diff --git "a/036.jsonl" "b/036.jsonl"
new file mode 100644--- /dev/null
+++ "b/036.jsonl"
@@ -0,0 +1,680 @@
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_656","text":"#!\/usr\/bin\/env python\n\n##########################################################################################################\n# Modulo Bioestadistica - 2015 de la Universidad del Comahue. Centro Regional Bariloche\n#http:\/\/crubweb.uncoma.edu.ar\/\n# Dr. <NAME>\n# email: <EMAIL>\n# licence: MIT. http:\/\/opensource.org\/licenses\/MIT \n\n#Ejemplo del libro Sokal, Introduccion a la bioestadistica, Reverte, 2002. version en ingles  p.79\n#Distribucion normal o gaussiana\n#Ejecutar:\n#python 09_introNormal.py\n##########################################################################################################\n\n\n# Importo librerias\nimport numpy as np\nimport pylab as P\nimport matplotlib.pyplot as plt\nimport matplotlib.mlab as mlab\nimport math\nimport scipy.stats as stats\n\n#Generador de coef binomial\ndef normpdf(x, mean, sd):\n    var = float(sd)**2\n    pi = 3.1415926\n    denom = (2*pi*var)**.5\n    num = math.exp(-(float(x)-float(mean))**2\/(2*var))\n    return num\/denom\n\n\n#Generador de coef binomial\ndef binCoefGen(k):\n    f = math.factorial\n    coef = []\n    print k\n    for i in range(k+1):\n        #print i\n        a = f(k)\/f(i)\/f(k-i)\n        print a\n        coef.append(a)\n    return coef\n    \n#Defino el k    \nprint \"Efecto del k -> inf. Probar k = 5, 10, 50, 150. criterio pqk > 3\"\nk = 150\n\n#calculo los bin\nbins = np.array([x for x in range(0, k+1)])\n\n#Defino la probabilidad de ocurrencia    \np = 0.5\n\n\ncolumna2p = np.array([p**(k-x) for x in range(0, k+1)])\nprint columna2p\n\n#calculo la probabilidad de no ocurrencia\nq = 1-p\ncolumna3q = np.array([q**x for x in range(0, k+1)])\nprint columna3q\nprint \"approx: \", p*q*k\nbincoef = np.array(binCoefGen(k))\n\ncolumna4relfrec = np.array([columna2p[x]*columna3q[x]*bincoef[x] for x in range(0, k+1)])\nprint columna4relfrec\n\ntotalMuestras = 1\nfrecAbsTeor = np.array([columna4relfrec[x]*totalMuestras for x in range(0, k+1)])\nprint frecAbsTeor\nmean= k*p\nsigma = math.sqrt(k)*p*q\nprint \"mean teorico:\", mean\nprint \"sigma teorico:\", sigma\n#Defino titulos\nplt.ylabel(\"Funcion densidad de probabilidad Normal\")\nplt.xlabel(\"Y\")\nplt.title(\"Distribuciones normales\")\n\n#Defino ancho de barra\nwidth = 1.0\n\n\n#Defino 2 graficas de barras\nnormalWLib1stats = stats.norm.pdf(bins,mean,2*sigma) \nnormalWLib2mlab = mlab.normpdf(bins,mean,2*sigma)\n\n#Check with other library\n\nmeans = [4,8,8]\nstds = [2,2,1]\n\nnormVals = []\nnormVals.append([])\nnormVals.append([])\nnormVals.append([])\n\nfor k in range(len(means)):\n\tfor i in range(len(bins)):\n\t\tnormVals[k].append(normpdf(bins[i],means[k],stds[k]))\n\ncolors = [\"red\",\"blue\",\"green\"]\nlabels = [\"Propongan 1\",\"Propongan 2\",\"Propongan 3\"]\n\n#labels = [\"Norm mu=%d sigma=%d\"%(means[0],stds[0]),\"Norm mu=%d sigma=%d\"%(means[1],stds[1]),\"Norm mu=%d sigma=%d\"%(means[2],stds[2])]\n\nfor k in range(len(means)):\n\tplt.plot(bins,normVals[k],lw = 2, color = colors[k], label=labels[k])\t\nplt.xlim(0,15)\n\n#Ubico leyenda\nplt.legend( loc='upper left', numpoints = 1 )\n\n#Dibujo\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_657","text":"import unittest\nfrom unittest import TestCase\n\nfrom escnn.group import CyclicGroup\nfrom escnn.group import DihedralGroup\n\nimport numpy as np\nimport scipy.sparse as sparse\n\n\nclass TestComputeRegularRepresentations(TestCase):\n    \n    def test_dihedral_rr_odd(self):\n        dg = DihedralGroup(9)\n        self.dihedral_rr_eval(dg, dg.representations['regular'])\n    \n    def test_dihedral_rr_even(self):\n        dg = DihedralGroup(10)\n        self.dihedral_rr_eval(dg, dg.representations['regular'])\n    \n    def test_dihedral_rr_large(self):\n        dg = DihedralGroup(16)\n        self.dihedral_rr_eval(dg, dg.representations['regular'])\n\n    def test_dihedral_rr_small(self):\n        dg = DihedralGroup(2)\n        self.dihedral_rr_eval(dg, dg.representations['regular'])\n\n    def test_cyclic_rr_odd(self):\n        cg = CyclicGroup(11)\n        self.cyclic_rr_eval(cg, cg.representations['regular'])\n\n    def test_cyclic_rr_even(self):\n        cg = CyclicGroup(10)\n        self.cyclic_rr_eval(cg, cg.representations['regular'])\n\n    def test_cyclic_rr_large(self):\n        cg = CyclicGroup(20)\n        self.cyclic_rr_eval(cg, cg.representations['regular'])\n\n    def test_cyclic_rr_small(self):\n        cg = CyclicGroup(2)\n        self.cyclic_rr_eval(cg, cg.representations['regular'])\n\n    def cyclic_rr_eval(self, cg, rr):\n        # rr = cg.representations['regular']\n\n        # np.set_printoptions(precision=4, suppress=True)\n        # print('Change of Basis')\n        # print(rr.change_of_basis)\n        # print('Change of Basis Inv')\n        # print(rr.change_of_basis_inv)\n        # print('RR')\n        # n = cg.order\n        # for i in range(n):\n        #     print(rr(i * 2 * np.pi \/ n))\n        \n        D = rr.change_of_basis\n        D_inv = rr.change_of_basis_inv\n        for i, element in enumerate(cg.elements):\n        \n            rho_i = np.zeros([cg.order(), cg.order()])\n        \n            for k in range(cg.order()):\n                rho_i[(i + k) % cg.order(), k] = 1.0\n        \n            # Build the direct sum of the irreps for this element\n            blocks = []\n            for irrep in rr.irreps:\n                repr = cg.irrep(*irrep)(element)\n                blocks.append(repr)\n        \n            P = sparse.block_diag(blocks, format='csc')\n            R = D @ P @ D_inv\n            self.assertTrue(np.allclose(R, rho_i), f\"{element}:\\n{R}\\n!=\\n{rho_i}\\n\")\n            self.assertTrue(np.allclose(rr(element), rho_i), f\"{element}:\\n{rr(element)}\\n!=\\n{rho_i}\\n\")\n\n    def dihedral_rr_eval(self, dg, rr):\n    \n        # rr = dg.representations['regular']\n    \n        # np.set_printoptions(precision=2, suppress=True)\n        # print('Change of Basis')\n        # print(rr.change_of_basis)\n        # print('Change of Basis Inv')\n        # print(rr.change_of_basis_inv)\n        # print('RR')\n        # n = dg.rotation_order\n        # for i in range(n):\n        #     print(rr((0, i * 2 * np.pi \/ n)))\n        # for i in range(n):\n        #     print(rr((1, i * 2 * np.pi \/ n)))\n    \n        D = rr.change_of_basis\n        D_inv = rr.change_of_basis_inv\n\n        # np.set_printoptions(precision=3, threshold=10*rr.size**2, suppress=True, linewidth=25*rr.size + 5)\n        \n        for i, element in enumerate(dg.elements):\n        \n            rho_i = np.zeros([dg.order(), dg.order()])\n        \n            f = -1 if element.to('int')[0] else 1\n            # r = int(np.round(element[1] * dg.rotation_order \/ (2 * np.pi)))\n            r = element.to('int')[1]\n        \n            for k in range(dg.rotation_order):\n                rho_i[dg.rotation_order * element.to('int')[0] + ((r + k * f) % dg.rotation_order), k] = 1.0\n            for k in range(dg.rotation_order):\n                rho_i[dg.rotation_order * (1 - element.to('int')[0]) + ((r + k * f) % dg.rotation_order), dg.rotation_order + k] = 1.0\n        \n            # Build the direct sum of the irreps for this element\n            blocks = []\n            for irrep in rr.irreps:\n                repr = dg.irrep(*irrep)(element)\n                blocks.append(repr)\n        \n            P = sparse.block_diag(blocks, format='csc')\n            R = D @ P @ D_inv\n            self.assertTrue(np.allclose(R, rho_i), f\"{element}:\\n{R}\\n!=\\n{rho_i}\\n\")\n            self.assertTrue(np.allclose(rr(element), rho_i), f\"{element}:\\n{rr(element)}\\n!=\\n{rho_i}\\n\")\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_658","text":"###__________________________ SymPy - Mechanics ____________________________###\n\n##_________ Reference System _________##\n# El objeto primordial que vamos a manejar van a ser los sistemas de referencia. \n# Podremos definir relaciones geométricas entre ellos y de esta forma las transformaciones \n# de vectores entre un sistema y otro serán triviales.\n\n# La manera usual de empezar a trabajar con SymPy es importar la función init_session:\nfrom sympy import init_session, Symbol, symbols, pi, I, E, cos, sin, exp, tan, simplify, expand, factor, collect, apart, cancel, expand_trig, diff, Derivative, Function, integrate, limit, series, Eq, solve, dsolve, Matrix, N\n# from sympy import init_session\ninit_session(use_latex=True)\n\n# Todo lo que necesitamos está en sympy.physics.mechanics, incluyendo la clase ReferenceFrame. \n# Nada más crear un sistema de referencia podemos acceder a sus versores unitarios: x, y y z.\n\nfrom sympy.physics.mechanics import ReferenceFrame \n\n# A = ReferenceFrame(\"A\")\n# print(A.x)\n\n# Y para definir vectores solo tenemos que multiplicar cada componente por su versor:\n# print(2 * A.x - 1 * A.y)\n\n# De ahora en adelante, para trabajar como si nos enfrentáramos a un problema de \n# la escuela, vamos a hacer dos cosas:\n    # [-] Definir un sistema inercial 1 del que partir, para así poder referir todos \n    # los demás sistemas a él.\n    # [-] Que los versores de ese sistema sean 𝑖,𝑗,𝑘\n    \n# A = ReferenceFrame(\"1\", latexs=['\\mathbf{i}', '\\mathbf{j}', '\\mathbf{k}'])\n# print(A.x + A.y + A.z)\n\n# Y para no tener que hacerlo siempre, un pequeño truco de magia:\n# Definimos nuestra propia clase para que los versores sean IJK\n#------------------------------------------------------------------------------\nclass IJKReferenceFrame(ReferenceFrame):\n    def __init__(self, name):\n        super().__init__(name, latexs=['\\mathbf{%s}_{%s}' % (idx, name) for idx in (\"i\", \"j\", \"k\")])\n        self.i = self.x\n        self.j = self.y\n        self.k = self.z\n#------------------------------------------------------------------------------\nA = IJKReferenceFrame(\"1\")\nprint(A.x + A.y + A.z)\n\n##_________ Vectorial Algebra _________##\n# Nuestros vectores funcionan también con símbolos, y podemos realizar las operaciones \n# de producto escalar y producto vectorial con ellos.\nR, V = symbols('R, V', positive=True)\nr1 = R * (A.x + A.y + A.z)\nv1 = V * (A.x - 2 * A.z)\n\nfrom sympy.physics.mechanics import dot, cross\n\nprint(r1.dot(v1))\nprint(dot(r1, v1))\nprint(r1 & v1)\n\nprint(r1.cross(v1))\nprint(cross(r1, v1))\nprint(r1 ^ v1)\n\n# Podemos hallar también la norma de los vectores con su método magnitude e incluso \n# normalizarlos con normalize:\nprint((r1 ^ v1).magnitude())\nprint((r1 ^ v1).normalize())\n\n##_________ Exercise _________##\n# Usando directamente la fórmula para la derivada en ejes móviles:\n    # $$\\left(\\frac{\\operatorname{d}\\!\\mathbf{a}}{\\operatorname{d}\\!t}\\right)_1 \n    # = \\left(\\frac{\\operatorname{d}\\!\\mathbf{a}}{\\operatorname{d}\\!t}\\right)_0 \n    # + \\mathbf{\\omega}_{01}\\! \\times \\mathbf{a}$$\n# Calcula la derivada del vector de posición $R \\mathbf{i}_0$, siendo $A_0$ un \n# sistema de referencia que gira respecto al inercial con velocidad angular \n# $\\mathbf{\\omega}_{01}=\\Omega \\mathbf{k}_0$. **¿Cuál es el módulo de la derivada?**\nR, Omega = symbols('R, Omega', positive=True)\nA0 = IJKReferenceFrame('0')\na = R * A0.i\nomega01 = Omega * A0.k\nda = omega01 ^ a # cross producut\nprint(da.magnitude())\n# Si no especificaste `positive=True` vas a ver algo como sqrt(omega^2*R^2). \n# Debería haber una forma de simplificar esta expresión _a posteriori_, pero de\n# momento no funciona del todo bien. \n\n##_________ Relative Movement _________##\n# ¿A quién no le gusta multiplicar matrices de rotación? Para esa minoría que lo \n# detesta, existe SymPy. Para ello debemos especificar la orientación de nuestros \n# sistemas de referencia usando el *método orient*, y recuperaremos la matriz de \n# cosenos directores usando el *método dcm*.\nA1 = IJKReferenceFrame(\"1\")\nA0 = IJKReferenceFrame(\"0\")\nphi = symbols('phi')\nA0.orient(A1, 'Axis', [phi, A1.z])  # Rotación phi alrededor del eje A1.z\nprint(A0.dcm(A1))                          # \"Direct Cosine Matrix\"\n# Usando el argumento `Axis` hemos especificado que rotamos el sistema un ángulo \n# especificado alrededor de un eje. Otros métodos son:\n    # * `Body`: se especifican los tres ángulos de Euler.\n    # * `Space`: igual que `Body`, pero las rotaciones se aplican en orden inverso.\n    # * `Quaternion`: utilizando cuaternios, rotación alrededor de un vector unitario\n    # $\\lambda$ una cantidad $\\theta$.\n\n##_________ Different Reference System _________##\n# Para expresar un vector en otro sistema de referencia, no hay más que usar los \n# métodos express o to_matrix:\nprint(A0.x.express(A1))\nprint(A0.x.to_matrix(A1))\n\n##_________ Dynamic Symbols (time dependent) _________##\n# Si queremos especificar que un símbolo puede variar con el tiempo, hay que usar \n# la función dynamicsymbols:\nfrom sympy.physics.mechanics import dynamicsymbols\n\nalpha = dynamicsymbols('alpha')\n# Y pedir su derivada con el método diff:\nprint(alpha.diff())\n\n##_________ Exercise1 _________##\nprint('_______________Exercise1___________________')\n# from notebook completos\/041-SymPy\n## Obtener la matriz de rotación de la pala B respecto a los ejes A1. ##\nprint('______Rot Matrix_________')\nA = IJKReferenceFrame(\"A\")\nA1 = IJKReferenceFrame(\"A1\")\npsi = dynamicsymbols('psi')\nA1.orient(A, 'Axis', [psi, A.z])\nprint('A1 DCM A --> =', A1.dcm(A))  # T_{A1A}\n\nA2 = IJKReferenceFrame(\"A2\")\nbeta = dynamicsymbols('beta')\nA2.orient(A1, 'Axis', [beta, -A1.y])\nprint('A2 DCM A1 --> =', A2.dcm(A1))  # T_{A2A1}\n\nA3 = IJKReferenceFrame(\"A3\")\nzeta = dynamicsymbols('zeta')\nA3.orient(A2, 'Axis', [zeta, A2.z])\nprint('A3 DCM A1 --> =',A3.dcm(A1))  # T_{A3A1}\n\nB = IJKReferenceFrame(\"B\")\ntheta = dynamicsymbols('theta')\nB.orient(A3, 'Axis', [theta, A3.x])\nprint('B DCM A3 --> =', B.dcm(A3))  # T_{BA3}\n\nprint('B DCM A2 --> =',B.dcm(A2))\n\nprint('B DCM A1 --> =',B.dcm(A1))\n\n## Angular Velocity ##\nprint('______Ang Vel______')\n# También podemos hallar la velocidad angular de un sistema respecto a otro \n# usando el método ang_vel_in:\nprint(B.ang_vel_in(A2))\nprint(B.ang_vel_in(A))\nprint(B.ang_vel_in(A).express(A))\n\n## Derivative in moving axis ##\nprint('______Derivative in moving axis______')\n# Hacer una derivada con la fórmula lo hace cualquiera, pero SymPy puede \n# encargarse automáticamente.\nv1 = A1.x\ndv1 = v1.diff(symbols('t'), A)\nprint(dv1.to_matrix(A1))\nprint((dv1 & A1.j).simplify())\nprint('_______________End Exercise1___________________')\n\n##_________ Puntos, velocidades y la rueda que no desliza _________##\n# El último paso que nos queda para completar la cinemática es la posibilidad de \n# definir puntos en sólidos y aplicar su campo de velocidades. SymPy también \n# permite esto, y para ello no tenemos más que importar la clase Point.\nfrom sympy.physics.mechanics import Point\nO = Point(\"O\")\n# Para trabajar como lo haríamos en la escuela, vamos a especificar que O es el\n# origen de A, y para eso vamos a imponer que su velocidad es cero con el método set_vel:\nO.set_vel(A, 0)\n# Para definir nuevos puntos, podemos utilizar el método locate_new:\ne_b = symbols('e_b')\nE_b = O.locatenew('E_b', e_b * A1.x)\n# Y para obtener vectores de un punto a otro, el método pos_from:\nprint(E_b.pos_from(O))\n# La notación de este paquete está influenciada por el libro\n#  <NAME>. & <NAME>. \"Dynamics, Theory and Applications\"\n\n# Por último, el **campo de velocidades de un sólido rígido** se formula usando \n# el método `v2pt_theory`.\n    # $$v^P_A = v^O_A + \\omega_{A_1 A} \\times \\mathbf{OP}$$\n# Este método pertenece *al punto del cual queremos conocer la velocidad* y \n# recibe tres parámetros:\n    # * `O`, punto de velocidad conocida respecto a A\n    # * `A`, sistema de referencia donde queremos calcular la velocidad\n    # * `A1`, sistema de referencia donde están fijos ambos puntos (_sistema de arrastre_)\nprint(E_b.v2pt_theory(O, A, A1))\n\n##_________ Exercise2 _________##\nprint('_______________Exercise2___________________')\n# from notebook completos\/041-SymPy\n# ¡Halla la velocidad y la aceleración de P!\n\n# Creamos nuestros sistemas de referencia\nA1 = IJKReferenceFrame('1')\nA0 = IJKReferenceFrame('0')\nA2 = IJKReferenceFrame('2')\n\n# Creamos los símbolos dinámicos necesarios\nxi, theta = dynamicsymbols('xi, theta')\n\n# Orientamos los sistemas de referencia\nA0.orient(A1, 'Axis', [0, A1.k])  # A0 no gira respecto a A1\nA2.orient(A0, 'Axis', [theta, A0.k])\nprint('A2 DCM A1 --> =', A2.dcm(A1))\n\n# Creamos el punto C, centro del disco, y especificamos su velocidad\n# respecto a A1\nC = Point('C')\nC.set_vel(A1, xi.diff() * A1.x)\n\n# Localizamos el punto P, punto fijo del disco, respecto a C, en\n# el sistema A2 (que gira solidariamente con el disco)\nR = symbols('R')\nP = C.locatenew('P', -R * A2.j)\nprint(P.pos_from(C))\n\n# Hallamos la velocidad de P en A1, expresada en A0\n# ¡Con esta llamada ya estamos diciendo que C y P son fijos en A2!\nprint(P.v2pt_theory(C, A1, A2).express(A0))\n\n#______________________________________________________________________________\n#______________________________________________________________________________\n# \n# Estabilidad y control dinámicos longitudinales en cadena abierta\n# Análisis de la estabilidad longitudinal de un B747-100\n# https:\/\/nbviewer.jupyter.org\/github\/AlexS12\/Mecanica_Vuelo\/blob\/master\/MVII_MatrizSistema.ipynb"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_659","text":"'''\nCreated on Jun 7, 2012\n\n@author: vinnie\n'''\n\nimport os\nimport sys\nimport cv2 as cv\nfrom scipy.ndimage import filters\n#import scipy.signal as signal\nimport numpy as np\nimport pylab as plb\nimport matplotlib.cm as cm\nfrom itertools import product\n\n_ALPHA = 100\n_BETA = 200\n_W_LINE = 250\n_W_EDGE = 30\n_MIN_DISTANCE = 10\n_INITIAL_SMOOTH = 15\n_INITIAL_ITERATIONS = 30\n_ITERATIONS_DELTA = 5 \n_SMOOTH_FACTOR_DELTA = 4\n\n_NUM_NEIGHBORS = 9\n_MAX_SNAXELS = 10000\n_INITIAL_DISTANCE_BETWEEN_SNAXELS = 50\n\ndef _display(image, snaxels=None):\n    \"\"\"\n    Display a grayscale image with pylab, and draw the contour if there is any.\n    \"\"\"\n    plb.clf()\n    if snaxels is not None:\n        for s in snaxels:\n            plb.plot(s[0],s[1],'g.',markersize=10.0)\n    \n    plb.imshow(image, cmap=cm.Greys_r)\n    plb.draw()\n    \n    return\n\ndef _gradientImage(image):\n    \"\"\"\n    Obtain a gradient image (in both x and y directions)\n    \"\"\"\n    gradient = np.sqrt(filters.sobel(image, 0)**2 + filters.sobel(image, 1)**2)\n    gradient -= gradient.min()\n\n    return gradient \n  \ndef _inBounds(image, point):\n    \"\"\"\n    Is the point within the bounds of the image?\n    \"\"\"\n    return np.all(point < np.shape(image)) and np.all(point > 0)\n\ndef _externalEnergy(image, smooth_image, point):\n    \"\"\"\n    The external energy of the point, a combination of line and edge \n    \"\"\"\n    pixel = 255 * image[point[1]][point[0]]\n    smooth_pixel = 255 * smooth_image[point[1]][point[0]]\n    external_energy = (_W_LINE * pixel) - (_W_EDGE * (smooth_pixel**2))\n    return external_energy\n\ndef _energy(image, smooth_image, current_point, next_point, previous_point=None):\n    \"\"\"\n    Total energy (internal and external).\n    Internal energy measures the shape of the contour\n    \"\"\"\n    d_squared = np.linalg.norm(next_point -current_point)**2\n    \n    if previous_point is None:\n        e =  _ALPHA * d_squared + _externalEnergy(image, smooth_image, current_point)\n        return e \n    else:\n        deriv = np.sum((next_point - 2 * current_point + previous_point)**2)\n        e = 0.5 * (_ALPHA * d_squared + _BETA * deriv + _externalEnergy(image, smooth_image, current_point))\n        return e\n\ndef _iterateContour(image, smooth_image, snaxels, energy_matrix, position_matrix, neighbors):\n    \"\"\"\n    Compute the minimum energy locations for all the snaxels in the contour\n    \"\"\"\n    snaxels_added = len(snaxels)\n    for curr_idx in range(snaxels_added - 1, 0, -1):\n        energy_matrix[curr_idx][:][:] = float(\"inf\")\n        prev_idx = (curr_idx - 1) % snaxels_added\n        next_idx = (curr_idx + 1) % snaxels_added\n        \n        for j, next_neighbor in enumerate(neighbors):\n            next_node = snaxels[next_idx] + next_neighbor\n            \n            if not _inBounds(image, next_node):\n                continue\n            \n            min_energy = float(\"inf\")\n            for k, curr_neighbor in enumerate(neighbors):\n                curr_node = snaxels[curr_idx] + curr_neighbor\n                distance = np.linalg.norm(next_node - curr_node)\n                \n                if not _inBounds(image, curr_node) or (distance < _MIN_DISTANCE):\n                    continue\n                \n                min_energy = float(\"inf\")\n                for l, prev_neighbor in enumerate(neighbors):\n                    prev_node = snaxels[prev_idx] + prev_neighbor\n                        \n                    if not _inBounds(image, prev_node):\n                        continue\n                        \n                    energy = energy_matrix[prev_idx][k][l] + _energy(image, smooth_image, curr_node, next_node, prev_node)\n                    \n                    if energy < min_energy:\n                        min_energy = energy\n                        min_position_k = k\n                        min_position_l = l\n                \n                energy_matrix[curr_idx][j][k] = min_energy\n                position_matrix[curr_idx][j][k][0] = min_position_k\n                position_matrix[curr_idx][j][k][1] = min_position_l\n    \n    min_final_energy = float(\"inf\")\n    min_final_position_j = 0\n    min_final_position_k = 0\n\n    for j in range(_NUM_NEIGHBORS):\n        for k in range(_NUM_NEIGHBORS):\n            if energy_matrix[snaxels_added - 2][j][k] < min_final_energy:\n                min_final_energy = energy_matrix[snaxels_added - 2][j][k]\n                min_final_position_j = j\n                min_final_position_k = k\n\n    pos_j = min_final_position_j\n    pos_k = min_final_position_k\n    \n    for i in range(snaxels_added - 1, -1, -1):\n        snaxels[i] = snaxels[i] + neighbors[pos_j]\n        if i > 0:\n            pos_j = position_matrix[i - 1][pos_j][pos_k][0]\n            pos_k = position_matrix[i - 1][pos_j][pos_k][1]\n            \n    return min_final_energy\n\ndef activeContour(image, snaxels):\n    \"\"\"\n    Iterate the contour until the energy reaches an equilibrium\n    \"\"\"\n    energy_matrix = np.zeros( (_MAX_SNAXELS - 1, _NUM_NEIGHBORS, _NUM_NEIGHBORS), dtype=np.float32)\n    position_matrix = np.zeros( (_MAX_SNAXELS - 1, _NUM_NEIGHBORS, _NUM_NEIGHBORS, 2), dtype=np.int32 )\n    neighbors = np.array([[i, j] for i in range(-1, 2) for j in range(-1, 2)])\n    min_final_energy_prev = float(\"inf\")\n    \n    counter = 0\n    smooth_factor = _INITIAL_SMOOTH \n    iterations = _INITIAL_ITERATIONS\n    gradient_image = _gradientImage(image)\n    smooth_image = cv.blur(gradient_image, (smooth_factor, smooth_factor))\n        \n    while True:\n        counter += 1\n        if not (counter % iterations):\n            iterations += _ITERATIONS_DELTA\n            if smooth_factor > _SMOOTH_FACTOR_DELTA:\n                smooth_factor -= _SMOOTH_FACTOR_DELTA            \n            smooth_image = cv.blur(gradient_image, (smooth_factor, smooth_factor))\n            print \"Deblur step, smooth factor now: \", smooth_factor\n        \n        _display(smooth_image, snaxels)\n        min_final_energy = _iterateContour(image, smooth_image, snaxels, energy_matrix, position_matrix, neighbors)\n        \n        if (min_final_energy == min_final_energy_prev) or smooth_factor < _SMOOTH_FACTOR_DELTA:\n            print \"Min energy reached at \", min_final_energy\n            print \"Final smooth factor \", smooth_factor\n            break\n        else:\n            min_final_energy_prev = min_final_energy\n        \n\ndef _pointsOnCircle(center, radius, num_points=12):\n    points = np.zeros((num_points, 2), dtype=np.int32)\n    for i in range(num_points):\n        theta = float(i)\/num_points * (2 * np.pi)\n        x = center[0] + radius * np.cos(theta)\n        y = center[1] + radius * np.sin(theta)\n        p = [x, y]\n        points[i] = p\n        \n    return points\n\ndef activeContourFromCircle(image_file, center, radius):\n    image = plb.imread(image_file)\n    if image.ndim > 2:\n        image = np.mean(image, axis=2)\n    print \"Image size: \", image.shape\n    \n    plb.ion()\n    plb.figure(figsize=np.array(np.shape(image))\/50.)\n    \n    _display(image)\n#    num_points = int((2 * np.pi * radius)\/_INITIAL_DISTANCE_BETWEEN_SNAXELS)\n    snaxels = _pointsOnCircle(center, radius, 30)\n    _display(image, snaxels)\n    activeContour(image, snaxels)\n    \n    # show and save the result\n    plb.ioff()\n    _display(image, snaxels)\n    plb.savefig(os.path.splitext(image_file)[0] + \"-contour-result.png\")\n    plb.show()\n    return\n\ndef _test():\n    \"\"\"\n    Run the active contour on an image file\n    \"\"\"\n    activeContourFromCircle(\"mri.png\", (290, 440), 125)\n    \n    return\n\nif __name__ == '__main__':\n    _test()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_660","text":"from __future__ import print_function\nimport cv2\nimport PIL.Image\nimport numpy as np\nimport scipy.stats\nimport sys\nimport itertools\nfrom line_intersection import *\nnp.set_printoptions(suppress=True, precision=2)\n\ndef scaleImageIfNeeded(img, max_width=1024, max_height=1024):\n  \"\"\"Scale image down to max_width \/ max_height keeping aspect ratio if needed. Do nothing otherwise.\"\"\"\n  # Input and Output is a numpy array\n  img = PIL.Image.fromarray(img)\n  img_width, img_height = img.size\n  # print(\"Image size %dx%d\" % (img_width, img_height))\n  aspect_ratio = min(float(max_width)\/img_width, float(max_height)\/img_height)\n  if aspect_ratio < 1.0:\n    new_width, new_height = ((np.array(img.size) * aspect_ratio)).astype(int)\n    # print(\" Resizing to %dx%d\" % (new_width, new_height))\n    return np.array(img.resize((new_width,new_height)))\n  return np.array(img)\n\ndef getAngle(a,b,c):\n  # Get angle given 3 side lengths, in degrees\n  k = (a*a+b*b-c*c) \/ (2*a*b)\n  # Handle floating point errors\n  if (k < -1):\n    k=-1\n  elif k > 1:\n    k=1\n  return np.arccos(k) * 180.0 \/ np.pi\n\ndef angleCloseDeg(a, b, angle_threshold=10):\n  d = np.abs(a - b)\n  # Handle angles that are ~180 degrees apart\n  return d <= angle_threshold or np.abs(d-180) <= angle_threshold\n\ndef getSegmentThetaRho(line):\n  x1,y1,x2,y2 = line\n  theta = np.math.atan2(y2-y1, x2-x1)\n  m = np.tan(theta)\n  # rho = np.abs(y1 + m*x1) \/ np.sqrt(m*m+1)\n  rho = x1*np.cos(theta) + y1*np.sin(theta)\n  return theta, rho\n\ndef getTwoLineSegmentIntersection(p,pr,q,qs):\n  # Uses http:\/\/stackoverflow.com\/a\/565282\/2574639\n  # Given two line segments defined by sets of points\n  # (p -> pr) and (q -> qs).\n  # Return the intersection point between them\n  # *assumes it always exists for our particular use-case*\n  \n  # Convert to floats\n  p = p.astype(np.float32)\n  pr = pr.astype(np.float32)\n  q = q.astype(np.float32)\n  qs = qs.astype(np.float32)\n  r = pr-p\n  s = qs-q\n  # print(p, pr, r)\n  # print(q, qs, s)\n  rxs = np.cross(r, s)\n  if rxs == 0:\n    return [] # parallel\n  t = np.cross((q - p), s) \/ rxs\n  return p + t*r # intersect\n\ndef chooseRandomGoodQuad(lines_a, lines_b, median_contour):\n  # Get random set of points\n  # Redo until min side distance of random corners greater than a multiple \n  # of the median tile found from initial estimator.\n  sides_tile = getSquareSides(median_contour)\n  for i in range(50):\n    corners = chooseRandomQuad(lines_a, lines_b)\n    sides_quad = getSquareSides(corners)\n    if (i < 5):\n      tile_size_mult = 5\n    elif (i < 10):\n      tile_size_mult = 4\n    elif (i < 20):\n      tile_size_mult = 3\n    elif (i < 30):\n      tile_size_mult = 2\n    else:\n      tile_size_mult = 1\n    \n    if min(sides_quad) > min(sides_tile*tile_size_mult):\n      return corners\n  \n  print('chooseRandomGoodQuad hit max iter: %d' % i)\n  return corners\n\ndef chooseRandomQuad(lines_a, lines_b):\n  # Return 1 random quad (4 points) by choosing\n  # 2 lines from lines_a and 2 lines from lines_b \n  # and returning their intersections\n  a = np.random.choice(range(len(lines_a)),2, replace=False)\n  b = np.random.choice(range(len(lines_b)),2, replace=False)\n\n  pairs = np.array([\n    [a[0], b[0]],\n    [a[0], b[1]],\n    [a[1], b[1]],\n    [a[1], b[0]],\n    ])\n\n  corners = np.zeros([4,2])\n  for i in range(4):\n    k1 = lines_a[pairs[i,0]]\n    k2 = lines_b[pairs[i,1]]\n    corners[i,:] = getTwoLineSegmentIntersection(k1[:2], k1[2:], k2[:2], k2[2:])\n  return corners\n\n\ndef getSegmentTheta(line):\n  x1,y1,x2,y2 = line\n  theta = np.math.atan2(y2-y1, x2-x1)\n  return theta\n\ndef is_square(cnt, eps=3.0, xratio_thresh = 0.5):\n  # 4x2 array, rows are each point, columns are x and y\n  center = cnt.sum(axis=0)\/4\n\n  # Side lengths of rectangular contour\n  dd0 = np.sqrt(((cnt[0,:] - cnt[1,:])**2).sum())\n  dd1 = np.sqrt(((cnt[1,:] - cnt[2,:])**2).sum())\n  dd2 = np.sqrt(((cnt[2,:] - cnt[3,:])**2).sum())\n  dd3 = np.sqrt(((cnt[3,:] - cnt[0,:])**2).sum())\n\n  # diagonal ratio\n  xa = np.sqrt(((cnt[0,:] - cnt[2,:])**2).sum())\n  xb = np.sqrt(((cnt[1,:] - cnt[3,:])**2).sum())\n  xratio = xa\/xb if xa < xb else xb\/xa\n\n  # Check whether all points part of convex hull\n  # ie. not this http:\/\/i.stack.imgur.com\/I6yJY.png\n  # all corner angles, angles are less than 180 deg, so not necessarily internal angles\n  ta = getAngle(dd3, dd0, xb) \n  tb = getAngle(dd0, dd1, xa)\n  tc = getAngle(dd1, dd2, xb)\n  td = getAngle(dd2, dd3, xa)\n  angle_sum = np.round(ta+tb+tc+td)\n\n  is_convex = angle_sum == 360\n\n  angles = np.array([ta,tb,tc,td])\n  good_angles = np.all((angles > 40) & (angles < 140))\n\n\n  # side ratios\n  dda = dd0 \/ dd1\n  if dda < 1:\n    dda = 1. \/ dda\n  ddb = dd1 \/ dd2\n  if ddb < 1:\n    ddb = 1. \/ ddb\n  ddc = dd2 \/ dd3\n  if ddc < 1:\n    ddc = 1. \/ ddc\n  ddd = dd3 \/ dd0\n  if ddd < 1:\n    ddd = 1. \/ ddd\n  side_ratios = np.array([dda,ddb,ddc,ddd])\n  good_side_ratios = np.all(side_ratios < eps)\n\n  # Return whether side ratios within certain ratio < epsilon\n  return (\n    # abs(1.0 - dda) < eps and \n    # abs(1.0 - ddb) < eps and\n    # xratio > xratio_thresh and \n    # good_side_ratios and\n    # is_convex and\n    good_angles)\n\ndef minimum_distance2(v, w, p):\n  # Return squared min distance between point p and line segment vw\n  # Via http:\/\/stackoverflow.com\/a\/1501725\n  # Return minimum distance between line segment vw and point p\n  l2 = np.sum((v - w)**2)  # i.e. |w-v|^2 -  avoid a sqrt\n  if (l2 == 0.0):\n    return np.sum((p - v)**2)   # v == w case\n  # Consider the line extending the segment, parameterized as v + t (w - v).\n  # We find projection of point p onto the line. \n  # It falls where t = [(p-v) . (w-v)] \/ |w-v|^2\n  # We clamp t from [0,1] to handle points outside the segment vw.\n  t = max(0, min(1, np.dot(p - v, w - v) \/ l2))\n  projection = v + t * (w - v)  # Projection falls on the segment\n  return np.sum((p - projection)**2)\n\ndef getMinLineAngleDistance(a0, a1):\n  # Compare line angles (which can be 180 off from one another, or +- 180)\n  v0 = abs(a1-a0)\n  v1 = abs((a1+np.pi) - a0)\n  v2 = abs(a1 - (a0+np.pi))\n  return min([v0,v1,v2])\n\ndef getBestCorners(tile_corners, hough_lines, angle_threshold = 10*np.pi\/180):\n  # Given 4x2 imperfect tile corners and Nx4 line segments\n  # Expects line segments and corner points to be in same cartesian space\n  #\n  # Find 4 best line segments that are best match to the tile corners\n  # and return the corners based off of those line segments, and those line segments\n  best_lines = np.zeros([4,4])\n  for i in range(4):\n    corner_theta = getSegmentTheta(tile_corners[[i,i,((i+1)%4),((i+1)%4)], [0,1,0,1]])\n    corner_ctr_pt = (tile_corners[i,:] + tile_corners[((i+1)%4),:]) \/ 2\n\n    best_d = 1e6\n    for line in hough_lines:\n      theta = getSegmentTheta(line)\n      # If angle within 10 degrees\n      # if abs(corner_theta - theta) < angle_threshold:\n      if getMinLineAngleDistance(corner_theta, theta) < angle_threshold:\n        d = minimum_distance2(line[:2], line[2:], corner_ctr_pt)\n        if d < best_d:\n          best_d = d\n          best_lines[i,:] = line\n  \n  new_corners = np.zeros([4,2], dtype=np.float32)\n  for i in range(4):\n    x = getTwoLineSegmentIntersection(\n      best_lines[i,:2], best_lines[i,2:],\n      best_lines[(i+1)%4,:2], best_lines[(i+1)%4,2:])\n    # print(best_lines, x)\n    # print(best_lines[i,:2], best_lines[i,2:], best_lines[(i+1)%4,:2], best_lines[(i+1)%4,2:])\n    new_corners[i,:] = x\n\n  return new_corners, best_lines\n\ndef simplifyContours(contours):\n  for i in range(len(contours)):\n    # Approximate contour and update in place\n    contours[i] = cv2.approxPolyDP(contours[i],0.04*cv2.arcLength(contours[i],True),True)\n\ndef pruneContours(contours):\n  new_contours = []\n  for i in range(len(contours)):\n    cnt = contours[i]    \n    # Only contours that fill an area of at least 8x8 pixels\n    if cv2.contourArea(cnt) < 8*8:\n      continue\n    # Only rectangular contours allowed\n    if len(cnt) != 4:\n      continue\n\n    if not is_square(cnt):\n      continue\n\n    new_contours.append(cnt)\n  new_contours = np.array(new_contours)\n  if len(new_contours) == 0:\n    return new_contours, None\n  \n  norm_contours = new_contours[:,:,0,:] - new_contours[:,[0],0,:]\n  median_contour = np.median(norm_contours, axis=0).astype(int)\n  diff = np.sqrt(np.sum((norm_contours - median_contour)**2,axis=2))\n\n  new_contours = new_contours[np.all(diff < 60, axis=1)]\n\n  return np.array(new_contours), median_contour\n\ndef getSquareSides(cnt):\n  # 4x2 array, rows are each point, columns are x and y\n  center = cnt.sum(axis=0)\/4\n\n  # Side lengths of rectangular contour\n  dd0 = np.sqrt(((cnt[0,:] - cnt[1,:])**2).sum())\n  dd1 = np.sqrt(((cnt[1,:] - cnt[2,:])**2).sum())\n  dd2 = np.sqrt(((cnt[2,:] - cnt[3,:])**2).sum())\n  dd3 = np.sqrt(((cnt[3,:] - cnt[0,:])**2).sum())\n  return np.array([dd0, dd1, dd2, dd3])\n\n\nfrom time import time\ndef calculateMask(mask_shape, contours, iters=10):\n  a = time()\n  sum_mask = np.zeros(mask_shape, dtype=int)\n  tmp_mask = np.zeros(mask_shape, dtype=int)\n  for i, cnt in enumerate(contours):\n    for i in np.linspace(5,23,iters):\n    # for i in [3,5,7,9,11,13,15]:\n      # Calculate oversized tile mask and add to sum\n      # big_cnt = (cnt.mean(axis=0) + (cnt-cnt.mean(axis=0))*i).astype(int)\n      cnt_center = cnt.mean(axis=0)\n      big_cnt = (cnt*i + cnt_center*(1-i)).astype(int)\n      tmp_mask[:] = 0 # Reset\n      cv2.drawContours(tmp_mask,[big_cnt],0,1,-1) # Fill mask with 1's inside contour\n      sum_mask += tmp_mask\n\n  # Normalize mask to 0-1 range\n  sum_mask = sum_mask.astype(float) \/ sum_mask.max()\n  # print(\"Mask calc took %.4f seconds.\" % (time() - a))\n  return sum_mask\n\ndef getContourThetas(contours):\n  thetas = []\n  for cnt in contours:\n    cnt = cnt[:,0,:]\n    if cnt[0,0] < cnt[1,0]:\n      side0 = np.hstack([cnt[1,:],cnt[0,:]])\n    else:\n      side0 = np.hstack([cnt[0,:],cnt[1,:]])\n    if cnt[1,0] < cnt[2,0]:\n      side1 = np.hstack([cnt[2,:],cnt[1,:]])\n    else:\n      side1 = np.hstack([cnt[1,:],cnt[2,:]])\n    if cnt[2,0] < cnt[3,0]:\n      side2 = np.hstack([cnt[3,:],cnt[2,:]])\n    else:\n      side2 = np.hstack([cnt[2,:],cnt[3,:]])\n    if cnt[3,0] < cnt[0,0]:\n      side3 = np.hstack([cnt[0,:],cnt[3,:]])\n    else:\n      side3 = np.hstack([cnt[3,:],cnt[0,:]])\n    theta0 = getSegmentTheta(side0)\n    theta1 = getSegmentTheta(side1)\n    theta2 = getSegmentTheta(side2)\n    theta3 = getSegmentTheta(side3)\n    thetas.extend([theta0,theta1,theta2,theta3])\n  return np.array(thetas)\n\ndef getEstimatedChessboardMask(img, edges, iters=10):\n  # Morphological Gradient to get internal squares of canny edges. \n  kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))\n  edges_gradient = cv2.morphologyEx(edges, cv2.MORPH_GRADIENT, kernel)\n\n  _, contours, hierarchy = cv2.findContours(edges_gradient, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)\n  # Approximate polygons of contours\n  simplifyContours(contours)\n\n  if len(contours) == 0:\n    return np.ones(img.shape[:2], dtype=float), None, None, None\n\n  # Prune contours to rectangular ones\n  contours, median_contour = pruneContours(contours)\n\n  if len(contours) == 0 or median_contour is None:\n    return np.ones(img.shape[:2], dtype=float), None, None, None\n\n  thetas = getContourThetas(contours)\n    \n  top_two_angles = calculateKDE(thetas)\n\n  mask = calculateMask(edges_gradient.shape, contours, iters)\n\n  min_area_rect = getMinAreaRect(mask)\n\n  return mask, top_two_angles, min_area_rect, median_contour\n\n\ndef calculateKDE(thetas):\n  thetas *= 180\/np.pi\n  thetas[thetas<0] += 180\n  \n  kde_func = scipy.stats.gaussian_kde(thetas)\n  positions = np.linspace(-40,180+40,360)\n  kde_res = kde_func(positions)\n\n  left_half = np.diff(kde_res)\n  right_half = np.diff(kde_res[::-1])\n  \n  f = kde_res.copy()\n  f[1:][left_half<0] = 0\n  f[:-1][right_half[::-1]<0] = 0\n\n  peak_indices = np.argwhere(f).flatten()\n  peak_angles = positions[peak_indices]\n\n  order = np.argsort(kde_res[peak_indices])[::-1] # strongest to weakest peaks\n\n  return peak_angles[order[:2]] # top two strongest angles in degrees\n\n# def plotKDE(thetas):\n#   thetas *= 180\/np.pi\n#   thetas[thetas<0] += 180\n  \n#   ax1 = plt.subplot(211)\n#   plt.plot(thetas,np.zeros(thetas.shape),'.')\n#   plt.hist(thetas,20)\n\n#   plt.subplot(212, sharex=ax1)\n#   kde_func = scipy.stats.gaussian_kde(thetas)\n#   positions = np.linspace(-40,180+40,360)\n#   kde_res = kde_func(positions)\n#   plt.plot(positions, kde_res)\n\n#   c = kde_res.copy()\n#   left_half = np.diff(kde_res)\n#   right_half = np.diff(kde_res[::-1])\n  \n#   f = c.copy()\n#   f[1:][left_half<0] = 0\n#   f[:-1][right_half[::-1]<0] = 0\n#   peak_indices = np.argwhere(f).flatten()\n#   print(peak_indices, positions[peak_indices])\n#   peak_angles = positions[peak_indices]\n\n#   plt.plot(peak_angles, kde_res[peak_indices],'go')\n#   order = np.argsort(kde_res[peak_indices][::-1]) # strongest to weakest peaks\n#   return peak_angles[order[:2]], peak_angles, kde_res[peak_indices] # two angles in degrees\n\ndef getHoughLines(edges, min_line_size=100):\n  # Expects chessboard to take up over 50% of edge map\n  # min_line_size = int(min(edges.shape)\/8)\n  lines = cv2.HoughLinesP(edges,1,np.pi\/360.0, int(min_line_size),\n    minLineLength = min_line_size, maxLineGap = min_line_size\/2)\n\n  if lines is None:\n    return np.array([])\n\n  return lines[:,0,:]\n\ndef getSegmentTheta(line):\n  x1,y1,x2,y2 = line\n  theta = np.math.atan2(y2-y1, x2-x1)\n  return theta\n\ndef parseHoughLines(lines, top_two_angles, angle_threshold_deg=20):\n  is_good = np.zeros(len(lines)) # 0 = bad, 1 = close to 1st angle, 2 = close to 2nd angle\n  for i, line in enumerate(lines):\n    theta = getSegmentTheta(line) * 180\/np.pi # to degrees\n    d1 = getMinLineAngleDistanceDeg(theta, top_two_angles[0])\n    d2 = getMinLineAngleDistanceDeg(theta, top_two_angles[1])\n    if (d1 < angle_threshold_deg):\n      is_good[i] = 1\n    elif (d2 < angle_threshold_deg):\n      is_good[i] = 2\n  lines_a = lines[is_good==1]\n  lines_b = lines[is_good==2]\n  return lines_a, lines_b\n\n\ndef getMinLineAngleDistance(a0, a1):\n  # In radians\n  # Compare line angles (which can be 180 off from one another, or +- 180)\n  v0 = abs(a1-a0)\n  v1 = abs((a1+np.pi) - a0)\n  v2 = abs(a1 - (a0+np.pi))\n  return min([v0,v1,v2])\n\ndef getMinLineAngleDistanceDeg(a0, a1):\n  # In degrees\n  # Compare line angles (which can be 180 off from one another, or +- 180)\n  v0 = abs(a1-a0)\n  v1 = abs((a1+180) - a0)\n  v2 = abs(a1 - (a0+180))\n  return min([v0,v1,v2])\n\n\ndef plotHoughLines(img, lines, color=(255,255,255), line_thickness=2):\n  # colors = np.random.random([lines.shape[0],3])*255\n  # colors = np.array([\n  #     [20,20,20],\n  #     [255,0,0],\n  #     [0,255,0],\n  #     [255,255,0],\n  #     [0,0,255],\n  #     [255,0,255],\n  #     [0,255,255],\n  #     [200,200,200],\n  #     ], dtype=np.uint8)\n  # Plot lines\n  for i, line in enumerate(lines):\n    # color = list(map(int,colors[i%len(colors)]))\n    cv2.line(img,\n      tuple(line[:2].astype(np.int)),\n      tuple(line[2:].astype(np.int)), color, thickness=line_thickness)\n\n\n\ndef getMinAreaRect(mask):\n  a = np.argwhere(mask.T>0.5)\n  # rect = cv2.boundingRect(a)\n  rect = cv2.minAreaRect(a)\n  return rect\n\ndef drawMinAreaRect(img, rect, color=(0,255,255)):\n  ctr = tuple(map(int,rect[0]))\n  \n  box = cv2.boxPoints(rect)\n  box = np.int0(box)\n\n  cv2.drawContours(img,[box],0,color,2)\n  cv2.circle(img, ctr, 3, (255,0,0),-1)\n\n\ndef skeletonize_1d(data):\n  c = data.copy()\n  left_half = np.diff(data)\n  right_half = np.diff(data[::-1])\n\n  f = data.copy()\n  f[1:][left_half<0] = 0\n  f[:-1][right_half[::-1]<0] = 0\n  return f\n\ndef getWarpCheckerLines(img):\n  \"\"\"Given a warped axis-aligned image of a chessboard, return internal line crossings\"\"\"\n  # TODO: Fix awkward conversion\n  # Convert RGB numpy array to image, then to grayscale image, then back to numpy array\n  img_gray = np.array(PIL.Image.fromarray(img).convert('L'))\n  img_gray = cv2.bilateralFilter(img_gray,15,75,75)\n\n  # Find gradients\n  sobelx = cv2.Sobel(img_gray,cv2.CV_64F,1,0,ksize=5)\n  sobely = cv2.Sobel(img_gray,cv2.CV_64F,0,1,ksize=5)\n\n  sobelx_pos = sobelx.copy()\n  sobelx_pos[sobelx <= 0] = 0\n  sobelx_neg = sobelx.copy()\n  sobelx_neg[sobelx > 0] = 0\n\n  sobely_pos = sobely.copy()\n  sobely_pos[sobely <= 0] = 0\n  sobely_neg = sobely.copy()\n  sobely_neg[sobely > 0] = 0\n\n  kernel = np.array([ 0.  ,  0.  ,  0.04,  0.32,  0.88,  0.88,  0.32,  0.04,  0.  ,  0.  ])\n\n  checker_x = np.sum(sobelx_pos, axis=0) * np.sum(-sobelx_neg, axis=0)\n  checker_x = np.convolve(checker_x, kernel, 'same')\n  checker_x = checker_x \/ checker_x.max()\n  checker_x[checker_x<0.1] = 0\n  checker_x = skeletonize_1d(checker_x)\n\n  checker_y = np.sum(sobely_pos, axis=1) * np.sum(-sobely_neg, axis=1)\n  checker_y = np.convolve(checker_y, kernel, 'same')\n  checker_y = checker_y \/ checker_y.max()\n  checker_y[checker_y<0.1] = 0\n  checker_y = skeletonize_1d(checker_y)\n\n  x_lines = np.argwhere(checker_x).flatten()\n  y_lines = np.argwhere(checker_y).flatten()\n\n\n\n  #######\n  ## Semi-brute force approach, merge all combinations of 3 points \n  # with equal spacing under one standard deviation\n  x_lines = getBestEqualSpacing(x_lines)\n  y_lines = getBestEqualSpacing(y_lines)\n\n  ###########\n\n  if len(x_lines) < 7 or len(y_lines) < 7:\n    return [], [], [], []\n\n  # Select set of 7 adjacent lines with max sum score\n  x_scores = np.zeros(x_lines.shape[0]-7+1)\n  for i in range(0,x_lines.shape[0]-7+1):\n    x_scores[i] = np.sum(checker_x[x_lines[i:i+7]])\n  x_start = np.argmax(x_scores)\n  strongest_x_lines = range(x_start,x_start+7)\n\n  y_scores = np.zeros(y_lines.shape[0]-7+1)\n  for i in range(0,y_lines.shape[0]-7+1):\n    y_scores[i] = np.sum(checker_y[y_lines[i:i+7]])\n  y_start = np.argmax(y_scores)\n  strongest_y_lines = range(y_start,y_start+7)\n\n  # TODO: Sanity check areas between lines for consistent color when choosing?\n\n  # Choose best internal 7 chessboard lines\n  lines_x = x_lines[strongest_x_lines]\n  lines_y = y_lines[strongest_y_lines]\n\n  # Add outer chessboard edges assuming consistent step size\n  step_x = np.median(np.diff(lines_x))\n  step_y = np.median(np.diff(lines_y))\n\n  lines_x = np.hstack([lines_x[0]-step_x, lines_x, lines_x[-1]+step_x])\n  lines_y = np.hstack([lines_y[0]-step_y, lines_y, lines_y[-1]+step_y])\n\n  return lines_x, lines_y, step_x, step_y\n\n  # x_lines = np.argwhere(checker_x).flatten()\n  # y_lines = np.argwhere(checker_y).flatten()\n\n  # x_diff = np.diff(x_lines)\n  # y_diff = np.diff(y_lines)\n\n  # step_x_pred = np.median(x_diff)\n  # step_y_pred = np.median(y_diff)\n\ndef pruneGradLines(a, b, eta=10):\n  # Remove values from vector 'a' that aren't close to values in vector b\n  is_good = np.zeros(len(a),dtype=bool)\n  for i,v in enumerate(a):\n    if min(b-v) < eta:\n      is_good[i] = True\n  return a[is_good]\n  \n\n\n\n\n\n\n\n\n\n\n\n\ndef main(filenames):\n  for filename in filenames:\n    img = cv2.imread(filename)\n    img = scaleImageIfNeeded(img, 600, 480)\n\n    # Edges\n    edges = cv2.Canny(img, 100, 550)\n    mask, _, _, _ = getEstimatedChessboardMask(img, edges, iters=10)\n\n    img_masked_full = cv2.bitwise_and(img,img,mask = (mask > 0.5).astype(np.uint8))\n    img_masked = cv2.addWeighted(img,0.2,img_masked_full,0.8,0)\n    edges_masked = cv2.bitwise_and(edges,edges,mask = (mask > 0.5).astype(np.uint8))\n\n    cv2.imshow('img %s' % filename,img_masked)\n    cv2.imshow('edges %s' % filename, edges_masked)\n    cv2.imshow('mask %s' % filename, mask)\n\n\n  cv2.waitKey(0)\n  cv2.destroyAllWindows()\n\nif __name__ == '__main__':\n  if len(sys.argv) > 1:\n    filenames = sys.argv[1:]\n  else:\n    # filenames = ['input\/1.jpg']\n    filenames = ['input2\/18.jpg']\n  print(\"Loading\", filenames)\n  main(filenames)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_661","text":"<reponame>bartolsthoorn\/PH_XXZ\nimport h5py\nimport numpy as np\nfrom ripser import ripser\nimport gudhi as gd\nfrom persim import plot_diagrams\nfrom scipy.spatial.distance import pdist\nfrom scipy.spatial.distance import squareform\nfrom tqdm import tqdm\nfrom multiprocessing import Pool\nimport gudhi as gd\nimport pickle\nimport persim\n\nfilename = 'snapshots_4_100000_32.hdf5'\n#filename = 'snapshots_6_100000_32.hdf5'\nf = h5py.File(filename, 'r')\nL = 4\nN = L*L*L*16\n\nspins_type = 'global'\n\ncoordinates = f['coordinates'][:].transpose()\ncoordinates = coordinates.reshape(N,3)\ncoordinates_D = squareform(pdist(coordinates, metric='euclidean'))\nprint(np.min(coordinates_D[coordinates_D > 0]))\nspins = f['spins_' + spins_type][:].transpose()\nprint(spins.shape)\n\nJ_grid = f['J'][:]\nT_grid = f['T'][:]\nprint(J_grid)\n\nN_T = len(T_grid)\nN_J = len(J_grid)\n\nf.close()\n\nparams = []\nfor i, J in enumerate(J_grid):\n    for j, T in enumerate(T_grid):\n        params.append((J,T))\n\nn_samples = 32\ndef calculate_barcodes(samples):\n    points_list = [coordinates + (spins * 0.3535533905932738 * 0.25) for spins in samples]\n    points_list = points_list[0:n_samples]\n    dgms = [[] for i in range(3)]\n    for points in points_list:\n        #rips = ripser(points, thresh=max_death, maxdim=maxdim)\n        alpha_complex = gd.AlphaComplex(points=points)\n        st_alpha = alpha_complex.create_simplex_tree()\n        barcodes = st_alpha.persistence()\n        #for i, d in enumerate(rips['dgms']):\n        #    dgms[i] += list(d)\n        for d in np.arange(3):\n            dgms[d] += [bar for dim, bar in barcodes if dim == d]\n    return dgms\n\nbarcodes = []\nfor i, J in tqdm(enumerate(J_grid), total=len(J_grid)):\n    for j, T in tqdm(enumerate(T_grid), total=len(T_grid)):\n        barcodes.append(calculate_barcodes(spins[i, j, :]))\n\npickle.dump(barcodes, open(filename.split('.')[0] + '_' + spins_type + ('_barcodes_%d.p' % n_samples), 'wb' ))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_662","text":"<reponame>HuguesMoreau\/TMD_fusion_benchmark<filename>preprocess\/transforms.py\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nThis file contains diverse preprocessing functions (mostly norms ans spectrograms),\nand basic tests and visualizations.\nIf you are to work with any IPython console (ex: with Jupyter or spyder), is is advised\nto launch a '%matplotlib qt' ,to get clean widow\n\"\"\"\n\n\nif __name__ == '__main__': # this is used to launch the file from anywhere\n    import sys\n    sys.path.append(\"..\")\n\nimport numpy as np\nimport torch\nimport scipy.signal, scipy.interpolate, scipy.ndimage\n\n\nfrom param import classes_names, fs, duration_window, duration_overlap, duration_segment, spectro_batch_size\nfrom preprocess import Datasets\n\nif __name__ == \"__main__\":\n    import matplotlib.pyplot as plt\n    n_classes = len(classes_names)\n    # We will need this for the tests\n    DS = Datasets.SignalsDataSet(mode='train', split='balanced', comp_preprocess_first=False)\n\n\n#%% transform functions\n\n\"\"\"In all following functions, the input parameter (data) is, by default,\n a dict of numpy arrays, containing signal names (eg. \"Gyr_z\") as keys, and 1-dimensional\n arrays as values\n\nMost of this part contains basic visualizations to make sure the preprocessing is correct\"\"\"\n\n\n\n\nclass TemporalTransform():\n    \"\"\"  create the base transform to use to each element of the data\n    Also generates data for thr 'Random' and 'Zero' cases\n\n    Parameters\n    ----------\n    signal_name_list: a list of string signals (ex: 'Gyr_y', 'Ori_x')\n        If a string ends by \"_norm\" (ex: \"Mag_norm\"), the output will\n        be the norm of the three (or four) axis of the signal.\n        The signals can also be 'Zero', in which case the segments are only\n        zeros, or 'Random', in which case each data oint is sampled with normal\n        distribution (zero mean, unit variance)\n\n    Returns\n    -------\n    a function with input:  a dict of (_, 6000) arrays (key example: 'Gyr_y')\n                and output: a dictionnary of arrays.\n    \"\"\"\n    def __init__(self, signal_name_list):\n        super(TemporalTransform, self).__init__()\n        self.signal_name_list = signal_name_list\n\n\n    def __call__(self, data):\n        \"\"\"\n        Parameters\n        ----------\n        a dict of (B, 6000) arrays (key example: 'Gyr_y')\n\n        Returns\n        -------\n        a dictionnary of arrays. This time, the keys are from signal_name_list,\n            and the values are either raw signals (if the key ends with '_x',\n            '_y', '_z', or '_w'); a norm of several signals (if the key ends\n            with '_norm'); or a specific signal (if the key is 'Random' or\n            'Zero'). The shape of each array is (B, 6000), where B (batch size)\n            depends on the input shape.\n        \"\"\"\n\n        outputs = {}\n        for signal_name in self.signal_name_list:\n\n            if signal_name[-2:] in ['_x', '_y', '_z', '_w'] or signal_name == \"Pressure\":\n                processed_signal = data[signal_name]\n\n            elif signal_name == 'Random':\n                data_shape = data[\"Acc_x\"].shape\n                processed_signal = np.random.randn(data_shape[0], data_shape[1]).astype(np.float32)\n\n            elif signal_name == 'Zero':\n                data_shape = data[\"Acc_x\"].shape\n                processed_signal = np.zeros(data_shape).astype(np.float32)\n\n\n            elif signal_name[-5:] == '_norm':\n                suffix_location = signal_name.index(\"_\") # 4 if signal_name == \"LAcc\", 3 otherwise\n                sensor = signal_name[:suffix_location]    # ex: 'Acc', 'LAcc'\n\n                if sensor == \"Ori\":\n                    # in that case, data[sensor+\"_x\"]**2 + data[sensor+\"_y\"]**2 + data[sensor+\"_z\"]**2 should be 1.0\n                    processed_signal = np.sqrt(data[sensor+\"_x\"]**2 + data[sensor+\"_y\"]**2 + data[sensor+\"_z\"]**2 \\\n                                             + data[sensor+\"_w\"]**2)\n                else :\n                    processed_signal = np.sqrt(data[sensor+\"_x\"]**2 + data[sensor+\"_y\"]**2 + data[sensor+\"_z\"]**2)\n            else :\n                raise ValueError(\"unknown signal name: '{}'. Signal names should end with either '_x', '_y', '_z', '_w', or '_norm'\".format(signal_name))\n\n            outputs[signal_name] = processed_signal\n\n        return outputs\n\n\n\n    def __str__(self):\n        \"\"\"purely for visual purposes, so that we can print() the function\"\"\"\n        str_to_return = \"Temporal_transform\"\n        str_to_return += \"\\n\\t Signals: {}\".format(self.signal_name_list)\n        return str_to_return\n\n\n\n\n\n\nif __name__ == \"__main__\":\n\n    # plot one figure per sensor\n    # on each figure, one subplot per class,\n    # to find one instance per each class, we start looking at index = index0\n    index0 = 0\n\n    for tested_signal_name in [\"Acc_norm\", \"Ori_norm\", \"Mag_norm\", \"LAcc_x\"]:\n        # plot 1 segment from each class.\n        plt.figure()\n\n        if tested_signal_name != 'Pressure':\n            suffix_location = tested_signal_name.index(\"_\")\n            tested_sensor = tested_signal_name[:suffix_location]    # ex: 'Acc', 'LAcc'\n        else:\n            tested_sensor = 'Pressure'\n\n        sensor_axis = [tested_sensor + axis for axis in [\"_x\", \"_y\", \"_z\"]] if tested_sensor != 'Pressure' else ['Pressure']\n        if tested_sensor == \"Ori\" :  sensor_axis.append(tested_sensor+\"_w\")\n\n        temporal_transform = TemporalTransform([tested_signal_name])\n\n        remaining_classes = classes_names.copy()\n        index = index0\n\n        while len(remaining_classes)>0:\n            data_tensor, class_tensor = DS[index] # data is a dict of 2D tensors (1,nb)\n            data_cpu = {signal:data_tensor[signal].to(torch.device('cpu')).detach().numpy() for signal in data_tensor.keys()}\n            class_index = int(class_tensor)\n            class_name = classes_names[class_index-1]\n\n            if class_name in remaining_classes:\n\n                remaining_classes.remove(class_name)\n                plt.subplot(2, 4, n_classes - len(remaining_classes))\n\n\n                for k,signal in enumerate(sensor_axis):\n\n                    if k==0:  # compute the temporal axis once\n                        nb = data_cpu[signal].shape[1]\n                        x_t = np.linspace(0, nb\/fs, nb)\n\n                    plt.plot(x_t, data_cpu[signal][0,:])\n\n                selected_signal = temporal_transform(data_cpu)[tested_signal_name]\n\n                error_message_dtype = \"One of the signals does not have the correct type: {}, {} \\n dtype should be float32, is actually {}\".format(tested_signal_name, str(temporal_transform), selected_signal.dtype)\n                assert (selected_signal.dtype == 'float32'), error_message_dtype\n\n                plt.plot(x_t, selected_signal[0,:], '--')\n                plt.xlabel(\"t (s)\")\n                legend = sensor_axis + [tested_signal_name+' (selected)']\n                plt.legend(legend)\n                plt.title(\"{} ({}, index={})\".format(tested_sensor, classes_names[class_index-1], index))\n\n\n            index +=1\n\n        plt.show()\n\n\n\n\n#%% FFT\n\nclass FFTTransform():\n    \"\"\"  create a transform to use to return the power of the spectrum\n    (computed through a Fourier transform) of each element of the data\n\n    Parameters\n    ----------\n    signal_name_list: a list of string signals (ex: 'Gyr_y', 'Ori_x')\n        If a string ends by \"_norm\" (ex: \"Mag_norm\"), the output will\n        be the norm of the three (or four) axis of the signal.\n\n    Returns\n    -------\n    a function with input:  a dict of (B, 6000) arrays (key example: 'Gyr_y')\n                and output: a dictionnary of (B, 6000) arrays.\n    \"\"\"\n    def __init__(self, signal_name_list):\n        super(FFTTransform, self).__init__()\n        self.signal_name_list = signal_name_list\n        self.temporal_transform = TemporalTransform(signal_name_list)\n\n\n    def __call__(self, data):\n        \"\"\"\n        Parameters\n        ----------\n        a dict of (B, 6000) arrays (key example: 'Mag_x')\n\n        Returns\n        -------\n        a dictionnary of arrays. The keys are from signal_name_list, and the\n            values are the power spectra of each signal. The shape of each array is\n            (B, 6000), where B (batch size) depends on the input shape\n        \"\"\"\n        temporal_signals = self.temporal_transform(data)\n        del data  # free some memory\n\n        outputs = {}\n        for signal_name in self.signal_name_list:\n            complex_fft = np.fft.fft(temporal_signals[signal_name], axis=1)\n            power_fft = np.abs(complex_fft)\n            power_fft[:,0] = 0. # remove the DC component (to avoid this component\n              #  outscales te others)\n\n            centered_power_fft = np.fft.fftshift(power_fft, axes=1) # so 0 Hz is in the middle\n\n            outputs[signal_name] = centered_power_fft.astype('float32')\n            del temporal_signals[signal_name] # release the memory\n\n            # a faire, calculer les f et les sauver\n            # self.f=f\n\n        return outputs\n\n\n\n    def __str__(self):\n        \"\"\"purely for visual purposes, so that we can print() the function\"\"\"\n        str_to_return = \"FFT_transform\"\n        str_to_return += \"\\n\\t Signals: {}\".format(self.signal_name_list)\n        return str_to_return\n\n\n\n\n#%%\n\nif __name__ == \"__main__\":\n\n    # classes to plot,\n    sel_classes = [\"Still\",\"Walk\",\"Run\",\"Train\"]\n    nsel = len(sel_classes)\n\n    for tested_signal_name in [\"Acc_norm\", \"Gyr_y\", \"Mag_norm\", \"Pressure\"]:\n        # plot 1 segment from each class.\n        plt.figure()\n        tested_sensor = tested_signal_name[:3]\n        if \"_\" in tested_sensor:\n            sensor_axis = [tested_sensor + axis for axis in [\"_x\", \"_y\", \"_z\"]]\n        else: # Pressure\n            sensor_axis = [tested_sensor]\n        if tested_sensor == \"Ori\" :  sensor_axis.append(tested_sensor+\"_w\")\n\n        fft_transform =      FFTTransform([tested_signal_name])\n        temporal_transform = TemporalTransform([tested_signal_name])\n\n        remaining_classes = sel_classes.copy()\n\n        index = 0\n        isub = 1\n\n        while len(remaining_classes)>0:\n            data_tensor, class_tensor = DS[index]\n            data_cpu = {signal:data_tensor[signal].to(torch.device('cpu')).detach().numpy() for signal in data_tensor.keys()}\n            class_index = int(class_tensor)\n\n            class_name = classes_names[class_index-1]\n\n            if class_name in remaining_classes:\n                remaining_classes.remove(class_name)\n\n                plt.subplot(2, nsel, isub)\n                selected_signal = temporal_transform(data_cpu)[tested_signal_name]\n\n                 # plot the temporal signal\n                nb = selected_signal.shape[1]\n                x_t = np.linspace(0, nb\/fs, nb)\n\n                x_f = np.linspace(-fs\/2,fs\/2, nb)\n\n                plt.plot(x_t, selected_signal[0,:])\n                plt.xlabel(\"t (s)\")\n                plt.title(\"{} ({}, index={})\".format(tested_signal_name, classes_names[class_index-1], index))\n\n                 # plot the fft\n                plt.subplot(2, nsel, isub + 4)\n                isub += 1\n                selected_power = fft_transform(data_cpu)[tested_signal_name]\n\n                error_message_dtype = \"One of the signals does not have the correct type: {}, {} \\n dtype should be float32, is actually {}\".format(tested_signal_name, str(fft_transform), selected_power.dtype)\n                assert (selected_power.dtype == 'float32'), error_message_dtype\n\n                plt.plot(x_f, selected_power[0,:])\n                plt.xlabel(\"f (Hz)\")\n                plt.title(\"FFT of {} ({}, index={})\".format(tested_signal_name, classes_names[class_index-1], index))\n\n            index +=1\n        plt.show()\n\n\n\n\n\n\n\n\n#%%\n\n#  ----------------  Spectral transforms  ---------------------\n\n\n# Interpolation functions\ndef interpol_log(f, t, spectrogram, out_size):\n    \"\"\"interpolates the spectrogram in input using a linear axis for the timestamps and a LOG axis for the frequencies\n\n    Parameters\n    ----------\n    f : numpy array, shape: (F_in,), frequencies of the spectrogram\n    t : numpy array, shape: (T_in,), timestamps of the spectrogram\n    spectrogram : (B, F_in, T_in), B is batch size; 3D numpy array\n\n    out_size : couple of ints (F_out, T_out)\n\n    Returns\n    -------\n    f_interpolated : numpy array, shape: (F_out,), frequencies of the spectrogram AFTER interpolation\n    t_interpolated : numpy array, shape: (T_out,), timestamps of the spectrogram AFTER interpolation\n    a spectrogram, where the f axis (second dimension) has been re-interpolated\n    using a log axis\n\n    \"\"\"\n    B = spectrogram.shape[0]\n    out_f, out_t = out_size\n\n    log_f = np.log(f+f[1]) #  log between 0.2 Hz and 50.2 Hz\n\n    log_f_normalized    = (log_f-log_f[0])\/(log_f[-1]-log_f[0]) # between 0.0 and 1.0\n    t_normalized        = (t-t[0])\/(t[-1]-t[0])\n\n    rescaled_f = out_f*log_f_normalized # 0 and 48\n    # rescaled_f = (out_f-1)*log_f_normalized ??\n    rescaled_t = out_t*t_normalized\n\n    spectrogram_interpolated = np.zeros( (B, out_f, out_t), dtype='float32')\n    index_f, index_t = np.arange(out_f), np.arange(out_t) # between 0 and 47\n\n    for i in range(B):\n        spectrogram_fn = scipy.interpolate.interp2d(rescaled_t, rescaled_f, spectrogram[i,:,:], copy=False)\n        # interp2d returns a 2D function\n        spectrogram_interpolated[i,:,:] = spectrogram_fn(index_t, index_f)  # care to the order\n\n    f_fn = scipy.interpolate.interp1d(rescaled_f, f, copy=False)\n    f_interpolated = f_fn(index_f)\n\n    t_fn = scipy.interpolate.interp1d(rescaled_t, t, copy=False)\n    t_interpolated = t_fn(index_t)\n\n\n    return f_interpolated, t_interpolated, spectrogram_interpolated\n\n\n\ndef interpol_lin(f, t, spectrogram, out_size):\n    \"\"\"interpolates the spectrogram in input using a linear axis for the timestamps AND the frequencies\n\n    Parameters\n    ----------\n    f : numpy array, shape: (F_in,), frequencies of the spectrogram\n    t : numpy array, shape: (T_in,), timestamps of the spectrogram\n    spectrogram : (B, F_in, T_in) numpy array\n    out_size : couple of ints (F_out, T_out)\n     (does not need f or t)\n\n\n    Returns\n    -------\n    f_interpolated : numpy array, shape: (F_out,), frequencies of the spectrogram AFTER interpolation\n    t_interpolated : numpy array, shape: (T_out,), timestamps of the spectrogram AFTER interpolation\n    a spectrogram: 3D numpy array, where the f axis (second dimension) has been re-interpolated\n          using a linear axis\n    \"\"\"\n    B, F_in, T_in = spectrogram.shape\n    out_f, out_t = out_size\n    output_shape = (B, out_f, out_t ) # result is (B, out_f, out_t )\n\n    rescale_factor_d = 1.   # for depth\n    rescale_factor_f = F_in\/out_f # typically 550\/48\n    rescale_factor_t = T_in\/out_t\n\n    matrix_transform = np.diag( np.array([rescale_factor_d, rescale_factor_f, rescale_factor_t]) ) # (3,3) matrix\n\n    # spectrogram = matrix_transform * spectrogram_interpolated\n    spectrogram_interpolated = scipy.ndimage.affine_transform(spectrogram, matrix_transform, offset=0, order=1, output_shape=output_shape)\n        # we only use linear interpolation because we almost always downsample, and because 2nd order methods and above\n        # have a nasty tendency to create small negative local minimas between two strictly positive values\n        # we do not want this when we apply a log to the values of the spectrogram\n\n    f_interpolated = scipy.ndimage.affine_transform(f, np.array( [rescale_factor_f] ) , offset=0, order=1, output_shape = (out_f,) )\n    t_interpolated = scipy.ndimage.affine_transform(t, np.array( [rescale_factor_t] ) , offset=0, order=1, output_shape = (out_t,) )\n\n\n    return f_interpolated, t_interpolated, spectrogram_interpolated\n\n\n\ndef no_interpolation(f, t, spectrogram, out_size):\n    \"\"\" This function is just a placeholder that mimics the arguments\n    of the two previous interpolation functions    \"\"\"\n    return f, t, spectrogram\n\n\n\n\n\n\n\n\n\n\n#%%\n#  ---------------- The spectrogram class --------------\nclass SpectrogramTransform():\n    \"\"\" create the transform to work with spectrograms. This class behaves\n    essentially the same as TempralTransform, except the created transform\n    returns a dict of 3d array instead of 2d\n\n\n    Parameters\n    ----------\n    signal_name_list: a list of string signals (ex: 'Gyr_y', 'Ori_x')\n        If a string ends by \"_norm\" (ex: \"Mag_norm\"), the output will\n        be the norm of the three (or four) axis of the signal.\n    fs: sampling frequency\n    duration_window, duration_overlap: duration in sec of spectrogram window and overlap\n    spectro_batch_size:\n        turning 13,000 temporal signals into (550, 500) array\n        spectrograms at once is too much: a single (13000, 550, 500) array,\n        with simple precision requires 7.15 Go !\n        This is why we work with batches of 1000 instead. For each batch,\n        we compute the complete sectrogram (1000 x 550 x 500), then\n        interpolate it to smaller sizes, before working wit the following batch.\n\n    interpolation :  string (\"log\", \"linear\", \"none\")\n    log_power : bool. If True, the values of the  power spectrum are replaced\n        by their log\n    out_size : tuple of integer (nb_interp_f, nb_interp_t) = size of spectrogram AFTER interpolation        Is ignored if no interpolation occurs. Default: None\n        the spectrogram is computed for 2 1D-arrays: f and t\n\n    flag_debug: flag for print debugging info\n\n\n\n    Returns\n    -------\n    a function with input: data : a dict of (_, 6000) arrays  (key example: 'Gyr_y')\n                and output: a dictionnary of 2d arrays.\n\n    \"\"\"\n    def __init__(self, signal_name_list, fs, duration_window, duration_overlap, spectro_batch_size, interpolation,\n                 log_power, out_size=None, flag_debug=False):\n        super(SpectrogramTransform, self).__init__()\n\n        self.temporal_transform = TemporalTransform(signal_name_list)\n        self.fs = fs\n        self.duration_window = duration_window\n        self.duration_overlap = duration_overlap\n        self.spectro_batch_size = spectro_batch_size\n\n        self.signal_name_list = signal_name_list\n        self.log_power = log_power\n        self.interpolation_name = interpolation\n\n        if interpolation == \"linear\":\n            self.interpolation_fn = interpol_lin\n            self.out_size = out_size\n\n        elif interpolation == \"log\":\n            self.interpolation_fn = interpol_log\n            self.out_size = out_size\n\n        elif interpolation == \"none\":\n            self.interpolation_fn = no_interpolation\n            self.out_size = None\n\n        else :\n            raise ValueError(\"Unknown interpolation: '{}'. Use one of 'log', 'linear', 'none'\".format(interpolation))\n\n        # if interpolation == \"none\" and out_size != None :\n        #     warnings.warn(\"No interpolation is to take place, but an target output size was provided. the output_size argument will be ignored\",  Warning)\n\n        self.flag_debug = flag_debug\n\n    def __call__(self, data):\n        \"\"\"\n        Parameters\n        ----------\n        data : a dict of (B, 6000) arrays  (key example: 'Gyr_y')\n\n        Returns\n        -------\n        a dictionnary of 2d arrays. The keys are from signal_name_list,\n            and the values are either spectrograms of raw signals (if the key\n            ends with '_x', '_y', '_z', or '_w'); or a spectogram of a norm of\n            signals (if the key ends with '_norm'). The shape of the spectrogram\n            is (B, F, T), where B (batch size) depends on the input shape, and\n            F and T are given by self.out_size\n        \"\"\"\n\n\n        temporal_signals = self.temporal_transform(data)\n        del data  # free some memory\n\n\n        fs = self.fs\n\n        nperseg     = int(self.duration_window * fs)\n        noverlap    = int(self.duration_overlap * fs)\n\n        spectro_batch_size = self.spectro_batch_size\n        # turning 13,000 temporal signals into (550, 500) array\n            # spectrograms at once is too much: a single (13000, 550, 500) array,\n            # with simple precision requires 7.15 Go !\n            # This is why we work with batches of 1000 instead. For each batch,\n            # we compute the complete sectrogram (1000 x 550 x 500), then\n            # interpolate it to smaller sizes, before working wit the following batch.\n\n        out_size = self.out_size\n\n        flag_debug = self.flag_debug\n\n        outputs = {}\n\n        for signal_name in self.signal_name_list:\n            current_spectro_batch_size = temporal_signals[signal_name].shape[0]\n\n            if current_spectro_batch_size < spectro_batch_size :\n                f, t, spectrogram = scipy.signal.spectrogram(temporal_signals[signal_name], fs=fs, nperseg=nperseg, noverlap=noverlap)\n\n                f_interpolated, t_interpolated, interpolated_spectrogram = self.interpolation_fn(f, t, spectrogram, out_size)\n                        # f, t, and possibly out_size will be ignored when the function does not need them\n\n            else :\n                n_batches = (current_spectro_batch_size-1)\/\/spectro_batch_size +1\n\n\n\n                if out_size is not None:  # we actually compute the interpolation\n                    nb_interp_f, nb_interp_t = out_size\n\n                else:    # we only recompute the shapes of the raw spectrogram\n                    nb_interp_f = int(duration_window*fs\/2) +1\n                    nb_interp_t = int((duration_segment-duration_window)\/(duration_window-duration_overlap)) +1\n\n                interpolated_spectrogram = np.zeros((current_spectro_batch_size, nb_interp_f, nb_interp_t), dtype='float32')\n                for i in range(n_batches):\n                    i_min =   i   * spectro_batch_size\n                    i_max = (i+1) * spectro_batch_size  # does not matter if it goes beyond current_spectro_batch_size\n                    this_temporal_signal = temporal_signals[signal_name][i_min:i_max,:]\n\n                    f, t, spectrogram = scipy.signal.spectrogram(this_temporal_signal, fs=fs, nperseg=nperseg, noverlap=noverlap)\n\n                    if out_size is not None:\n                        f_interpolated, t_interpolated, interpolated_spectrogram[i_min:i_max,:,:] = self.interpolation_fn(f, t, spectrogram, out_size) # erase the spectrogram by its interpolation\n                    else:\n                        f_interpolated, t_interpolated, interpolated_spectrogram[i_min:i_max,:,:] = f, t, spectrogram\n\n\n            if flag_debug:\n                print('f_interpolated:')\n                print(f_interpolated[:5])\n                print(f_interpolated[-5:])\n\n\n            del temporal_signals[signal_name]\n\n            if self.log_power :\n                np.log(interpolated_spectrogram + 1e-10, dtype='float32', out=interpolated_spectrogram)\n\n            outputs[signal_name] = interpolated_spectrogram\n\n            self.f_interpolated = f_interpolated\n            self.t_interpolated = t_interpolated\n\n            # for future debug\n            # self.f = f\n            # self.t = t\n            # self.spectrogram = spectrogram\n\n\n\n\n        return outputs\n\n\n\n    def __str__(self):\n        \"\"\"purely for visual purposes, so that we can print() the function\"\"\"\n        str_to_return = \"Spectrogram transform\"\n        str_to_return += \"\\n\\t Signals: {}\".format(self.signal_name_list)\n        if self.interpolation_fn != no_interpolation:\n            if self.out_size != None :\n                str_to_return += \"\\n\\t Output size: {}\".format(self.out_size)\n            else :\n                str_to_return += \"\\n\\t Output size: unchanged\"\n\n        str_to_return += \"\\n\\t Interpolation: {}\".format(self.interpolation_name)\n        str_to_return += \"\\n\\t Log power: {}\".format(self.log_power)\n\n        return str_to_return\n\n# end of class SpectrogramTransform():\n\n\n\n#%%\nif __name__ == \"__main__\":\n\n    flag_debug = 0\n    flag_index = False # if true, plot the spectrogram wrt to index; if False, wrt to Timestamps and Frequencies\n    fontdict = {'fontsize':10}\n    vmin, vmax = 0, 60\n    vmin, vmax = None, None\n    n_ticks = 10\n\n    # we plot the raw spectrogram and two interpolated spectrograms for the following classes\n    sel_classes = [\"Run\"]\n    nsel = len(sel_classes)\n    functions = {\"raw spectrogram\":           \"none\",\n                 \"linear interpolation\":      \"linear\",\n                 \"logarithmic interpolation\": \"log\"}\n\n    remaining_classes = sel_classes.copy()\n    index = 3204  # where to tart the search\n\n    signal_name = \"Acc_norm\"\n    temporal_transform = TemporalTransform([signal_name])  # we will plot the result\n\n    while len(remaining_classes)>0:\n\n        flag_debug = len(remaining_classes) == (nsel-1)\n\n        data_tensor, class_tensor = DS[index]\n        data_cpu = {signal:data_tensor[signal].to(torch.device('cpu')).detach().numpy() for signal in data_tensor.keys()}\n        class_index = int(class_tensor)\n\n        class_name = classes_names[class_index-1]\n\n        prefix_title = '%s (index=%d)'% (class_name,index)\n\n\n\n        if class_name in remaining_classes:\n            remaining_classes.remove(class_name)\n\n\n            temporal_signal = temporal_transform(data_cpu)[signal_name]\n            nb = temporal_signal.shape[1]\n            x_t = np.linspace(0, nb\/fs, nb)\n\n\n            plt.figure(figsize=(30,10))\n\n            plt.subplot(2,4,1)\n\n\n            plt.plot(x_t, temporal_signal[0,:])\n            plt.title(prefix_title + \"\\nraw signal : {}\".format(signal_name), fontdict)\n            plt.xlabel(\"t (sec)\")\n            plt.ylabel(\"Acc (m\/s²)\")\n\n            index_figure = 2\n\n\n            # for log_power in [False]:\n            for log_power in [False, True]:\n\n                if flag_debug:\n                    print('\\n log_power = %s' % log_power)\n\n                for f_name in functions :\n\n                    if flag_debug:\n                        print('\\n f_name = %s' % f_name)\n\n                    function_interpol = functions[f_name]\n\n                    data_tensor, _ = DS[index]  # we need to recreate data because the variable is deleted\n                    data_cpu = {signal:data_tensor[signal].to(torch.device('cpu')).detach().numpy() for signal in data_tensor.keys()}\n\n                    spectrogram_transform = SpectrogramTransform([signal_name], fs, duration_window, duration_overlap, spectro_batch_size,\n                                                                 function_interpol, log_power, out_size=(48, 48), flag_debug = flag_debug)\n\n                    spectrogram_interpolated = spectrogram_transform(data_cpu)[signal_name]\n\n                    f_interpolated = spectrogram_transform.f_interpolated\n                    t_interpolated = spectrogram_transform.t_interpolated\n\n\n                    error_message_dtype = \"One of the spectrograms does not have the correct type: {}, log_power={}, {}. \\n dtype should be float32, is actually {}\".format(signal_name, str(log_power), f_name, spectrogram_interpolated.dtype)\n                    assert (spectrogram_interpolated.dtype == 'float32'), error_message_dtype\n\n                    plt.subplot(2,4,index_figure)\n\n                    if flag_index:\n                        ylabel = \"f (index)\"\n                        xlabel = \"t (index)\"\n\n                        plt.imshow(spectrogram_interpolated[0,:,:])\n\n                    else:\n                        ylabel = \"f (Hz) \"\n                        xlabel = \"t (s)\"\n\n                        t_interpolated = spectrogram_transform.t_interpolated\n                        f_interpolated = spectrogram_transform.f_interpolated\n                        matrix_shape = spectrogram_interpolated.shape\n                        time_list = [f'{t_interpolated[i]:.0f}' for i in np.round(np.linspace(0, matrix_shape[2]-1,n_ticks)).astype(int)]\n                        freq_list = [f'{f_interpolated[i]:.1f}' for i in np.round(np.linspace(0, matrix_shape[1]-1,n_ticks)).astype(int)]\n\n                        plt.xticks(np.linspace(0, matrix_shape[2]-1, n_ticks), time_list)\n                        plt.yticks(np.linspace(0, matrix_shape[1]-1, n_ticks), freq_list)\n\n                        plt.imshow(spectrogram_interpolated[0,:,:])\n\n                    plt.ylabel(ylabel)\n                    plt.xlabel(xlabel)\n                    plt.colorbar()\n\n                    index_figure += 1\n\n                    log_power_text = 'log power' if log_power==True else 'power'\n\n                    plt.title(\"{} of {}\".format( log_power_text, f_name), fontdict = {'fontsize':10})\n\n                index_figure += 1 # for the vertical alignment\n        index +=1\n    plt.show()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_663","text":"import numpy as np\nimport pandas as pd\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport scipy.stats as sts\nfrom finn.util.gdrive import *\nimport sklearn\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.svm import SVR\nfrom sklearn import model_selection\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.model_selection import cross_val_score\nimport os, csv\n\n#define the worksheet name from finn-resource-dashboard\nworksheet_name = \"FCLayer_resources\"\n#define the directory name where to save the graphs\ndirectory_name = \"FCLayer\"\n\n##create the directory\nnew_dir_path = \"..\/graphs\/%s\" % directory_name\ntry:\n    os.mkdir(new_dir_path)\nexcept OSError:\n    print (\"Creation of the directory %s failed\" % new_dir_path)\nelse:\n    print (\"Successfully created the directory %s \" % new_dir_path)\n\nfilename  = \"db_mem_const.csv\"\n\n#get all records from the selected worksheet\nlist_of_dicts = get_records_from_resource_dashboard(worksheet_name)\n\n# convert list of dicts to dataframe\ndf = pd.DataFrame(list_of_dicts)\nprint(df)\n\nfpga = df['FPGA'].iloc[0]\n\n#get synth data\ndf = df[df.apply(lambda r: r.str.contains('synthesis', case=False).any(), axis=1)]\n\n#get records where act=None\ndf = df[df['act'].astype(str) == 'None']\n\n#get records where mem_mode=external\ndf_external = df[df['mem_mode'].astype(str) == 'external']\n\n#get records where mem_mode=const\ndf_const = df[df['mem_mode'].astype(str) == 'const']\n\ndef models(res_class):\n\n    #encode wdt, idt\n    labelencoder = LabelEncoder()\n    df_training['wdt_encoded'] = labelencoder.fit_transform(df_training['wdt'])\n    df_training['idt_encoded'] = labelencoder.fit_transform(df_training['idt'])\n\n    features = ['mh', 'mw', 'pe', 'simd', 'wdt_encoded', 'idt_encoded']\n    #features = ['mh', 'mw', 'pe', 'simd']\n    #extract features\n    X = df_training.loc[:, features].values\n    #extract target\n    Y = df_training.loc[:, [res_class]].values\n\n    #split the data into train\/test data sets 30% testing, 70% training\n    X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size = 0.3, random_state=0)\n    \n    #linear regression\n    linear_reg_model = LinearRegression()\n    linear_reg_model = linear_reg_model.fit(X_train, Y_train)\n    Y_predict_linear = linear_reg_model.predict(X_test)\n    score_linear = linear_reg_model.score(X_test, Y_test)\n\n    #search for the best SVR hyperparameters\n    gscv = GridSearchCV(\n        estimator=SVR(kernel='poly', max_iter=20000000),\n        param_grid={\n            #'C': [0.1, 1, 10, 100, 1000],\n            #'epsilon': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10],\n            #'gamma': [0.0001, 0.001, 0.005, 0.1, 1, 3, 5]\n            'C': [1],\n            'epsilon': [0.1],\n            'gamma': [0.001]\n        },\n        cv=5, n_jobs = -1, verbose = 2)\n\n    grid_result = gscv.fit(X_train, Y_train.ravel())\n\n    print(\"Best parameters set found on development set:\")\n    print()\n    print(grid_result.best_params_)\n\n    #get best hyperparameters and define the model\n    best_params = grid_result.best_params_\n    best_svr = SVR(kernel='poly', C=best_params[\"C\"], epsilon=best_params[\"epsilon\"], gamma=best_params[\"gamma\"])\n    \n    #train the SVR model\n    best_svr = best_svr.fit(X_train, Y_train.ravel())\n\n    Y_predict_svr = best_svr.predict(X_test)\n\n    print(X_test)\n\n    print(best_svr.score(X_test, Y_test))\n\n    #cross-validation\n    scores = cross_val_score(best_svr, X, Y.ravel(), cv=5)\n    print(scores)\n\n    return X_test, Y_test, Y_predict_svr, best_svr.score(X_test, Y_test), Y_predict_linear, score_linear\n\ndef generate_graph_test_set(parameter, res_class):\n\n    X_test, Y_test, Y_predict_svr, score_svr, Y_predict_linear, score_linear = models(res_class)\n\n    fig = plt.figure(figsize=(20, 11))\n    ax = fig.gca()\n\n    X_test = [col[2] for col in X_test]\n\n    ax.scatter(Y_predict_linear, X_test, marker=\"o\", s=200, facecolors='none', edgecolors='g', label='predicted_linear')\n    ax.scatter(Y_predict_svr, X_test, marker=\"^\", s=500, facecolors='none', edgecolors='m', label='predicted_svr')\n    ax.scatter(Y_test, X_test, marker=\"x\", s=50, color='r', label='synth')\n\n    ax.set_xlabel(\"%s\" % 'LUT')\n    ax.set_ylabel(\"%s\" % 'pe')\n\n    if \"FCLayer\" in worksheet_name:\n        ax.set_title(\"%s vs %s (SVR_score = %s, linear_score = %s)\" % ('pe', 'LUT', score_svr, score_linear))\n    else:\n        ax.set_title(\"%s vs %s (SVR_score = %s, linear_score = %s)\" % ('pe', 'LUT', score_svr, score_linear))\n    \n    leg = ax.legend()\n    \n    fig.savefig('..\/graphs\/%s\/plot_%s_vs_%s_weight_mem_const_test.png' % (directory_name, 'pe', 'LUT'), bbox_inches='tight')\n\n\n#get dataframe headers\nheaders = list(df)\n\n#get all parameters and resource classes from the csv file\nparameters = []\nres_classes = []\nseparator = 0\nfor s in headers:\n    if s == 'Resources from:':\n        separator = 1\n    elif separator:\n        res_classes.append(s)\n    else:\n        parameters.append(s)\n\n#remove tools details: FPGA, finn_commit, vivado_version, vivado_build_no\n#remove timing \n#remove act, mem_mode, Res from\ncolumns_to_remove = ['act', 'mem_mode', 'Resources from:', 'FPGA', 'finn_commit', 'vivado_version', 'vivado_build_no', 'TargetClockPeriod', 'EstimatedClockPeriod', 'Delay', 'TargetClockFrequency [MHz]', 'EstimatedClockFrequency [MHz]']\nres_classes = [element for element in res_classes if element not in columns_to_remove]\nparameters = [element for element in parameters if element not in columns_to_remove]\n\ndf_const = df_const.drop(columns_to_remove, axis=1)\ndf_external = df_external.drop(columns_to_remove, axis=1)\n\nprint(parameters)\nprint(res_classes)\nprint(len(df_external))\nprint(len(df_const))\nprint(df_external)\nprint(df_const)\n\npd.set_option('display.max_columns', 500)\n\n#isolate contribution of weights to overall resource utilization by subtracting resources of equivalent (mem_mode = external) configuration \ndf_training = pd.DataFrame(columns=list(df_const))\n\n\nwith open(filename, 'w') as csvfile:\n    csvwriter = csv.writer(csvfile)\n    headers = list(df_training)\n    #headers.insert(0, 'set')\n    csvwriter.writerow(headers)\n\nfound_row = False\nfor index, row1 in df_external.iterrows():\n    for index, row2 in df_const.iterrows():\n        for s in parameters:\n            if row1[s] == row2[s]:\n                found_row = True\n            else:\n                found_row = False\n                break\n        if found_row == True:\n            print(row1)\n            print(row2)\n            \"\"\"\n            with open(filename, 'a+') as csvfile:\n                csvwriter = csv.writer(csvfile)\n                row = pd.concat([pd.Series(['external']), row1])\n                csvwriter.writerow(row)\n                row = pd.concat([pd.Series(['const']), row2])\n                csvwriter.writerow(row)\n            \"\"\"\n            for res in res_classes:\n                row2[res] = row2[res] - row1[res]\n            df_training = df_training.append(row2, ignore_index=True)\n            \n            with open(filename, 'a+') as csvfile:\n                csvwriter = csv.writer(csvfile)\n                #row2 = pd.concat([pd.Series(['result']), row2])\n                csvwriter.writerow(row2)\n\nprint(df_training)\n\n\n#for testing\nparameters = ['pe']\nres_classes = ['LUT']\n\nfor parameter in parameters:\n    for res_class in res_classes:\n        generate_graph_test_set(parameter, res_class)\n        \n\"\"\"\n####test####\nparameters = ['mh', 'mw', 'pe','simd']\nres_classes = ['LUT', 'BRAM']\n\nlist_columns = ['mh', 'mw', 'pe','simd', 'LUT', 'BRAM']\nlist_data = [ [16, 16, 8, 8, 345, 34],[16, 16, 2, 2, 456, 45], [32, 32, 16, 16, 786, 77]]\ndf_ext= pd.DataFrame(columns=list_columns, data=list_data)\n\nlist_columns = ['mh', 'mw', 'pe','simd', 'LUT', 'BRAM']\nlist_data = [ [16, 16, 8, 8, 3345, 234],[32, 32, 16, 16, 5786, 477], [15, 15, 2, 2, 2456, 145]]\ndf_ct= pd.DataFrame(columns=list_columns, data=list_data)\n\nprint(df_ext)\nprint(df_ct)\ndf_training = pd.DataFrame(columns=list(df_ct))\nfound_row = False\nfor index, row1 in df_ext.iterrows():\n    for index, row2 in df_ct.iterrows():\n        for s in parameters:\n            if row1[s] == row2[s]:\n                found_row = True\n            else:\n                found_row = False\n                break\n        if found_row == True:\n            for res in res_classes:\n                row2[res] = row2[res] - row1[res]\n            df_training = df_training.append(row2, ignore_index=True)\nprint(df_training)\n\"\"\""}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_664","text":"<filename>extract.py\nimport argparse\nimport os\nimport numpy as np\nimport scipy.io as sio\nimport torch\n\nfrom configs.default import dataset_cfg\nfrom data import get_test_loader\nfrom models.model import Model\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser()\n    parser.add_argument(\"gpu\", type=int)\n    parser.add_argument(\"model_path\", type=str)  # TODO compatible for different models\n    parser.add_argument(\"--img-h\", type=int, default=256)\n    parser.add_argument(\"--dataset\", type=str, default=None)\n\n    args = parser.parse_args()\n    model_path = args.model_path\n    fname = model_path.split(\"\/\")[-1]\n\n    if args.dataset is not None:\n        dataset = args.dataset\n    else:\n        dataset = model_path.split(\"\/\")[1]\n\n    prefix = os.path.splitext(fname)[0]\n\n    dataset_config = dataset_cfg.get(dataset)\n    image_size = (args.img_h, 128)\n\n    torch.backends.cudnn.benchmark = True\n    os.environ[\"CUDA_VISIBLE_DEVICES\"] = str(args.gpu)\n\n    model = Model(eval=True, drop_last_stride=True)\n\n    state_dict = torch.load(model_path)\n\n    model.load_state_dict(state_dict, strict=False)\n    model.float()\n    model.eval()\n    model.cuda()\n\n    # extract query feature\n    query = get_test_loader(root=os.path.join(dataset_config.root, dataset_config.query),\n                            batch_size=512,\n                            image_size=image_size,\n                            num_workers=16)\n\n    query_feat = []\n    query_label = []\n    query_cam_id = []\n    query_img_path = []\n    for data, label, cam_id, img_path, _ in query:\n        with torch.autograd.no_grad():\n            feat = model(data.cuda(non_blocking=True))\n\n        query_feat.append(feat.data.cpu().numpy())\n        query_label.append(label.data.cpu().numpy())\n        query_cam_id.append(cam_id.data.cpu().numpy())\n        query_img_path.extend(img_path)\n\n    query_feat = np.concatenate(query_feat, axis=0)\n    query_label = np.concatenate(query_label, axis=0)\n    query_cam_id = np.concatenate(query_cam_id, axis=0)\n    print(query_feat.shape)\n\n    dir_name = \"features\/{}\".format(dataset, prefix)\n    if not os.path.isdir(dir_name):\n        os.makedirs(dir_name)\n\n    save_name = \"{}\/query-{}.mat\".format(dir_name, prefix)\n    sio.savemat(save_name,\n                {\"feat\": query_feat,\n                 \"ids\": query_label,\n                 \"cam_ids\": query_cam_id,\n                 \"img_path\": query_img_path})\n\n    # extract gallery feature\n    gallery = get_test_loader(root=os.path.join(dataset_config.root, dataset_config.gallery),\n                              batch_size=512,\n                              image_size=image_size,\n                              num_workers=16)\n\n    gallery_feat = []\n    gallery_label = []\n    gallery_cam_id = []\n    gallery_img_path = []\n    for data, label, cam_id, img_path, _ in gallery:\n        with torch.autograd.no_grad():\n            feat = model(data.cuda(non_blocking=True))\n\n        gallery_feat.append(feat.data.cpu().numpy())\n        gallery_label.append(label)\n        gallery_cam_id.append(cam_id)\n        gallery_img_path.extend(img_path)\n\n    gallery_feat = np.concatenate(gallery_feat, axis=0)\n    gallery_label = np.concatenate(gallery_label, axis=0)\n    gallery_cam_id = np.concatenate(gallery_cam_id, axis=0)\n    print(gallery_feat.shape)\n\n    save_name = \"{}\/gallery-{}.mat\".format(dir_name, prefix)\n    sio.savemat(save_name,\n                {\"feat\": gallery_feat,\n                 \"ids\": gallery_label,\n                 \"cam_ids\": gallery_cam_id,\n                 \"img_path\": gallery_img_path})\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_665","text":"<reponame>jupito\/dwilib\n#!\/usr\/bin\/python3\n\n\"\"\"Get grid-wise features.\"\"\"\n\n# TODO Also scale lesiontype.\n\nimport argparse\nfrom itertools import product\nimport logging\nimport os.path\n\nimport numpy as np\nfrom scipy import ndimage\n\nimport dwi.files\nimport dwi.texture\nimport dwi.util\n\nlog = logging.getLogger('grid')\n\n\ndef parse_args():\n    \"\"\"Parse command-line arguments.\"\"\"\n    p = argparse.ArgumentParser(description=__doc__)\n    p.add_argument('--verbose', '-v', action='count',\n                   help='increase verbosity')\n    p.add_argument('--image', required=True,\n                   help='input image or pmap')\n    p.add_argument('--param', type=int,\n                   help='parameter index')\n    p.add_argument('--prostate', metavar='MASKFILE', required=True,\n                   help='prostate mask')\n    p.add_argument('--lesions', metavar='MASKFILE', nargs='+', required=True,\n                   help='lesion masks')\n    p.add_argument('--mbb', type=float,\n                   help='minimum bounding box padding in millimeters (try 15)')\n    p.add_argument('--voxelsize', type=float,\n                   help='rescaled voxel size in millimeters (try 0.25)')\n    p.add_argument('--winsize', type=float, default=5,\n                   help='window (cube) size in millimeters (default 5)')\n    p.add_argument('--voxelspacing', type=float, nargs=3,\n                   help='force voxel spacing (leave out to read from image)')\n    p.add_argument('--use_centroid', action='store_true',\n                   help='align by prostate centroid instead of image corner')\n    p.add_argument('--nanbg', action='store_true',\n                   help='set non-prostate background to nan')\n    p.add_argument('--lesiontypes', metavar='TYPE', nargs='+',\n                   help='lesion types in mask order (CZ or PZ)')\n    p.add_argument('--output', metavar='FILENAME', required=True,\n                   help='output pmap file')\n    return p.parse_args()\n\n\ndef get_lesiontype_array(lesiontypes, lesions):\n    \"\"\"Create lesiontype array. It contains -1 or 1 depending on lesion type,\n    or zero where no lesion.\n    \"\"\"\n    lesiontype = np.zeros_like(lesions[0], dtype=np.int8)\n    if lesiontypes is not None:\n        for lt, l in zip(lesiontypes, lesions):\n            if lt.lower() == 'cz':\n                lesiontype[l] = -1\n            elif lt.lower() == 'pz':\n                lesiontype[l] = 1\n            else:\n                raise ValueError('Invalid lesiontype: {}'.format(lt))\n    log.info('Lesion types: %s, +1: %i, -1: %i', lesiontypes,\n             np.count_nonzero(lesiontype == 1),\n             np.count_nonzero(lesiontype == -1))\n    return lesiontype\n\n\ndef get_mbb(mask, spacing, pad):\n    \"\"\"Get mask minimum bounding box as slices, with minimum padding in mm.\"\"\"\n    padding = [int(np.ceil(pad \/ x)) for x in spacing]\n    physical_padding = [x * y for x, y in zip(padding, spacing)]\n    mbb = dwi.util.bounding_box(mask, padding)\n    slices = tuple(slice(*x) for x in mbb)\n    log.info('Cropping minimum bounding box, padding: %s', pad)\n    log.debug('\\tVoxel padding: %s', padding)\n    log.debug('\\tPhysical padding: %s', physical_padding)\n    log.debug('\\tMinimum bounding box: %s', mbb)\n    return slices\n\n\ndef rescale(img, src_spacing, dst_spacing):\n    \"\"\"Rescale image according to voxel spacing sequences (mm per voxel).\"\"\"\n    factor = [s\/d for s, d in zip(src_spacing, dst_spacing)]\n    log.info('Scaling by factor: %s', factor)\n    output = ndimage.interpolation.zoom(img, factor, order=0)\n    return output\n\n\ndef generate_windows(imageshape, winshape, center):\n    \"\"\"Generate slice objects for a grid of windows around given center.\n\n    Float center will be rounded. Yield a tuple with coordinate slices of each\n    window, and window position relative to the center.\n    \"\"\"\n    center = [int(round(x)) for x in center]\n    starts = [i % w for i, w in zip(center, winshape)]\n    stops = [i-w+1 for i, w in zip(imageshape, winshape)]\n    its = (range(*x) for x in zip(starts, stops, winshape))\n    for coords in product(*its):\n        slices = tuple(slice(i, i+w) for i, w in zip(coords, winshape))\n        relative = tuple(int((i-c)\/w) for i, c, w in zip(coords, center,\n                                                         winshape))\n        yield slices, relative\n\n\ndef get_datapoint(image, prostate, lesion, lesiontype, stat):\n    \"\"\"Extract output datapoint for a cube.\n\n    If stat is None, median is used. Otherwise, see dwi.texture.stats().\n    \"\"\"\n    assert image.shape == prostate.shape == lesion.shape == lesiontype.shape\n    if np.isnan(image).all():\n        value = np.nan\n    else:\n        image = image[np.isfinite(image)]  # Remove nan values.\n        if stat is None:\n            value = np.median(image)\n        else:\n            value = dwi.texture.stats(image)[stat]\n    nneg = np.count_nonzero(lesiontype < 0)\n    npos = np.count_nonzero(lesiontype > 0)\n    # Label as lesiontype -1 or 1 based on majority, or 0 if no lesion.\n    lt = 0\n    if nneg > 0:\n        lt = -1\n    if npos > nneg:\n        lt = 1\n    return (\n        np.count_nonzero(prostate) \/ prostate.size,\n        np.count_nonzero(lesion) \/ prostate.size,\n        lt,\n        value,\n        )\n\n\ndef create_grid_centroid(metric_winshape, metric_gridshape=(100, 150, 150)):\n    \"\"\"Create and fill grid array based on prostate centroid.\"\"\"\n    gridshape = [int(g\/\/w) for g, w in zip(metric_gridshape, metric_winshape)]\n    gridshape = [x + x % 2 for x in gridshape]  # Make any odds even.\n    grid = np.full(gridshape + [4], np.nan, dtype=np.float32)\n    return grid\n\n\ndef create_grid_corner(image, winshape):\n    \"\"\"Create and fill grid array based on corner.\"\"\"\n    gridshape = [i\/\/w for i, w in zip(image.shape, winshape)]\n    grid = np.full(gridshape + [4], np.nan, dtype=np.float32)\n    return grid\n\n\ndef process(image, spacing, prostate, lesion, lesiontype, metric_winshape,\n            stat, voxelsize=None, use_centroid=False):\n    \"\"\"Process one parameter.\"\"\"\n    # TODO: Should do them all at the same time.\n    # Rescale image and masks.\n    if voxelsize is not None:\n        src_spacing = spacing\n        spacing = [voxelsize] * 3\n        image = rescale(image, src_spacing, spacing)\n        prostate = prostate.astype(np.float_)\n        prostate = rescale(prostate, src_spacing, spacing)\n        prostate = dwi.util.asbool(prostate)\n        lesion = lesion.astype(np.float_)\n        lesion = rescale(lesion, src_spacing, spacing)\n        lesion = dwi.util.asbool(lesion)\n        assert image.shape == prostate.shape == lesion.shape\n        # TODO Also scale lesiontype.\n\n        phys_size = [x*y for x, y in zip(image.shape, spacing)]\n        log.info('Transformed image: %s %s', image.shape, image.dtype)\n        log.info('Voxel spacing: %s, physical size: %s', spacing, phys_size)\n\n    # Extract grid datapoints. Grid placing is based either on prostate\n    # centroid, or image corner.\n    voxel_winshape = [int(round(x\/y)) for x, y in zip(metric_winshape,\n                                                      spacing)]\n    log.debug('Window metric: %s, voxel: %s', metric_winshape, voxel_winshape)\n\n    centroid = [round(x, 2) for x in dwi.util.centroid(prostate)]\n    if use_centroid:\n        base = centroid\n        grid = create_grid_centroid(metric_winshape)\n        grid_base = [s\/\/2 for s in grid.shape]\n    else:\n        base = [0] * 3\n        grid = create_grid_corner(image, voxel_winshape)\n        grid_base = [0] * 3\n    log.debug('Prostate centroid: %s, base: %s', centroid, base)\n\n    windows = list(generate_windows(image.shape, voxel_winshape, base))\n    for slices, relative in windows:\n        indices = tuple(c+r for c, r in zip(grid_base, relative))\n        values = get_datapoint(image[slices], prostate[slices], lesion[slices],\n                               lesiontype[slices], stat)\n        grid[indices] = values\n    return grid\n\n\ndef average_image(image):\n    \"\"\"Do average filtering for image.\"\"\"\n    d = dict(size=(3, 3), mode='nearest')\n    for p in range(image.shape[-1]):\n        for i in range(image.shape[0]):\n            ix = (i, slice(None), slice(None), p)\n            image[ix] = ndimage.filters.median_filter(image[ix], **d)\n\n\ndef indexed_path(path, i):\n    \"\"\"Add an index to path before possible extension.\"\"\"\n    root, ext = os.path.splitext(path)\n    return '{r}-{i}{e}'.format(r=root, i=i, e=ext)\n\n\ndef set_loggin(verbosity=0):\n    \"\"\"Set up logging.\"\"\"\n    import sys\n    loglevel = logging.INFO if verbosity else logging.WARNING\n    logging.basicConfig(level=loglevel, stream=sys.stdout)\n\n\ndef main():\n    \"\"\"Main.\"\"\"\n    args = parse_args()\n    set_loggin(verbosity=args.verbose)\n\n    image, attrs = dwi.files.read_pmap(args.image, ondisk=True)\n    if args.param is not None:\n        image = image[..., args.param]\n        image.shape += (1,)\n        attrs['parameters'] = [attrs['parameters'][args.param]]\n    spacing = attrs['voxel_spacing']\n\n    # Read masks.\n    prostate = dwi.files.read_mask(args.prostate,\n                                   expected_voxel_spacing=spacing)\n    lesions = [dwi.files.read_mask(x, expected_voxel_spacing=spacing,\n                                   container=prostate) for x in args.lesions]\n    lesion = dwi.util.unify_masks(lesions)\n\n    assert image.shape[:3] == prostate.shape == lesion.shape\n    if args.voxelspacing is not None:\n        spacing = args.voxelspacing\n\n    phys_size = [x*y for x, y in zip(image.shape[:3], spacing)]\n    log.info('Image: %s %s', image.shape, image.dtype)\n    log.debug('Voxel spacing: %s, physical size: %s', spacing, phys_size)\n    log.debug('Lesions: %i', len(args.lesions))\n\n    lesiontype = get_lesiontype_array(args.lesiontypes, lesions)\n\n    # Crop MBB. The remaining image is stored in memory.\n    if args.mbb is None:\n        slices = tuple(slice(0, x) for x in image.shape[:3])\n    else:\n        slices = get_mbb(prostate, spacing, args.mbb)\n    image = image[slices]\n    prostate = prostate[slices]\n    lesion = lesion[slices]\n    lesiontype = lesiontype[slices]\n    assert (image.shape[:3] == prostate.shape == lesion.shape ==\n            lesiontype.shape)\n\n    # average_image(image)\n\n    assert image.ndim == 4, image.ndim\n    image = image.astype(np.float32)\n    if args.nanbg:\n        image[-prostate] = np.nan  # Set background to nan.\n\n    basic = ['prostate', 'lesion', 'lesiontype']\n    metric_winshape = [args.winsize] * 3\n    if args.param is None:\n        params = attrs['parameters']  # Use average of each parameter.\n    else:\n        params = list(dwi.texture.stats([0]).keys())  # Use statistical feats.\n    d = dict(voxelsize=args.voxelsize, use_centroid=args.use_centroid)\n    grid = None\n    for i, param in enumerate(params):\n        if args.param is None:\n            img = image[..., i]\n            stat = None\n        else:\n            img = image[..., 0]\n            stat = param\n        a = process(img, spacing, prostate, lesion, lesiontype,\n                    metric_winshape, stat, **d)\n        if grid is None:\n            shape = a.shape[0:-1] + (len(basic) + len(params),)\n            grid = np.empty(shape, dtype=a.dtype)\n            log.info('Grid shape: %s', grid.shape)\n            grid[..., 0:len(basic)] = a[..., 0:-1]  # Init with basic.\n        grid[..., len(basic)+i] = a[..., -1]  # Add each feature.\n    outfile = args.output\n    attrs = dict(n_lesions=len(args.lesions), spacing=metric_winshape)\n    attrs['parameters'] = basic + params\n    log.info('Writing %s to %s', grid.shape, outfile)\n    dwi.files.write_pmap(outfile, grid, attrs)\n\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_666","text":"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Sun Jan 23 00:27:00 2022\r\n\r\n@author: marco\r\n\"\"\"\r\nimport pandas as pd\r\nimport numpy as np\r\nimport os\r\nfrom scipy.linalg import pinv as inv\r\nimport matplotlib.pyplot as plt\r\nos.chdir('C:\/\/Users\/\/marco\/\/Desktop\/\/Projects\/\/Bayesian_OLS')\r\ncwd = os.getcwd()\r\nprint(\"Current working directory: {0}\".format(cwd))\r\nimport warnings                                  # `do not disturbe` mode\r\nwarnings.filterwarnings('ignore')\r\n\r\n#y = Puller.Banxico(serie=\"SR16734\", name=\"IGAE\", plot=False)\r\n#p = Puller.Banxico(serie=\"SP1\", name=\"Inflation\", plot=False)\r\n#r = Puller.Banxico(serie=\"SF3270\", name=\"Interest_rate\", plot=False)\r\n#m = Puller.Banxico(serie=\"SF1\", name=\"Money\", plot=False)\r\n#df = pd.concat([y, p, r, m], axis=1).dropna()\r\ndf = pd.read_excel('inflation.xls', index_col=0)\r\n\r\nY=df.iloc[:,0:1].to_numpy()\r\nX=df.iloc[:,1:].to_numpy()\r\n\r\ndef plot_dist(df, column, title):\r\n    mu = df[column].mean()\r\n    sigma = df[column].std()\r\n    n, bins, patches = plt.hist(x=df[column], bins='auto', \r\n                                color='#0504aa',\r\n                                alpha=0.7, rwidth=0.85)\r\n    plt.grid(axis='y', alpha=0.75)\r\n    plt.ylabel(None)\r\n    plt.title(title)\r\n    maxfreq = n.max()\r\n    plt.ylim(ymax=np.ceil(maxfreq \/ 10) * 10 if (maxfreq % 10 > 0) else maxfreq + 10)\r\n    plt.show() #plot\r\n    \r\ndef ar_companion_matrix(beta):\r\n    # dont include constant\r\n    k = beta.shape[0]-1\r\n    FF = np.zeros((k, k))\r\n    #insert identity matrix\r\n    FF[1:k, 0:(k-1)] = np.eye(N=k-1, M=k-1)\r\n    temp = (beta[1:k+1, :]).T\r\n    #state space companion form\r\n    #Insert coeffcients along top row\r\n    FF[0:1,0:k+1] = temp\r\n    return(FF)\r\n\r\ndef gibbs(X,Y,reps,burn,t0,d0,plot):\r\n    reps = reps # number of Gibbs iterations\r\n    burn = burn # percent of burn-in iterations\r\n    out  = np.zeros((reps, X.shape[1]+1))\r\n    t1  = Y.shape[0]  #number of observations\r\n    b0 =  np.zeros((X.shape[1],1))#Priors\r\n    sigma0 = np.eye((X.shape[1])) # variance matrix\r\n    # priors for sigma2\r\n    t0 = t0\r\n    d0 = d0\r\n    # Starting values\r\n    B = b0\r\n    sigma2 = 1\r\n    for i in range(0,reps):\r\n        M = inv(inv(sigma0) + (1\/sigma2) * X.T @ X) @ (inv(sigma0) @ b0 + (1\/sigma2)* X.T @ Y)\r\n        V = inv(inv(sigma0) + (1\/sigma2) * X.T @ X)\r\n        chck = -1\r\n        while (chck < 1):\r\n            B = M + (np.random.normal(0,1,X.shape[1]) @ np.linalg.cholesky(V)).T.reshape(-1,1)\r\n            b = ar_companion_matrix(B)\r\n            ee = np.max(np.abs(np.linalg.eig(b)[1]))\r\n            if (ee <= 1):\r\n                chck = 1\r\n        # compute residuals\r\n        resids = Y - X @ B\r\n        T2 = t0 + t1\r\n        D1 = d0 + resids.T @ resids\r\n        # keep samples after burn period\r\n        out[i,] = np.append(B.T,sigma2)\r\n        #draw from Inverse Gamma\r\n        z0 = np.random.normal(1,1,t1)\r\n        z0z0 = z0.T @ z0\r\n        sigma2 = D1\/z0z0\r\n    \r\n    out = pd.DataFrame(out[burn:reps,:])\r\n    \r\n    if plot==True:\r\n        for i in range(0,out.shape[1]):\r\n            if i != out.shape[1]-1:\r\n                plot_dist(df=out, column=[i], title='Estimator distribution of beta ' + str(i))\r\n            else:\r\n                plot_dist(df=out, column=[i], title='Estimator distribution of the variance')\r\n        \r\n    return(out)\r\n\r\n\r\ngibbs(X=X,Y=Y,reps=5000,burn=4000,t0 = 1,d0 = 0.1, plot=True)\r\n\r\n\r\n\r\n'''\r\ngibbs_sampler <- function(X,Y,B0,sigma0,sigma2,theta0,D0,reps,out,out1){\r\n  for (i in 1:reps){\r\n    \r\n    M = solve(solve(sigma0)\r\n              +as.numeric(1\/sigma2)*t(X)%*%X)%*%(solve(sigma0)%*%b0\r\n              +as.numeric(1\/sigma2)*t(X)%*%Y)\r\n    V = solve(solve(sigma0)+as.numeric(1\/sigma2)*t(X)%*%X)\r\n    chck=-1\r\n    while (chck < 1){ #check for stability\r\n      \r\n      B= M+t(rnorm(ncol(X))%*%chol(V))\r\n      b = ar_companion_matrix(B)\r\n      ee <- max(sapply(eigen(b)$values,abs))\r\n      if(ee<=1){\r\n      }\r\n    }\r\n    # compute residuals\r\n    resids <- Y- X%*%B\r\n    T2 = t0 + t1\r\n    D1 = d0 + t(resids) %*% resids\r\n    \r\n    # keeps samples after burn period\r\n    out[i,] <- t(matrix(c(t(B),sigma2)))\r\n    \r\n    #draw from Inverse Gamma\r\n    z0 = rnorm(t1,1)\r\n    z0z0 = t(z0) %*% z0\r\n    sigma2 = D1\/z0z0\r\n    \r\n    # compute 2 year forecasts\r\n    yhat = rep(0,h)\r\n    end = as.numeric(length(Y))\r\n    #yhat[1:2] = Y[(end-1):end,]\r\n    cfactor = sqrt(sigma2)\r\n    X_mat = c(1,rep(0,ncol(X)-1))\r\n    \r\n    \r\n    for(m in ncol(X):h){\r\n      for (lag in 1:(ncol(X)-1)){\r\n        #create X matrix with p lags\r\n        X_mat[(lag+1)] = yhat[m-lag]\r\n      }\r\n      # Use X matrix to forecast yhat\r\n      yhat[m] = X_mat %*% B + rnorm(1) * cfactor\r\n    }\r\n    \r\n    out1[i,] <- yhat\r\n  }\r\n  return = list(out,out1)\r\n}\r\n    \r\n    \r\n# Set the parameters\r\nreps = 5000 # number of Gibbs iterations\r\nburn = 4000 # percent of burn-in iterations\r\n\r\n# Forecast horizon\r\nh = 24\r\n\r\n# Matrix to store posterior coefficients and forecasts\r\nout  = matrix(0, nrow = reps, ncol = ncol(X_BO) + 1)\r\nout1 = matrix(0, nrow = reps, ncol = h)\r\n\r\nt1 <- nrow(Y_CA) #number of observations\r\nb0 = matrix(0,ncol(X_CA),1) #Priors\r\nsigma0 <- diag(ncol(X_CA)) # variance matrix\r\n# priors for sigma2\r\nt0= 1\r\nd0=0.1\r\n\r\n# Starting values\r\nB = b0\r\nsigma2 = 1\r\ndf1 = gibbs_sampler(X_CA,Y_CA, B,sigma0,sigma2,t0,d0,reps,out,out1)\r\n\r\ncoef <- results[[1]][(burn+1):reps,]\r\nforecasts <- results[[2]][(burn+1):reps,]\r\n\r\n\r\nconst <- mean(coef[,1])\r\nbeta1 <- mean(coef[,2])\r\nbeta2 <- mean(coef[,3])\r\nbeta3 <- mean(coef[,4])\r\nsigma <- mean(coef[,5])"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_667","text":"<gh_stars>1-10\nimport numpy as np\r\nimport infomap\r\nimport pandas as pd\r\nimport scipy\r\nfrom tqdm import tqdm\r\nimport networkx as nx\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.colors as colors\r\nfrom scipy.signal import lfilter\r\nimport warnings\r\n\r\nfrom tqdm import tqdm_notebook\r\nfrom functools import reduce\r\nwarnings.filterwarnings('ignore')\r\n\r\ndef cluster_counts(labels,features):\r\n    cluster_indexes=[]\r\n    for c in np.unique(labels):\r\n        cluster_indexes.append(np.where(np.array(labels)==c))\r\n    clusters_features=[]\r\n    for cluster in cluster_indexes:\r\n      # print(cluster)\r\n      cluster_features=[features[j] for j in cluster[0] ]\r\n      clusters_features.append(cluster_features)\r\n    return cluster_indexes,clusters_features\r\n\r\ndef distances_calculations(features_vectors):\r\n    distances=[]\r\n    n=15\r\n    b = [1.0 \/ n] * n\r\n    a = 1\r\n    for vector1 in tqdm(features_vectors):\r\n        distance=[]\r\n        for vector2 in features_vectors:\r\n            distance.append(scipy.linalg.norm(vector1-vector2,2))\r\n        distances.append(lfilter(b,a,distance))\r\n    return distances\r\ndef weights_init(distances_total):\r\n  weights=[]\r\n  for dist in tqdm(distances_total):\r\n      w=[]\r\n      for d in (dist):\r\n          w.append(1\/(0.01+d))\r\n      weights.append(w)\r\n  return weights\r\n\r\nimport pickle\r\ndef save_pkl(variable, name):\r\n    name = name + '.pkl'\r\n    output = open(name, 'wb')\r\n    pickle.dump(variable, output)\r\n    output.close()\r\ndef findCommunities(G):\r\n    \"\"\"\r\n    Partition network with the Infomap algorithm.\r\n    Annotates nodes with 'community' id.\r\n    \"\"\"\r\n\r\n    im = infomap.Infomap(\"--two-level\")\r\n\r\n    print(\"Building Infomap network from a NetworkX graph...\")\r\n    for source, target in G.edges:\r\n        im.add_link(source, target)\r\n\r\n    print(\"Find communities with Infomap...\")\r\n    im.run()\r\n\r\n    print(f\"Found {im.num_top_modules} modules with codelength: {im.codelength}\")\r\n\r\n    communities = im.get_modules()\r\n    nx.set_node_attributes(G, communities, 'community')\r\n\r\n\r\n#create function for  clearence inside the cluster, by euclidian distance\r\ndef new_weights(weights):\r\n  weights_new=[]\r\n  for weight in weights:\r\n    w=weight.copy()\r\n    w=np.array(w)\r\n    w[w<(np.median(w)+np.std(w))]=0\r\n    weights_new.append(w)\r\n  return weights_new\r\n\r\ndef cluster_clearence(cluster_feature_vector:list):\r\n    print(len(cluster_feature_vector))\r\n    distance=[]\r\n    for vector_1 in tqdm_notebook(cluster_feature_vector):\r\n        dist=[]\r\n        for vector_2 in cluster_feature_vector:\r\n            dist.append(np.linalg.norm(vector_1-vector_2,2))\r\n        dist=np.mean(dist)\r\n        distance.append(dist)\r\n    return np.mean(distance)\r\n\r\ndef cluster_creation(distances:list,features_all:list,features:list,inter:int,treshold:float):\r\n  final_clusters=[]\r\n\r\n  weights=weights_init(distances)\r\n  weights_new=new_weights(weights)\r\n\r\n  weights_matrix=np.matrix(weights_new)\r\n  Graph=nx.DiGraph(weights_matrix)\r\n  findCommunities(Graph)\r\n  communities = [v for k,v in nx.get_node_attributes(Graph, 'community').items()]\r\n # print('number of clusters:', np.unique(communities))\r\n  clusters,cluster_features=cluster_counts(communities,features_all)\r\n\r\n  # clusters=[cluster[0] for cluster in clusters ]\r\n  # vectors=[distances for i in range(len(clusters))]\r\n  distance=list(map(cluster_clearence,cluster_features))\r\n  if np.isnan(np.array(distance)).any() == True:\r\n    print('DETECTED NAN')\r\n    a=np.argwhere(np.isnan(distance))\r\n   # print(a)\r\n    distance.pop(a[0][0])\r\n    cluster_features.pop(a[0][0])\r\n\r\n  print('clearence of clusters',distance)\r\n  \r\n  bad_clusters=[]\r\n  for i in range(len(distance)):\r\n    \r\n    if distance[i]<=treshold:\r\n      final_clusters.append(cluster_features[i])\r\n    else:\r\n      bad_clusters.append(cluster_features[i])\r\n  cluster_length=len(bad_clusters)\r\n\r\n  i=0\r\n  # for i in range(len(bad_clusters)):\r\n  final_bad_clusters=[]\r\n  while i<cluster_length:\r\n    #print('ITERATION '+str(i),'Total quantaty of clusters:',len(bad_clusters))\r\n    #print(\"___\"*20)\r\n    small_features=bad_clusters[i]\r\n    small_vectors=distances_calculations(small_features)\r\n\r\n    weights=weights_init(small_vectors)\r\n    weights_new=new_weights(weights)\r\n    \r\n    weights_matrix=np.matrix(weights_new)\r\n    \r\n    Graph=nx.DiGraph(weights_matrix)\r\n    findCommunities(Graph)\r\n    communities = [v for k,v in nx.get_node_attributes(Graph, 'community').items()]\r\n    #print('number of mini clusters in cluster '+str(i), np.unique(communities))\r\n\r\n    clusters,cluster_features=cluster_counts(communities,small_features)\r\n\r\n    # clusters=[cluster[0] for cluster in clusters ]\r\n    # vectors=[small_vectors for vec in range(len(clusters))]\r\n    distance=list(map(cluster_clearence,cluster_features))\r\n    if np.isnan(np.array(distance)).any() == True:\r\n      print('DETECTED NAN')\r\n      a=np.argwhere(np.isnan(distance))\r\n      distance.pop(a[0][0])\r\n      cluster_features.pop(a[0][0])\r\n    print('clearence of mini clusters',distance)\r\n\r\n    for m in range(len(distance)):\r\n      if distance[m]<=treshold:\r\n        final_clusters.append(cluster_features[m])\r\n      elif i<=inter and distance[m]>treshold:\r\n        bad_clusters.append(cluster_features[m])\r\n\r\n      elif i>inter and distance[m]>treshold:\r\n        final_bad_clusters.append(cluster_features[m])\r\n      \r\n    cluster_length=len(bad_clusters)\r\n    print(cluster_length)\r\n    i=i+1\r\n   \r\n  bad_clusters_vectors=np.concatenate(final_bad_clusters)\r\n  bad_vectors=distances_calculations(bad_clusters_vectors)\r\n\r\n  weights=weights_init(bad_vectors)\r\n  weights_new=new_weights(weights)\r\n\r\n  weights_matrix=np.matrix(weights_new)\r\n  Graph=nx.DiGraph(weights_matrix)\r\n  findCommunities(Graph)\r\n  communities = [v for k,v in nx.get_node_attributes(Graph, 'community').items()]\r\n\r\n # print('number of mini clusters in cluster '+str(i), np.unique(communities))\r\n\r\n  clusters,cluster_features=cluster_counts(communities,bad_clusters_vectors)\r\n\r\n  \r\n  bad_clusters=[]\r\n  for i in range(len(distance)):\r\n    \r\n    if distance[i]<=treshold:\r\n      final_clusters.append(cluster_features[i])\r\n    else:\r\n      bad_clusters.append(cluster_features[i])\r\n  cluster_length=len(bad_clusters)\r\n  i=0\r\n # print('CLUSTERS from bad')\r\n  final_bad_clusters=[]\r\n  while i<cluster_length:\r\n   # print('ITERATION '+str(i),'Total quantaty of clusters from bad cluster:',len(bad_clusters))\r\n    #print(\"___\"*20)\r\n    small_features=bad_clusters[i]\r\n    small_vectors=distances_calculations(small_features)\r\n    \r\n    weights=weights_init(small_vectors)\r\n    weights_new=new_weights(weights)\r\n\r\n    weights_matrix=np.matrix(weights_new)\r\n    Graph=nx.DiGraph(weights_matrix)\r\n    findCommunities(Graph)\r\n    communities = [v for k,v in nx.get_node_attributes(Graph, 'community').items()]\r\n    #print('number of mini clusters in cluster '+str(i), np.unique(communities))\r\n\r\n    clusters,cluster_features=cluster_counts(communities,small_features)\r\n\r\n    # clusters=[cluster[0] for cluster in clusters ]\r\n    # vectors=[small_vectors for vec in range(len(clusters))]\r\n    distance=list(map(cluster_clearence,cluster_features))\r\n    if np.isnan(np.array(distance)).any() == True:\r\n      #print('DETECTED NAN')\r\n      a=np.argwhere(np.isnan(distance))\r\n      distance.pop(a[0][0])\r\n      cluster_features.pop(a[0][0])\r\n    #print('clearence of mini clusters from bad clusters',distance)\r\n\r\n    for m in range(len(distance)):\r\n      if distance[m]<=treshold:\r\n        final_clusters.append(cluster_features[m])\r\n      elif i<=inter and distance[m]>treshold:\r\n        bad_clusters.append(cluster_features[m])\r\n\r\n      elif i>inter and distance[m]>treshold:\r\n        final_bad_clusters.append(cluster_features[m])\r\n      \r\n    cluster_length=len(bad_clusters)\r\n    # print(cluster_length)\r\n    i=i+1\r\n \r\n  return final_clusters,final_bad_clusters\r\n\r\ndef final_cluster(features,cluster_feature):\r\n  final_clusters=[]\r\n  for feature_vector in cluster_feature:\r\n    cluster=[]\r\n    for vector in feature_vector:\r\n      bc=np.bincount(np.where(features==vector)[0])\r\n      cluster.append(bc.argmax())\r\n    final_clusters.append(cluster)\r\n  return final_clusters"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_668","text":"\"\"\"\nFilename: oligopoly.py\nAuthors: <NAME>, <NAME>, <NAME>\nThis is an example for the lecture dyn_stack.rst from the QuantEcon\nseries of lectures by <NAME> and <NAME>.\nWe deal with a large monopolistic firm who faces costs:\nC_t = e Q_t + .5 g Q_t^2 + .5 c (Q_{t+1} - Q_t)^2\nwhere the fringe firms face:\nsigma_t = d q_t + .5 h q_t^2 + .5 c (q_{t+1} - q_t)^2\nAdditionally, there is a linear inverse demand curve of the form:\np_t = A_0 - A_1 (Q_t + \\bar{q_t}) + \\eta_t,\nwhere:\n.. math\n    \\eta_{t+1} = \\rho \\eta_t + C_{\\varepsilon} \\varepsilon_{t+1};\n    \\varepsilon_{t+1} \\sim N(0, 1)\nFor more details, see the lecture.\n\"\"\"\nimport numpy as np\nimport scipy.linalg as la\nfrom quantecon import LQ\nfrom quantecon.matrix_eqn import solve_discrete_lyapunov\nfrom scipy.optimize import root\n\n\ndef setup_matrices(params):\n    \"\"\"\n    This function sets up the A, B, R, Q for the oligopoly problem\n    described in the lecture.\n    Parameters\n    ----------\n    params : Array(Float, ndim=1)\n        Contains the parameters that describe the problem in the order\n        [a0, a1, rho, c_eps, c, d, e, g, h, beta]\n    Returns\n    -------\n    (A, B, Q, R) : Array(Float, ndim=2)\n        These matrices describe the oligopoly problem.\n    \"\"\"\n\n    # Left hand side of (37)\n    Alhs = np.eye(5)\n    Alhs[4, :] = np.array([a0-d, 1., -a1, -a1-h, c])\n    Alhsinv = la.inv(Alhs)\n\n    # Right hand side of (37)\n    Brhs = np.array([[0., 0., 1., 0., 0.]]).T\n    Arhs = np.eye(5)\n    Arhs[1, 1] = rho\n    Arhs[3, 4] = 1.\n    Arhs[4, 4] = c \/ beta\n\n    # R from equation (40)\n    R = np.array([[0., 0., (a0-e)\/2., 0., 0.],\n                  [0., 0., 1.\/2., 0., 0.],\n                  [(a0-e)\/2., 1.\/2, -a1 - .5*g, -a1\/2, 0.],\n                  [0., 0., -a1\/2, 0., 0.],\n                  [0., 0., 0., 0., 0.]])\n\n    Rf = np.array([[0., 0., 0., 0., 0., (a0-d)\/2.],\n                  [0., 0., 0., 0., 0., 1.\/2.],\n                  [0., 0., 0., 0., 0., -a1\/2.],\n                  [0., 0., 0., 0., 0., -a1\/2.],\n                  [0., 0., 0., 0., 0., 0.],\n                  [(a0-d)\/2., 1.\/2., -a1\/2., -a1\/2., 0., -h\/2.]])\n\n    Q = np.array([[c\/2]])\n\n    A = Alhsinv.dot(Arhs)\n    B = Alhsinv.dot(Brhs)\n\n    return A, B, Q, R, Rf\n\n\ndef find_PFd(A, B, Q, R, Rf, beta=.95):\n    \"\"\"\n    Taking the parameters A, B, Q, R as found in the `setup_matrices`,\n    we find the value function of the optimal linear regulator problem.\n    This is steps 2 and 3 in the lecture notes.\n    Parameters\n    ----------\n    (A, B, Q, R) : Array(Float, ndim=2)\n        The matrices that describe the oligopoly problem\n    Returns\n    -------\n    (P, F, d) : Array(Float, ndim=2)\n        The matrix that describes the value function of the optimal\n        linear regulator problem.\n    \"\"\"\n\n    lq = LQ(Q, -R, A, B, beta=beta)\n    P, F, d = lq.stationary_values()\n\n    Af = np.vstack((np.hstack([A-np.dot(B,F), np.array([[0., 0., 0., 0., 0.]]).T]),np.array([[0., 0., 0., 0., 0., 1.]])))\n    Bf = np.array([[0., 0., 0., 0., 0., 1.]]).T\n\n    lqf = LQ(Q, -Rf, Af, Bf, beta=beta)\n    Pf, Ff, df = lqf.stationary_values()\n\n    return P, F, d, Pf, Ff, df\n\n\ndef solve_for_opt_policy(params, eta0=0., Q0=0., q0=0.):\n    \"\"\"\n    Taking the parameters as given, solve for the optimal decision rules\n    for the firm.\n    Parameters\n    ----------\n    params : Array(Float, ndim=1)\n        This holds all of the model parameters in an array\n    Returns\n    -------\n    out :\n    \"\"\"\n    # Step 1\/2: Formulate\/Solve the optimal linear regulator\n    (A, B, Q, R, Rf) = setup_matrices(params)\n    (P, F, d, Pf, Ff, df) = find_PFd(A, B, Q, R, Rf, beta=beta)\n\n    # Step 3: Convert implementation into state variables (Find coeffs)\n    P22 = P[-1, -1]\n    P21 = P[-1, :-1]\n    P22inv = P22**(-1)\n\n    # Step 4: Find optimal x_0 and \\mu_{x, 0}\n    z0 = np.array([1., eta0, Q0, q0])\n    x0 = -P22inv*np.dot(P21, z0)\n    D0 = -np.dot(P22inv, P21)\n\n    # Return -F and -Ff because we use u_t = -F y_t\n    return P, -F, D0, Pf, -Ff\n\n\n# Parameter values\na0 = 100.\na1 = 1.\nrho = .8\nc_eps = .2\nc = 1.\nd = 20.\ne = 20.\ng = .2\nh = .2\nbeta = .95\nparams = np.array([a0, a1, rho, c_eps, c, d, e, g, h, beta])\n\n\nP, F, D0, Pf,Ff  = solve_for_opt_policy(params)\n\n\n# Checking time-inconsistency:\nA, B, Q, R, Rf = setup_matrices(params)\n# arbitrary initial z_0\ny0 = np.array([[1, 1, 1, 1]]).T\n# optimal x_0 = i_0\ni0 = np.dot(D0,y0)\n# iterate one period using the closed-loop system\ny1 = np.dot( A + np.dot(B,F) , np.vstack([y0, i0]) )\n# the last element of y_1 is x_1 = i_1\ni1_0 = y1[-1,0]\n\n# compare this to the case when the leader solves a Stackelberg problem\n# in period 1. if in period 1 the leader could choose i1 given\n# (1, v_1, Q_1, \\bar{q}_1)\ni1_1 = np.dot(D0, y1[0:-1,0])\n\n\nprint(\"P = {}\".format(P))\nprint(\"-F = {}\".format(F))\nprint(\"D0 = {}\".format(D0))\nprint(\"Pf = {}\".format(Pf))\nprint(\"-Ff = {}\".format(Ff))\nprint(\"i1_0 = {}\".format(i1_0))\nprint(\"i1_1 = {}\".format(i1_1))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_669","text":"from scipy import optimize\nimport scipy\nimport numpy\nimport matplotlib.pyplot as plt\n\ndef func(x, a, b):\n        return a + b * numpy.log2(x)\n\ndef create_graph():\n    with open('.\/results_n.txt') as f:\n        y_pts_n = f.read().splitlines()\n    with open('.\/results_n_2.txt') as f:\n        y_pts_n_2 = f.read().splitlines()\n    with open('.\/results_log_p.txt') as f:\n        y_pts_log_p = f.read().splitlines()\n\n    line_n, _ = scipy.optimize.curve_fit(lambda t,a,b: a+b*numpy.log2(t), range(2, 25, 2),  y_pts_n)\n    line_n_2, _ = scipy.optimize.curve_fit(lambda t,a,b: a+b*numpy.log2(t), range(2, 49, 2),  y_pts_n_2)\n    line_log_p, _ = scipy.optimize.curve_fit(lambda t,a,b: a+b*numpy.log2(t), range(2, 111, 2),  y_pts_log_p)\n\n    fig, ax = plt.subplots()\n    # ax.plot(range(2, 25, 2), y_pts_n, linestyle='None', marker='o', color='b', label=r\"$p(n) = n$\")\n    ax.plot(range(2, 111, 2), func(range(2, 111, 2), *line_n),\n            linewidth=2.0, linestyle='-', color='b', label=r\"$Fitted Curve: n$\"\n    )\n    # ax.plot(range(2, 49, 2), y_pts_n_2,\n    #         linestyle='None', marker='o', color='r',  label=r\"$p(n) = \\frac{n}{2}$\"\n    # )\n    ax.plot(range(2, 111, 2), func(range(2, 111, 2), *line_n_2),\n            linewidth=2.0, linestyle='-', color='r', label=r\"$Fitted Curve: \\frac{n}{2}$\"\n    )\n    # ax.plot(range(2, 111, 2), y_pts_log_p,\n    #         linestyle='None', marker='o', color='g', label=r\"$p(n) = \\frac{n}{p} \\geq \\log \\, p$\"\n    # )\n    ax.plot(range(2, 111, 2), func(range(2, 111, 2), *line_log_p),\n        linewidth=2.0, linestyle='-', color='g', label=r\"$Fitted Curve: \\frac{n}{p} \\geq \\log \\, p$\"\n    )\n    ax.set(xlabel='n - points count', ylabel=r'time $(\\mu s)$',\n           title='Line-of-Sight')\n    ax.grid()\n    ax.set_ylim(ymin=0)\n    ax.legend(loc=\"upper left\")\n    fig.savefig(\"common_graph.pdf\", format=\"pdf\")\n    plt.show()\n\nif __name__ == '__main__':\n    create_graph()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_670","text":"import sympy\nimport argparse\nimport numpy as np\n\nimport equations\nimport data\n# from dsr_utils import run_dsr\nfrom gp_utils import run_gp\nfrom interpolate import num_diff, num_diff_gp\nimport pickle\nimport os\nimport time\n\n# # set up ODE config\n# ode_param = None\n# x_id = 0\n#\n# # data generation config\n# freq = 10\n# n_sample = 100\n# noise_sigma = 0.0\n#\n# # set up algorithm config\n# alg = 'gp'\n\ndef run(ode_name, ode_param, x_id, freq, n_sample, noise_ratio, alg, seed, n_seed):\n    np.random.seed(999)\n    print(freq)\n\n    ode = equations.get_ode(ode_name, ode_param)\n    T = ode.T\n    init_low = ode.init_low\n    init_high = ode.init_high\n    has_coef = ode.has_coef\n\n    noise_sigma = ode.std_base * noise_ratio\n\n    dg = data.DataGenerator(ode, T, freq, n_sample, noise_sigma, init_low, init_high)\n    yt = dg.generate_data()\n\n    if noise_sigma == 0:\n        dxdt_hat = (yt[1:, :, :] - yt[:-1, :, :]) \/ (dg.solver.t[1:] - dg.solver.t[:-1])[:, None, None]\n    elif alg != 'gp':\n        dxdt_hat = num_diff(yt, dg, alg)\n    else:\n        dxdt_hat, xt_hat = num_diff_gp(yt, dg, ode)\n\n    print('Numerical differentiation: Done.')\n\n    # if alg != 'gp':\n    X_train = yt[:-1, :, :]\n    # else:\n    #     X_train = xt_hat[:-1, :, :]\n    X_train = X_train.reshape(X_train.shape[0] * X_train.shape[1], X_train.shape[2])\n\n    y_train = dxdt_hat[:, :, x_id].flatten()\n    assert X_train.shape[0] == y_train.shape[0]\n\n    if alg == 'tv':\n        path_base = 'results\/{}\/noise-{}\/sample-{}\/freq-{}\/'.format(ode_name, noise_ratio, n_sample, freq)\n    elif alg == 'gp':\n        path_base = 'results_gp\/{}\/noise-{}\/sample-{}\/freq-{}\/'.format(ode_name, noise_ratio, n_sample, freq)\n    else:\n        path_base = 'results_spline\/{}\/noise-{}\/sample-{}\/freq-{}\/'.format(ode_name, noise_ratio, n_sample, freq)\n\n    if not os.path.isdir(path_base):\n        os.makedirs(path_base)\n\n    for s in range(seed, seed+n_seed):\n        print(' ')\n        print('Running with seed {}'.format(s))\n        if x_id == 0:\n            path = path_base + 'grad_seed_{}.pkl'.format(s)\n        else:\n            path = path_base + 'grad_x_{}_seed_{}.pkl'.format(x_id, s)\n\n        if os.path.isfile(path):\n            print('Skipping seed {}'.format(s))\n            continue\n        start = time.time()\n        f_hat, est_gp = run_gp(X_train, y_train, ode, x_id, s)\n        print(f_hat)\n        f_true = ode.get_expression()[x_id]\n        if not isinstance(f_true, tuple):\n            correct = sympy.simplify(f_hat - f_true) == 0\n        else:\n            correct_list = [sympy.simplify(f_hat - f) == 0 for f in f_true]\n            correct = max(correct_list) == 1\n\n        end = time.time()\n\n        with open(path, 'wb') as f:\n            pickle.dump({\n                'model': est_gp._program,\n                'X_train': X_train,\n                'y_train': y_train,\n                'seed': s,\n                'correct': correct,\n                'f_hat': f_hat,\n                'ode': ode,\n                'noise_ratio': noise_ratio,\n                'noise_sigma': noise_sigma,\n                'dg': dg,\n                'time': end-start,\n            }, f)\n\n        print(f_hat)\n        print(correct)\n\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser()\n    parser.add_argument(\"--ode_name\", help=\"name of the ode\", type=str)\n    parser.add_argument(\"--ode_param\", help=\"parameters of the ode (default: None)\", type=str, default=None)\n    parser.add_argument(\"--x_id\", help=\"ID of the equation to be learned\", type=int, default=0)\n    parser.add_argument(\"--freq\", help=\"sampling frequency\", type=float, default=10)\n    parser.add_argument(\"--n_sample\", help=\"number of trajectories\", type=int, default=100)\n    parser.add_argument(\"--noise_sigma\", help=\"noise level (default 0)\", type=float, default=0.)\n    parser.add_argument(\"--alg\", help=\"name of the benchmark\", type=str, default='tv', choices=['tv', 'spline', 'gp'])\n    parser.add_argument(\"--seed\", help=\"random seed\", type=int, default=0)\n    parser.add_argument(\"--n_seed\", help=\"random seed\", type=int, default=10)\n\n    args = parser.parse_args()\n    print('Running with: ', args)\n\n    if args.ode_param is not None:\n        param = [float(x) for x in args.ode_param.split(',')]\n    else:\n        param = None\n    if args.freq >= 1:\n        freq = int(args.freq)\n    else:\n        freq = args.freq\n    run(args.ode_name, param, args.x_id, freq, args.n_sample, args.noise_sigma, args.alg, seed=args.seed, n_seed=args.n_seed)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_671","text":"<reponame>bigpeng2012\/CarND-Vehicle-Detection<filename>Vehicle_Detection_Tracking.py\n#!\/usr\/bin\/env python\n# coding: utf-8\n\n# # P5 Vehicle Detection\n\n# ## The goals \/ steps of this project are the following:\n# \n# 1.Perform a Histogram of Oriented Gradients (HOG) feature extraction on a labeled training set of images and train a classifier Linear SVM classifier\n# \n# 2.Optionally, you can also apply a color transform and append binned color features, as well as histograms of color, to your HOG feature vector.\n# \n# 3.Note: for those first two steps don't forget to normalize your features and randomize a selection for training and testing.\n# \n# 4.Implement a sliding-window technique and use your trained classifier to search for vehicles in images.\n# \n# 5.Run your pipeline on a video stream (start with the test_video.mp4 and later implement on full project_video.mp4) and create a heat map of recurring detections frame by frame to reject outliers and follow detected vehicles.\n# \n# 6.Estimate a bounding box for vehicles detected.\n\n# In[1]:\n\n\nimport cv2\nimport glob\nimport numpy as np\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nimport time\n\nfrom random import shuffle\n\nfrom skimage.feature import hog\nfrom sklearn.svm import LinearSVC\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.model_selection import train_test_split\nfrom scipy.ndimage.measurements import label\n\nfrom sklearn.preprocessing import StandardScaler\nfrom tqdm import tqdm\n\nfrom moviepy.editor import VideoFileClip\nfrom IPython.display import HTML\n\nget_ipython().run_line_magic('matplotlib', 'inline')\n\n\n# ### Load Data\n\n# In[2]:\n\n\ncar_images = glob.glob('vehicles\/**\/*.png')\nnoncar_images = glob.glob('non-vehicles\/**\/*.png')\nprint(len(car_images), len(noncar_images))\n\n\n# ### Visualize Data Example\n\n# In[3]:\n\n\nfig, axs = plt.subplots(2,8, figsize=(8, 3))\n#fig.subplots_adjust(hspace = .2, wspace=.001)\naxs = axs.ravel()\n\n\nfor i in np.arange(8):\n    img = cv2.imread(car_images[np.random.randint(0,len(car_images))])\n    img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)\n    axs[i].axis('off')\n    axs[i].set_title('car', fontsize=15)\n    axs[i].imshow(img)\nfor i in np.arange(8,16):\n    img = cv2.imread(noncar_images[np.random.randint(0,len(noncar_images))])\n    img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)\n    axs[i].axis('off')\n    axs[i].set_title('noncar', fontsize=15)\n    axs[i].imshow(img)\n\n\n# ## Feature Extraction\n\n# ### Histogram of Oriented Gradient (HOG) Features\n\n# In[4]:\n\n\ndef get_hog_features(img, orient, pix_per_cell, cell_per_block, \n                        vis=False, feature_vec=True):\n    # Call with two outputs if vis==True\n    if vis == True:\n        features, hog_image = hog(img, orientations=orient, \n                                  pixels_per_cell=(pix_per_cell, pix_per_cell),\n                                  cells_per_block=(cell_per_block, cell_per_block), \n                                  transform_sqrt=False, \n                                  visualise=True, feature_vector=False)\n        return features, hog_image\n    # Otherwise call with one output\n    else:      \n        features = hog(img, orientations=orient, \n                       pixels_per_cell=(pix_per_cell, pix_per_cell),\n                       cells_per_block=(cell_per_block, cell_per_block), \n                       transform_sqrt=False, \n                       visualise=False, feature_vector=feature_vec)\n        return features\n\n\n# ### Example of HOG Features\n\n# In[5]:\n\n\n# Generate a random index to look at a car image\nind = np.random.randint(0, len(car_images))\n# Read in the image\nimage = mpimg.imread(car_images[ind])\ngray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n# Define HOG parameters\norient = 10\npix_per_cell = 8\ncell_per_block = 2\n# Call our function with vis=True to see an image output\nfeatures, hog_image = get_hog_features(gray, orient, \n                        pix_per_cell, cell_per_block, \n                        vis=True, feature_vec=False)\n\n# Plot the examples\nfig = plt.figure(figsize = (15,20))\nplt.subplot(121)\nplt.imshow(image, cmap='gray')\nplt.title('Example Car Image')\nplt.subplot(122)\nplt.imshow(hog_image, cmap='gray')\nplt.title('HOG Visualization')\nplt.savefig('output_images\/hog_visualization.png', \n            bbox_inches=\"tight\")\n\n\n# ### Histogram of Color \n\n# In[6]:\n\n\ndef color_hist(img, nbins=32, bins_range=(0, 256), vis=False):\n    \n    bins_range=(0, 256)\n    # Compute the histogram of the color channels separately\n    channel1_hist = np.histogram(img[:,:,0], bins=nbins, range=bins_range)\n    channel2_hist = np.histogram(img[:,:,1], bins=nbins, range=bins_range)\n    channel3_hist = np.histogram(img[:,:,2], bins=nbins, range=bins_range)\n    \n    # Generating bin centers\n    bin_edges = channel1_hist[1] #all three bins are the same size\n    bin_centers = (bin_edges[1:] + bin_edges[0:len(bin_edges) - 1])\/2\n    \n    hist_features = np.concatenate((channel1_hist[0],\n                                    channel2_hist[0],\n                                    channel3_hist[0]))\n    if vis == True:\n        return channel1_hist, channel2_hist, channel3_hist, bin_centers\n    else:\n        return hist_features\n\n\n# ### Spatial Binning of Color\n\n# In[7]:\n\n\ndef bin_spatial(img, color_space='RGB', size=(32, 32)):\n    # Convert image to new color space (if specified)\n    if color_space != 'RGB':\n        if color_space == 'HSV':\n            feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n        elif color_space == 'LUV':\n            feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2LUV)\n        elif color_space == 'HLS':\n            feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)\n        elif color_space == 'YUV':\n            feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YUV)\n        elif color_space == 'YCrCb':\n            feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\n    else: feature_image = np.copy(img)             \n    # Use cv2.resize().ravel() to create the feature vector\n    features = cv2.resize(feature_image, size).ravel() \n    # Return the feature vector\n    return features\n\n\n# ### Extract Features from a list of Imgaes\n\n# In[8]:\n\n\n# Define a function to extract features from a list of images\n# Have this function call bin_spatial() and color_hist()\ndef extract_features(images, color_space='RGB', spatial_size=(32, 32), \n                     hist_bins=32, orient=9, pix_per_cell=8,\n                     cell_per_block=2, hog_channel=0,\n                     spatial_feat=True, hist_feat=True, hog_feat=True):\n    # Create a list to append feature vectors to\n    features = []\n    # Iterate through the list of images\n    for file in tqdm(images):\n        file_features = []\n        img = mpimg.imread(file) # idea for the progress came from \"nhiddink\"\n        # apply color conversion if other than 'RGB'\n        if color_space != 'RGB':\n            if color_space == 'HSV':\n                feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n            elif color_space == 'LUV':\n                feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2LUV)\n            elif color_space == 'HLS':\n                feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)\n            elif color_space == 'YUV':\n                feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YUV)\n            elif color_space == 'YCrCb':\n                feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\n        else: feature_image = np.copy(img)\n            \n        if spatial_feat == True:\n            # Apply bin_spatial() to get spatial color features\n            spatial_features = bin_spatial(feature_image, size=spatial_size)\n            file_features.append(spatial_features)\n        if hist_feat == True:\n            # Apply color_hist() also with a color space option now\n            hist_features = color_hist(feature_image, nbins=hist_bins)\n            file_features.append(hist_features)\n        if hog_feat == True:\n            # Call get_hog_features() with vis=False, feature_vec=True\n            if hog_channel == 'ALL':\n                hog_features = []\n                for channel in range(feature_image.shape[2]):\n                    hog_features.append(get_hog_features(feature_image[:,:,channel], \n                                        orient, pix_per_cell, cell_per_block, \n                                        vis=False, feature_vec=True))\n                hog_features = np.ravel(hog_features)\n            else:\n                hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, \n                                                pix_per_cell, cell_per_block, vis=False,\n                                                feature_vec=True)\n            file_features.append(hog_features)\n        # Append the new feature vector to the features list\n        features.append(np.concatenate(file_features))\n    # Return list of feature vectors\n    return features\n\n\n# ### Slide Window Search\n\n# In[9]:\n\n\ndef slide_window(img, x_start_stop=[None, None], y_start_stop=[None, None], \n                 xy_window=(128, 128), #(64, 64), (96, 96)\n                 xy_overlap=(0.5, 0.5)):\n    # If x and\/or y start\/stop positions not defined, set to image size\n    if x_start_stop[0] == None:\n        x_start_stop[0] = 0\n    if x_start_stop[1] == None:\n        x_start_stop[1] = img.shape[1]\n    if y_start_stop[0] == None:\n        y_start_stop[0] = 0\n    if y_start_stop[1] == None:\n        y_start_stop[1] = img.shape[0]\n    # Compute the span of the region to be searched    \n    xspan = x_start_stop[1] - x_start_stop[0]\n    yspan = y_start_stop[1] - y_start_stop[0]\n    # Compute the number of pixels per step in x\/y\n    nx_pix_per_step = np.int(xy_window[0]*(1 - xy_overlap[0]))\n    ny_pix_per_step = np.int(xy_window[1]*(1 - xy_overlap[1]))\n    # Compute the number of windows in x\/y\n    nx_buffer = np.int(xy_window[0]*(xy_overlap[0]))\n    ny_buffer = np.int(xy_window[1]*(xy_overlap[1]))\n    nx_windows = np.int((xspan-nx_buffer)\/nx_pix_per_step) \n    ny_windows = np.int((yspan-ny_buffer)\/ny_pix_per_step) \n    # Initialize a list to append window positions to\n    window_list = []\n\n    for ys in range(ny_windows):\n        for xs in range(nx_windows):\n            # Calculate window position\n            startx = xs*nx_pix_per_step + x_start_stop[0]\n            endx = startx + xy_window[0]\n            starty = ys*ny_pix_per_step + y_start_stop[0]\n            endy = starty + xy_window[1]\n            # Append window position to list\n            window_list.append(((startx, starty), (endx, endy)))\n    # Return the list of windows\n    return window_list\n\n# Define a function to draw bounding boxes\n\n\n# In[10]:\n\n\n# Define a function to draw bounding boxes\ndef draw_boxes(img, bboxes, color=(255, 0, 0), thick=6):\n    # Make a copy of the image\n    imcopy = np.copy(img)\n    # Iterate through the bounding boxes\n    for bbox in bboxes:\n        # Draw a rectangle given bbox coordinates\n        cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n    # Return the image copy with boxes drawn\n    return imcopy\n\n\n# ### Sliding Window Example\n\n# In[11]:\n\n\ntest_img = mpimg.imread('test_images\/test4.jpg')\n\nwindows =  slide_window(test_img,\n                        x_start_stop=[None, None],\n                        y_start_stop=[400, 656], #tune the parameters\n                        xy_window=(64, 64),\n                        xy_overlap=(0.5, 0.5))\n\nwindow_img = draw_boxes(test_img, windows, color=(255,0,0),thick = 6)\nplt.imshow(window_img);\nmatplotlib.rc('xtick', labelsize=15) \nmatplotlib.rc('ytick', labelsize=15)\nplt.title('Sliding Windows Technique:', fontsize=15);\n#plt.savefig('output_images\/sliding_windows.png', bbox_inches=\"tight\")\n\n\n# ### Extract Features from a Single Image\n\n# In[12]:\n\n\n# This function is very similar to extract_features()\n# just for a single image rather than list of images\ndef single_img_features(image, color_space='RGB', spatial_size=(32, 32),\n                        hist_bins=32, orient=9, \n                        pix_per_cell=8, cell_per_block=2, hog_channel=0,\n                        spatial_feat=True, hist_feat=True, hog_feat=True):    \n    #1) Define an empty list to receive features\n    img_features = []\n    #2) Apply color conversion if other than 'RGB'\n    if color_space != 'RGB':\n        if color_space == 'HSV':\n            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n        elif color_space == 'LUV':\n            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV)\n        elif color_space == 'HLS':\n            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HLS)\n        elif color_space == 'YUV':\n            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)\n        elif color_space == 'YCrCb':\n            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)\n    else: feature_image = np.copy(image)\n    #3) Compute spatial features if flag is set\n    if spatial_feat == True:\n        # Apply bin_spatial() to get spatial color features\n        spatial_features = bin_spatial(feature_image, size=spatial_size)\n        #4) Append features to list\n        img_features.append(spatial_features)\n    #5) Compute histogram features if flag is set\n    if hist_feat == True:\n        # Apply color_hist() also with a color space option now\n        hist_features = color_hist(feature_image, nbins=hist_bins)\n        #6) Append features to list\n        img_features.append(hist_features)\n    #7) Compute HOG features if flag is set\n    if hog_feat == True:\n        if hog_channel == 'ALL':\n            hog_features = []\n            for channel in range(feature_image.shape[2]):\n                hog_features.append(get_hog_features(feature_image[:,:,channel], \n                                    orient, pix_per_cell, cell_per_block, \n                                    vis=False, feature_vec=True))\n            hog_features = np.ravel(hog_features)\n        else:\n            hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, \n                                            pix_per_cell, cell_per_block,\n                                            vis=False, feature_vec=True)\n        #8) Append features to list\n        img_features.append(hog_features)\n    #9) Return concatenated array of features\n    return np.concatenate(img_features)\n\n\n# In[13]:\n\n\n# Define a function you will pass an image \n# and the list of windows to be searched (output of slide_windows())\ndef search_windows(img, windows, clf, scaler, color_space='RGB', \n                   spatial_size=(32, 32), hist_bins=32, orient=9, \n                   pix_per_cell=8, cell_per_block=2, hog_channel=0,\n                   spatial_feat=True, hist_feat=True, hog_feat=True):\n\n    #1) Create an empty list to receive positive detection windows\n    on_windows = []\n    #2) Iterate over all windows in the list\n    for window in windows:\n        #3) Extract the test window from original image\n        test_img = cv2.resize(img[window[0][1]:window[1][1], window[0][0]:window[1][0]], (64, 64))      \n        #4) Extract features for that window using single_img_features()\n        features = single_img_features(test_img, color_space=color_space, \n                            spatial_size=spatial_size, hist_bins=hist_bins, \n                            orient=orient, pix_per_cell=pix_per_cell, \n                            cell_per_block=cell_per_block, \n                            hog_channel=hog_channel, spatial_feat=spatial_feat, \n                            hist_feat=hist_feat, hog_feat=hog_feat)\n        #5) Scale extracted features to be fed to classifier\n        test_features = scaler.transform(np.array(features).reshape(1, -1))\n        #6) Predict using your classifier\n        prediction = clf.predict(test_features)\n        #7) If positive (prediction == 1) then save the window\n        if prediction == 1:\n            on_windows.append(window)\n    #8) Return windows for positive detections\n    return on_windows\n\n\n# ## Train and Test the Classifier\n\n# In[14]:\n\n\n### TODO: Tweak these parameters and see how the results change.\ncolor_space = 'YCrCb' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb\n#color_space = 'RGB'\norient = 10  # HOG orientations   #9\npix_per_cell = 8 # HOG pixels per cell\ncell_per_block = 2 # HOG cells per block\nhog_channel = 'ALL' # Can be 0, 1, 2, or \"ALL\"\nspatial_size = (32, 32) # Spatial binning dimensions\nhist_bins = 64   # Number of histogram bins\nspatial_feat = True # Spatial features on or off\nhist_feat = True # Histogram features on or off\nhog_feat = True # HOG features on or off\n\ncar_features = extract_features(car_images, color_space=color_space, \n                            spatial_size=spatial_size, hist_bins=hist_bins, \n                            orient=orient, pix_per_cell=pix_per_cell, \n                            cell_per_block=cell_per_block, \n                            hog_channel=hog_channel,\n                            spatial_feat=spatial_feat, hist_feat=hist_feat,\n                            hog_feat=hog_feat)\nnotcar_features = extract_features(noncar_images, color_space=color_space, \n                            spatial_size=spatial_size, hist_bins=hist_bins, \n                            orient=orient, pix_per_cell=pix_per_cell, \n                            cell_per_block=cell_per_block, \n                            hog_channel=hog_channel,\n                            spatial_feat=spatial_feat, hist_feat=hist_feat,\n                            hog_feat=hog_feat)\n\n\n# Create an array stack of feature vectors\nX = np.vstack((car_features, notcar_features)).astype(np.float64)\n# Fit a per-column scaler\nX_scaler = StandardScaler().fit(X)\n# Apply the scaler to X\nscaled_X = X_scaler.transform(X)\n\n# Define the labels vector\ny = np.hstack((np.ones(len(car_features)), np.zeros(len(notcar_features))))\n\n# Split up data into randomized training and test sets\nrand_state = np.random.randint(0, 100)\nX_train, X_test, y_train, y_test = train_test_split(scaled_X, y,\n                                                    test_size=0.2,\n                                                    random_state=rand_state)\n# Use a linear SVC\nsvc = LinearSVC()\n# Check the training time for the SVC\nt=time.time()\nsvc.fit(X_train, y_train)\nt2 = time.time()\nprint(round(t2-t, 2), 'seconds to train SVC.')\nprint('Using:', orient, 'orientations', pix_per_cell,\n    'pixels per cell and', cell_per_block, 'cells per block')\nprint('Feature vector length:', len(X_train[0]))\n\n\nprint('Test Accuracy of SVC: {0:.2f}%'.format(round(svc.score(X_test, y_test)*100, 4)))\nprint()\nt = time.time()\nprint('  Predictions:', svc.predict(X_test[0:10]))\nprint('       Labels:', y_test[0:10])\nt2 = time.time()\nprint()\nprint(round(t2-t, 5), 'seconds to predict 10 labels with SVC.')\n\n\n# ### Test on test_images\n\n# In[15]:\n\n\nfor i in range(1,7):\n    \n    fname = 'test_images\/test{}.jpg'.format(i)\n    image = mpimg.imread(fname)\n    draw_image = np.copy(image)\n\n    image = image.astype(np.float32)\/255\n\n    windows =  slide_window(test_img,\n                            x_start_stop=[600, None],\n                            y_start_stop=[400, 656], #tune the parameters\n                            xy_window=(128,128),\n                            xy_overlap=(.7,.7))\n\n    hot_windows = search_windows(image, windows, svc, X_scaler, color_space=color_space, \n                            spatial_size=spatial_size, hist_bins=hist_bins, \n                            orient=orient, pix_per_cell=pix_per_cell, \n                            cell_per_block=cell_per_block, \n                            hog_channel=hog_channel, spatial_feat=spatial_feat, \n                            hist_feat=hist_feat, hog_feat=hog_feat)                       \n\n    \n    window_img = draw_boxes(draw_image, hot_windows)\n    \n    f, (ax1, ax2) = plt.subplots(1, 2, figsize=(18,9))\n    plt.tight_layout()\n    ax1.imshow(draw_image)\n    ax1.set_title('Original Image', fontsize=30)\n    ax2.imshow(window_img)\n    ax2.set_title('Detect Vehicles', fontsize=30)\n    #plt.savefig('output_images\/windows.png', bbox_inches=\"tight\")\n\n\n# ### Build Heat Maps to Fix Multiple Detections & False Positives\n\n# In[16]:\n\n\ndef add_heat(heatmap, bbox_list):\n    # Iterate through list of bboxes\n    for box in bbox_list:\n        # Add += 1 for all pixels inside each bbox\n        # Assuming each \"box\" takes the form ((x1, y1), (x2, y2))\n        heatmap[box[0][1]:box[1][1], box[0][0]:box[1][0]] += 1\n\n    # Return updated heatmap\n    return heatmap# Iterate through list of bboxes\n    \ndef apply_threshold(heatmap, threshold):\n    # Zero out pixels below the threshold\n    heatmap[heatmap <= threshold] = 0\n    # Return thresholded map\n    return heatmap\n\ndef draw_labeled_bboxes(img, labels):\n    # Iterate through all detected cars\n    for car_number in range(1, labels[1]+1):\n        # Find pixels with each car_number label value\n        nonzero = (labels[0] == car_number).nonzero()\n        # Identify x and y values of those pixels\n        nonzeroy = np.array(nonzero[0])\n        nonzerox = np.array(nonzero[1])\n        # Define a bounding box based on min\/max x and y\n        bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy)))\n        # Draw the box on the image\n        cv2.rectangle(img, bbox[0], bbox[1], (255,0,0), 8)\n    # Return the image\n    return img\n\ndef convert_color(img, conv='RGB2YCrCb'):\n    if conv == 'RGB2YCrCb':\n        return cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\n    if conv == 'BGR2YCrCb':\n        return cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)\n    if conv == 'RGB2LUV':\n        return cv2.cvtColor(img, cv2.COLOR_RGB2LUV)\n\n\n# In[17]:\n\n\ndef find_cars(img, ystart, ystop, scale, svc, X_scaler,\n              orient, pix_per_cell, cell_per_block,\n              spatial_size, hist_bins):\n    \n    draw_img = np.copy(img)\n    img = img.astype(np.float32)\/255\n    \n    img_tosearch = img[ystart:ystop,:,:]\n    ctrans_tosearch = convert_color(img_tosearch, conv='RGB2YCrCb')\n    if scale != 1:\n        imshape = ctrans_tosearch.shape\n        ctrans_tosearch = cv2.resize(ctrans_tosearch,\n                                     (np.int(imshape[1]\/scale),\n                                      np.int(imshape[0]\/scale)))\n        \n    ch1 = ctrans_tosearch[:,:,0]\n    ch2 = ctrans_tosearch[:,:,1]\n    ch3 = ctrans_tosearch[:,:,2]\n\n    # Define blocks and steps as above\n    nxblocks = (ch1.shape[1] \/\/ pix_per_cell) - cell_per_block + 1\n    nyblocks = (ch1.shape[0] \/\/ pix_per_cell) - cell_per_block + 1 \n    nfeat_per_block = orient*cell_per_block**2\n    \n    # 64 was the orginal sampling rate, with 8 cells and 8 pix per cell\n    window = 64\n    nblocks_per_window = (window \/\/ pix_per_cell) - cell_per_block + 1\n    cells_per_step = 2  # Instead of overlap, define how many cells to step\n    nxsteps = (nxblocks - nblocks_per_window) \/\/ cells_per_step\n    nysteps = (nyblocks - nblocks_per_window) \/\/ cells_per_step\n    \n    # Compute individual channel HOG features for the entire image\n    hog1 = get_hog_features(ch1, orient, pix_per_cell, cell_per_block, feature_vec=False)\n    hog2 = get_hog_features(ch2, orient, pix_per_cell, cell_per_block, feature_vec=False)\n    hog3 = get_hog_features(ch3, orient, pix_per_cell, cell_per_block, feature_vec=False)\n    \n    bbox_list=[] \n    for xb in range(nxsteps):\n        for yb in range(nysteps):\n            ypos = yb*cells_per_step\n            xpos = xb*cells_per_step\n            # Extract HOG for this patch\n            hog_feat1 = hog1[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n            hog_feat2 = hog2[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n            hog_feat3 = hog3[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n            hog_features = np.hstack((hog_feat1, hog_feat2, hog_feat3))\n\n            xleft = xpos*pix_per_cell\n            ytop = ypos*pix_per_cell\n\n            # Extract the image patch\n            subimg = cv2.resize(ctrans_tosearch[ytop:ytop+window, xleft:xleft+window], (64,64))\n\n            # Get color features\n            spatial_features = bin_spatial(subimg, size=spatial_size)\n            hist_features = color_hist(subimg, nbins=hist_bins)\n\n            # Scale features and make a prediction\n            test_features = X_scaler.transform(np.hstack((spatial_features,\n                                                          hist_features,\n                                                          hog_features)).reshape(1, -1))  \n            \n            # Scale features and make a prediction  \n            test_prediction = svc.predict(test_features)\n            \n            if test_prediction == 1:\n                xbox_left = np.int(xleft*scale)\n                ytop_draw = np.int(ytop*scale)\n                win_draw = np.int(window*scale)\n                cv2.rectangle(draw_img,(xbox_left, ytop_draw+ystart),\n                              (xbox_left+win_draw,ytop_draw+win_draw+ystart),\n                              (255,0,0),8)\n                bbox_list.append(((xbox_left, ytop_draw+ystart), \n                                  (xbox_left+win_draw,ytop_draw+win_draw+ystart)))\n                \n    \n    return bbox_list\n\n\n# ### Test on test_images\n\n# In[18]:\n\n\nfor i in range(1,7):\n    \n    fname = 'test_images\/test{}.jpg'.format(i)\n    img = mpimg.imread(fname)\n    \n\n    orient=10\n    pix_per_cell=8\n    cell_per_block=2\n    spatial_size=(32, 32)\n    hist_bins=64\n    \n    bbox_list = []\n    \n    \n    ystart = 380\n    ystop = 550\n    scale = 1.0\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n    \n    ystart = 400\n    ystop = 600\n    scale = 1.5\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n    \n    ystart = 400\n    ystop = 656\n    scale = 2.0\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n   \n  \n    bbox_list = [item for sublist in bbox_list for item in sublist] \n    \n    #out_img = draw_boxes(img, bbox_list, random_color=True)\n    out_img = draw_boxes(img, bbox_list)\n    \n    heat = np.zeros_like(img[:,:,0]).astype(np.float)\n    heat = add_heat(heat, bbox_list)\n    heat = apply_threshold(heat, 2)  \n\n    # Find final boxes from heatmap using label function\n    labels = label(heat)\n    new_img = draw_labeled_bboxes(np.copy(img), labels)\n\n    f, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18,9))\n    plt.tight_layout()\n    ax1.imshow(out_img)\n    ax1.set_title('Search Boxes', fontsize=30)\n    ax2.imshow(heat, cmap='hot')\n    ax2.set_title('Heat Map', fontsize=30)\n    ax3.imshow(new_img)\n    ax3.set_title('Bounding Boxes', fontsize=30)\n    #plt.savefig('output_images\/heat_map1.png', bbox_inches=\"tight\")\n\n\n# ## Final Pipeline\n\n# In[19]:\n\n\ndef detect_vehicle(img):\n\n    orient=10\n    pix_per_cell=8\n    cell_per_block=2\n    spatial_size=(32, 32)\n    hist_bins=64\n    \n    bbox_list = []\n    \n    ystart = 380\n    ystop = 550\n    scale = 1.0\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n    \n    ystart = 400\n    ystop = 600\n    scale = 1.5\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n    \n    ystart = 400\n    ystop = 656\n    scale = 2.0\n    bbox_list.append(find_cars(img, ystart, ystop, scale, svc, X_scaler,\n                                    orient, pix_per_cell, cell_per_block,\n                                    spatial_size, hist_bins))\n    bbox_list = [item for sublist in bbox_list for item in sublist] \n    \n    heat = np.zeros_like(img[:,:,0]).astype(np.float)\n    heat = add_heat(heat, bbox_list)\n    heat = apply_threshold(heat, 2)  \n\n    # Find final boxes from heatmap using label function\n    labels = label(heat)\n    new_img = draw_labeled_bboxes(np.copy(img), labels)\n    \n    return new_img\n\n\n# ### Test on Video Stream\n\n# In[20]:\n\n\nclip1 = VideoFileClip(\"test_video.mp4\")\ntest_output  = \"test_output.mp4\"\ntest_clip = clip1.fl_image(detect_vehicle)\nget_ipython().run_line_magic('time', 'test_clip.write_videofile(test_output, audio=False)')\n\n\n# In[21]:\n\n\nclip2 = VideoFileClip(\"project_video.mp4\")\noutput = \"project_output.mp4\"\nclip = clip2.fl_image(detect_vehicle)\nget_ipython().run_line_magic('time', 'clip.write_videofile(output, audio=False)')\n\n\n# In[ ]:\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_304","text":"<filename>tests\/test_series.py\nfrom sympy import (\n    symbols, cos, sin, log, sqrt,\n    Tuple, pi, Plane, S, I, im,\n    Circle, Point,\n    Piecewise, And, Eq, Interval, Abs, lambdify\n)\nfrom spb.series import (\n    LineOver1DRangeSeries, Parametric2DLineSeries, Parametric3DLineSeries,\n    SurfaceOver2DRangeSeries, ContourSeries, ParametricSurfaceSeries,\n    InteractiveSeries,\n    ImplicitSeries,\n    Vector2DSeries, Vector3DSeries, SliceVector3DSeries,\n    ComplexSeries, ComplexInteractiveSeries, ComplexPointSeries,\n    ComplexPointInteractiveSeries,\n    GeometrySeries, GeometryInteractiveSeries,\n    PlaneSeries, PlaneInteractiveSeries,\n    List2DSeries\n)\nfrom spb.functions import _process_piecewise\nimport numpy as np\nfrom pytest import warns, raises\n\ndef test_lin_log_scale():\n    # Verify that data series create the correct spacing in the data.\n    x, y, z = symbols(\"x, y, z\")\n\n    s = LineOver1DRangeSeries(x, (x, 1, 10), adaptive=False, n=50, xscale=\"linear\")\n    xx, _ = s.get_data()\n    assert np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n\n    s = LineOver1DRangeSeries(x, (x, 1, 10), adaptive=False, n=50, xscale=\"log\")\n    xx, _ = s.get_data()\n    assert not np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n\n    s = Parametric2DLineSeries(\n        cos(x), sin(x), (x, pi \/ 2, 1.5 * pi), adaptive=False, n=50, xscale=\"linear\"\n    )\n    _, _, param = s.get_data()\n    assert np.isclose(param[1] - param[0], param[-1] - param[-2])\n\n    s = Parametric2DLineSeries(\n        cos(x), sin(x), (x, pi \/ 2, 1.5 * pi), adaptive=False, n=50, xscale=\"log\"\n    )\n    _, _, param = s.get_data()\n    assert not np.isclose(param[1] - param[0], param[-1] - param[-2])\n\n    s = Parametric3DLineSeries(\n        cos(x), sin(x), x, (x, pi \/ 2, 1.5 * pi), adaptive=False, n=50, xscale=\"linear\"\n    )\n    _, _, _, param = s.get_data()\n    assert np.isclose(param[1] - param[0], param[-1] - param[-2])\n\n    s = Parametric3DLineSeries(\n        cos(x), sin(x), x, (x, pi \/ 2, 1.5 * pi), adaptive=False, n=50, xscale=\"log\"\n    )\n    _, _, _, param = s.get_data()\n    assert not np.isclose(param[1] - param[0], param[-1] - param[-2])\n\n    s = SurfaceOver2DRangeSeries(\n        cos(x ** 2 + y ** 2),\n        (x, 1, 5),\n        (y, 1, 5),\n        n=10,\n        xscale=\"linear\",\n        yscale=\"linear\",\n    )\n    xx, yy, _ = s.get_data()\n    assert np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])\n    assert np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])\n\n    s = SurfaceOver2DRangeSeries(\n        cos(x ** 2 + y ** 2), (x, 1, 5), (y, 1, 5), n=10, xscale=\"log\", yscale=\"log\"\n    )\n    xx, yy, _ = s.get_data()\n    assert not np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])\n    assert not np.isclose(yy[1, 0] - yy[0, 0], yy[-1, 0] - yy[-2, 0])\n\n    s = ImplicitSeries(\n        cos(x ** 2 + y ** 2) > 0,\n        (x, 1, 5),\n        (y, 1, 5),\n        n=10,\n        xscale=\"linear\",\n        yscale=\"linear\",\n        adaptive=False,\n    )\n    xx, yy, _, _, _ = s.get_data()\n    assert np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n    assert np.isclose(yy[1] - yy[0], yy[-1] - yy[-2])\n\n    s = ImplicitSeries(\n        cos(x ** 2 + y ** 2) > 0,\n        (x, 1, 5),\n        (y, 1, 5),\n        n=10,\n        xscale=\"log\",\n        yscale=\"log\",\n        adaptive=False,\n    )\n    xx, yy, _, _, _ = s.get_data()\n    assert not np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n    assert not np.isclose(yy[1] - yy[0], yy[-1] - yy[-2])\n\n    s = InteractiveSeries([log(x)], [(x, 1e-05, 1e05)], n=10, xscale=\"linear\")\n    xx, yy = s.get_data()\n    assert np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n\n    s = InteractiveSeries([log(x)], [(x, 1e-05, 1e05)], n=10, xscale=\"log\")\n    xx, yy = s.get_data()\n    assert not np.isclose(xx[1] - xx[0], xx[-1] - xx[-2])\n\n    s = ComplexSeries(\n        cos(x),\n        (x, 1e-05, 1e05),\n        n=10,\n        xscale=\"linear\",\n        adaptive=False,\n    )\n    xx, yy, _ = s.get_data()\n    assert np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])\n\n    s = ComplexSeries(\n        cos(x),\n        (x, 1e-05, 1e05),\n        n=10,\n        xscale=\"log\",\n        adaptive=False,\n    )\n    xx, yy, _ = s.get_data()\n    assert not np.isclose(xx[0, 1] - xx[0, 0], xx[0, -1] - xx[0, -2])\n\n    s = Vector3DSeries(\n        x,\n        y,\n        z,\n        (x, 1, 1e05),\n        (y, 1, 1e05),\n        (z, 1, 1e05),\n        xscale=\"linear\",\n        yscale=\"linear\",\n        zscale=\"linear\",\n    )\n    xx, yy, zz, _, _, _ = s.get_data()\n    assert np.isclose(\n        xx[0, :, 0][1] - xx[0, :, 0][0], xx[0, :, 0][-1] - xx[0, :, 0][-2]\n    )\n    assert np.isclose(\n        yy[:, 0, 0][1] - yy[:, 0, 0][0], yy[:, 0, 0][-1] - yy[:, 0, 0][-2]\n    )\n    assert np.isclose(\n        zz[0, 0, :][1] - zz[0, 0, :][0], zz[0, 0, :][-1] - zz[0, 0, :][-2]\n    )\n\n    s = Vector3DSeries(\n        x,\n        y,\n        z,\n        (x, 1, 1e05),\n        (y, 1, 1e05),\n        (z, 1, 1e05),\n        xscale=\"log\",\n        yscale=\"log\",\n        zscale=\"log\",\n    )\n    xx, yy, zz, _, _, _ = s.get_data()\n    assert not np.isclose(\n        xx[0, :, 0][1] - xx[0, :, 0][0], xx[0, :, 0][-1] - xx[0, :, 0][-2]\n    )\n    assert not np.isclose(\n        yy[:, 0, 0][1] - yy[:, 0, 0][0], yy[:, 0, 0][-1] - yy[:, 0, 0][-2]\n    )\n    assert not np.isclose(\n        zz[0, 0, :][1] - zz[0, 0, :][0], zz[0, 0, :][-1] - zz[0, 0, :][-2]\n    )\n\n\ndef test_data_shape():\n    # Verify that the series produces the correct data shape when the input\n    # expression is a number.\n    u, x, y, z = symbols(\"u, x:z\")\n\n    # scalar expression: it should return a numpy ones array\n    s = LineOver1DRangeSeries(1, (x, -5, 5))\n    xx, yy = s.get_data()\n    assert len(xx) == len(yy)\n    assert np.all(yy == 1)\n\n    s = LineOver1DRangeSeries(1, (x, -5, 5), adaptive=False)\n    xx, yy = s.get_data()\n    assert len(xx) == len(yy)\n    assert np.all(yy == 1)\n\n    s = Parametric2DLineSeries(sin(x), 1, (x, 0, pi))\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(yy == 1)\n\n    s = Parametric2DLineSeries(1, sin(x), (x, 0, pi))\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(xx == 1)\n\n    s = Parametric2DLineSeries(sin(x), 1, (x, 0, pi), adaptive=False)\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(yy == 1)\n\n    s = Parametric2DLineSeries(1, sin(x), (x, 0, pi), adaptive=False)\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(xx == 1)\n\n    s = Parametric3DLineSeries(cos(x), sin(x), 1, (x, 0, 2 * pi))\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))\n    assert np.all(zz == 1)\n\n    s = Parametric3DLineSeries(cos(x), 1, x, (x, 0, 2 * pi))\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))\n    assert np.all(yy == 1)\n\n    s = Parametric3DLineSeries(1, sin(x), x, (x, 0, 2 * pi))\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(zz)) and (len(xx) == len(param))\n    assert np.all(xx == 1)\n\n    s = SurfaceOver2DRangeSeries(1, (x, -2, 2), (y, -3, 3))\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    s = ParametricSurfaceSeries(1, x, y, (x, 0, 1), (y, 0, 1))\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(xx == 1)\n\n    s = ParametricSurfaceSeries(1, 1, y, (x, 0, 1), (y, 0, 1))\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(yy == 1)\n\n    s = ParametricSurfaceSeries(x, 1, 1, (x, 0, 1), (y, 0, 1))\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    s = ComplexSeries(1, (x, -5, 5), modules=None)\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    s = ComplexSeries(1, (x, -5, 5), modules=\"mpmath\")\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    s = ComplexSeries(1, (x, -5 - 2 * I, 5 + 2 * I), domain_coloring=True,\n            modules=None)\n    rr, ii, mag, arg, colors, _ = s.get_data()\n    assert (rr.shape == ii.shape) and (rr.shape[:2] == colors.shape[:2])\n    assert (rr.shape == mag.shape) and (rr.shape == arg.shape)\n\n    s = ComplexSeries(1, (x, -5 - 2 * I, 5 + 2 * I), domain_coloring=True,\n            modules=\"mpmath\")\n    rr, ii, mag, arg, colors, _ = s.get_data()\n    assert (rr.shape == ii.shape) and (rr.shape[:2] == colors.shape[:2])\n    assert (rr.shape == mag.shape) and (rr.shape == arg.shape)\n\n    # Corresponds to LineOver1DRangeSeries\n    s = InteractiveSeries([S.One], [Tuple(x, -5, 5)])\n    s.update_data(dict())\n    xx, yy = s.get_data()\n    assert len(xx) == len(yy)\n    assert np.all(yy == 1)\n\n    # Corresponds to Parametric2DLineSeries\n    s = InteractiveSeries([S.One, sin(x)], [Tuple(x, 0, pi)])\n    s.update_data(dict())\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(xx == 1)\n\n    s = InteractiveSeries([sin(x), S.One], [Tuple(x, 0, pi)])\n    s.update_data(dict())\n    xx, yy, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param))\n    assert np.all(yy == 1)\n\n    # Corresponds to Parametric3DLineSeries\n    s = InteractiveSeries([cos(x), sin(x), S.One], [(x, 0, 2 * pi)])\n    s.update_data(dict())\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param)) and (len(xx) == len(zz))\n    assert np.all(zz == 1)\n\n    s = InteractiveSeries([S.One, sin(x), x], [(x, 0, 2 * pi)])\n    s.update_data(dict())\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param)) and (len(xx) == len(zz))\n    assert np.all(xx == 1)\n\n    s = InteractiveSeries([cos(x), S.One, x], [(x, 0, 2 * pi)])\n    s.update_data(dict())\n    xx, yy, zz, param = s.get_data()\n    assert (len(xx) == len(yy)) and (len(xx) == len(param)) and (len(xx) == len(zz))\n    assert np.all(yy == 1)\n\n    # Corresponds to SurfaceOver2DRangeSeries\n    s = InteractiveSeries([S.One], [(x, -2, 2), (y, -3, 3)])\n    s.update_data(dict())\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    # Corresponds to ParametricSurfaceSeries\n    s = InteractiveSeries([S.One, x, y], [(x, 0, 1), (y, 0, 1)])\n    s.update_data(dict())\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(xx == 1)\n\n    s = InteractiveSeries([x, S.One, y], [(x, 0, 1), (y, 0, 1)])\n    s.update_data(dict())\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(yy == 1)\n\n    s = InteractiveSeries([x, y, S.One], [(x, 0, 1), (y, 0, 1)])\n    s.update_data(dict())\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n    assert np.all(zz == 1)\n\n    s = ComplexInteractiveSeries(S.One, (x, -5, 5), real=True, imag=False,\n            modules=None)\n    s.update_data(dict())\n    xx, yy, zz = s.get_data()\n    assert (xx.shape == yy.shape) and (xx.shape == zz.shape)\n\n\ndef test_interactive():\n    u, x, y, z = symbols(\"u, x:z\")\n\n    # verify that InteractiveSeries produces the same numerical data as their\n    # corresponding non-interactive series.\n    def do_test(data1, data2):\n        assert len(data1) == len(data2)\n        for d1, d2 in zip(data1, data2):\n            assert np.allclose(d1, d2)\n\n    s1 = InteractiveSeries([u * cos(x)], [(x, -5, 5)], \"\", params={u: 1}, n1=50)\n    s2 = LineOver1DRangeSeries(cos(x), (x, -5, 5), \"\", adaptive=False, n=50)\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [u * cos(x), u * sin(x)], [(x, -5, 5)], \"\", params={u: 1}, n1=50\n    )\n    s2 = Parametric2DLineSeries(cos(x), sin(x), (x, -5, 5), \"\", adaptive=False, n=50)\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [u * cos(x), u * sin(x), u * x], [(x, -5, 5)], \"\", params={u: 1}, n1=50\n    )\n    s2 = Parametric3DLineSeries(cos(x), sin(x), x, (x, -5, 5), \"\", adaptive=False, n=50)\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [cos(x ** 2 + y ** 2)],\n        [(x, -3, 3), (y, -3, 3)],\n        \"\",\n        params={u: 1},\n        n1=50,\n        n2=50,\n    )\n    s2 = SurfaceOver2DRangeSeries(\n        cos(x ** 2 + y ** 2), (x, -3, 3), (y, -3, 3), \"\", adaptive=False, n1=50, n2=50\n    )\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [cos(x + y), sin(x + y), x - y],\n        [(x, -3, 3), (y, -3, 3)],\n        \"\",\n        params={u: 1},\n        n1=50,\n        n2=50,\n    )\n    s2 = ParametricSurfaceSeries(\n        cos(x + y),\n        sin(x + y),\n        x - y,\n        (x, -3, 3),\n        (y, -3, 3),\n        \"\",\n        adaptive=False,\n        n1=50,\n        n2=50,\n    )\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [-u * y, u * x], [(x, -3, 3), (y, -2, 2)], \"\", params={u: 1}, n1=15, n2=15\n    )\n    s2 = Vector2DSeries(-y, x, (x, -3, 3), (y, -2, 2), \"\", n1=15, n2=15)\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [u * z, -u * y, u * x],\n        [(x, -3, 3), (y, -2, 2), (z, -1, 1)],\n        \"\",\n        params={u: 1},\n        n1=15,\n        n2=15,\n        n3=15,\n    )\n    s2 = Vector3DSeries(\n        z, -y, x, (x, -3, 3), (y, -2, 2), (z, -1, 1), \"\", n1=15, n2=15, n3=15\n    )\n    do_test(s1.get_data(), s2.get_data())\n\n    s1 = InteractiveSeries(\n        [u * z, -u * y, u * x],\n        [(x, -3, 3), (y, -2, 2), (z, -1, 1)],\n        \"\",\n        params={u: 1},\n        slice=Plane((-1, 0, 0), (1, 0, 0)),\n        n1=15,\n        n2=15,\n        n3=15,\n    )\n    s2 = SliceVector3DSeries(\n        Plane((-1, 0, 0), (1, 0, 0)),\n        z,\n        -y,\n        x,\n        (x, -3, 3),\n        (y, -2, 2),\n        (z, -1, 1),\n        \"\",\n        n1=15,\n        n2=15,\n        n3=15,\n    )\n    do_test(s1.get_data(), s2.get_data())\n\n    ### Test InteractiveSeries and ComplexInteractiveSeries with complex\n    ### functions\n\n    # complex function evaluated over a real line with numpy\n    s1 = InteractiveSeries(\n        [(z ** 2 + 1) \/ (z ** 2 - 1)], [(z, -3, 3)], \"\", n1=50,\n        is_complex=True, modules=None)\n    s2 = LineOver1DRangeSeries(\n        (z ** 2 + 1) \/ (z ** 2 - 1), (z, -3, 3), \"\", adaptive=False,\n        n=50, is_complex=True, modules=None)\n    do_test(s1.get_data(), s2.get_data())\n\n    # complex function evaluated over a real line with mpmath\n    s1 = InteractiveSeries(\n        [(z ** 2 + 1) \/ (z ** 2 - 1)], [(z, -3, 3)], \"\",\n        n1=11, is_complex=True, modules=\"mpmath\")\n    s2 = LineOver1DRangeSeries(\n        (z ** 2 + 1) \/ (z ** 2 - 1), (z, -3, 3), \"\", adaptive=False,\n        n=11, is_complex=True, modules=\"mpmath\")\n    do_test(s1.get_data(), s2.get_data())\n\n    # abs\/arg values of complex function evaluated over a real line wit numpy\n    expr = (z ** 2 + 1) \/ (z ** 2 - 1)\n    s1 = InteractiveSeries(\n        [expr], [(z, -3, 3)], \"\",\n        n1=50, is_complex=True, absarg=expr, modules=None)\n    s2 = LineOver1DRangeSeries(\n        expr, (z, -3, 3), \"\", adaptive=False,\n        n=50, is_complex=True, absarg=expr, modules=None)\n    do_test(s1.get_data(), s2.get_data())\n\n    # abs\/arg values of complex function evaluated over a real line wit mpmath\n    expr = (z ** 2 + 1) \/ (z ** 2 - 1)\n    s1 = InteractiveSeries(\n        [expr], [(z, -3, 3)], \"\",\n        n1=50, is_complex=True, absarg=expr, modules=\"mpmath\")\n    s2 = LineOver1DRangeSeries(\n        expr, (z, -3, 3), \"\", adaptive=False,\n        n=50, is_complex=True, absarg=expr, modules=\"mpmath\")\n    do_test(s1.get_data(), s2.get_data())\n\n    # domain coloring or 3D\n    s1 = ComplexInteractiveSeries(\n        u * (z ** 2 + 1) \/ (z ** 2 - 1), (z, -3 - 4 * I, 3 + 4 * I), \"\",\n        n1=20, n2=20, domain_coloring=True, params = {u: 1}, modules=None\n    )\n    s2 = ComplexSeries(\n        (z ** 2 + 1) \/ (z ** 2 - 1), (z, -3 - 4 * I, 3 + 4 * I), \"\",\n        n1=20, n2=20, domain_coloring=True, modules=None\n    )\n    do_test(s1.get_data(), s2.get_data())\n\ndef test_complex_discretization():\n    x, y, z = symbols(\"x:z\")\n\n    # test complex discretization for LineOver1DRangeSeries and\n    # SurfaceOver2DRangeSeries and InteractiveSeries\n\n    # is_complex=True should produce (intermediate) complex results, which are\n    # later converted to floats. is_complex=False should produce (intermediate)\n    # float results.\n    s1 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=False, modules=None, n=10)\n    s2 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=True, modules=None, n=10)\n    d1 = s1._uniform_sampling(lambdify([s1.var], s1.expr, s1.modules))\n    d2 = s2._uniform_sampling(lambdify([s2.var], s2.expr, s2.modules))\n    assert all(isinstance(t, float) for t in d1[0])\n    assert all(isinstance(t, float) for t in d1[1])\n    assert all(isinstance(t, complex) for t in d2[0])\n    assert all(isinstance(t, complex) for t in d2[1])\n    d3 = s1.get_data()\n    with warns(np.ComplexWarning):\n        d4 = s2.get_data()\n\n    # Mpmath and Numpy produces different results\n    s1 = LineOver1DRangeSeries(im(sqrt(-x)), (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=True, modules=None, n=10)\n    s2 = LineOver1DRangeSeries(im(sqrt(-x)), (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=True, modules=\"mpmath\", n=10)\n    d1, d2 = s1.get_data(), s2.get_data()\n    assert (d1[-1][-1] < 0) and (d2[-1][-1] > 0)\n    assert np.array_equal(d1[-1], -d2[-1])\n\n    def do_test(data1, data2, compare=True):\n        assert len(data1) == len(data2)\n        for d1, d2 in zip(data1, data2):\n            assert (d1.dtype == np.float64) and (d2.dtype == np.float64)\n            if compare:\n                assert np.array_equal(d1, d2)\n\n    # using Numpy and a real discretization will produce NaN value when x<0.\n    with warns(RuntimeWarning, match=\"invalid value encountered in sqrt\"):\n        s1 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s1\",\n                adaptive=False, is_complex=False, modules=None, n=20)\n        s1.get_data()\n\n    # using Numpy or Mpmath with complex discretization won't raise warnings.\n    # Results between Numpy as Mpmath shoudl be really close\n    s2 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s2\",\n            adaptive=False, is_complex=True, modules=None, n=20)\n    s3 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s3\",\n            adaptive=False, is_complex=True, modules=\"mpmath\", n=20)\n    do_test(s2.get_data(), s3.get_data())\n\n\n    # using Numpy and a real discretization will produce NaN value when x<0.\n    with warns(RuntimeWarning, match=\"invalid value encountered in sqrt\"):\n        s4 = LineOver1DRangeSeries(sqrt(x), (x, -10, 10), \"s4\",\n                adaptive=True, is_complex=False, modules=None)\n        s4.get_data()\n\n    # using Numpy or Mpmath with complex discretization won't raise warnings.\n    # Results between Numpy as Mpmath shoudl be really close.\n    # NOTE: changed the function because the adaptive algorithm works by\n    # checking the collinearity between three points (the x, y coordinates must\n    # be real). Instead, with \"mpmath\" the y coordinate is a complex number.\n    s5 = LineOver1DRangeSeries(im(sqrt(x)), (x, -10, 10), \"s5\",\n            adaptive=True, is_complex=True, modules=None)\n    s6 = LineOver1DRangeSeries(im(sqrt(x)), (x, -10, 10), \"s6\",\n            adaptive=True, is_complex=True, modules=\"mpmath\")\n    # can't directly compare the results because of the adaptive sampling\n    do_test(s5.get_data(), s6.get_data(), False)\n\n\n    # Mpmath and Numpy produces different results\n    s1 = SurfaceOver2DRangeSeries(im(sqrt(-x)), (x, -5, 5), (y, -5, 5),\n            is_complex=False, modules=None)\n    s2 = SurfaceOver2DRangeSeries(im(sqrt(-x)), (x, -5, 5), (y, -5, 5),\n            is_complex=True, modules=\"mpmath\")\n    d1, d2 = s1.get_data(), s2.get_data()\n    assert (d1[-1][-1, -1] < 0) and (d2[-1][-1, -1] > 0)\n    assert np.all(np.abs(d1[-1]) - np.abs(d2[-1])) < 1e-08\n\n    # Interactive series produces the same numerical data as LineOver1DRangeSeries.\n    # NOTE: InteractiveSeries doesn't support adaptive algorithm!\n    s1 = LineOver1DRangeSeries(im(sqrt(-x)), (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=True, modules=None, n=10)\n    s2 = InteractiveSeries([im(sqrt(-x))], [(x, -10, 10)], \"s2\",\n            is_complex=True, modules=None, n1=10)\n    s3 = InteractiveSeries([im(sqrt(-x))], [(x, -10, 10)], \"s3\",\n            is_complex=True, modules=\"mpmath\", n1=10)\n    d1, d2, d3 = s1.get_data(), s2.get_data(), s3.get_data()\n    do_test(d1, d2)\n    assert np.all(np.abs(d1[-1]) - np.abs(d3[-1])) < 1e-08\n\n    expr = sqrt(-x)\n    s1 = LineOver1DRangeSeries(expr, (x, -10, 10), \"s1\",\n            adaptive=False, is_complex=True, modules=None, n=10, absarg=expr)\n    s2 = InteractiveSeries([expr], [(x, -10, 10)], \"s2\",\n            is_complex=True, modules=None, n1=10, absarg=expr)\n    s3 = InteractiveSeries([expr], [(x, -10, 10)], \"s3\",\n            is_complex=True, modules=\"mpmath\", n1=10, absarg=expr)\n    d1, d2, d3 = s1.get_data(), s2.get_data(), s3.get_data()\n    do_test(d1, d2)\n    assert np.all(np.abs(d1[-1]) - np.abs(d3[-1])) < 1e-08\n\n    # Interactive series produces the same numerical data as SurfaceOver2DRangeSeries\n    s1 = SurfaceOver2DRangeSeries(im(sqrt(-x)), (x, -3, 3), (y, -3, 3),\n            is_complex=True, modules=\"mpmath\", n1=20, n2=20)\n    s2 = InteractiveSeries([im(sqrt(-x))], [(x, -3, 3), (y, -3, 3)], \"s2\",\n            is_complex=True, modules=None, n1=20, n2=20)\n    s3 = InteractiveSeries([im(sqrt(-x))], [(x, -3, 3), (y, -3, 3)], \"s3\",\n            is_complex=True, modules=\"mpmath\", n1=20, n2=20)\n    do_test(d1, d2)\n    assert np.all(np.abs(d1[-1]) - np.abs(d3[-1])) < 1e-08\n\ndef test_str():\n    x, y, z = symbols(\"x:z\")\n\n    s = LineOver1DRangeSeries(cos(x), (x, -4, 3), \"test\")\n    assert str(s) == \"cartesian line: cos(x) for x over (-4.0, 3.0)\"\n    s = Parametric2DLineSeries(cos(x), sin(x), (x, -4, 3), \"test\")\n    assert str(s) == \"parametric cartesian line: (cos(x), sin(x)) for x over (-4.0, 3.0)\"\n    s = Parametric3DLineSeries(cos(x), sin(x), x, (x, -4, 3), \"test\")\n    assert str(s) == \"3D parametric cartesian line: (cos(x), sin(x), x) for x over (-4.0, 3.0)\"\n    s = SurfaceOver2DRangeSeries(cos(x * y), (x, -4, 3), (y, -2, 5), \"test\")\n    assert str(s) == \"cartesian surface: cos(x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)\"\n    s = ContourSeries(cos(x * y), (x, -4, 3), (y, -2, 5), \"test\")\n    assert str(s) == \"contour: cos(x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)\"\n    s = ParametricSurfaceSeries(cos(x * y), sin(x * y), x * y,\n        (x, -4, 3), (y, -2, 5), \"test\")\n    assert str(s) == \"parametric cartesian surface: (cos(x*y), sin(x*y), x*y) for x over (-4.0, 3.0) and y over (-2.0, 5.0)\"\n    s = ImplicitSeries(x < y, (x, -5, 4), (y, -3, 2), \"test\")\n    assert str(s) == \"Implicit expression: x < y for x over (-5.0, 4.0) and y over (-3.0, 2.0)\"\n    s = ComplexPointSeries(2 + 3 * I, \"test\")\n    assert str(s) == \"complex point 2 + 3*I\"\n    s = ComplexPointSeries([2 + 3 * I, 4 * I], \"test\")\n    assert str(s) == \"complex points (2 + 3*I, 4*I)\"\n    s = ComplexPointInteractiveSeries([2 + 3 * I], \"test\")\n    assert str(s) == \"complex interactive points: (2 + 3*I,)\"\n    s = ComplexPointInteractiveSeries([2 + 3 * I, 4 * I], \"test\")\n    assert str(s) == \"complex interactive points: (2 + 3*I, 4*I)\"\n    s = ComplexSeries(sqrt(z), (z, -2-3j, 4+5j), \"test\", threed=True)\n    assert str(s) == \"cartesian surface: sqrt(z) for re(z) over (-2.0, 4.0) and im(z) over (-3.0, 5.0)\"\n    s = ComplexSeries(sqrt(z), (z, -2-3j, 4+5j), \"test\", domain_coloring=True)\n    assert str(s) == \"domain coloring: sqrt(z) for re(z) over (-2.0, 4.0) and im(z) over (-3.0, 5.0)\"\n    s = ComplexInteractiveSeries(x * sqrt(z), (z, -2-3j, 4+5j), \"test\",\n        threed=True, params={x: 1})\n    assert str(s) == \"interactive cartesian surface for expression: x*sqrt(z) over (z, (-2-3j), (4+5j)) and parameters [x, z]\"\n    s = ComplexInteractiveSeries(x * sqrt(z), (z, -2-3j, 4+5j), \"test\",\n        domain_coloring=True, params={x: 1})\n    assert str(s) == \"interactive domain coloring for expression: x*sqrt(z) over (z, (-2-3j), (4+5j)) and parameters [x, z]\"\n    s = Vector2DSeries(-y, x, (x, -5, 4), (y, -3, 2), \"test\")\n    assert str(s) == \"2D vector series: [-y, x] over (x, -5.0, 4.0), (y, -3.0, 2.0)\"\n    s = Vector3DSeries(z, y, x, (x, -5, 4), (y, -3, 2), (z, -6, 7), \"test\")\n    assert str(s) == \"3D vector series: [z, y, x] over (x, -5.0, 4.0), (y, -3.0, 2.0), (z, -6.0, 7.0)\"\n    s = SliceVector3DSeries(Plane((0, 0, 0), (1, 0, 0)), z, y, x,\n        (x, -5, 4), (y, -3, 2), (z, -6, 7), \"test\")\n    assert str(s) == \"sliced 3D vector series: [z, y, x] over (x, -5.0, 4.0), (y, -3.0, 2.0), (z, -6.0, 7.0) at Plane(Point3D(0, 0, 0), (1, 0, 0))\"\n    s = PlaneSeries(Plane((0, 0, 0), (1, 1, 1)),\n        (x, -5, 4), (y, -3, 2), (z, -6, 7), \"test\")\n    assert str(s) == \"plane series of Plane(Point3D(0, 0, 0), (1, 1, 1)) over (x, -5, 4), (y, -3, 2), (z, -6, 7)\"\n    s = PlaneInteractiveSeries([Plane((z, 0, 0), (1, 1, 1))],\n        [(x, -5, 4), (y, -3, 2), (z, -6, 7)], \"test\", params={z: 1})\n    assert str(s) == \"interactive plane series of Plane(Point3D(z, 0, 0), (1, 1, 1)) over (x, -5, 4), (y, -3, 2), (z, -6, 7) with parameters [z]\"\n    s = GeometrySeries(Circle(Point(0, 0), 5))\n    assert str(s) == \"geometry entity: Circle(Point2D(0, 0), 5)\"\n    s = GeometryInteractiveSeries([Circle(Point(x, 0), 5)], [], params={x: 1})\n    assert str(s) == \"interactive geometry entity: Circle(Point2D(x, 0), 5) with parameters [x]\"\n\n    # interactive series\n    s = InteractiveSeries([z * cos(x)], [(x, -4, 3)], \"test\", params={z: 1})\n    assert str(s) == \"interactive expression: z*cos(x) with ranges (x, -4.0, 3.0) and parameters [x, z]\"\n    s = InteractiveSeries([z * cos(x * y)], [(x, -4, 3), (y, -2, 1)], \"test\",\n        params={z: 1})\n    assert str(s) == \"interactive expression: z*cos(x*y) with ranges (x, -4.0, 3.0), (y, -2.0, 1.0) and parameters [x, y, z]\"\n    s = InteractiveSeries([z * cos(x * y), sin(x * y), x*y],\n        [(x, -4, 3), (y, -2, 1)], \"test\", params={z: 1})\n    assert str(s) == \"interactive expression: (z*cos(x*y), sin(x*y), x*y) with ranges (x, -4.0, 3.0), (y, -2.0, 1.0) and parameters [x, y, z]\"\n\ndef test_piecewise():\n    x = symbols(\"x\")\n\n    # Test that univariate Piecewise objects are processed in such a way to\n    # create multiple series, each one with the correct range\n\n    f = Piecewise(\n        (-1, x < -1),\n        (x, And(-1 <= x, x < 0)),\n        (x**2, And(0 <= x, x < 1)),\n        (x**3, x >= 1)\n    )\n    s = _process_piecewise(f, (x, -5, 5), \"A\")\n    assert len(s) == 4\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in s)\n    assert (s[0].expr == -1) and (s[0].start == -5) and (s[0].end == -1)\n    assert (s[1].expr == x) and (s[1].start == -1) and (s[1].end == 0)\n    assert (s[2].expr == x**2) and (s[2].start == 0) and (s[2].end == 1)\n    assert (s[3].expr == x**3) and (s[3].start == 1) and (s[3].end == 5)\n    labels = [\"A\" + str(i + 1) for i in range(5)]\n    assert all(t.label == l for t, l in zip(s, labels))\n\n    f = Piecewise(\n        (1, x < -5),\n        (x, Eq(x, 0)),\n        (x**2, Eq(x, 2)),\n        (x**3, (x > 0) & (x < 2)),\n        (x**4, True)\n    )\n    s = _process_piecewise(f, (x, -10, 10), \"B\")\n    assert len(s) == 6\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in [s[0], s[3], s[4], s[5]])\n    assert all(isinstance(t, List2DSeries) for t in [s[1], s[2]])\n    assert (s[0].expr == 1) and (s[0].start == -10) and (s[0].end == -5)\n    assert (np.allclose(s[1].list_x, np.array([0.])) and\n        np.allclose(s[1].list_y, np.array([0.])))\n    assert (np.allclose(s[2].list_x, np.array([2.])) and\n        np.allclose(s[2].list_y, np.array([4.])))\n    assert (s[3].expr == x**3) and (s[3].start == 0) and (s[3].end == 2)\n    assert (s[4].expr == x**4) and (s[4].start == -5) and (s[4].end == 0)\n    assert (s[5].expr == x**4) and (s[5].start == 2) and (s[5].end == 10)\n    labels = [\"B\" + str(i + 1) for i in range(5)] + [\"B5\"]\n    assert all(t.label == l for t, l in zip(s, labels))\n\n    f = Piecewise((x, Interval(0, 1).contains(x)), (0, True))\n    s = _process_piecewise(f, (x, -10, 10), \"C\")\n    assert len(s) == 3\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in s)\n    assert (s[0].expr == x) and (s[0].start == 0) and (s[0].end == 1)\n    assert (s[1].expr == 0) and (s[1].start == -10) and (s[1].end == 0)\n    assert (s[2].expr == 0) and (s[2].start == 1) and (s[2].end == 10)\n    labels = [\"C1\", \"C2\", \"C2\"]\n    assert all(t.label == l for t, l in zip(s, labels))\n\n    f = Piecewise((x, Interval(0, 1, False, True).contains(x)), (0, True))\n    s = _process_piecewise(f, (x, -10, 10), \"D\")\n    assert len(s) == 3\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in s)\n    assert (s[0].expr == x) and (s[0].start == 0) and (s[0].end == 1)\n    assert (s[1].expr == 0) and (s[1].start == -10) and (s[1].end == 0)\n    assert (s[2].expr == 0) and (s[2].start == 1) and (s[2].end == 10)\n    labels = [\"D1\", \"D2\", \"D2\"]\n    assert all(t.label == l for t, l in zip(s, labels))\n\n    f = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))\n    s = _process_piecewise(f, (x, -10, 10), \"E\")\n    assert len(s) == 2\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in s)\n    assert (s[0].expr == x) and (s[0].start == -10) and (s[0].end == 1)\n    assert (s[1].expr == x**2) and (s[1].start == 1) and (s[1].end == 10)\n\n    # NotImplementedError: as_set is not implemented for relationals with\n    # periodic solutions\n    p1 = Piecewise((cos(x), x < 0), (0, True))\n    f = Piecewise((0, Eq(p1, 0)), (p1 \/ Abs(p1), True))\n    raises(NotImplementedError, lambda: _process_piecewise(f, (x, -10, 10), \"F\"))\n\n    f = Piecewise((1 - x, (x >= 0) & (x < 1)), (0, True))\n    s = _process_piecewise(f, (x, -10, 10), \"test\")\n    assert len(s) == 3\n    assert all(isinstance(t, LineOver1DRangeSeries) for t in s)\n    assert (s[0].expr == 1 - x) and (s[0].start == 0) and (s[0].end == 1)\n    assert (s[1].expr == 0) and (s[1].start == -10) and (s[1].end == 0)\n    assert (s[2].expr == 0) and (s[2].start == 1) and (s[2].end == 10)\n\n    # The range is smaller than the function \"domain\"\n    f = Piecewise(\n        (1, x < -5),\n        (x, Eq(x, 0)),\n        (x**2, Eq(x, 2)),\n        (x**3, (x > 0) & (x < 2)),\n        (x**4, True)\n    )\n    s = _process_piecewise(f, (x, -3, 3), \"A\")\n    labels = [\"A2\", \"A3\", \"A4\", \"A5\", \"A5\"]\n    assert all(t.label == l for t, l in zip(s, labels))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_305","text":"import cPickle\nimport numpy as np\nfrom Bio.SVDSuperimposer import SVDSuperimposer\nfrom scipy.linalg import sqrtm, inv\n\n\ndef sym(w):\n    return w.dot(inv(sqrtm(w.T.dot(w))))\n\ndef params2cc(parameters, return_steps=False):\n    steps = []\n\n    h2_tran = parameters[-3:]\n\n    h2_rot = np.reshape(parameters[-12:-3], (3,3))\n    helical_params = np.reshape(parameters[:-12], (2,3))\n\n    h2_rot = sym(h2_rot)\n\n    h1_ref = du_mean_helix\n    if return_steps:\n        step_coords = np.append(h1_ref,h1_ref,axis=0)\n        steps.append(step_coords)\n\n    h1_dev, h2_dev = du_pca_helix.inverse_transform(helical_params)\n    h1_dev = np.reshape(h1_dev, (h1_ref.shape[0],h1_ref.shape[1]))\n    h2_dev = np.reshape(h2_dev, (h1_ref.shape[0],h1_ref.shape[1]))\n\n    h1 = h1_ref+h1_dev\n    h2 = h1_ref+h2_dev\n\n    if return_steps:\n        step_coords = np.append(h1,h2,axis=0)\n        steps.append(step_coords)\n\n    h2_new = np.dot(h2, h2_rot)\n    if return_steps:\n        step_coords = np.append(h1,h2_new,axis=0)\n        steps.append(step_coords)\n\n    h2_new = h2_new + h2_tran\n    if return_steps:\n        step_coords = np.append(h1,h2_new,axis=0)\n        steps.append(step_coords)\n\n    orig_coords = np.append(h1,h2_new,axis=0)\n\n    if return_steps:\n        return steps\n\n    return orig_coords\n\n\ndef cc2params(coords):\n\n    sup=SVDSuperimposer()\n\n    n_atoms_mono = int(coords.shape[0]\/2)\n\n    h1 = coords[:n_atoms_mono]\n    h2 = coords[n_atoms_mono:]\n    h1_ref = du_mean_helix\n\n    # align h1 and h2 with mean angles to the ref helix\n\n    sup.set(h1_ref, h1)\n    sup.run()\n    h1_aligned_ref = sup.get_transformed()\n\n    sup.set(h1_ref, h2)\n    sup.run()\n    h2_aligned_ref = sup.get_transformed()\n\n    # estimate parameters from pca\n    # center to h1_ref\n    h1_aligned_ref = h1_aligned_ref - h1_ref\n    h2_aligned_ref = h2_aligned_ref - h1_ref\n    # unwrap\n    h1_aligned_ref = np.reshape(h1_aligned_ref, (h1_aligned_ref.shape[0]*h1_aligned_ref.shape[1]))\n    h2_aligned_ref = np.reshape(h2_aligned_ref, (h2_aligned_ref.shape[0]*h2_aligned_ref.shape[1]))\n    # get params\n    helical_params =du_pca_helix.transform([h1_aligned_ref, h2_aligned_ref])\n    h1_aligned_ref, h2_aligned_ref = du_pca_helix.inverse_transform(helical_params)\n    h1_aligned_ref = np.reshape(h1_aligned_ref, (h1_ref.shape[0],h1_ref.shape[1]))\n    h2_aligned_ref = np.reshape(h2_aligned_ref, (h1_ref.shape[0],h1_ref.shape[1]))\n\n    # construct ideal helices\n\n    h1_transformed = h1_ref+h1_aligned_ref\n    h2_transformed = h1_ref+h2_aligned_ref\n\n    # adjust hi_helix1 and hi_helix2 by the parameters\n\n    # align h1 to h1 ideal and transform all coords\n\n    sup.set(h1, h1_transformed)\n    sup.run()\n    h1_ideal = sup.get_transformed()\n\n    # align h2_ideal to h2\n\n    sup.set(h2, h2_transformed)\n    sup.run()\n    h2_ideal = sup.get_transformed()\n\n    coords_ideal = np.append(h1_ideal,h2_ideal,axis=0)\n\n    # align ideal coords to the ref helix\n    sup.set(h1_transformed,h1_ideal)\n    sup.run()\n    (rot_ref, tran_ref) = sup.get_rotran()\n\n    coords_ideal = np.dot(coords_ideal,rot_ref) + tran_ref\n\n    h1_new = coords_ideal[:n_atoms_mono]\n    h2_new = coords_ideal[n_atoms_mono:]\n\n    sup.set(h2_new, h2_transformed)\n    sup.run()\n    (rot2, tran2) = sup.get_rotran()\n    h2_rot = rot2.flatten()\n    helical_params = helical_params.flatten()\n    transform_params = np.append(helical_params,np.append(h2_rot, tran2))\n\n    return transform_params\n\n\ndu_pca_helix, du_mean_helix = cPickle.load(open('helix_template.pkl', \"rb\"))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_306","text":"import sympy\nfrom qibo import gates, K\nfrom qibo.config import raise_error\n\n\nclass HamiltonianTerm:\n    \"\"\"Term of a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`.\n\n    Symbolic Hamiltonians are represented by a list of\n    :class:`qibo.core.terms.HamiltonianTerm` objects storred in the\n    ``SymbolicHamiltonian.terms`` attribute. The mathematical expression of\n    the Hamiltonian is the sum of these terms.\n\n    Args:\n        matrix (np.ndarray): Full matrix corresponding to the term representation\n            in the computational basis. Has size (2^n, 2^n) where n is the\n            number of target qubits of this term.\n        q (list): List of target qubit ids.\n    \"\"\"\n\n    def __init__(self, matrix, *q):\n        for qi in q:\n            if qi < 0:\n                raise_error(ValueError, \"Invalid qubit id {} < 0 was given \"\n                                        \"in Hamiltonian term\".format(qi))\n        if not (matrix is None or isinstance(matrix, K.qnp.numeric_types) or\n                isinstance(matrix, K.qnp.tensor_types)):\n            raise_error(TypeError, \"Invalid type {} of symbol matrix.\"\n                                   \"\".format(type(matrix)))\n        dim = int(matrix.shape[0])\n        if 2 ** len(q) != dim:\n            raise_error(ValueError, \"Matrix dimension {} given in Hamiltonian \"\n                                    \"term is not compatible with the number \"\n                                    \"of target qubits {}.\"\n                                    \"\".format(dim, len(q)))\n        self.target_qubits = tuple(q)\n        self._gate = None\n        self.hamiltonian = None\n        self._matrix = matrix\n\n    @property\n    def matrix(self):\n        \"\"\"Matrix representation of the term.\"\"\"\n        return self._matrix\n\n    @property\n    def gate(self):\n        \"\"\":class:`qibo.abstractions.gates.Unitary` gate that implements the action of the term on states.\"\"\"\n        if self._gate is None:\n            self._gate = gates.Unitary(self.matrix, *self.target_qubits)\n        return self._gate\n\n    def exp(self, x):\n        \"\"\"Matrix exponentiation of the term.\"\"\"\n        return K.qnp.expm(-1j * x * self.matrix)\n\n    def expgate(self, x):\n        \"\"\":class:`qibo.abstractions.gates.Unitary` gate implementing the action of exp(term) on states.\"\"\"\n        return gates.Unitary(self.exp(x), *self.target_qubits)\n\n    def merge(self, term):\n        \"\"\"Creates a new term by merging the given term to the current one.\n\n        The resulting term corresponds to the sum of the two original terms.\n        The target qubits of the given term should be a subset of the target\n        qubits of the current term.\n        \"\"\"\n        if not set(term.target_qubits).issubset(set(self.target_qubits)):\n            raise_error(ValueError, \"Cannot merge HamiltonianTerm acting on \"\n                                    \"qubits {} to term on qubits {}.\"\n                                    \"\".format(term.target_qubits, self.target_qubits))\n        matrix = K.np.kron(term.matrix, K.qnp.eye(2 ** (len(self) - len(term))))\n        matrix = K.np.reshape(matrix, 2 * len(self) * (2,))\n        order = []\n        i = len(term)\n        for qubit in self.target_qubits:\n            if qubit in term.target_qubits:\n                order.append(term.target_qubits.index(qubit))\n            else:\n                order.append(i)\n                i += 1\n        order.extend([x + len(order) for x in order])\n        matrix = K.np.transpose(matrix, order)\n        matrix = K.np.reshape(matrix, 2 * (2 ** len(self),))\n        return HamiltonianTerm(self.matrix + matrix, *self.target_qubits)\n\n    def __len__(self):\n        return len(self.target_qubits)\n\n    def __mul__(self, x):\n        return HamiltonianTerm(x * self.matrix, *self.target_qubits)\n\n    def __rmul__(self, x):\n        return self.__mul__(x)\n\n    def __call__(self, state, density_matrix=False):\n        \"\"\"Applies the term on a given state vector or density matrix.\"\"\"\n        if density_matrix:\n            self.gate.density_matrix = True\n            return self.gate._density_matrix_half_call(state)\n        return self.gate(state) # pylint: disable=E1102\n\n\nclass SymbolicTerm(HamiltonianTerm):\n    \"\"\":class:`qibo.core.terms.HamiltonianTerm` constructed using ``sympy`` expression.\n\n    Example:\n        ::\n\n            from qibo.symbols import X, Y\n            from qibo.core.terms import SymbolicTerm\n            sham = X(0) * X(1) + 2 * Y(0) * Y(1)\n            termsdict = sham.as_coefficients_dict()\n            sterms = [SymbolicTerm(c, f) for f, c in termsdict.items()]\n\n    Args:\n        coefficient (complex): Complex number coefficient of the underlying\n            term in the Hamiltonian.\n        factors (sympy.Expr): Sympy expression for the underlying term.\n        symbol_map (dict): Dictionary that maps symbols in the given ``factors``\n            expression to tuples of (target qubit id, matrix).\n            This is required only if the expression is not created using Qibo\n            symbols and to keep compatibility with older versions where Qibo\n            symbols were not available.\n    \"\"\"\n\n    def __init__(self, coefficient, factors=1, symbol_map={}):\n        self.coefficient = complex(coefficient)\n        self._matrix = None\n        self._gate = None\n        self.hamiltonian = None\n\n        # List of :class:`qibo.symbols.Symbol` that represent the term factors\n        self.factors = []\n        # Dictionary that maps target qubit ids to a list of matrices that act on each qubit\n        self.matrix_map = {}\n        if factors != 1:\n            for factor in factors.as_ordered_factors():\n                # check if factor has some power ``power`` so that the corresponding\n                # matrix is multiplied ``pow`` times\n                if isinstance(factor, sympy.Pow):\n                    factor, pow = factor.args\n                    assert isinstance(pow, sympy.Integer)\n                    assert isinstance(factor, sympy.Symbol)\n                    pow = int(pow)\n                else:\n                    pow = 1\n\n                # if the user is using ``symbol_map`` instead of qibo symbols,\n                # create the corresponding symbols\n                if factor in symbol_map:\n                    from qibo.symbols import Symbol\n                    q, matrix = symbol_map.get(factor)\n                    factor = Symbol(q, matrix, name=factor.name)\n\n                if isinstance(factor, sympy.Symbol):\n                    if isinstance(factor.matrix, K.qnp.tensor_types):\n                        self.factors.extend(pow * [factor])\n                        q = factor.target_qubit\n                        # if pow > 1 the matrix should be multiplied multiple\n                        # when calculating the term's total matrix so we\n                        # repeat it in the corresponding list that will\n                        # be used during this calculation\n                        # see the ``SymbolicTerm.matrix`` property for the\n                        # full matrix calculation\n                        if q in self.matrix_map:\n                            self.matrix_map[q].extend(pow * [factor.matrix])\n                        else:\n                            self.matrix_map[q] = pow * [factor.matrix]\n                    else:\n                        self.coefficient *= factor.matrix\n                elif factor == sympy.I:\n                    self.coefficient *= 1j\n                elif factor.is_number:\n                    self.coefficient *= complex(factor)\n                else: # pragma: no cover\n                    raise_error(TypeError, \"Cannot parse factor {}.\".format(factor))\n\n        self.target_qubits = tuple(sorted(self.matrix_map.keys()))\n\n    @property\n    def matrix(self):\n        \"\"\"Calculates the full matrix corresponding to this term.\n\n        Returns:\n            Matrix as a ``np.ndarray`` of shape ``(2 ** ntargets, 2 ** ntargets)``\n            where ``ntargets`` is the number of qubits included in the factors\n            of this term.\n        \"\"\"\n        if self._matrix is None:\n            def matrices_product(matrices):\n                \"\"\"Product of matrices that act on the same tuple of qubits.\n\n                Args:\n                    matrices (list): List of matrices to multiply, as exists in\n                        the values of ``SymbolicTerm.matrix_map``.\n                \"\"\"\n                if len(matrices) == 1:\n                    return matrices[0]\n                matrix = K.np.copy(matrices[0])\n                for m in matrices[1:]:\n                    matrix = matrix @ m\n                return matrix\n\n            self._matrix = self.coefficient\n            for q in self.target_qubits:\n                matrix = matrices_product(self.matrix_map.get(q))\n                self._matrix = K.np.kron(self._matrix, matrix)\n        return self._matrix\n\n    def copy(self):\n        \"\"\"Creates a shallow copy of the term with the same attributes.\"\"\"\n        new = self.__class__(self.coefficient)\n        new.factors = self.factors\n        new.matrix_map = self.matrix_map\n        new.target_qubits = self.target_qubits\n        return new\n\n    def __mul__(self, x):\n        \"\"\"Multiplication of scalar to the Hamiltonian term.\"\"\"\n        new = self.copy()\n        new.coefficient *= x\n        if self._matrix is not None:\n            new._matrix = x * self._matrix\n        return new\n\n    def __call__(self, state, density_matrix=False):\n        for factor in self.factors:\n            if density_matrix:\n                factor.gate.density_matrix = True\n                state = factor.gate._density_matrix_half_call(state)\n            else:\n                state = factor.gate(state)\n        return self.coefficient * state\n\n\nclass TermGroup(list):\n    \"\"\"Collection of multiple :class:`qibo.core.terms.HamiltonianTerm` objects.\n\n    Allows merging multiple terms to a single one for faster exponentiation\n    during Trotterized evolution.\n\n    Args:\n        term (:class:`qibo.core.terms.HamiltonianTerm`): Parent term of the group.\n            All terms appended later should target a subset of the parents'\n            target qubits.\n    \"\"\"\n\n    def __init__(self, term):\n        super().__init__([term])\n        self.target_qubits = set(term.target_qubits)\n        self._term = None\n\n    def append(self, term):\n        \"\"\"Appends a new :class:`qibo.core.terms.HamiltonianTerm` to the collection.\"\"\"\n        super().append(term)\n        self.target_qubits |= set(term.target_qubits)\n        self._term = None\n\n    def can_append(self, term):\n        \"\"\"Checks if a term can be appended to the group based on its target qubits.\"\"\"\n        return set(term.target_qubits).issubset(self.target_qubits)\n\n    @classmethod\n    def from_terms(cls, terms):\n        \"\"\"Divides a list of terms to multiple :class:`qibo.core.terms.TermGroup`s.\n\n        Terms that target the same qubits are grouped to the same group.\n\n        Args:\n            terms (list): List of :class:`qibo.core.terms.HamiltonianTerm` objects.\n\n        Returns:\n            List of :class:`qibo.core.terms.TermGroup` objects that contain\n            all the given terms.\n        \"\"\"\n        # split given terms according to their order\n        # order = len(term.target_qubits)\n        orders = {}\n        for term in terms:\n            if len(term) in orders:\n                orders[len(term)].append(term)\n            else:\n                orders[len(term)] = [term]\n\n        groups = []\n        # start creating groups with the higher order terms as parents and then\n        # append each term of lower order to the first compatible group\n        for order in sorted(orders.keys())[::-1]:\n            for child in orders[order]:\n                flag = True\n                for i, group in enumerate(groups):\n                    if group.can_append(child):\n                        group.append(child)\n                        flag = False\n                        break\n                if flag:\n                    groups.append(cls(child))\n        return groups\n\n    @property\n    def term(self):\n        \"\"\"Returns a single :class:`qibo.core.terms.HamiltonianTerm`. after merging all terms in the group.\"\"\"\n        if self._term is None:\n            self._term = self.to_term()\n        return self._term\n\n    def to_term(self, coefficients={}):\n        \"\"\"Calculates a single :class:`qibo.core.terms.HamiltonianTerm` by merging all terms in the group.\n\n        Args:\n            coefficients (dict): Optional dictionary that allows passing a different\n                coefficient to each term according to its parent Hamiltonian.\n                Useful for :class:`qibo.core.adiabatic.AdiabaticHamiltonian` calculations.\n        \"\"\"\n        c = coefficients.get(self[0].hamiltonian)\n        merged = self[0] * c if c is not None else self[0]\n        for term in self[1:]:\n            c = coefficients.get(term.hamiltonian)\n            merged = merged.merge(term * c if c is not None else term)\n        return merged\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_307","text":"import os\nimport sys\n\nsys.path.append(os.path.abspath(os.path.join(\".\/libs\/graph_embeddings\")))\nimport graph_embeddings\nimport numpy as np\nimport pandas as pd\nfrom scipy import sparse\n\nsys.path.append(os.path.abspath(os.path.join(\".\/libs\/residual2vec\")))\nimport residual2vec\n\n#\n# Input\n#\nnetfile = snakemake.input[\"netfile\"]\nnodefile = snakemake.input[\"nodefile\"] if \"nodefile\" in snakemake.input.keys() else None\ndim = int(snakemake.params[\"dim\"])\nwindow_length = int(snakemake.params[\"window_length\"])\nmodel_name = snakemake.params[\"model_name\"]\ndirected = snakemake.params[\"directed\"] == \"directed\"\nnoselfloop = (\n    snakemake.params[\"noselfloop\"] == \"True\"\n    if \"noselfloop\" in snakemake.params.keys()\n    else False\n)\ncontroll_for = (\n    snakemake.params[\"controlfor\"]\n    if \"controlfor\" in snakemake.params.keys()\n    else \"None\"\n)\nbackward_prob = (\n    float(snakemake.params[\"backward_prob\"])\n    if \"backward_prob\" in snakemake.params.keys()\n    else 0\n)\nembfile = snakemake.output[\"embfile\"]\n\n#\n# Load\n#\nnet = sparse.load_npz(netfile)\n\nif nodefile is not None:\n    node_table = pd.read_csv(nodefile)\n\n#\n# Preprocess\n#\nif directed is False:\n    net = net + net.T\n\nif noselfloop:\n    net.setdiag(0)\n\nif directed:\n    eta = backward_prob \/ (1 - backward_prob)\n    outdeg = np.array(net.sum(axis=1)).reshape(-1)\n    indeg = np.array(net.sum(axis=0)).reshape(-1)\n    eta_nodes = (\n        outdeg * backward_prob \/ (indeg * (1 - backward_prob) + outdeg * backward_prob)\n    )\n    eta_nodes[outdeg == 0] = 1\n    eta_nodes[indeg == 0] = 0\n    net = sparse.diags(1 - eta_nodes) * net + sparse.diags(eta_nodes) @ net.T\n\n#\n# Load the emebdding models\n#\nmembership = np.zeros(net.shape[0])\noffset = np.zeros(net.shape[0])\nif model_name == \"node2vec\":\n    model = graph_embeddings.Node2Vec(window_length=window_length, restart_prob=0)\nelif model_name == \"node2vec-qhalf\":\n    model = graph_embeddings.Node2Vec(\n        window_length=window_length, restart_prob=0, q=0.5\n    )\nelif model_name == \"node2vec-qdouble\":\n    model = graph_embeddings.Node2Vec(window_length=window_length, restart_prob=0, q=2)\nelif model_name == \"deepwalk\":\n    model = graph_embeddings.DeepWalk(window_length=window_length, restart_prob=0,)\nelif model_name == \"glove\":\n    model = graph_embeddings.Glove(window_length=window_length, restart_prob=0,)\nelif model_name == \"fairwalk\":\n    if (controll_for == \"None\") or (node_table is None):\n        model = graph_embeddings.Fairwalk(window_length=window_length)\n    else:\n        membership = node_table[controll_for].values\n        model = graph_embeddings.Fairwalk(\n            group_membership=membership, window_length=window_length,\n        )\nelif model_name == \"residual2vec\":\n    if (controll_for == \"None\") or (node_table is None):\n        model = residual2vec.residual2vec_matrix_factorization(window_length=window_length,)\n    else:\n        membership = node_table[controll_for].values\n        model = residual2vec.residual2vec_matrix_factorization(\n            group_membership=membership, window_length=window_length,\n        )\nelif model_name == \"leigenmap\":\n    model = graph_embeddings.LaplacianEigenMap()\nelif model_name == \"netmf\":\n    model = graph_embeddings.NetMF(window_length=window_length)\nelif model_name == \"graphsage\":\n    model = graph_embeddings.GraphSage()\nelif model_name == \"gcn\":\n    model = graph_embeddings.GCN()\nelif model_name == \"graphsage-doubleK\":\n    model = graph_embeddings.GraphSage(num_default_features=dim * 2)\nelif model_name == \"gcn-doubleK\":\n    model = graph_embeddings.GCN(num_default_features=dim * 2)\nelif model_name == \"gat\":\n    model = graph_embeddings.GAT(layer_sizes=[64, 256])\nelif model_name == \"gat-doubleK\":\n    model = graph_embeddings.GCN(num_default_features=dim * 2)\nelif model_name == \"lndeg\":  # fake embedding. Just to save offset\n    A = sparse.csr_matrix(net)\n    deg = np.array(A.sum(axis=1)).reshape(-1)\n    emb = np.zeros((len(deg), dim))\n    np.savez(\n        embfile,\n        emb=emb,\n        out_emb=emb,\n        membership=np.zeros_like(deg),\n        offset=np.log(np.maximum(deg, 1)),\n        window_length=window_length,\n        dim=dim,\n        directed=directed,\n        model_name=model_name,\n    )\n    sys.exit()\n\n\n#\n# Embedding\n#\nmodel.fit(sparse.csr_matrix(net))\nemb = model.transform(dim=dim)\n\ntry:\n    offset = model.node_offset\nexcept AttributeError:\n    pass\n\n#\n# Save\n#\nnp.savez(\n    embfile,\n    emb=emb,\n    membership=membership,\n    offset=offset,\n    window_length=window_length,\n    dim=dim,\n    directed=directed,\n    model_name=model_name,\n)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_308","text":"<filename>evidence_inference\/models\/model_0.py\nfrom os.path import join, dirname, abspath\nimport sys\n\n# this monstrosity produces the module directory in an environment where this is unpacked\nsys.path.insert(0, abspath(join(dirname(abspath(__file__)), '..', '..')))\nimport copy\nimport random\n\nimport numpy as np\nfrom scipy import stats\n\nfrom sklearn.metrics import accuracy_score, precision_recall_fscore_support, classification_report\n\nfrom gensim.models import KeyedVectors\n\nimport torch\nfrom torch import optim\nimport torch.nn as nn\nfrom torch.nn import functional as F\nfrom torch.autograd import Variable\n\nUSE_CUDA = True\n\nfrom evidence_inference.preprocess.preprocessor import SimpleInferenceVectorizer as SimpleInferenceVectorizer\nfrom evidence_inference.models.utils import PaddedSequence\nfrom evidence_inference.models.attention_distributions import TokenAttention, evaluate_model_attention_distribution\n\n\nclass CBoWEncoder(nn.Module):\n    \"\"\"Bag of words encoder for Intervention (also Comparator, Outcome) token sequences.\n\n    Note that ordering information is discarded here, and our words are represented by continuous vectors.\n    \"\"\"\n\n    def __init__(self, vocab_size, embeddings: nn.Embedding=None, embedding_dim=200, use_attention=False, condition_attention=False, tokenwise_attention=False, query_dims=None):\n        super(CBoWEncoder, self).__init__()\n\n        self.vocab_size = vocab_size\n\n        if embeddings is None:\n            self.embedding = nn.Embedding(vocab_size, embedding_dim)\n        else:\n            self.embedding = embeddings\n            self.embedding_dim = embeddings.embedding_dim\n\n        self.use_attention = use_attention\n        if self.use_attention:\n            self.attention_mechanism = TokenAttention(self.embedding_dim, self.query_dims, condition_attention, tokenwise_attention)\n\n    def forward(self, word_inputs: PaddedSequence, query_v_for_attention: torch.Tensor=None, normalize_attention_distribution=True):\n        if isinstance(word_inputs, PaddedSequence):\n            embedded = self.embedding(word_inputs.data)\n        else:\n            raise ValueError(\"Got an unexpected type {} for word_inputs {}\".format(type(word_inputs), word_inputs))\n        if self.use_attention:\n            a = self.attention_mechanism(word_inputs, embedded, query_v_for_attention, normalize=normalize_attention_distribution)\n            output = torch.sum(a * embedded, dim=1)\n            return None, output, a\n        else:\n            output = torch.sum(embedded, dim=1) \/ word_inputs.batch_sizes.unsqueeze(-1).to(torch.float)\n            return output\n\n\nclass GRUEncoder(nn.Module):\n    \"\"\" GRU encoder for Intervention (also Comparator, Outcome) token sequences.\n\n    Also contains attention mechanisms for use with this particular encoder\n    \"\"\"\n\n    def __init__(self, vocab_size, n_layers=1, hidden_size=32, embeddings: nn.Embedding=None,\n                 use_attention=False, condition_attention=False, tokenwise_attention=False, query_dims=None, bidirectional=False):\n        \"\"\" Prepares a GRU encoder for the Intervention, Comparator, or outcome token sequences.\n\n        Either initializes embedding layer from existing embeddings or creates a random one of size vocab X hidden_size.\n\n        When using attention we either:\n        * condition on a hidden unit from the encoder and some query vector of size query_dims, which passes a linear\n          combination of the two through a non-linearity (Tanh) and then compresses this to a final number\n        * or we use a linear function from the output of the encoder.\n\n        In both cases, we use a softmax over the possible outputs to impose a final attention distribution.\n        \"\"\"\n        super(GRUEncoder, self).__init__()\n        if condition_attention and not use_attention:\n            raise ValueError(\"Cannot condition attention when there is no attention mechanism! Try setting \"\n                             \"use_attention to true or condition_attention to false, \")\n        if tokenwise_attention and not use_attention:\n            raise ValueError(\"Cannot have element-wise attention when there is no attention mechanism! Try setting \"\n                             \"use_attention to true or condition_attention to false, \")\n\n        self.vocab_size = vocab_size\n        self.n_layers = n_layers\n        self.use_attention = use_attention\n        self.condition_attention = condition_attention\n        self.tokenwise_attention = tokenwise_attention\n        self.query_dims = query_dims\n        self.bidirectional = bidirectional\n        if self.bidirectional:\n            self.hidden_size = hidden_size \/\/ 2\n        else:\n            self.hidden_size = hidden_size\n\n        if embeddings is None:\n            self.embedding = nn.Embedding(self.vocab_size, self.hidden_size)\n            self.gru = nn.GRU(input_size=self.hidden_size, hidden_size=self.hidden_size, num_layers=self.n_layers, batch_first=True, bidirectional=self.bidirectional)\n        else:\n            self.embedding = embeddings\n            self.gru = nn.GRU(input_size=embeddings.embedding_dim, hidden_size=self.hidden_size, num_layers=self.n_layers, batch_first=True, bidirectional=self.bidirectional)\n\n        if self.use_attention:\n            encoding_size = self.hidden_size + int(self.bidirectional) * self.hidden_size\n            self.attention_mechanism = TokenAttention(encoding_size, self.query_dims, condition_attention, tokenwise_attention)\n\n    def forward(self, word_inputs: PaddedSequence, init_hidden: torch.Tensor=None, query_v_for_attention: torch.Tensor=None, normalize_attention_distribution=True) -> (torch.Tensor, torch.Tensor):\n        if isinstance(word_inputs, PaddedSequence):\n            embedded = self.embedding(word_inputs.data)\n            as_padded = word_inputs.pack_other(embedded)\n            output, hidden = self.gru(as_padded, init_hidden)\n            output = PaddedSequence.from_packed_sequence(output, batch_first=True)\n        else:\n            raise ValueError(\"Unknown input type {} for word_inputs: {}, try a PaddedSequence or a Tensor\".format(type(word_inputs), word_inputs))\n\n        # concatenate the hidden representations\n        if self.bidirectional:\n            if self.n_layers > 1:\n                raise ValueError(\"Implement me!\")\n            hidden = torch.cat([hidden[0], hidden[1]], dim=1)\n\n        if self.use_attention:\n            # note that these hidden_input_states are masked to zeros (when appropriate) already when this is called.\n            hidden_input_states = output\n            a = self.attention_mechanism(hidden_input_states, query_v_for_attention, normalize=normalize_attention_distribution)\n\n            # note this is an element-wise multiplication, so each of the hidden states is weighted by the attention vector\n            weighted_hidden = torch.sum(a * output.data, dim=1)\n            return output, weighted_hidden, a\n\n        return output, hidden\n\n\nclass InferenceNet(nn.Module):\n    \"\"\" Predicts the relative (statistical) benefits of a pair of medical interventions with respect to an outcome.\n\n    The input to the model is:\n    * an array of article tokens\n    * an array of medical intervention tokens\n    * an array of \"comparator\" tokens (i.e. an alternate intervention)\n    * an array of outcome tokens\n\n    The output is a distribution over whether or not the text of the particular article supports the intervention being\n    statistically better (p=0.05), neutral, or worse than the comparator for the outcome.\n\n    This model works via:\n    * encoding the article via a gated recurrent unit\n    * encoding the intervention, comparator, and outcome via either a gated recurrent unit or a continuous bag of words encoder\n    * optionally allowing a separate attention mechanism within each of these units to either:\n        * learn a distribution over article tokens\n        * learn a distribution over article tokens conditioned on the intervention, comparator, and outcome encodings\n    * passing the encoded result through a linear layer and then a softmax\n    \"\"\"\n\n    def __init__(self, vectorizer, h_size=32,\n                 init_embeddings=None,\n                 init_wvs_path=\"embeddings\/PubMed-w2v.bin\",\n                 weight_tying=False,\n                 ICO_encoder=\"CBoW\",\n                 article_encoder=\"GRU\",\n                 attention_over_article_tokens=True,\n                 condition_attention=True,\n                 tokenwise_attention=False,\n                 tune_embeddings=False,\n                 h_dropout_rate=0.2):\n        super(InferenceNet, self).__init__()\n        if condition_attention and not attention_over_article_tokens:\n            raise ValueError(\"Must have attention in order to have conditional attention!\")\n\n        self.vectorizer = vectorizer\n        vocab_size = len(self.vectorizer.idx_to_str)\n        \n        if init_embeddings is None:\n            print(\"loading pre-trained embeddings...\")\n            init_embedding_weights = InferenceNet.init_word_vectors(init_wvs_path, vectorizer)\n            print(\"done.\")\n        else:\n            print(\"Using provided embeddings\")\n            init_embedding_weights = init_embeddings\n\n        self.ICO_encoder = ICO_encoder\n\n        # this is the size of the concatenated <abstract, I, C, O> representations,\n        # which will depend on the encoder variant being used.\n        self.ICO_dims = None\n\n        if ICO_encoder == \"CBoW\":\n            self.intervention_encoder = CBoWEncoder(vocab_size=vocab_size, embeddings=init_embedding_weights)\n            self.comparator_encoder = CBoWEncoder(vocab_size=vocab_size, embeddings=init_embedding_weights)\n            self.outcome_encoder = CBoWEncoder(vocab_size=vocab_size, embeddings=init_embedding_weights)\n            if article_encoder == 'CBoW':\n                self.ICO_dims = init_embedding_weights.embedding_dim * 3\n                MLP_input_size = self.ICO_dims + init_embedding_weights.embedding_dim\n                if h_size:\n                    print(\"Warning: ignoring the hidden size as the article encoder is CBoW and emits a fixed output\")\n            elif article_encoder == 'GRU' or article_encoder == 'biGRU':\n                self.ICO_dims = init_embedding_weights.embedding_dim * 3\n                MLP_input_size = self.ICO_dims + h_size\n            else:\n                raise ValueError(\"Unknown article_encoder type {}\".format(article_encoder))\n        elif ICO_encoder == \"GRU\" or ICO_encoder == 'biGRU':\n            bidirectional = ICO_encoder == 'biGRU'\n            # then use an RNN encoder for I, C, O elements.\n            self.intervention_encoder = GRUEncoder(vocab_size=vocab_size, hidden_size=h_size,\n                                                   embeddings=init_embedding_weights, bidirectional=bidirectional)\n            self.comparator_encoder = GRUEncoder(vocab_size=vocab_size, hidden_size=h_size,\n                                                 embeddings=init_embedding_weights, bidirectional=bidirectional)\n            self.outcome_encoder = GRUEncoder(vocab_size=vocab_size, hidden_size=h_size,\n                                              embeddings=init_embedding_weights, bidirectional=bidirectional)\n            self.ICO_dims = h_size * 3 \n            if article_encoder == 'CBoW':\n                # note that the CBoW encoder ignores the h_size here\n                MLP_input_size = self.ICO_dims + init_embedding_weights.embedding_dim\n            elif article_encoder == 'GRU' or article_encoder == 'biGRU':\n                MLP_input_size = self.ICO_dims + h_size  # the input to the MLP is the concatentation of the ICO hidden states and the article hidden states.\n            else:\n                raise ValueError(\"Unknown article_encoder type {}\".format(article_encoder))\n        else:\n            raise ValueError(\"No such encoder: {}\".format(ICO_encoder))\n\n        self.article_encoder_type = article_encoder\n        if article_encoder == 'GRU' or article_encoder == 'biGRU':\n            bidirectional = article_encoder == 'biGRU'\n            self.article_encoder = GRUEncoder(vocab_size=vocab_size, hidden_size=h_size,\n                                              embeddings=init_embedding_weights,\n                                              use_attention=attention_over_article_tokens,\n                                              condition_attention=condition_attention,\n                                              tokenwise_attention=tokenwise_attention,\n                                              query_dims=self.ICO_dims,\n                                              bidirectional=bidirectional)\n        elif article_encoder == 'CBoW':\n            self.article_encoder = CBoWEncoder(vocab_size=vocab_size,\n                                               embeddings=init_embedding_weights,\n                                               use_attention=attention_over_article_tokens,\n                                               condition_attention=condition_attention,\n                                               tokenwise_attention=tokenwise_attention,\n                                               query_dims=self.ICO_dims)\n        else:\n            raise ValueError(\"Unknown article encoder type: {}\".format(article_encoder))\n\n        if not tune_embeddings:\n            print(\"freezing word embedding layer!\")\n            for layer in (\n                    self.article_encoder, self.intervention_encoder, self.comparator_encoder, self.outcome_encoder):\n                # note: we are relying on the fact that all encoders will have a\n                # \"embedding\" layer (nn.Embedding). \n                layer.embedding.requires_grad = False\n                layer.embedding.weight.requires_grad = False\n\n        # weight tying (optional)\n        # note that this is not meaningful (or, rather, does nothing) when embeddings are\n        # frozen.\n        # TODO note that weights are currently tied because all the ICOEncoders use the same underlying objects.\n        if weight_tying:\n            print(\"tying word embedding layers\")\n            self.intervention_encoder.embedding.weight = self.comparator_encoder.embedding.weight = \\\n                self.outcome_encoder.embedding.weight = self.article_encoder.embedding.weight\n        self.batch_first = True\n\n        self.MLP_hidden = nn.Linear(MLP_input_size, 16)\n        self.out = nn.Linear(16, 3)\n        self.dropout = nn.Dropout(p=h_dropout_rate)\n\n    def _encode(self, I_tokens, C_tokens, O_tokens):\n        if self.ICO_encoder == \"CBoW\":\n            # simpler case of a CBoW encoder.\n            I_v = self.intervention_encoder(I_tokens)\n            C_v = self.comparator_encoder(C_tokens)\n            O_v = self.outcome_encoder(O_tokens)\n        elif self.ICO_encoder == 'GRU' or self.ICO_encoder == 'biGRU':\n            # then we have an RNN encoder. Hidden layers are automatically initialized\n            _, I_v = self.intervention_encoder(I_tokens)\n            _, C_v = self.comparator_encoder(C_tokens)\n            _, O_v = self.outcome_encoder(O_tokens)\n        else:\n            raise ValueError(\"No such encoder: {}\".format(self.ICO_encoder))\n        return I_v, C_v, O_v\n\n    def forward(self, article_tokens: PaddedSequence, I_tokens: PaddedSequence, C_tokens: PaddedSequence, O_tokens: PaddedSequence,\n                batch_size, debug_attn=False, verbose_attn=False):\n        if isinstance(article_tokens, PaddedSequence):\n            assert all([isinstance(x, PaddedSequence) for x in [I_tokens, C_tokens, O_tokens]])\n        elif isinstance(article_tokens, torch.Tensor):\n            # TODO test this codepath\n            assert all([isinstance(x, torch.Tensor) for x in [I_tokens, C_tokens, O_tokens]]) and all([x.shape[0] == 1 for x in [article_tokens, I_tokens, C_tokens, O_tokens]])\n        else:\n            raise ValueError(\"Got an unexpected type for our input tensor: {}\".format(type(article_tokens)))\n\n        ##################################################\n        # First encode the I, C, O frame (the query)     #\n        ##################################################\n        # the output of each of these should be of shape (batch x word_embedding_size)\n        I_v, C_v, O_v = self._encode(I_tokens, C_tokens, O_tokens)\n\n        if self.article_encoder.use_attention:\n\n            query_v = None\n            if self.article_encoder.condition_attention:\n                query_v = torch.cat([I_v, C_v, O_v], dim=1)\n\n            _, a_v, attn_weights = self.article_encoder(article_tokens, query_v_for_attention=query_v)\n\n            # @TODO return to debugging\/inspecting attention\n            if verbose_attn:\n                attn_weights = attn_weights.data.cpu().numpy()\n                for i in range(batch_size):\n                    attn_weights_slice = attn_weights[i][:article_tokens.batch_sizes[i].item()].squeeze()\n                    sorted_idx = np.argsort(attn_weights_slice)\n                    # hack\n                    if sorted_idx.size == 1:\n                        continue\n                    length = len(attn_weights_slice)\n                    top_words = [self.vectorizer.idx_to_str[article_tokens.data[i][idx]] for idx in sorted_idx[max(-20, -1 * length):]]\n                    top_words.reverse()\n                    top_words_weights = [attn_weights_slice[idx] for idx in sorted_idx[max(-20, -1 * length):]]\n                    top_words_weights.reverse()\n                    bottom_words = [self.vectorizer.idx_to_str[article_tokens.data[i][idx]] for idx in sorted_idx[:min(20, length)]]\n                    bottom_words.reverse()\n                    bottom_words_weights = [attn_weights_slice[idx] for idx in sorted_idx[:min(20, length)]]\n                    bottom_words_weights.reverse()\n\n                    def tokens_to_str(tokens):\n                        return \", \".join([self.vectorizer.idx_to_str[x.item()] for x in tokens])\n                    print(\"I, C, O frame:\",\n                          tokens_to_str(I_tokens.data[i][:I_tokens.batch_sizes[i]]), \";\",\n                          tokens_to_str(C_tokens.data[i][:C_tokens.batch_sizes[i]]), \":\",\n                          tokens_to_str(O_tokens.data[i][:O_tokens.batch_sizes[i]]))\n                    print(\"top words:\", \", \".join(top_words))\n                    print(\"weights:\", \", \".join(str(x) for x in top_words_weights))\n                    print(\"bottom words:\", \", \".join(bottom_words))\n                    print(\"weights:\", \", \".join(str(x) for x in bottom_words_weights))\n\n        else:\n            if self.article_encoder_type == 'CBoW':\n                # TODO implement attention for the CBoW model\n                a_v = self.article_encoder(article_tokens)\n            elif self.article_encoder_type == 'GRU' or self.article_encoder_type == 'biGRU':\n                _, a_v = self.article_encoder(article_tokens)\n            else:\n                raise ValueError(\"Unknown article encoder type {}\".format(self.article_encoder_type))\n\n        # TODO document this\n        if len(a_v.size()) == 3:\n            a_v = a_v.squeeze(0)\n        h = torch.cat([a_v, I_v, C_v, O_v], dim=1)\n        h = self.dropout(h)\n        raw_out = self.out(self.MLP_hidden(h))\n\n        return F.softmax(raw_out, dim=1)\n\n    @classmethod\n    def init_word_vectors(cls, path_to_wvs, vectorizer, use_cuda=USE_CUDA) -> nn.Embedding:\n        WVs = KeyedVectors.load_word2vec_format(path_to_wvs, binary=True)\n\n        E = np.zeros((len(vectorizer.str_to_idx), WVs.vector_size))\n        WV_matrix = np.matrix([WVs[v] for v in WVs.vocab.keys()])\n        mean_vector = np.mean(WV_matrix, axis=0)\n\n        for idx, token in enumerate(vectorizer.idx_to_str):\n            if token in WVs:\n                E[idx] = WVs[token]\n            else:\n                E[idx] = mean_vector\n        # TODO make this cleaner\n        padding_idx = int(vectorizer.str_to_idx[SimpleInferenceVectorizer.PAD])\n        E[padding_idx] = torch.zeros(E.shape[1])\n        embedding = nn.Embedding(E.shape[0], E.shape[1], padding_idx=padding_idx)\n        embedding.weight.data.copy_(torch.from_numpy(E))\n        embedding.weight.requires_grad = False\n        if use_cuda:\n            embedding = embedding.cuda()\n        return embedding\n\n\ndef _get_y_vec(y_dict, as_vec=True, majority_lbl=True) -> torch.LongTensor:\n    # +1 because raw labels are -1, 0, 1 -> 0, 1, 2\n    # for indexing reasons that appear in the loss function\n    # (cross-entropy loss wants the index of the highest value, and we index at 0)\n    all_labels = [y_j[0] + 1 for y_j in y_dict]\n    if majority_lbl:\n        y_collapsed = int(stats.mode(all_labels)[0][0])\n    else:\n        y_collapsed = random.choice(all_labels)\n\n    if as_vec:\n        y_vec = np.zeros(3)\n        y_vec[y_collapsed] = 1.0\n        ret = torch.LongTensor(y_vec)\n    else:\n        ret = torch.LongTensor([y_collapsed])\n    if USE_CUDA:\n        ret = ret.cuda()\n    return ret\n\n\ndef _to_torch_var(x):\n    var_x = Variable(torch.LongTensor(x))\n    if USE_CUDA:\n        var_x = var_x.cuda()\n    return var_x\n\n\ndef predict_for_inst(nnet, inst, verbose_attn=False):\n    abstract = _to_torch_var(inst[\"article\"]).unsqueeze(0)\n    I, C, O = _to_torch_var(inst[\"I\"]).unsqueeze(0), _to_torch_var(inst[\"C\"]).unsqueeze(0), _to_torch_var(inst[\"O\"]).unsqueeze(0)\n    print(\"sizes:\", abstract.size(), I.size(), C.size(), O.size())\n    y_hat = nnet(abstract, I, C, O, batch_size=1, verbose_attn=verbose_attn)\n    return y_hat\n\n\n'''\ndef conf_matrix(nnet, instances):\n    M = np.zeros((3,3))\n    for inst in instances:\n        y = _get_y_vec(inst['y'], as_vec=False)\n        y_hat = np.argmax(predict_for_inst(nnet, inst))\n        M[y, y_hat] += 1.0\n    return M\n'''\n\n\ndef make_preds(nnet, instances, batch_size, inference_vectorizer, verbose_attn_to_batches=False, cuda=USE_CUDA):\n    # TODO consider removing the inference_vectorizer since all we need is an unk_idx from it\n    y_vec = torch.cat([_get_y_vec(inst['y'], as_vec=False) for inst in instances]).squeeze()\n    unk_idx = int(inference_vectorizer.str_to_idx[SimpleInferenceVectorizer.PAD])\n    y_hat_vec = []\n    # we batch this so the GPU doesn't run out of memory\n    nnet.eval()\n    for i in range(0, len(instances), batch_size):\n        batch_instances = instances[i:i+batch_size]\n        articles, Is, Cs, Os = [PaddedSequence.autopad([torch.LongTensor(inst[x]) for inst in batch_instances], batch_first=True, padding_value=unk_idx) for x in ['article', 'I', 'C', 'O']]\n        if cuda:\n            articles, Is, Cs, Os = articles.cuda(), Is.cuda(), Cs.cuda(), Os.cuda()\n        verbose_attn = verbose_attn_to_batches and i in verbose_attn_to_batches\n        y_hat_batch = nnet(articles, Is, Cs, Os, batch_size=len(batch_instances), verbose_attn=verbose_attn)\n        y_hat_vec.append(y_hat_batch)\n    nnet.train()\n    return y_vec, torch.cat(y_hat_vec, dim=0)\n\n\ndef to_int_preds(y):\n    # the cast to int is necessary as this gets passed to sklearn packages that don't understand numpy.int64, which is the default return type here.\n    return [int(np.argmax(y_i)) for y_i in y.cpu()]\n\n\ndef _loss_for_inst(inst, nnet, criterion):\n    y = _get_y_vec(inst['y'], as_vec=False).squeeze()\n    y_hat = predict_for_inst(nnet, inst)\n    ####\n    # as per https:\/\/github.com\/pytorch\/pytorch\/issues\/5554, \n    # output needs to have dims (N, C), so we add an extra\n    # dim for N here (just 1).\n    y_hat = torch.unsqueeze(y_hat, dim=0)\n    if USE_CUDA:\n        y_hat = y_hat.cuda()\n        y = y.cuda()\n\n    return criterion(y_hat, y)\n\n\ndef _get_majority_label(inst):\n    all_lbls = [y[0] + 1 for y in inst['y']]\n    return stats.mode(all_lbls)[0][0]\n\n\ndef train(ev_inf: InferenceNet, train_Xy, val_Xy, test_Xy, inference_vectorizer, epochs=10, batch_size=16, shuffle=True):\n    # we sort these so batches all have approximately the same length (ish), which decreases the \n    # average amount of padding needed, and thus total number of steps in training.\n    if not shuffle:\n        train_Xy.sort(key=lambda x: len(x['article']))\n        val_Xy.sort(key=lambda x: len(x['article']))\n        test_Xy.sort(key=lambda x: len(x['article']))\n    print(\"Using {} training examples, {} validation examples, {} testing examples\".format(len(train_Xy), len(val_Xy), len(test_Xy)))\n    most_common = stats.mode([_get_majority_label(inst) for inst in train_Xy])[0][0]\n\n    best_val_model = None\n    best_val_f1 = float('-inf')\n    if USE_CUDA:\n        ev_inf = ev_inf.cuda()\n\n    optimizer = optim.Adam(ev_inf.parameters())\n    criterion = nn.CrossEntropyLoss(reduction='sum')  # sum (not average) of the batch losses.\n\n    # TODO add epoch timing information here\n    epochs_since_improvement = 0\n    val_metrics = {\n        \"val_acc\": [],\n        \"val_p\": [],\n        \"val_r\": [],\n        \"val_f1\": [],\n        \"val_loss\": [],\n        'train_loss': [],\n        'val_aucs': [],\n        'train_aucs': [],\n        'val_entropies': [],\n        'val_evidence_token_mass': [],\n        'val_evidence_token_err': [],\n        'train_entropies': [],\n        'train_evidence_token_mass': [],\n        'train_evidence_token_err': []\n    }\n    for epoch in range(epochs):\n        if epochs_since_improvement > 10:\n            print(\"Exiting early due to no improvement on validation after 10 epochs.\")\n            break\n        if shuffle:\n            random.shuffle(train_Xy)\n\n        epoch_loss = 0\n        for i in range(0, len(train_Xy), batch_size):\n            instances = train_Xy[i:i+batch_size]\n            ys = torch.cat([_get_y_vec(inst['y'], as_vec=False) for inst in instances], dim=0)\n            # TODO explain the use of padding here\n            unk_idx = int(inference_vectorizer.str_to_idx[SimpleInferenceVectorizer.PAD])\n            articles, Is, Cs, Os = [PaddedSequence.autopad([torch.LongTensor(inst[x]) for inst in instances], batch_first=True, padding_value=unk_idx) for x in ['article', 'I', 'C', 'O']]\n            optimizer.zero_grad()\n            if USE_CUDA:\n                articles, Is, Cs, Os = articles.cuda(), Is.cuda(), Cs.cuda(), Os.cuda()\n                ys = ys.cuda()\n            verbose_attn = (epoch == epochs - 1 and i == 0) or (epoch == 0 and i == 0)\n            if verbose_attn:\n                print(\"Training attentions:\")\n            tags = ev_inf(articles, Is, Cs, Os, batch_size=len(instances), verbose_attn=verbose_attn)\n            loss = criterion(tags, ys)\n            #if loss.item() != loss.item():\n            #    import pdb; pdb.set_trace()\n            epoch_loss += loss.item()\n            loss.backward()\n            optimizer.step()\n        val_metrics['train_loss'].append(epoch_loss)\n\n        with torch.no_grad():\n            verbose_attn_to_batches = set([0,1,2,3,4]) if epoch == epochs - 1 or epoch == 0 else False\n            if verbose_attn_to_batches:\n                print(\"Validation attention:\")\n            # make_preds runs in eval mode\n            val_y, val_y_hat = make_preds(ev_inf, val_Xy, batch_size, inference_vectorizer, verbose_attn_to_batches=verbose_attn_to_batches)\n            val_loss = criterion(val_y_hat, val_y.squeeze())\n            y_hat = to_int_preds(val_y_hat)\n\n            if epoch == 0:\n                dummy_preds = [most_common] * len(val_y)\n                dummy_acc = accuracy_score(val_y.cpu(), dummy_preds)\n                val_metrics[\"baseline_val_acc\"] = dummy_acc\n                p, r, f1, _ = precision_recall_fscore_support(val_y.cpu(), dummy_preds, labels=None, beta=1, average='macro', pos_label=1, warn_for=('f-score',), sample_weight=None)\n                val_metrics['p_dummy'] = p\n                val_metrics['r_dummy'] = r\n                val_metrics['f_dummy'] = f1\n\n                print(\"val dummy accuracy: {:.3f}\".format(dummy_acc))\n                print(\"classification report for dummy on val: \")\n                print(classification_report(val_y.cpu(), dummy_preds))\n                print(\"\\n\\n\")\n\n            acc = accuracy_score(val_y.cpu(), y_hat)\n            val_metrics[\"val_acc\"].append(acc)\n            val_loss = val_loss.cpu().item()\n            val_metrics[\"val_loss\"].append(val_loss)\n           \n            # f1 = f1_score(val_y, y_hat, average=\"macro\")\n            p, r, f1, _ = precision_recall_fscore_support(val_y.cpu(), y_hat, labels=None, beta=1, average='macro', pos_label=1, warn_for=('f-score',), sample_weight=None)\n            val_metrics[\"val_f1\"].append(f1)\n            val_metrics[\"val_p\"].append(p)\n            val_metrics[\"val_r\"].append(r)\n\n            if ev_inf.article_encoder.use_attention:\n                train_auc, train_entropies, train_evidence_token_masses, train_evidence_token_err = evaluate_model_attention_distribution(ev_inf, train_Xy, cuda=USE_CUDA, compute_attention_diagnostics=True)\n                val_auc, val_entropies, val_evidence_token_masses, val_evidence_token_err = evaluate_model_attention_distribution(ev_inf, val_Xy, cuda=USE_CUDA, compute_attention_diagnostics=True)\n                print(\"train auc: {:.3f}, entropy: {:.3f}, evidence mass: {:.3f}, err: {:.3f}\".format(train_auc, train_entropies, train_evidence_token_masses, train_evidence_token_err))\n                print(\"val auc: {:.3f}, entropy: {:.3f}, evidence mass: {:.3f}, err: {:.3f}\".format(val_auc, val_entropies, val_evidence_token_masses, val_evidence_token_err))\n            else:\n                train_auc, train_entropies, train_evidence_token_masses, train_evidence_token_err = \"\", \"\", \"\", \"\"\n                val_auc, val_entropies, val_evidence_token_masses, val_evidence_token_err = \"\", \"\", \"\", \"\"\n            val_metrics['train_aucs'].append(train_auc)\n            val_metrics['train_entropies'].append(train_entropies)\n            val_metrics['train_evidence_token_mass'].append(train_evidence_token_masses)\n            val_metrics['train_evidence_token_err'].append(train_evidence_token_err)\n            val_metrics['val_aucs'].append(val_auc)\n            val_metrics['val_entropies'].append(val_entropies)\n            val_metrics['val_evidence_token_mass'].append(val_evidence_token_masses)\n            val_metrics['val_evidence_token_err'].append(val_evidence_token_err)\n            if f1 > best_val_f1:\n                print(\"New best model at {} with val f1 {:.3f}\".format(epoch, f1))\n                best_val_f1 = f1\n                best_val_model = copy.deepcopy(ev_inf)\n                epochs_since_improvement = 0\n            else:\n                epochs_since_improvement += 1\n\n            #if val_loss != val_loss or epoch_loss != epoch_loss:\n            #    import pdb; pdb.set_trace()\n\n            print(\"epoch {}. train loss: {}; val loss: {}; val acc: {:.3f}\".format(\n                epoch, epoch_loss, val_loss, acc))\n       \n            print(classification_report(val_y.cpu(), y_hat))\n            print(\"val macro f1: {0:.3f}\".format(f1))\n            print(\"\\n\\n\")\n\n    val_metrics['best_val_f1'] = best_val_f1\n    with torch.no_grad():\n        print(\"Test attentions:\")\n        verbose_attn_to_batches = set([0,1,2,3,4])\n        # make_preds runs in eval mode\n        test_y, test_y_hat = make_preds(best_val_model, test_Xy, batch_size, inference_vectorizer, verbose_attn_to_batches=verbose_attn_to_batches)\n        test_loss = criterion(test_y_hat, test_y.squeeze())\n        y_hat = to_int_preds(test_y_hat)\n        final_test_preds = zip([t['a_id'] for t in test_Xy], [t['p_id'] for t in test_Xy], y_hat)\n\n        acc = accuracy_score(test_y.cpu(), y_hat)\n        val_metrics[\"test_acc\"] = acc\n        test_loss = test_loss.cpu().item()\n        val_metrics[\"test_loss\"] = test_loss\n\n        # f1 = f1_score(test_y, y_hat, average=\"macro\")\n        p, r, f1, _ = precision_recall_fscore_support(test_y.cpu(), y_hat, labels=None, beta=1, average='macro', pos_label=1, warn_for=('f-score',), sample_weight=None)\n        val_metrics[\"test_f1\"] = f1\n        val_metrics[\"test_p\"] = p\n        val_metrics[\"test_r\"] = r\n        if ev_inf.article_encoder.use_attention:\n            test_auc, test_entropies, test_evidence_token_masses, test_evidence_token_err = evaluate_model_attention_distribution(best_val_model, test_Xy, cuda=USE_CUDA, compute_attention_diagnostics=True)\n            print(\"test auc: {:.3f}, , entropy: {:.3f}, kl_to_uniform {:.3f}\".format(test_auc, test_entropies, test_evidence_token_masses))\n        else:\n            test_auc, test_entropies, test_evidence_token_masses, test_evidence_token_err = \"\", \"\", \"\", \"\"\n        val_metrics['test_auc'] = test_auc\n        val_metrics['test_entropy'] = test_entropies\n        val_metrics['test_evidence_token_mass'] = test_evidence_token_masses\n        val_metrics['test_evidence_token_err'] = test_evidence_token_err\n\n        print(\"test loss: {}; test acc: {:.3f}\".format(test_loss, acc))\n\n        print(classification_report(test_y.cpu(), y_hat))\n        print(\"test macro f1: {}\".format(f1))\n        print(\"\\n\\n\")\n\n    return best_val_model, inference_vectorizer, train_Xy, val_Xy, val_metrics, final_test_preds\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_309","text":"<reponame>LCAV\/lippmann-photography\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Jun 21 16:27:58 2017\n\n@author: gbaechle\n\"\"\"\n\nfrom scipy import misc, io\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom skimage.color import rgb2xyz, xyz2rgb\nfrom lippmann import *\nimport imageio\n\nimport sys\nsys.path.append(\"..\/\")\nimport color_tools as ct\n\nplt.close('all')\n\n\n\ndef read_image(path):\n\n    return imageio.imread(path).astype(float)\/255.\n    \n    \ndef compute_spectrum_slice(sliced, lambdas):\n    \n    #comppute the spectrum\n    im_xyz   = xyz2rgb(sliced.reshape((1,-1,3))).reshape(-1, 3)\n    spectrum = ct.from_xyz_to_spectrum(im_xyz, lambdas)\n    \n    return spectrum\n    \n\ndef compute_lippmann_slice(spectrums, lambdas, depths):\n    \n    lippmann = np.zeros((len(spectrums), len(depths)))\n    \n    for i, s in enumerate(spectrums):\n        print(i)\n        lip, _ = lippmann_transform(lambdas, s, depths) \n        lippmann[i, :] = lip\n        \n    return lippmann\n    \n    \ndef compute_end_plate(im, lambdas, vmax):\n    \n    two_k = 4 * np.pi \/ lambdas\n    \n    im_xyz   = xyz2rgb(im)\n    spectrums = ct.from_xyz_to_spectrum(im_xyz, lambdas)\n    \n    intensity = -np.trapz(spectrums, two_k*c\/2, axis=2)\n    mpl.image.imsave('Figures\/baseline.png', intensity, vmax=vmax, vmin=0)\n    \n    return intensity\n\n    \ndef generate_slices(im, N=500):\n    \n    lambdas, _ = generate_wavelengths(N)\n    depths = generate_depths(delta_z=2.5E-9, max_depth=2.5E-6)\n    \n    H = 883-1\n    L = 883-1\n    slice1 = compute_spectrum_slice(im[:H, L, :3], lambdas)\n    slice2 = compute_spectrum_slice(im[H, :L, :3], lambdas)\n    slice3 = compute_spectrum_slice(im[:H, 0, :3], lambdas)\n    slice4 = compute_spectrum_slice(im[0, :L, :3], lambdas)\n    \n    lip1 = compute_lippmann_slice(slice1, lambdas, depths)\n    lip2 = compute_lippmann_slice(slice2, lambdas, depths)\n    lip3 = compute_lippmann_slice(slice3, lambdas, depths)\n    lip4 = compute_lippmann_slice(slice4, lambdas, depths)\n    \n    print(np.max(lip1), np.max(lip2), np.max(lip3), np.max(lip4))\n    vmax = max(np.max(lip1), np.max(lip2), np.max(lip3), np.max(lip4))\n    \n    for i in range(1,5):    \n        \n        i_str = str(i)\n        mpl.image.imsave('Figures\/slice' + i_str + '.png', eval('lip' + i_str), vmax=vmax)\n    \n    return lambdas, vmax\n    \n    \n    \nif __name__ == '__main__':\n    \n#    path = '..\/images\/original.png'\n    path = '..\/images\/lippmann_image.jpg'\n    im = read_image(path)   \n    \n    lambdas, vmax = generate_slices(im, N=500)\n    \n#    spectrum = compute_end_plate(im[:800, :750, :3], lambdas, vmax) \n    spectrum = compute_end_plate(im[:, :, :3], lambdas, vmax) \n    \n#    misc.imsave('Figures\/front.png', im[:800, :750])\n    misc.imsave('Figures\/front.png', im)\n    \n    plt.figure()\n    plt.imshow(im)\n    plt.figure()\n#    plt.imshow(im[:800, :750, :3])\n    plt.imshow(im[:, :, :3])\n    \n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_310","text":"<filename>testing\/gen_feature_space_samples.py\nimport numpy as np\nimport pandas as pd\nimport graphviz\nimport graphviz.backend\nfrom numpy.distutils.system_info import f2py_info\nfrom sklearn import tree\nfrom sklearn.datasets import load_boston, load_iris, load_wine, load_digits, load_breast_cancer, load_diabetes, fetch_mldata\nfrom matplotlib.figure import figaspect\nimport string\nimport re\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom dtreeviz.shadow import *\nfrom numbers import Number\nimport matplotlib.patches as patches\nfrom scipy import stats\nfrom sklearn.neighbors import KernelDensity\nimport inspect, sys, tempfile\n\nfrom dtreeviz.trees import *\n\ndef viz_digits(features, feature_names, max_depth):\n    digits = load_digits()\n\n    # \"8x8 image of integer pixels in the range 0..16.\"\n    columns = [f'pixel[{i},{j}]' for i in range(8) for j in range(8)]\n\n    fig, ax = plt.subplots(1, 1)\n    X_train = digits.data[:,features]\n    y_train = digits.target\n    if len(features)==1:\n        x_train = digits.data[:, features[0]]\n\n        ctreeviz_univar(ax, x_train, y_train, max_depth=max_depth, feature_name=feature_names[0],\n                        class_names=[str(i) for i in range(10)], gtype='strip', target_name='digit')\n        filename = f\"\/tmp\/digits-{feature_names[0]}-featspace-depth-{max_depth}.svg\"\n    else:\n        ctreeviz_bivar(ax, X_train, y_train, max_depth=max_depth,\n                       feature_names=feature_names, class_names=[str(i) for i in range(10)], target_name='digit')\n        filename = f\"\/tmp\/digits-{','.join(feature_names)}-featspace-depth-{max_depth}.svg\"\n\n    print(f\"Create {filename}\")\n    plt.tight_layout()\n    plt.savefig(filename, bbox_inches=0, pad_inches=0)\n    plt.show()\n    # plt.close()\n\ndef viz_wine(features, feature_names, max_depth):\n    wine = load_wine()\n\n    X_train = wine.data[:,features]\n    y_train = wine.target\n    if len(features)==1:\n        figsize = (6, 2)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        x_train = wine.data[:, features[0]]\n\n        ctreeviz_univar(ax, x_train, y_train, max_depth=max_depth, feature_name=feature_names[0],\n                        class_names=list(wine.target_names), gtype='strip', target_name='wine')\n        filename = f\"\/tmp\/wine-{feature_names[0]}-featspace-depth-{max_depth}.svg\"\n    else:\n        figsize = (6, 5)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        ctreeviz_bivar(ax, X_train, y_train, max_depth=max_depth,\n                       feature_names=feature_names, class_names=list(wine.target_names), target_name='wine',show={'splits'})\n        filename = f\"\/tmp\/wine-{','.join(feature_names)}-featspace-depth-{max_depth}.svg\"\n\n    print(f\"Create {filename}\")\n    plt.tight_layout()\n    plt.savefig(filename, bbox_inches=0, pad_inches=0)\n    plt.show()\n\n\ndef viz_knowledge(features, feature_names, max_depth):\n    know = pd.read_csv(\"data\/knowledge.csv\")\n    class_names = ['very_low', 'Low', 'Middle', 'High']\n    know['UNS'] = know['UNS'].map({n: i for i, n in enumerate(class_names)})\n\n    X_train = know.drop('UNS', axis=1)\n    X_train = X_train.values[:,features]\n    y_train = know['UNS']\n    if len(features)==1:\n        figsize = (6, 2)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        x_train = know.PEG\n\n        ctreeviz_univar(ax, x_train, y_train, max_depth=max_depth, feature_name=feature_names[0],\n                        class_names=class_names, gtype='strip', target_name='knowledge')\n        filename = f\"\/tmp\/knowledge-{feature_names[0]}-featspace-depth-{max_depth}.svg\"\n    else:\n        figsize = (6, 5)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        ctreeviz_bivar(ax, X_train, y_train, max_depth=max_depth,\n                       feature_names=feature_names, class_names=class_names, target_name='knowledge')\n        filename = f\"\/tmp\/knowledge-{','.join(feature_names)}-featspace-depth-{max_depth}.svg\"\n\n    print(f\"Create {filename}\")\n    plt.tight_layout()\n    plt.savefig(filename, bbox_inches=0, pad_inches=0)\n    plt.show()\n\n\ndef viz_diabetes(features, feature_names, max_depth):\n    diabetes = load_diabetes()\n\n    X_train = diabetes.data\n    X_train = X_train[:,features]\n    y_train = diabetes.target\n    if len(features)==1:\n        figsize = (6, 2)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        x_train = diabetes.data[:, features[0]]\n\n        rtreeviz_univar(ax, x_train, y_train, max_depth=max_depth, feature_name=feature_names[0], target_name='diabetes')\n        filename = f\"\/tmp\/diabetes-{feature_names[0]}-featspace-depth-{max_depth}.svg\"\n    else:\n        figsize = (6, 5)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        rtreeviz_bivar_heatmap(ax, X_train, y_train, max_depth=max_depth,\n                               feature_names=feature_names)\n        filename = f\"\/tmp\/diabetes-{','.join(feature_names)}-featspace-depth-{max_depth}.svg\"\n\n    print(f\"Create {filename}\")\n    plt.tight_layout()\n    plt.savefig(filename, bbox_inches=0, pad_inches=0)\n    plt.show()\n\n\ndef viz_boston(features, feature_names, max_depth):\n    boston = load_boston()\n\n    X_train = boston.data\n    X_train = X_train[:,features]\n    y_train = boston.target\n    if len(features)==1:\n        figsize = (6, 2)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        x_train = boston.data[:, features[0]]\n\n        rtreeviz_univar(ax, x_train, y_train, max_depth=max_depth, feature_name=feature_names[0], target_name='price')\n        filename = f\"\/tmp\/boston-{feature_names[0]}-featspace-depth-{max_depth}.svg\"\n    else:\n        figsize = (6, 5)\n        fig, ax = plt.subplots(1, 1, figsize=figsize)\n        rtreeviz_bivar_heatmap(ax, X_train, y_train, max_depth=max_depth,\n                               feature_names=feature_names)\n        filename = f\"\/tmp\/boston-{','.join(feature_names)}-featspace-depth-{max_depth}.svg\"\n\n    print(f\"Create {filename}\")\n    plt.tight_layout()\n    plt.savefig(filename, bbox_inches=0, pad_inches=0)\n    plt.show()\n\n\nviz_boston(features=[5],feature_names=['RM'], max_depth=2)\nviz_boston(features=[5],feature_names=['RM'], max_depth=4)\nviz_boston(features=[5,12],feature_names=['RM','LSTAT'], max_depth=2)\nviz_boston(features=[5,12],feature_names=['RM','LSTAT'], max_depth=4)\n\nviz_diabetes(features=[2],feature_names=['bmi'], max_depth=2)\nviz_diabetes(features=[2],feature_names=['bmi'], max_depth=5)\nviz_diabetes(features=[2,0],feature_names=['bmi','age'], max_depth=2)\nviz_diabetes(features=[2,0],feature_names=['bmi','age'], max_depth=5)\n\nviz_knowledge(features=[4],feature_names=['PEG'], max_depth=2)\nviz_knowledge(features=[4],feature_names=['PEG'], max_depth=3)\nviz_knowledge(features=[4,3],feature_names=['PEG','LPR'], max_depth=2)\nviz_knowledge(features=[4,3],feature_names=['PEG','LPR'], max_depth=3)\n\nviz_wine(features=[12],feature_names=['proline'], max_depth=2)\nviz_wine(features=[12],feature_names=['proline'], max_depth=3)\nviz_wine(features=[12,6],feature_names=['proline','flavanoids'], max_depth=1)\nviz_wine(features=[12,6],feature_names=['proline','flavanoids'], max_depth=2)\nviz_wine(features=[12,6],feature_names=['proline','flavanoids'], max_depth=3)\nviz_digits(features=[2*8+5], feature_names=['pixel[2,5]'], max_depth=20)\nviz_digits(features=[4*8+4,2*8+5], feature_names=['pixel[4,4]','pixel[2,5]'], max_depth=5)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_311","text":"<reponame>appleface2050\/Coursera-ML\n# coding:utf-8\n\nimport numpy as np\nimport pandas as pd\nfrom sklearn import svm\nimport seaborn as sns\nimport scipy.io as sio\nimport matplotlib.pyplot as plt\nfrom sklearn import metrics\n\nif __name__ == '__main__':\n    mat = sio.loadmat('data\/ex6data3.mat')\n    print(mat.keys())\n    training = pd.DataFrame(mat.get('X'), columns=['X1', 'X2'])\n    training['y'] = mat.get('y')\n\n    cv = pd.DataFrame(mat.get('Xval'), columns=['X1', 'X2'])\n    cv['y'] = mat.get('yval')\n    print(training.shape)\n    print(training.head())\n\n    print(cv.shape)\n    print(cv.head())\n\n    candidate = [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100]\n    # gamma to comply with sklearn parameter name\n    combination = [(C, gamma) for C in candidate for gamma in candidate]\n    print(len(combination))\n\n    search = []\n\n    for C, gamma in combination:\n        svc = svm.SVC(C=C, gamma=gamma)\n        svc.fit(training[['X1', 'X2']], training['y'])\n        search.append(svc.score(cv[['X1', 'X2']], cv['y']))\n    print(search)\n    best_score = search[np.argmax(search)]\n    best_param = combination[np.argmax(search)]\n    print(best_score, best_param)\n\n    best_svc = svm.SVC(C=best_param[1], gamma=best_param[0])\n    best_svc.fit(training[['X1', 'X2']], training['y'])\n    ypred = best_svc.predict(cv[['X1', 'X2']])\n\n    print(metrics.classification_report(cv['y'], ypred))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_312","text":"<gh_stars>1-10\n\nimport os\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.dates as mdates\nfrom matplotlib.dates import MonthLocator\n# import matplotlib.ticker\nimport numpy as np\nfrom sense.canopy import OneLayer\nfrom sense.soil import Soil\nfrom sense import model\nimport scipy.stats\nfrom scipy.optimize import minimize\nimport pdb\n\n\n# Helper functions for statistical parameters\n#--------------------------------------------\ndef rmse_prediction(predictions, targets):\n    \"\"\" calculation of RMSE \"\"\"\n    return np.sqrt(np.nanmean((predictions - targets) ** 2))\n\ndef linregress(predictions, targets):\n    \"\"\" Calculate a linear least-squares regression for two sets of measurements \"\"\"\n    slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(predictions, targets)\n    return slope, intercept, r_value, p_value, std_err\n\ndef read_mni_data(path, file_name, extention, field, sep=';'):\n    \"\"\" read MNI campaign data \"\"\"\n    df = pd.io.parsers.read_csv(os.path.join(path, file_name + extension), header=[0, 1], sep=sep)\n    df = df.set_index(pd.to_datetime(df[field]['date']))\n    df = df.drop(df.filter(like='date'), axis=1)\n    return df\n\ndef read_agrometeo(path, file_name, extentio, sep=';', decimal=','):\n    \"\"\" read agro-meteorological station (hourly data) \"\"\"\n    df = pd.read_csv(os.path.join(path, file_name + extension), sep=sep, decimal=decimal)\n    df['SUM_NN050'] = df['SUM_NN050'].str.replace(',','.')\n    df['SUM_NN050'] = df['SUM_NN050'].str.replace('-','0').astype(float)\n\n    df['date'] = df['Tag'] + ' ' + df['Stunde']\n\n    df = df.set_index(pd.to_datetime(df['date'], format='%d.%m.%Y %H:%S'))\n    return df\n\ndef filter_relativorbit(data, field, orbit1, orbit2=None, orbit3=None, orbit4=None):\n    \"\"\" data filter for relativ orbits \"\"\"\n    output = data[[(check == orbit1 or check == orbit2 or check == orbit3 or check == orbit4) for check in data[(field,'relativeorbit')]]]\n    return output\n\ndef smooth(x,window_len=11,window='hanning'):\n        if x.ndim != 1:\n                raise ValueError #, \"smooth only accepts 1 dimension arrays.\"\n        if x.size < window_len:\n                raise ValueError #, \"Input vector needs to be bigger than window size.\"\n        if window_len<3:\n                return x\n        if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:\n                raise ValueError #, \"Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'\"\n        s=np.r_[2*x[0]-x[window_len-1::-1],x,2*x[-1]-x[-1:-window_len:-1]]\n        if window == 'flat': #moving average\n                w=np.ones(window_len,'d')\n        else:\n                w=eval('np.'+window+'(window_len)')\n        y=np.convolve(w\/w.sum(),s,mode='same')\n        return y[window_len:-window_len+1]\n\ndef read_data(path, file_name, extension, field, path_agro, file_name_agro, extension_agro):\n    # Read MNI data\n    df = read_mni_data(path, file_name, extension, field)\n\n    # Read agro-meteorological station\n    df_agro = read_agrometeo(path_agro, file_name_agro, extension_agro)\n\n    # filter for field\n    field_data = df.filter(like=field)\n\n    # filter for relativorbit\n    field_data_orbit = filter_relativorbit(field_data, field, 95, 168)\n    # field_data = field_data_orbit\n\n    # get rid of NaN values\n    parameter_nan = 'LAI'\n    field_data = field_data[~np.isnan(field_data.filter(like=parameter_nan).values)]\n\n    # available auxiliary data\n    theta_field = np.deg2rad(field_data.filter(like='theta'))\n    # theta_field[:] = 45\n    sm_field = field_data.filter(like='SM')\n    height_field = field_data.filter(like='Height')\/100\n    lai_field = field_data.filter(like='LAI')\n    vwc_field = field_data.filter(like='VWC')\n    pol_field = field_data.filter(like='sigma_sentinel_'+pol)\n    return df, df_agro, field_data, field_data_orbit, theta_field, sm_field, height_field, lai_field, vwc_field, pol_field\n\n### Optimization ###\n#-----------------------------------------------------------------\ndef solve_fun(VALS):\n\n    for i in range(len(var_opt)):\n        dic[var_opt[i]] = VALS[i]\n\n    ke = dic['coef'] * np.sqrt(dic['lai'])\n    # ke = dic['coef'] * np.sqrt(dic['vwc'])\n    # ke=1\n    dic['ke'] = ke\n\n    # surface\n    soil = Soil(mv=dic['mv'], C_hh=dic['C_hh'], C_vv=dic['C_vv'], D_hh=dic['D_hh'], D_vv=dic['D_vv'], C_hv=dic['C_hv'], D_hv=dic['D_hv'], V2=dic['V2'], s=dic['s'], clay=dic['clay'], sand=dic['sand'], f=dic['f'], bulk=dic['bulk'], l=dic['l'])\n\n    # canopy\n    can = OneLayer(canopy=dic['canopy'], ke_h=dic['ke'], ke_v=dic['ke'], d=dic['d'], ks_h = dic['omega']*dic['ke'], ks_v = dic['omega']*dic['ke'], V1=dic['V1'], V2=dic['V2'], A_hh=dic['A_hh'], B_hh=dic['B_hh'], A_vv=dic['A_vv'], B_vv=dic['B_vv'], A_hv=dic['A_hv'], B_hv=dic['B_hv'])\n\n    S = model.RTModel(surface=soil, canopy=can, models=models, theta=dic['theta'], freq=dic['f'])\n    S.sigma0()\n\n    return S.__dict__['stot'][pol[::-1]]\n\ndef fun_opt(VALS):\n\n\n    # return(10.*np.log10(np.nansum(np.square(solve_fun(VALS)-dic['pol_value']))))\n    return(np.nansum(np.square(solve_fun(VALS)-dic['pol_value'])))\n\ndef data_optimized_run(n, field_data, theta_field, sm_field, height_field, lai_field, vwc_field, pol):\n    n = np.int(np.floor(n\/2))\n\n    if n > 0:\n        field_data = field_data.drop(field_data.index[-n:])\n        field_data = field_data.drop(field_data.index[0:n])\n        theta_field = theta_field.drop(theta_field.index[-n:])\n        theta_field = theta_field.drop(theta_field.index[0:n])\n\n    sm_field = field_data.filter(like='SM')\n    height_field = field_data.filter(like='Height')\/100\n    lai_field = field_data.filter(like='LAI')\n    vwc_field = field_data.filter(like='VWC')\n\n    vv_field = field_data.filter(like='sigma_sentinel_vv')\n    vh_field = field_data.filter(like='sigma_sentinel_vh')\n\n    pol_field = field_data.filter(like='sigma_sentinel_'+pol)\n    return field_data, theta_field, sm_field, height_field, lai_field, vwc_field, vv_field, vh_field, pol_field\n#-----------------------------------------------------------------\n\n### Data preparation ###\n#-----------------------------------------------------------------\n# storage information\npath = '\/media\/tweiss\/Daten\/new_data'\nfile_name = 'multi10' # theta needs to be changed to for norm multi\nextension = '.csv'\n\npath_agro = '\/media\/nas_data\/2017_MNI_campaign\/field_data\/meteodata\/agrarmeteorological_station'\nfile_name_agro = 'Eichenried_01012017_31122017_hourly'\nextension_agro = '.csv'\n\nfield = '508_high'\nfield_plot = ['508_high', '508_low', '508_med']\npol = 'vv'\n# pol = 'vh'\n\n# output path\nplot_output_path = '\/media\/tweiss\/Daten\/plots\/paper\/'\n\ndf, df_agro, field_data, field_data_orbit, theta_field, sm_field, height_field, lai_field, vwc_field, pol_field = read_data(path, file_name, extension, field, path_agro, file_name_agro, extension_agro)\n\n#-----------------------------------------------------------------\n\n### Run SenSe module\n#-----------------------------------------------------------------\n#### Choose models\n#-----------------\n\nsurface_list = ['Oh92', 'Oh04', 'Dubois95', 'WaterCloud', 'I2EM']\n# surface_list = ['Oh92', 'Oh04', 'WaterCloud']\n# surface_list = ['WaterCloud']\ncanopy_list = ['turbid_isotropic', 'water_cloud']\n# canopy_list = ['water_cloud']\n\n# surface_list = ['Oh92']\n# surface_list = ['Oh04']\n# surface_list = ['Dubois95']\n# surface_list = ['WaterCloud']\n# surface_list = ['I2EM']\n# canopy_list = ['turbid_isotropic']\n# canopy_list = ['water_cloud']\n\n### option for time invariant or variant calibration of parameter\n#-------------------------------\nopt_mod = 'time invariant'\n# opt_mod = 'time variant'\n#---------------------------\n\n### plot option: \"single\" or \"all\" modelcombination\n#------------------------------\n# plot = 'single'\nplot = 'all'\n#------------------------------\n\n### plot option scatterplot or not\n#-------------------------------\n# style = 'scatterplot'\nstyle = ''\n\n### plot option for scatterplot single ESU\n#------------------------------------\n# style_2 = 'scatterplot_single_ESU'\nstyle_2 = ''\n#-----------------------------------\n\n# Initialize plot settings\n#---------------------------\nif style == 'scatterplot':\n    fig, ax = plt.subplots(figsize=(10, 10))\nelse:\n    fig, ax = plt.subplots(figsize=(17, 10))\n# plt.title('Winter Wheat')\nplt.ylabel('Backscatter [dB]', fontsize=15)\nplt.xlabel('Date', fontsize=15)\nplt.tick_params(labelsize=12)\n\n\nif pol == 'vv':\n    ax.set_ylim([-25,-7.5])\nelif pol == 'vh':\n    ax.set_ylim([-30,-15])\n\ncolormaps = ['Greens', 'Purples', 'Blues', 'Oranges', 'Reds', 'Greys', 'pink', 'bone', 'Blues', 'Blues', 'Blues']\nj = 0\n\ncolormap = plt.get_cmap(colormaps[j])\ncolors = [colormap(jj) for jj in np.linspace(0.35, 1., 3)]\n\nfor k in surface_list:\n\n    for kk in canopy_list:\n        df, df_agro, field_data, field_data_orbit, theta_field, sm_field, height_field, lai_field, vwc_field, pol_field = read_data(path, file_name, extension, field, path_agro, file_name_agro, extension_agro)\n        freq = 5.405\n        clay = 0.08\n        sand = 0.12\n        bulk = 1.5\n        s = 0.0105 # vv\n        s = 0.0115\n        # s = 0.009 # vh ?????\n\n        C_hh = 0\n        D_hh = 0\n        C_hv = -22.5\n        D_hv = 3.2\n        C_vv = -14.609339\n        D_vv = 12.884086\n\n        ### Canopy\n        # Water Cloud (A, B, V1, V2, theta)\n        # SSRT (coef, omega, theta)\n        #-----------------------------------\n        A_hh = 0\n        B_hh = 0\n        A_hv = 0.029\n        B_hv = 0.0013\n        A_vv = 0.0029\n        B_vv = 0.13\n        V1 = lai_field.values.flatten()\n        V2 = V1 # initialize in surface model\n        coef = 1.\n        omega = 0.027 # vv\n        omega = 0.015 # vh\n        # IEM\n        l = 0.01\n\n\n        surface = k\n        canopy = kk\n        models = {'surface': surface, 'canopy': canopy}\n\n        #### Optimization\n        #-----------------\n\n        if opt_mod == 'time invariant':\n\n            dic = {\"mv\":sm_field.values.flatten(), \"C_hh\":C_hh, \"C_vv\":C_vv, \"D_hh\":D_hh, \"D_vv\":D_vv, \"C_hv\":C_hv, \"D_hv\":D_hv, \"s\":s, \"clay\":clay, \"sand\":sand, \"f\":freq, \"bulk\":bulk, \"l\":l, \"canopy\":canopy, \"d\":height_field.values.flatten(), \"V1\":V1, \"V2\":V2, \"A_hh\":A_hh, \"B_hh\":B_hh, \"A_vv\":A_vv, \"B_vv\":B_vv, \"A_hv\":A_hv, \"B_hv\":B_hv, \"lai\":lai_field.values.flatten(), \"vwc\":vwc_field.values.flatten(), \"pol_value\":pol_field.values.flatten(), \"theta\":theta_field.values.flatten(), \"omega\": omega, \"coef\": coef}\n\n            if canopy == 'turbid_isotropic':\n                var_opt = ['coef']\n                guess = [2.]\n                bounds = [(0.001,5.5)]\n            elif surface == 'WaterCloud' and canopy == 'water_cloud':\n                var_opt = ['A_vv', 'B_vv', 'A_hv', 'B_hv', 'C_vv', 'D_vv', 'C_hv', 'D_hv']\n                guess = [A_vv, B_vv, A_hv, B_hv, C_vv, D_vv, C_hv, D_hv]\n                bounds = [(0.,1), (0.,1), (0.,1), (0.,1), (-20.,-1.), (1.,20.), (-20.,-1.), (1.,20.)]\n            elif canopy == 'water_cloud':\n                var_opt = ['A_vv', 'B_vv', 'A_hv', 'B_hv']\n                guess = [A_vv, B_vv, A_hv, B_hv]\n                bounds = [(0.,1), (0.,1), (0.,1), (0.,1)]\n\n            method = 'L-BFGS-B'\n\n            res = minimize(fun_opt,guess,bounds=bounds, method=method)\n\n            fun_opt(res.x)\n            aaa = res.x\n\n        if opt_mod == 'time variant':\n            aaa = [[],[],[],[],[],[],[],[],[],[],[],[]]\n            n=7\n\n            for i in range(len(pol_field.values.flatten())-n+1):\n\n                if type(coef) == float:\n                    dic = {\"mv\":sm_field.values.flatten()[i:i+n], \"C_hh\":C_hh, \"C_vv\":C_vv, \"D_hh\":D_hh, \"D_vv\":D_vv, \"C_hv\":C_hv, \"D_hv\":D_hv, \"V2\":V2[i:i+n], \"s\":s, \"clay\":clay, \"sand\":sand, \"f\":freq, \"bulk\":bulk, \"l\":l, \"canopy\":canopy, \"d\":height_field.values.flatten()[i:i+n], \"V1\":V1[i:i+n], \"A_hh\":A_hh, \"B_hh\":B_hh, \"A_vv\":A_vv, \"B_vv\":B_vv, \"A_hv\":A_hv, \"B_hv\":B_hv, \"lai\":lai_field.values.flatten()[i:i+n], \"vwc\":vwc_field.values.flatten()[i:i+n], \"pol_value\":pol_field.values.flatten()[i:i+n], \"theta\":theta_field.values.flatten()[i:i+n], \"omega\": omega, \"coef\": coef}\n                else:\n                    dic = {\"mv\":sm_field.values.flatten()[i:i+n], \"C_hh\":C_hh, \"C_vv\":C_vv, \"D_hh\":D_hh, \"D_vv\":D_vv, \"C_hv\":C_hv, \"D_hv\":D_hv, \"V2\":V2[i:i+n], \"s\":s, \"clay\":clay, \"sand\":sand, \"f\":freq, \"bulk\":bulk, \"l\":l, \"canopy\":canopy, \"d\":height_field.values.flatten()[i:i+n], \"V1\":V1[i:i+n], \"A_hh\":A_hh, \"B_hh\":B_hh, \"A_vv\":A_vv, \"B_vv\":B_vv, \"A_hv\":A_hv, \"B_hv\":B_hv, \"lai\":lai_field.values.flatten()[i:i+n], \"vwc\":vwc_field.values.flatten()[i:i+n], \"pol_value\":pol_field.values.flatten()[i:i+n], \"theta\":theta_field.values.flatten()[i:i+n], \"omega\": omega, \"coef\": coef[i:i+n]}\n\n                if canopy == 'turbid_isotropic' and surface == 'WaterCloud':\n                    var_opt = ['coef', 'C_vv', 'D_vv', 'C_hv', 'D_hv']\n                    guess = [0.01, C_vv, D_vv, C_hv, D_hv]\n                    bounds = [(0.1,5.5), (-20.,-1.), (1.,20.), (-20.,-1.), (1.,20.)]\n                elif canopy == 'turbid_isotropic':\n                    var_opt = ['coef']\n                    guess = [0.1]\n                    bounds = [(0.,2)]\n                elif surface == 'WaterCloud' and canopy == 'water_cloud':\n                    # var_opt = ['A_vv', 'B_vv', 'A_hv', 'B_hv', 'C_vv', 'D_vv', 'C_hv', 'D_hv']\n                    # guess = [A_vv, B_vv, A_hv, B_hv, C_vv, D_vv, C_hv, D_hv]\n                    # bounds = [(0.,1), (guess[1]*0.55, guess[1]*1.55), (0.,1), (guess[3]*0.75, guess[3]*1.25), (-20.,-1.), (1.,20.), (-20.,-1.), (1.,20.)]\n                    var_opt = ['C_vv', 'D_vv', 'C_hv', 'D_hv']\n                    guess = [C_vv, D_vv, C_hv, D_hv]\n                    bounds = [(-20.,-1.), (1.,20.), (-20.,-1.), (1.,20.)]\n                elif canopy == 'water_cloud':\n                    var_opt = ['A_vv', 'B_vv', 'A_hv', 'B_hv']\n                    guess = [A_vv, B_vv, A_hv, B_hv]\n                    bounds = [(0.,1), (0.,1), (0.00001,1), (0.00001,1)]\n\n                # var_opt = ['omega']\n                # guess = [0.1]\n                # bounds = [(0.,5.5)]\n\n                # var_opt = ['s', 'coef', 'omega']\n                # guess = [0.01, 0.1, 0.01]\n                # bounds = [(0.001,0.03),(0.,2.5),(0.001,0.1)]\n\n                # var_opt = ['C_hv', 'D_hv']\n                # guess = [-13, 14]\n                # bounds = [(-200.,100.),(-200.,400.)]\n\n                # var_opt = ['A_vv', 'B_vv']\n\n                # try:\n                #     guess = [res.x[0], res.x[1]]\n                # except:\n                #     guess = [0.005, 0.09]\n                # # bounds = [(0.000,5.),(0.001,5.)]\n                # bounds = [(guess[0]*0.75, guess[0]*1.25), (guess[1]*0.75, guess[1]*1.25)]\n                # bounds = [(guess[0]*0.9, guess[0]*1.1), (guess[1]*0.75, guess[1]*1.25)]\n                # var_opt = ['coef', 'omega']\n                # guess = [0.1, 0.22]\n                # bounds = [(0.,5.5),(0.00001,0.2)]\n                method = 'L-BFGS-B'\n                # method = 'trust-exact'\n\n                res = minimize(fun_opt,guess,bounds=bounds, method=method)\n\n                fun_opt(res.x)\n\n                for j in range(len(res.x)):\n                    aaa[j].append(res.x[j])\n\n            field_data, theta_field, sm_field, height_field, lai_field, vwc_field, vv_field, vh_field, pol_field = data_optimized_run(n, field_data, theta_field, sm_field, height_field, lai_field, vwc_field, pol)\n            V1 = lai_field.values.flatten()\n            V2 = V1 # initialize in surface model\n\n        #-----------------------------------------------------------------\n\n        for i in range(len(res.x)):\n            exec('%s = %s' % (var_opt[i],aaa[i]))\n\n        ke = coef * np.sqrt(lai_field.values.flatten())\n        # ke = smooth(ke, 11)\n\n        soil = Soil(mv=sm_field.values.flatten(), C_hh=np.array(C_hh), C_vv=np.array(C_vv), D_hh=np.array(D_hh), D_vv=np.array(D_vv), C_hv=np.array(C_hv), D_hv=np.array(D_hv), s=s, clay=clay, sand=sand, f=freq, bulk=bulk, l=l)\n\n        can = OneLayer(canopy=canopy, ke_h=ke, ke_v=ke, d=height_field.values.flatten(), ks_h = omega*ke, ks_v = omega*ke, V1=np.array(V1), V2=np.array(V2), A_hh=np.array(A_hh), B_hh=np.array(B_hh), A_vv=np.array(A_vv), B_vv=np.array(B_vv), A_hv=np.array(A_hv), B_hv=np.array(B_hv))\n\n        S = model.RTModel(surface=soil, canopy=can, models=models, theta=theta_field.values.flatten(), freq=freq)\n        S.sigma0()\n#-----------------------------------------------------------------\n        date = field_data.index\n\n        colormap = plt.get_cmap(colormaps[j])\n        colors = [colormap(jj) for jj in np.linspace(0.35, 1., 4)]\n\n        # ax.plot(10*np.log10(pol_field), 'ks-', label='Sentinel-1 Pol: ' + pol, linewidth=3)\n        # ax.plot(date, 10*np.log10(S.__dict__['s0g'][pol[::-1]]), color=colors[0], marker='s', linestyle='--', label=pol+' s0g')\n        # ax.plot(date, 10*np.log10(S.__dict__['s0c'][pol[::-1]]), color=colors[1], marker='s', linestyle='--', label=pol+' s0c')\n        # ax.plot(date, 10*np.log10(S.__dict__['s0cgt'][pol[::-1]]), 'ms-', label=pol+' s0cgt')\n        # ax.plot(date, 10*np.log10(S.__dict__['s0gcg'][pol[::-1]]), 'ys-', label=pol+' s0gcg')\n\n        mask = ~np.isnan(pol_field.values.flatten()) & ~np.isnan(S.__dict__['stot'][pol[::-1]])\n        slope, intercept, r_value, p_value, std_err = scipy.stats.linregress((pol_field.values.flatten()[mask]), (S.__dict__['stot'][pol[::-1]][mask]))\n        slope1, intercept1, r_value1, p_value1, std_err1 = scipy.stats.linregress(10*np.log10(pol_field.values.flatten())[mask], 10*np.log10(S.__dict__['stot'][pol[::-1]])[mask])\n        rmse = rmse_prediction(10*np.log10(pol_field.values.flatten()), 10*np.log10(S.__dict__['stot'][pol[::-1]]))\n\n        if k == 'Oh92':\n            hm = 'Oh92'\n            colors = 'blue'\n        elif k == 'Oh04':\n            hm = 'Oh04'\n            colors = 'red'\n        elif k == 'Dubois95':\n            hm='Dubois95'\n            colors = 'orange'\n        elif k == 'WaterCloud':\n            hm = 'Water Cloud'\n            colors = 'purple'\n        elif k == 'I2EM':\n            hm = 'IEM'\n            colors = 'green'\n\n        if plot == 'all':\n            if kk == 'turbid_isotropic':\n\n                ax.plot(date, 10*np.log10(S.__dict__['stot'][pol[::-1]]), color=colors, marker='s', linestyle='dashed', label = hm+ ' + ' +  'SSRT' + '; Pol: ' + pol + '; RMSE: ' + str(rmse)[0:4] + '; $R^2$: ' + str(r_value)[0:4])\n            else:\n                ax.plot(date, 10*np.log10(S.__dict__['stot'][pol[::-1]]), color=colors, marker='s', label = hm+ ' + ' +  'Water Cloud' + '; Pol: ' + pol + '; RMSE: ' + str(rmse)[0:4] + '; $R^2$: ' + str(r_value)[0:4])\n\n        if plot == 'single':\n            if style == 'scatterplot':\n                if pol == 'vv':\n                    ax.set_xlim([-22.5,-7.5])\n                elif pol == 'vh':\n                    ax.set_xlim([-30,-15])\n\n                if style_2 == 'scatterplot_single_ESU':\n                    ax.plot(10*np.log10(pol_field.values.flatten()),10*np.log10(S.__dict__['stot'][pol[::-1]]), 'rs', label=field)\n\n                    x = 10*np.log10(pol_field.values.flatten())\n                    y = 10*np.log10(S.__dict__['stot'][pol[::-1]])\n\n                    lower_position = np.nanargmin(x)\n                    upper_position = np.nanargmax(x)\n\n                    ax.plot(np.array((x[lower_position],x[upper_position])),np.array((y[lower_position],y[upper_position])), '--r')\n\n\n                else:\n                    aa = []\n                    bb = []\n                    # cc = []\n\n                    # field_plot = ['508_high', '508_low', '508_med']\n                    jj = 0\n                    colors = ['ks', 'ys', 'ms', 'rs']\n\n                    for field in field_plot:\n                        df, df_agro, field_data, field_data_orbit, theta_field, sm_field, height_field, lai_field, vwc_field, pol_field = read_data(path, file_name, extension, field, path_agro, file_name_agro, extension_agro)\n                        field_data, theta_field, sm_field, height_field, lai_field, vwc_field, vv_field, vh_field, pol_field = data_optimized_run(n, field_data, theta_field, sm_field, height_field, lai_field, vwc_field, pol)\n\n                        soil = Soil(mv=sm_field.values.flatten(), C_hh=np.array(C_hh), C_vv=np.array(C_vv), D_hh=np.array(D_hh), D_vv=np.array(D_vv), C_hv=np.array(C_hv), D_hv=np.array(D_hv), s=s, clay=clay, sand=sand, f=freq, bulk=bulk, l=l)\n\n                        can = OneLayer(canopy=canopy, ke_h=ke, ke_v=ke, d=height_field.values.flatten(), ks_h = omega*ke, ks_v = omega*ke, V1=np.array(V1), V2=np.array(V2), A_hh=np.array(A_hh), B_hh=np.array(B_hh), A_vv=np.array(A_vv), B_vv=np.array(B_vv), A_hv=np.array(A_hv), B_hv=np.array(B_hv))\n\n                        S = model.RTModel(surface=soil, canopy=can, models=models, theta=theta_field.values.flatten(), freq=freq)\n                        S.sigma0()\n\n                        ax.plot(10*np.log10(pol_field.values.flatten()),10*np.log10(S.__dict__['stot'][pol[::-1]]), colors[jj], label=field)\n\n                        slope, intercept, r_value, p_value, std_err = linregress(10*np.log10(pol_field.values.flatten())[~np.isnan(10*np.log10(S.__dict__['stot'][pol[::-1]]))], 10*np.log10(S.__dict__['stot'][pol[::-1]])[~np.isnan(10*np.log10(S.__dict__['stot'][pol[::-1]]))])\n                        line = slope * 10*np.log10(S.__dict__['stot'][pol[::-1]]) + intercept\n\n                        # ax.plot(10*np.log10(S.__dict__['stot'][pol[::-1]]), line)\n\n                        lower_position = np.nanargmin(line)\n                        upper_position = np.nanargmax(line)\n\n                        ax.plot(np.array((10*np.log10(S.__dict__['stot'][pol[::-1]])[lower_position],10*np.log10(S.__dict__['stot'][pol[::-1]])[upper_position])),np.array((line[lower_position],line[upper_position])), '--'+colors[jj][0])\n\n                        aa = np.append(aa, 10*np.log10(pol_field.values.flatten()))\n                        bb = np.append(bb, 10*np.log10(S.__dict__['stot'][pol[::-1]]))\n                        jj = jj+1\n            else:\n                ax.plot(date, 10*np.log10(S.__dict__['stot'][pol[::-1]]), color='orange', marker='s', label=S.models['surface']+ ' + ' +  S.models['canopy'] + ' Pol: ' + pol + '; RMSE: ' + str(rmse)[0:4] + '; $R^2$: ' + str(r_value)[0:4])\n                ax.plot(date, 10*np.log10(S.__dict__['s0g'][pol[::-1]]), color='red', marker='s', label='Ground contribution')\n                ax.plot(date, 10*np.log10(S.__dict__['s0c'][pol[::-1]]), color='green', marker='s', label='Canopy contribution')\n\n        j = j+1\n\n\nif style == 'scatterplot':\n    pass\nelse:\n    ax.plot(10*np.log10(pol_field), 'ks-', label='Sentinel-1 Pol: ' + pol, linewidth=3)\n    plt.legend()\n    plt.title(field)\n\nif plot == 'all':\n    # plt.show()\n    plt.savefig(plot_output_path+pol+'_all_'+opt_mod)\n\nif plot == 'single':\n    if style == 'scatterplot':\n        plt.ylabel(surface + ' ' + canopy + ' [dB]')\n        plt.xlabel('Sentinel-1 [dB]')\n        plt.legend()\n        x = np.linspace(np.min(10*np.log10(pol_field.values.flatten()))-2, np.max(10*np.log10(pol_field.values.flatten()))+2, 16)\n        ax.plot(x,x)\n        if style_2 == 'scatterplot_single_ESU':\n            www = rmse_prediction(10*np.log10(pol_field).values.flatten(), 10*np.log10(S.__dict__['stot'][pol[::-1]]))\n            plt.title(pol+' ' + field + ' ' + surface + ' ' + canopy + '$R^2$='+str(r_value)+' RMSE='+str(www))\n            plt.savefig(plot_output_path+'scatterplot_fertig_single_'+field+'_'+pol+'_'+file_name+'_'+S.models['surface']+'_'+S.models['canopy'])\n        else:\n            www = rmse_prediction(aa, bb)\n            # slope, intercept, r_value, p_value, std_err = linregress(aaa[~np.isnan(bbb)], bbb[~np.isnan(bbb)])\n            plt.title(pol+' ' + field + ' ' + surface + ' ' + canopy + '$R^2$='+str(r_value)+' RMSE='+str(www))\n            plt.savefig(plot_output_path+'scatterplot_fertig_'+field+'_'+pol+'_'+file_name+'_'+S.models['surface']+'_'+S.models['canopy'])\n    else:\n        plt.savefig(plot_output_path+pol+'_single_'+opt_mod+'_'+S.models['surface']+'_'+S.models['canopy'])\n\n\npdb.set_trace()\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_313","text":"<filename>Pandas-analyzing-dataset\/code.py\n# --------------\n# Importing header files\r\nimport numpy as np\r\nimport pandas as pd\r\nfrom scipy.stats import mode \r\n \r\nimport warnings\r\nwarnings.filterwarnings('ignore')\r\n\r\n#Reading file\r\nbank = pd.read_csv(path)\r\n#Code starts here\r\ncategorical_var=bank.select_dtypes(include = 'object')\r\n#print(categorical_var)\r\nnumerical_var=bank.select_dtypes(include = 'number')\r\n#print(numerical_var)\r\nprint(categorical_var.shape)\r\nprint(numerical_var.shape)\r\nbank.drop('Loan_ID',inplace=True,axis=1)\r\nbanks = pd.DataFrame(bank)\r\nprint(banks.isnull().sum())\r\nprint(banks.shape)\r\nbank_mode = banks.mode().iloc[0]\r\nbanks.fillna(bank_mode,inplace=True)\r\nprint(banks.isnull().sum().values.sum())\r\navg_loan_amount = pd.pivot_table(banks,index=('Gender','Married','Self_Employed'),values='LoanAmount').agg(np.mean)\r\nprint(avg_loan_amount)\r\nloan_approved_se = banks[(banks['Self_Employed'] == 'Yes') & (banks['Loan_Status'] == 'Y')].count()  \r\nloan_approved_nse = banks[(banks['Self_Employed'] == 'No') & (banks['Loan_Status'] == 'Y')].count()\r\nLoan_Status = 614\r\npercentage_se = round((loan_approved_se\/Loan_Status)*100,2)\r\npercentage_nse = round((loan_approved_nse\/Loan_Status)*100,2)\r\nprint(percentage_se)\r\nprint(percentage_nse)\r\nloan_term = banks['Loan_Amount_Term'].apply(lambda x : int(x) \/ 12)\r\nbig_loan_term = len(loan_term[loan_term>=25])\r\nprint(big_loan_term)\r\ncolumns_to_show = ['ApplicantIncome', 'Credit_History']\r\nloan_groupby=banks.groupby(['Loan_Status'])\r\nloan_groupby=loan_groupby[columns_to_show]\r\nmean_values = loan_groupby.agg(np.mean)\r\nprint(mean_values)\r\n\r\n\r\n\r\n\r\n\r\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_314","text":"<reponame>ArgonneCPAC\/skysim\n\"\"\"\n\"\"\"\nimport numpy as np\nfrom scipy.stats import johnsonsb\nfrom astropy.utils.misc import NumpyRNGContext\nfrom halotools.empirical_models import conditional_abunmatch\n\n\ndef calculate_johnsonsb_params_disk(\n        magr, johnsonsb_disk_table_abscissa=[-19, -21],\n        johnsonsb_disk_table=[0.15, -0.15], **kwargs):\n    return np.interp(magr, johnsonsb_disk_table_abscissa, johnsonsb_disk_table)\n\n\ndef calculate_johnsonsb_params_bulge(\n        magr, johnsonsb_bulge_table_abscissa=[-19, -21],\n        johnsonsb_bulge_table=[1.5, 0.6], **kwargs):\n    return np.interp(magr, johnsonsb_bulge_table_abscissa, johnsonsb_bulge_table)\n\n\ndef monte_carlo_ellipticity_disk(magr, inclination = None, seed=None, **kwargs):\n    \"\"\"\n    Parameters\n    ----------\n    magr : ndarray\n        Numpy array of shape (ngals, )\n\n    inclination : ndarray\n        Numpy array of shape (ngals, )\n\n    Returns\n    -------\n    ellipticity_realization : ndarray\n    \"\"\"\n\n    magr = np.atleast_1d(magr)\n    inclination = np.atleast_1d(inclination)\n\n    a = calculate_johnsonsb_params_disk(magr, **kwargs)\n    b = np.ones_like(a)\n\n    with NumpyRNGContext(seed):\n        ellipticity_realization = johnsonsb.rvs(a, b)\n\n    nwin = 101\n    if inclination is None:\n        inclination_correlated_ellipticity = conditional_abunmatch(\n            magr, inclination, magr, ellipticity_realization, nwin)\n        return inclination_correlated_ellipticity\n    else:\n        return ellipticity_realization\n\n\ndef monte_carlo_ellipticity_bulge(magr, seed=None, **kwargs):\n    \"\"\"\n    Parameters\n    ----------\n    magr : ndarray\n        Numpy array of shape (ngals, )\n\n    Returns\n    -------\n    ellipticity_realization : ndarray\n    \"\"\"\n    magr = np.atleast_1d(magr)\n\n    a = calculate_johnsonsb_params_bulge(magr, **kwargs)\n    b = np.ones_like(a)\n\n    with NumpyRNGContext(seed):\n        ellipticity_realization = johnsonsb.rvs(a, b)\n    return ellipticity_realization\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_315","text":"<gh_stars>100-1000\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\nfrom . import _unittest as unittest\nimport cmath\nimport decimal\nimport math\nimport re\n\ntry:\n    import numpy\nexcept ImportError:\n    numpy = False\n\nfrom datatest._vendor.predicate import (\n    _check_type,\n    _check_callable,\n    _check_wildcard,\n    _check_truthy,\n    _check_falsy,\n    _check_nan,\n    _check_regex,\n    _check_set,\n    _get_matcher_parts,\n    get_matcher,\n    MatcherBase,\n    MatcherObject,\n    MatcherTuple,\n    Predicate,\n    PredicateIntersectionType,\n    PredicateUnionType,\n)\n\n\nclass TestCheckType(unittest.TestCase):\n    def test_isinstance(self):\n        function = lambda x: _check_type(int, x)\n        self.assertTrue(function(0))\n        self.assertTrue(function(1))\n        self.assertFalse(function(0.0))\n        self.assertFalse(function(1.0))\n\n    def test_is_type(self):\n        self.assertTrue(_check_type(int, int))\n\n\nclass TestCheckCallable(unittest.TestCase):\n    def test_function(self):\n        def divisible3or5(x):  # <- Helper function.\n            return (x % 3 == 0) or (x % 5 == 0)\n\n        function = lambda x: _check_callable(divisible3or5, x)\n        self.assertFalse(function(1))\n        self.assertFalse(function(2))\n        self.assertTrue(function(3))\n        self.assertFalse(function(4))\n        self.assertTrue(function(5))\n        self.assertTrue(function(6))\n\n    def test_error(self):\n        def fails_internally(x):  # <- Helper function.\n            raise TypeError('raising an error')\n\n        function = lambda x: _check_callable(fails_internally, x)\n        with self.assertRaises(TypeError):\n            self.assertFalse(function('abc'))\n\n    def test_identity(self):\n        def always_false(x):  # <- Helper function.\n            return False\n\n        function = lambda x: _check_callable(always_false, x)\n        self.assertTrue(function(always_false))\n\n    def test_identity_with_error(self):\n        def fails_internally(x):  # <- Helper function.\n            raise TypeError('raising an error')\n\n        function = lambda x: _check_callable(fails_internally, x)\n        self.assertTrue(function(fails_internally))\n\n\nclass TestCheckWildcard(unittest.TestCase):\n    def test_always_true(self):\n        self.assertTrue(_check_wildcard(1))\n        self.assertTrue(_check_wildcard(object()))\n        self.assertTrue(_check_wildcard(None))\n\n\nclass TestCheckTruthy(unittest.TestCase):\n    def test_matches(self):\n        self.assertTrue(_check_truthy('x'))\n        self.assertTrue(_check_truthy(1.0))\n        self.assertTrue(_check_truthy([1]))\n        self.assertTrue(_check_truthy(range(1)))\n\n    def test_nonmatches(self):\n        self.assertFalse(_check_truthy(''))\n        self.assertFalse(_check_truthy(0.0))\n        self.assertFalse(_check_truthy([]))\n        self.assertFalse(_check_truthy(range(0)))\n\n\nclass TestCheckFalsy(unittest.TestCase):\n    def test_matches(self):\n        self.assertTrue(_check_falsy(''))\n        self.assertTrue(_check_falsy(0.0))\n        self.assertTrue(_check_falsy([]))\n        self.assertTrue(_check_falsy(range(0)))\n\n    def test_nonmatches(self):\n        self.assertFalse(_check_falsy('x'))\n        self.assertFalse(_check_falsy(1.0))\n        self.assertFalse(_check_falsy([1]))\n        self.assertFalse(_check_falsy(range(1)))\n\n\nclass TestCheckNaN(unittest.TestCase):\n    def test_matches(self):\n        self.assertTrue(_check_nan(float('NaN')))\n        self.assertTrue(_check_nan(complex(float('NaN'))))\n        self.assertTrue(_check_nan(decimal.Decimal('NaN')))\n        if hasattr(math, 'nan'):  # New in version 3.5\n            self.assertTrue(_check_nan(math.nan))\n        if hasattr(cmath, 'nan'):  # New in version 3.6\n            self.assertTrue(_check_nan(cmath.nan))\n\n    def test_nonmatches(self):\n        self.assertFalse(_check_nan('x'))\n        self.assertFalse(_check_nan(1))\n        self.assertFalse(_check_nan(1.0))\n        self.assertFalse(_check_nan(complex(1)))\n        self.assertFalse(_check_nan(decimal.Decimal('1.123')))\n\n    @unittest.skipUnless(numpy, 'requires numpy')\n    def test_numpy_cases(self):\n        self.assertTrue(_check_nan(numpy.nan))\n        self.assertFalse(_check_nan(numpy.int64(123)))\n\n\nclass TestCheckRegex(unittest.TestCase):\n    def test_function(self):\n        regex = re.compile('(Ch|H)ann?ukk?ah?')\n        function = lambda x: _check_regex(regex, x)\n\n        self.assertTrue(function('Happy Hanukkah'))\n        self.assertTrue(function('Happy Chanukah'))\n        self.assertFalse(function('Merry Christmas'))\n\n    def test_incompatible_types(self):\n        regex = re.compile('abc')\n        self.assertFalse(_check_regex(regex, 123))\n        self.assertFalse(_check_regex(regex, ('a', 'b')))\n\n    def test_identity(self):\n        regex = re.compile('abc')\n        self.assertTrue(_check_regex(regex, regex))\n\n\nclass TestCheckSet(unittest.TestCase):\n    def test_function(self):\n        function = lambda x: _check_set(set(['abc', 'def']), x)\n        self.assertTrue(function('abc'))\n        self.assertFalse(function('xyz'))\n\n    def test_whole_set_equality(self):\n        function = lambda x: _check_set(set(['abc', 'def']), x)\n        self.assertTrue(function(set(['abc', 'def'])))\n\n    def test_unhashable_check(self):\n        function = lambda x: _check_set(set(['abc', 'def']), x)\n        self.assertFalse(function(['abc']))\n        self.assertFalse(function((1, ['xyz'])))\n\n\nclass TestGetMatcherParts(unittest.TestCase):\n    def test_type(self):\n        pred_handler, repr_string = _get_matcher_parts(int)\n        self.assertTrue(pred_handler(1))\n        self.assertFalse(pred_handler(1.0))\n        self.assertEqual(repr_string, 'int')\n\n    def test_callable(self):\n        def userfunc(x):\n            return x == 1\n        pred_handler, repr_string = _get_matcher_parts(userfunc)\n        self.assertTrue(pred_handler(1))\n        self.assertFalse(pred_handler(2))\n        self.assertEqual(repr_string, 'userfunc')\n\n        userlambda = lambda x: x == 1\n        pred_handler, repr_string = _get_matcher_parts(userlambda)\n        self.assertTrue(pred_handler(1))\n        self.assertFalse(pred_handler(2))\n        self.assertEqual(repr_string, '<lambda>')\n\n    def test_ellipsis_wildcard(self):\n        pred_handler, repr_string = _get_matcher_parts(Ellipsis)\n        self.assertIs(pred_handler, _check_wildcard)\n        self.assertEqual(repr_string, '...')\n\n    def test_truthy(self):\n        pred_handler, repr_string = _get_matcher_parts(True)\n        self.assertIs(pred_handler, _check_truthy)\n        self.assertEqual(repr_string, 'True')\n\n    def test_falsy(self):\n        pred_handler, repr_string = _get_matcher_parts(False)\n        self.assertIs(pred_handler, _check_falsy)\n        self.assertEqual(repr_string, 'False')\n\n    def test_nan(self):\n        pred_handler, repr_string = _get_matcher_parts(float('nan'))\n        self.assertIs(pred_handler, _check_nan)\n        self.assertEqual(repr_string, 'NaN')\n\n    def test_regex(self):\n        regex = re.compile('ab[cd]')\n\n        pred_handler, repr_string = _get_matcher_parts(regex)\n        self.assertTrue(pred_handler('abc'))\n        self.assertFalse(pred_handler('abe'))\n        self.assertEqual(repr_string, \"re.compile('ab[cd]')\")\n\n    def test_set(self):\n        myset = set(['a'])\n        pred_handler, repr_string = _get_matcher_parts(myset)\n        self.assertTrue(pred_handler('a'))\n        self.assertFalse(pred_handler('b'))\n        self.assertEqual(repr_string, repr(myset))\n\n    def test_no_special_handling(self):\n        self.assertIsNone(_get_matcher_parts(1))\n        self.assertIsNone(_get_matcher_parts(0))\n\n\nclass TestMatcherInheritance(unittest.TestCase):\n    def test_inheritance(self):\n        self.assertTrue(issubclass(MatcherTuple, MatcherBase))\n        self.assertTrue(issubclass(MatcherObject, MatcherBase))\n\n\nclass TestGetMatcher(unittest.TestCase):\n    def assertIsInstance(self, obj, cls, msg=None):  # New in Python 3.2.\n        if not isinstance(obj, cls):\n            standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls)\n            self.fail(self._formatMessage(msg, standardMsg))\n\n    def test_single_value(self):\n        # Check for MatcherObject wrapping.\n        def isodd(x):  # <- Helper function.\n            return x % 2 == 1\n        matcher = get_matcher(isodd)\n        self.assertIsInstance(matcher, MatcherObject)\n\n        # When original is adequate, it should be returned unchanged.\n        original = object()\n        matcher = get_matcher(original)\n        self.assertIs(matcher, original)\n\n    def test_tuple_of_values(self):\n        # Check for MatcherTuple wrapping.\n        def isodd(x):  # <- Helper function.\n            return x % 2 == 1\n        matcher = get_matcher((1, isodd))\n        self.assertIsInstance(matcher, MatcherTuple)\n\n        # When tuple contains no MatcherObject objects,\n        # the original should be returned unchanged.\n        original = ('abc', 123)\n        matcher = get_matcher(original)\n        self.assertIs(matcher, original)\n\n    def test_get_matcher_from_matcher(self):\n        original = get_matcher((1, 'abc'))\n        matcher = get_matcher(original)\n        self.assertIs(matcher, original)\n\n    def test_get_matcher_from_predicate(self):\n        predicate = Predicate('abc')\n        matcher = get_matcher(predicate)\n        self.assertIs(matcher, predicate.matcher)\n\n    def test_integration(self):\n        \"\"\"A small integration test that checks a tuple containing all\n        of the different special handling cases.\n        \"\"\"\n        def mycallable(x):  # <- Helper function.\n            return x == '_'\n\n        myregex = re.compile('_')\n\n        myset = set(['_'])\n\n        matcher = get_matcher(\n            (mycallable,  myregex, myset, '_', Ellipsis)\n        )\n\n        self.assertTrue(matcher == ('_', '_', '_', '_', '_'))   # <- Passes all conditions.\n        self.assertFalse(matcher == ('X', '_', '_', '_', '_'))  # <- Callable returns False.\n        self.assertFalse(matcher == ('_', 'X', '_', '_', '_'))  # <- Regex has no match.\n        self.assertFalse(matcher == ('_', '_', 'X', '_', '_'))  # <- Not in set.\n        self.assertFalse(matcher == ('_', '_', '_', 'X', '_'))  # <- Does not equal string.\n        self.assertTrue(matcher == ('_', '_', '_', '_', 'X'))   # <- Passes all conditions (wildcard).\n\n        expected = \"(mycallable, re.compile('_'), {0!r}, '_', ...)\".format(myset)\n        self.assertEqual(repr(matcher), expected)\n\n\nclass TestPredicate(unittest.TestCase):\n    def test_predicate_function(self):\n        pred = Predicate('abc')\n        self.assertTrue(pred('abc'))\n        self.assertFalse(pred('def'))\n        self.assertFalse(pred(123))\n\n        pred = Predicate(re.compile('^abc$'))\n        self.assertTrue(pred('abc'))\n        self.assertFalse(pred('def'))\n        self.assertFalse(pred(123))\n\n        pred = Predicate(1)\n        self.assertTrue(pred(1))\n        self.assertFalse(pred(2))\n        self.assertFalse(pred('abc'))\n\n        pred = Predicate(('abc', int))\n        self.assertTrue(pred(('abc', 1)))\n        self.assertFalse(pred(('abc', 1.0)))\n\n        pred = Predicate((str, float('nan')))\n        self.assertTrue(pred(('abc', float('nan'))))\n        self.assertFalse(pred(('abc', 1.0)))\n        self.assertFalse(pred(('abc', 'xyz')))\n\n    @unittest.skipUnless(numpy, 'requires numpy')\n    def test_numpy_types(self):\n        \"\"\"Check that built-in types can match numpy types.\"\"\"\n        # Match numpy.character sub-types.\n        pred = Predicate(str)\n        self.assertTrue(pred(numpy.str_('abc')))\n        self.assertTrue(pred(numpy.unicode_('def')))\n\n        # Match numpy.integer sub-types.\n        pred = Predicate(int)\n        self.assertTrue(pred(numpy.int8(123)))\n        self.assertTrue(pred(numpy.uint64(456)))\n\n        # Match numpy.floating sub-types.\n        pred = Predicate(float)\n        self.assertTrue(pred(numpy.float32(1.0)))\n        self.assertTrue(pred(numpy.float64(2.0)))\n\n        # Match numpy.complexfloating sub-types.\n        pred = Predicate(complex)\n        self.assertTrue(pred(numpy.complex64(1.0)))\n        self.assertTrue(pred(numpy.complex128(2.0)))\n\n    @unittest.skipUnless(numpy, 'requires numpy')\n    def test_numpy_equality_error(self):\n        \"\"\"Doing `numpy.dtype(float) == 1` raises a TypeError.\n        Comparisons that error-out should be caught and considered\n        non-matches\/False.\n        \"\"\"\n        pred = Predicate(numpy.dtype(float))\n        self.assertFalse(pred(1))\n\n        pred = Predicate(1)\n        self.assertFalse(pred(numpy.dtype(float)))\n\n    def test_inverted_logic(self):\n        pred = ~Predicate('abc')\n        self.assertFalse(pred('abc'))\n        self.assertTrue(pred('def'))\n\n    def test_repr(self):\n        pred = Predicate('abc')\n        self.assertEqual(repr(pred), \"Predicate('abc')\")\n\n        pred = ~Predicate('abc')\n        self.assertEqual(repr(pred), \"~Predicate('abc')\")\n\n        pred = Predicate('abc', name='custom_name')\n        self.assertEqual(repr(pred), \"Predicate('abc', name='custom_name')\")\n\n    def test_optional_name(self):\n        pred1 = Predicate('abc')  # <- No name arg provided.\n        self.assertFalse(hasattr(pred1, '__name__'))\n\n        pred2 = Predicate(pred1)  # <- No name arg inherited from pred1.\n        self.assertFalse(hasattr(pred1, '__name__'))\n\n        pred3 = Predicate('abc', name='pred3_name')  # <- Provides name.\n        self.assertEqual(pred3.__name__, 'pred3_name')\n\n        pred4 = Predicate(pred3)  # <- Inherits name from pred3.\n        self.assertEqual(pred4.__name__, 'pred3_name')\n\n        pred5 = Predicate(pred3, name='pred5_name')  # <- Overrides pred3 name.\n        self.assertEqual(pred5.__name__, 'pred5_name')\n\n        # Test bad name values.\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='1foo')\n\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='foo!')\n\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='foo bar')\n\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='foo()')\n\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='foo ')\n\n        with self.assertRaises(ValueError):\n            Predicate('abc', name='')\n\n    def test_str(self):\n        pred = Predicate('abc')\n        self.assertEqual(str(pred), \"'abc'\")\n\n        inverted = ~Predicate('abc')\n        self.assertEqual(str(inverted), \"not 'abc'\")\n\n    def test_predicate_from_predicate(self):\n        pred1 = Predicate('abc')\n        pred2 = Predicate(pred1)\n        self.assertIsNot(pred1, pred2, msg='should be different object')\n        self.assertIs(pred1.obj, pred2.obj, msg='should keep original reference')\n        self.assertEqual(pred1.matcher, pred2.matcher)\n        self.assertEqual(pred1._inverted, pred2._inverted)\n\n        from_inverted = Predicate(~Predicate('abc'))\n        self.assertTrue(from_inverted._inverted)\n\n    @unittest.skipUnless(numpy, 'requires numpy')\n    def test_predicate_from_predicate_numpy(self):\n        pred1 = Predicate(numpy.int64)\n        pred2 = Predicate(pred1)\n        self.assertIsNot(pred1, pred2, msg='should be different object')\n        self.assertIs(pred1.obj, pred2.obj, msg='should keep original reference')\n        self.assertIs(pred1.matcher, pred2.matcher)\n        self.assertEqual(pred1._inverted, pred2._inverted)\n\n    def test_passthrough(self):\n        \"\"\"Callable predicates should return the values provided by\n        the given function as-is--the values should not be converted\n        to True or False.\n        \"\"\"\n        TOKEN = object()\n\n        def divisible_or_token(x):  # <- Helper function.\n            if x % 3 == 0:\n                return True\n            if x % 5 == 0:\n                return TOKEN\n            return False\n\n        predicate = Predicate(divisible_or_token)\n        self.assertEqual(predicate(1), False)\n        self.assertEqual(predicate(3), True)\n        self.assertIs(predicate(5), TOKEN, msg='TOKEN should be returned, not True.')\n\n    def test_equality_inconsistency(self):\n        \"\"\"Badly behaved objects could have inconsistent EQ and NE\n        behavior. To make sure that Predicate objects are consistent\n        they should only use`==` internally, not `!=`.\n        \"\"\"\n        class Inconsistent(object):\n            def __init__(self_, value):\n                self_.value = value\n\n            def __eq__(self_, other):\n                return self_.value == other\n\n            def __ne__(self_, other):\n                \"\"\"Badly behaved not-equals method.\"\"\"\n                return self_.__eq__(other)  # <- DECEPTIVE RESULT!\n\n        # Test `Inconsistent` class, itself.\n        obj = Inconsistent(1)\n        self.assertTrue(obj == 1, msg='expected behavior')\n        self.assertTrue(obj != 1, msg='badly behaved comparison result')\n        self.assertFalse(obj == 2, msg='expected behavior')\n        self.assertFalse(obj != 2, msg='badly behaved comparison result')\n\n        # Test predicate matching.\n        pred = Predicate(Inconsistent(1))\n        self.assertTrue(pred(1))\n        self.assertFalse(pred(2))\n\n        # Test inverted predicate matching.\n        pred = ~Predicate(Inconsistent(1))\n        self.assertFalse(pred(1))\n        self.assertTrue(pred(2))\n\n    def test_equality_failure(self):\n        class BadObj(object):\n            def __eq__(self, other):\n                if isinstance(other, BadObj):\n                    return True\n                raise TypeError('Sudden but inevitable betrayal!')\n\n        pred = Predicate(BadObj())\n        self.assertFalse(pred(1))\n\n        pred = Predicate(1)\n        self.assertFalse(pred(BadObj()))\n\n        pred = ~Predicate(BadObj())  # Check inverted case.\n        self.assertTrue(pred(1))\n\n        pred = ~Predicate(1)  # Check inverted case.\n        self.assertTrue(pred(BadObj()))\n\n\nclass TestPredicateIntersectionType(unittest.TestCase):\n    def setUp(self):\n        \"\"\"Define simple predicates to use for testing.\"\"\"\n        self.pred_gt3 = Predicate(lambda x: x > 3)  # Greater-than three.\n        self.pred_even = Predicate(lambda x: x % 2 == 0)  # Is even.\n\n    def test_basics(self):\n        pred = PredicateIntersectionType(self.pred_gt3, self.pred_even)\n        self.assertFalse(pred(1))\n        self.assertFalse(pred(2))\n        self.assertFalse(pred(3))\n        self.assertTrue(pred(4))\n        self.assertFalse(pred(5))\n        self.assertTrue(pred(6))\n        self.assertFalse(pred(7))\n\n    def test_inverted(self):\n        # Using the inversion operator (~).\n        inv_pred = ~PredicateIntersectionType(self.pred_gt3, self.pred_even)\n        self.assertTrue(inv_pred(1))\n        self.assertTrue(inv_pred(2))\n        self.assertTrue(inv_pred(3))\n        self.assertFalse(inv_pred(4))\n        self.assertTrue(inv_pred(5))\n        self.assertFalse(inv_pred(6))\n        self.assertTrue(inv_pred(7))\n\n    def test_repr(self):\n        pred = PredicateIntersectionType(self.pred_gt3, self.pred_even)\n        self.assertEqual(repr(pred), 'Predicate(<lambda>) & Predicate(<lambda>)')\n\n        inv_pred = ~pred\n        self.assertEqual(repr(inv_pred), '~(Predicate(<lambda>) & Predicate(<lambda>))')\n\n    def test_bad_type(self):\n        with self.assertRaises(TypeError):\n            PredicateIntersectionType(self.pred_gt3, 'foobarbaz')\n\n        with self.assertRaises(TypeError):\n            PredicateIntersectionType('foobarbaz', self.pred_gt3)\n\n    def test_bitwise_operator(self):\n        pred = self.pred_gt3 & self.pred_even  # <- Bitwise operator.\n        self.assertIsInstance(pred, PredicateIntersectionType)\n\n    def test_bitwise_operator_bad_type(self):\n        with self.assertRaises(TypeError):\n            self.pred_gt3 & 'foobarbaz'\n\n        with self.assertRaises(TypeError):\n            'foobarbaz' & self.pred_gt3\n\n    def test_intersection_method(self):\n        pred = self.pred_gt3.intersection(self.pred_even)  # <- Intersection method.\n        self.assertIsInstance(pred, PredicateIntersectionType)\n\n        with self.assertRaises(TypeError):\n            self.pred_gt3.intersection('foobarbaz')\n\n\nclass TestPredicateUnionType(unittest.TestCase):\n    def setUp(self):\n        \"\"\"Define simple predicates to use for testing.\"\"\"\n        self.pred_foo = Predicate('foo')  # Is \"foo\".\n        self.pred_bar = Predicate('bar')  # Is \"bar\".\n\n    def test_basics(self):\n        pred = PredicateUnionType(self.pred_foo, self.pred_bar)\n        self.assertTrue(pred('foo'))\n        self.assertTrue(pred('bar'))\n        self.assertFalse(pred('baz'))\n\n    def test_inverted(self):\n        # Using the inversion operator (~).\n        inv_pred = ~PredicateUnionType(self.pred_foo, self.pred_bar)\n        self.assertFalse(inv_pred('foo'))\n        self.assertFalse(inv_pred('bar'))\n        self.assertTrue(inv_pred('baz'))\n\n    def test_repr(self):\n        pred = PredicateUnionType(self.pred_foo, self.pred_bar)\n        self.assertEqual(repr(pred), \"Predicate('foo') | Predicate('bar')\")\n\n        inv_pred = ~pred\n        self.assertEqual(repr(inv_pred), \"~(Predicate('foo') | Predicate('bar'))\")\n\n    def test_bad_type(self):\n        with self.assertRaises(TypeError):\n            PredicateIntersectionType(self.pred_foo, 'foobarbaz')\n\n        with self.assertRaises(TypeError):\n            PredicateIntersectionType('foobarbaz', self.pred_foo)\n\n    def test_bitwise_operator(self):\n        pred = self.pred_foo | self.pred_bar\n        self.assertIsInstance(pred, PredicateUnionType)\n\n    def test_bitwise_operator_bad_type(self):\n        with self.assertRaises(TypeError):\n            self.pred_foo | 'foobarbaz'\n\n        with self.assertRaises(TypeError):\n            'foobarbaz' | self.pred_foo\n\n    def test_union_method(self):\n        pred = self.pred_foo.union(self.pred_bar)  # <- Union method.\n        self.assertIsInstance(pred, PredicateUnionType)\n\n        with self.assertRaises(TypeError):\n            self.pred_foo.union('foobarbaz')\n\n\nclass TesCombinedTypeNesting(unittest.TestCase):\n    def setUp(self):\n        \"\"\"Define simple predicates to use for testing.\"\"\"\n        self.pred_foo = Predicate('foo')  # Is \"foo\".\n        self.pred_bar = Predicate('bar')  # Is \"bar\".\n        self.pred_baz = Predicate('baz')  # Is \"baz\".\n        self.pred_gt3 = Predicate(lambda x: x > 3)  # Greater-than three.\n        self.pred_even = Predicate(lambda x: x % 2 == 0)  # Is even.\n\n    def test_behavior(self):\n        pred = self.pred_foo | self.pred_bar | self.pred_baz | (self.pred_gt3 & self.pred_even)\n        self.assertFalse(pred(1))\n        self.assertFalse(pred(2))\n        self.assertFalse(pred(3))\n        self.assertTrue(pred(4))\n        self.assertFalse(pred(5))\n        self.assertTrue(pred(6))\n        self.assertFalse(pred(7))\n        self.assertTrue(pred('foo'))\n        self.assertTrue(pred('bar'))\n        self.assertTrue(pred('baz'))\n        self.assertFalse(pred('qux'))\n\n    def test_repr(self):\n        \"\"\"Several of the following predicates are logically nonsensical\n        but since we're only testing the repr behavior, this is OK.\n        \"\"\"\n        pred = self.pred_foo | self.pred_bar | self.pred_baz\n        expected = \"Predicate('foo') | Predicate('bar') | Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo & self.pred_bar & self.pred_baz\n        expected = \"Predicate('foo') & Predicate('bar') & Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo | self.pred_bar & self.pred_baz  # \"&\" takes precedence\n        expected = \"Predicate('foo') | (Predicate('bar') & Predicate('baz'))\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = (self.pred_foo | self.pred_bar) & self.pred_baz  # Change order\n        expected = \"(Predicate('foo') | Predicate('bar')) & Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo & self.pred_bar | self.pred_baz  # \"&\" takes precedence\n        expected = \"(Predicate('foo') & Predicate('bar')) | Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo & (self.pred_bar | self.pred_baz)  # Change order\n        expected = \"Predicate('foo') & (Predicate('bar') | Predicate('baz'))\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo | self.pred_bar | self.pred_gt3 & self.pred_even | self.pred_baz\n        expected = \"Predicate('foo') | Predicate('bar') | (Predicate(<lambda>) & Predicate(<lambda>)) | Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n        pred = self.pred_foo | (self.pred_bar | self.pred_gt3) & self.pred_even | self.pred_baz\n        expected = \"Predicate('foo') | ((Predicate('bar') | Predicate(<lambda>)) & Predicate(<lambda>)) | Predicate('baz')\"\n        self.assertEqual(repr(pred), expected)\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_316","text":"\"\"\"\nperformance test\n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport miepy\nfrom tqdm import tqdm\nfrom functools import partial\nfrom scipy.sparse.linalg import bicg, bicgstab\nfrom miepy.interactions import solve_linear_system\nfrom topics.photonic_clusters.create_lattice import hexagonal_lattice_particles\nfrom timer import time_function\n\nnm = 1e-9\n\nAg = miepy.materials.Ag()\nradius = 75*nm\nsource = miepy.sources.plane_wave.from_string(polarization='rhc')\nsource = miepy.sources.gaussian_beam(2500*nm, [1, 1j], power=.002)\n\nx = np.linspace(-4000*nm, 4000*nm, 100)\ny = np.linspace(-4000*nm, 4000*nm, 100)\nsource = miepy.sources.grid_interpolate_source(source, [x,y,0])\nseparation = 600*nm\n\nx = np.arange(-1500*nm, 1500*nm, 50*nm)\ny = np.arange(-1500*nm, 1500*nm, 50*nm)\n# source = miepy.sources.grid_interp_source(source, grid=(x,y,0))\n\n\ndef tests(Nmax, step=1):\n    Nparticles = np.arange(1, Nmax+1, step)\n    t_force, t_flux, t_build, t_solve, t_source = [np.zeros_like(Nparticles, dtype=float) for i in range(5)]\n    for i,N in enumerate(Nparticles):\n        print(N, Nmax)\n        # positions = [[n*separation, 0, 0] for n in range(N)]\n        positions = hexagonal_lattice_particles(N)*separation\n        mie = miepy.sphere_cluster(position=positions,\n                                   radius=radius,\n                                   material=Ag,\n                                   source=source,\n                                   wavelength=600*nm,\n                                   lmax=2)\n        \n        t_force[i] = time_function(mie.force)\n        t_flux[i] = time_function(mie.cross_sections)\n        t_build[i] = time_function(partial(miepy.interactions.sphere_aggregate_tmatrix, \n                              mie.position, mie.mie_scat, mie.material_data.k_b))\n\n        A = miepy.interactions.sphere_aggregate_tmatrix(mie.position, mie.mie_scat, k=mie.material_data.k_b)\n        t_solve[i] = time_function(partial(solve_linear_system, A, mie.p_src, method=miepy.solver.bicgstab))\n        \n        x = np.linspace(0, N*separation, 1)\n        y = 2*radius*np.ones_like(x)\n        z = np.zeros_like(x)\n\n        t_source[i] = time_function(mie._solve_source_decomposition)\n\n    fig, ax = plt.subplots()\n\n    ax.plot(Nparticles, t_force*1e3, '-o', label='force')\n    ax.plot(Nparticles, t_flux*1e3,'-o',  label='flux')\n    ax.plot(Nparticles, t_build*1e3, '-o', label='build')\n    ax.plot(Nparticles, t_solve*1e3, '-o', label='solve')\n    ax.plot(Nparticles, t_source*1e3, '-o', label='source')\n\n    ax.legend()\n    ax.set(xlabel='number of particles', ylabel='runtime (ms)')\n\n    plt.show()\n\ntests(10, step=1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_317","text":"from lightweaver.fal import Falc82\nfrom lightweaver.rh_atoms import H_6_atom, H_6_CRD_atom, H_3_atom, C_atom, O_atom, OI_ord_atom, Si_atom, Al_atom, CaII_atom, Fe_atom, FeI_atom, He_9_atom, He_atom, He_large_atom, MgII_atom, N_atom, Na_atom, S_atom\nimport lightweaver as lw\nimport numpy as np\nimport scipy.interpolate as interp\nfrom astropy.convolution import Box1DKernel\nfrom astropy.convolution import convolve\nfrom astropy.io import fits\nfrom enum import IntEnum\nfrom mpi4py import MPI\nfrom tqdm import tqdm\nimport pickle\nimport argparse\n\nclass tags(IntEnum):\n    READY = 0\n    DONE = 1\n    EXIT = 2\n    START = 3\n\ndef smooth(sig, width):\n    return convolve(sig, Box1DKernel(width))\n\ndef iterate_ctx_crd(ctx, Nscatter=10, NmaxIter=500):\n    for i in range(NmaxIter):\n        dJ = ctx.formal_sol_gamma_matrices(verbose=False)\n        if i < Nscatter:\n            continue\n        delta = ctx.stat_equil(printUpdate=False)\n\n        if dJ < 3e-3 and delta < 1e-3:\n            # print(i, flush=True)\n            # print('----------')\n            return\n\ndef synth_spectrum(atmos, depthData=False, Nthreads=1, conserveCharge=False):\n    atmos.quadrature(5)\n    aSet = lw.RadiativeSet([H_6_atom(),\n    C_atom(),\n     OI_ord_atom(), Si_atom(), Al_atom(),\n    CaII_atom(),\n    Fe_atom(),\n    He_9_atom(),\n    MgII_atom(), N_atom(), Na_atom(), S_atom()\n    ])\n    # aSet.set_active('H', 'Ca')\n    aSet.set_active('Ca')\n    spect = aSet.compute_wavelength_grid()\n\n    eqPops = aSet.compute_eq_pops(atmos)\n\n    ctx = lw.Context(atmos, spect, eqPops, Nthreads=Nthreads, conserveCharge=conserveCharge)\n    if depthData:\n        ctx.depthData.fill = True\n    \n    iterate_ctx_crd(ctx)\n    eqPops.update_lte_atoms_Hmin_pops(atmos, quiet=True)\n    ctx.formal_sol_gamma_matrices(verbose=False)\n    return ctx\n    \ndef master_work(filename, write_frequency=1):    \n    task_index = 0\n    num_workers = size - 1\n    closed_workers = 0\n\n    fmodel = fits.open('\/net\/drogon\/scratch1\/aasensio\/3dcubes\/Enhanced_network_385_tau_from_RH_01_tau8.fits')    \n    bifrost = fmodel[0].data[:].astype('<f8').reshape((11, 96, -1))\n\n    n = bifrost.shape[-1]\n    \n    log_departure_list = [None] * n\n    T_list = [None] * n\n    tau_list = [None] * n\n    vturb_list = [None] * n\n    cmass = [None]\n    success = True\n\n    tasks = [0] * n\n    pointer = 0    \n    \n    print(\"*** Master starting with {0} workers\".format(num_workers))\n    with tqdm(initial=pointer, total=n, ncols=140) as pbar:\n        while closed_workers < num_workers:\n            dataReceived = comm.recv(source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status)                \n            source = status.Get_source()\n            tag = status.Get_tag()\n\n            if tag == tags.READY:\n                # Worker is ready, so send it a task\n                try:                    \n                    task_index = tasks.index(0)\n\n                    tau500 = np.ascontiguousarray(10.0**bifrost[0, ::-1, task_index])\n                    T = np.ascontiguousarray(bifrost[1, ::-1, task_index])\n                    vlos = np.ascontiguousarray(bifrost[5, ::-1, task_index]) \/ 100.0  # m\/s\n                    vturb = np.ascontiguousarray(bifrost[3, ::-1, task_index]) \/ 100.0 # m\/s\n\n                    dataToSend = {'index': task_index, 'tau500': tau500, 'T': T, 'vlos': vlos, 'vturb': vturb}\n                    comm.send(dataToSend, dest=source, tag=tags.START)\n\n                    tasks[task_index] = 1\n\n                    pbar.set_postfix(sent=f'{task_index}->{source}')\n                    \n                except:\n                    comm.send(None, dest=source, tag=tags.EXIT)\n\n            elif tag == tags.DONE:\n                index = dataReceived['index']                \n                success = dataReceived['success']\n                \n                if (not success):\n                    tasks[index] = -1\n                else:\n                    log_departure_list[index] = dataReceived['log_departure']\n                    T_list[index] = dataReceived['T']\n                    tau_list[index] = dataReceived['tau']\n                    vturb_list[index] = dataReceived['vturb']\n                    cmass = dataReceived['cmass']\n                \n                pbar.update(1)                \n                    \n            elif tag == tags.EXIT:\n                print(\" * MASTER : worker {0} exited.\".format(source))\n                closed_workers += 1\n\n            if (pbar.n \/ write_frequency == pbar.n \/\/ write_frequency):\n\n                with open(f'{filename}_logdeparture.pk', 'wb') as filehandle:\n                    pickle.dump(log_departure_list[0:task_index], filehandle)\n\n                with open(f'{filename}_T.pk', 'wb') as filehandle:\n                    pickle.dump(T_list[0:task_index], filehandle)\n                \n                with open(f'{filename}_vturb.pk', 'wb') as filehandle:\n                    pickle.dump(vturb_list[0:task_index], filehandle)\n\n                with open(f'{filename}_tau.pk', 'wb') as filehandle:\n                    pickle.dump(tau_list[0:task_index], filehandle)\n\n                with open(f'{filename}_cmass.pk', 'wb') as filehandle:\n                    pickle.dump(cmass, filehandle)\n\n    print(\"Master finishing\")\n\n    with open(f'{filename}_cmass.pk', 'wb') as filehandle:\n        pickle.dump(cmass, filehandle)\n\n    with open(f'{filename}_logdeparture.pk', 'wb') as filehandle:\n        pickle.dump(log_departure_list, filehandle)\n\n    with open(f'{filename}_T.pk', 'wb') as filehandle:\n        pickle.dump(T_list, filehandle)\n\n    with open(f'{filename}_vturb.pk', 'wb') as filehandle:\n        pickle.dump(vturb_list, filehandle)\n\n    with open(f'{filename}_tau.pk', 'wb') as filehandle:\n        pickle.dump(tau_list, filehandle)\n    \n\ndef slave_work(rank):\n    \n    while True:\n        comm.send(None, dest=0, tag=tags.READY)\n        dataReceived = comm.recv(source=0, tag=MPI.ANY_TAG, status=status)        \n\n        tag = status.Get_tag()\n            \n        if tag == tags.START:            \n            # Do the work here\n            task_index = dataReceived['index']\n            tau500 = dataReceived['tau500']\n            T = dataReceived['T']\n            vlos = dataReceived['vlos']\n            vturb = dataReceived['vturb']\n                    \n            success = 1\n\n            try:\n                atmos = lw.Atmosphere.make_1d(scale=lw.ScaleType.Tau500, depthScale=tau500, temperature=T, vlos=vlos, vturb=vturb, verbose=False)\n                ctx = synth_spectrum(atmos, depthData=True, conserveCharge=False)\n                tau = atmos.tauRef\n                cmass = atmos.cmass\n                temperature = atmos.temperature\n                vturb = atmos.vturb\n                log_departure = np.log10(ctx.activeAtoms[0].n \/ ctx.activeAtoms[0].nStar)\n            except:\n                success = 0           \n                            \n            dataToSend = {'index': task_index, 'T': temperature, 'log_departure': log_departure, 'tau': tau, 'cmass': cmass, 'vturb': vturb, 'success': success}\n\n            comm.send(dataToSend, dest=0, tag=tags.DONE)\n\n        elif tag == tags.EXIT:\n            break\n\n    comm.send(None, dest=0, tag=tags.EXIT)\n    \n\nif (__name__ == '__main__'):\n\n    # Initializations and preliminaries\n    comm = MPI.COMM_WORLD   # get MPI communicator object\n    size = comm.size        # total number of processes\n    rank = comm.rank        # rank of this process\n    status = MPI.Status()   # get MPI status object\n\n    print(f\"Node {rank}\/{size} active\", flush=True)\n\n           \n    if rank == 0:        \n        parser = argparse.ArgumentParser(description='Generate synthetic models and solve NLTE problem')        \n        parser.add_argument('--f', '--freq', default=1, type=int, metavar='FREQ', help='Frequency of model write')        \n\n        parsed = vars(parser.parse_args())\n        \n        master_work('bifrost', write_frequency=parsed['f'])\n    else:\n        slave_work(rank)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_318","text":"<reponame>jeti182\/tvatoj-power<gh_stars>1-10\n# MIT License\n\n# Copyright (c) 2020 <NAME>\n\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nfrom numpy import random, exp, array, zeros, log, clip\nfrom theano.tensor import mean, cast\nfrom theano.tensor import exp as ttexp\nfrom math import floor\nfrom numpy.random import random as runif\nfrom tqdm import tqdm\nimport pymc3\nimport pandas as pd\nfrom scipy.optimize import fmin\nfrom scipy.stats import *\nfrom tqdm import tqdm\nfrom scipy.stats import beta\nimport sys, logging\nimport warnings\n\nlogger = logging.getLogger(__name__)\ntry: \n    import coloredlogs\n    coloredlogs.install(level='DEBUG')\nexcept ImportError:\n    logging.info('If you like the terminal output colored.' + \n                 'Install colored coloredlogs (e.g., pip install coloredlogs)')\n\n# The TVAOJ psychometric function, see Tünnermann, Petersen, & Scharlau (2015):\ndef tvatoj_psychometric_function(SOA, C, wp, vp=None, vr=None):\n    \"\"\" Takes SOAs in ms and either C in 1\/ms and w or vp and vr in 1\/ms \"\"\"\n    if vp is None or vr is None:\n        vp = C * wp\n        vr = C * (1 - wp)\n    SOA = array(SOA)\n    left = (1-exp(-vp*abs(SOA))) + exp(-vp*abs(SOA)) * vp\/(vp+vr)\n    right = exp(-vr*abs(SOA))*vp\/(vp+vr)\n    return ((SOA<=0)*left  + (SOA>0)*right)\n\n# A generative simulation of the process\ndef simulate_subject_toj(SOA, reps, C, wp):\n    v1 = C * wp                             # attentional weights and overall rate C ...\n    v2 = C * (1 -wp)                        # ... determine the individual rates\n    probe_first_count = 0                   # Our counter each SOA starts with zero\n    for i in range(0, reps):                # For every repetition\n        tS = -log(1 - runif(1)) \/ v2        # let stimulus 2 race and record its VSTM arrival\n        tC =  SOA - log(1 - runif(1)) \/ v1  # sane for stimulus 1, offset by the SOA\n        if tC < tS:                         # Did 1 arrive before 2?\n            probe_first_count += 1          # Count as a \"probe first judment\"\n    return probe_first_count                # Return the result across all SOAs\n\n\n# Simulate TOJs for a group of participants, by drawing \n# their individual parameters from distributions\ndef simulate_tojs(simulation_setup): \n\n    s = simulation_setup # For convenient access ...\n    single_wp=False\n\n    # Get the paras per individual\n    if 'C_sd_within' in s: # within subject design\n        logging.info('[SIM] Simulating two different (but correlated) C parameters.')\n        C_sub_mu = clip(random.normal(s['C_mu'], s['C_sd_between'], size=s['num_participants']), 0, None)\n        C_a_sub =  clip(random.normal(C_sub_mu, s['C_sd_within'], size=s['num_participants']), 0, None)\n        C_n_sub =  clip(random.normal(C_sub_mu, s['C_sd_within'], size=s['num_participants']), 0,None)\n        wp_a_sub =  clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)\n        wp_n_sub =  clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)\n    elif 'C_a_mu' in s: # between design\n        logging.info('[SIM] Simulating two independent C parameters.')\n        C_a_sub =  clip(random.normal(s['C_a_mu'], s['C_a_sd_between'], size=s['num_participants']), 0, None)\n        C_n_sub =  clip(random.normal(s['C_n_mu'], s['C_n_sd_between'], size=s['num_participants']), 0,None)\n        wp_a_sub =  clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)\n        wp_n_sub =  clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)\n    elif 'C_single_mu' in s:\n        logging.info('[SIM] Simulating a single C parameter for both conditions.')\n        C_a_sub =  clip(random.normal(s['C_single_mu'], s['C_single_sd_between'], size=s['num_participants']), 0, None)\n        C_n_sub = C_a_sub\n        wp_a_sub =  clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)\n        wp_n_sub =  clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)\n    elif 'wp_mu' in s: # A single wp ==> Single condition experient\n        logging.info('[SIM] Simulating a single condition.')\n        C_sub =  clip(random.normal(s['C_mu'], s['C_sd_between'], size=s['num_participants']), 0, None)\n        wp_sub =  clip(random.normal(s['wp_mu'], s['wp_sd_between'], size=s['num_participants']), 0, None)\n        single_wp=True\n    else:\n        logger.error('Could not infer the design from the simulation parameters provided. Please refer to the exmaples')\n        sys.exit('Aborting')\n\n\n    # Get the TOJs\n    participant_id = []\n    condition_id = []\n    probe_first_count = []\n    repetitions = []\n    SOA = []\n\n    if single_wp:\n        condition_nums = [0]\n    else:\n        condition_nums = [0, 1]\n\n    for p in range(0, s['num_participants']):\n        for i,soa in enumerate(s['SOAs']):\n            for c in condition_nums:\n                participant_id.append(p)\n                condition_id.append(c)\n                SOA.append(soa)\n                repetitions.append(s['repetitions'][i])\n                if c == 0 and not single_wp: # simulate a neutral condition TOJ\n                    probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_n_sub[p], wp_n_sub[p]))\n                if c == 1 and not single_wp: # simulate an attention condition TOJ\n                    probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_a_sub[p], wp_a_sub[p]))\n                if c == 0 and single_wp:\n                    probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_sub[p], wp_sub[p]))\n\n    df = pd.DataFrame()\n    df['participant_id'] = participant_id\n    df['condition_id'] = condition_id\n    df['SOA'] = SOA\n    df['repetitions'] = repetitions\n    df['probe_first_count'] = probe_first_count\n                \n        \n    return df\n\n\n\n# Using the non-centered reparamtrization to reduce divergenses\n# See here for the rationale: https:\/\/twiecki.io\/blog\/2017\/02\/08\/bayesian-hierchical-non-centered\/\ndef hierarchical_model_noncentered(data, single_C=False, single_wp=False):\n    '''Sets up a pymc3 model based on TVATOJ.\n\n    :param data: A TOJ dataframe as return by the simulations\n    :param single_C: Whether to use single C (for both conditions)\n    :param single_wp: Whether to use a single wp (implies single C and produces a model for a single condition only)\n\n    :returns: Model\n    :rtype: pymc3.Model\n    '''\n \n    model = pymc3.Model()\n    with model: \n\n        p_id = data['participant_id']\n        c_id = data['condition_id']\n\n        if single_wp:        \n            wp_c_id = len(data['condition_id']) * [0]\n            single_C = True\n        else:\n            wp_c_id = c_id\n\n        if single_C:        \n            C_c_id = len(data['condition_id']) * [0]\n        else:\n            C_c_id = c_id\n\n            \n        pfc =  pymc3.Data('probe_first_count',data['probe_first_count'])\n\n        C_mu = pymc3.Normal('C_mu', 0.080, 0.050, shape=len(set(C_c_id)))\n        C_sd = pymc3.HalfCauchy('C_sd', 0.1, shape=len(set(C_c_id)))\n        \n        wp_mu = pymc3.Normal('wp_mu', 0.5,0.2, shape=len(set(wp_c_id)))\n        wp_sd = pymc3.HalfCauchy('wp_sd', 0.2, shape=len(set(wp_c_id)))\n\n        wp_e = pymc3.Normal('wp_e', 0,1, shape=(len(set(p_id)), len(set(wp_c_id))))\n        C_e = pymc3.Normal('C_e', 0,1, shape=(len(set(p_id)), len(set(C_c_id))))\n\n        C = pymc3.Deterministic('C', (C_mu + C_e * C_sd).clip(0.0001, 0.9999))\n        wp = pymc3.Deterministic('wp',  (wp_mu + wp_e * wp_sd).clip(0.0001, 0.9999))\n    \n        theta = pymc3.Deterministic('theta', tvatoj_psychometric_function(\n            data['SOA'], C[(p_id, C_c_id)], wp[(p_id, wp_c_id)]))\n\n        y = pymc3.Binomial('y', n=cast(data['repetitions'], 'int64'),\n                                p=theta, observed=pfc,\n                                dtype='int64')  \n\n        # The deterministic transformation could probably be externalized\n        # However, here the calculation is most safe to produce prober within subject estimates\n        vp = pymc3.Deterministic('vp', wp * C)\n        vr = pymc3.Deterministic('vr', (1 - wp) * C)\n        \n        \n        vp_mean = pymc3.Deterministic('vp_mean', mean(vp, axis=0)) \n        vr_mean = pymc3.Deterministic('vr_mean', mean(vr, axis=0)) \n        if not single_wp:\n            va_diff_mean = pymc3.Deterministic('va_diff_mean', mean(vp[:,1] - vr[:,1])) # Diff of probe and ref rate in the attention cond\n            vp_diff_mean = pymc3.Deterministic('vp_diff_mean', mean(vp[:,1] - vp[:,0])) # Diff of attention and neutral condition probe rates\n            vr_diff_mean = pymc3.Deterministic('vr_diff_mean', mean(vr[:,1] - vr[:,0])) # Diff of attention and neutral condition probe rates\n            wpa_mean = pymc3.Deterministic('wpa_mean', mean(wp[:,1])) \n            wp_diff_mean = pymc3.Deterministic('wp_diff_mean', mean(wp[:,1] - wp[:,0])) \n        else:\n            wp_vs_point5_mean = pymc3.Deterministic('wp_mean', mean(wp)) \n        return(model)\n\n \n# This function is borrowed from @aloctavodia, who ported it from <NAME>'s scripts\n# https:\/\/github.com\/aloctavodia\/Doing_bayesian_data_analysis\/blob\/master\/HDIofICDF.py\ndef HDIofICDF(dist_name, credMass=0.95, **args):\n    # freeze distribution with given arguments\n    distri = dist_name(**args)\n    # initial guess for HDIlowTailPr\n    incredMass =  1.0 - credMass\n\n    def intervalWidth(lowTailPr):\n        return distri.ppf(credMass + lowTailPr) - distri.ppf(lowTailPr)\n\n    # find lowTailPr that minimizes intervalWidth\n    HDIlowTailPr = fmin(intervalWidth, incredMass, ftol=1e-8, disp=False)[0]\n    # return interval as array([low, high])\n    return distri.ppf([HDIlowTailPr, credMass + HDIlowTailPr])\n\ndef sim_and_fit(setup, model_func, iterations, condition_func, \n                goal_var_names=None, log_var_names=['C_mu', 'wp_mu'],\n                single_C=False, single_wp=False, outfile='out.csv',\n                turn_off_warnings=True,\n                tune=1000,\n                target_accept=0.85,\n                init='adapt_diag'):\n\n    if (turn_off_warnings):\n        warnings.filterwarnings(\"ignore\")\n        logging.warning('Attention: Warnings turned off. ') # There is so much from pymc3 and theano ..\n\n    if log_var_names==None or len(log_var_names) < 1:\n        sys.exit('log_var_names should not be empty or None! Log at least one variable!')\n    num_success=0\n    model = None\n    for i in tqdm(range(iterations), desc='Overall progress'):\n        data = simulate_tojs(setup)\n        if model is None:\n            model = model_func(data, single_C=single_C, single_wp=single_wp)\n        with model:\n            pymc3.set_data({'probe_first_count': data['probe_first_count']})\n            trace = pymc3.sample(2000, tune=tune, cores=4, init=init, target_accept=target_accept)\n            summary_stats = pymc3.summary(trace, var_names=goal_var_names, hdi_prob=0.95)\n            print(summary_stats)\n        success = condition_func(summary_stats) * 1 # Either 0 or 1, depending on reaching our goals.\n        num_success += success\n        attempts = (i+1)\n        success_rate = num_success \/ attempts\n        hdi = HDIofICDF(beta,a=1+num_success, b=1+(attempts-num_success))\n        logging.info(('[ESTIMATE] Success rate: %.2f' % success_rate +\n                     ' [95 %% HDI: %.2f to %.2f]' % (hdi[0],hdi[1]) + \n                     '\\n' + '-'* 20))\n\n        out_df = pymc3.summary(trace, var_names=log_var_names, hdi_prob=0.95)\n        out_df.insert(0, 'iteration', attempts)\n        out_df.insert(1, 'success', success)\n        out_df.insert(2, 'power_est', success_rate)\n        out_df.insert(3, 'power_hdi_2.5%', hdi[0])\n        out_df.insert(4, 'power_hdi_97.5%', hdi[1])\n        if attempts == 1:\n            out_df.to_csv(outfile)\n        else:\n            out_df.to_csv(outfile, mode='a', header=False)\n\n'''\nConvenience function to fit with logging.\n'''            \ndef fit(model, outfile='fit.csv'):\n    with model:\n        trace = pymc3.sample(2000, tune=1000, cores=4, init='adapt_diag') #, target_accept=.85)\n        summary_stats = pymc3.summary(trace, hdi_prob=0.95)\n        summary_stats.to_csv(outfile)\n    logger.info('The model was fitted and a summary was written to: ' + outfile)\n    logger.info('You can analyze the returned trace with help of the Arviz library (https:\/\/arviz-devs.github.io\/arviz\/)')\n    logger.info('For instance, plot parameter posteriors with arviz.plot_posterior(trace, var_names=[\"C\", \"wp\"])')\n    return trace\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_319","text":"# Hysteresis model\n# http:\/\/eprints.lancs.ac.uk\/1375\/1\/MFI_10c.pdf\n# Identification of Hysteresis Functions Using a Multiple Model Approach\n# Mihaylova, Lampaert et al\n\nimport numpy as npy\nfrom scipy.optimize import root\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\nimport copy\n\n#%%\n\nplt.close('all')\n\nclass HysteresisModel:\n    \"\"\"\n    Hysteresis model comprising a number of elementary Maxwell-slip models\n    refer http:\/\/eprints.lancs.ac.uk\/1375\/1\/MFI_10c.pdf\n    \"\"\"\n    \n    def __init__(self,N,K,W=None,delta=None):\n        \n        self.N = N\n        \"\"\"\n        Integer number of elementary models\n        \"\"\"\n        \n        self.K = npy.ravel(npy.abs(K))\n        \"\"\"\n        Array of stiffness values for each elementary model\n        \"\"\"\n        \n        if delta is None :\n            # K and W specified\n            \n            if W is None:\n                raise ValueError(\"Error: either delta or W arguments \"+\n                                 \"must be provided!\")\n            else:\n                W = npy.ravel(npy.abs(W))          # limiting friction values\n                \n        else:\n            # K and delta specified\n            # W to be inferred, given this input\n            delta = npy.abs(npy.ravel(delta))\n            W = self.K * delta\n            \n        self.W = W\n        \"\"\"\n        Array of limiting friction values for each elementary model\n        \"\"\"\n        \n        # Initialise matrices F and C, which do not vary with input\n        self.F = npy.asmatrix(npy.identity(self.N))\n        self.C = npy.asmatrix(npy.diag(-self.K))\n        \n        # Initialise matrices G and D, as empty\n        self.G = npy.asmatrix(npy.empty((self.N,1)))\n        self.D = npy.asmatrix(npy.empty((self.N,1)))\n        \n        # Initialise array to contain case indexs\n        self.case = npy.zeros((self.N,),dtype=int)\n        \n                \n        \n    @property\n    def x0(self):\n        return self._x0        \n\n    @x0.setter\n    def x0(self,x0):\n        \"\"\"\n        Set initial states\n        \"\"\"\n        self._x0 = npy.asmatrix(npy.ravel(x0)).T\n        self.x =self.x0\n        \n        if self.x.shape[0] != self.N:\n            raise ValueError(\"Error: x0 wrong shape!\")\n            \n    @property\n    def x(self):\n        return self._x\n    \n    @x.setter\n    def x(self,val):\n        #print(\"States updated\")\n        self._x = npy.asmatrix(val)\n        \n            \n    def update(self,u,save_states=True):\n        \"\"\"\n        Function to advance state-space description of model dynamics \n        by a single time step, returning next state and output vectors\n        \"\"\"\n    \n        x = copy.deepcopy(self.x)\n        \n        # Define G and D matrix entries\n        for i in range(self.N): # loop over all elementary models\n            \n            Wi = self.W[i]\n            Ki = self.K[i]\n            \n            # Evaluate switching parameter\n            fi = Ki * (u - x[i])\n            \n            if fi > Wi:\n                # Case 2\n                self.case[i] = 2\n                self.G[i] = 1\n                self.D[i] = 0\n                x[i] = -Wi\/Ki\n                \n            \n            elif fi < -Wi:\n                # Case 3\n                self.case[i] = 3\n                self.G[i] = 1\n                self.D[i] = 0   \n                x[i] = +Wi\/Ki\n            \n            else:\n                # Case 1\n                self.case[i] = 1\n                self.G[i] = 0\n                self.D[i] = Ki\n        \n        # Compute next states and output\n        # using eqns (10) and (11) in Mihaylova's paper\n        x_next = self.F * x + self.G * u\n        y_k = self.C * x + self.D * u\n        \n        Fh_k = y_k.sum() # total hysteresis force\n                \n        # Update states\n        if save_states:\n            self.x = x_next\n\n        return x_next, y_k, Fh_k\n    \n        \n    def run(self,x0,uVals):\n        \"\"\"\n        Run simulation from initial conditions, given inputs u\n            x0    : column vector [Nx1]\n            u     : list or vector of length (nSteps,1)\n        \"\"\"\n        \n        # Convert and check shape of u\n        uVals = npy.ravel(uVals)\n        nSteps = uVals.shape[0] \n        \n        # Initialise state space eqns\n        self.x0 = x0\n        \n        # Step through state space eqns\n        xVals = npy.zeros((nSteps,self.N))\n        yVals = npy.zeros((nSteps,self.N))\n        Fh_vals = npy.zeros((nSteps,))\n        \n        for k, u_k in enumerate(uVals):\n            \n            # Get next states and output\n            x_k, y_k, Fh_k = self.update(u_k)\n            \n            # Store\n            xVals[k,:] = npy.ravel(x_k)\n            yVals[k,:] = y_k.T\n            Fh_vals[k] = Fh_k\n        \n        # Store results\n        self.uVals = uVals\n        self.xVals = xVals\n        self.yVals = yVals\n        self.FhVals = Fh_vals\n        \n        # Return states and output for each step\n        return xVals, yVals, Fh_vals\n    \n    \n    def write_results(self,\n                      fname='results.csv',\n                      delimiter=','):\n        \n        arr = npy.asmatrix(self.uVals).T\n        titles = [\"u\"]\n        N = self.N\n        \n        arr = npy.hstack((arr,self.xVals))\n        titles += [\"x%d\" % (i+1) for i in range(N)]\n        \n        arr = npy.hstack((arr,self.yVals))\n        titles += [\"y%d\" % (i+1) for i in range(N)]\n        \n        arr = npy.hstack((arr,npy.asmatrix(self.FhVals).T))\n        titles += [\"Fh\"]\n        \n        npy.savetxt(fname=fname,\n                    X=arr,\n                    delimiter=delimiter,\n                    header=delimiter.join(str(x) for x in titles))\n    \n    \n    def PlotResults_timeSeries(self,tVals):\n        \"\"\"\n        Plot results as time series\n        [t,u], [t,x], [t,y], [t,Fh]\n        \"\"\"\n        \n        fig, axarr = plt.subplots(4,sharex=True)\n        fig.set_size_inches(16,9,forward=True)\n        \n        ax1 = axarr[0]\n        ax1.plot(tVals,self.uVals)\n        ax1.xaxis.set_visible(False)\n        ax1.set_ylabel(\"u\")\n        ax1.set_xlabel(\"Input displacement, u(t)\")\n        \n        ax2 = axarr[1]\n        ax2.plot(tVals,self.xVals)\n        ax2.xaxis.set_visible(False)\n        ax2.set_ylabel(\"x\")\n        ax2.set_title(\"States of\\nelementary models, x(t)\")\n        \n        ax3 = axarr[2]\n        ax3.plot(tVals,self.yVals)\n        ax3.xaxis.set_visible(False)\n        ax3.set_ylabel(\"y\")\n        ax3.set_title(\"Outputs from\\nelementary models, y(t)\")\n        \n        ax4 = axarr[3]\n        ax4.plot(tVals,self.FhVals)\n        ax4.set_xlabel(\"Time (seconds)\")\n        ax4.set_ylabel(\"F$_h$\")\n        ax4.set_title(\"Net output F$_h$\")\n        \n        \n    def PlotResults(self):\n        \"\"\"\n        Plot results as [u,x], [u,y], [u,Fh] plots\n        \"\"\"\n        \n        fig, axarr = plt.subplots(1,3,sharex=True)\n        fig.set_size_inches(16,9,forward=True)\n        \n        ax1 = axarr[0]\n        ax1.plot(self.uVals,self.xVals)\n        ax1.set_xlabel(\"Input u\")\n        ax1.set_title(\"States of\\nelementary models, x\")\n        \n        ax2 = axarr[1]\n        \n        ax2.plot(self.uVals,self.yVals)\n        ax2.set_xlabel(\"Slip (u-x)\")\n        ax2.set_title(\"Outputs from\\nelementary models, y\")\n        \n        ax3 = axarr[2]\n        ax3.plot(self.uVals,self.FhVals)\n        ax3.set_xlabel(\"Input u\")\n        ax3.set_title(\"Net output F$_h$\")\n    \n\nclass static_response():\n    \"\"\"\n    Class used to compute response to forcing input\n    \"\"\"\n\n    def __init__(self,hys_obj,K1, K2):\n        self.hys_obj = hys_obj\n        self.K1 = K1\n        self.K2 = K2\n    \n    def net_force(self,d,F_ext,verbose=False):\n        \"\"\"\n        Function which defines net force \n        given position 'u' and external force 'F_ext'\n        \"\"\"\n        \n        u = d[0] - d[1]  # relative displacement at friction interface\n        F_hys = self.hys_obj.update(u=u,save_states=False)[2]\n\n        F_net_1 = self.K1 * d[0] + F_hys - F_ext\n        F_net_2 = self.K2 * d[1] - F_hys\n        F_net = npy.array([F_net_1,F_net_2])\n        \n        if verbose:\n            print(\"u = %.3e\" % u)\n            print(\"x = {0}\".format(self.hys_obj.x))\n            print(\"F_hys = {0}\".format(F_hys))\n            print(\"F_net = {0}\".format(F_net))\n        \n        return F_net\n    \n    def run(self,F_vals,x0=None,d0=None):\n        \n        # Define function to solve for next u\n        def solve(d_last,F_k,hys_obj):\n    \n            # Determine next u to satify equilibrium - i.e. zero net force\n            sol = root(fun=self.net_force,x0=d_last,args=(F_k,))\n            d_k = sol.x\n            u_k = d_k[0]-d_k[1]\n            \n            F_net = self.net_force(d_k,F_k)\n            \n            if not sol.success:\n                pass#print(sol.message)\n                \n            x_k, y_k, F_hys_k = hys_obj.update(u=u_k,save_states=True)\n            \n            return F_hys_k, d_k, u_k, x_k, y_k, F_net\n        \n        # Set initial conditions\n        if x0 is None:\n            x0 = npy.zeros((self.hys_obj.N,))\n        self.hys_obj.x0 = x0\n        \n        if d0 is None:\n            d0 = npy.array([0.0,0.0])\n        d_j = d0 # initial guess\n        \n        # Run step by step \n        F_hys_vals = []\n        x_vals = []\n        u_vals = []\n        y_vals = []\n        F_net_vals = []\n        \n        for j, F_j in enumerate(F_vals):\n            \n            #print(\"--- Step #%d ---\" % j)\n            F_hys_j, d_j, u_j, x_j, y_j, F_net = solve(d_j,F_j,self.hys_obj)\n            \n            F_hys_vals.append(F_hys_j)\n            x_vals.append(npy.ravel(x_j))\n            y_vals.append(npy.ravel(y_j))\n            u_vals.append(u_j)\n            F_net_vals.append(F_net)\n        \n        self.x_vals = x_vals\n        self.y_vals = y_vals\n        self.u_vals = u_vals\n        self.F_hys_vals = F_hys_vals\n        self.F_vals = F_vals\n        self.F_net_vals = F_net_vals\n        \n    \n    def plot(self):\n        \n        fig, axarr = plt.subplots(3,2,sharex='col')\n        fig.set_size_inches(14,8)\n        \n        ax = axarr[0,0]\n        ax.plot(self.F_vals,label='$F_{external}$')\n        ax.plot(self.F_hys_vals,label='$F_{hysteresis}$')\n        ax.legend()\n        ax.set_ylabel(\"Forces\")\n        \n        ax = axarr[1,0]\n        ax.plot(self.u_vals)\n        ax.set_ylabel(\"Displacement, u\")\n        \n        ax = axarr[2,0]\n        ax.plot(self.x_vals)\n        ax.set_xlabel(\"Step index\")\n        ax.set_ylabel(\"States, x\")\n        \n        ax = axarr[0,1]\n        ax.plot(self.u_vals,self.y_vals)\n        ax.set_ylabel(\"Outputs, y\")\n        \n        ax = axarr[1,1]\n        ax.plot(self.u_vals,self.F_hys_vals)\n        ax.set_ylabel(\"$F_{hysteresis}$\")\n        \n        ax = axarr[2,1]\n        ax.plot(self.u_vals,self.F_vals)\n        ax.set_xlabel(\"Displacement, u\")\n        ax.set_ylabel(\"$F_{external}$\")\n        \n        return fig\n        \n    \n# -------- TEST ROUTINE ----------\n\nif __name__ == \"__main__\":\n    \n    test_routine = 1\n    \n    if test_routine == 0:\n            \n        # Define hysteresis model\n        K = [1000,2000,3000] \n        delta = [1,2,3]\n        Ne = len(K)\n        hys = HysteresisModel(Ne,K,delta=delta)\n        \n        # Define displacement inputs\n        dt = 0.02\n        tmax = 10\n        u0 = 10\n        \n        import random\n\n        def randomWalk(N,normalise=True):\n                \n            x= [0]\n            \n            for j in range(N-1):\n                step_x = random.randint(0,1)\n                if step_x == 1:\n                    x.append(x[j] + 1 + 0.05*npy.random.normal())\n                else:\n                    x.append(x[j] - 1 + 0.05*npy.random.normal())\n                 \n            x = npy.asarray(x)\n            \n            if normalise:\n                absmaxVal = npy.max([npy.max(x),-npy.min(x)])\n                x = x \/ absmaxVal\n            \n            return x\n        \n        tVals = npy.arange(0,tmax,dt)\n        uVals = u0*randomWalk(tVals.shape[0])\n        \n        #uVals = 4.5*npy.sin(2*npy.pi*0.5*tVals)\n        \n        # Obtain states and outputs by state space stepping\n        hys.run(npy.zeros((Ne,)),uVals)\n        \n        # Plot results\n        hys.PlotResults()\n        hys.PlotResults_timeSeries(tVals)\n          \n        #hys.write_results()\n    \n    elif test_routine==1:\n        \n        # Define hysteresis model\n        K = [1000,2000,3000] \n        W = [1000,1000,1000]\n        Ne = len(K)\n        hys = HysteresisModel(Ne,K,W=W)\n        \n        # Define force function\n        # Define displacement inputs\n        dt = 0.02\n        tmax = 10\n        u0 = 10\n        F0 = 3000\n        \n        t_vals = npy.arange(0,tmax,dt)\n        F_vals = F0 * (npy.sin(2*npy.pi*t_vals) + npy.sin(2*npy.pi*3.2*t_vals))\n    \n        # Define spring\n        K_spring = 1500\n        \n        # Define and run analysis\n        analysis = static_response(hys_obj=hys,K_spring=K_spring)\n        analysis.run(F_vals=F_vals)\n        analysis.plot()            \n    \n    else:\n        raise ValueError(\"No test selected!\")\n    \n#%%\n\n#\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_352","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue May 11 09:37:22 2021\n\n@author: <NAME>\n\"\"\"\n'''\nComplexity = Hard\n'''\n'''\nGiven two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.\n\nThe overall run time complexity should be O(log (m+n)).\n\n \n\nExample 1:\n\nInput: nums1 = [1,3], nums2 = [2]\nOutput: 2.00000\nExplanation: merged array = [1,2,3] and median is 2.\nExample 2:\n\nInput: nums1 = [1,2], nums2 = [3,4]\nOutput: 2.50000\nExplanation: merged array = [1,2,3,4] and median is (2 + 3) \/ 2 = 2.5.\nExample 3:\n\nInput: nums1 = [0,0], nums2 = [0,0]\nOutput: 0.00000\nExample 4:\n\nInput: nums1 = [], nums2 = [1]\nOutput: 1.00000\nExample 5:\n\nInput: nums1 = [2], nums2 = []\nOutput: 2.00000\n \n\nConstraints:\n\nnums1.length == m\nnums2.length == n\n0 <= m <= 1000\n0 <= n <= 1000\n1 <= m + n <= 2000\n-106 <= nums1[i], nums2[i] <= 106\nAccepted\n937,027\nSubmissions\n2,961,335\n'''\n\n'''\nResults of below solution:\n    \nRuntime: 92 ms, faster than 64.31% of Python3 online submissions for Median of Two Sorted Arrays.\nMemory Usage: 14.4 MB, less than 78.54% of Python3 online submissions for Median of Two Sorted Arrays.\n'''\nclass Solution:\n    def findMedianSortedArrays(self, nums1, nums2) -> float:\n        array=sorted(nums1+nums2)\n        import statistics\n        return statistics.median(array)\n        \n        \n        \ny=Solution()\nnums1 = [1,3] \nnums2 = [2]\nprint(y.findMedianSortedArrays(nums1, nums2))\nnums1 = [1,2]\nnums2 = [3,4]\nprint(y.findMedianSortedArrays(nums1, nums2))\nnums1 = [0,0]\nnums2 = [0,0]\nprint(y.findMedianSortedArrays(nums1, nums2))\nnums1 = []\nnums2 = [1]\nprint(y.findMedianSortedArrays(nums1, nums2))\nnums1 = [2]\nnums2 = []\nprint(y.findMedianSortedArrays(nums1, nums2))     \n      \n        \n        \n        \n        \n        \n        \n        \n        \n        \n        \n        \n        \n        \n        \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_353","text":"# -*- coding:utf-8 -*-\n__author__ = 'yangjian'\n\"\"\"\n\n\"\"\"\n\nfrom collections import defaultdict\n\nimport numpy as np\nimport pandas as pd\nfrom scipy.cluster import hierarchy\nfrom scipy.stats import spearmanr\nfrom sklearn.impute import SimpleImputer\n\nfrom hypernets.core import randint\nfrom hypernets.tabular import sklearn_ex as skex, dask_ex as dex, column_selector as cs\nfrom hypernets.tabular.cfg import TabularCfg as cfg\nfrom hypernets.utils import logging\n\nlogger = logging.get_logger(__name__)\n\n\ndef select_by_multicollinearity(X, method=None):\n    \"\"\"\n    Adapted from https:\/\/scikit-learn.org\/stable\/auto_examples\/inspection\/plot_permutation_importance_multicollinear.html\n    handling multicollinearity is by performing hierarchical clustering on the features’ Spearman\n    rank-order correlations, picking a threshold, and keeping a single feature from each cluster.\n    \"\"\"\n    X_shape = X.shape\n    if dex.is_dask_dataframe(X):\n        X_shape = dex.compute(X_shape)[0]\n    sample_limit = cfg.multi_collinearity_sample_limit\n    if X_shape[0] > sample_limit:\n        logger.info(f'{X_shape[0]} rows data found, sample to {sample_limit}')\n        frac = sample_limit \/ X_shape[0]\n        X, _, = dex.train_test_split(X, train_size=frac, random_state=randint())\n\n    n_values = [X[c].value_counts() for c in X.columns]\n    if dex.is_dask_dataframe(X):\n        n_values = dex.compute(*n_values)\n    one_values = [n.name for n in n_values if len(n) <= 1]\n    if len(one_values) > 0:\n        X = X[[c for c in X.columns if c not in one_values]]\n\n    logger.info('computing correlation')\n    if (method is None or method == 'spearman') and isinstance(X, pd.DataFrame):\n        Xt = SimpleImputer(missing_values=np.nan, strategy='most_frequent').fit_transform(X)\n        corr = spearmanr(Xt).correlation\n    elif isinstance(X, pd.DataFrame):\n        Xt = X.copy()\n        cols = cs.column_number_exclude_timedelta(X)\n        if cols:\n            Xt[cols] = SimpleImputer(missing_values=np.nan, strategy='most_frequent').fit_transform(Xt[cols])\n        Xt = skex.SafeOrdinalEncoder().fit_transform(Xt)\n        corr = Xt.corr(method=method).values\n    else:  # dask\n        Xt = dex.SafeOrdinalEncoder().fit_transform(X)\n        corr = Xt.corr(method='pearson' if method is None else method).compute().values\n\n    logger.info('computing cluster')\n    corr_linkage = hierarchy.ward(corr)\n    cluster_ids = hierarchy.fcluster(corr_linkage, 1, criterion='distance')\n    cluster_id_to_feature_ids = defaultdict(list)\n    for idx, cluster_id in enumerate(cluster_ids):\n        cluster_id_to_feature_ids[cluster_id].append(idx)\n    selected = [X.columns[v[0]] for v in cluster_id_to_feature_ids.values()]\n    unselected = list(set(X.columns.to_list()) - set(selected)) + one_values\n    feature_clusters = [[X.columns[i] for i in v] for v in cluster_id_to_feature_ids.values()]\n    return feature_clusters, selected, unselected\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_354","text":"<reponame>DeepK\/hoDMD-experiments\nfrom scipy.fftpack import dct\nfrom traintestutil import train_test\nimport numpy\nfrom functools import partial\nimport argparse\n\n\ndef dct_keep(to_keep, vectors):\n  return numpy.hstack(dct(vectors)[:to_keep, :])\n\n\nif __name__ == \"__main__\":\n\n  parser = argparse.ArgumentParser(description='Evaluate DCT based sentence embedding')\n  parser.add_argument(\"pickled_training_data_path\", help=\"pickled train path\")\n  parser.add_argument(\"pickled_test_data_path\", help=\"pickled test path\")\n  parser.add_argument(\"DCT_components_to_keep\", help=\"DCT components to keep\", type = int)\n\n  args = parser.parse_args()\n\n  pickled_training_data_path = args.pickled_training_data_path\n  pickled_test_data_path = args.pickled_test_data_path\n  DCT_components_to_keep = args.DCT_components_to_keep\n\n  print (\"DCT components to keep -> %s\"%DCT_components_to_keep)\n\n  func_to_apply = partial(dct_keep, DCT_components_to_keep)\n\n  filter_by_len = DCT_components_to_keep\n  results = train_test(pickled_training_data_path, pickled_test_data_path, func_to_apply, filter_by_len)\n  results = results.split(\"\\n\")[-2]\n  print (results)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_355","text":"'''\nCopyright(C) 2016 Engineering Department, University of Cambridge, UK.\n\nLicense\n   Licensed under the Apache License, Version 2.0 (the \"License\");\n   you may not use this file except in compliance with the License.\n   You may obtain a copy of the License at\n\n     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n\n   Unless required by applicable law or agreed to in writing, software\n   distributed under the License is distributed on an \"AS IS\" BASIS,\n   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n   See the License for the specific language governing permissions and\n   limitations under the License.\n\nAuthor\n    <NAME> <<EMAIL>>\n'''\n\nimport os\nimport subprocess\nimport numpy as np\nimport scipy.interpolate\nfrom scipy import signal as sig\n\nfrom lib import sigproc as sp\nfrom . import fileio\n\ndef resample(wav, fs, trgfs, method=2, deterministic=True):\n    '''\n        deterministic [True] : Try to make it deterministic.\n                               (e.g. sox (mehtod=2) is not deterministic by default)\n                    ATTENTION This option has been tested only for method==2\n    '''\n    if method==1:\n        # sndfile-resample (libresample)\n        # 'c' argument\n        #0 : Best Sinc Interpolator\n        #1 : Medium Sinc Interpolator (default)\n        #2 : Fastest Sinc Interpolator TO AVOID\n        #3 : ZOH Interpolator TO AVOID\n        #4 : Linear Interpolator TO AVOID\n        # sndfile-resample _seems_ to be always deterministic\n\n        tmpinfname = sp.gentmpfile('sndfile-resample-in.wav')\n        tmpoutfname = sp.gentmpfile('sndfile-resample-out.wav')\n\n        try:\n            wavwrite(tmpinfname, wav, fs)\n\n            cmd = 'sndfile-resample -c 0 -to '+str(trgfs)+' '+tmpinfname+' '+tmpoutfname\n            out = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)\n            #print(out)\n\n            syn, synfs, synenc = wavread(tmpoutfname)\n        except:\n            if os.path.exists(tmpinfname): os.remove(tmpinfname)\n            if os.path.exists(tmpoutfname): os.remove(tmpoutfname)\n            raise\n\n        if os.path.exists(tmpinfname): os.remove(tmpinfname)\n        if os.path.exists(tmpoutfname): os.remove(tmpoutfname)\n\n    elif method==2:\n        # SOX\n        # VHQ: -v -s: The fastest with the results among the bests\n        # ATTENTION:If deterministic=False, sox is NOT deterministic!\n        #           I.e. it does NOT produce the same samples for each run!\n\n        tmpinfname = sp.gentmpfile('sox-resample-in.wav')\n        tmpoutfname = sp.gentmpfile('sox-resample-out.wav')\n\n        try:\n            fileio.wavwrite(tmpinfname, wav, fs)\n\n            cmd = 'sox '\n            if deterministic: cmd += '--no-dither '\n            cmd += tmpinfname+' '+tmpoutfname+' rate -v -s '+str(trgfs)\n            out = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)\n            #print(out)\n\n            syn, synfs, synenc = fileio.wavread(tmpoutfname)\n        except:\n            if os.path.exists(tmpinfname): os.remove(tmpinfname)\n            if os.path.exists(tmpoutfname): os.remove(tmpoutfname)\n            raise\n\n        if os.path.exists(tmpinfname): os.remove(tmpinfname)\n        if os.path.exists(tmpoutfname): os.remove(tmpoutfname)\n\n    elif method==3:\n        '''\n        Resample using FFT and power of 2\n        Create sometimes a significant peak at Nyquist\n        '''\n        syn = wav.copy()\n        wavlen = syn.shape[0]\n        wavlenpow2  = int(np.power(2, np.floor(np.log2(wavlen))+1))\n        syn = np.pad(syn, (0, wavlenpow2-wavlen), constant_values=(0,0), mode='constant')\n        syn = scipy.signal.resample(syn, np.round(len(syn)*float(trgfs)\/fs))\n        syn = syn[:np.round(wavlen*float(trgfs)\/fs)]\n\n    if 0:\n        import matplotlib.pyplot as plt\n        plt.ion()\n        plt.plot(np.arange(len(wav))\/float(fs), wav, 'k')\n        plt.plot(np.arange(len(syn))\/float(trgfs), syn, 'b')\n        from IPython.core.debugger import  Pdb; Pdb().set_trace()\n\n    return syn\n\n# Resample feature using the nearest\ndef featureresample(ts, X, nts):\n    if len(X.shape)>1:\n        Y = np.zeros((len(nts), X.shape[1]))\n    else:\n        Y = np.zeros(len(nts))\n    for n, t in enumerate(nts):\n        idx = np.where(ts>=t)[0]\n        if len(idx)==0:\n            idx = X.shape[0]-1\n        else:\n            idx = np.min(idx) # Nearest\n        idx = np.clip(idx, 0, X.shape[0]-1)\n        if len(X.shape)>1:\n            Y[n,:] = X[idx,:]\n        else:\n            Y[n] = X[idx]\n    return Y\n\ndef f0s_resample_pitchsync(f0s, nbperperiod, f0min=20.0, f0max=5000.0):\n    f0s = f0s.copy()\n\n    # Interpolate where there is zero values\n    f0s[:,1] = np.interp(f0s[:,0], f0s[f0s[:,1]>0,0], f0s[f0s[:,1]>0,1])\n\n    f0s[:,1] = np.clip(f0s[:,1], f0min, f0max)\n\n    ts = [0.0]\n    while ts[-1]<f0s[-1,0]:\n        cf0 = np.interp(ts[-1], f0s[:,0], f0s[:,1])\n        ts.append(ts[-1]+(1.0\/nbperperiod)\/cf0)\n    f0s = np.vstack((ts, np.interp(ts, f0s[:,0], f0s[:,1]))).T\n\n    return f0s\n\ndef f0s_resample_cst(f0s, timeshift):\n    f0s = f0s.copy()\n\n    vcs = f0s.copy()\n    vcs[vcs[:,1]>0,1] = 1\n\n    nts = np.arange(f0s[0,0], f0s[-1,0], timeshift)\n\n    # The voicing resampling has to be done using nearest ...\n    vcsfn = scipy.interpolate.interp1d(vcs[:,0], vcs[:,1], kind='nearest', bounds_error=False, fill_value=0)\n\n    # ... whereas the frequency resampling need linear interpolation, while ignoring the voicing\n    f0s = np.interp(nts, f0s[f0s[:,1]>0,0], f0s[f0s[:,1]>0,1])\n\n    # Put back the voicing\n    f0s[vcsfn(nts)==0] = 0.0\n\n    f0s = np.vstack((nts, f0s)).T\n\n    if 0:\n        plt.plot(f0s[:,0], f0s[:,1])\n\n    return f0s\n\ndef f0s_rmsteps(f0s):\n    '''\n    Description\n        Removes steps in the F0 curve.\n\n        Steps can come from some F0 estimator (e.g. those based on GCI\n        detection are likely to exhibits these).\n\n        For pulse synthesis, it avoids some glitches around the main lobes\n\n        It might be bad for creaky voice (oversmoothing the f0 curve),\n        though F0 estimate in creaky voice is quite likely to be wrong anyway.\n    '''\n    f0sori = f0s.copy()\n    f0s = f0s.copy()\n    voicedi = np.where(f0s[:,1]>0)[0]\n    shift = np.mean(np.diff(f0s[:,0]))\n    fc = (1.0\/shift)\/4.0  # The cut-off frequency\n    hshift = (1.0\/fc)\/8.0 # The high sampling rate for resampling the original curve\n    data = np.interp(np.arange(0.0, f0s[-1,0], hshift), f0s[voicedi,0], f0s[voicedi,1])\n    b, a = sig.butter(8, fc\/(0.5\/hshift), btype='low')\n    f0ss = sig.filtfilt(b, a, data)\n    f0s[voicedi,1] = np.interp(f0s[voicedi,0], np.arange(0.0, f0s[-1,0], hshift), f0ss)\n\n    if 0:\n        plt.plot(f0sori[:,0], f0sori[:,1], 'k')\n        plt.plot(f0s[:,0], f0s[:,1], 'b')\n        from IPython.core.debugger import  Pdb; Pdb().set_trace()\n\n    return f0s\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_356","text":"from pathlib import Path\nimport os\nimport matplotlib as mpl\nif os.environ.get('DISPLAY') is None:  # NOQA\n    mpl.use('Agg')  # NOQA\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as ticker\nimport matplotlib\nimport itertools\nimport numpy as np\n\n# from pylab import rcParams\n# rcParams['figure.figsize'] = (12, 12)\nfontsize = 12\nparams = {\n    'figure.figsize': (12, 12),\n    'axes.labelsize': fontsize,\n    'axes.titlesize': fontsize,\n    'legend.fontsize': fontsize,\n    'xtick.labelsize': fontsize - 1,\n    'ytick.labelsize': fontsize - 1,\n}\nmpl.rcParams.update(params)\n\n\ndef histogram(\n        values,\n        *,\n        name,\n        filetype=\"png\",\n        plt_kwargs=None,\n        hist_kwargs=None):\n    n, bins, patches = mpl_plot(\n        plt_fn=lambda: plt.hist(values, linewidth=10, **(hist_kwargs or {})),\n        name=name,\n        filetype=filetype,\n        **(plt_kwargs or {}))\n    return n, bins\n\n\ndef scatter(\n        x,\n        y,\n        *,\n        name,\n        filetype=\"png\",\n        plt_kwargs=None,\n        scatter_kwargs=None,\n        fit_y=None,\n        fit_plot_kwargs=None,\n        legend=False):\n    def plot_fit():\n        if fit_y is not None:\n            plt.plot(x, fit_y, **(fit_plot_kwargs or {}))\n\n    def legend_fn():\n        if legend:\n            if isinstance(legend, dict):\n                plt.legend(**legend)\n            else:\n                plt.legend()\n\n    if isinstance(y, dict):\n        def plt_fn():\n            for label, _y in y.items():\n                plt.scatter(x, _y, label=label, **(scatter_kwargs or {}))\n            plot_fit()\n            legend_fn()\n    else:\n        def plt_fn():\n            plt.scatter(x, y, **(scatter_kwargs or {}))\n            plot_fit()\n            legend_fn()\n    mpl_plot(\n        plt_fn=plt_fn,\n        name=name,\n        filetype=filetype,\n        **plt_kwargs)\n\n\ndef mpl_plot(\n        plt_fn,\n        *,\n        name,\n        filetype=\"png\",\n        **plt_kwargs):\n    Figure.file_types = [filetype]\n    Figure.set_defaults(**plt_kwargs)\n    with Figure(name):\n        return plt_fn()\n\n\n# http:\/\/pytorch.org\/tutorials\/intermediate\/seq2seq_translation_tutorial.html#the-seq2seq-model  # NOQA\ndef plot_attention(\n        input_labels, output_labels, attentions,\n        out_colors=None, filepath=None):\n    # Set up figure with colorbar\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    cax = ax.matshow(attentions, cmap='bone')\n    fig.colorbar(cax)\n\n    # Set up axes\n    ax.tick_params(axis='both', which='major', labelsize=10)\n    ax.tick_params(axis='both', which='minor', labelsize=8)\n    ax.set_xticklabels([''] + output_labels, rotation=90)\n    ax.set_yticklabels([''] + input_labels)\n\n    # Show label at every tick\n    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n\n    if out_colors:\n        out_colors = [\"k\"] + out_colors\n        assert len(out_colors) == 1 + len(output_labels), \\\n            f\"got {len(out_colors)} colors for {len(output_labels)} labels\"\n        for xtick, color in zip(ax.get_xticklabels(), out_colors):\n            xtick.set_color(color)\n\n    if filepath:\n        plt.savefig(filepath)\n    else:\n        plt.show()\n    plt.close()\n\n\n# http:\/\/scikit-learn.org\/stable\/auto_examples\/model_selection\/plot_confusion_matrix.html  # NOQA\ndef plot_confusion_matrix(\n        cm, classes,\n        normalize=False, title='Confusion matrix', cmap=plt.cm.Blues,\n        filepath=None):\n    \"\"\"This function prints and plots the confusion matrix.\n    Normalization can be applied by setting `normalize=True`.\n    \"\"\"\n    if normalize:\n        cm = cm.astype('float') \/ cm.sum(axis=1)[:, np.newaxis]\n        plt.imshow(\n            cm, interpolation='nearest', cmap=cmap, vmin=0, vmax=1)\n    else:\n        plt.imshow(cm, interpolation='nearest', cmap=cmap)\n    plt.title(title)\n    plt.colorbar()\n    tick_marks = np.arange(len(classes))\n    plt.xticks(tick_marks, classes, rotation=90)\n    plt.yticks(tick_marks, classes)\n\n    thresh = cm.max() \/ 2.\n    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n        plt.text(\n                j, i, f\"{cm[i, j]:.2f}\",\n                horizontalalignment=\"center\",\n                color=\"white\" if cm[i, j] > thresh else \"black\")\n\n    plt.tight_layout()\n    plt.ylabel('True label')\n    plt.xlabel('Predicted label')\n    if filepath:\n        plt.savefig(filepath)\n    else:\n        plt.show()\n    plt.close()\n\n\n# https:\/\/stackoverflow.com\/questions\/18195758\/set-matplotlib-colorbar-size-to-match-graph  # NOQA\ndef add_colorbar(im, aspect=20, pad_fraction=0.5, **kwargs):\n    \"\"\"Add a vertical color bar to an image plot.\"\"\"\n    from mpl_toolkits import axes_grid1\n    divider = axes_grid1.make_axes_locatable(im.axes)\n    width = axes_grid1.axes_size.AxesY(im.axes, aspect=1.\/aspect)\n    pad = axes_grid1.axes_size.Fraction(pad_fraction, width)\n    current_ax = plt.gca()\n    cax = divider.append_axes(\"right\", size=width, pad=pad)\n    plt.sca(current_ax)\n    return im.axes.figure.colorbar(im, cax=cax, **kwargs)\n\n\ndef simple_imshow(\n        matrix,\n        cmap=\"viridis\", figsize=(10, 10), aspect_equal=True, outfile=None,\n        title=None, xlabel=None, ylabel=None,\n        xticks=True,\n        yticks=True,\n        xtick_labels=None,\n        ytick_labels=None,\n        xtick_locs_labels=None,\n        ytick_locs_labels=None,\n        xtick_label_rotation='vertical',\n        xgrid=None,\n        ygrid=None,\n        colorbar=True, scale=\"lin\", cbar_title=None,\n        bad_color=None,\n        origin='upper'):\n    if aspect_equal and figsize[1] is None:\n        matrix_aspect = matrix.shape[0] \/ matrix.shape[1]\n        width = figsize[0]\n        height = max(3, width * matrix_aspect)\n        figsize = (width, height)\n    fig = plt.figure(figsize=figsize)\n    ax = fig.add_subplot(1, 1, 1)\n    if aspect_equal:\n        ax.set_aspect('equal')\n    if title:\n        plt.title(title)\n    if xlabel:\n        ax.set_xlabel(xlabel)\n    if ylabel:\n        ax.set_ylabel(ylabel)\n    norm = matplotlib.colors.SymLogNorm(1) if scale == \"log\" else None\n    cmap = mpl.cm.get_cmap(cmap)\n    if bad_color is not None:\n        cmap.set_bad(bad_color)\n    im = plt.imshow(\n        matrix, interpolation='nearest', cmap=cmap, norm=norm, origin=origin)\n    if xtick_labels is not None:\n        assert xtick_locs_labels is None\n        locs = np.arange(0, len(xtick_labels))\n        xtick_locs_labels = locs, xtick_labels\n    if ytick_labels is not None:\n        assert ytick_locs_labels is None\n        locs = np.arange(0, len(ytick_labels))\n        ytick_locs_labels = locs, ytick_labels\n    if xtick_locs_labels is not None:\n        plt.xticks(*xtick_locs_labels, rotation=xtick_label_rotation)\n    if ytick_locs_labels is not None:\n        plt.yticks(*ytick_locs_labels)\n    if xgrid is not None or ygrid is not None:\n        if xgrid is not None:\n            ax.set_xticks(xgrid, minor=True)\n        if ygrid is not None:\n            ax.set_yticks(ygrid, minor=True)\n        ax.grid(which=\"minor\")\n    if xticks is not True:\n        plt.tick_params(\n            axis='x',          # changes apply to the x-axis\n            which='both',      # both major and minor ticks are affected\n            bottom=False,      # ticks along the bottom edge are off\n            top=False,)         # ticks along the top edge are off\n    if yticks is not True:\n        plt.tick_params(\n            axis='y',          # changes apply to the y-axis\n            which='both',      # both major and minor ticks are affected\n            left=False,      # ticks along the bottom edge are off\n            right=False,)         # ticks along the top edge are off\n    if colorbar:\n        cbar = add_colorbar(im)\n        if cbar_title:\n            cbar.ax.set_ylabel(cbar_title, rotation=270)\n    plt.tight_layout()\n    if outfile:\n        plt.savefig(outfile)\n    else:\n        plt.show()\n    plt.clf()\n\n\ndef embed_2d(\n        emb, emb_method=\"UMAP\", umap_n_neighbors=15, umap_min_dist=0.1,\n        return_proj=False):\n    if hasattr(emb_method, 'fit_transform'):\n        proj = emb_method\n    elif emb_method.lower() == \"umap\":\n        try:\n            from umap import UMAP\n        except ImportError:\n            print(\"Please install umap to use emb_method='UMAP'\")\n            print(\"pip install umap-learn (NOT pip install umap)\")\n            print(\"https:\/\/github.com\/lmcinnes\/umap\")\n            raise\n        proj = UMAP(\n            init=\"random\",\n            n_neighbors=umap_n_neighbors,\n            min_dist=umap_min_dist)\n    else:\n        import sklearn.manifold\n        proj = getattr(sklearn.manifold, emb_method)()\n    emb_2d = proj.fit_transform(emb)\n    if return_proj:\n        return emb_2d, proj\n    return emb_2d\n\n\ndef plot_embeddings(\n        emb, emb_method=None,\n        labels=None, color=None, classes=None, class2color=None, title=None,\n        outfile=None, cmap=\"viridis\", max_labels=100,\n        colorbar_ticks=None, reverse_colorbar=False, colorbar_label=None,\n        label_fontpath=None,\n        **scatter_kwargs):\n    \"\"\"\n    Plot a scatterplot of the embeddings contained in emb.\n\n    emb: an array with dim (n_embeddings x 2) or (n_embeddings x emb_dim).\n    In the latter case an embedding method emb_method should be supplied\n    to project from emb_dim to dim=2.\n\n    emb_method: \"UMAP\", \"TSNE\", or any other algorithm in sklearn.manifold\n    labels: Optional text labels for each embedding\n    color: Optional color for each embedding, according to which it will be\n    colored in the plot.\n    classes:  Optional class for each embedding, according to which it will\n    be colored in the plot.\n    class2color: A map which determines the color assigned to each class\n    outfile: If provided, save plot to this file instead of showing it\n    cmap: colormap\n    max_labels: maximum number of labels to be displayed\n    \"\"\"\n    from matplotlib.ticker import NullFormatter\n    if emb_method:\n        x, y = embed_2d(emb, emb_method).T\n    else:\n        x, y = emb.T\n    figsize = (14, 12) if color is not None else (12, 12)\n    fig = plt.figure(figsize=figsize)\n    ax = fig.add_subplot(111)\n    ax.set_aspect('equal')\n    ax.xaxis.set_major_formatter(NullFormatter())\n    ax.yaxis.set_major_formatter(NullFormatter())\n    if not scatter_kwargs:\n        scatter_kwargs = dict(marker=\"o\", s=1, alpha=1)\n    if classes is not None:\n        for cls in set(classes):\n            i = (classes == cls).nonzero()\n            ax.scatter(x[i], y[i], label=cls, **scatter_kwargs)\n    elif color is not None:\n        sc = ax.scatter(x, y, c=color, cmap=cmap, **scatter_kwargs)\n        cb = fig.colorbar(sc, ticks=colorbar_ticks)\n        if reverse_colorbar:\n            cb.ax.invert_yaxis()\n        if colorbar_label:\n            cb.set_label(colorbar_label)\n    else:\n        ax.scatter(x, y, **scatter_kwargs)\n\n    if labels is not None:\n        if label_fontpath:\n            import matplotlib.font_manager as fm\n            fontproperties = fm.FontProperties(fname=label_fontpath)\n        else:\n            fontproperties = None\n        n_labels = len(labels)\n        for i in range(len(emb)):\n            if (\n                    max_labels < 0 or\n                    n_labels <= max_labels or\n                    not i % (n_labels \/\/ max_labels)):\n                ax.annotate(\n                    labels[i], (x[i], y[i]), alpha=0.76, size=10,\n                    fontproperties=fontproperties)\n    if title:\n        plt.title(title)\n    plt.axis('tight')\n    if classes is not None:\n        plt.legend(loc='best', scatterpoints=1, markerscale=5, fontsize=10)\n    plt.tight_layout()\n    if outfile:\n        plt.savefig(str(outfile))\n    else:\n        plt.show()\n\n\ndef plot_dendrogram(\n        dist,\n        labels,\n        outfile=None,\n        method=\"centroid\",\n        figsize=(50, 45),\n        font_size=10,\n        cmap='magma_r',\n        ):\n    from scipy.cluster import hierarchy\n    fig = plt.figure(figsize=figsize)\n    # dendrogram\n    axdendro = fig.add_axes([0.09, 0.1, 0.2, 0.8])\n    axdendro.set_xticks([])\n    axdendro.set_yticks([])\n    Y = hierarchy.linkage(dist, method=method)\n    Z = hierarchy.dendrogram(\n        Y, orientation='right', labels=labels, leaf_font_size=font_size)\n    # distance matrix\n    index = Z['leaves']\n    D = dist[index, :]\n    D = D[:, index]\n    axmatrix = fig.add_axes([0.3, 0.1, 0.6, 0.8])\n    im = axmatrix.matshow(D, aspect='auto', origin='lower', cmap=cmap)\n    axmatrix.set_xticks([])\n    axmatrix.set_yticks([])\n    # colorbar\n    axcolor = fig.add_axes([0.91, 0.1, 0.02, 0.8])\n    plt.colorbar(im, cax=axcolor)\n\n    if outfile:\n        fig.savefig(str(outfile))\n    else:\n        fig.show()\n    plt.close(fig)\n\n\ndef get_palette(categories, cmap=None):\n    from bokeh.palettes import (\n        Category20,\n        Category20b,\n        Category20c,\n        viridis,\n        )\n    n_cat = len(set(categories))\n    if cmap is not None:\n        return cmap[n_cat]\n    if n_cat <= 20:\n        if n_cat <= 2:\n            palette = Category20[3]\n            return [palette[0], palette[-1]]\n        else:\n            return Category20[n_cat]\n    if n_cat <= 40:\n        return Category20[20] + Category20b[20]\n    if n_cat <= 60:\n        return Category20[20] + Category20b[20] + Category20c[20]\n    return viridis(n_cat)\n\n\ndef plot_embeddings_bokeh(\n        emb,\n        emb_method='UMAP',\n        classes=None,\n        class_category=None,\n        labels=None,\n        color=None,\n        raw_colors=None,\n        color_category=None,\n        color_categorical=False,\n        cmap=None,\n        cmap_reverse=False,\n        colorbar=False,\n        colorbar_ticks=None,\n        outfile=None,\n        title=None,\n        scatter_labels=False,\n        tooltip_fields=None,\n        figure_kwargs=None,\n        write_png=False,\n        return_plot=False,\n        plot_width=None,\n        plot_height=None,\n        reuse_figure=None,\n        **circle_kwargs,\n        ):\n    \"\"\"\n    Creates an interactive scatterplot of the embeddings contained in emb,\n    using the bokeh library.\n\n    emb: an array with dim (n_embeddings x 2) or (n_embeddings x emb_dim).\n    In the latter case an embedding method emb_method should be supplied\n    to project from emb_dim to dim=2.\n\n    emb_method: \"UMAP\", \"TSNE\", or any other algorithm in sklearn.manifold\n    labels: Optional text labels for each embedding\n    color: Optional color for each embedding, according to which it will be\n    colored in the plot.\n    classes:  Optional class for each embedding, according to which it will\n    be colored in the plot.\n    outfile: If provided, save plot to this file instead of showing it\n    cmap: colormap\n    title: optional title of the plot\n    \"\"\"\n    from bokeh.plotting import figure, output_file, show, save\n    from bokeh.models import (\n        ColumnDataSource, CategoricalColorMapper, LinearColorMapper,\n        ColorBar, FixedTicker, Text)\n    from bokeh.palettes import Viridis256\n\n    if emb_method:\n        emb = embed_2d(emb, emb_method)\n    else:\n        assert emb.shape[1] == 2\n\n    if outfile:\n        output_file(outfile)\n\n    if cmap is not None:\n        if isinstance(cmap, str):\n            import bokeh.palettes\n            # matplotib suffix for reverse color maps\n            if cmap.endswith(\"_r\"):\n                cmap_reverse = True\n                cmap = cmap[:-2]\n            cmap = getattr(bokeh.palettes, cmap)\n        elif isinstance(cmap, dict):\n            cmap = cmap[max(cmap.keys())]\n        if cmap_reverse:\n            if isinstance(cmap, dict):\n                new_cmap = {}\n                for k, v in cmap.items():\n                    v = list(v)\n                    v.reverse()\n                    new_cmap[k] = v\n                cmap = new_cmap\n            else:\n                cmap = list(cmap)\n                cmap.reverse()\n\n    source_dict = dict(x=emb[:, 0], y=emb[:, 1])\n    if labels is not None:\n        source_dict[\"label\"] = labels\n\n    if raw_colors is not None:\n        assert color is None\n        if any(isinstance(c, str) for c in raw_colors):\n            assert all(isinstance(c, str) for c in raw_colors)\n        else:\n            assert all(len(c) == 3 for c in raw_colors)\n            assert cmap is None\n            from bokeh.colors import RGB\n            raw_colors = [RGB(*c) for c in raw_colors]\n        source_dict[\"color\"] = raw_colors\n        color_conf = {\"field\": \"color\"}\n    elif color is not None:\n        if any(isinstance(c, str) for c in color):\n            assert all(isinstance(c, str) for c in color)\n            palette = get_palette(color, cmap=cmap)\n            color_mapper = CategoricalColorMapper(\n                    factors=sorted(set(color)),\n                    palette=palette)\n        else:\n            if cmap is None:\n                cmap = Viridis256\n            elif isinstance(cmap, dict):\n                cmap = cmap[max(cmap.keys())]\n            color_mapper = LinearColorMapper(cmap)\n        color_conf = {\n            \"field\": \"color\",\n            \"transform\": color_mapper}\n        source_dict[\"color\"] = color\n    else:\n        color_conf = \"red\"\n\n    if classes is not None:\n        source_dict[\"class\"] = classes\n    if tooltip_fields:\n        for k, v in tooltip_fields.items():\n            source_dict[k] = v\n    source = ColumnDataSource(source_dict)\n\n    tools = \"crosshair,pan,wheel_zoom,box_zoom,reset,hover\"\n    figure_kwargs = figure_kwargs or {}\n    if plot_width is not None:\n        figure_kwargs['plot_width'] = plot_width\n    if plot_height is not None:\n        figure_kwargs['plot_height'] = plot_height\n    if reuse_figure is None:\n        p = figure(tools=tools, sizing_mode='stretch_both', **figure_kwargs)\n    else:\n        p = reuse_figure\n    if title:\n        p.title.text = title\n\n    if colorbar:\n        if colorbar_ticks:\n            ticker = FixedTicker(ticks=colorbar_ticks)\n        else:\n            ticker = None\n        colorbar = ColorBar(\n            color_mapper=color_mapper, ticker=ticker)\n\n    if labels is not None and scatter_labels:\n        glyph = Text(\n            x=\"x\", y=\"y\", text=\"label\", angle=0.0,\n            text_color=color_conf, text_alpha=0.95, text_font_size=\"8pt\",\n            **circle_kwargs)\n        p.add_glyph(source, glyph)\n    else:\n        plot_kwargs = dict(\n                x='x', y='y',\n                source=source,\n                color=color_conf,\n                **circle_kwargs\n                )\n        if classes is not None:\n            legend_field = 'class'\n        elif color is not None and not raw_colors:\n            legend_field = 'color'\n        else:\n            legend_field = None\n        if legend_field:\n            plot_kwargs['legend_field'] = legend_field\n            # sort by color field to order the legend entries nicely\n            sorted_source = source.to_df().sort_values(legend_field)\n            plot_kwargs['source'] = source.from_df(sorted_source)\n\n        p.circle(**plot_kwargs)\n\n    if labels is not None:\n        from bokeh.models import HoverTool\n        from collections import OrderedDict\n        hover = p.select(dict(type=HoverTool))\n        hover_entries = [\n            (\"label\", \"@label{safe}\"),\n            (\"(x, y)\", \"(@x, @y)\"),\n            ]\n        if color is not None and color_category:\n            hover_entries.append((color_category, \"@color\"))\n        if classes is not None and class_category:\n            hover_entries.append((class_category, \"@class\"))\n        if tooltip_fields:\n            for field in tooltip_fields:\n                hover_entries.append((field, \"@\" + field))\n        hover.tooltips = OrderedDict(hover_entries)\n    if colorbar:\n        assert color is not None\n        p.add_layout(colorbar, 'right')\n    if return_plot:\n        return p\n    if outfile:\n        save(p)\n        if write_png:\n            from bokeh.io import export_png\n            png_file = outfile.with_suffix('.png')\n            export_png(p, filename=png_file)\n    else:\n        show(p)\n\n\nclass Figure():\n    \"\"\"Provides a context manager that automatically saves and closes\n    a matplotlib plot.\n\n    >>> with Figure(\"figure_name\"):\n    >>>     plt.plot(x, y)\n    >>> # saves plot to {Figure.fig_dir}\/{figure_name}.{Figure.file_type}\n\n    When creating many figures with the same settings, e.g. plt.xlim(0, 100)\n    and plt.ylim(0, 1.0), defaults can be set with:\n\n    >>> Figure.set_defaults(xlim=(0, 100), ylim=(0, 1.0))\n    >>> # context manager will call plt.xlim(0, 100) and plt.ylim(0, 1.0)\n    \"\"\"\n    fig_dir = Path(\"out\/fig\")\n    file_types = [\"png\", \"pdf\"]\n    default_plt_calls = {}\n    late_calls = [\"xscale\", \"xlim\", \"yscale\", \"ylim\"]  # order is important\n\n    def __init__(\n            self, name,\n            figwidth=6, figheight=None, fontsize=12,\n            invert_xaxis=False, invert_yaxis=False,\n            **kwargs):\n        self.fig = plt.figure()\n        self.fig.set_figwidth(figwidth)\n        phi = 1.6180\n        self.fig.set_figheight(figheight or figwidth \/ phi)\n        # params = {\n        #     'figure.figsize': (figwidth, figheight or figwidth \/ phi),\n        #     'axes.labelsize': fontsize,\n        #     'axes.titlesize': fontsize,\n        #     'legend.fontsize': fontsize,\n        #     'xtick.labelsize': fontsize - 1,\n        #     'ytick.labelsize': fontsize - 1,\n        # }\n        # mpl.rcParams.update(params)\n        self.name = name\n        self.plt_calls = {**kwargs}\n        self.invert_xaxis = invert_xaxis\n        self.invert_yaxis = invert_yaxis\n        for attr, val in self.default_plt_calls.items():\n            if attr not in self.plt_calls:\n                self.plt_calls[attr] = val\n\n    def __enter__(self):\n        for attr, val in self.plt_calls.items():\n            # if attr in self.late_calls:\n            #     continue\n            try:\n                getattr(plt, attr)(val)\n            except:\n                getattr(plt, attr)(*val)\n\n        return self.fig\n\n    def __exit__(self, exc_type, exc_val, exc_tb):\n        # for attr in self.late_calls:\n        #     if attr in self.plt_calls:\n        #         print(attr, self.plt_calls[attr])\n        #         getattr(plt, attr)(self.plt_calls[attr])\n        if self.invert_xaxis:\n            plt.gca().invert_xaxis()\n        if self.invert_yaxis:\n            plt.gca().invert_yaxis()\n        plt.tight_layout()\n        for file_type in self.file_types:\n            outfile = self.fig_dir \/ f\"{self.name}.{file_type}\"\n            plt.savefig(outfile)\n        plt.clf()\n\n    @classmethod\n    def set_defaults(cls, **kwargs):\n        cls.default_plt_calls = kwargs\n        for attr, val in kwargs.items():\n            setattr(cls, attr, val)\n\n    @classmethod\n    def reset_defaults(cls):\n        cls.default_plt_calls = {}\n\n\nlinestyles = [\n    \"-\", \"--\", \"-.\", \":\",\n    \"-\", \"--\", \"-.\", \":\",\n    \"-\", \"--\", \"-.\", \":\",\n    \"-\", \"--\", \"-.\", \":\",\n    \"-\", \"--\", \"-.\", \":\",\n    \"-\", \"--\", \"-.\", \":\"]\n\ntry:\n    from bokeh.palettes import Category20\n    colors = Category20[20]\nexcept ImportError:\n    try:\n        import seaborn as sns\n        colors = sns.color_palette(\"muted\")\n    except ImportError:\n        # https:\/\/gist.github.com\/huyng\/816622\n        colors = [\n            \"348ABD\", \"7A68A6\", \"A60628\",\n            \"467821\", \"CF4457\", \"188487\", \"E24A33\",\n            \"348ABD\", \"7A68A6\", \"A60628\",\n            \"467821\", \"CF4457\", \"188487\", \"E24A33\",\n            \"348ABD\", \"7A68A6\", \"A60628\",\n            \"467821\", \"CF4457\", \"188487\", \"E24A33\",\n            ]\n\n# https:\/\/matplotlib.org\/api\/markers_api.html\nmarkers = [\n    \".\",   # point\n    \",\",   # pixel\n    \"o\",   # circle\n    \"v\",   # triangle_down\n    \"^\",   # triangle_up\n    \"<\",   # triangle_left\n    \">\",   # triangle_right\n    \"1\",   # tri_down\n    \"2\",   # tri_up\n    \"3\",   # tri_left\n    \"4\",   # tri_right\n    \"8\",   # octagon\n    \"s\",   # square\n    \"p\",   # pentagon\n    \"P\",   # plus (filled)\n    \"*\",   # star\n    \"h\",   # hexagon1\n    \"H\",   # hexagon2\n    \"+\",   # plus\n    \"x\",   # x\n    \"X\",   # x (filled)\n    \"D\",   # diamond\n    \"d\",   # thin_diamond\n    \"|\",   # vline\n    \"_\",   # hline\n    ]\n\n\nif __name__ == \"__main__\":\n    plot_attention(\n        \"1 2 3 4\".split(),\n        \"a b c d\".split(),\n        np.random.rand(4, 4),\n        out_colors=\"r g b r\".split())\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_357","text":"# encoding: utf-8\n\n\n__author__ = '<NAME> <<EMAIL>>'\n__date__ = '06\/2012'\n\n\n\"\"\"Module to convert frame representation as output by kinect recording\nto angle and\/or angle velocity histogram representations.\n\"\"\"\n\n\nimport numpy as np\nfrom scipy.cluster.vq import kmeans, whiten\n\nfrom ..lib.transformations import (quaternion_multiply, quaternion_inverse,\n                                   euler_from_quaternion)\nfrom ..lib.utils import delayed_velocities, meta_map\nfrom ..lib.vector_quantization import get_histos\nfrom ..lib.kde2d import gaussian_kde_2d\n\n# Note: frame names from ros kinect seems to denote left \/ right from\n#   the observer point of view.\n\n\nANGLES = [\n        ('left_shoulder', 'left_elbow'),\n        ('left_elbow', 'left_hand'),\n        ('torso', 'left_hip'),\n        ('left_hip', 'left_knee'),\n        ('left_knee', 'left_foot'),\n        ('right_shoulder', 'right_elbow'),\n        ('right_elbow', 'right_hand'),\n        ('torso', 'right_hip'),\n        ('right_hip', 'right_knee'),\n        ('right_knee', 'right_foot'),\n        ]\n\n\ndef angles_indices(marker_names):\n    return [(marker_names.index(source), marker_names.index(dest))\n            for source, dest in ANGLES]\n\n\ndef get_angles(sample, source_frame, dest_frame):\n    \"\"\"Compute rotation along three basis axis between two frames\n    in the given sample.\n\n    :param sample: array of translations and rotations (shape: (nb_frames, 7)\n    :param source_frame, dest_frame: indices of source and dest frames\n    \"\"\"\n    # All transformations are from the base frame, to get transformation from\n    # one frame to the other, the first one needs to be inversed.\n    # q = q1^{-1} * q2\n    q = quaternion_multiply(quaternion_inverse(sample[source_frame, 3:]),\n            sample[dest_frame, 3:])\n    return euler_from_quaternion(q)\n\n\ndef get_angle_array(sample, angles_idx):\n    angles = [get_angles(sample, s, d) for s, d in angles_idx]\n    return np.hstack(angles)\n\n\ndef record_to_angle_array(record, angles_idx):\n    return np.vstack([get_angle_array(sample, angles_idx)\n        for sample in record])\n\n\ndef db_to_list_of_angle_arrays(db):\n    angle_idx = angles_indices(db.marker_names)\n    return [record_to_angle_array(r[0], angle_idx) for r in db.records]\n\n\ndef db_to_angles_and_vels(db, vel_delay=1, vel_padding='zeros'):\n    angles = db_to_list_of_angle_arrays(db)\n    vels = [delayed_velocities(vel_delay, angle, padding=vel_padding)\n            for angle in angles]\n    return angles, vels\n\n\ndef get_bounds(vels):\n    min_vel = np.min(np.vstack(vels))\n    max_vel = np.max(np.vstack(vels))\n    return min_vel, max_vel\n\n\ndef filter_values(data, bounds):\n    \"\"\"Filter big values in data, according to given bounds.\n    :param data: numpy array\n    :param bounds: (min, max)\n    \"\"\"\n    cut = lambda x: np.maximum(np.minimum(x, bounds[1]), bounds[0])\n    return map(cut, data)\n\n\ndef db_to_binned_hist_matrix(db, vel_delay=1, vel_padding='zeros',\n        nb_bins=16, bounds=None, vel_bounds=None, rel_h=.3, fft=True):\n    \"\"\"Compute the histogram matrix from the database, using binned histograms\n    smoothed by a Gaussian kernel.\n\n    :param db:\n        the Database\n\n    :param vel_delay, vel_padding:\n        delayed velocity parameters\n\n    :param nb_bins: int,\n        number of bins (output dimension of histograms for a joint)\n\n    :param bounds, vel_bounds: (min, max), couples of floats\n        bounds on angle and velocities, if given, data\n        is cut to fit in bounds, else they are computed from data.\n\n    :param rel_h: float,\n        relative width of the Gaussian smoother\n\n    :param fft: bool,\n        whether to use fft convolution (default)\n\n    :return: (nb ex, nb features) matrix\n    \"\"\"\n    angles, vels = db_to_angles_and_vels(db, vel_delay=1, vel_padding='zeros')\n    # Angle bounds\n    if bounds is None:\n        bounds = get_bounds(angles)\n    else:\n        angles = filter_values(angles, bounds)\n    # Velocity bounds\n    if vel_bounds is None:\n        vel_bounds = get_bounds(vels)\n    else:\n        vels = filter_values(vels, vel_bounds)\n    # Histogram are specific to each angle and corresponding velocity\n    # Compute Gaussian width from relative width for angles\n    h = rel_h * (bounds[1] - bounds[0])\n    # Compute gaussian width for velocities\n    h_vel = rel_h * (vel_bounds[1] - vel_bounds[0])\n    # For fair comparison with 1D hist and VQ\n    nb_bins_sqrt = int(np.sqrt(nb_bins))\n    to_gaussKDEs2 = lambda x: [  # x = (angles, vels)\n            gaussian_kde_2d(\n                np.hstack([x[0][:, dim][:, np.newaxis],\n                    x[1][:, dim][:, np.newaxis]]),\n                h, h_vel, nb_bins=nb_bins_sqrt,\n                bounds=(np.array([bounds[0], vel_bounds[0]]),\n                    np.array([bounds[1], vel_bounds[1]])),\n                fft=fft)\n            for dim in range(x[0].shape[1])]\n    kdes = map(to_gaussKDEs2, zip(angles, vels))\n    # Each kde is a triplet (x_grid, y_grid, bins)\n    # Get and flatten histograms (second element of the couple)\n    hist = meta_map(2, lambda  x: x[2].flatten())(kdes)\n    data_matrix = np.vstack(map(np.hstack, hist))\n    return data_matrix\n\n\ndef compact_examples(x):\n    \"\"\"Vertically stack list of array and returns stacked\n    array and indices to un_compact it.\n    \"\"\"\n    idx = [y.shape[0] for y in x]\n    return np.vstack(x), list(np.cumsum(idx))\n\n\ndef un_compact_examples(v, idx):\n    return [v[i:j, :]\n            for i, j in zip([0] + idx[:-1], idx)]\n\n\ndef db_to_VQ_hist_matrix(db, vel_delay=1, vel_padding='zeros',\n        nb_bins=16, bounds=None, vel_bounds=None, soft_vq=None):\n    \"\"\"Compute the histogram matrix from the database, using binned histograms\n    smoothed by a Gaussian kernel.\n\n    :param db:\n        the Database\n\n    :param vel_delay, vel_padding:\n        delayed velocity parameters\n\n    :param nb_bins: int,\n        number of bins (output dimension of histograms for a joint)\n\n    :param bounds, vel_bounds: (min, max), couples of floats\n        bounds on angle and velocities, if given, data\n        is cut to fit in bounds\n\n    :param soft_vq:\n        if not None (default) soft vector quantization parameter.\n    \"\"\"\n    angles, vels = db_to_angles_and_vels(db, vel_delay=1, vel_padding='zeros')\n    # Angle bounds\n    if bounds is not None:\n        angles = filter_values(angles, bounds)\n    # Velocity bounds\n    if vel_bounds is not None:\n        vels = filter_values(vels, vel_bounds)\n    # For each DOF and each example compute 2D angle-vel vects\n    # angles \/ vels => [(time, dof) for each example]\n    nb_dofs = angles[0].shape[1]\n    nb_ex = len(angles)\n    data = [[np.hstack([a[:, dof][:, np.newaxis],\n                        v[:, dof][:, np.newaxis]])\n             for a, v in zip(angles, vels)]\n            for dof in range(nb_dofs)]\n    compacted = map(compact_examples, data)\n    # Whiten data for each dof\n    all_data = [whiten(d) for d, _ in compacted]\n\n    # Compute centroids for each DOF\n    centro = [kmeans(d, nb_bins, iter=20)[0] for d in all_data]\n    # Compute hitograms for each sample\n    histos = [get_histos(d, c, soft=soft_vq)\n              for d, c in zip(all_data, centro)]\n    # Group and sum by example\n    histos_by_ex = [un_compact_examples(h, c[1])\n                    for h, c in zip(histos, compacted)]\n    ex_histos = np.array([[h.sum(axis=0) for h in hs] for hs in histos_by_ex])\n    # ex_histo is now (nb_dofs, nb_ex, nb_bins)\n    Xdata = np.swapaxes(ex_histos, 0, 1).reshape((nb_ex, nb_bins * nb_dofs))\n    Xdata \/= Xdata.sum(axis=1)[:, np.newaxis]\n    return Xdata\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_358","text":"import os\nimport argparse\nimport numpy as np\nimport paddle.fluid as fluid\nfrom scipy import sparse\nimport pdb\n\nfrom utils import *\nfrom layer import vmat, qe\n\n\nparser = argparse.ArgumentParser(description='GNN_Reranking')\nparser.add_argument('--data_path', \n                    type=str, \n                    default='..\/features\/market_88_test.pkl',\n                    help='path to dataset')\nparser.add_argument('--k1', \n                    type=int, \n                    default=26,     # Market-1501\n                    # default=60,   # Veri-776\n                    help='parameter k1')\nparser.add_argument('--k2', \n                    type=int, \n                    default=7,      # Market-1501\n                    # default=10,   # Veri-776\n                    help='parameter k2')\n\nargs = parser.parse_args()\n\ndef main():   \n    data = load_pickle(args.data_path)\n    k1 = args.k1\n    k2 = args.k2\n    \n    query_cam = data['query_cam']\n    query_label = data['query_label']\n    gallery_cam = data['gallery_cam']\n    gallery_label = data['gallery_label']\n          \n    gallery_feature = data['gallery_f']\n    query_feature = data['query_f']\n    total_features = np.concatenate((query_feature,gallery_feature),axis=0)\n    query_num = query_feature.shape[0]\n\n    X_u = fluid.layers.data(name=\"all_fea\",shape=[total_features.shape[0], total_features.shape[1]],dtype='float32')\n    original_score = fluid.layers.matmul(X_u, X_u, transpose_x=False, transpose_y=True)\n\n    _, initial_rank_k1 = fluid.layers.topk(original_score, k=k1)\n    S, initial_rank_k2 = fluid.layers.topk(original_score, k=k2)\n\n    initial_rank_k1_fp32 = fluid.layers.cast(initial_rank_k1, dtype='float32')\n    initial_rank_k2_fp32 = fluid.layers.cast(initial_rank_k2, dtype='float32')\n\n    # stage 1\n    A = vmat(initial_rank_k1_fp32)\n    S = S * S\n\n    # stage 2\n    if k2 != 1:      \n        for i in range(2):\n            AT = fluid.layers.transpose(A, perm=[1,0])\n            A = A + AT\n            A = qe(A, initial_rank_k2_fp32, S)\n            A_norm = fluid.layers.sqrt(fluid.layers.reduce_sum(fluid.layers.square(A), dim=1))\n            A = fluid.layers.elementwise_div(A, A_norm, axis=0)\n\n    score = fluid.layers.matmul(A, A, transpose_x=False, transpose_y=True)\n\n    use_cuda = True\n    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() \n    exe = fluid.Executor(place) \n\n    exe.run(fluid.default_startup_program()) \n\n    outs = exe.run(\n        feed={'all_fea':total_features},\n        fetch_list=[score])\n\n    cosine_similarity = np.array(outs[0])\n    indices = np.argsort(-cosine_similarity[:query_num, query_num:], axis=1)\n    indices = indices.reshape(query_feature.shape[0], gallery_feature.shape[0])\n    evaluate_ranking_list(indices, query_label, query_cam, gallery_label, gallery_cam)\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_359","text":"<reponame>lanl\/pyDRESCALk\n#@author:  <NAME>,<NAME>\nfrom scipy.stats import wilcoxon\nfrom . import config\nfrom .dist_clustering import *\nfrom .pyDRESCAL import *\nfrom .plot_results import *\n\nclass sample():\n    \"\"\"\n    Generates perturbed version of data based on sampling distribution.\n\n    Args:\n        data (ndarray, sparse matrix): Array of which to find a perturbation.\n        noise_var (float): The perturbation amount.\n        method (str) : Method for sampling (uniform\/poisson)\n        seed (float),optional : Set seed for random data generation\n    \"\"\"\n\n\n    @comm_timing()\n    def __init__(self, data, noise_var, method, params,seed=None):\n        self.np = params.np\n        self.X = data\n        self.noise_var = noise_var\n        self.seed = seed\n        if self.seed != None:\n            self.np.random.seed(self.seed)\n        self.method = method\n        self.X_per = 0\n\n    @comm_timing()\n    def randM(self):\n        \"\"\"\n        Multiplies each element of X by a uniform random number in (1-epsilon, 1+epsilon).\n        \"\"\"\n\n        M = 2 * self.noise_var * self.np.random.random_sample(self.X.shape).astype(self.X.dtype) + self.noise_var\n        M = M + 1\n        self.X_per = self.np.multiply(self.X, M)\n\n    @comm_timing()\n    def poisson(self):\n        \"\"\"Resamples each element of a matrix from a Poisson distribution with the mean set by that element. Y_{i,j} = Poisson(X_{i,j}\"\"\"\n\n        self.X_per = self.np.random.poisson(self.X).astype(self.X.dtype)\n\n    @comm_timing()\n    def fit(self):\n        r\"\"\"\n        Calls the sub routines to perform resampling on data\n\n        Returns\n        -------\n        X_per : ndarry\n           Perturbed version of data\n        \"\"\"\n\n        if self.method == 'uniform':\n            self.randM()\n        elif self.method == 'poisson':\n            self.poisson()\n        return self.X_per\n\n\nclass pyDRESCALk():\n    r\"\"\"\n    Performs the distributed RESCAL decomposition with custom clustering for estimating hidden factors k\n\n    Parameters:\n        A_ij (ndarray) : Distributed Data\n        factors (tuple), optional : Distributed factors W and H\n        params (class): Class which comprises following attributes\n        params.init (str) : RESCAL initialization(rand\/nnsvd)\n        params.comm1 (object): Global Communicator\n        params.comm (object): Modified communicator object\n        params.k (int) : Rank for decomposition\n        params.m (int) : Global dimensions m\n        params.n (int) : Global dimensions n\n        params.p_r  (int): Cartesian grid row count\n        params.p_c  (int): Cartesian grid column count\n        params.row_comm (object) : Sub communicator along row\n        params.col_comm (object) : Sub communicator along columns\n        params.A_update (bool) : flag to set W update True\/False\n        params.norm (str): RESCAL norm to be minimized\n        params.method(str): RESCAL optimization method\n        params.eps (float) : Epsilon value\n        params.verbose (bool) : Flag to enable\/disable display results\n        params.save_factors (bool) : Flag to enable\/disable saving computed factors\n        params.perturbations (int) : Number of Perturbations for clustering\n        params.noise_var (float) : Set noise variance for perturbing the data\n        params.sill_thr (float) : Set the sillhouette threshold for estimating K with p-test\n        params.start_k (int) : Starting range for Feature search K\n        params.end_k (int) : Ending range for Feature search K\"\"\"\n\n    @comm_timing()\n    def __init__(self, X_ijk, factors=None, params=None):\n        self.X_ijk = X_ijk\n        self.local_m, self.local_n, self.local_n = len(self.X_ijk),self.X_ijk[0].shape[0],self.X_ijk[0].shape[1]\n        self.params = params\n        self.np = self.params.np\n        self.comm1 = self.params.comm1\n        self.rank = self.comm1.rank\n        self.p_r, self.p_c = self.params.p_r, self.params.p_c\n        self.fpath = self.params.fpath\n        self.fname = self.params.fname\n        #self.fname = \"Testrescalk\"\n        self.p = self.p_r * self.p_c\n        if self.p_r != 1 and self.p_c != 1:\n            self.topo = '2d'\n        else:\n            self.topo = '1d'\n        self.sampling = var_init(self.params,'sampling',default='uniform')\n        self.perturbations = var_init(self.params,'perturbations',default=10)\n        self.noise_var = var_init(self.params,'noise_var',default=.03)\n        self.Rall = 0\n        self.Aall = 0\n        self.recon_err = 0\n        self.AvgR = 0\n        self.AvgG = 0\n        self.col_err = 0\n        self.clusterSilhouetteCoefficients, self.avgSilhouetteCoefficients = 0, 0\n        self.L_errDist = 0\n        self.avgErr = 0\n        self.start_k = self.params.start_k  # ['start_k']\n        self.end_k = self.params.end_k  # ['end_k']\n        self.step_k = var_init(self.params,'step_k',default=1)\n        self.verbose = var_init(params,'verbose',default=True)\n\n\n    @comm_timing()\n    def fit(self):\n        r\"\"\"\n        Calls the sub routines to perform distributed RESCAL decomposition and then custom clustering to estimate k\n\n        Returns\n        -------\n        nopt : int\n           Estimated value of latent features\n        \"\"\"\n        SILL_MIN = []\n        SILL_AVG = []\n        errRegres = []\n        errRegresTol = []\n        RECON = []\n        RECON1 = []\n        self.params.results_paths = self.params.results_path +self.params.fname + '\/'\n        if self.rank == 0:\n            try: os.makedirs(self.params.results_paths)\n            except: pass\n        for self.k in range(self.start_k, self.end_k + 1,self.step_k):\n            self.params.k = self.k\n            self.pyrescalk_per_k()\n            SILL_MIN.append(self.np.around(self.np.min(self.clusterSilhouetteCoefficients), 2))\n            SILL_AVG.append(self.np.around(self.np.mean(self.clusterSilhouetteCoefficients), 2))\n            errRegres.append([self.col_err])\n            errRegresTol.append([self.recon_err])\n            RECON.append(self.L_errDist)\n            RECON1.append(self.avgErr)\n        if self.rank==0:\n            plot_results_paper(self.start_k, self.end_k,self.step_k, RECON, SILL_AVG, SILL_MIN, self.params.results_path, self.fname)\n\n\n    @comm_timing()\n    def pyrescalk_per_k(self):\n        \"\"\"Performs RESCAL decomposition and clustering for each k to estimate silhouette statistics\"\"\"\n        self.params.results_paths = self.params.results_path+ str(self.k) + '\/'\n        if self.rank == 0:\n            try: os.makedirs(self.params.results_paths)\n            except: pass\n        results = []\n        if self.rank == 0: print('*************Computing for k=', self.k, '************')\n        for i in range(self.perturbations):\n            if self.rank == 0: print('Current perturbation =', i)\n            self.params.perturbation = i\n            data = sample(data=self.X_ijk, noise_var=self.noise_var, method=self.sampling,params=self.params, seed=self.rank*1000+i*100).fit()\n            self.params.A_update = True\n            results.append(pyDRESCAL(data, factors=None, params=self.params).fit())\n        self.Aall = self.np.stack([results[i][0] for i in range(self.perturbations)],axis=-1)\n        #self.Aall = self.Aall.reshape(self.Aall.shape[0], self.k, self.perturbations, order='F')      #n x k x perturbations\n        self.Rall = self.np.stack([results[i][2] for i in range(self.perturbations)],axis=-1)\n        #self.Rall = self.Rall.reshape(results[0][2].shape[0], self.k, self.Rall.shape[1], self.perturbations)    #m x k x k x perturbations\n        self.recon_err = [results[i][3] for i in range(self.perturbations)]\n        [processAvg, processSTD, self.Rall, self.clusterSilhouetteCoefficients, self.avgSilhouetteCoefficients,\n                idx] = custom_clustering(self.Aall, self.Rall, self.params).fit()\n        self.AvgR = self.np.median(self.Rall, axis=-1)\n        self.AvgA = processAvg\n        self.params.A_update = False\n        regressH = pyDRESCAL(self.X_ijk, factors=[self.AvgA, self.AvgR], params=self.params)\n        self.AvgA, self.AvgA_j, self.AvgR, self.L_errDist = regressH.fit()\n        self.avgErr = np.mean(self.recon_err)\n        cluster_stats = {'clusterSilhouetteCoefficients': self.clusterSilhouetteCoefficients,\n                         'avgSilhouetteCoefficients': self.avgSilhouetteCoefficients, \\\n                          'avgErr': self.avgErr, 'recon_err': self.recon_err,'L_errDist':self.L_errDist}\n        data_writer = data_write(self.params)\n        data_writer.save_factors([self.AvgA, self.AvgR], reg=True)\n        data_writer.save_cluster_results(cluster_stats)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_360","text":"<filename>bsuite\/bsuite\/models\/agent_bootdqn.py<gh_stars>1-10\nimport dm_env\nimport numpy as np\nimport torch\nimport torch.nn.functional as functional\nimport torch.optim as optim\nimport typing\nimport wandb\n\nfrom utils.memory import Experience, ReplayMemory, PrioritizedReplayMemory\nfrom models.qnet_MCdrop import Dqn, DuelDQN, TwoHeadDqn\n\nfrom scipy.optimize import minimize\nfrom collections import namedtuple, deque, Counter\n\n# from qnet import Dqn, DuelDQN\n\ndef get_iv_weights(variances):\n    '''\n    Returns Inverse Variance weights\n    Params\n    ======\n        variances (numpy array): variance of the targets\n    '''\n    weights = 1\/variances\n    (weights)\n    weights = weights\/np.sum(weights)\n    (weights)\n    return weights\n\ndef compute_eff_bs(weights):\n    # Compute original effective mini-batch size\n    eff_bs = 1\/np.sum(np.square(weights))\n    #print(eff_bs)\n    return eff_bs\n\ndef get_optimal_xi(variances, minimal_size, epsilon_start):\n    minimal_size = min(variances.shape[0] - 1, minimal_size)\n    if compute_eff_bs(get_iv_weights(variances)) >= minimal_size:\n        return 0        \n    fn = lambda x: np.abs(compute_eff_bs(get_iv_weights(variances+np.abs(x))) - minimal_size)\n    epsilon = minimize(fn, 0, method='Nelder-Mead', options={'fatol': 1.0, 'maxiter':100})\n    xi = np.abs(epsilon.x[0])\n    xi = 0 if xi is None else xi\n    return xi\n\n\nclass BootstrapDQN:\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n        \"\"\"\n        Initializes the agent,  constructs the qnet and the q_target, initializes the optimizer and ReplayMemory.\n        Args:\n            action_spec(dm_env.specs.DiscreteArray): description of the action space of the environment\n            observation_spec(dm_env.specs.Array): description of observations form the environment\n            device(str): \"gpu\" or \"cpu\"\n            settings(dict): dictionary with settings\n        \"\"\"\n        self.device = device\n        self.opt = opt\n        self.num_ensemble = num_ensemble\n        action_size = action_spec.num_values\n        state_size = np.prod(observation_spec.shape)\n        self.action_size = action_size\n        self.state_size = state_size\n        self.batch_size = settings['batch_size']\n        self.noisy_nets = settings['qnet_settings']['noisy_nets']\n\n        self.qnets, self.tnets, self.optims = [], [], []\n        for i in range(num_ensemble):\n            if settings[\"duelling_dqn\"]:\n                qnet = DuelDQN(state_size, action_size, settings['qnet_settings']).to(device)\n                q_target = DuelDQN(state_size, action_size, settings['qnet_settings']).to(device)\n            else:\n                qnet = Dqn(state_size, action_size, settings['qnet_settings'], seed=opt.net_seed+i).to(device)\n                q_target = Dqn(state_size, action_size, settings['qnet_settings'], seed=opt.net_seed+i).to(device)\n                self.drop_porb = 0\n\n            self.qnets.append(qnet)\n            q_target.load_state_dict(qnet.state_dict())\n            self.tnets.append(q_target)\n            self.optims.append(optim.Adam(qnet.parameters(), lr=settings['lr']))\n\n        self.epsilon = settings[\"epsilon_start\"]\n        self.decay = settings[\"epsilon_decay\"]\n        self.epsilon_min = settings[\"epsilon_min\"]\n        self.gamma = settings['gamma']\n\n        self.start_optimization = settings[\"start_optimization\"]\n        self.update_qnet_every = settings[\"update_qnet_every\"]\n        self.update_target_every = settings[\"update_target_every\"]\n        self.number_steps = 0\n        self.ddqn = settings[\"ddqn\"]\n\n        self.xi = settings[\"xi\"]\n        self.dynamic_xi = settings[\"dynamic_xi\"]\n        self.minimal_eff_bs_ratio = settings[\"minimal_eff_bs_ratio\"]\n        self.minimal_eff_bs = int(self.batch_size * self.minimal_eff_bs_ratio)\n        self.mask_prob = settings[\"mask_prob\"]\n\n        self._rng = np.random.RandomState(net_seed)\n        self._active_head = self._rng.randint(self.num_ensemble)\n        # Initialize replay memory\n        self.prioritized_replay = settings[\"prioritized_buffer\"]\n        if self.prioritized_replay:\n            self.memory = PrioritizedReplayMemory(device, settings[\"buffer_size\"], self.gamma, settings[\"n_steps\"],\n                                                  settings[\"alpha\"], settings[\"beta0\"], settings[\"beta_increment\"])\n        else:\n            self.memory = ReplayMemory(device, settings[\"buffer_size\"], self.gamma, settings[\"n_steps\"])\n        return\n\n    def select_action(self, timestep: dm_env.TimeStep) -> int:\n        \"\"\"\n        Returns an action following an epsilon-greedy policy.\n        Args:\n            timestep(dm_env.TimeStep): An observation from the environment\n\n        Returns:\n            int: The chosen action.\n        \"\"\"\n        observation = np.array(timestep.observation).flatten()\n        observation = torch.from_numpy(observation).float().to(self.device)\n        self.number_steps += 1\n\n        if not self.noisy_nets:\n            self.update_epsilon()\n\n        if np.random.rand() < self.epsilon:\n            return np.random.choice(self.action_size)\n        else:\n            return int(self.qnets[self._active_head].get_max_action(observation))\n\n\n    def greedy(self, Q_ensemble):\n        mean_Q = np.mean(Q_ensemble, 0)\n        # ------------------- action selection ------------------- #\n        # if self.opt.select_action == \"vote\":\n        actions = [np.argmax(Q) for Q in Q_ensemble]\n        data = Counter(actions)\n        action = data.most_common(1)[0][0]\n        # elif self.opt.select_action == \"mean\":\n        # action = np.argmax(mean_Q)\n\n        return action\n\n    def select_action_test(self, timestep: dm_env.TimeStep) -> int:\n        \"\"\"\n        Returns an action following an epsilon-greedy policy.\n        Args:\n            timestep(dm_env.TimeStep): An observation from the environment\n\n        Returns:\n            int: The chosen action.\n        \"\"\"\n        observation = np.array(timestep.observation).flatten()\n        observation = torch.from_numpy(observation).float().to(self.device)\n        # self.number_steps += 1\n\n        with torch.no_grad():\n            Q_ensemble = np.array([qnet(observation).cpu().data.numpy()\n                               for qnet in self.qnets])\n\n        return int(self.greedy(Q_ensemble))\n\n    def update_epsilon(self) -> None:\n        \"\"\"\n        Decays epsilon until self.epsilon_min\n        Returns:\n            None\n        \"\"\"\n        if self.epsilon > self.epsilon_min:\n            self.epsilon *= self.decay\n\n    @staticmethod\n    def calc_loss(q_observed: torch.Tensor,\n                  q_target: torch.Tensor,\n                  weights: torch.Tensor) -> typing.Tuple[torch.Tensor, np.float64]:\n        \"\"\"\n        Returns the mean weighted MSE loss and the loss for each sample\n        Args:\n            q_observed(torch.Tensor): calculated q_value\n            q_target(torch.Tensor):   target q-value\n            weights: weights of the batch samples\n\n        Returns:\n            tuple(torch.Tensor, np.float64): mean squared error loss, loss for each indivdual sample\n        \"\"\"\n        losses = functional.mse_loss(q_observed, q_target, reduction='none')\n        loss = (weights * losses).sum()\n        return loss, losses.cpu().detach().numpy() + 1e-8\n\n    def update(self,\n               step: dm_env.TimeStep,\n               action: int,\n               next_step: dm_env.TimeStep) -> None:\n        \"\"\"\n        Adds experience to the replay memory, performs an optimization_step and updates the q_target neural network.\n        Args:\n            step(dm_env.TimeStep): Current observation from the environment\n            action(int): The action that was performed by the agent.\n            next_step(dm_env.TimeStep): Next observation from the environment\n        Returns:\n            None\n        \"\"\"\n\n        logs = []\n        observation = np.array(step.observation).flatten()\n        next_observation = np.array(next_step.observation).flatten()\n        done = next_step.last()\n\n        if next_step.last():\n          self._active_head = self._rng.randint(self.num_ensemble)\n\n        exp = Experience(observation,\n                         action,\n                         next_step.reward,\n                         next_step.discount,\n                         next_observation,\n                         0,\n                         done,\n                         self._rng.binomial(1, self.mask_prob, self.num_ensemble).astype(np.float32)\n                         )\n        self.memory.add(exp)\n\n        if self.memory.number_samples() < self.start_optimization:\n            return logs\n\n        if self.number_steps % self.update_qnet_every == 0:\n            s0, a0, n_step_reward, discount, s1, _, dones, indices, weights, masks = self.memory.sample_batch(self.batch_size)\n            logs = self.optimization_step(s0, a0, n_step_reward, discount, s1, indices, weights, masks)\n\n        if self.number_steps % self.update_target_every == 0:\n            for i in range(self.num_ensemble):\n                self.tnets[i].load_state_dict(self.qnets[i].state_dict())\n        return logs\n\n    def optimization_step(self,\n                          s0: torch.Tensor,\n                          a0: torch.Tensor,\n                          n_step_reward: torch.Tensor,\n                          discount: torch.Tensor,\n                          s1: torch.Tensor,\n                          indices: typing.Optional[torch.Tensor],\n                          weights: typing.Optional[torch.Tensor],\n                          masks: torch.Tensor) -> None:\n        \"\"\"\n        Calculates the Bellmann update and updates the qnet.\n        Args:\n            s0(torch.Tensor): current state\n            a0(torch.Tensor): current action\n            n_step_reward(torch.Tensor): n-step reward\n            discount(torch.Tensor): discount factor\n            s1(torch.Tensor): next state\n            indices(torch.Tensor): batch indices, needed for prioritized replay. Not used yet.\n            weights(torch.Tensor): weights needed for prioritized replay\n\n        Returns:\n            None\n        \"\"\"\n\n        with torch.no_grad():\n            if self.noisy_nets:\n                self.q_target.reset_noise()\n                self.qnet.reset_noise()\n\n            # Calculating the target values\n            next_q_vals = torch.stack([self.tnets[i](s1) for i in range(self.num_ensemble)])\n            next_actions = torch.stack([next_q_vals[i].max(1)[1] for i in range(self.num_ensemble)])\n            # if self.ddqn:\n            #     a1 = torch.argmax(self.qnet(s1), dim=1).unsqueeze(-1)\n            #     next_q_val = next_q_vals.gather(1, a1).squeeze()\n            # else:\n            #     next_q_val = torch.max(next_q_vals, dim=2).values\n            q_targets = torch.stack([n_step_reward.squeeze() + self.gamma * discount.squeeze() * torch.max(next_q_vals[i], dim=1).values\\\n                                        for i in range(self.num_ensemble)])\n            # print(discount.size(), next_q_vals.size(), next_actions.size())\n            q_target_var_all = (self.gamma**2) * (discount.repeat(1, self.action_size)**2) * next_q_vals.var(0)\n\n        eff_batch_size_list, xi_list, loss_list = [], [], []        \n        for i in range(self.num_ensemble):\n            # print(next_actions[i].size(), masks.size(), q_targets.size())\n            q_target_var = q_target_var_all.gather(1, next_actions[i].unsqueeze(-1).long())[masks[:, i, 0]]\n            # print(q_target_var.size())\n            self.xi = get_optimal_xi(q_target_var.detach().cpu().numpy(\n                ), self.minimal_eff_bs, self.xi) if self.dynamic_xi else self.xi\n            weights = self.get_mse_weights(q_target_var)\n            q_observed = self.qnets[i](s0).gather(1, a0.long()).squeeze()[masks[:, i, 0]]\n            critic_loss, batch_loss = self.calc_loss(q_observed, q_targets[i][masks[:, i, 0]], weights.to(self.device))\n\n            # Backpropagation of the gradients\n            self.optims[i].zero_grad()\n            critic_loss.backward()\n            torch.nn.utils.clip_grad_norm_(self.qnets[i].parameters(), 5)\n            self.optims[i].step()\n\n            eff_batch_size_list.append(\n                compute_eff_bs(weights.detach().cpu().numpy()))\n            xi_list.append(self.xi)\n            # loss_list.append(loss.item())\n\n        # Update replay memory\n        self.memory.update_priorities(indices, batch_loss)\n        return q_target_var.detach().cpu().numpy(), weights.squeeze().detach().cpu().numpy(), np.mean(eff_batch_size_list), np.mean(xi_list)\n\n    def train_log(self, var, weights, eff_batch_size, eps_list):\n        wandb.log({\"IV Weights(VAR)\": np.var(weights), \"IV Weights(Mean)\": np.mean(weights),\n            \"IV Weights(Min)\": np.min(weights), \"IV Weights(Max)\": np.max(weights), \"IV Weights(Median)\": np.median(weights)}, commit=False)\n        wandb.log({\"Variance(Q) (VAR)\": np.var(var), \"Variance(Q) (Mean)\": np.mean(var),\n            \"Variance(Q) (Min)\": np.min(var), \"Variance(Q) (Max)\": np.max(var), \"Variance(Q) (Median)\": np.median(var)}, commit=False)\n        wandb.log(\n            {\"Avg Effective Batch Size \/ Episode\": np.mean(eff_batch_size), \"Avg Epsilon \/ Episode\": np.mean(eps_list),\n            \"Max Epsilon \/ Episode\": np.max(eps_list), \"Median Epsilon \/ Episode\": np.median(eps_list), \n            \"Min Epsilon \/ Episode\": np.min(eps_list)}, commit=False)\n\n    def get_mse_weights(self, variance):\n        return torch.ones(variance.size()) \/ variance.size()[0]\n\n\nclass EnsembleDQN(BootstrapDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n\n    def greedy(self, Q_ensemble):\n        mean_Q = np.mean(Q_ensemble, 0)\n        # ------------------- action selection ------------------- #\n        # if self.opt.select_action == \"vote\":\n        # actions = [np.argmax(Q) for Q in Q_ensemble]\n        # data = Counter(actions)\n        # action = data.most_common(1)[0][0]\n        # elif self.opt.select_action == \"mean\":\n        action = np.argmax(mean_Q)\n\n        return action\n\n    def select_action(self, timestep: dm_env.TimeStep) -> int:\n        \"\"\"\n        Returns an action following an epsilon-greedy policy.\n        Args:\n            timestep(dm_env.TimeStep): An observation from the environment\n\n        Returns:\n            int: The chosen action.\n        \"\"\"\n        observation = np.array(timestep.observation).flatten()\n        observation = torch.from_numpy(observation).float().to(self.device)\n        self.number_steps += 1\n\n        for qnet in self.qnets:\n            qnet.eval()\n\n        with torch.no_grad():\n            Q_ensemble = np.array([qnet(observation).cpu().data.numpy()\n                               for qnet in self.qnets])\n\n        if not self.noisy_nets:\n            self.update_epsilon()\n\n        if np.random.rand() < self.epsilon:\n            return np.random.choice(self.action_size)\n        else:\n            return int(self.greedy(Q_ensemble))\n\n    def select_action_test(self, timestep: dm_env.TimeStep) -> int:\n        \"\"\"\n        Returns an action following an epsilon-greedy policy.\n        Args:\n            timestep(dm_env.TimeStep): An observation from the environment\n\n        Returns:\n            int: The chosen action.\n        \"\"\"\n        observation = np.array(timestep.observation).flatten()\n        observation = torch.from_numpy(observation).float().to(self.device)\n        self.number_steps += 1\n\n        for qnet in self.qnets:\n            qnet.eval()\n\n        with torch.no_grad():\n            Q_ensemble = np.array([qnet(observation).cpu().data.numpy()\n                               for qnet in self.qnets])\n\n        return int(self.greedy(Q_ensemble))\n\n\n\nclass LakshmiBootDQN(BootstrapDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n\n\n        self.qnets, self.tnets, self.optims = [], [], []\n        for i in range(num_ensemble):\n            if settings[\"duelling_dqn\"]:\n                qnet = DuelDQN(self.state_size, self.action_size, settings['qnet_settings']).to(device)\n                q_target = DuelDQN(self.state_size, self.action_size, settings['qnet_settings']).to(device)\n            else:\n                qnet = TwoHeadDqn(self.state_size, self.action_size, settings['qnet_settings'], seed=opt.net_seed+i).to(device)\n                q_target = TwoHeadDqn(self.state_size, self.action_size, settings['qnet_settings'], seed=opt.net_seed+i).to(device)\n                self.drop_porb = 0\n\n            self.qnets.append(qnet)\n            q_target.load_state_dict(qnet.state_dict())\n            self.tnets.append(q_target)\n            self.optims.append(optim.Adam(qnet.parameters(), lr=settings['lr']))\n\n    def optimization_step(self,\n                          s0: torch.Tensor,\n                          a0: torch.Tensor,\n                          n_step_reward: torch.Tensor,\n                          discount: torch.Tensor,\n                          s1: torch.Tensor,\n                          indices: typing.Optional[torch.Tensor],\n                          weights: typing.Optional[torch.Tensor],\n                          masks: torch.Tensor) -> None:\n        \"\"\"\n        Calculates the Bellmann update and updates the qnet.\n        Args:\n            s0(torch.Tensor): current state\n            a0(torch.Tensor): current action\n            n_step_reward(torch.Tensor): n-step reward\n            discount(torch.Tensor): discount factor\n            s1(torch.Tensor): next state\n            indices(torch.Tensor): batch indices, needed for prioritized replay. Not used yet.\n            weights(torch.Tensor): weights needed for prioritized replay\n\n        Returns:\n            None\n        \"\"\"\n\n        with torch.no_grad():\n            if self.noisy_nets:\n                self.q_target.reset_noise()\n                self.qnet.reset_noise()\n\n            # Calculating the target values\n            next_q_vals_all = torch.stack([torch.stack(self.tnets[i](s1, is_training=True))\n                                                         for i in range(self.num_ensemble)])\n            next_q_vals, next_q_vals_std = next_q_vals_all[:,0], next_q_vals_all[:,1]\n            next_actions = torch.stack([next_q_vals[i].max(1)[1] for i in range(self.num_ensemble)])\n            # q_targets_all = torch.stack([n_step_reward.squeeze() + self.gamma * discount.squeeze() * next_q_vals[i]\\\n                                                                                    # for i in range(self.num_ensemble)])\n            # print(discount.size(), n_step_reward.size(), next_q_vals.size())\n            q_targets_all = torch.stack([n_step_reward.repeat(1, self.action_size) + self.gamma * discount.repeat(1, self.action_size) * next_q_vals[i]\\\n                                                                                    for i in range(self.num_ensemble)])\n            q_targets = torch.stack([n_step_reward.squeeze() + self.gamma * discount.squeeze() * torch.max(next_q_vals[i], dim=1).values\\\n                                                                                    for i in range(self.num_ensemble)])\n            # print(discount.size(), next_q_vals.size(), next_actions.size())\n            # q_target_var_all = (self.gamma**2) * (discount.repeat(1, self.action_size)**2) * next_q_vals.var(0)\n            next_q_vals_std = (self.gamma**2) * torch.stack([next_q_vals_std[i].gather(1, next_actions[i].unsqueeze(-1).long()) for i in range(self.num_ensemble)])\n            # print(next_q_vals.size(), next_q_vals_std.size(), q_targets.size())\n            # print((next_q_vals_std**2 + q_targets**2 - q_targets.mean(0).unsqueeze(-1).repeat(self.num_ensemble,1,1)**2).mean(0).size())\n            q_var_mixture = (discount.repeat(1, self.action_size)**2) * (next_q_vals_std**2 + q_targets_all**2 - q_targets_all.mean(0).unsqueeze(0).repeat(self.num_ensemble,1,1)**2).mean(0)\n\n        eff_batch_size_list, xi_list, loss_list = [], [], []        \n        for i in range(self.num_ensemble):\n            # print(next_actions[i].size(), masks.size(), q_targets.size())\n            q_target_var = q_var_mixture.gather(1, next_actions[i].unsqueeze(-1).long())[masks[:, i, 0]]\n            # print(q_target_var.size())\n            self.xi = get_optimal_xi(q_target_var.detach().cpu().numpy(\n                ), self.minimal_eff_bs, self.xi) if self.dynamic_xi else self.xi\n            weights = self.get_mse_weights(q_target_var)\n            q_observed, q_observed_std = self.qnets[i](s0, is_training=True)\n            q_observed = q_observed.gather(1, a0.long()).squeeze()#[masks[:, i, 0]]\n            q_observed_std = q_observed_std.gather(1, a0.long()).squeeze()#[masks[:,i,0]]\n\n            y, mu, std = q_targets, q_observed, q_observed_std\n            lossatt = torch.mean((y - mu)**2 \/ (2 * (std**2)) + (1\/2) * torch.log((std**2)))\n\n            critic_loss, batch_loss = self.calc_loss(q_observed[masks[:, i, 0]], q_targets[i][masks[:, i, 0]], weights.to(self.device))\n\n            # Backpropagation of the gradients\n            self.optims[i].zero_grad()\n            critic_loss += self.opt.lossatt_weight * lossatt\n            critic_loss.backward()\n            torch.nn.utils.clip_grad_norm_(self.qnets[i].parameters(), 5)\n            self.optims[i].step()\n\n            eff_batch_size_list.append(\n                compute_eff_bs(weights.detach().cpu().numpy()))\n            xi_list.append(self.xi)\n            # loss_list.append(loss.item())\n\n        # Update replay memory\n        self.memory.update_priorities(indices, batch_loss)\n        return q_target_var.detach().cpu().numpy(), weights.squeeze().detach().cpu().numpy(), np.mean(eff_batch_size_list), np.mean(xi_list)\n\n\nclass IV_BootstrapDQN(BootstrapDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n\n    def iv_weights(self, variance):\n        weights = (1. \/ (variance+self.xi))\n        weights \/= weights.sum(0)\n        return weights\n\n    def get_mse_weights(self, variance):\n        return self.iv_weights(variance)\n\n\nclass IV_DQN(EnsembleDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n\n    def iv_weights(self, variance):\n        weights = (1. \/ (variance+self.xi))\n        weights \/= weights.sum(0)\n        return weights\n\n    def get_mse_weights(self, variance):\n        return self.iv_weights(variance)\n\nclass IV_LakshmiBootDQN(LakshmiBootDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n\n    def iv_weights(self, variance):\n        weights = (1. \/ (variance+self.xi))\n        weights \/= weights.sum(0)\n        return weights\n\n    def get_mse_weights(self, variance):\n        return self.iv_weights(variance)\n\n\nclass SunriseDQN(BootstrapDQN):\n    def __init__(self,\n                 opt,\n                 action_spec: dm_env.specs.DiscreteArray,\n                 observation_spec: dm_env.specs.Array,\n                 num_ensemble: int,\n                 net_seed: int,\n                 device: torch.device,\n                 settings: dict) -> None:\n\n        super().__init__(opt, action_spec, observation_spec, num_ensemble, net_seed, device, settings)\n        self.opt = opt\n\n    def sunrise_weights(self, variance):\n        temp = self.opt.sunrise_temp\n        weights = torch.sigmoid(-torch.sqrt(variance)*temp) + 0.5\n        return weights\n\n    def get_mse_weights(self, variance):\n    \treturn self.sunrise_weights(variance)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_361","text":"<reponame>mengdong\/mapr-streams-mxnet-face\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom symbol.resnet import *\nfrom symbol.config import config\nfrom symbol.processing import bbox_pred, clip_boxes, nms\nimport face_embedding\nfrom mapr_streams_python import Consumer, KafkaError, Producer\nimport numpy as np\nimport cv2, os, json, time, sys, pickle\nimport mxnet as mx\nimport argparse, random, sklearn\nimport tensorflow as tf\nfrom scipy import misc\nfrom sklearn.decomposition import PCA\nfrom time import sleep\nfrom easydict import EasyDict as edict\nfrom mtcnn_detector import MtcnnDetector\nimport face_image, face_preprocess\nfrom flask import Flask, Response\n\napp = Flask(__name__)\n\n@app.route('\/')\ndef index():\n    return Response(kafkastream(),\n                    mimetype='multipart\/x-mixed-replace; boundary=frame')\n\ndef ch_dev(arg_params, aux_params, ctx):\n    new_args = dict()\n    new_auxs = dict()\n    for k, v in arg_params.items():\n        new_args[k] = v.as_in_context(ctx)\n    for k, v in aux_params.items():\n        new_auxs[k] = v.as_in_context(ctx)\n    return new_args, new_auxs\n\ndef resize(im, target_size, max_size):\n    \"\"\"\n    only resize input image to target size and return scale\n    :param im: BGR image input by opencv\n    :param target_size: one dimensional size (the short side)\n    :param max_size: one dimensional max size (the long side)\n    :return:\n    \"\"\"\n    im_shape = im.shape\n    im_size_min = np.min(im_shape[0:2])\n    im_size_max = np.max(im_shape[0:2])\n    im_scale = float(target_size) \/ float(im_size_min)\n    if np.round(im_scale * im_size_max) > max_size:\n        im_scale = float(max_size) \/ float(im_size_max)\n    im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\n    return im, im_scale\n\ndef get_face_embedding(filename, arg_params, aux_params, sym, model, ctx):\n    img_orig = cv2.imread(filename)\n    img_orig = cv2.cvtColor(img_orig, cv2.COLOR_BGR2RGB)\n    img, scale = resize(img_orig.copy(), 600, 1000)\n    im_info = np.array([[img.shape[0], img.shape[1], scale]], dtype=np.float32)  # (h, w, scale)\n    img = np.swapaxes(img, 0, 2)\n    img = np.swapaxes(img, 1, 2)  # change to (c, h, w) order\n    img = img[np.newaxis, :]  # extend to (n, c, h, w)\n    arg_params[\"data\"] = mx.nd.array(img, ctx)\n    arg_params[\"im_info\"] = mx.nd.array(im_info, ctx)\n    exe = sym.bind(ctx, arg_params, args_grad=None, grad_req=\"null\", aux_states=aux_params)\n\n    exe.forward(is_train=False)\n    output_dict = {name: nd for name, nd in zip(sym.list_outputs(), exe.outputs)}\n    rois = output_dict['rpn_rois_output'].asnumpy()[:, 1:]  # first column is index\n    scores = output_dict['cls_prob_reshape_output'].asnumpy()[0]\n    bbox_deltas = output_dict['bbox_pred_reshape_output'].asnumpy()[0]\n    pred_boxes = bbox_pred(rois, bbox_deltas)\n    pred_boxes = clip_boxes(pred_boxes, (im_info[0][0], im_info[0][1]))\n    cls_boxes = pred_boxes[:, 4:8]\n    cls_scores = scores[:, 1]\n    keep = np.where(cls_scores >0.6)[0]\n    cls_boxes = cls_boxes[keep, :]\n    cls_scores = cls_scores[keep]\n    dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)\n    keep = nms(dets.astype(np.float32), 0.3)\n    dets = dets[keep, :]\n    bbox = dets[0, :4]\n    roundfunc = lambda t: int(round(t\/scale))\n    vfunc = np.vectorize(roundfunc)\n    bbox = vfunc(bbox)\n    f_vector, jpeg = model.get_feature(img_orig, bbox, None)\n    fT = f_vector.T\n    return fT\n\ndef kafkastream():\n    if args.gpuid >= 0:\n        ctx = mx.gpu(args.gpuid)\n    else:\n        ctx = mx.cpu()\n    _, arg_params, aux_params = mx.model.load_checkpoint('mxnet-face-fr50', 0)\n    arg_params, aux_params = ch_dev(arg_params, aux_params, ctx)\n    sym = resnet_50(num_class=2)\n    model = face_embedding.FaceModel(args.gpuid)\n\n    f1T = get_face_embedding(args.filename, arg_params, aux_params, sym, model, ctx)\n\n    c = Consumer({'group.id': args.groupid,\n              'default.topic.config': {'auto.offset.reset': 'earliest', 'enable.auto.commit': 'false'}})\n    c.subscribe([args.readstream+':'+args.readtopic])\n    running = True\n    p = Producer({'streams.producer.default.stream': args.writestream})\n\n    while running:\n        msg = c.poll(timeout=0)\n        if msg is None: continue\n        if not msg.error():\n            pickle_vector = pickle.loads(msg.value())\n            nparr = np.fromstring(pickle_vector[0], np.uint8)\n            img_orig = cv2.imdecode(nparr, 1)\n\n            bbox_vector = pickle_vector[1]\n            print(len(bbox_vector))\n            embedding_vector = pickle_vector[2]\n            if len(embedding_vector) > 0:\n                sim_vector = [np.dot(f, f1T) for f in embedding_vector]\n                idx = sim_vector.index(max(sim_vector))\n                bbox = bbox_vector[idx]\n                sim = sim_vector[idx]\n                if sim > args.threshold:\n                    img = cv2.cvtColor(img_orig, cv2.COLOR_RGB2BGR)\n                    cv2.rectangle(img, (int(round(bbox[0])), int(round(bbox[1]))),\n                        (int(round(bbox[2])), int(round(bbox[3]))),  (0, 255, 0), 2)\n                    ret, jpeg = cv2.imencode('.png', img)\n                    bytecode = jpeg.tobytes()\n                    time.sleep(args.timeout)\n                    yield (b'--frame\\r\\n'\n                        b'Content-Type: image\/png\\r\\n\\r\\n' + bytecode + b'\\r\\n\\r\\n')\n                    if args.writetostream:\n                        p.produce(args.writetopic, jpeg.tostring())\n                        print(args.writetopic)\n        elif msg.error().code() != KafkaError._PARTITION_EOF:\n            print(msg.error())\n            running = False\n\n    c.close()\n    p.flush()\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser(description='mapr consumer settings')\n    parser.add_argument('--groupid', default='dong001', help='mapr consumer to read from')\n    parser.add_argument('--gpuid', default='-1', type=int, help='')\n    parser.add_argument('--port', default='5013', type=int, help='')\n    parser.add_argument('--threshold', default='0.3', type=float, help='')\n    parser.add_argument('--readstream', default='\/tmp\/processedvideostream', help='')\n    parser.add_argument('--writestream', default='\/tmp\/identifiedstream', help='')\n    parser.add_argument('--timeout', default='0.3', type=float, help='')\n    parser.add_argument('--writetostream', default='0', type=int, help='')\n    parser.add_argument('--writetopic', default='sam', help='topic to write to')\n    parser.add_argument('--readtopic', default='topic1', help='topic to write to')\n    parser.add_argument('--filename', default='sam_.jpg', help='')\n    args = parser.parse_args()\n    app.run(host='0.0.0.0', port=args.port, debug=True)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_362","text":"# cifar10_svm.py\n\n# Support Vector Machine (SVM)\n\nimport time\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport numpy as np\nfrom sklearn import model_selection\nfrom scipy.io import loadmat\n\nfrom sklearn.svm import SVC, LinearSVC\nfrom sklearn.metrics import hinge_loss\nfrom sklearn.metrics import classification_report, f1_score, accuracy_score, confusion_matrix\n\ndef run_svc(svc, title):\n    # Fit model\n    start = time.time()\n    svc.fit(x_train, y_train)\n    end = time.time()\n    print(\"\\nModel took %0.2f seconds to train\"%(end - start))\n\n    # Calculate predictions\n    start = time.time()\n    predicted = svc.predict(x_test)\n    end = time.time()\n    print(\"Model took %0.2f seconds to calculate predictions\"%(end - start))\n\n    # Output results\n    print('\\naccuracy', accuracy_score(y_test, predicted))\n    print('\\nSVM Results for ' + title)\n    print('\\nConfusion Matrix:')\n    print(confusion_matrix(y_test, predicted))\n\n    print('\\nClassification Report:', classification_report(y_test, predicted))\n    #print(\"Hinge loss\", hinge_loss(y_test, predicted))\n\n\n# Load datasets from file\nnpzfile = np.load('cifar10.npz')\nprint(npzfile.files)\n\nx_train = npzfile['x_train']\nx_test = npzfile['x_test']\ny_train = npzfile['y_train']\ny_test = npzfile['y_test']\n\n\n# Standardize the columns\nx_train = x_train \/ 255\nx_test = x_test \/ 255\n\n# The model cannot deal with 2D array so we have to convert to 1D array.\nx_train_flat = np.empty(shape=[x_train.shape[0]] + [3072], dtype='float32')\n\nfor i in range(x_train.shape[0]):\n    x_train_flat[i,:] = x_train[i,:,:].flatten()\n\n# Flatten x_test array\nx_test_flat = np.empty(shape=[x_test.shape[0]] + [3072], dtype='float32')\nfor i in range(x_test.shape[0]):\n    x_test_flat[i,:] = x_test[i,:,:].flatten()\n\nx_train = x_train_flat\nx_test = x_test_flat\ny_train = y_train.ravel()\ny_test = y_test.ravel()\n\nprint('\\n', type(x_train))\nprint('x_train shape:', x_train.shape)\nprint('x_test shape:', x_test.shape)\nprint('y_train shape:', y_train.shape)\nprint('y_test shape:', y_test.shape)\n\n\n# Linear\nsvc = SVC(kernel='linear', C=1)\nrun_svc(svc, 'Linear')\n\n# Radial Basis Function (RBF)\nsvc = SVC(kernel='rbf', gamma=1, C=1)\nrun_svc(svc, 'Radial Basis Function (RBF)')\n\n# Polynomial\nsvc = SVC(kernel='poly', degree=5, C=1)\nrun_svc(svc, 'Polynomial)')\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_363","text":"<filename>twod_phase.py\n\"\"\"\n2D neural field phase model\n\nall evaluations on NxN matrix.\n\nconvolutions performed on 0,2pi x 0,2pi domain. plotted on -pi,pi x -pi,pi domain.\n\nnotes:\n-\n\ntodo: \n-include methods to get and view slices, steady-state bumps\n\"\"\"\n\n\n\nimport numpy as np\nnp.random.seed(0)\n\nimport matplotlib\n#matplotlib.use(\"Agg\")\n#matplotlib.use(\"GTKAgg\")\n\n# for dynamic print updating\nfrom sys import stdout\nimport sys\nimport getopt\n\n#import twod_phase\nimport collections\nimport matplotlib.pylab as mp\nimport os\n#import scipy as sp\nimport scipy as sp\nfrom scipy.integrate import odeint,dblquad\nfrom scipy.interpolate import interp1d\nfrom scipy.optimize import fsolve\nimport scipy.spatial as spatial\nimport scipy.spatial.distance as dist\nimport scipy.cluster.hierarchy as hier\nimport time\n#from colorsys import hsv_to_rgb\nfrom mpl_toolkits.mplot3d import Axes3D\nimport copy\nimport math\n\n\n\nfrom matplotlib import rc\nrc('text', usetex=True)\nrc('font', family='serif', serif=['Computer Modern Roman'])\n\n# anim\nimport matplotlib.pyplot as plt\n\n\nimport fourier_2d as f2d\nfrom euler import ESolve\nfrom twod_full import SimDat as sd\nfrom twod_full import f,plot_s\nfrom lib import *\n\n#sd = sd(display_params=False)\n\n\nsin = np.sin\ncos = np.cos\npi = np.pi\nsqrt = np.sqrt\nexp = np.exp\n\nperiodization_lower = -5\nperiodization_upper = 5\n\n\ndef usage():\n    print \"-l, --use-last\\t\\t: use last data from last sim\"\n    print \"-v, --save-last\\t\\t: save last data of current sim\"\n    print \"-s, --use-ss\\t\\t: use last saved steady-state data\"\n    print \"-e, --save-ss\\t\\t: save solution as steady-state data\"\n    print \"-r, --use-random\\t: use random inits\"\n    print \"-h, --help\\t\\t: help function\"\n    print \"-p, --run-phase\\t\\t: run phase\"\n    print \"-f, --run-full\\t\\t: run full\"\n\n\ndef shift(Z,x,y):\n    \"\"\"\n    shift surface Z by coordinates x,y\n    \"\"\"\n    N,N = Z.shape\n    Nx = int(N*x\/(2*pi))\n    Ny = int(N*y\/(2*pi))\n    return np.roll(np.roll(Z,Nx,axis=1),Ny,axis=0)\n\n\nclass Phase(sd):\n    \"\"\"\n    simulate phase equation\n    \"\"\"\n    def __init__(self,\n                 check_h=False,\n                 check_j=False,\n                 recompute_h=False,\n                 recompute_j=False,\n                 recompute_fq=True,\n                 recompute_phase_lc=False,\n                 compute_h_error=False,\n                 new_phase_rhs=False,\n                 low_memory=False,\n                 use_last=False,\n                 save_last=False,\n                 pertx=False,\n                 perty=False,\n                 init_mode='polar',\n                 dde_T=100,\n                 dde_dt=.1,\n                 dde_delay_t=20,\n                 g=0.,q=0.,\n                 x0=0,y0=0,\n                 x1=0,y1=0,\n                 dde_periodization_lower=-2,\n                 dde_periodization_upper=2,\n                 phase_option='full'):\n\n\n        \"\"\"\n        compute_h_error: True or False. Compute the error between lookup table H_1 and Fourier approximation of H_1\n        low_memory: if false, excludes all simulations that are memory-intensive. Some plots may not be available.\n        \n        \"\"\"\n\n        \"\"\"\n        Sim.__init__(self)\n        Kernel.__init__(self)\n        \n        \"\"\"\n        sd.__init__(self,display_params=False)\n        \n        #SteadyState.__init__(self)\n\n        self.init_mode = init_mode\n\n        self.x0 = x0 # initial x-coordinate (1st pair)\n        self.y0 = y0 # initial y-coordinate (1st pair)\n\n        self.x1 = x1 # initial x-coordinate (2nd pair)\n        self.y1 = y1 # initial y-coordinate (2nd pair)\n\n        self.phase_option = phase_option\n        self.new_phase_rhs=new_phase_rhs\n\n        self.dde_periodization_lower = dde_periodization_lower\n        self.dde_periodization_upper = dde_periodization_upper\n\n        self.g = g\n        self.q = q\n\n        self.dde_T = dde_T\n        self.dde_dt = dde_dt\n        self.dde_delay_t = dde_delay_t\n        self.dde_TN = int(self.dde_T\/self.dde_dt)\n        self.dde_t = np.linspace(0,self.dde_T+self.dde_dt,self.dde_TN)\n        self.dde_delay_N = int(self.dde_delay_t\/self.dde_dt)\n\n\n        self.recompute_h = recompute_h\n        self.recompute_j = recompute_j\n        self.recompute_phase_lc = recompute_phase_lc\n        self.recompute_fq = recompute_fq\n\n        self.use_last = use_last\n        self.save_last = save_last\n\n        self.check_h = check_h\n        self.check_j = check_j\n\n        self.pertx = pertx\n        self.perty = perty\n\n        self.dde_dir = 'opt='+str(phase_option)+\\\n                       '_delayN='+str(self.dde_delay_N)+\\\n                        '_dt='+str(self.dde_dt)\n\n        if (not os.path.exists(self.savedir+'\/'+self.dde_dir)):\n            os.makedirs(self.savedir+'\/'+self.dde_dir)\n\n\n        self.filename_th1 = self.savedir+'\/'+self.dde_dir+'\/th1_last.dat'\n        self.filename_th2 = self.savedir+'\/'+self.dde_dir+'\/th2_last.dat'\n        self.filename_thi_t = self.savedir+'\/'+self.dde_dir+'\/thi_t_last.dat'\n\n        self.H1,self.H2 = self.H_i()\n        self.J1,self.J2 = self.J_i()\n\n        print '* Running phase_dde()...'\n        self.th1_ph,self.th2_ph = self.phase_dde()\n\n        print '  ... done.'\n        \n        if compute_h_error:\n            err_h1,err_j1 = self.HJ_i_error()\n            print 'H1_lookup vs H1_fourier error =',err_h1\n            print 'J1_lookup vs J1_fourier error =',err_j1\n\n\n    def h1_approx(self,x,y,sig=5.,a=.1):\n        #return x*exp(-(x**2+y**2)**2)\n        # based on numerics h1 seems to be y*exp\n        if self.phase_option == 'approx2':\n            return x*exp(-(x**2+y**2)**2\/sig**2) - a*sin(x)\n        else:\n            return x*exp(-(x**2+y**2)**2\/sig**2)\n\n    def h2_approx(self,x,y):\n        return self.h1_approx(y,x)\n\n    def h1_approx_p(self,x,y):\n        \"\"\"\n        periodized kernel using difference of gaussians\n        \"\"\"\n        tot = 0\n        for n in np.arange(self.dde_periodization_lower,self.dde_periodization_upper+1,1):\n            for m in np.arange(self.dde_periodization_lower,self.dde_periodization_upper+1,1):\n                tot = tot + self.h1_approx(x+n*2*pi,y+m*2*pi)\n        return tot\n\n\n    def h2_approx_p(self,x,y):\n        \"\"\"\n        periodized kernel using difference of gaussians\n        \"\"\"\n        tot = 0\n        for n in np.arange(self.dde_periodization_lower,self.dde_periodization_upper+1,1):\n            for m in np.arange(self.dde_periodization_lower,self.dde_periodization_upper+1,1):\n                tot = tot + self.h2_approx(x+n*2*pi,y+m*2*pi)\n        return tot\n\n\n    def phase_dde(self):\n        \"\"\"\n        the full integro-delay-differential equation using Euler's method\n        x: x[:N], x[N:]. x history and y history, respectively. up to N time steps.    \n\n        todo:\n        -start with bard's approximations\n        -once the bard method works, move on to Fourier stuff.\n\n        I will use this guy's code if I have to:\n        https:\/\/zulko.wordpress.com\/2013\/03\/01\/delay-differential-equations-easy-with-python\/\n        \"\"\"\n\n        file_not_found = False\n        while True:\n\n            if self.use_last and not(file_not_found):\n                if os.path.isfile(self.filename_th1) and\\\n                   os.path.isfile(self.filename_th2):\n                    print 'using last'\n                    th1_0 = np.loadtxt(self.filename_th1)\n                    th2_0 = np.loadtxt(self.filename_th2)\n                    break\n                else:\n                    print 'init file not found'\n                    file_not_found = True\n            else:\n                #np.random.seed(0)\n                if self.init_mode == 'polar':\n                    print 'using polar init'\n                    r0 = self.x0#.36219\n                    nu0 = self.y0#1.2458\n                    th0 = np.linspace(0,-self.dde_delay_t,self.dde_delay_N)*nu0\n                    th1_0 = r0*cos(th0)\n                    th2_0 = r0*sin(th0)\n                    \n                elif self.init_mode == 'cartesian':\n                    print 'using cartesian init'\n                    init_angle = np.arctan2(self.y1-self.y0,self.x0-self.x1)\n                    if init_angle < 0:\n                        init_angle += 2*pi\n\n                    print 'initial angle',init_angle\n                    x_line = np.linspace(self.x0,self.x1,self.dde_delay_N)\n                    y_line = np.linspace(self.y0,self.y1,self.dde_delay_N)\n                    th1_0 = x_line\n                    th2_0 = y_line\n                    \n                    if self.pertx:\n                        print 'Reminder: added small perturbation to x init'\n                        N = 20\n                        th1_0[-N:]+=.01*np.exp(-np.linspace(0,N*self.dde_dt,N))\n                        #th2_0[-150:-145]+=.01\n\n                    if self.perty:\n                        print 'Reminder: added small perturbation to y init'\n                        th1_0[-150:-145]+=.01\n                        #th2_0[-150:-145]+=.01\n\n\n                    \n                else:\n                    raise ValueError('no initial choice'+str(self.init_mode))\n\n                break\n        \n        th1 = np.zeros(self.dde_TN)\n        th2 = np.zeros(self.dde_TN)\n\n        th1[:self.dde_delay_N] = th1_0\n        th2[:self.dde_delay_N] = th2_0\n\n        # approximate the H function as a negative gaussian derivative: x*exp(-(x^2+y^2))\n\n        # solve dde\n        # for reference: H_1(x,y) = x*exp(-(x^2+y^2))\n        # so H_1(th1(tau-s)-th1(tau),th2(tau-s)-th2(tau))\n\n        n = np.arange(0,self.dde_delay_N,1)\n        for i in range(self.dde_delay_N-1,self.dde_TN):\n            if self.phase_option == 'approx' or self.phase_option == 'approx2':\n\n                h1_val = self.h1_approx_p(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                h2_val = self.h2_approx_p(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n\n                j1 = -self.h1_approx_p(th1[i-1],th2[i-1])\n                j2 = -self.h2_approx_p(th1[i-1],th2[i-1])\n\n            elif self.phase_option == 'full':\n                h1_val = f2d.H1_fourier(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                h2_val = f2d.H2_fourier(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                \n                j1 = -f2d.H1_fourier(th1[i-1],th2[i-1])\n                j2 = -f2d.H2_fourier(th1[i-1],th2[i-1])\n\n            elif self.phase_option == 'trunc':\n                h1_val = self.h1(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1],0.8)\n                h2_val = self.h2(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1],0.8)\n                \n                j1 = -self.h1(th1[i-1],th2[i-1],0.8)\n                j2 = -self.h2(th1[i-1],th2[i-1],0.8)\n\n                \n            th1[i] = th1[i-1] + self.dde_dt*( -(1.*self.g)*np.sum(np.exp(-n*self.dde_dt)*h1_val)*self.dde_dt + self.q*j1 )\n            th2[i] = th2[i-1] + self.dde_dt*( -(1.*self.g)*np.sum(np.exp(-n*self.dde_dt)*h2_val)*self.dde_dt + self.q*j2 )\n\n\n            #if self.phase_option == 'approx':\n            th1 = np.mod(th1+pi,2*pi)-pi\n            th2 = np.mod(th2+pi,2*pi)-pi\n            #elif self.phase_option == 'full':\n        if self.q == 0:\n            xv = th1[-1]-th1[-2]#np.mean(np.gradient(th1[-10:],self.dde_dt))\n            yv = th2[-1]-th2[-2]#np.mean(np.gradient(th2[-10:],self.dde_dt))\n            print 'velocity components'+' (xv,yv)='+str(xv)+','+str(yv)+')'\n            print 'velocity =',np.sqrt(xv**2 + yv**2)\n            final_angle = np.arctan2(yv,xv)\n            if final_angle < 0:\n                final_angle += 2*pi\n            print 'velocity angle',final_angle\n\n\n        if False:\n            mp.figure()\n            mp.plot(th1[-self.dde_delay_N:],th2[-self.dde_delay_N:])\n            mp.show()\n\n        if self.save_last:\n            np.savetxt(self.filename_th1,th1[-self.dde_delay_N:])\n            np.savetxt(self.filename_th2,th2[-self.dde_delay_N:])\n            np.savetxt(self.filename_thi_t,self.dde_t[-self.dde_delay_N:])\n\n        return th1,th2\n\n\n\n    def phase_dde_v2(self,dde_TN,x0,y0,phase_option='full'):\n        \"\"\"\n        v2 is the same as above, but with manual input params and improved control over initial conditions\n\n        x0,y0: initial arrays up to self.dde_delay_N, self.dde_delay_t\n\n        the full integro-delay-differential equation using Euler's method\n        x: x[:N], x[N:]. x history and y history, respectively. up to N time steps.    \n\n        \"\"\"\n        \n        th1 = np.zeros(dde_TN)\n        th2 = np.zeros(dde_TN)\n\n        th1[:self.dde_delay_N] = x0\n        th2[:self.dde_delay_N] = y0\n\n        # approximate the H function as a negative gaussian derivative: x*exp(-(x^2+y^2))\n\n        # solve dde\n        # for reference: H_1(x,y) = x*exp(-(x^2+y^2))\n        # so H_1(th1(tau-s)-th1(tau),th2(tau-s)-th2(tau))\n\n        n = np.arange(0,self.dde_delay_N,1)\n        for i in range(self.dde_delay_N-1,dde_TN):\n            if phase_option == 'approx' or phase_option == 'approx2':\n\n                h1_val = self.h1_approx_p(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                h2_val = self.h2_approx_p(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n\n                j1 = -self.h1_approx_p(th1[i-1],th2[i-1])\n                j2 = -self.h2_approx_p(th1[i-1],th2[i-1])\n\n            elif phase_option == 'full':\n                h1_val = f2d.H1_fourier(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                h2_val = f2d.H2_fourier(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1])\n                \n                j1 = -f2d.H1_fourier(th1[i-1],th2[i-1])\n                j2 = -f2d.H2_fourier(th1[i-1],th2[i-1])\n\n\n            elif self.phase_option == 'trunc':\n                h1_val = self.h1(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1],0.8)\n                h2_val = self.h2(th1[i-1-n]-th1[i-1],th2[i-1-n]-th2[i-1],0.8)\n                \n                j1 = -self.h1(th1[i-1],th2[i-1],0.8)\n                j2 = -self.h2(th1[i-1],th2[i-1],0.8)\n\n                \n            th1[i] = th1[i-1] + self.dde_dt*( -(1.*self.g)*np.sum(np.exp(-n*self.dde_dt)*h1_val)*self.dde_dt + self.q*j1 )\n            th2[i] = th2[i-1] + self.dde_dt*( -(1.*self.g)*np.sum(np.exp(-n*self.dde_dt)*h2_val)*self.dde_dt + self.q*j2 )\n\n            th1 = np.mod(th1+pi,2*pi)-pi\n            th2 = np.mod(th2+pi,2*pi)-pi\n\n        return th1,th2\n\n\n    def load_phase_lc(self):\n        \"\"\"\n        if lc data exists, load. if DNE or recompute required, compute here.\n        \"\"\"\n        file_not_found = False\n\n        self.filename_lc_phase = self.lcdir+'\/'+'lc_phase.dat'\n\n        while True:\n            if self.recompute_phase_lc or file_not_found:\n                \"\"\"\n                force recomputation of LC\n                \"\"\"\n                self.compute_phase_lc() # contains self.lc_phase_data\n                np.savetxt(self.filename_lc_phase,self.lc_phase_data)\n                break\n\n            else:\n                if os.path.isfile(self.filename_lc_phase):\n\n                    lc_phase_data = np.loadtxt(self.filename_lc_phase)\n\n                    self.lc_t_phase = lc_phase_data[:,0]\n                    self.lc_th1_phase = lc_phase_data[:,1]\n                    self.lc_th2_phase = lc_phase_data[:,2]\n                    \n                    self.lc_per = self.lc_t_phase[-1]\n                    print 'limit cycle period', self.lc_per\n                    # check to see if file contains lc or not.\n                    # non-lc parameter files have [-1,-1] as the data.\n\n                    if (lc_phase_data[0,0] == -1) and\\\n                       (lc_phase_data[0,1] == -1) and\\\n                       (lc_phase_data[0,2] == -1):\n                        self.limit_cycle_exists = False\n                    else:\n                        self.limit_cycle_exists = True\n                        \n                        self.lc_th1_phase_fn = interp1d(self.lc_t_phase,self.lc_th1_phase)\n                        self.lc_th2_phase_fn = interp1d(self.lc_t_phase,self.lc_th2_phase)\n\n                    break\n                else:\n                    file_not_found = True\n\n                            # make lookup tables for easier access and implementation\n\n    def phase_lc(self,t,choice):\n        if choice == 1:\n            return self.lc_th1_phase_fn(np.mod(t,self.lc_per))\n        if choice == 2:\n            return self.lc_th2_phase_fn(np.mod(t,self.lc_per))\n\n\n    def compute_phase_lc(self):\n        \"\"\"\n        if lc not found, or if recomputation requested, compute LC.\n\n        algorithm:\n        1. use existing data. if there are enough crossings, skip to 2. if there are not enough crossings detected, re-run with more time (print time). if there are enough crossings, skip to 2. else, quit.\n        2. given that there are enough crossings, check periodicity by using the last period estimate and check if the solution comes back to the start (up to some tolerance, print this). if the tolerance check fails, quit. else go to 3.\n        3. if a limit cycle exists, save the limit cycle solution data with a filename containing all parameter info in the format array=[time|theta1|theta2] (i.e. to plot theta1 over time i would use plot([array[:,0],array[:,1])).\n        \n        \"\"\"\n        \n        tol = .01\n\n        # first try finding crossings with current solution data.\n\n        temp_th1 = copy.deepcopy(self.th1_ph)\n        temp_th2 = copy.deepcopy(self.th2_ph)\n\n        find_crossings_iter = 0 # count # of times attempted to find enough LC crossings\n        max_find_crossings_iter = 1\n        crossings_exist = True # assume true to start\n\n        temp_TN = self.dde_TN\n        temp_t = self.dde_t\n\n\n\n        # step 1 use existing data.\n        while True:\n            # find ccw crossings on right\n            crossing_idx_ccw = (temp_th1[1:]>0)*(temp_th2[1:]>0)*(temp_th2[:-1]<=0)\n            crossing_idx_cw = (temp_th1[1:]>0)*(temp_th2[1:]<=0)*(temp_th2[:-1]>0)\n\n            cross_fail = 0\n\n            # check number of crossings in each direction\n            if np.sum(crossing_idx_ccw) <= 5:\n                print 'not enough crossings in ccw direction ('+str(np.sum(crossing_idx_ccw))+')'\n                cross_fail += 1\n            else:\n                print 'enough candidate crossings found in ccw direction ('+str(np.sum(crossing_idx_ccw))+')'\n                crossing_idx = crossing_idx_ccw\n                break # break to leave loop and go to step 2\n\n            if np.sum(crossing_idx_cw) <= 5:\n                print 'not enough crossings in cw direction ('+str(np.sum(crossing_idx_cw))+')'\n                cross_fail += 1\n            else:\n                print 'enough candidate crossings found in ccw direction ('+str(np.sum(crossing_idx_cw))+')'\n                crossing_idx = crossing_idx_cw\n                break # break to leave loop and go to step 2\n\n            if find_crossings_iter >= max_find_crossings_iter:\n                # if there was a limit cycle, it would have been detected in the 2nd pass above.\n                # give up if limit cycle not found in 2nd pass.\n                crossings_exist = False # gloabl var\n                self.limit_cycle_exists = False # global var\n                print 'no limit cycle found at step 1.', find_crossings_iter\n\n                # save dummy file.\n                break\n\n            if cross_fail == 2 and (find_crossings_iter < max_find_crossings_iter):\n                # if both crossing checks fail in step 1, run sim for longer\n                # this should not run in the second pass (when find_crossings_iter >= 1)\n                temp_T = 100\n                print 'not enough crossings. Re-initializing with additional time T='+str(temp_T)\n\n                dde_TN = int(temp_T\/self.dde_dt)\n                temp_temp_th1 = np.zeros(dde_TN+temp_TN)\n                temp_temp_th2 = np.zeros(dde_TN+temp_TN)\n                \n                x0 = temp_th1[-self.dde_delay_N:]\n                y0 = temp_th2[-self.dde_delay_N:]\n\n                temp_temp_th1[:self.dde_TN] = temp_th1\n                temp_temp_th2[:self.dde_TN] = temp_th2\n\n                temp_temp_th1[self.dde_TN:],temp_temp_th2[self.dde_TN:] = self.phase_dde_v2(dde_TN,x0,y0)\n\n                temp_th1 = temp_temp_th1\n                temp_th2 = temp_temp_th2\n\n                find_crossings_iter += 1 # add 1 to number of longer sims run\n\n        # step 2 check periodicity.\n        if crossings_exist:\n            print 'checking periodicity...'\n            # get last idx #\n            # http:\/\/stackoverflow.com\/questions\/34667282\/numpy-where-detailed-step-by-step-explanation-examples\n            final_idx = np.where(crossing_idx==1)[0][-1]\n\n            # get approx period\n            crossing_t = temp_t[1:][crossing_idx]\n            period = crossing_t[-1]-crossing_t[-4]\n            \n            temp_TN = int(period\/self.dde_dt)\n\n            # get approx init\n            temp_th1_2 = np.zeros(temp_TN)\n            temp_th2_2 = np.zeros(temp_TN)\n\n            x0 = temp_th1[(final_idx-self.dde_delay_N):final_idx]\n            y0 = temp_th2[(final_idx-self.dde_delay_N):final_idx]\n\n            print np.shape(x0)\n            print len(temp_th1_2)\n            print crossing_t\n\n\n            #temp_th1_2[:self.dde_delay_N] = x0\n            #temp_th2_2[:self.dde_delay_N] = y0\n\n\n            # integrate for 1 period\n            temp_th1_2,temp_th2_2 = self.phase_dde_v2(temp_TN,x0,y0)\n\n            temp_th1 = temp_th1_2\n            temp_th2 = temp_th2_2\n            \n            if False:\n                # just test plotting\n                mp.figure()\n                mp.plot(temp_th1,temp_th2)\n\n                mp.figure()\n                mp.plot(temp_th1)\n                mp.plot(temp_th2)\n                mp.show()\n\n            # check tolerance\n            err = (np.abs(temp_th1[-1]-temp_th1[0])+np.abs(temp_th2[-1]-temp_th2[0]))\n            if err<tol:\n                print 'limit cycle found!', 'tol =',np.abs(temp_th1[-1]-temp_th1[0])+np.abs(temp_th2[-1]-temp_th2[0])\n\n\n\n                self.lc_t_phase = np.linspace(0,period,temp_TN)\n                self.lc_th1_phase = temp_th1\n                self.lc_th2_phase = temp_th2\n\n                self.lc_phase_data = np.zeros((len(self.lc_t_phase),3))                \n                self.lc_phase_data[:,0] = self.lc_t_phase\n                self.lc_phase_data[:,1] = self.lc_th1_phase\n                self.lc_phase_data[:,2] = self.lc_th2_phase\n                \n            else:\n                self.lc_phase_data = np.zeros((2,3))\n                print 'LIMIT CYCLE CANDIDATE DOES NOT EXIST, err =',err\n                self.limit_cycle_exists = False\n                self.lc_t_phase = [-1,-1]\n                self.lc_th1_phase = [-1,-1]\n                self.lc_th2_phase = [-1,-1]\n\n        else:\n            self.lc_phase_data = np.zeros((2,3))\n            print 'LIMIT CYCLE CANDIDATE DOES NOT EXIST'\n            self.limit_cycle_exists = False\n            self.lc_t_phase = [-1,-1]\n            self.lc_th1_phase = [-1,-1]\n            self.lc_th2_phase = [-1,-1]\n\n\n\n        self.lc_phase_data[:,0] = self.lc_t_phase\n        self.lc_phase_data[:,1] = self.lc_th1_phase\n        self.lc_phase_data[:,2] = self.lc_th2_phase\n\n\n\n    def load_fq(self):\n        \"\"\"\n        if fq data exists, load. if DNE or recompute required, compute here.\n        \"\"\"\n        file_not_found = False\n\n        # load lc phase data\n        self.load_phase_lc()\n        \n        self.filename_fq = self.lcdir+'\/'+'fq.dat'\n\n        if self.limit_cycle_exists:\n            while True:\n                if self.recompute_fq or file_not_found:\n                    \"\"\"\n                    force recomputation of fq\n                    \"\"\"\n                    self.compute_fq() # contains self.fq_data\n                    np.savetxt(self.filename_fq,self.fq_data)\n                    break\n\n                else:\n                    if os.path.isfile(self.filename_fq):\n\n                        fq_data = np.loadtxt(self.filename_fq)\n\n                        break\n                    else:\n                        file_not_found = True\n        else:\n            print 'no fq data to generate'\n\n\n    def coeff_mat(self,t):\n        \"\"\"\n        coefficient matrix for linearized system\n        \"\"\"\n        h1x_th0,h1y_th0 = f2d.H1_fourier(self.phase_lc(t,1),self.phase_lc(t,2),d=True)\n        #h2x_th0,h2y_th0 = f2d.H2_fourier_centered(self.phase_lc(t,1),self.phase_lc(t,2),d=True)\n        h1x_0,h1y_0 = f2d.H1_fourier(0,0,d=True)\n        #h2x_0,h2y_0 = f2d.H2_fourier_centered(0,0,d=True)\n\n        #j1x_0=-h1x_0; j1y_0=-h1y_0\n        #j2x_0=-h2x_0; j2y_0=-h2y_0\n\n        #j1x_th0=-h1x_th0; j1y_th0=-h1y_th0\n        #j2x_th0=-h2x_th0; j2y_th0=-h2y_th0\n\n        \n        #print h1x_th0,self.phase_lc(t,1),self.phase_lc(t,2)\n\n        return np.array([[-self.q*h1x_th0 + self.g*h1x_0, -self.q*h1y_th0, -self.g, 0.],\n                         [-self.q*h1y_th0, -self.q*h1x_th0 + self.g*h1x_0, 0., -self.g],\n                         [h1x_0, 0.,   -1., 0.],\n                         [0.,    h1x_0, 0., -1.]])\n\n    def fq_rhs(self,y,t):\n        th1=y[0]; th2=y[1]; a1=y[2]; b1=y[3]\n\n        out = self.coeff_mat(t)\n\n        c11=out[0,0]; c12=out[0,1]; c13=out[0,2]; c14=out[0,3]\n        c21=out[1,0]; c22=out[1,1]; c23=out[1,2]; c24=out[1,3]\n        c31=out[2,0]; c32=out[2,1]; c33=out[2,2]; c34=out[2,3]\n        c41=out[3,0]; c42=out[3,1]; c43=out[3,2]; c44=out[3,3]\n        \n        #print c11, c22\n\n        return np.array([c11*th1 + c12*th2 + c13*a1 + c14*b1,\n                         c21*th1 + c22*th2 + c23*a1 + c24*b1,\n                         c31*th1 + c32*th2 + c33*a1 + c34*b1,\n                         c41*th1 + c42*th2 + c43*a1 + c44*b1])\n\n    def compute_fq(self):\n        \"\"\"\n        compute monodromy matrix and fq exp here\n        \"\"\"\n        #phase_lc(t,choice)\n        \n        # integrate over one period, i.e., self.lc_per\n        \n        #self.lc_per\n\n\n        t = np.linspace(0,self.lc_per,5000)\n        start_X = np.zeros((4,4))\n        end_X = np.zeros((4,4))\n        \n\n        print 'computing monodromy matrix'\n        for i in range(4):\n            print i+1,'of',4\n            # make start B the identity\n            start_X[i,i] = 1.\n            \n            # initialize accordingly\n            init = np.zeros(4)\n            init[i] = 1\n            sol = odeint(self.fq_rhs,init,t)\n            end_X[:,i] = sol[-1,:]\n\n            if False:\n                mp.figure()\n                mp.plot(t,sol[:,0])\n                mp.plot(t,sol[:,1])\n                mp.plot(t,sol[:,2])\n                mp.plot(t,sol[:,3])\n                mp.show()\n        \n        #start_X_inv = np.linalg.inv(start_X)\n        B = np.dot(start_X,end_X)\n\n        self.fq_data = np.absolute(np.linalg.eig(B)[0])\n        print self.fq_data\n        #print np.absolute(np.linalg.eig(self.fq_data)[0])\/self.lc_per\n\n\n\n    def H_i(self):\n        \"\"\"\n        interaction function of 2d bump\n        need u0b,f, du\/dx, du\/dy, domain as lookup tables.\n        u0b: ss bump\n        df_u0b: f'(u0b)\n        ux,uy: gradient of u0b\n        x: domain\n        i: h_i\n        params: \n        check_h: set True to force compute H_i and verify saved H_i.\n        \"\"\"\n\n        self.H_1_path = self.dir1+\"\/\"+self.ss_dir2+\"\/\"+\"H_1.dat\"\n        self.H_2_path = self.dir1+\"\/\"+self.ss_dir2+\"\/\"+\"H_2.dat\"\n\n        if (os.path.isfile(self.H_1_path) and os.path.isfile(self.H_2_path)) and not(self.recompute_h):\n            print '* H_i files found. Loading...'\n            H1 = np.loadtxt(self.H_1_path)\n            H2 = np.loadtxt(self.H_2_path)\n            print '  ... done.'\n\n        else:\n            print \"* Computing H_i...\"\n            H1 = np.zeros((self.N,self.N))\n            H2 = np.zeros((self.N,self.N))\n\n            for i in range(self.N):\n                stdout.write(\"\\r  ... building... %d%%\" % int((100.*(i+1)\/self.N)))\n                stdout.flush()\n                for j in range(self.N):\n                    temp1 = 0\n                    temp2 = 0\n\n                    # given x,y coordinates, compute double sum\n                    # \\int\\int_\\Omega f'(u0(y))\\grad u0(y) u0(y+x)dy\n                    for n in range(self.N):\n                        for m in range(self.N):\n                            #temp1 += self.ux[n,m]*self.df_u0b[n,m]*self.u0ss[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]\n                            #temp2 += self.uy[n,m]*self.df_u0b[n,m]*self.u0ss[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]\n\n                            temp1 += self.ux[n,m]*self.df_u0b[n,m]*self.u0ss[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]\n                            temp2 += self.uy[n,m]*self.df_u0b[n,m]*self.u0ss[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]\n                    H1[i,j] = temp1*((2*pi)**2)\/(self.N**2)\n                    H2[i,j] = temp2*((2*pi)**2)\/(self.N**2)\n            np.savetxt(self.H_1_path,H1)\n            np.savetxt(self.H_2_path,H2)\n\n        print\n        return H1, H2\n\n\n    def J_i(self):\n        \"\"\"\n        pinning approximation\n        interaction function of 2d bump\n        need u0b,f, du\/dx, du\/dy, I, domain as lookup tables.\n        u0b: ss bump\n        df_u0b: f'(u0b)\n        ux,uy: gradient of u0b\n        x: domain\n        I: pinning function\n        params: \n        check_J: set True to force compute J_i and verify saved J_i.\n        \n        \"\"\"\n        self.J_1_path = self.dir1+\"\/\"+self.ss_dir2+\"\/\"+\"J_1.dat\"\n        self.J_2_path = self.dir1+\"\/\"+self.ss_dir2+\"\/\"+\"J_2.dat\"\n\n        if (os.path.isfile(self.J_1_path) and os.path.isfile(self.J_2_path)) and not(self.recompute_j):\n            print '* J_i files found. Loading...'\n            J1 = np.loadtxt(self.J_1_path)\n            J2 = np.loadtxt(self.J_2_path)\n            print '  ... done.'\n            \n        else:\n            print \"* Computing J_i...\"\n            J1 = np.zeros((self.N,self.N))\n            J2 = np.zeros((self.N,self.N))\n        \n            for i in range(self.N):\n                stdout.write(\"\\r  ... building... %d%%\" % int((100.*(i+1)\/self.N)))\n                stdout.flush()\n                for j in range(self.N):\n                    temp1 = 0\n                    temp2 = 0\n\n                    # given x,y coordinates, compute double sum\n                    # \\int\\int_\\Omega I(y)f'(u0(y+x))\\grad u0(y+x)dy\n                    for n in range(self.N):\n                        for m in range(self.N):\n                            temp1 += self.ux[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]*self.df_u0b[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]*self.Itable[n,m]\n                            temp2 += self.uy[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]*self.df_u0b[np.mod(n+i+self.N\/2,self.N),np.mod(m+j+self.N\/2,self.N)]*self.Itable[n,m]\n                    J1[i,j] = temp1*((2*pi)**2)\/(self.N**2)\n                    J2[i,j] = temp2*((2*pi)**2)\/(self.N**2)\n            np.savetxt(self.J_1_path,J1)\n            np.savetxt(self.J_2_path,J2)\n\n        print\n        return J1,J2\n\n    def HJ_i_error(self):\n        \"\"\"\n        compute error between H_i, J_i lookup tables and Fourier approximations.\n        \"\"\"\n        \n        \"\"\"\n        fig = plt.figure()        \n        ax = fig.gca(projection='3d')\n        ax.set_title(\"h1_table\")\n        ax = plot_s(ax,self.XX,self.YY,self.H1)\n        \n        fig2 = plt.figure()\n        ax2 = fig2.gca(projection='3d')\n        ax2.set_title(\"h1_fourier\")\n        \n        ax2 = plot_s(ax2,XX9,YY9,f2d.H1_fourier(XX9,YY9))\n\n        plt.show()\n        \"\"\"\n\n        # cut off last entry to match table.\n        X9 = np.linspace(-pi,pi-2*pi\/self.N,self.N)\n        XX9, YY9 = np.meshgrid(X9,X9)\n        \n        err_h1 = np.amax(np.abs(self.H1 - f2d.H1_fourier(XX9,YY9)))\n        err_j1 = np.amax(np.abs(self.J1 + f2d.H1_fourier(XX9,YY9)))\n        return err_h1,err_j1\n\n\n    def get_contour_verts(self,cn):\n        \"\"\"\n        given contour plot, get the vertices.\n        \"\"\"\n        \n        contours = []\n        # for each contour line\n        for cc in cn.collections:\n            paths = []\n            # for each separate section of the contour line\n            for pp in cc.get_paths():\n                xy = []\n                # for each segment of that section\n                for vv in pp.iter_segments():\n                    xy.append(vv[0])\n                paths.append(np.vstack(xy))\n            contours.append(paths)\n\n        return contours\n\n    def kappa_estimate(self,verbose=False):\n        \"\"\"\n        check value of inner product (\\nabla u_0,u^*).\n        (u_0',u^*) = \\int_0^{2\\pi} \\int_0^{2\\pi} \\nabla u_0(x,y)\\cdot [f'(u_0(x,y)) \\nabla u_0(x,y)] dx dy\n        = \\int_0^{2\\pi} \\int_0^{2\\pi} f'(u_0(x,y)) \\nabla u_0(x,y) \\cdot \\nabla u_0(x,y) dx dy\n        = \\int_0^{2\\pi} \\int_0^{2\\pi} f'(u_0(x,y)) \\| \\nabla u_0(x,y) \\|**2 dx dy\n        \n        ss0,ss1,ss_shift: ss bump solution\n        \"\"\"\n\n        if verbose:\n            print '\\t building kappa'\n        tot = 0\n\n        for i in range(N):\n            for j in range(N):\n                tot += f(self.u0ss,self.r,self.ut,d=True)[i,j]*\\\n                       (self.ux[i,j]**2 + self.uy[i,j]**2)\n\n        tot \/= (self.N*self.N)\n\n        if verbose:\n            print '\\t... done.'\n            print '\\t inner product kappa_2 \\equiv (\\\\nabla u_0,u^*) =',tot\n\n        return tot\n\n    def twod_velocity(self,g,mode='phase',tol=5e-2,zero_vel_tol=1e-5):\n        \"\"\"\n        return nu1,nu2 given g. b is fixed at b=0.8\n        requires bifurcation data.\n        g: bifurcation parameter. adaptation strength\n        mode: 'phase' or 'full'. uses bifurcation data from full model or truncated phase model.\n\n        zero_vel_tol: if velocity in axial direction, ignore. If one of the velocities is below this small number, it means the movement is axial. in this case, ignore.\n\n        the parameters put into collect_disjoint_branches (remove_isolated, isolated_number, remove_redundant, etc) are finely tuned. do not change unless you know what you are doing!\n        \"\"\"\n\n        if mode == 'phase':\n            bif = np.loadtxt('twodphs3.ode.allinfo.dat')\n            #bif = np.loadtxt('twod_wave_trunc_exist_all.dat')\n            #bif2 = np.loadtxt('twod_wave_exist_br2.dat')\n            \n            # get all possible disjoint branches\n            val,ty = collect_disjoint_branches(bif,remove_isolated=True,isolated_number=50)\n        elif mode == 'full':\n            bif = np.loadtxt('twod_wave_exist_v2.dat')\n            #bif2 = np.loadtxt('twod_wave_exist_br2.dat')\n            \n            #bif_diag1 = np.loadtxt('twod_wave_exist_diag1.dat')\n            bif_diag2 = np.loadtxt('twod_wave_exist_diag_v2.dat')\n            \n            # get all possible disjoint branches\n            val,ty = collect_disjoint_branches(bif,remove_isolated=True,isolated_number=3,remove_redundant=False,N=10)\n            val_di,ty_di = collect_disjoint_branches(bif_diag2,remove_isolated=True,isolated_number=3,remove_redundant=False,N=10)\n\n            # combine dicts\n            for key in val_di.keys():\n                val[key+'d'] = val_di.pop(key)\n            for key in ty_di.keys():\n                ty[key+'d'] = ty_di.pop(key)\n            \n        for key in val.keys():\n            g_data = val[key][:,0]\n            v1_data = val[key][:,2]\n            v2_data = val[key][:,3]\n\n            smallest_diff = np.amin(np.abs(g-g_data))\n            min_idx = np.argmin(np.abs(g-g_data))\n\n            \n            if (smallest_diff < tol) and\\\n               (np.abs(v1_data[min_idx])>zero_vel_tol) and\\\n               (np.abs(v2_data[min_idx])>zero_vel_tol) and\\\n               (np.abs(v2_data[min_idx] - v1_data[min_idx])>zero_vel_tol):\n\n                tol = smallest_diff\n                v1 = v1_data[min_idx]\n                v2 = v2_data[min_idx]\n\n        return v1,v2\n\n    def parameteric_intersection(self):\n        \"\"\"\n        get the first intersection between two parametric curves\n        \"\"\"\n\n    def twod_velocity_v2(self,g,b,mode='trunc',\n                         tol=5e-2,\n                         diag_tol=5e-2,\n                         zero_vel_tol=1e-5,\n                         M_nu1 = 100,\n                         M_nu2 = 100,\n                         N = 200\n                     ):\n        \"\"\"\n        return nu1,nu2 given g and b.\n        does not depend on any bifurcation data.\n        g: bifurcation parameter. adaptation strength\n        b: Fourier coefficient\n        mode: 'trunc' or 'full'. uses full H function or truncated h function\n\n        zero_vel_tol: if velocity in axial direction, ignore. If one of the velocities is below this small number, it means the movement is axial. in this case, ignore.\n\n        solve:\n        (1) 0 = -\\nu_1 + g \\int_0^\\infty e^{-s} H_1(\\nu_1 s,\\nu_2 s) ds \n        (2) 0 = -\\nu_2 + g \\int_0^\\infty e^{-s} H_2(\\nu_1 s,\\nu_2 s) ds\n\n        \"\"\"\n\n        nu1 = np.linspace(0,3,M_nu1)\n        nu2 = np.linspace(0,3,M_nu2)\n        sint = np.linspace(0,N\/10,N)\n        \n        nu1,nu2,sint = np.meshgrid(nu1,nu2,sint)\n\n        N = np.shape(sint)[-1] # get size of integration variable array\n        sint_pos = len(np.shape(sint))-1# get position of integration var\n        \n        # get limits of integration\n        int_lo = sint[0,0,0]\n        int_hi = sint[0,0,-1]\n        dx = (int_hi-1.*int_lo)\/N\n        \n        if mode == 'trunc':\n            integrand1 = exp(-sint)*self.h1(nu1*sint,nu2*sint,b)\n            integrand2 = exp(-sint)*self.h2(nu1*sint,nu2*sint,b)\n\n        elif mode == 'full':\n            integrand1 = exp(-sint)*f2d.H1_fourier(nu1*sint,nu2*sint)\n            integrand2 = exp(-sint)*f2d.H2_fourier(nu1*sint,nu2*sint)\n        else:\n            raise ValueError('Invalid choice='+mode)\n\n        eq1 = -nu1[:,:,0] + g*integrand1.sum(sint_pos)*dx\n        eq2 = -nu2[:,:,0] + g*integrand2.sum(sint_pos)*dx\n        \n        # get contours\n\n        fig = plt.figure()\n        ax = fig.add_subplot(111)\n\n        cs1 = ax.contour(nu1[:,:,0],nu2[:,:,0],eq1,levels=[0.])\n        cs2 = ax.contour(nu1[:,:,0],nu2[:,:,0],eq2,levels=[0.])\n\n        p1_all = cs1.collections[0].get_paths()\n        p2_all = cs2.collections[0].get_paths()\n\n        p1x_dict = {}\n        p1y_dict = {}\n\n        p2x_dict = {}\n        p2y_dict = {}\n\n        # this block of code will separate all branches into dictionaries.\n        # redundant since we have two nontrivial curves.\n\n        # gather nontrival zero contour from first equation\n        for i in range(len(p1_all)):\n            v = p1_all[i].vertices\n            x = v[:,0]\n            y = v[:,1]\n            \n            if (np.sum(np.abs(x)) <= zero_vel_tol) or (np.sum(np.abs(y)) <= zero_vel_tol):\n                pass\n            else:\n                p1x_dict[str(i)] = x\n                p1y_dict[str(i)] = y\n\n        # gather nontrival zero contour from second equation\n        for i in range(len(p2_all)):\n            v = p2_all[i].vertices\n            x = v[:,0]\n            y = v[:,1]\n            if (np.sum(np.abs(x)) <= zero_vel_tol) or (np.sum(np.abs(y)) <= zero_vel_tol):\n                pass\n            else:\n                p2x_dict[str(i)] = x\n                p2y_dict[str(i)] = y\n\n        # warn user if there are more than 2 unique contours\n        if (len(p1x_dict) > 1) or\\\n           (len(p1y_dict) > 1) or\\\n           (len(p2x_dict) > 1) or\\\n           (len(p2y_dict) > 1):\n            raise ValueError('Warning: multiple zero contours detected. use the plot function in twod_velocity_v2')\n            print 'there should be 1 zero contour for each existence equation'\n\n\n        if (len(p1x_dict) < 1) or\\\n           (len(p1y_dict) < 1) or\\\n           (len(p2x_dict) < 1) or\\\n           (len(p2y_dict) < 1):\n            raise RuntimeError('Warning: no contours detected. use the plot function in twod_velocity_v2')\n            print 'there should be 1 zero contour for each existence equation'\n        \n        \n        if False:\n            mp.figure(5)\n            for key in p1x_dict.keys():\n                mp.plot(p1x_dict[key],p1y_dict[key])\n            for key in p2x_dict.keys():\n                mp.plot(p2x_dict[key],p2y_dict[key])\n\n            \n            mp.show()\n\n        # find contour intersection. we only need the first.\n        for key in p1x_dict.keys():\n            x1 = p1x_dict[key]\n            y1 = p1y_dict[key]\n            \n        for key in p2x_dict.keys():\n            x2 = p2x_dict[key]\n            y2 = p2y_dict[key]\n\n        # create the interpolated functions\n        t = np.linspace(0,1,len(x1))\n        z = np.zeros((2,len(x1)))\n        z[0,:] = x1\n        z[1,:] = y1\n        c1 = interp1d(t,z)\n\n        t = np.linspace(0,1,len(x2))\n        z = np.zeros((2,len(x2)))\n        z[0,:] = x2\n        z[1,:] = y2\n        c2 = interp1d(t,z)\n\n        def err(tt):\n            t1 = tt[0]\n            t2 = tt[1]\n            return c1(t1)-c2(t2)\n\n            \n\n        try:\n            t1,t2 = fsolve(err,x0=[.65,.75],factor=.01)\n        except ValueError:\n            print 'if you get the error, ValueError: A value in x_new is above the interpolation range. then modify starting times in def twod_velocity_v2 in twod_phase.py'\n\n        v1,v2 = c1(t1)\n\n\n        if False:\n            mp.figure()\n            z1 = c1(np.linspace(0,.6,10))\n            x1 = z1[0,:]\n            y1 = z1[1,:]\n            mp.plot(x1,y1)\n\n            z2 = c2(np.linspace(0,.9,10))\n            x2 = z2[0,:]\n            y2 = z2[1,:]\n            mp.plot(x2,y2)\n\n\n            mp.show()\n        \n        plt.clf()\n        return v1,v2\n\n        \n    def h1(self,x,y,b,d=False):\n        if d:\n            return cos(x)*(1+b*cos(y)),-b*sin(x)*sin(y)\n        else:\n            return sin(x)*(1+b*cos(y))\n\n    def h2(self,x,y,b,d=False):\n        if d:\n            return -b*sin(x)*sin(y),cos(y)*(1+b*cos(x))\n        else:\n            return sin(y)*(1+b*cos(x))\n\n    def evans(self,lam,sint,g=2.):\n        \"\"\"\n        evans function\n        all meshgrids size\/shape of (M,M,N)\n        lam: complex number, or meshgrid on complex domain (M values)\n        sint: integration variable. meshgrid on real domain (N values)\n        nu1,nu2: velocity values\n        \"\"\"\n\n\n\n        # get nu1,nu2 given g\n        print 'reminder: implement g to nu1,nu2 conversion'\n\n        # g=3\n        #nu1=1.21;nu2=2.09\n\n        # g=4\n        #nu1=1.45;nu2=2.54\n\n        b=.8\n\n        def h1(x,y,d=False):\n            if d:\n                return cos(x)*(1+b*cos(y)),-b*sin(x)*sin(y)\n            else:\n                return sin(x)*(1+b*cos(y))\n\n        def h2(x,y,d=False):\n            if d:\n                # sin(y)*(1+b*cos(x))\n                return -b*sin(x)*sin(y),cos(y)*(1+b*cos(x))\n            else:\n                return sin(y)*(1+b*cos(x))\n        \n        Q1,Q2 = f2d.H1_fourier(-nu1*sint,-nu2*sint,d=True)\n        Q3,Q4 = f2d.H2_fourier(-nu1*sint,-nu2*sint,d=True)\n        \n        #Q1,Q2 = h1(-nu1*sint,-nu2*sint,d=True)\n        #Q3,Q4 = h2(-nu1*sint,-nu2*sint,d=True)\n        \n        # Q3,Q4 should be same as Q4,Q3=H1_fourier(-nu2*sint,-nu2*sint,d=True)\n        \n        sam = ( exp(-lam*sint)-1 ) \/ lam\n        \n        N = np.shape(sint)[-1] # get size of integration variable array\n        sint_pos = len(np.shape(sint))-1# get position of integration var\n\n        Qhat1 = (np.exp(-sint)*Q1*sam).sum(sint_pos)\/N\n        Qhat2 = (np.exp(-sint)*Q2*sam).sum(sint_pos)\/N\n        Qhat3 = (np.exp(-sint)*Q3*sam).sum(sint_pos)\/N\n        Qhat4 = (np.exp(-sint)*Q4*sam).sum(sint_pos)\/N\n\n        # return the complex valued functions\n\n        return (1.\/g + Qhat1)*(1.\/g + Qhat4) - Qhat3*Qhat2\n\n\n    def evans_v2(self,al,be,sint,g=2.5,b=0.8,return_intermediates=False,mode='trunc'):\n        \"\"\"\n        evans function\n        all meshgrids size\/shape of (M,M,N)\n        al,be: real and imaginary parts of some eigenvalue\n        sint: integration variable. meshgrid on real domain (N values)\n        \"\"\"\n\n\n        # get nu1,nu2 given g\n\n        nu1,nu2=self.twod_velocity_v2(g,b,mode=mode)\n        print 'velocity',nu1,nu2, \"g=\"+str(g)+\", b=\"+str(b)\n\n        # g=4\n        #nu1=1.45;nu2=2.54\n\n        # g=3\n        #nu1=1.21;nu2=2.09\n\n        # g=2.5\n        #nu1=1.0712;nu2=1.8395\n\n        # g=2\n        #nu1=.91067;nu2=1.5529\n\n        # g=1.5\n        #nu1=.70711;nu2=1.2247\n\n        if mode == 'full':\n            Q1,Q2 = f2d.H1_fourier(-nu1*sint,-nu2*sint,d=True)\n            Q3,Q4 = f2d.H2_fourier(-nu1*sint,-nu2*sint,d=True)\n        \n        elif mode == 'trunc':\n            Q1,Q2 = self.h1(-nu1*sint,-nu2*sint,b,d=True)\n            Q3,Q4 = self.h2(-nu1*sint,-nu2*sint,b,d=True)\n            #Q3,Q4 = h1(-nu2*sint,-nu1*sint,d=True)\n\n        \n        # Q3,Q4 should be same as Q4,Q3=H1_fourier(-nu2*sint,-nu2*sint,d=True)\n        \n        samp = exp(-al*sint)*cos(-be*sint) - 1\n        samq = exp(-al*sint)*sin(-be*sint) \n        \n        N = np.shape(sint)[-1] # get size of integration variable array\n        sint_pos = len(np.shape(sint))-1# get position of integration var\n\n        # get limits of integration\n        int_lo = sint[0,0,0]\n        int_hi = sint[0,0,-1]\n        dx = (int_hi-1.*int_lo)\/N\n\n\n        ph1 = (np.exp(-sint)*Q1*samp).sum(sint_pos)*dx\n        qh1 = (np.exp(-sint)*Q1*samq).sum(sint_pos)*dx\n\n        ph2 = (np.exp(-sint)*Q2*samp).sum(sint_pos)*dx\n        qh2 = (np.exp(-sint)*Q2*samq).sum(sint_pos)*dx\n\n        ph3 = ph2\n        qh3 = qh2\n\n        ph4 = (np.exp(-sint)*Q4*samp).sum(sint_pos)*dx\n        qh4 = (np.exp(-sint)*Q4*samq).sum(sint_pos)*dx\n\n\n        # return the complex valued functions\n        alf = al[:,:,0]\n        bef = be[:,:,0]\n\n        e_re = (g**2.)*(ph1*ph4 - qh1*qh4 - ph2*ph3 + qh2*qh3) + g*(alf*(ph1+ph4) - bef*(qh1+qh4)) + alf**2.-bef**2.\n        e_im = (g**2.)*(ph1*qh4 + qh1*ph4 - qh2*ph3 - ph2*qh3) + g*(alf*(qh1+qh4) + bef*(ph1+ph4)) + 2.*alf*bef\n        \n        if return_intermediates:\n            return e_re,e_im,ph1,qh1,ph2,qh2,ph3,qh3,ph4,qh4\n        return e_re,e_im\n\n\n    def evans_zero_alpha(self,g,b,al,be,sint,real=True,tol=1e-2):\n        \"\"\"\n        return the real part of the input that yields a zero in the evans function.\n        \"\"\"\n\n\n\n        e_re,e_im = self.evans_v2(al,be,sint,\n                                  return_intermediates=False,g=g,b=b)\n    \n        fig = plt.figure()\n        ax = fig.add_subplot(111)\n\n        \n        cs1 = ax.contour(al[:,:,0],be[:,:,0],e_re,levels=[0.])\n        cs2 = ax.contour(al[:,:,0],be[:,:,0],e_im,levels=[0.])\n\n        if False:\n            intersection_example,contour_pts1,contour_pts2 = findIntersection(cs1,cs2,return_intermediates=True)\n            \n\n            plt.plot(contour_pts1[:,0]+.0001,contour_pts1[:,1]+.0001)\n            plt.plot(contour_pts2[:,0],contour_pts2[:,1])\n            plt.show()\n\n\n        p1_all = cs1.collections[0].get_paths()\n        p2_all = cs2.collections[0].get_paths()\n\n        p1x_dict_raw = {}\n        p1y_dict_raw = {}\n\n        p2x_dict_raw = {}\n        p2y_dict_raw = {}\n\n        # this block of code will separate all branches into dictionaries.\n\n        # gather nontrival zero contour from real part\n        for i in range(len(p1_all)):\n            v = p1_all[i].vertices\n            x = v[:,0]\n            y = v[:,1]\n\n            p1x_dict_raw[str(i)] = x\n            p1y_dict_raw[str(i)] = y\n\n        # gather nontrival zero contour from imaginary part\n        for i in range(len(p2_all)):\n            v = p2_all[i].vertices\n            x = v[:,0]\n            y = v[:,1]\n\n            p2x_dict_raw[str(i)] = x\n            p2y_dict_raw[str(i)] = y\n\n\n        if False:\n\n            mp.figure(5)\n            mp.title('original branches')\n            for key in p1x_dict_raw.keys():\n                mp.plot(p1x_dict_raw[key],p1y_dict_raw[key])\n            for key in p2x_dict_raw.keys():\n                mp.plot(p2x_dict_raw[key],p2y_dict_raw[key])\n\n            \n            #mp.show()\n        \n\n\n\n        # remove branches that cross the origin\n        p1x_dict = {}\n        p1y_dict = {}\n\n        for key in p1x_dict_raw.keys():\n            skipflag = False\n            for i in range(len(p1x_dict_raw[key])):\n                if np.abs(p1x_dict_raw[key][i]-p1y_dict_raw[key][i])<.01:\n                    skipflag = True\n\n            if not(skipflag):\n                p1x_dict[key] = p1x_dict_raw[key]\n                p1y_dict[key] = p1y_dict_raw[key]\n\n        p2x_dict = {}\n        p2y_dict = {}\n\n        for key in p2x_dict_raw.keys():\n            skipflag = False\n            for i in range(len(p2x_dict_raw[key])):\n                if np.abs(p2x_dict_raw[key][i]-p2y_dict_raw[key][i])<.01:\n                    skipflag = True\n\n            if not(skipflag):\n                p2x_dict[key] = p2x_dict_raw[key]\n                p2y_dict[key] = p2y_dict_raw[key]\n\n\n        if False:\n            mp.figure(6)\n            mp.title('remaining branches')\n            for key in p1x_dict.keys():\n                mp.plot(p1x_dict[key],p1y_dict[key])\n            for key in p2x_dict.keys():\n                mp.plot(p2x_dict[key],p2y_dict[key])\n\n            \n            mp.show()\n\n\n        # find contour intersection. if multiple mins found, take one with greater magnitude in complex plane\n        # find minimia by taking differences\n        \n        min_xs = []\n        min_ys = []\n\n        for key1 in p1x_dict.keys():\n            for key2 in p2x_dict.keys():\n                rex = p1x_dict[key1]\n                rey = p1y_dict[key1]\n                \n                imx = p2x_dict[key2]\n                imy = p2y_dict[key2]\n\n                if False:\n                    mp.figure()\n                    mp.plot(rex,rey,color='black',lw=3)\n                    mp.plot(imx,imy,color='gray',lw=3)\n                    \n                    mp.show()\n\n\n                newtol = tol\n                for i in range(len(rex)):\n                    diff_arr = (rex[i]-imx)**2. + (rey[i]-imy)**2.\n                    minval = np.amin(diff_arr)\n\n                    if minval < newtol:\n                        newtol = minval\n                        minx = rex[i]\n                        miny = rey[i]\n                        #print minx,miny\n                min_xs.append(minx)\n                min_ys.append(miny)\n\n            \"\"\"\n            smallest_diff = np.amin(np.abs(g-g_data))\n            min_idx = np.argmin(np.abs(g-g_data))\n \n             \n            if (smallest_diff < tol) and\\\n               (np.abs(v1_data[min_idx])>zero_vel_tol) and\\\n               (np.abs(v2_data[min_idx])>zero_vel_tol) and\\\n               (np.abs(v2_data[min_idx] - v1_data[min_idx])>zero_vel_tol):\n \n                tol = smallest_diff\n                v1 = v1_data[min_idx]\n                v2 = v2_data[min_idx]\n            \"\"\"\n\n        print 'minx,miny',min_xs,min_ys, 'for g,b=',g,b\n\n\n        \"\"\"\n        for key in p1x_dict.keys():\n            x1 = p1x_dict[key]\n            y1 = p1y_dict[key]\n            \n        for key in p2x_dict.keys():\n            x2 = p2x_dict[key]\n            y2 = p2y_dict[key]\n\n        # create the interpolated functions\n        t = np.linspace(0,1,len(x1))\n        z = np.zeros((2,len(x1)))\n        z[0,:] = x1\n        z[1,:] = y1\n        c1 = interp1d(t,z)\n\n        t = np.linspace(0,1,len(x2))\n        z = np.zeros((2,len(x2)))\n        z[0,:] = x2\n        z[1,:] = y2\n        c2 = interp1d(t,z)\n\n        def err(tt):\n            t1 = tt[0]\n            t2 = tt[1]\n            return c1(t1)-c2(t2)\n\n        t1,t2 = fsolve(err,x0=[.6,.8],factor=.01)\n\n        v1,v2 = c1(t1)\n\n\n        if False:\n            mp.figure()\n            z1 = c1(np.linspace(0,.6,10))\n            x1 = z1[0,:]\n            y1 = z1[1,:]\n            mp.plot(x1,y1)\n\n            z2 = c2(np.linspace(0,.9,10))\n            x2 = z2[0,:]\n            y2 = z2[1,:]\n            mp.plot(x2,y2)\n\n\n            mp.show()\n        \n        \"\"\"\n\n        # if no intersections, return nan\n        if (min_xs == []) or (min_ys == []):\n            return np.nan\n\n        # if two or more intersections, use the one with greatest magnitude in complex plane\n        min_xs = np.array(min_xs)\n        min_ys = np.array(min_ys)\n\n        if (len(min_xs) >= 2):\n            max_idx = np.argmax(min_xs**2. + min_yx**2.)\n            min_xs = [min_xs[max_idx]]\n            min_ys = [min_ys[max_idx]]\n                \n\n        if real:\n            return min_xs[0]\n        return min_xs[0],min_ys[0]\n\n\n\n    def plot(self,option=\"h1\"):\n\n        fig = plt.figure()\n        \n\n        if option == 'h1':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H1 (numerical)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n\n            ax = plot_s(ax,self.H1)\n\n\n        elif option == 'h2':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H2 (numerical)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.H2)\n            ax = plot_s(ax,self.H2)\n\n        elif option == 'j1':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"J1 (numerical)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,self.J1)\n\n        elif option == 'j2':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"J2 (numerical)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            ax = plot_s(ax,self.J2)\n\n        elif option == 'h1_approx2':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H1 (approx v2)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n\n            z = np.sin(self.XX)*.2+self.h1_approx(self.XX,self.YY,sig=4.)\n            ax = plot_s(ax,z\/2.)\n\n        elif option == 'evans':\n            M_re = 300\n            M_im = 300\n            N = 200\n\n            lam_re = np.linspace(-.25,1.,M_re)\n            lam_im = np.linspace(-.01,2,M_im)\n            sint = np.linspace(0,N\/10,N)\n\n            #LAM_re, LAM_im, SINT = np.meshgrid(lam_re,lam_im,sint,dtype=np.complex)\n            LAM_re, LAM_im, SINT = np.meshgrid(lam_re,lam_im,sint)\n\n            LAM_re_contour, LAM_im_contour = np.meshgrid(lam_re,lam_im)\n            \n            e_re,e_im = self.evans_v2(LAM_re,LAM_im,SINT,\n                                      return_intermediates=False,g=4.,b=.4)\n\n\n            ax = fig.add_subplot(111)\n\n            #e_re = np.cos(2*LAM_re_contour*pi)*np.sin(LAM_im_contour*pi)\n            #e_im = np.sin(2*LAM_re_contour*pi)*np.cos(LAM_re_contour*pi)\n\n            cs_re = ax.contour(LAM_re_contour,LAM_im_contour,e_re,levels=[0.])\n            cs_im = ax.contour(LAM_re_contour,LAM_im_contour,e_im,levels=[0.])\n\n            p = cs_re.collections[0].get_paths()[0]\n            v = p.vertices\n            x = v[:,0]\n            y = v[:,1]\n\n            cs_re.collections[0].set_color('black')\n            cs_re.collections[0].set_label('re')\n            cs_re.collections[0].set_linewidths(2)\n\n            cs_im.collections[0].set_color('gray')\n            cs_im.collections[0].set_label('im')\n            cs_im.collections[0].set_linewidths(2)\n\n            ax.legend()\n\n\n\n            # plot real and imag parts\n        \n        elif option == 'phase_time':\n            ax = fig.add_subplot(111)\n            ax.set_title(\"phase over time\")\n            ax.set_xlabel('t')\n            ax.set_ylabel(r\"$\\theta$\")\n            ax.plot(self.dde_t,np.mod(self.th1_ph+pi,2*pi)-pi)\n            ax.plot(self.dde_t,np.mod(self.th2_ph+pi,2*pi)-pi)\n\n        elif option == 'phase_space':\n            ax = fig.add_subplot(111)\n            ax.set_title(\"phase in space\")\n            ax.set_xlabel(r\"$x$\")\n            ax.set_ylabel(r\"$y$\")\n            #ax.set_xlim(-pi,pi)\n            #ax.set_ylim(-pi,pi)\n            #ax.plot(np.mod(self.th1_ph+pi,2*pi)-pi,np.mod(self.th2_ph+pi,2*pi)-pi)\n            \n            #ax.set_xlim(-pi,pi)\n            #ax.set_ylim(-pi,pi)\n            ax.plot(np.mod(self.th1_ph+pi,2*pi)-pi,np.mod(self.th2_ph+pi,2*pi)-pi)\n\n        elif option == 'h1_fourier':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H1 (Fourier)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,f2d.H1_fourier(self.XX,self.YY))\n\n        elif option == 'h2_fourier':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H2 (Fourier)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,f2d.H2_fourier(self.XX,self.YY))\n\n\n        elif option == 'h1_fourier_dx':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"dH1dx (Fourier)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            dh1x,hd1y = f2d.H1_fourier(self.XX,self.YY,d=True)\n            ax = plot_s(ax,dh1x)\n\n        elif option == 'h1_fourier_dy':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"dH1dy (Fourier)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            dh1x,hd1y = f2d.H1_fourier(self.XX,self.YY,d=True)\n            ax = plot_s(ax,dh1y)\n\n            \n        elif option == 'h1_1d':\n            ax = fig.add_subplot(111)\n            ax.plot([-pi,pi],[0,0],color='black')\n\n            ax.plot(self.X,-f2d.H1_fourier(self.X,self.X),label='-h1(x,x)',lw=3)\n            ax.plot(self.X,-f2d.H1_fourier(-self.X,-self.X),label='-h1(-x,-x)',lw=3)\n            ax.plot(self.X,-f2d.H1_fourier(self.X,-self.X),label='-h1(x,-x)',ls='--',lw=2)\n            ax.plot(self.X,-f2d.H1_fourier(-self.X,self.X),label='-h1(-x,x)',ls='--',lw=2)\n\n            ax.set_xlim(-pi,pi)\n            \n            handles, labels = ax.get_legend_handles_labels()\n            ax.legend(handles,labels)\n            #ax.plot(self.X,f2d.H1_fourier(self.X,0))\n\n        elif option == 'nullclines':\n            \n            # get contours\n            # http:\/\/stackoverflow.com\/questions\/18304722\/python-find-contour-lines-from-matplotlib-pyplot-contour\n            \n            ax = fig.add_subplot(111)\n            \n            h1_x0_idx_vals = np.where(np.diff(np.sign(-f2d.H1_fourier(self.X,self.X))))[0]\n            h1_x0_vals = self.X[h1_x0_idx_vals]\n            \n            t = np.linspace(0,100,1000)\n            \n            print h1_x0_vals\n            \n            for x0 in h1_x0_vals:\n                # run sim, get solution\n                sol = odeint(H_i_contour,[x0,x0],t)\n                ax.plot(sol[:,0],sol[:,1])\n            ax.plot(self.X,-f2d.H1_fourier(self.X,self.X))\n            ax.set_xlim(-pi,pi)\n            ax.set_ylim(-pi,pi)\n\n            \n\n\n        elif option == 'h1_centered_d':\n            h1_dx,h1_dy = f2d.H1_fourier_centered(self.XX,self.YY,d=True)\n\n            ax1 = fig.add_subplot(121,projection='3d')\n            ax1.set_title(\"H1 dx (Fourier, centered)\")\n            ax1.set_xlabel(\"x\")\n            ax1.set_ylabel(\"y\")\n            ax1 = plot_s(ax1,h1_dx)\n\n            ax2 = fig.add_subplot(122,projection='3d')\n            ax2.set_title(\"H1 dy (Fourier, centered)\")\n            ax2.set_xlabel(\"x\")\n            ax2.set_ylabel(\"y\")\n            ax2 = plot_s(ax2,h1_dy)\n\n            dx_val,dy_val = f2d.H1_fourier(0,0,d=True)\n            \n            print 'h1_fourier dx value at (0,0) =',dx_val\n            print 'h1_fourier dy value at (0,0) =',dy_val\n\n            dx_val,dy_val = f2d.H1_fourier(pi,pi,d=True)\n\n            print 'h1_fourier dx value at (pi,pi) =',dx_val\n            print 'h1_fourier dy value at (pi,pi) =',dy_val\n            \n\n        elif option == 'h1_fourier_d':\n            h1_dx,h1_dy = f2d.H1_fourier(self.XX,self.YY,d=True)\n\n            ax1 = fig.add_subplot(121,projection='3d')\n            ax1.set_title(\"H1 dx (Fourier)\")\n            ax1.set_xlabel(\"x\")\n            ax1.set_ylabel(\"y\")\n            ax1 = plot_s(ax1,h1_dx)\n\n            ax2 = fig.add_subplot(122,projection='3d')\n            ax2.set_title(\"H1 dy (Fourier)\")\n            ax2.set_xlabel(\"x\")\n            ax2.set_ylabel(\"y\")\n            ax2 = plot_s(ax2,h1_dy)\n\n            dx_val,dy_val = f2d.H1_fourier(0,0,d=True)\n            \n            print 'h1_fourier dx value at (0,0) =',dx_val\n            print 'h1_fourier dy value at (0,0) =',dy_val\n\n            dx_val,dy_val = f2d.H1_fourier(pi,pi,d=True)\n\n            print 'h1_fourier dx value at (pi,pi) =',dx_val\n            print 'h1_fourier dy value at (pi,pi) =',dy_val\n\n\n\n\n        elif option == 'h2_fourier_d':\n            h2_dx,h2_dy = f2d.H2_fourier(self.XX,self.YY,d=True)\n\n            ax1 = fig.add_subplot(121,projection='3d')\n            ax1.set_title(\"H2 dx (Fourier)\")\n            ax1.set_xlabel(\"x\")\n            ax1.set_ylabel(\"y\")\n            ax1 = plot_s(ax1,h2_dx)\n\n            ax2 = fig.add_subplot(122,projection='3d')\n            ax2.set_title(\"H2 dy (Fourier)\")\n            ax2.set_xlabel(\"x\")\n            ax2.set_ylabel(\"y\")\n            ax2 = plot_s(ax2,h2_dy)\n\n            dx_val,dy_val = f2d.H2_fourier(0,0,d=True)\n            \n            print 'h2_fourier dx value at (0,0) =',dx_val\n            print 'h2_fourier dy value at (0,0) =',dy_val\n\n            dx_val,dy_val = f2d.H1_fourier(pi,pi,d=True)\n\n            print 'h2_fourier dx value at (pi,pi) =',dx_val\n            print 'h2_fourier dy value at (pi,pi) =',dy_val\n\n\n\n        elif option == 'h2_fourier_dy':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H1 dx (Fourier)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,f2d.H2_fourier(self.XX,self.YY,d=True))\n            print 'h1_fourier dy value at (0,0) =',f2d.H2_fourier(0,0,d=True)\n            print 'h1_fourier dy value at (pi,pi) =',f2d.H2_fourier(pi,pi,d=True)\n\n        elif option == 'h1_approx':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H1 approx_p. phase_option=\"+str(self.phase_option))\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,self.h1_approx(self.XX,self.YY))\n\n        elif option == 'h2_approx':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"H2 approx_p. phase_option=\"+str(self.phase_option))\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            #ax = plot_s(ax,self.XX,self.YY,self.J1)\n            ax = plot_s(ax,self.h2_approx_p(self.XX,self.YY))\n\n            \n        elif option == 'test':\n            ax = fig.gca(projection='3d')\n            ax.set_title(\"abs(x)\")\n            ax.set_xlabel(\"x\")\n            ax.set_ylabel(\"y\")\n            ax = plot_s(ax,np.abs(self.XX))\n        else:\n            print 'option, ', option, ' not found.'\n\n        return fig\n\ndef H_i_contour(z,t,i=1):\n    x = z[0]\n    y = z[1]\n    \n    # get derivatives of fourier\n    if i == 1:\n        h1x,h1y = f2d.H1_fourier(x,y,d=True)\n        return -h1y,h1x\n    elif i == 2:\n        h2x,h2y = f2d.H2_fourier(x,y,d=True)\n        return -h2y,h2x\n\n\n\n#def main(screen):\ndef main(argv):\n\n    # process terminal flags\n    try:\n        opts, args = getopt.getopt(argv, \"lvserhpf\", [\"use-last\",\"save-last\",\"use-ss\",\"save-ss\",\"use-random\",\"help\",\"run-phase\",\"run-full\"])\n\n    except getopt.GetoptError:\n        usage()\n        sys.exit(2)\n\n    use_last=False;save_last=False;use_ss=False;save_ss=False;use_random=False\n    run_full=False;run_phase=False\n\n    if opts == []:\n        print \"Please run using flags -p (phase model) and\/or -f (full model)\"\n        usage()\n        sys.exit(2)\n\n    for opt, arg in opts:\n        if opt in (\"-h\", \"--help\"):\n\n            usage()\n            sys.exit()\n        else:\n            if opt in (\"-l\",\"--use-last\"):\n                use_last = True\n                print \"use_last=True\"\n            elif opt in ('-v','--save-last'):\n                save_last = True\n                print \"save_last=True\"\n            elif opt in ('-s','--use-ss'):\n                use_ss = True\n                print \"use_ss=True\"\n            elif opt in ('-e','save-ss'):\n                save_ss = True\n                print \"save_ss=True\"\n            elif opt in ('-r','use-random'):\n                use_random = True\n                print \"use_random=True\"\n            elif opt in ('-p','run-phase'):\n                run_phase = True\n                print \"run class phase=True\"\n            elif opt in ('-f','run-full'):\n                run_full = True\n                print \"run class theta (full sim)=True\"\n\n    \"\"\"\n    ktest = Kernel(recompute_kernel=False,kernel_type='diff_gauss')\n    ktest.plot()\n    plt.show()\n\n    u0b_test = SteadyState(recompute_ss=False)\n    u0b_test.plot(\"u0b\")\n    u0b_test.plot(\"u0b_grad_x\")\n    u0b_test.plot(\"u0b_grad_y\")\n\n    plt.show()\n    #phase = Phase(recompute_h=False,phase_option='approx2')\n    \"\"\"\n\n    if run_phase:\n        phase = Phase(x0=-2,x1=2.,y0=0,y1=0.0,\n                      init_mode='cartesian',\n                      q=0.,g=.989006,\n                      dde_dt=.05,\n                      dde_T=500,\n                      phase_option='full',\n                      recompute_h=False,recompute_j=False,\n                      recompute_fq=False,recompute_phase_lc=False,\n                      compute_h_error=False,\n                      save_last=save_last,\n                      use_last=use_last,\n                  )\n        \n        #phase.plot(\"h1_fourier\")\n        #phase.plot(\"h2_fourier\")\n\n        #phase.plot('h1')\n        #phase.plot('h2')\n\n        #phase.plot('h1_approx2')\n    \n        #phase.plot(\"h1_fourier_d\")\n        #phase.plot(\"h1_fourier_centered_d\")\n        #phase.plot(\"h2_fourier_d\")\n        \n        #phase.plot(\"nullclines\")\n        \n        #phase.plot(\"h1_approx\")\n        #phase.plot(\"h2_approx\")\n\n        phase.plot(\"phase_time\")\n        phase.plot(\"phase_space\")\n\n        #phase.plot('evans')\n\n        #phase.plot(\"h1_1d\")\n\n        #phase.plot('h1_fourier_dx')\n        #phase.plot('h2_fourier_dx')\n    \n        #phase.plot(\"j1\")\n        #phase.plot(\"j2\")\n        \n        #hettest = Heterogeneity()\n        #hettest.plot()\n\n\n\n    plt.show()\n\n\nif __name__ == \"__main__\":\n    main(sys.argv[1:])\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_364","text":"# cmd> snakeviz hi2lo.profile\n\nimport numpy as np\nimport scipy\nfrom imcut import pycut\nimport cProfile\n\n# import io3d\n\n\ndef make_data(sz=32, offset=0, sigma=80):\n    seeds = np.zeros([sz, sz, sz], dtype=np.int8)\n    seeds[offset + 12, offset + 9 : offset + 14, offset + 10] = 1\n    seeds[offset + 20, offset + 18 : offset + 21, offset + 12] = 1\n    img = np.ones([sz, sz, sz])\n    img = img - seeds\n\n    seeds[\n        offset + 3 : offset + 15, offset + 2 : offset + 6, offset + 27 : offset + 29\n    ] = 2\n    img = scipy.ndimage.morphology.distance_transform_edt(img)\n    segm = img < 7\n    img = (100 * segm + sigma * np.random.random(img.shape)).astype(np.uint8)\n    return img, segm, seeds\n\n\nimg, seg, seeds = make_data(64, 20)\nsegparams = {\n    # 'method':'graphcut',\n    # \"method\": \"multiscale_graphcut\",\n    # \"method\": \"hi2lo\",\n    \"method\": \"lo2hi\",\n    \"use_boundary_penalties\": False,\n    \"boundary_dilatation_distance\": 2,\n    \"boundary_penalties_weight\": 1,\n    \"block_size\": 8,\n    \"tile_zoom_constant\": 1,\n}\ngc = pycut.ImageGraphCut(img, segparams=segparams)\ngc.set_seeds(seeds)\ngc.run()\n# cProfile.run(\"gc.run()\")\n# import sed3\n# ed = sed3.sed3(gc.segmentation==0, contour=seg)\n# ed.show()\n\n# self.assertLess(\n#     np.sum(\n#         np.abs((gc.segmentation == 0).astype(np.int8) - seg.astype(np.int8))\n#     ),\n#     600,\n# )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_365","text":"<reponame>scdsr\/NCTU-CS-assignments<filename>DIP_2019_Spring\/Hw3\/test.py<gh_stars>1-10\nfrom __future__ import division\n\n### git@yash0307 ###\nimport tensorflow as tf\nfrom tensorflow import keras\n\nfrom skimage.segmentation import slic\nfrom skimage.segmentation import mark_boundaries\nfrom skimage.util import img_as_float\nfrom skimage import io, color\n\nfrom keras import applications\nfrom keras.preprocessing.image import ImageDataGenerator\nfrom keras import optimizers\nfrom keras.models import Sequential, Model, load_model\nfrom keras.layers import Dropout, Flatten, Dense, merge, Activation, Conv1D, Input, MaxPooling1D, Convolution1D\nfrom keras.layers.pooling import GlobalAveragePooling1D\nfrom keras.callbacks import LearningRateScheduler\nfrom keras.callbacks import ModelCheckpoint\nimport keras.backend as K\n'''\nfrom tensorflow.python.keras.layers import Dropout, Flatten, Dense, Activation, Conv1D, Input, MaxPooling1D, Convolution1D\nfrom tensorflow.python.keras import activations\nfrom tensorflow.python.keras import backend as K\n'''\nimport numpy as np\nimport math\nimport json\nimport sys\nimport random\nimport scipy.io as sio\nimport os\nfrom PIL import Image\nimport glob\n\n# print('tensorflow Ver: ' + tf.VERSION)\n# print('Keras Ver: ' +tf.keras.__version__)\n\ndef initialize_net(train_params):\n    '''\n    #tensorflow keras modification\n    model = tf.keras.Sequential()\n    \n    model.add(Conv1D(nb_filter=5, \n                filter_length=10, \n                init='glorot_uniform', \n                border_mode='same', \n                input_shape=(train_params['max_size'], 3), \n                bias=True))\n    \n    model.add(tf.keras.layers.Activation('tanh'))\n    \n    model.add(MaxPooling1D(pool_size=2))\n    \n    model.add(Conv1D(nb_filter=10,\n                filter_length=20, \n                init='glorot_uniform', \n                border_mode='same', \n                bias=True))\n                \n    model.add(tf.keras.layers.Activation('tanh'))\n    \n    model.add(MaxPooling1D(pool_size=2))\n    \n    model.add(Conv1D(nb_filter=20,\n                filter_length=20,\n                init='glorot_uniform',\n                border_mode='same',\n                bias=True))\n    model.add(tf.keras.layers.Activation('tanh'))\n    \n    model.add(MaxPooling1D(pool_size=2))\n    \n    model.add(GlobalAveragePooling1D(input_shape=model.output_shape[1:]))\n    \n    model.add(Dense(input_dim=20, \n            output_dim=2,\n            init='glorot_uniform'))\n            \n    model.add(tf.keras.layers.Activation('tanh'))\n    \n    model.add(Dropout(0.3))\n    \n    model.add(Dense(input_dim=2, \n            output_dim=2, \n            init='glorot_uniform'))\n            \n    model.add(tf.keras.layers.Activation('softmax'))\n    '''     \n    model = Sequential()    \n    model.add(Conv1D(nb_filter=5, \n                filter_length=10, \n                init='glorot_uniform', \n                border_mode='same', \n                input_shape=(train_params['max_size'], 3), \n                bias=True))\n    \n    model.add(Activation('tanh'))\n    \n    model.add(MaxPooling1D(pool_size=2))\n    model.add(Conv1D(nb_filter=10,\n                filter_length=20, \n                init='glorot_uniform', \n                border_mode='same', \n                bias=True))     \n    model.add(Activation('tanh'))\n    model.add(MaxPooling1D(pool_size=2))\n    \n    model.add(Conv1D(nb_filter=20,\n                filter_length=20,\n                init='glorot_uniform',\n                border_mode='same',\n                bias=True))\n    model.add(Activation('tanh'))\n    model.add(MaxPooling1D(pool_size=2))\n    model.add(GlobalAveragePooling1D(input_shape=model.output_shape[1:]))\n    \n    model.add(Dense(input_dim=20, \n            output_dim=2,\n            init='glorot_uniform'))\n    model.add(Activation('tanh'))\n    model.add(Dropout(0.3))\n    \n    model.add(Dense(input_dim=2, \n            output_dim=2, \n            init='glorot_uniform'))\n    model.add(Activation('softmax'))\n\n    return model\n\ndef initialize_params(train_data, data):\n    print('neg_samples', len(data[0]))\n    print('pos_samples', len(data[1]))    \n    train_params = {'batch_size':256, \n            'max_size':256, \n            'base_lr':0.001, \n            'decay_steps':5,\n            'decay_factor':0.5, \n            'num_epochs':15, \n            'neg_samples':len(data[0]), \n            'pos_samples':len(data[1]), \n            'total_samples':len(data[0])+len(data[1]), \n            'checkpoint':1}\n\n    return train_params\n\ndef get_train_data(train_data, train_labels):\n    data = {1:[], 0:[]}\n    num_images = train_data.shape[1]\n    for i in range(0, num_images):\n        given_image_sp = train_data[0][i]\n        # print('given_image_sp',len(given_image_sp))\n        given_image_lb = train_labels[i][0]\n        # print('given_image_lb',len(given_image_lb))\n        num_sp = given_image_lb.shape[1]\n        for j in range(0, num_sp):\n            given_label = given_image_lb[0][j]\n            given_rep = np.asarray(given_image_sp[j][:], dtype='float')\n            #print('given_rep: ',given_rep)\n            if given_label == 0:\n                #given_rep = np.asarray(given_image_sp[j][:], dtype='float')\n                #print('given_label == 0')\n                data[0].append(given_rep)\n            elif given_label == 1:\n                #given_rep = np.asarray(given_image_sp[j][:], dtype='float')\n                #print('given_label == 1')\n                data[1].append(given_rep)\n            else:\n                print('SOMETHING IS WRONG !')\n    return data\n\ndef load_data(data, train_params):\n    data_frac = 0.5\n    X_temp = np.zeros((train_params['batch_size'], train_params['max_size'], 3))\n    Y_temp = np.zeros((train_params['batch_size'], 2))\n    #print('population: ', range(0,train_params['pos_samples']))\n    #print('sample: ',int(train_params['batch_size']*data_frac+2))\n    idx = random.sample(range(0,train_params['pos_samples']), int(train_params['batch_size']*data_frac+2))\n    for i in range(0, int(train_params['batch_size']*data_frac)):\n        Y_temp[i][1] = float(1)\n        sam = data[1][idx[i]]\n        sam_len = sam.shape[0]\n        X_temp[i, :sam_len, :] = np.true_divide(sam, sam.max())\n    idx = random.sample(range(0, train_params['neg_samples']), int(train_params['batch_size']-(train_params['batch_size']*data_frac)+2))\n    for i in range(int(train_params['batch_size']*data_frac), train_params['batch_size']):\n        Y_temp[i][0] = float(1)\n        sam = data[0][idx[i-int(train_params['batch_size']*data_frac)]]\n        sam_len = sam.shape[0]\n        X_temp[i, :sam_len, :] = np.true_divide(sam, sam.max())\n        X = np.zeros((train_params['batch_size'], train_params['max_size'], 3))\n        Y = np.zeros((train_params['batch_size'], 2))\n    perm_idx = np.random.permutation(train_params['batch_size'])\n    for i in range(0, train_params['batch_size']):\n        X[i,:,:] = X_temp[perm_idx[i],:,:]\n        Y[i,:] = Y_temp[perm_idx[i],:]\n    return (X,Y)\n    print('----write result, read mats')\n    f_out = open(resultFile,'w')\n    train_data = sio.loadmat(all_Q_mat)['all_Q']\n    train_labels = sio.loadmat(superpixel_label_mat)['all_superpixel_labels']\n    print('----get_train_data')    \n    data = get_train_data(train_data, train_labels)\n    print(len(data))\n    print('----initialize_params')\n    train_params = initialize_params(train_data, data)\n    print('----initialize_net')\n    model = initialize_net(train_params)\n    model.summary()\n    print('----model compile')\n    model.compile(loss='categorical_crossentropy',\n        optimizer=optimizers.Adam(lr=train_params['base_lr']),\n        metrics=['accuracy'])\n    print('----ImageDataGenerator')\n    train_datagen = ImageDataGenerator(\n                featurewise_center=True,\n                featurewise_std_normalization=True)\n\n    for epoch in range(0, train_params['num_epochs']):\n        num_iterations = int(train_params['total_samples']\/train_params['batch_size']) + 1\n        for iteration in range(0, num_iterations):\n            print ('Epoch : ' + str(epoch) + ' | Iteration : ' + str(iteration))\n            given_data = load_data(data, train_params)\n            X = given_data[0]\n            Y = given_data[1]\n            model.fit(X,Y,\n                epochs=1,\n                verbose=1)\n        if epoch%train_params['decay_steps'] == 0 and epoch != 0:\n            print (' Changing learning rate ... ')\n            lr = K.get_value(model.optimizer.lr)\n            K.set_value(model.optimizer.lr, lr*train_params['decay_factor'])\n            print(\"lr changed to {}\".format(lr*train_params['decay_factor']))\n        if epoch%train_params['checkpoint'] == 0 and epoch != 0:\n            print (' Saving model ... ')\n            model_name = 'model_' + str(epoch) + '.h5'\n            model.save(model_name)\n        if epoch%1 == 0:\n            acu_pos = 0\n            acu_neg = 0\n            acu = 0\n            for i in range(0, int(train_params['pos_samples']\/train_params['batch_size'])):\n                X = np.zeros((train_params['batch_size'], train_params['max_size'], 3))\n                Y = np.zeros((train_params['batch_size'], 2))\n                for j in range(0, train_params['batch_size']):\n                    sam = data[1][i*train_params['batch_size'] + j]\n                    sam_len = sam.shape[0]\n                    X[j, :sam_len, :] = np.true_divide(sam, sam.max())\n                    Y[j][1] = float(1)\n                pred = model.evaluate(X,Y, \n                        batch_size=train_params['batch_size'])\n                print(pred)\n                acu_pos = acu_pos + pred[1]\n                acu = acu + pred[1]\n            for i in range(0, int(train_params['neg_samples']\/train_params['batch_size'])):\n                X = np.zeros((train_params['batch_size'], train_params['max_size'], 3))\n                Y = np.zeros((train_params['batch_size'], 2))\n                for j in range(0, train_params['batch_size']):\n                    sam = data[0][i*train_params['batch_size'] + j]\n                    sam_len = sam.shape[0]\n                    X[j, :sam_len, :] = np.true_divide(sam, sam.max())\n                    Y[j][0] = float(1)\n                pred = model.evaluate(X,Y, \n                        batch_size=train_params['batch_size'])\n                print(pred)\n                acu_neg = acu_neg + pred[1]\n                acu = acu + pred[1]\n            acu_pos = float(acu_pos)\/float(int(train_params['pos_samples']\/train_params['batch_size'])) \n            acu_neg = float(acu_neg)\/float(int(train_params['neg_samples']\/train_params['batch_size']))\n            acu = float(acu)\/float(int(train_params['pos_samples']\/train_params['batch_size']) + int(train_params['neg_samples']\/train_params['batch_size']))\n            f_out.write('acu_pos: ' + str(acu_pos)+', acu_neg: '+str(acu_neg)+', acu:'+str(acu)+'\\n')\n\n'''\ndef label2idx(img_mat,N):\n    print('------label 2 index processing------')   \n    #labelset\n    idx_1d= np.arange(1,img_mat.size+1,1)\n    #ind_eleMap=np.reshape(idx_1d, (img_mat.shape))\n    #print(idx_1d)\n    #ind_eleMap=np.zeros_like(img_mat)\n    ind_eleMap=np.reshape(idx_1d,(img_mat.shape))\n    #print(ind_eleMap)\n    for pix in range(1,N):\n        #np.where(a < 5, a, 10*a)\n        bin_elementMap=np.where(img_mat==pix,1,0)\n        remain_ele=np.trim_zeros(ind_eleMap*bin_elementMap)\n        np.concatenate(labelset, remain_ele,axis=0)\n        #print(vect)\n        #print(bin_elementMap)\n'''\ndef gaussian_weight(X,mu,sigma):\n    return math.exp((-1\/(2*sigma*sigma))*((X-mu)*(X-mu)));\n\ndef slicSeg(srcFiles_img,srcFiles_labels,img_mat,lbl_mat):\n    #suerpixel extraction\n    # Define hyperparameters\n    dist_sigma = 10; #sigma for gaussian distance weight in Part 1\n    gauss_weight = 1;\n    numSegments=200\n    \n    # srcFiles_img = dir('G:\\SPFExtarct\\MSRA10K_Imgs_GT\\MSRA10K_Imgs_GT\\Imgs\\*.jpg');\n    # srcFiles_labels = dir('G:\\SPFExtarct\\MSRA10K_Imgs_GT\\MSRA10K_Imgs_GT\\Imgs\\*.png');\n    # may add some normalization to distance weight\n    #path, dirs, files = next(os.walk(srcFiles_img+'\/*.jpg'))\n    #file_count = len(files)\n    dir_img=glob.glob(srcFiles_img)\n    dir_lbl=glob.glob(srcFiles_labels)\n    filenum=3\n    # filenum=len(dir_img)\n    all_Q={}\n    all_superpixel_labels={}\n    #for img in glob.glob(srcFiles_img):\n    for a in range(0,filenum):\n        sp_tx = '--superpixel segmentation for image: %s--' % (a+1)\n        print(sp_tx)\n        # read image\n        #print(dir_img[i])\n        #print(dir_lbl[i])\n        print(a)\n        path_img=dir_img[a]\n        path_lbl=dir_lbl[a]\n        im_image = io.imread(path_img)\n        #print(im_image)\n        im_label = io.imread(path_lbl)\n        #print(im_label)\n        #[L,N] = superpixels(im_lab,200,'IsInputLab',1);\n        # L= label numbers, N = superpixel numbers \n        # im_lab = rgb2lab(im);\n        L = slic(img_as_float(im_image), n_segments = numSegments) #include the lab convert\n        L=L+1 # start from 1\n        N=np.amax(L)\n        print('superpixel segment number: ', N)\n\n    # Vectorize superpixels in R and make mean color vector for each r\n        print('----mean color calculation----')\n        #im_size = io.imread(path_img).size;\n        C = np.zeros((N,3));\n        #r_val=im_image[:,:,0]\n        #g_val=im_image[:,:,1]\n        #b_val=im_image[:,:,2]\n        for i in range(1,N):\n            #print(np.where(L==i,1,0))\n            #r_val=im_image(:,:,0)\n            #g_val=im_image(:,:,1)\n            #b_valim_image(:,:,2)\n            red_spi_value=np.mean(im_image[(np.where(L==i,1,0)==1),0])\n            green_spi_value=np.mean(im_image[(np.where(L==i,1,0)==1),1])\n            blue_spi_value=np.mean(im_image[(np.where(L==i,1,0)==1),2])\n            #r_val_txt= 'sp:%s, r_val: %s'% (i,red_spi_value)\n            #print(r_val_txt)\n            \n            C[i,:]=[red_spi_value, green_spi_value, blue_spi_value];\n            #np.append(C,[red_spi_value, green_spi_value, blue_spi_value], axis=0)\n        #print(C)\n        print('----mean color calculation: done!----')\n    \n    # Find the superpixel center for each region r\n        print('----center position calculation----')\n        #P = np.zeros((N,1));\n        segments_ids = np.unique(L)\n        #print('sp segments id: ', segments_ids)\n        # centers\n        #label_idx = label2idx(L,N);\n        for i in range(1,N):\n            centers = np.round(np.array([np.mean(np.nonzero(L==i),axis=1) for i in segments_ids]))\n            #P(i,1) = round(mean(label_idx{i}));\n        #print(centers)\n        print('----center position calculation: done!----')\n    \n    # Make contrast separation vector Q by comparing each superpixel\n        print('----mat obtaining----')\n        Q_color = np.zeros((N,N,3))\n        Q = np.zeros((N,N,3))\n        dist = np.zeros((N,N))\n        \n        for i in range(1,N):\n            for j in range(1,N):\n                p_i=centers[i]\n                p_j=centers[j]\n                #dist(i,j) = norm(p_i - p_j);\n                dist[i,j] = np.linalg.norm(p_i - p_j);\n                #dist_txt='i: %s, j: %s, Euc distance: %s'% (p_i,p_j,dist[i,j])\n                #print(dist_txt)\n                #print('----distance of inter-superpixel: finished----')\n                #count of unit number in each superpixel\n                t_j = np.sum((L==j).astype(int)) #np.sum([np.nonzero(L==j)]) #numel(label_idx{j});\n                dist_weight = gaussian_weight(dist[i,j],0,dist_sigma);\n                #print(t_j)\n               \n                Q[i,j,0] = t_j*abs(C[i,0]-C[j,0])*gauss_weight*dist_weight;\n                Q[i,j,1] = t_j*abs(C[i,1]-C[j,1])*gauss_weight*dist_weight;\n                Q[i,j,2] = t_j*abs(C[i,2]-C[j,2])*gauss_weight*dist_weight;\n                #print('----Q weighted by distance: finished----')\n            \n            #print(dist[i,:])\n            #print(np.argsort(dist[i,:],axis=0))\n            #[~,I] = sort(dist(i,:)];\n            I=np.argsort(dist[i,:],axis=0)\n            Q_color[i,:,:] = Q[i,I,:]\n            #print('----Q_color weighted by distance: finished----')  \n        #all_Q(1,a) = {Q_color};\n        #print(Q_color)\n        all_Q = dict(zip([1,a], Q_color)) #{Q_color}\n        print('------all_Q obtaining: done!------')\n        \n        \n        #label\n        superpixel_label = np.zeros((1,N))\n        im_bw=im_label #binary\n        for j in range(1,N): #1:size(label_idx,1)\n            #label_idx_j = label_idx{j};\n            label_region = L==j\n            if ( np.count_nonzero(label_region)>np.count_nonzero(~label_region) ):\n                superpixel_label[1,j]= 1;\n                  \n        all_superpixel_labels = dict(zip([a,1], superpixel_label))  #transpose\n        print('------all_superpixel_labels obtaining: done!------')\n        \n    #save imagelists and segmentation labels \n    #save('all_Q.mat','all_Q');\n    \n    sio.savemat(img_mat,{'all_Q':all_Q});\n    print('--save mat: All_Q.mat done!--')\n    \n    sio.savemat(lbl_mat,{'all_superpixel_labels':all_superpixel_labels});\n    print('--save mat: all_superpixel_labels.mat done!--')\n    \ndef testing_eval(testingResult,testingQmat,testingLabelmat):\n    f_out = open(testingResult,'w')\n    train_data = sio.loadmat(testingQmat)['all_Q']\n    train_labels = sio.loadmat(testingLabelmat)['all_superpixel_labels']\n    data = get_train_data(train_data, train_labels)\n    train_params = initialize_params(train_data, data)\n\n    model = load_model('model_4.h5')\n    num_images = train_data.shape[1]\n    actual_images=0;\n    avg_acu = 0\n    out_mat = np.zeros((num_images, train_params['max_size']))\n    try:\n        for i in range(0, num_images):\n            given_image_sp = train_data[0][i]\n            given_image_lb = train_labels[i][0]\n            num_sp = given_image_lb.shape[1]\n            acu = 0\n            for j in range(0, num_sp):\n                given_label = given_image_lb[0][j]\n                X = np.zeros((1,train_params['max_size'], 3))\n                if given_label == 0:\n                    given_rep = np.asarray(given_image_sp[j][:], dtype='float')\n                    sam_len = given_rep.shape[0]\n                    #X[0,:sam_len, :] = np.true_divide(given_rep, given_rep.max())\n                    if (given_rep.max()==0):\n                        X[0,:sam_len, :] = given_rep\n                    else:\n                        X[0,:sam_len, :] = np.true_divide(given_rep, given_rep.max())                    \n                    pred = model.predict(X)\n                    pred_idx = np.where(pred == pred.max())[1][0]\n                    #if (pred.max() < 0.60) and (pred_idx == 1): # constraint\n                        # pred_idx = 0\n                    out_mat[i][j] = pred_idx\n                    if pred_idx == given_label:\n                        acu += 1\n                    else:\n                        pass\n                elif given_label == 1:\n                    given_rep = np.asarray(given_image_sp[j][:], dtype='float')\n                    sam_len = given_rep.shape[0]\n                    #X[0,:sam_len, :] = np.true_divide(given_rep, given_rep.max())\n                    if (given_rep.max()==0):\n                        X[0,:sam_len, :] = given_rep\n                    else:\n                        X[0,:sam_len, :] = np.true_divide(given_rep, given_rep.max())\n                    pred = model.predict(X)\n                    pred_idx = np.where(pred == pred.max())[1][0]\n                    out_mat[i][j] = pred_idx\n                    if pred_idx == given_label:\n                        acu += 1\n                    else:\n                        pass\n                else:\n                    print('SOMETHING IS WRONG !')\n                    sys.exit(1)\n            acu = float(acu)\/float(num_sp)\n            print('Given Image Acu: ' + str(acu))\n            avg_acu = avg_acu + acu\n            actual_images +=1\n            f_out.write('acu:'+str(acu)+'\\n')\n    except IndexError:\n        avg_acu = float(avg_acu)\/float(actual_images)\n        print('(Index Except) Over Acu: ' + str(avg_acu))\n        #sio.savemat('.\/Test_predict.mat', mdict={'predict_mat':pred})    \n        sio.savemat('.\/Test_out.mat', mdict={'out_mat':out_mat})\n        f_out.write('(Index Except) Over Acu:'+str(avg_acu)+'\\n')\n    else:    \n        avg_acu = float(avg_acu)\/float(num_images)\n        print('Over Acu: ' + str(avg_acu))\n        #sio.savemat('.\/Test_predict.mat', mdict={'predict_mat':pred})    \n        sio.savemat('.\/Test_out.mat', mdict={'out_mat':out_mat})\n        f_out.write('Over Acu:'+str(avg_acu)+'\\n')\n\nif __name__ == '__main__':\n    \n    #SLIC mat information\n    '''\n    train_image='..\/MSRA10K_Imgs_GT\/Imgs\/*.jpg'\n    train_mask='..\/MSRA10K_Imgs_GT\/Imgs\/*.png'\n    test_image='..\/testing\/*.jpg'\n    test_mask='..\/testing\/*.png'\n    slicSeg(train_image,train_mask,train_image_mat,train_mask_mat)\n    slicSeg(test_image,test_mask,test_image_mat,test_mask_mat)\n    '''\n    # make_superpixel_labels()\n    #input data directory path training\n    train_image_mat='..\/train\/all_Q.mat'\n    train_mask_mat='..\/train\/all_superpixel_labels.mat'\n    #testing\n    test_image_mat='..\/test\/all_Q.mat'\n    test_mask_mat='..\/test\/all_superpixel_labels.mat'\n\n    # training\n    #readSLICandMDLInit('train_result.txt',train_image_mat,train_mask_mat)\n    #testing\n    testing_eval('test_results.txt',test_image_mat,test_mask_mat)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_366","text":"<filename>src\/metrics.py\nimport numpy as np\nimport pandas as pd\n\ndef annualizedRet(r, num_periods):\n    '''\n\n    @param r: series, returns\n    @param num_periods: scalar, number of periods in return series\n    @return: scalar, annualized return\n    '''\n\n    comp = (1 + r).prod()\n    nPer = r.shape[0]\n    return comp ** (num_periods \/ nPer) - 1\n\ndef annualizedVol(r, num_periods, downside = False):\n    '''\n\n    @param r: series, returns\n    @param num_periods: scalar, number of periods in return series\n    @param downside: bool, for downside std\n    @return: scalar, annualized volatility\n    '''\n\n    if downside:\n        semistd = r[r < 0].std()\n        return semistd * (num_periods ** 0.5)\n    else:\n        return r.std() * (num_periods ** 0.5)\n\n\ndef drawdown(r: pd.Series):\n    '''\n\n    @param r: series, returns\n    @return: dictionary: 'hwm':high watermark, 'drawdowns': drawdown periods\n    '''\n\n    index = 1000 * (1 + r).cumprod()\n    highwatermark = index.cummax()\n    drawdowns = (index - highwatermark) \/ highwatermark\n    return pd.DataFrame(dict(hwm = highwatermark,\n                             drawdowns=drawdowns))\n\ndef skewness(r):\n    '''\n\n    @param r: series, returns\n    @return: scalar, third moment\n    '''\n    centerMoment = r - r.mean()\n    sigR = r.std(ddof=0)\n    exp = (centerMoment ** 3).mean()\n    return exp \/ sigR ** 3\n\ndef kurtosis(r):\n    '''\n\n    @param r: series, returns\n    @return: scalar, fourth moment\n    '''\n\n    centerMoment = r - r.mean()\n    sigR = r.std(ddof=0)\n    exp = (centerMoment ** 4).mean()\n    return exp \/ sigR ** 4\n\ndef varGaussian(r, level=5, modified=False):\n    '''\n\n    @param r: series, returns\n    @param level: scalar, significance level\n    @param modified: bool, taylor expansion and approximation of the VAR\n    @return: scalar, percentage of portfolio Value at Risk\n    '''\n    from scipy.stats import norm\n    z = norm.ppf(level \/ 100)\n\n    if modified is True:\n        s = skewness(r)\n        k = kurtosis(r)\n        z = (z +\n             (z ** 2 - 1) * s \/ 6 +\n             (z ** 3 - 3 * z) * (k - 3) \/ 24 -\n             (2 * z ** 3 - 5 * z) * (s ** 2) \/ 36\n             )\n    return - (r.mean() + z * r.std(ddof=0))\n\ndef sharpeRatio(r, rf, num_periods):\n    '''\n\n    @param r: series, returns\n    @param rf: scalar or series, of risk-free rate proxy\n    @param num_periods: scalar, number of periods\n    @return: scalar, risk-adjusted return\n    '''\n    # convert the annual riskfree to per period\n    rf = (1 + rf) ** (1 \/ num_periods) - 1\n    excessRets = r - rf\n    annExcessRets = annualizedRet(excessRets, num_periods)\n    annVol = annualizedVol(r, num_periods)\n    return annExcessRets \/ annVol\n\ndef sortinoRatio(r,rf, num_periods):\n    '''\n\n    @param r: series, returns\n    @param rf: scalar or series, of risk-free rate proxy\n    @param num_periods: scalar, number of periods\n    @return: scalar, risk-adjusted return\n    '''\n\n    rf = (1 + rf) ** (1 \/ num_periods) - 1\n    excessRets = r - rf\n    annExcessRets = annualizedRet(excessRets, num_periods)\n    anndownsideVol = annualizedVol(r, num_periods, downside=True)\n    return annExcessRets \/ anndownsideVol\n\ndef summary_stats(r, riskFree=0, periodsInYear=252):\n    '''\n\n    @param r: series, return\n    @param riskFree: scalar or series, of risk-free rate proxy\n    @param num_periods: scalar, number of periods\n    @param title: string, title of the returned df\n    @return: DataFrame of summary statistics\n    '''\n\n    if not isinstance(r,pd.DataFrame):\n        r = pd.DataFrame(r)\n\n    annR = r.aggregate(annualizedRet, num_periods= periodsInYear)\n    annVol = r.aggregate(annualizedVol, num_periods= periodsInYear)\n    dd = r.aggregate(lambda r: drawdown(r).drawdowns.min())\n    skew = r.aggregate(skewness)\n    kurt = r.aggregate(kurtosis)\n    modVar = r.aggregate(varGaussian, level=5, modified=True)\n    sharpe = r.aggregate(sharpeRatio, rf=riskFree, num_periods = periodsInYear)\n    sortino = r.aggregate(sortinoRatio, rf = riskFree, num_periods = periodsInYear)\n\n    stats = pd.DataFrame({\n        'Annualized Returns': annR*100,\n        'Annualized Volatility':  annVol*100,\n        'Sharpe Ratio': sharpe,\n        'Sortino Ratio': sortino,\n        'Max Drawdown':  dd*100,\n        'Skewness': skew,\n        'Kurtosis': kurt,\n        'Cornish Fisher adj. VAR 5%': modVar*100,\n    })\n\n    #formatting\n    stats['Annualized Returns'] = stats['Annualized Returns'].map('{:,.2f}%'.format)\n    stats['Annualized Volatility'] = stats['Annualized Volatility'].map('{:,.2f}%'.format)\n    stats['Sharpe Ratio'] = stats['Sharpe Ratio'].map('{:,.2f}'.format)\n    stats['Sortino Ratio'] = stats['Sortino Ratio'].map('{:,.2f}'.format)\n    stats['Max Drawdown'] = stats['Max Drawdown'].map('{:,.2f}%'.format)\n    stats['Skewness'] = stats['Skewness'].map('{:,.2f}'.format)\n    stats['Kurtosis'] = stats['Kurtosis'].map('{:,.2f}'.format)\n    stats['Cornish Fisher adj. VAR 5%'] = stats['Cornish Fisher adj. VAR 5%'].map('{:,.2f}%'.format)\n\n    return stats.T"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_367","text":"<reponame>y-kunii\/face_classification<filename>src\/video_emotion_color_demo_stereo.py\nfrom statistics import mode\n\nimport cv2\nfrom keras.models import load_model\nimport numpy as np\n\nfrom utils.datasets import get_labels\nfrom utils.inference import detect_faces\nfrom utils.inference import draw_text\nfrom utils.inference import draw_bounding_box\nfrom utils.inference import apply_offsets\nfrom utils.inference import load_detection_model\nfrom utils.preprocessor import preprocess_input\n\ndef draw_image(gray_image,rgb_image, faces):\n    for face_coordinates in faces:\n    \n        x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)\n        gray_face = gray_image[y1:y2, x1:x2]\n        try:\n            gray_face = cv2.resize(gray_face, (emotion_target_size))\n        except:\n            continue\n\n        gray_face = preprocess_input(gray_face, True)\n        gray_face = np.expand_dims(gray_face, 0)\n        gray_face = np.expand_dims(gray_face, -1)\n        emotion_prediction = emotion_classifier.predict(gray_face)\n        emotion_probability = np.max(emotion_prediction)\n        emotion_label_arg = np.argmax(emotion_prediction)\n        emotion_text = emotion_labels[emotion_label_arg]\n        emotion_window.append(emotion_text)\n\n        if len(emotion_window) > frame_window:\n            emotion_window.pop(0)\n        try:\n            emotion_mode = mode(emotion_window)\n        except:\n            continue\n\n        if emotion_text == 'angry':\n            color = emotion_probability * np.asarray((255, 0, 0))\n        elif emotion_text == 'sad':\n            color = emotion_probability * np.asarray((0, 0, 255))\n        elif emotion_text == 'happy':\n            color = emotion_probability * np.asarray((255, 255, 0))\n        elif emotion_text == 'surprise':\n            color = emotion_probability * np.asarray((0, 255, 255))\n        else:\n            color = emotion_probability * np.asarray((0, 255, 0))\n\n        color = color.astype(int)\n        color = color.tolist()\n\n        draw_bounding_box(face_coordinates, rgb_image, color)\n        draw_text(face_coordinates, rgb_image, emotion_mode,\n                  color, 0, -45, 1, 1)\n\n\n# parameters for loading data and images\ndetection_model_path = '..\/trained_models\/detection_models\/haarcascade_frontalface_default.xml'\nemotion_model_path = '..\/trained_models\/emotion_models\/fer2013_mini_XCEPTION.102-0.66.hdf5'\nemotion_labels = get_labels('fer2013')\n\n# hyper-parameters for bounding boxes shape\nframe_window = 10\nemotion_offsets = (20, 40)\n\n# loading models\nface_detection = load_detection_model(detection_model_path)\nemotion_classifier = load_model(emotion_model_path, compile=False)\n\n# getting input model shapes for inference\nemotion_target_size = emotion_classifier.input_shape[1:3]\n\n# starting lists for calculating modes\nemotion_window = []\n\n# starting video streaming\ncv2.namedWindow('window_frame')\nvideo_captureL = cv2.VideoCapture(0)\nvideo_captureR = cv2.VideoCapture(2)\nbgr_imageL = np.zeros((480,640,3), np.uint8)\nbgr_imageR = np.zeros((480,640,3), np.uint8)\nwhile True:\n    bgr_imageL = video_captureL.read()[1]\n    bgr_imageR = video_captureR.read()[1]\n    gray_imageL = cv2.cvtColor(bgr_imageL, cv2.COLOR_BGR2GRAY)\n    gray_imageR = cv2.cvtColor(bgr_imageR, cv2.COLOR_BGR2GRAY)\n    rgb_imageL = cv2.cvtColor(bgr_imageL, cv2.COLOR_BGR2RGB)\n    rgb_imageR = cv2.cvtColor(bgr_imageR, cv2.COLOR_BGR2RGB)\n    facesL = detect_faces(face_detection, gray_imageL)\n    facesR = detect_faces(face_detection, gray_imageR)\n\n    draw_image(gray_imageL,rgb_imageL, facesL)\n    draw_image(gray_imageR,rgb_imageR, facesR)\n\n    bgr_imageL = cv2.cvtColor(rgb_imageL, cv2.COLOR_RGB2BGR)\n    bgr_imageR = cv2.cvtColor(rgb_imageR, cv2.COLOR_RGB2BGR)\n    stereoImg = cv2.hconcat([bgr_imageL, bgr_imageR])\n    cv2.imshow('window_frame', stereoImg)\n    if cv2.waitKey(1) & 0xFF == ord('q'):\n        break\nvideo_captureL.release()\nvideo_captureR.release()\ncv2.destroyAllWindows()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_592","text":"import hashlib\nimport os\nimport pickle\nimport time\nimport csv\nimport gzip\nimport numpy\nimport pandas\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport scipy\nimport pprint\nimport sklearn.cluster\nimport mpl_toolkits.mplot3d\nimport matplotlib.patches\n\n\ndef get_matrix(filename):\n    return pandas.DataFrame(scipy.io.mmread(filename).toarray())\n\n\ndef get_feature_ids(filename):\n    return [row[0] for row in csv.reader(gzip.open(filename, mode=\"rt\"), delimiter=\"\\t\")]\n\n\ndef get_gene_name(filename):\n    return [row[1] for row in csv.reader(gzip.open(filename, mode=\"rt\"), delimiter=\"\\t\")]\n\n\ndef get_feature_type(filename):\n    return [row[2] for row in csv.reader(gzip.open(filename, mode=\"rt\"), delimiter=\"\\t\")]\n\n\ndef get_barcodes(filename):\n    return [row[0] for row in csv.reader(gzip.open(filename, mode=\"rt\"), delimiter=\"\\t\")]\n\n\ndata = dict()\n\n\ndef get_all(ID):\n    if ID in data:\n        return data[ID]\n    dirname = \"\/home\/jwlee\/Spermatogenesis\/result\/\" + ID + \"\/outs\/filtered_feature_bc_matrix\"\n    matrix_dir = os.path.join(dirname, \"matrix.mtx.gz\")\n    features_path = os.path.join(dirname, \"features.tsv.gz\")\n    barcodes_path = os.path.join(dirname, \"barcodes.tsv.gz\")\n\n    data[ID] = {\"matrix\": get_matrix(matrix_dir), \"feature_ids\": get_feature_ids(features_path), \"gene_name\": get_gene_name(features_path), \"feature_type\": get_feature_type(features_path), \"barcodes\": get_barcodes(barcodes_path)}\n\n    return data[ID]\n\n\nnow = time.strftime(\"%m%d%H%M%S\")\nfigure_directory = \"\/home\/jwlee\/Spermatogenesis\/figures\/\"\nIDs = [\"NS_SW1\", \"NS_SW2\", \"NS_SW3\", \"NS_SW4\"]\n\n\ndef select_highly_variable_genes(raw_data, show=True, datum_point=95):\n    a = raw_data.mean(axis=1).to_numpy()\n    b = raw_data.var(axis=1).to_numpy()\n    data = pandas.DataFrame.from_dict({\"means\": a, \"cvs\": numpy.divide(b, a)})\n\n    data = data.loc[(data[\"cvs\"] > 0) & (data[\"means\"] > 0)]\n\n    selected = data.loc[(data[\"cvs\"] >= numpy.percentile(data[\"cvs\"], datum_point)) & (data[\"means\"] >= numpy.percentile(data[\"means\"], datum_point))]\n    unselected = data.loc[(data[\"cvs\"] < numpy.percentile(data[\"cvs\"], datum_point)) | (data[\"means\"] < numpy.percentile(data[\"means\"], datum_point))]\n\n    raw_data = raw_data.iloc[selected.index]\n    print(\"Gene & Cell:\", raw_data.shape)\n\n    if show:\n        mpl.use(\"Agg\")\n        mpl.rcParams.update({\"font.size\": 30})\n\n        plt.figure()\n        plt.scatter(numpy.log(selected[\"means\"]), numpy.log(selected[\"cvs\"]), c=\"blue\", alpha=0.6, label=\"Selected\")\n        plt.scatter(numpy.log(unselected[\"means\"]), numpy.log(unselected[\"cvs\"]), c=\"red\", alpha=0.6, label=\"Unselected\")\n\n        plt.grid(True)\n        plt.title(str(selected.shape[0]) + \" Genes: \" + str(100 - datum_point) + \"%\")\n        plt.xlabel(\"log(means)\")\n        plt.ylabel(\"log(CV)\")\n        plt.legend()\n\n        fig = plt.gcf()\n        fig.set_size_inches(24, 18)\n        fig.savefig(figure_directory + \"HighlyVariableGene_\" + now + \".png\")\n        plt.close()\n\n    return raw_data\n\n\ndef get_whole_data(genes=None):\n    def make_md5(data):\n        if data is None:\n            return hashlib.md5(\"\".encode(\"utf-8\")).hexdigest()\n        else:\n            return hashlib.md5(str(sorted(genes)).encode(\"utf-8\")).hexdigest()\n\n    if os.path.exists(make_md5(genes) + \".data\"):\n        with open(make_md5(genes) + \".data\", \"rb\") as f:\n            return pickle.load(f)\n\n    if genes is not None and \"ref\" in genes:\n        data = get_matrix(\"\/home\/jwlee\/Spermatogenesis\/result\/ref\/outs\/filtered_feature_bc_matrix\/matrix.mtx.gz\")\n        print(data)\n\n        data = sklearn.decomposition.PCA(random_state=0, n_components=data.shape[1]).fit_transform(numpy.swapaxes(data.values, 0, 1))\n        print(\"PCA data:\", data)\n        print(\"Cell & Gene-like:\", len(data), len(data[0]))\n\n        data = numpy.swapaxes(sklearn.manifold.TSNE(n_components=2, random_state=0).fit_transform(data), 0, 1)\n\n        projection = dict()\n        projection[\"Barcode\"] = get_barcodes(\"\/home\/jwlee\/Spermatogenesis\/result\/ref\/outs\/filtered_feature_bc_matrix\/barcodes.tsv.gz\")\n        projection[\"std_TSNE-1\"] = scipy.stats.zscore(data[0])\n        projection[\"std_TSNE-2\"] = scipy.stats.zscore(data[1])\n\n        with open(make_md5(genes) + \".data\", \"wb\") as f:\n            pickle.dump(projection, f)\n\n        return projection\n\n    data = get_matrix(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/matrix.mtx.gz\")\n\n    if genes is None:\n        data = select_highly_variable_genes(data)\n    else:\n        data[\"gene\"] = get_gene_name(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/features.tsv.gz\")\n        data = data[data[\"gene\"].isin(genes)]\n        del data[\"gene\"]\n\n    data = sklearn.decomposition.PCA(random_state=0, n_components=\"mle\").fit_transform(numpy.swapaxes(data.values, 0, 1))\n    print(\"PCA data: \", data)\n    print(\"Cell & Gene-like:\", len(data), len(data[0]))\n\n    data = numpy.swapaxes(sklearn.manifold.TSNE(n_components=2, random_state=0).fit_transform(data), 1, 0)\n\n    projection = dict()\n    projection[\"Barcode\"] = numpy.array(get_barcodes(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/barcodes.tsv.gz\"))\n    projection[\"std_TSNE-1\"] = scipy.stats.zscore(data[0])\n    projection[\"std_TSNE-2\"] = scipy.stats.zscore(data[1])\n\n    projection = pandas.DataFrame.from_dict(projection)\n\n    with open(make_md5(genes) + \".data\", \"wb\") as f:\n        pickle.dump(projection, f)\n\n    return projection\n\n\ndef draw_all():\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    projection = get_whole_data()\n\n    plt.figure()\n    plt.scatter(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], alpha=0.6)\n\n    plt.grid(True)\n    plt.title(\"Total\")\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"total\" + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef get_real_barcodes(ID):\n    projection = pandas.read_csv(\"\/home\/jwlee\/Spermatogenesis\/result\/\" + ID + \"\/outs\/analysis\/tsne\/2_components\/projection.csv\", header=0)\n\n    return [barcode[:-1] + ID[-1] for barcode in projection[\"Barcode\"]]\n\n\ndef get_data_from_id(ID, genes=None):\n    if ID == \"ref\":\n        return get_whole_data(genes=[\"ref\"])\n\n    projection = get_whole_data(genes)\n    return projection[numpy.isin(projection[\"Barcode\"], get_real_barcodes(ID))]\n\n\ndef get_data_from_id_3d(ID, genes=None):\n    projection = get_whole_data_3d(genes)\n    return projection[numpy.isin(projection[\"Barcode\"], get_real_barcodes(ID))]\n\n\ndef draw_all_with_color():\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    for ID in IDs:\n        projection = get_data_from_id(ID)\n        plt.scatter(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], alpha=0.6, label=ID)\n\n    plt.grid(True)\n    plt.title(\"Total\")\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n    plt.legend()\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"total_\" + now + \".png\")\n    plt.close()\n\n\ndef draw_tSNE(ID, genes=None):\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    whole_projection = get_whole_data(genes)\n\n    wanted = whole_projection[numpy.isin(whole_projection[\"Barcode\"], get_real_barcodes(ID))]\n    unwanted = whole_projection[numpy.invert(numpy.isin(whole_projection[\"Barcode\"], get_real_barcodes(ID)))]\n\n    plt.figure()\n    plt.scatter(unwanted[\"std_TSNE-1\"], unwanted[\"std_TSNE-2\"], c=\"tab:gray\", alpha=0.6)\n    plt.scatter(wanted[\"std_TSNE-1\"], wanted[\"std_TSNE-2\"], c=\"tab:blue\", alpha=1)\n\n    plt.grid(True)\n    plt.title(ID)\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + ID + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef make_cluster_dict(cells):\n    cells = cells.tolist()\n    given = dict()\n    for i in range(max(cells) + 1):\n        given[i] = list(filter(lambda x: cells[x] == i, list(range(len(cells)))))\n    return given\n\n\ndef clustering_Spectral_with_num(ID, num_groups):\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    projection = get_data_from_id(ID)\n\n    projection[\"group\"] = sklearn.cluster.SpectralClustering(n_clusters=num_groups, random_state=0, n_jobs=-1).fit_predict(projection[[\"std_TSNE-1\", \"std_TSNE-2\"]].values)\n\n    group = make_cluster_dict(projection[\"group\"])\n    data = [group[i] for i in group]\n    cluster_centers = [numpy.mean([projection.loc[d, \"std_TSNE-1\"], projection.loc[d, \"std_TSNE-2\"]], axis=1) for d in data]\n\n    plt.figure()\n    plt.scatter(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], c=projection[\"group\"])\n    plt.scatter([elem[0] for elem in cluster_centers], [elem[1] for elem in cluster_centers], c=\"k\", marker=\"X\")\n    for i, loc in enumerate(cluster_centers):\n        plt.text(loc[0] + 0.05, loc[1], str(i), fontsize=30, bbox=dict(color=\"white\", alpha=0.8))\n\n    plt.grid(True)\n    plt.title(\"Spectral: \" + str(num_groups))\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"Spectral_\" + ID + \"_\" + str(num_groups) + \"_\" + now + \".png\")\n    plt.close()\n\n    return (group, cluster_centers)\n\n\ndef clustering_Kmeans_with_num(ID, num_groups):\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    projection = get_data_from_id(ID)\n\n    kmeans = sklearn.cluster.KMeans(n_clusters=num_groups, random_state=0, n_jobs=-1).fit(projection[[\"std_TSNE-1\", \"std_TSNE-2\"]].values)\n\n    projection[\"group\"] = kmeans.fit_predict(projection[[\"std_TSNE-1\", \"std_TSNE-2\"]].values)\n\n    plt.figure()\n    plt.scatter(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], c=projection[\"group\"])\n    plt.scatter([elem[0] for elem in kmeans.cluster_centers_], [elem[1] for elem in kmeans.cluster_centers_], c=\"k\", marker=\"X\", s=500)\n    for i, loc in enumerate(kmeans.cluster_centers_):\n        plt.text(loc[0] + 0.05, loc[1], str(i), fontsize=30, bbox=dict(color=\"white\", alpha=0.8))\n\n    plt.grid(True)\n    plt.title(\"KMeans: \" + str(num_groups))\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"KMeans_\" + ID + \"_\" + str(num_groups) + \"_\" + now + \".png\")\n    plt.close()\n\n    return (make_cluster_dict(projection[\"group\"]), kmeans.cluster_centers_)\n\n\ndef clustering_Kmeans(ID, num=10):\n    return [clustering_Kmeans_with_num(ID, i) for i in range(2, num + 1)]\n\n\ndef clustering_Kmeans_with_num_3d(ID, num_groups):\n    def change_str(num):\n        color = [\"#7e1e9c\", \"#15b01a\", \"#0343df\", \"#ff81c0\", \"#653700\", \"#e50000\", \"#95d0fc\", \"#029386\", \"#f97306\", \"#96f97b\", \"c20078\", \"#ffff14\", \"#75bbfd\", \"#929591\", \"#89fe05\", \"#bf77f6\", \"#9a0eea\", \"#033500\"]\n        return color[num % len(color)]\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    projection = get_data_from_id_3d(ID)\n\n    kmeans = sklearn.cluster.KMeans(n_clusters=num_groups, random_state=0, n_jobs=-1).fit(projection[[\"std_TSNE-1\", \"std_TSNE-2\", \"std_TSNE-3\"]].values)\n\n    projection[\"group\"] = kmeans.fit_predict(projection[[\"std_TSNE-1\", \"std_TSNE-2\", \"std_TSNE-3\"]].values)\n\n    fig = plt.figure()\n    ax = mpl_toolkits.mplot3d.Axes3D(fig, elev=45, azim=135)\n    ax.scatter(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], projection[\"std_TSNE-3\"], c=projection[\"group\"])\n    ax.scatter([elem[0] for elem in kmeans.cluster_centers_], [elem[1] for elem in kmeans.cluster_centers_], [elem[2] for elem in kmeans.cluster_centers_], c=\"k\", marker=\"X\", s=500)\n\n    ax.set_title(\"KMeans: \" + str(num_groups))\n    ax.set_xlabel(\"Standardized TSNE-1\")\n    ax.set_ylabel(\"Standardized TSNE-2\")\n    ax.set_zlabel(\"Standardized TSNE-3\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"KMeans3D_\" + ID + \"_\" + str(num_groups) + \"_\" + now + \".png\")\n    plt.close()\n\n    if not os.path.exists(\"Kmeans_\" + ID + \"_\" + str(num_groups) + \".data\"):\n        with open(\"KMeans_\" + ID + \"_\" + str(num_groups) + \".data\", \"w\") as f:\n            f.write(\"x,y,z,c\\n\")\n            for x, y, z, c in zip(projection[\"std_TSNE-1\"], projection[\"std_TSNE-2\"], projection[\"std_TSNE-3\"], list(map(lambda x: change_str(x), projection[\"group\"]))):\n                f.write(str(x) + \",\" + str(y) + \",\" + str(z) + \",\" + c + \"\\n\")\n\n    return (make_cluster_dict(projection[\"group\"]), kmeans.cluster_centers_)\n\n\ndef gene_in_cells(ID, cell_numbers=None):\n    all_data = get_all(ID)\n    all_data[\"matrix\"].index = all_data[\"gene_name\"]\n\n    if cell_numbers is None:\n        return all_data[\"matrix\"]\n\n    data = all_data[\"matrix\"].copy()\n\n    data.drop(all_data[\"matrix\"].columns[list(filter(lambda x: x not in cell_numbers, list(range(all_data[\"matrix\"].shape[1]))))], axis=1, inplace=True)\n\n    return data\n\n\ndef gene_sum_in_cells(ID, cell_numbers=None, num_gene=None):\n    data = gene_in_cells(ID, cell_numbers).sum(axis=1).sort_values(ascending=False)\n    data = data[data > 0]\n\n    return data if num_gene is None else data[:num_gene]\n\n\ndef gene_mean_in_cells(ID, cell_numbers=None, num_gene=100, text=True):\n    data = gene_in_cells(ID, cell_numbers).mean(axis=1).sort_values(ascending=False)\n    data = data[data > 0]\n\n    return data if num_gene is None else data[:num_gene]\n\n\ndef check_valid_function(cluster_function):\n    allowed_functions = [clustering_Kmeans_with_num, clustering_Spectral_with_num]\n    if cluster_function not in allowed_functions:\n        print(\"cluster_function must be in\", allowed_functions)\n        return False\n    else:\n        return True\n\n\ndef check_valid_function_3d(cluster_function):\n    allowed_functions = [clustering_Kmeans_with_num_3d]\n    if cluster_function not in allowed_functions:\n        print(\"cluster_function must be in\", allowed_functions)\n        return False\n    else:\n        return True\n\n\ndef stacked_bar_gene_sum(ID, cluster_function, num_groups=10, num_gene=5):\n    if not check_valid_function(cluster_function):\n        return\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    gene_list = numpy.swapaxes([list(gene_sum_in_cells(ID, cluster_group[i], num_gene)) for i in cluster_group], 0, 1)\n    gene_name = numpy.swapaxes([list(gene_sum_in_cells(ID, cluster_group[i], num_gene).index) for i in cluster_group], 0, 1)\n\n    pprint.pprint(gene_list)\n    pprint.pprint(gene_name)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    plt.bar(numpy.arange(num_groups), gene_list[0], 0.35)\n    for i in range(1, num_gene):\n        plt.bar(numpy.arange(num_groups), gene_list[i], 0.35, bottom=numpy.sum(numpy.array([gene_list[j] for j in range(i)]), axis=0))\n\n    gene_tick = numpy.amax(numpy.sum(gene_list, axis=0)) \/ 5 \/ num_gene\n    for i in range(num_groups):\n        for j in range(num_gene):\n            plt.text(i + 0.05, (j + 1) * gene_tick, gene_name[j][i], fontsize=10, bbox=dict(color=\"white\", alpha=0.3))\n\n    plt.grid(True)\n    plt.title(\"Stacked Bar \" + ID + \" with \" + str(num_gene) + \" Gene\")\n    plt.xlabel(\"Group\")\n    plt.ylabel(\"# of Genes\")\n    plt.xticks(numpy.arange(num_groups), list(range(num_groups)))\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"StackedBar_\" + ID + \"_\" + str(num_groups) + \"_\" + str(num_gene) + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef stacked_bar_gene_mean(ID, cluster_function, num_groups=10, num_gene=5):\n    if not check_valid_function(cluster_function):\n        return\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    gene_list = numpy.swapaxes([list(gene_mean_in_cells(ID, cluster_group[i], num_gene)) for i in cluster_group], 0, 1)\n    gene_name = numpy.swapaxes([list(gene_mean_in_cells(ID, cluster_group[i], num_gene).index) for i in cluster_group], 0, 1)\n\n    pprint.pprint(gene_list)\n    pprint.pprint(gene_name)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    plt.bar(numpy.arange(num_groups), gene_list[0], 0.35)\n    for i in range(1, num_gene):\n        plt.bar(numpy.arange(num_groups), gene_list[i], 0.35, bottom=numpy.sum(numpy.array([gene_list[j] for j in range(i)]), axis=0))\n\n    gene_tick = numpy.amax(numpy.sum(gene_list, axis=0)) \/ 5 \/ num_gene\n    for i in range(num_groups):\n        for j in range(num_gene):\n            plt.text(i + 0.05, (j + 1) * gene_tick, gene_name[j][i], fontsize=10, bbox=dict(color=\"white\", alpha=0.3))\n\n    plt.grid(True)\n    plt.title(\"Stacked Bar \" + ID + \" with \" + str(num_gene) + \" Genes\")\n    plt.xlabel(\"Group\")\n    plt.ylabel(\"# of Gene\")\n    plt.xticks(numpy.arange(num_groups), list(range(num_groups)))\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"StackedBar_\" + ID + \"_\" + str(num_groups) + \"_\" + str(num_gene) + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef sort_index(gene_list):\n    group_order = [tuple(list(scipy.stats.rankdata(data)) + [i]) for i, data in enumerate(gene_list)]\n\n    group_order.sort()\n\n    group_order = [list(elem)[-1] for elem in group_order]\n    answer = [[i for i in gene_list[j]] for j in group_order]\n\n    return (group_order, answer)\n\n\ndef heatmap_sum_top(ID, cluster_function, num_groups=10, num_gene=None, show_text=True):\n    if not check_valid_function(cluster_function) and not check_valid_function_3d(cluster_function):\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    gene_name = list(gene_sum_in_cells(ID).index)\n    if num_gene is not None:\n        gene_name = gene_name[:num_gene]\n    gene_name = sorted(gene_name)\n\n    group_order, gene_list = sort_index([gene_sum_in_cells(ID, cluster_group[i]) for i in cluster_group])\n    for i, data in enumerate(gene_list):\n        data.drop(labels=list(filter(lambda x: x not in gene_name, list(data.index))), inplace=True)\n        data.sort_index(inplace=True)\n        gene_list[i] = scipy.stats.zscore(data.tolist())\n\n    pprint.pprint(gene_name)\n    pprint.pprint(gene_list)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    plt.imshow(gene_list)\n\n    plt.title(\"HeatMap _ \" + ID + \"_\" + str(num_gene) + \" Genes\")\n    plt.xlabel(\"Genes\")\n    plt.ylabel(\"Groups\")\n    plt.xticks(numpy.arange(len(gene_name)), gene_name, fontsize=10, rotation=90)\n    plt.yticks(numpy.arange(len(group_order)), group_order, fontsize=10)\n\n    threshold = numpy.amax([numpy.amax(i) for i in gene_list]) \/ 2\n    for i in range(len(gene_name)):\n        for j in range(num_groups):\n            if show_text:\n                plt.text(j, i, str(gene_list[i][j]), color=\"white\" if gene_list[i][j] < threshold else 'black', fontsize=10)\n\n    fig = plt.gcf()\n    fig.set_size_inches(max(24, len(gene_name) * 0.5), 18)\n    fig.savefig(figure_directory + \"HeatMap_\" + ID + \"_\" + str(num_groups) + \"_\" + str(len(gene_name)) + \"_\" + now + \".png\")\n    plt.close()\n\n    return (cluster_group, group_order, cluster_centers)\n\n\ndef heatmap_mean_top(ID, cluster_function, num_groups=10, num_gene=10, show_text=False):\n    if not check_valid_function(cluster_function) and not check_valid_function_3d(cluster_function):\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    gene_name = list(gene_mean_in_cells(ID).index)\n    if num_gene is not None:\n        gene_name = gene_name[:num_gene]\n    gene_name = sorted(gene_name)\n\n    gene_list = [gene_mean_in_cells(ID, cluster_group[i]).sort_index() for i in cluster_group]\n    for i, data in enumerate(gene_list):\n        data = data.add(pandas.Series(0, index=gene_name), fill_value=0)\n        data.drop(labels=list(filter(lambda x: x not in gene_name, list(data.index))), inplace=True)\n        data.sort_index(inplace=True)\n        gene_list[i] = scipy.stats.zscore(data.tolist())\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    plt.imshow(gene_list)\n\n    plt.title(\"HeatMap_\" + ID + \"_\" + str(num_gene) + \" Genes\")\n    plt.xlabel(\"Genes\")\n    plt.ylabel(\"Groups\")\n    plt.xticks(numpy.arange(len(gene_name)), gene_name, fontsize=10, rotation=90)\n    plt.yticks(numpy.arange(num_groups), list(range(num_groups)), fontsize=10)\n\n    threshold = numpy.amax([numpy.amax(i) for i in gene_list]) \/ 2\n    for i in range(len(gene_name)):\n        for j in range(num_groups):\n            if show_text:\n                plt.text(j, i, str(gene_list[i][j]), color=\"white\" if gene_list[i][j] < threshold else 'black', fontsize=10)\n\n    fig = plt.gcf()\n    fig.set_size_inches(max(24, len(gene_name) * 0.5), 18)\n    fig.savefig(figure_directory + \"HeatMap_\" + ID + \"_\" + str(num_groups) + \"_\" + str(len(gene_name)) + \"_\" + now + \".png\")\n    plt.close()\n\n    return (cluster_group, list(range(num_groups)), cluster_centers)\n\n\ndef find_marker_gene(ID, cluster_function, num_groups=10):\n    if not check_valid_function(cluster_function):\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    whole_cells = gene_in_cells(ID)\n    marker_gene = list()\n    for i in cluster_group:\n        selected_gene = list()\n        data = gene_in_cells(ID, cell_numbers=cluster_group[i])\n        for row in list(data.index):\n            value = scipy.stats.ttest_ind(list(data.loc[row]), list(whole_cells.loc[row]))\n            if value[0] > 0 and value[1] < 0.05:\n                selected_gene.append((value[1], row))\n        selected_gene.sort()\n        print(selected_gene[:10])\n        marker_gene.append(tuple(selected_gene[i][1] for i in range(3)))\n\n    return marker_gene\n\n\ngene_1 = [\"Grfa1\", \"Zbtb16\", \"Nanos3\", \"Nanos2\", \",Sohlh1\", \"Neurog3\", \"Piwil4\", \"Lin28a\", \"Utf1\", \"Kit\", \"Uchl1\", \"Dmrt1\", \"Sohlh2\", \"Dazl\", \"Stra8\", \"Scml2\", \"Rpa2\", \"Rad51\", \"Rhox13\", \"Dmc1\", \"Melob\", \"Sycp1\", \"Sycp3\", \"Ccnb1ip1\", \"Hormad1\", \"Piwil2\", \"Piwil1\", \"Atr\", \"Mybl1\", \"Dyx1c1\", \"Msh3\", \"Ccnb1\", \"Spo11\", \"Ldha\", \"Ldhc\", \"Cetn4\", \"Tekt1\", \"Acr\", \"Ssxb1\", \"Ssxb2\", \"Acrv1\", \"Catsper3\", \"Catsper1\", \"Saxo1\", \"Hsfy2\", \"Txndc8\", \"Tnp1\", \"Tnp2\", \"Tmod4\", \"Gapdhs\", \"Car2\", \"Prm2\", \"Prm1\", \"Prm3\", \"Pgk2\", \"Wt1\", \"Sox9\", \"Cyp11a1\", \"Nr5a1\", \"Star\", \"Hsd3b1\", \"Clu\", \"Cyp17a1\", \"Gata4\", \"Acta2\"]\ngene_2 = [\"Id4\", \"Gfra1\", \"Zbtb16\", \"Stra8\", \"Rhox13\", \"Sycp3\", \"Dmc1\", \"Piwil1\", \"Pgk2\", \"Acr\", \"Gapdhs\", \"Prm1\"]\n\n\ndef heatmap_given_genes(ID, cluster_function, gene_name=gene_1, num_groups=10):\n    if not check_valid_function(cluster_function) and not check_valid_function_3d(cluster_function):\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    raw_gene_list = [gene_mean_in_cells(ID, cluster_group[i]) for i in cluster_group]\n    gene_list = [[None for i in gene_name] for j in raw_gene_list]\n    for i, data in enumerate(raw_gene_list):\n        for j, gene in enumerate(gene_name):\n            gene_list[i][j] = float(data.loc[gene]) if (gene in list(data.index)) else 0.0\n\n    for i, data in enumerate(gene_list):\n        if numpy.unique(data).size > 1:\n            gene_list[i] = scipy.stats.zscore(data)\n        else:\n            gene_list[i] = [0 for gene in data]\n\n    group_order, gene_list = sort_index(gene_list)\n    pprint.pprint(gene_list)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    plt.imshow(gene_list)\n\n    plt.title(\"Heatmap_\" + ID + \"_\" + str(len(gene_name)) + \" Genes\")\n    plt.xlabel(\"Genes\")\n    plt.ylabel(\"Groups\")\n    plt.xticks(numpy.arange(len(gene_name)), gene_name, fontsize=10, rotation=90)\n    plt.yticks(numpy.arange(num_groups), group_order, fontsize=10)\n\n    fig = plt.gcf()\n    fig.set_size_inches(max(24, 0.5 * len(gene_name)), max(18, 0.2 * num_groups))\n    fig.savefig(figure_directory + \"HeatMap_\" + ID + \"_\" + str(num_groups) + \"_\" + str(len(gene_name)) + \"_\" + now + \".png\")\n    plt.close()\n\n    return (cluster_group, group_order, cluster_centers)\n\n\ndef pseudotime(ID, cluster_function, num_groups=10, select_gene=True):\n    if not check_valid_function(cluster_function):\n        return\n\n    if select_gene:\n        cluster_group, group_order, cluster_centers = heatmap_given_genes(ID, cluster_function, num_groups=num_groups)\n    else:\n        cluster_group, group_order, cluster_centers = heatmap_mean_top(ID, cluster_function, show_text=False)\n    projection = get_data_from_id(ID)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    for i in cluster_group:\n        plt.scatter(projection[\"std_TSNE-1\"].iloc[cluster_group[i]], projection[\"std_TSNE-2\"].iloc[cluster_group[i]], c=[\"C\" + str(i % 10) for _ in range(projection[\"std_TSNE-1\"].iloc[cluster_group[i]].size)])\n    for i in range(1, len(cluster_centers)):\n        plt.arrow(cluster_centers[group_order[i - 1]][0], cluster_centers[group_order[i - 1]][1], 0.8 * (cluster_centers[group_order[i]][0] - cluster_centers[group_order[i - 1]][0]), 0.8 * (cluster_centers[group_order[i]][1] - cluster_centers[group_order[i - 1]][1]), width=0.05, edgecolor=None, linestyle=\":\")\n\n    plt.grid(True)\n    plt.title(\"Ordering Groups\")\n    plt.xlabel(\"Standardized TSNE-1\")\n    plt.ylabel(\"Standardized TSNE-2\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"Arrow_\" + ID + \"_\" + str(num_groups) + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef pseudotime_3d(ID, cluster_function, num_groups=10, select_gene=True):\n    class Arrow3D(matplotlib.patches.FancyArrowPatch):\n        def __init__(self, xs, ys, zs, *args, **kwargs):\n            matplotlib.patches.FancyArrowPatch.__init__(self, (0, 0), (0, 0), *args, **kwargs)\n            self._verts3d = xs, ys, zs\n\n        def draw(self, renderer):\n            xs3d, ys3d, zs3d = self._verts3d\n            xs, ys, zs = mpl_toolkits.mplot3d.proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)\n            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))\n            matplotlib.patches.FancyArrowPatch.draw(self, renderer)\n\n    if not check_valid_function_3d(cluster_function):\n        return\n\n    if select_gene:\n        cluster_group, group_order, cluster_centers = heatmap_given_genes(ID, cluster_function, num_groups=num_groups)\n    else:\n        cluster_group, group_order, cluster_centers = heatmap_mean_top(ID, cluster_function, num_groups=num_groups)\n    projection = get_data_from_id_3d(ID)\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    fig = plt.figure()\n    ax = mpl_toolkits.mplot3d.Axes3D(fig, elev=45, azim=135)\n\n    for i in cluster_group:\n        ax.scatter(projection[\"std_TSNE-1\"].iloc[cluster_group[i]], projection[\"std_TSNE-2\"].iloc[cluster_group[i]], projection[\"std_TSNE-3\"].iloc[cluster_group[i]], c=[\"C\" + str(i % 10) for _ in range(projection[\"std_TSNE-1\"].iloc[cluster_group[i]].size)])\n    for i in range(1, len(cluster_centers)):\n        ax.add_artist(Arrow3D([cluster_centers[group_order[i - 1]][0], cluster_centers[group_order[i]][0]], [cluster_centers[group_order[i - 1]][1], cluster_centers[group_order[i]][1]], [cluster_centers[group_order[i - 1]][2], cluster_centers[group_order[i]][2]], mutation_scale=20, lw=3, arrowstyle=\"-|>\", color=\"k\"))\n\n    ax.set_title(\"Ordering Groups in 3D\")\n    ax.set_xlabel(\"Standardized TSNE-1\")\n    ax.set_ylabel(\"Standardized TSNE-2\")\n    ax.set_zlabel(\"Standardized TSNE-3\")\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + \"Arraw3D_\" + ID + \"_\" + str(num_groups) + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef bar_given_genes(ID, cluster_function, gene_name=gene_1, num_groups=10):\n    if not check_valid_function(cluster_function):\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    raw_gene_list = [gene_mean_in_cells(ID, cluster_group[i]) for i in cluster_group]\n    gene_list = [[None for i in gene_name] for j in cluster_group]\n    for i, data in enumerate(raw_gene_list):\n        for j, gene in enumerate(gene_name):\n            gene_list[i][j] = float(data.loc[gene]) if (gene in list(data.index)) else 0.0\n\n    for i, data in enumerate(gene_list):\n        if numpy.unique(data).size > 1:\n            gene_list[i] = scipy.stats.zscore(data)\n        else:\n            gene_list[i] = [0 for _ in data]\n\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    plt.figure()\n    fig, ax = plt.subplots(num_groups)\n\n    for i, data in enumerate(gene_list):\n        for j, high in enumerate(data):\n            ax[i].bar(j, high, color=\"C\" + str(j % 10), edgecolor=\"k\", label=gene_name[j])\n\n    plt.setp(ax, xticks=list(range(len(gene_name))), xticklabels=gene_name)\n\n    fig = plt.gcf()\n    fig.set_size_inches(max(24, 2.5 * len(gene_name)), max(18, 4 * num_groups))\n    fig.savefig(figure_directory + \"Bar_graph_\" + ID + \"_\" + str(num_groups) + \"_\" + str(len(gene_name)) + \"_\" + now + \".png\")\n    plt.close()\n\n\ndef get_common_genes(ID, cluster_function, num_groups=10):\n    if not check_valid_function:\n        return\n\n    cluster_group, cluster_centers = cluster_function(ID, num_groups)\n\n    gene_list = [list(gene_mean_in_cells(ID, cluster_group[i]).index) for i in cluster_group]\n\n    common_gene = set(gene_list[0])\n    for gene in gene_list[1:]:\n        if not common_gene:\n            return common_gene\n        common_gene = common_gene & set(gene)\n\n    pprint.pprint(common_gene)\n    print(len(common_gene))\n\n    return common_gene\n\n\ndef scatter_given_genes(ID, genes=gene_1):\n    def change_scale(gene_expression):\n        minimum, maximum = min(gene_expression), max(gene_expression)\n\n        return list(map(lambda x: x if x > 0.1 else 0.1, list(map(lambda x: (x - minimum) \/ (maximum - minimum), gene_expression))))\n\n    data_1 = get_data_from_id(ID, genes)\n    data_2 = get_all(ID)\n\n    for gene in genes:\n        try:\n            number_gene = data_2[\"gene_name\"].index(gene)\n        except ValueError:\n            print(gene, \"is not here\")\n            continue\n\n        gene_expression = change_scale(data_2[\"matrix\"].iloc[number_gene].values)\n\n        mpl.use(\"Agg\")\n        mpl.rcParams.update({\"font.size\": 30})\n\n        plt.figure()\n        for x, y, alpha in zip(data_1[\"std_TSNE-1\"], data_1[\"std_TSNE-2\"], gene_expression):\n            plt.scatter(x, y, c='b', alpha=alpha)\n\n        plt.grid(True)\n        plt.title(ID + \"_\" + gene)\n        plt.xlabel(\"Standardized TSNE-1\")\n        plt.ylabel(\"Standardized TSNE-2\")\n\n        fig = plt.gcf()\n        fig.set_size_inches(24, 18)\n        fig.savefig(figure_directory + \"Scatter_\" + ID + \"_\" + gene + \"_\" + now + \".png\")\n        plt.close()\n\n        print(gene, \"Done!!\")\n\n\ndef get_whole_data_3d(genes=None):\n    def make_md5(data):\n        if data is None:\n            return hashlib.md5(\"3d\".encode(\"utf-8\")).hexdigest()\n        else:\n            return hashlib.md5((\"3d\" + str(sorted(data))).encode(\"utf-8\")).hexdigest()\n\n    if os.path.exists(make_md5(genes) + \".data\"):\n        with open(make_md5(genes) + \".data\", \"rb\") as f:\n            return pickle.load(f)\n\n    data = get_matrix(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/matrix.mtx.gz\")\n\n    if genes is None:\n        data = select_highly_variable_genes(data)\n    else:\n        data[\"gene\"] = get_gene_name(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/features.tsv.gz\")\n        data = data[data[\"gene\"].isin(genes)]\n        del data[\"gene\"]\n\n    data = sklearn.decomposition.PCA(random_state=0, n_components=\"mle\").fit_transform(numpy.swapaxes(data.values, 0, 1))\n    print(\"PCA data: \", data)\n    print(\"Cell & Gene-like:\", len(data), len(data[0]))\n\n    data = numpy.swapaxes(sklearn.manifold.TSNE(n_components=3, random_state=0).fit_transform(data), 0, 1)\n\n    projection = dict()\n    projection[\"Barcode\"] = numpy.array(get_barcodes(\"\/home\/jwlee\/Spermatogenesis\/result\/aggr\/outs\/filtered_feature_bc_matrix\/barcodes.tsv.gz\"))\n    projection[\"std_TSNE-1\"] = scipy.stats.zscore(data[0])\n    projection[\"std_TSNE-2\"] = scipy.stats.zscore(data[1])\n    projection[\"std_TSNE-3\"] = scipy.stats.zscore(data[2])\n\n    projection = pandas.DataFrame.from_dict(projection)\n\n    with open(make_md5(genes) + \".data\", \"wb\") as f:\n        pickle.dump(projection, f)\n\n    return projection\n\n\ndef draw_tSNE_3d(ID, genes=None):\n    mpl.use(\"Agg\")\n    mpl.rcParams.update({\"font.size\": 30})\n\n    whole_projection = get_whole_data_3d(genes)\n\n    if not os.path.exists(\"whole.data\"):\n        with open(\"whole.data\", \"w\") as f:\n            f.write(\"x,y,z\\n\")\n            for x, y, z in zip(whole_projection[\"std_TSNE-1\"], whole_projection[\"std_TSNE-2\"], whole_projection[\"std_TSNE-3\"]):\n                f.write(str(x) + \",\" + str(y) + \",\" + str(z) + \"\\n\")\n\n    wanted = whole_projection[numpy.isin(whole_projection[\"Barcode\"], get_real_barcodes(ID))]\n    unwanted = whole_projection[numpy.invert(numpy.isin(whole_projection[\"Barcode\"], get_real_barcodes(ID)))]\n\n    if not os.path.exists(ID + \".data\"):\n        with open(ID + \".data\", \"w\") as f:\n            f.write(\"x,y,z\\n\")\n            for x, y, z in zip(wanted[\"std_TSNE-1\"], wanted[\"std_TSNE-2\"], wanted[\"std_TSNE-3\"]):\n                f.write(str(x) + \",\" + str(y) + \",\" + str(z) + \"\\n\")\n\n    fig = plt.figure()\n    ax = mpl_toolkits.mplot3d.Axes3D(fig, elev=45, azim=135)\n\n    ax.scatter(unwanted[\"std_TSNE-1\"], unwanted[\"std_TSNE-2\"], unwanted[\"std_TSNE-3\"], c=\"tab:gray\", alpha=0.6)\n    ax.scatter(wanted[\"std_TSNE-1\"], wanted[\"std_TSNE-2\"], wanted[\"std_TSNE-3\"], c=\"tab:blue\", alpha=1)\n\n    ax.set_xlabel(\"Standardized TSNE-1\")\n    ax.set_ylabel(\"Standardized TSNE-2\")\n    ax.set_zlabel(\"Standardized TSNE-3\")\n    ax.set_title(ID)\n\n    fig = plt.gcf()\n    fig.set_size_inches(24, 18)\n    fig.savefig(figure_directory + ID + \"_3D_\" + now + \".png\")\n    plt.close()\n\n\nif __name__ == \"__main__\":\n    for ID in IDs:\n        pseudotime_3d(ID, clustering_Kmeans_with_num_3d, select_gene=False)\n    for _ in range(5):\n        print(\"\\a\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_594","text":"from numpy.core.numeric import array_equal\nfrom numpy.lib import math\nimport scipy.ndimage\nimport scipy.stats\nfrom scipy import signal\nimport matplotlib.pyplot as plt\nimport numpy as np\nnp.set_printoptions(suppress=True)\n\n\ndef gauss1d_a(pointCount: int, std: float):\n    return \n\n\ndef gauss1d_b(pointCount: int, std: float):\n    xs = range(pointCount)\n    xs = [x - (pointCount - 1)\/2 for x in xs]\n    ys = np.exp(-np.square(xs)\/(2 * std * std))\n    return ys\n\n\ndef show1d():\n    a = gauss1d_a(25, 3)\n    b = gauss1d_b(25, 3)\n    np.testing.assert_array_almost_equal(a, b)\n    print(\", \".join([str(x) for x in a]))\n    plt.plot(a)\n    plt.plot(b)\n    plt.show()\n\ndef show2d():\n    gkern1d = gauss1d_b(5, 2)\n    gkern2d = np.outer(gkern1d, gkern1d)\n    #plt.imshow(gkern2d, interpolation='none', cmap='Greys_r')\n    #plt.show()\n    print(gkern2d)\n\n\nif __name__ == \"__main__\":\n    show2d()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_595","text":"<gh_stars>0\nimport numpy as np\nimport scipy.stats as ss\nimport tensorflow as tf\nfrom tensorflow.keras import backend as K\n\nrating_weights = K.expand_dims(tf.constant(np.arange(1, 11), dtype='float32'), -1)\n\n\ndef earth_movers_distance(y_true, y_pred):\n    cdf_true = K.cumsum(y_true, axis=-1)\n    cdf_pred = K.cumsum(y_pred, axis=-1)\n    emd = K.sqrt(K.mean(K.square(cdf_true - cdf_pred), axis=-1))\n    return K.mean(emd)\n\n\ndef pearson_correlation(y_true, y_pred):\n    # y_true = y_true * rating_weights\n    # y_pred = y_pred * rating_weights\n    #\n    # xm = y_true - K.mean(y_true)\n    # ym = y_pred - K.mean(y_pred)\n    # print(xm, ym)\n    # pearson_correlation = K.sum(xm * ym) \/ K.sqrt(K.sum(K.square(xm) * K.square(ym)))\n    # print(pearson_correlation)\n    # return K.square(pearson_correlation)  # is is actually R-squared from regression\n    means_true = y_true - K.mean(y_true)\n    means_pred = y_pred - K.mean(y_pred)\n\n    # normalizing stage - setting a 1 variance\n    means_true = K.l2_normalize(means_true, axis=0)\n    means_pred = K.l2_normalize(means_pred, axis=0)\n\n    # final result\n    pearson_correlation = K.sum(means_true * means_pred)\n\n    return pearson_correlation\n\n\ndef pearson_correlation_ava(y_true, y_pred):\n    x = K.cumsum(K.dot(y_true, rating_weights))\n    y = K.cumsum(K.dot(y_pred, rating_weights))\n    return pearson_correlation(x, y)\n\n\ndef spearman_correlation(y_true, y_pred):\n    return ss.spearmanr(y_true.numpy(), y_pred.numpy())[0]\n\n\ndef two_class_quality(y_true, y_pred):\n    x = K.dot(y_true, rating_weights)\n    y = K.dot(y_pred, rating_weights)\n    score = K.equal(tf.floor(x \/ 5), tf.floor(y \/ 5))\n    return K.mean(score)\n\n\ndef two_class_quality_acc(y_true, y_pred):\n    x = np.array(y_true)\n    y = np.array(y_pred)\n    score = np.equal(np.floor(x \/ 5), np.floor(y \/ 5))\n    return np.mean(score)\n\n\ndef mean_abs_percentage(y_true, y_pred):\n    abs_diff = K.abs(y_pred - y_true) \/ y_true\n    return K.mean(1 - abs_diff)\n\n\ndef mean_abs_percentage_acc(y_true, y_pred):\n    x, y = np.array(y_true), np.array(y_pred)\n    abs_diff = np.abs(x - y) \/ x\n    return np.mean(1 - abs_diff)\n\n\ndef mean_abs_percentage_ava(y_true, y_pred):\n    x = K.dot(y_true, rating_weights)\n    y = K.dot(y_pred, rating_weights)\n    return mean_abs_percentage(x, y)\n\n\nif __name__ == '__main__':\n    a = np.array([1.62, 1.83, 1.89, 1.55, 1.74, 1.6, 1.6, 1.72, 1.54, 1.82])\n    b = np.array([57.15, 91.69, 95.27, 56.16, 78.52, 66.09, 63.71, 79.58, 50.22, 93.39])\n\n    print(a)\n    print(b)\n    print(pearson_correlation(a, b))\n    print(ss.pearsonr(a, b))\n    print(spearman_correlation(a, b))\n    print(ss.spearmanr(a, b))\n\n    a = np.array([1.62, 4.83, 5.89, 8.55, 8.74, 6.6, ])\n    b = np.array([2.62, 3.83, 1.89, 6.55, 5.74, 4.6, ])\n    print(two_class_quality(a, b))\n    print(mean_abs_percentage(a, b))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_596","text":"# import pyedflib\nimport numpy as np\nfrom scipy import signal as sg\nimport argparse\nimport sys\nimport json\n# import  matplotlib.pyplotmatplot  as plt\nfrom pprint import pprint\n\nimport pandas as pd\n\nclass Notch():\n    Q = 0 \n    f0 = 0 \n    def __init__(self,f0=60,Q=50):\n        self.f0=f0\n        self.Q=Q\n\n    def argparse(self):\n        parser = argparse.ArgumentParser()\n        parser.add_argument('-i','--archivo',help='Ingrese el nombre del archivo .edf a utilizar',type = str)\n        parser.add_argument('-fo','--fo',help='Frecuencia que se desea filtrar. Por defecto fo = 60',type = float)\n        parser.add_argument('-Q','--Q',help='Factor de calidad del filtro. Por defecto Q = 50',type = int)\n        parser.add_argument('-e','--edf',help='Nombre y dirección del archivo .edf de salida',type = str)\n        parsedargs = parser.parse_args()\n        arc = parsedargs.archivo\n        output = parsedargs.edf\n        if (parsedargs.fo != None):\n            if (parsedargs.fo> 0):\n                self.f0 = parsedargs.fo\n        if (parsedargs.Q != None):\n            if (parsedargs.Q>0):\n                self.Q = parsedargs.Q\n        return arc,output\n\n    # def read_edf(self,nameEdf):\n    #     '''\n    #     Descripción: Se encarga de leer el archivo .edf\n    #     Entradas: - nameEdf: nombre del archivo .edf\n    #     Salidas: - in_signal: Matriz de Canales X Tiempo\n    #              - fs: Frecuencia de muestro\n    #              - headers: Etiquetas del archivo .edf \n    #     '''   \n    #     edf = pyedflib.EdfReader(nameEdf) \n    #     headers = edf.getSignalHeaders() \n    #     nch  = edf.signals_in_file\n    #     nsig = edf.getNSamples()[0]\n    #     fs = edf.getSampleFrequency(0)\n    #     in_signal = np.zeros((nch,nsig))\n    #     for x in range(nch):\n    #         in_signal[x,:] = edf.readSignal(x)\n    #     edf._close()\n    #     del edf\n    #     return  in_signal,fs,headers\n\n    def filt(self,in_signal,fs):\n        '''\n        Descripción: Se encarga de filtrar los datos del EEG\n        Entradas: - in_signal: Matriz de Canales X Tiempo\n                  - fs: Frecuencia de muestro\n        Salidas: - out_signal: EEG filtrado (Matriz de CanalesXTiempo)\n        ''' \n        w0 = self.f0\/(fs\/2)  \n        num,den = sg.iirnotch(w0,self.Q)\n        out_signal = np.zeros((len(in_signal),len(in_signal[0])))\n        for i in range(0,len(in_signal)):\n            out_signal[i]=sg.filtfilt(num,den,in_signal[i])\n        return out_signal,num,den\n\n    # def write_edf(self,in_signal,headers,nameEdf):\n    #     '''\n    #     Descripción: Se encarga de escribir los datos del nuevo EEG\n    #     Entradas: - headers: etiquetas del .edf \n    #               - in_signal: Matriz de Canales X Tiempo\n    #               - nameEdf : Nombre con el que se desea guardar el nuevo .edf\n    #     ''' \n    #     edf = pyedflib.EdfWriter(nameEdf,len(in_signal),file_type=pyedflib.FILETYPE_EDFPLUS)\n    #     edf_info = []\n    #     edf_signal = []\n    #     for i in range (len(in_signal)):\n    #         channel_info={'label':headers[i]['label'],'dimension':headers[i]['dimension'],'sample_rate':headers[i]['sample_rate'],'physical_max':headers[i]['physical_max'] , 'physical_min': headers[i]['physical_min'], 'digital_max': headers[i]['digital_max'], 'digital_min': headers[i]['digital_min'], 'transducer':headers[i]['transducer'] , 'prefilter':headers[i]['prefilter']+',notch '+str(self.f0)+'Hz'}\n    #         edf_info.append(channel_info)\n    #         edf_signal.append(in_signal[i])\n    #     edf.setSignalHeaders(edf_info)\n    #     edf.writeSamples(edf_signal)\n    #     edf.close()\n    #     del edf\n\n#Read data from stdin\ndef read_in():\n    lines = sys.stdin.readlines()\n    #Since our input would only be having one line, parse our JSON data from that\n    return json.loads(lines[0])\n\nif __name__ == '__main__':\n   \n    notch1 = Notch()\n    # argparse input mode\n     # print (\"start of notch\")\n    # arc,output = notch1.argparse()\n    # signal , fs ,headers= notch1.read_edf(arc)\n    # filtered_signal,num,den = notch1.filt(signal[:,232250:234750],fs)\n    # print(\"size of output\",filtered_signal.shape)\n    # print(vals)\n    # print(\"size of input\",in_signal.shape)\n    # fig,subplt=plt.subplots(3,1,figsize=(8,5))\n    # subplt[0].plot(t,inp[9][ni:nf])\n    # subplt[0].title.set_text('Señal original')\n    # subplt[0].grid()\n    #notch1.write_edf(filtered_signal,headers,output)\n    \n    # python-shell input mode\n    inSignals=read_in()\n    nch=len(inSignals)\n    nSamples = len(inSignals[0]['data'])\n    fs=inSignals[0]['samplefrequency']\n    # print(nch,nSamples)\n    in_signal = np.zeros((nch,nSamples))\n\n    # print(len(inSignals))\n    # print(len(inSignals[0]['data']))\n    currentCh=0\n    for item in inSignals:\n        for subitem in item['data']:\n            subitem.pop('time', None)\n        df = pd.DataFrame(item['data'])\n        in_signal[currentCh,:]=np.array(df.values).transpose()\n        # print (in_signal[currentCh,:],currentCh)\n        currentCh = currentCh +1\n\n\n    \n\n    # python-shell execute mode\n    filtered_signal,num,den = notch1.filt(in_signal,fs)\n\n    # python-shell output mode\n    response={}\n    response['channels']=[]\n    currentCh=0\n    for channel in inSignals:\n        \n        channelObj={}\n        channelObj['id']=channel['id']\n        channelObj['label']=channel['label']\n        channelObj['samples']=channel['samples']\n        channelObj['physicalMaximum']=channel['physicalMaximum']\n        channelObj['physicalMinimum']=channel['physicalMinimum']\n        channelObj['digitalMaximum']=channel['digitalMaximum']\n        channelObj['digitalMinimum']=channel['digitalMinimum']\n        channelObj['samplefrequency']= channel['samplefrequency']\n        channelObj['data']=[]\n        currentD=0\n        for subitem in channel['data']:\n            d={}\n            # d['value']=float(subitem['value'])\n            d['value']=float(filtered_signal[currentCh,currentD])\n            channelObj['data'].append(d)\n            currentD=currentD+1\n        response['channels'].append(channelObj)\n        currentCh=currentCh+1\n        # print(channelObj['id'])\n    print (json.dumps(response))\n\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_597","text":"import numpy as np\nfrom scipy import sparse\nimport scipy.sparse.linalg as la\nimport time\nfrom random import randint\nfrom operators import *\nfrom spectrum_analysis import *\nfrom myio import *\nfrom hamiltonians import *\nfrom ipr import *\nimport sys\n\n\ndef simulation(dim_loc, L, n_dis, data, Hfunc, Kfunc, Zfunc=None, time_set=None):\n    dim=dim_loc**L\n\n    # Setting cycle\n    if time_set is not None:\n        steps=len(time_set)\n        Z=np.zeros((n_dis, L, steps), dtype=complex)\n        Znew=np.zeros((n_dis, L, steps), dtype=complex)\n    spectral_matrix= np.zeros((n_dis, 7))\n\n    # Disorder cycle\n    for counter in range(n_dis):\n        start = time.time()\n\n        H = Hfunc(**data)\n        kick = Kfunc(**data)\n        U_F = np.dot(la.expm(-1j*H),kick)\n        eigval, eigvec = np.linalg.eig(U_F)\n\n        # Spectral properties\n        spectrum = np.angle(eigval)\n        gaps = gap(spectrum)\n        shifted_gaps = shifted_gap(spectrum, dim_loc)\n        shifted_gaps_2 = shifted_gap(spectrum, 2)\n        log10_gaps = np.log10(gap(spectrum))\n        log10_shifted_gaps = np.log10(shifted_gap(spectrum, dim_loc))\n        log10_shifted_gaps_2 = np.log10(shifted_gap(spectrum, 2))\n        r = ratio(spectrum)\n        spectral_matrix[counter]=np.array([np.mean(gaps), np.mean(shifted_gaps),\\\n         np.mean(shifted_gaps_2), np.mean(log10_gaps), np.mean(log10_shifted_gaps),\\\n         np.mean(log10_shifted_gaps_2), r ])\n\n        if time_set is not None:\n            #Initial state\n            initial_state = np.zeros(dim)\n            initial_state[randint(0, dim-1)] = 1\n\n            final_state = evolve(time_set, initial_state, eigvec, eigval)\n\n            for i in range(L):\n             Z[counter, i], Znew[counter, i] = Zfunc(initial_state, final_state, i, time_set, **data)\n\n        elapsed = time.time()-start\n        print('size', L, '\\tdisorder realization', counter,'\\ttime elapsed', elapsed)\n\n    if time_set is not None:\n        Z_mean=np.mean(Z, axis=(0,1))\n        Z_var=np.var(Z, axis=(0,1))\n        Znew_mean=np.mean(Znew, axis=(0,1))\n        Znew_var=np.var(Znew, axis=(0,1))\n    else:\n        Z_mean=0\n        Z_var=0\n        Znew_mean=0\n        Znew_var=0\n    spectral_data=np.mean(spectral_matrix, axis=0)\n    spectral_data_var=np.var(spectral_matrix, axis=0) #not really the variance!!!!\n    return Z_mean, Z_var, Znew_mean, Znew_var, spectral_data, spectral_data_var\n\ndef IPR(dim_loc, L, n_dis, datavec, Hfunc, Kfunc):\n    dim=dim_loc**L\n    IPR_step_vec=np.zeros(len(datavec))\n    IPR_tot_vec=np.zeros(len(datavec))\n    IPR_sum_step_vec=np.zeros(len(datavec))\n    IPR_sum_tot_vec=np.zeros(len(datavec))\n\n\n    # Disorder cycle\n    for counter in range(n_dis):\n        start = time.time()\n        JZZ_array = datavec[0]['JZZ']*(1\/2+np.random.rand(L))\n        hZ_array = datavec[0]['hZ']*(np.random.rand(L))\n        hX_array = datavec[0]['hX']*(np.random.rand(L))\n        kick = Kfunc(**datavec[0])\n        for dcount, data in enumerate(datavec):\n            H = Hfunc(**data, JZZ_array=JZZ_array, hZ_array=hZ_array, hX_array=hX_array)\n            U_F = np.dot(la.expm(-1j*H),kick)\n            eigval, eigvec = np.linalg.eig(U_F)\n            if dcount==0:\n                eigvec0=eigvec\n                eigvec_old=eigvec\n            else:\n                eigvec, IPR_step =rearrange(eigvec,eigvec_old)\n                IPR_step_vec[dcount]+=IPR_step\n                IPR_tot_vec[dcount]+=IPR_func(eigvec, eigvec0)\n                IPR_sum_step_vec[dcount]+=sum_IPR(eigvec, eigvec_old)\n                IPR_sum_tot_vec[dcount]+=sum_IPR(eigvec, eigvec0)\n                eigvec_old=eigvec\n\n\n        elapsed = time.time()-start\n        print('size', L, '\\tdisorder realization', counter,'\\ttime elapsed', elapsed)\n\n    return IPR_step_vec\/n_dis, IPR_tot_vec\/n_dis, IPR_sum_step_vec\/n_dis, IPR_sum_tot_vec\/n_dis\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_598","text":"<gh_stars>0\n\"\"\"\nauthor: @nimrobotics\ndescription: calculates the functional connectivity between regions and plots them\n\"\"\"\n\nfrom multiprocessing import Condition\nimport numpy as np\nimport scipy.io\nimport glob\nimport os\nimport pandas as pd\n# from fnirslib.activation import getPeakActivation\n# from fnirslib.plots import plotData\nimport sys\nsys.path.append('..\/fnirslib')\nfrom plots import plotData\nfrom activation import getPeakActivation, getMeanActivation\n\nif __name__ == '__main__':\n    in_dir = \".\/procDataAct\/\" #directory of the data\n    out_dir = '.\/actData\/' #directory to save the plots\n    subdirs = [x[0] for x in os.walk(in_dir)][1:] #get all the subdirectories\n    threshold=0.4\n\n    females = ['SAI01', 'SAI02', 'SAI04', 'SAI09', 'SAI10', 'SAI14', 'SAI19', 'SAI22', 'SAI25', 'SAI26', 'SAI27', \n                'SAI28', 'SAI29', 'SAI30', 'SAI31', 'SAI32', 'SAI33', 'SAI35', 'SAI36', 'SAI38', 'SAI39', 'SAI40']\n    males = ['SAI03', 'SAI05', 'SAI06', 'SAI07', 'SAI08', 'SAI11', 'SAI12', 'SAI13', 'SAI15', 'SAI16', 'SAI17', \n                'SAI18', 'SAI20', 'SAI21', 'SAI23', 'SAI24', 'SAI34', 'SAI37']\n\n    # initialize a pd df\n    actDF = pd.DataFrame(columns=['ID', 'sex', 'condition', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10', 'C11', 'C12', 'C13', 'C14', 'C15', 'C16', 'C17', 'C18', 'C19', 'C20', 'C21', 'C22', 'C23', 'C24', 'C25', 'C26', 'C27', 'C28', 'C29', 'C30', 'C31', 'C32', 'C33', 'C34', 'C35', 'C36', 'C37', 'C38', 'C39', 'C40', 'C41', 'C42', 'C43', 'C44', 'C45', 'C46'])\n\n    for dir in subdirs:\n        condition = dir.split('\/')[-1]\n        files = glob.glob(dir+'\/*.mat') # get all the files in the directory\n        # avgActivation = np.zeros(np.\n        for file in files:\n            print('Processing file: ', file)\n            ID = file.split('\/')[-1].split('.')[0][1:]\n            if 'SAI'+ID in females:\n                sex = 'F'\n            if 'SAI'+ID in males:\n                sex = 'M'\n\n            print('\\nProcessing file: {}, condition: {}'.format(ID, condition))\n            data = scipy.io.loadmat(file) #load data from the directory\n            data = data['pdata'] #get the data from the dictionary\n            data = getPeakActivation(data, interval=8)\n            # data = getMeanActivation(data)\n            print('data shape: ', data.shape)\n            print('data: ', data[0])\n            actDF.loc[len(actDF)] = [ID, sex, condition] + list(data)\n\n    # save df to csv\n    actDF.to_csv(out_dir+'actDF.csv', index=False)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_599","text":"<filename>vislab\/datasets\/imagenet.py\n\"\"\"\nImageNet classification and detection challenges.\n\nEverything loaded from files, and images distributed with dataset.\n\"\"\"\nimport os\nimport pandas as pd\nimport glob\nimport scipy.io\nimport networkx as nx\nimport numpy as np\nimport multiprocessing\nimport vislab\nfrom vislab.datasets.pascal import load_annotation_files\n\n\nclass ImagenetGraph(object):\n    \"\"\"\n    Represents the ImageNet structure, loaded from .mat files provided\n    in the ILSVRC2013_devkit.\n\n    Download devkit from [1] and untar into devkit_dirname.\n    Then download meta_10k from [2] and place into devkit_dirname\/data.\n\n    [1]: http:\/\/imagenet.stanford.edu\/image\/ilsvrc2013\/ILSVRC2013_devkit.tgz\n    [2]: https:\/\/dl.dropboxusercontent.com\/u\/44891\/research\/meta_10k.mat\n    \"\"\"\n    def __init__(self, metafile, type='1k'):\n        \"\"\"\n        Parameters\n        ----------\n        type: string\n            In ['1k', '10k', 'det'].\n        \"\"\"\n        data = scipy.io.loadmat(metafile)['synsets']\n        if not type == '10k':\n            data = data[0]\n\n        g = nx.DiGraph()\n\n        # First pass: add nodes.\n        wnids = []\n        for node in data:\n            if type == '10k':\n                node = node[0]\n\n            wnid = str(node[1][0])\n            wnids.append(wnid)\n            g.add_node(wnid, {'words': node[2][0]})\n\n        # Second pass: add edges.\n        for i, node in enumerate(data):\n            if type == '10k':\n                node = node[0]\n\n            if type == 'det':\n                children = node[4].flatten()\n            else:\n                children = node[5][0]\n\n            # Children are IDs from the original metafile, which is 1-indexed.\n            for child in children:\n                g.add_edge(wnids[i], wnids[child - 1])\n\n        self.g = g\n\n    def node_name(self, wnid):\n        word = self.g.node[wnid]['words'].split(',')[0]\n        return '{} ({})'.format(word, wnid)\n\n    def get_all_successors(self, wnid):\n        children = self.g.successors(wnid)\n        all_children = list(children)\n        for child in children:\n            all_children += self.get_all_successors(child)\n        return all_children\n\n    def get_leaf_nodes(self, wnids):\n        return [\n            wnid for wnid in wnids\n            if not self.g.successors(wnid)\n        ]\n\n\ndef load_imagenet_detection(year='2013', force=False, args=None):\n    \"\"\"\n    TODO: currently only loads val split.\n    TODO: current hard-coded to be 2013 split.\n\n    Load all the annotations, including object bounding boxes.\n    Loads XML data in args['num_workers'] threads using joblib.Parallel.\n\n    Warning: this takes a few minutes to load from scratch!\n    \"\"\"\n    if args is None:\n        args = {'num_workers': multiprocessing.cpu_count()}\n\n    cache_filename = \\\n        vislab.config['paths']['shared_data'] + \\\n        '\/ilsvrc{}_dfs.h5'.format(year)\n    if not force and os.path.exists(cache_filename):\n        images_df = pd.read_hdf(cache_filename, 'images_df')\n        objects_df = pd.read_hdf(cache_filename, 'objects_df')\n        return images_df, objects_df\n\n    # Load all annotation file data (should take < 30 s).\n    # TODO: concat the dataframes here\n    splits = ['val']\n    for split in splits:\n        annotation_filenames = glob.glob('{}\/DET_bbox_{}\/*.xml'.format(\n            vislab.config['paths']['ILSVRC{}'.format(year)], split))\n        images_df, objects_df = load_annotation_files(\n            annotation_filenames, args['num_workers'])\n        images_df['_split'] = split\n\n    # Make sure that all labels are either True or False.\n    images_df = images_df.fillna(False)\n\n    # Propagate split info to objects_df\n    objects_df['split'] = np.repeat(\n        images_df['_split'].values,\n        images_df['_num_objects'].values.astype(int)\n    )\n\n    images_df.to_hdf(cache_filename, 'images_df', mode='w')\n    objects_df.to_hdf(cache_filename, 'objects_df', mode='a')\n    return images_df, objects_df\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_600","text":"import base64\nfrom io import BytesIO\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport re\nfrom numpy import mean, std\nimport random\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.base import clone\nimport scipy.stats as stats\nfrom .models import *\nfrom .forms import *\nimport numpy as np\nimport pandas as pd\nfrom scipy.stats import pearsonr\n\n\n# function to get the Image and plot\n\ndef get_image() -> object:\n    # create a byte buffer for the image to save\n    buffer = BytesIO()\n    # create a plot with the use of bytesio object\n    plt.savefig(buffer, format='png')\n    # set the cursor to the beginning of the screen\n    buffer.seek(0)\n    # retrieve the entire content of the file\n    image_png = buffer.getvalue()\n    # encoding and decoding\n    graph = base64.b64encode(image_png)\n    graph = graph.decode('utf-8')\n    # free the memory of the buffer\n    buffer.close()\n    return graph\n\n\n# enrollment capacity by school trend\ndef get_plot(chart_type, **kwargs):\n    plt.switch_backend('AGG')\n    # academic year\n    x = kwargs.get('x')\n    # y = total enrollment\n    y = kwargs.get('y')\n    # z = capacity of school\n    z = kwargs.get('z')\n    school_name = kwargs.get('name_of_school')\n\n    if chart_type == 'barplot':\n        fig, ax = plt.subplots(figsize=(10, 8))\n        ax.bar(x, z, width=0.50, color='gray', label='capacity of school')\n        ax.bar(x, y, width=0.25, color='g', label='total enrollment')\n        ax.set_ylabel(\"Total Enrollment \/ Capacity\")\n        for tick in ax.xaxis.get_major_ticks():\n            tick.label.set_fontsize(10)\n            # specify integer or one of preset strings, e.g.\n            # tick.label.set_fontsize('x-small')\n            tick.label.set_rotation('60')\n        for bar in ax.patches:\n            # Using Matplotlib annotate function and\n            # passing the coordinates where the annotation shall be done\n            # x-coordinate: bar.get_x() + bar.get_width() \/ 2\n            # y-coordinate: bar.get_height()\n            # free space to be left to make graph pleasing: (0, 8)\n            # ha and va stand for the horizontal and vertical alignment\n            plt.annotate(format(bar.get_height(), '.2f'),\n                         (bar.get_x() + bar.get_width() \/ 2,\n                          bar.get_height()), ha='center', va='center',\n                         size=8, xytext=(0, 3),\n                         textcoords='offset points')\n            plt.title(school_name)\n        ax.set_ylim([0, max(z) + 300])\n        ax.legend()\n\n    else:\n        title = school_name\n        plt.figure(figsize=(10, 8))\n        plt.title(title)\n        plt.plot(x, y, 'b-', label='enrollments')\n        plt.plot(x, z, 'g-', label='capacity')\n        # plt.ylim(0, max(y) + 100)\n        plt.ylabel(\"Total Enrollment \/ Capacity\")\n        plt.xlabel(\"Academic Year\")\n        plt.legend()\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\n# This graph plots trends of enrollment versus school capacity  for schools in a district for a select academic year\ndef get_pairs(**kwargs):\n    plt.switch_backend('AGG')\n    # total enrollment\n    x = kwargs.get('x')\n    # y = capacity of school\n    y = kwargs.get('y')\n    # selected year\n    year = kwargs.get('academic_year')\n    school = kwargs.get('name_of_school')\n    district = kwargs.get('district_name')\n    fig, ax = plt.subplots(figsize=(10, 8))\n    ax.bar(school, y, width=0.50, color='gray', label='capacity of school')\n    ax.bar(school, x, width=0.25, color='g', label='total enrollment')\n    ax.set_ylabel(\"Total Enrollment \/ Capacity\")\n    for tick in ax.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        # specify integer or one of preset strings, e.g.\n        # tick.label.set_fontsize('x-small')\n        tick.label.set_rotation(45)\n    for bar in ax.patches:\n        # Using Matplotlib annotate function and\n        # passing the coordinates where the annotation shall be done\n        # x-coordinate: bar.get_x() + bar.get_width() \/ 2\n        # y-coordinate: bar.get_height()\n        # free space to be left to make graph pleasing: (0, 8)\n        # ha and va stand for the horizontal and vertical alignment\n        plt.annotate(format(bar.get_height(), '.2f'),\n                     (bar.get_x() + bar.get_width() \/ 2,\n                      bar.get_height()), ha='center', va='center',\n                     size=8, xytext=(0, 3),\n                     textcoords='offset points')\n        plt.title(\"Enrollment\/capacity for the academic year \" + year + \" of district  \" + district)\n\n    plt.legend()\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_grade_plot(**kwargs):\n    plt.switch_backend('AGG')\n    # the  selected academic year\n    year = kwargs.get('academic_year')\n\n    # the selected school\n    school_name = kwargs.get('name_of_school')\n    data_boys = kwargs.get('data_boys')\n    data_girls = kwargs.get('data_girls')\n    data_none = kwargs.get('data')\n\n    # get subplots for boys, girls and single gender\n\n    if len(data_none) > 0:\n        fig, ax1 = plt.subplots(1, figsize=(10, 8))\n        ax1.plot(data_none['grade'], data_none['enrollment'], 'ro')\n        ax1.set_title('Enrollment')\n        school_title = School.objects.filter(id=school_name).distinct().values_list('school_name', flat=True)\n        school_name_title = school_title[0]\n        fig.suptitle(\"Enrollment for \" + school_name_title + \" - Academic Year \" + year)\n        plt.xlabel('Grades')\n        plt.tight_layout()\n        ax1.grid()\n        graph = get_image()\n        return graph\n\n    elif len(data_girls) > 0 and len(data_boys) > 0:\n        fig, (ax1, ax2) = plt.subplots(2, figsize=(10, 8))\n        ax1.plot(data_girls['grade'], data_girls['enrollment'], 'go')\n        ax1.set_title('Girls Enrollment')\n        ax2.plot(data_boys['grade'], data_boys['enrollment'], 'bo')\n        ax2.set_title('Boys Enrollment')\n\n        school_title = School.objects.filter(id=school_name).distinct().values_list('school_name', flat=True)\n        school_name_title = school_title[0]\n        fig.suptitle(\"Enrollment for \" + school_name_title + \" - Academic Year \" + year)\n        plt.xlabel('Grades')\n        plt.tight_layout()\n        ax1.grid()\n        ax2.grid()\n        graph = get_image()\n        return graph\n    else:\n        graph = \"No data recorded for the selected year\"\n        return graph\n\n\ndef get_district_grade_plot_girls(**kwargs):\n    plt.switch_backend('AGG')\n    # the  selected academic year\n    year = kwargs.get('academic_year')\n    grade = kwargs.get('grade')\n    # the selected school\n    district_name = kwargs.get('district')\n    data_girls = kwargs.get('data_girls')\n    school_girls = kwargs.get('school_girls')\n\n    # get subplots for boys, girls and single gender\n    fig, ax1 = plt.subplots(1, figsize=(10, 8))\n    ax1.plot(data_girls['enrollment'], school_girls, 'go')\n    ax1.set_title('Enrollment')\n    plt.xticks(np.arange(0, max(data_girls['enrollment']) + 5, 5.0))\n    for tick in ax1.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        # specify integer or one of preset strings, e.g.\n        # tick.label.set_fontsize('x-small')\n        tick.label.set_rotation(60)\n    district_title = School.objects.filter(id=district_name).distinct().values_list('district_name', flat=True)\n    district_name_title = district_title[0]\n    fig.suptitle(\"Grade - \" + str(grade) + \" Girls Enrollment for Academic Year \" + year + \" for district\" + str(\n        district_name_title))\n    plt.xlabel('Enrollment')\n    plt.ylabel('School')\n    plt.tight_layout()\n    ax1.grid()\n    graph = get_image()\n    return graph\n\n\ndef get_district_grade_plot_boys(**kwargs):\n    plt.switch_backend('AGG')\n    # the  selected academic year\n    year = kwargs.get('academic_year')\n    grade = kwargs.get('grade')\n    # the selected school\n    district_name = kwargs.get('district')\n    data_boys = kwargs.get('data_boys')\n    school_boys = kwargs.get('school_boys')\n\n    # get subplots for boys, girls and single gender\n    fig, ax1 = plt.subplots(1, figsize=(10, 8))\n    ax1.plot(data_boys['enrollment'], school_boys, 'bo')\n    ax1.set_title('Enrollment')\n    for tick in ax1.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        # specify integer or one of preset strings, e.g.\n        # tick.label.set_fontsize('x-small')\n        tick.label.set_rotation(60)\n        plt.xticks(np.arange(0, max(data_boys['enrollment']) + 5, 5.0))\n    district_title = School.objects.filter(id=district_name).distinct().values_list('district_name', flat=True)\n    district_name_title = district_title[0]\n    fig.suptitle(\"Grade - \" + str(grade) + \" Boys Enrollment for Academic Year \" + year + \" for district\" + str(\n        district_name_title))\n    plt.xlabel('Enrollment')\n    plt.ylabel('School')\n    plt.tight_layout()\n    ax1.grid()\n    graph = get_image()\n    return graph\n\n\ndef get_district_grade_plot_none(**kwargs):\n    plt.switch_backend('AGG')\n    # the  selected academic year\n    year = kwargs.get('academic_year')\n    grade = kwargs.get('grade')\n    # the selected school\n    district_name = kwargs.get('district')\n    data_none = kwargs.get('data_none')\n    school_none = kwargs.get('school_none')\n\n    # get subplots for boys, girls and single gender\n    fig, ax1 = plt.subplots(1, figsize=(10, 8))\n    ax1.plot(data_none['enrollment'], school_none, 'ro')\n    ax1.set_title('Enrollment')\n    plt.xticks(np.arange(0, max(data_none['enrollment']) + 5, 5.0))\n    for tick in ax1.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        # specify integer or one of preset strings, e.g.\n        # tick.label.set_fontsize('x-small')\n        tick.label.set_rotation(60)\n    district_title = School.objects.filter(id=district_name).distinct().values_list('district_name', flat=True)\n    district_name_title = district_title[0]\n    fig.suptitle(\"Grade - \" + str(grade) + \" Total Enrollment for Academic Year \" + year + \" for district\" + str(\n        district_name_title))\n    plt.xlabel('Enrollment')\n    plt.ylabel('School')\n    plt.tight_layout()\n    ax1.grid()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_boys_primary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    for _ in data.shape:\n        ger = (data['enrollment'] \/ data['age_5_to_11_years']) * 100\n        academic_year = data.academic_year\n    sns.set(font_scale=1)\n    sns.set_style(\"white\")\n    ax = ger.plot.bar(figsize=(15, 6))\n    sns.despine(left=True, bottom=True)\n    # label and title\n    ax.set_xticklabels(np.arange(len(academic_year)))\n    ax.set_title('Gross Enrollment Ratio (%) for Boys in Primary School In St. Lucia', size=18)\n    ax.set_xticklabels(academic_year)\n    for tick in ax.get_xticklabels():\n        tick.set_rotation(-30)\n    ax.set(xlabel='Academic Year', ylabel='Gross enrollment rate (%)')\n\n    # annotations\n    for p in ax.patches:\n        ax.annotate(format(p.get_height(), '.2f'),\n                    (p.get_x() + p.get_width() \/ 2., p.get_height()),\n                    ha='center', va='center',\n                    xytext=(0, 9),\n                    textcoords='offset points')\n    # adjust legend\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_girls_primary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    for _ in data.shape:\n        ger = (data['enrollment'] \/ data['age_5_to_11_years']) * 100\n        academic_year = data.academic_year\n    sns.set(font_scale=1)\n    sns.set_style(\"white\")\n    ax = ger.plot.bar(figsize=(15, 6), color='green')\n    sns.despine(left=True, bottom=True)\n    # label and title\n    ax.set_xticklabels(np.arange(len(academic_year)))\n    ax.set_title('Gross Enrollment Ratio (%) for Girls in Primary School In St. Lucia', size=18)\n    ax.set_xticklabels(academic_year)\n    for tick in ax.get_xticklabels():\n        tick.set_rotation(-30)\n    ax.set(xlabel='Academic Year', ylabel='Gross enrollment rate (%)')\n\n    # annotations\n    for p in ax.patches:\n        ax.annotate(format(p.get_height(), '.2f'),\n                    (p.get_x() + p.get_width() \/ 2., p.get_height()),\n                    ha='center', va='center',\n                    xytext=(0, 9),\n                    textcoords='offset points')\n    # adjust legend\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_primary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    data_boys = kwargs.get('data_boys')\n    data_girls = kwargs.get('data_girls')\n\n    for _ in data.shape:\n        ger_boys = (data_boys['enrollment'] \/ data_boys['age_5_to_11_years']) * 100\n        ger_girls = (data_girls['enrollment'] \/ data_girls['age_5_to_11_years']) * 100\n        academic_year = data_girls.academic_year\n        title = 'Trend of GER for Primary Schools in St. Lucia'\n        plt.figure(figsize=(10, 8))\n        plt.title(title)\n        plt.plot(academic_year, ger_boys, 'b-', label='boys')\n        plt.plot(academic_year, ger_girls, 'g-', label='girls')\n        plt.xticks(rotation=60)\n        # plt.ylim(0, max(y) + 100)\n        plt.ylabel(\"Gross Enrollment Ratio for boys and girls in St. Lucia\")\n        plt.xlabel(\"Academic Year\")\n        plt.legend()\n        plt.grid()\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_boys_secondary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    for _ in data.shape:\n        ger = (data['enrollment'] \/ data['age_12_to_16_years']) * 100\n        academic_year = data.academic_year\n    sns.set(font_scale=1)\n    sns.set_style(\"white\")\n    ax = ger.plot.bar(figsize=(15, 6))\n    sns.despine(left=True, bottom=True)\n    # label and title\n    ax.set_xticklabels(np.arange(len(academic_year)))\n    ax.set_title('Gross Enrollment Ratio (%) for Boys in Secondary School In St. Lucia', size=18)\n    ax.set_xticklabels(academic_year)\n    for tick in ax.get_xticklabels():\n        tick.set_rotation(-30)\n    ax.set(xlabel='Academic Year', ylabel='Gross enrollment rate (%)')\n\n    # annotations\n    for p in ax.patches:\n        ax.annotate(format(p.get_height(), '.2f'),\n                    (p.get_x() + p.get_width() \/ 2., p.get_height()),\n                    ha='center', va='center',\n                    xytext=(0, 9),\n                    textcoords='offset points')\n    # adjust legend\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_girls_secondary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    for _ in data.shape:\n        ger = (data['enrollment'] \/ data['age_12_to_16_years']) * 100\n        academic_year = data.academic_year\n    sns.set(font_scale=1)\n    sns.set_style(\"white\")\n    ax = ger.plot.bar(figsize=(15, 6), color='green')\n    sns.despine(left=True, bottom=True)\n    # label and title\n    ax.set_xticklabels(np.arange(len(academic_year)))\n    ax.set_title('Gross Enrollment Ratio (%) for Girls in secondary School In St. Lucia', size=18)\n    ax.set_xticklabels(academic_year)\n    for tick in ax.get_xticklabels():\n        tick.set_rotation(-30)\n    ax.set(xlabel='Academic Year', ylabel='Gross enrollment rate (%)')\n\n    # annotations\n    for p in ax.patches:\n        ax.annotate(format(p.get_height(), '.2f'),\n                    (p.get_x() + p.get_width() \/ 2., p.get_height()),\n                    ha='center', va='center',\n                    xytext=(0, 9),\n                    textcoords='offset points')\n    # adjust legend\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_secondary(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    data_boys = kwargs.get('data_boys')\n    data_girls = kwargs.get('data_girls')\n\n    for _ in data.shape:\n        ger_boys = (data_boys['enrollment'] \/ data_boys['age_12_to_16_years']) * 100\n        ger_girls = (data_girls['enrollment'] \/ data_girls['age_12_to_16_years']) * 100\n        academic_year = data_girls.academic_year\n        title = 'Trend of GER for Primary Schools in St. Lucia'\n        plt.figure(figsize=(10, 8))\n        plt.title(title)\n        plt.plot(academic_year, ger_boys, 'b-', label='boys')\n        plt.plot(academic_year, ger_girls, 'g-', label='girls')\n        plt.xticks(rotation=60)\n        # plt.ylim(0, max(y) + 100)\n        plt.ylabel(\"Gross Enrollment Ratio for boys and girls in Secondary School\")\n        plt.xlabel(\"Academic Year\")\n        plt.legend()\n        plt.grid()\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef clean_secondary_name(name):\n    name = re.sub(\"[^a-zA-Z]+\", \"\", name)\n    name = name.lower().replace('secondary', \"\")\n    name = name.replace('school', \"\")\n    return ' '.join(name.split())\n\n\ndef match_name(name, schools, district_dict):\n    for school in schools:\n        if clean_secondary_name(name) == clean_secondary_name(getattr(school, 'school_name')):\n            district_code = getattr(school, 'district_name_id')\n            district_dict[name] = district_code\n            return district_code\n    return None\n\n\ndef get_district(school_code, schools, district_dict):\n    for school in schools:\n        if int(getattr(school, 'school_code')) == school_code:\n            district = getattr(school, 'district_name_id')\n            district_dict[school_code] = district\n            return district\n    return None\n\n\ndef csec_performance_plot(data, district_1, district_2):\n    left_out = set()\n\n    df = pd.DataFrame(data.values())\n    plt.switch_backend('AGG')\n    years = [int(y) for y in df['year'].drop_duplicates()]\n    years.sort()\n    min_year = min(years)\n\n    schools = School.objects.all()\n    # schools = School.objects.filter(category_of_school='public secondary')\n\n    N_DISTRICTS = District.objects.count()\n    scores = np.zeros((len(years), N_DISTRICTS))\n    n_tests = np.zeros((len(years), N_DISTRICTS))\n    passing_scores = np.zeros((len(years), N_DISTRICTS))\n\n    # cache school to district matches\n    district_dict = {}\n\n    for index, row in df.iterrows():\n        school_code = int(row['school_id'])\n        if school_code in district_dict:\n            district = district_dict[school_code]\n        else:\n            district = get_district(school_code, schools, district_dict)\n        if not district:\n            left_out.add(row['school_id'])\n            continue\n        year = int(row['year']) - min_year\n        n_tests[year][district - 1] += 1\n        score = row['overall_grade']\n        if score == 'I' or score == 'II' or score == 'III':\n            scores[year][district - 1] += 1\n\n    passing_scores = 100 * scores \/ n_tests\n    passing_scores = pd.DataFrame(passing_scores)\n\n    labels = ['District ' + str(d + 1) for d in range(N_DISTRICTS)]\n    if not (district_1 and district_2):\n        for d in range(N_DISTRICTS):\n            plt.plot(years, passing_scores[d])\n    else:\n        plt.plot(years, passing_scores[district_1 - 1])\n        plt.plot(years, passing_scores[district_2 - 1])\n        labels = ['District ' + str(district_1), 'District ' + str(district_2)]\n    plt.xticks([min(years), max(years)])\n    plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 1.05))\n    plt.title(\"Percentage of Passing Scores (CSEC)\")\n    plt.tight_layout()\n    graph = get_image()\n\n    plt.clf()\n    passing_scores = passing_scores.T\n    passing_scores.columns = years\n    passing_scores.index = ['District ' + str(d + 1) for d in range(N_DISTRICTS)]\n    ax = sns.heatmap(passing_scores, annot=True)\n    plt.tight_layout()\n    heatmap = get_image()\n    return [graph, heatmap, left_out]\n\n\n# ===================================================================\n# Outlier detection at district level\n# ===================================================================\ndef get_outlier_district_plot(**kwargs):\n    plt.switch_backend('AGG')\n\n    school_enrollment = kwargs.get('x')\n    school_name = kwargs.get('y')\n\n    datamean = kwargs.get('data_mean')\n    input_school_type = kwargs.get('input_school_type')\n    academic_year = kwargs.get('academic_year')\n    district_input = kwargs.get('input_district')\n\n    fig, ax1 = plt.subplots(figsize=(10, 8))\n\n    ax1.set_title('Enrollment for District')\n    ax1.set_xlabel('School_Name')\n    ax1.set_ylabel('School_Scores')\n\n    ax1.bar(school_name, school_enrollment, color='b')\n\n    for tick in ax1.xaxis.get_major_ticks():\n        tick.label.set_fontsize(8)\n        tick.label.set_rotation('15')\n    plt.plot(school_name, datamean, linewidth=5, ls='solid', color='r')\n\n    plt.xlabel(\"School Name\")\n    plt.ylabel(\"Enrollment\")\n\n    plt.title(\n        \"Enrollment for \" + input_school_type + \" schools for district \" + district_input + \" and \" + academic_year + \" academic year \")\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\n# ==========================================================================\n# Outlier detection at national level\n# ==========================================================================\n\ndef get_outlier_national_plot(**kwargs):\n    plt.switch_backend('AGG')\n\n    school_enrollment = kwargs.get('x')\n    school_name = kwargs.get('y')\n\n    datamean = kwargs.get('data_mean')\n    input_school_type = kwargs.get('input_school_type')\n    academic_year = kwargs.get('academic_year')\n\n    fig, ax1 = plt.subplots(figsize=(12, 10))\n\n    ax1.set_title('Enrollment for Selected Year')\n    ax1.set_xlabel('School_Name')\n\n    ax1.bar(school_name, school_enrollment, width=0.1, color='b')\n    for tick in ax1.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        tick.label.set_rotation('vertical')\n    plt.plot(school_name, datamean, linewidth=3, ls='solid', color='r')\n\n    plt.xlabel(\"School Name\")\n    plt.ylabel(\"Enrollment\")\n    plt.title(\"Enrollment for \" + input_school_type + \" schools for year \" + academic_year)\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_regression(**kwargs):\n    plt.switch_backend('AGG')\n    plt.figure(figsize=(10, 8))\n\n    data = kwargs.get('data')\n    sns.set_theme(color_codes=True)\n    sns.regplot(x=data.enrollment, y=data.gdp_millions, data=data, x_estimator=np.mean, label='GDP');\n    sns.regplot(x=data.enrollment, y=data.educational_expenditure, data=data, x_estimator=np.mean,\n                label='Educational Expenditure');\n    sns.regplot(x=data.enrollment, y=data.government_expenditure, data=data, x_estimator=np.mean,\n                label='Government Expenditure');\n    plt.xlabel(\"Enrollment\")\n    plt.ylabel(\"Expenditure\")\n    plt.title(\"Linear Regression - Enrollment \/ GDP \/ Education \/ government expenditure\")\n    plt.legend()\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_plot_gdp_regress(**kwargs):\n    plt.switch_backend('AGG')\n    plt.figure(figsize=(10, 8))\n    data = kwargs.get('data')\n    sns.set_theme(color_codes=True)\n    sns.jointplot(x=data.enrollment, y=data.gdp_millions, data=data, x_estimator=np.mean,\n                  label='GDP', kind=\"reg\");\n    plt.xlabel(\"Enrollment\")\n    plt.ylabel(\"Expenditure\")\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_enrollment_joint_pearsons(**kwargs):\n    plt.switch_backend('AGG')\n    plt.figure(figsize=(10, 8))\n    data = kwargs.get('data')\n    sns.set_theme(color_codes=True)\n    import scipy.stats as stats\n    graph = sns.jointplot(data=data, x=data.enrollment, y=data.gdp_millions)\n    r, p = stats.pearsonr(x=data.enrollment, y=data.gdp_millions)\n    phantom, = graph.ax_joint.plot([], [], linestyle=\"\", alpha=0)\n    # here graph is not a ax but a joint grid, so we access the axis through ax_joint method\n    graph.ax_joint.legend([phantom], ['r={:f}, p={:f}'.format(r, p)])\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_enrollment_joint_spearman(**kwargs):\n    plt.switch_backend('AGG')\n    plt.figure(figsize=(10, 8))\n    data = kwargs.get('data')\n    sns.set_theme(color_codes=True)\n    graph = sns.jointplot(data=data, x=data.enrollment, y=data.gdp_millions)\n    r, p = stats.spearmanr(data.enrollment, data.gdp_millions)\n    phantom, = graph.ax_joint.plot([], [], linestyle=\"\", alpha=0)\n    # here graph is not a ax but a joint grid, so we access the axis through ax_joint method\n\n    graph.ax_joint.legend([phantom], ['r={:f}, p={:f}'.format(r, p)])\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_enrollment_multicollinearity(**kwargs):\n    plt.figure(figsize=(10, 8))\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    data = data[[\"educational_expenditure\", \"gdp_millions\", \"government_expenditure\", \"primary_school_expenditure\",\n                 \"secondary_school_expenditure\", \"enrollment\", \"age_5_to_11_years\", \"age_12_to_16_years\"]]\n    sns.set(style='white')\n    corr = data.corr()\n    mask = np.zeros_like(corr, dtype=np.bool)\n    mask[np.triu_indices_from(mask)] = True\n    f, ax = plt.subplots(figsize=(12, 10))\n    cmap = sns.diverging_palette(220, 10, as_cmap=True)\n    sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.9, center=0, square=True, linewidths=.5, annot=True,\n                cbar_kws={'shrink': .5});\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_kernel_density(**kwargs):\n    plt.figure(figsize=(10, 8))\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    sns.kdeplot(data=data.enrollment)\n    sns.despine()\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef plot_national_gender_enrollment(**kwargs):\n    plt.switch_backend('AGG')\n    data_boys_primary = kwargs.get('data_boys_primary')\n    data_boys_secondary = kwargs.get('data_boys_secondary')\n    data_girls_primary = kwargs.get('data_girls_primary')\n    data_girls_secondary = kwargs.get('data_girls_secondary')\n    title = 'Trend in enrollments over time'\n    plt.figure(figsize=(10, 8))\n    plt.title(title)\n    plt.plot(data_boys_primary['academic_year'], data_boys_primary['enrollment'], 'b-',\n             label='Boys enrolled in Primary School')\n    plt.plot(data_boys_secondary['academic_year'], data_boys_secondary['enrollment'], 'bo',\n             label='Boys enrolled in Secondary School')\n    plt.plot(data_girls_primary['academic_year'], data_girls_primary['enrollment'], 'r-',\n             label='Girls enrolled in Primary School')\n    plt.plot(data_girls_secondary['academic_year'], data_girls_secondary['enrollment'], 'ro',\n             label='Girls enrolled in secondary School')\n\n    plt.xticks(rotation=60)\n    # plt.ylim(0, max(y) + 100)\n    plt.ylabel(\"National Enrollment Trends\")\n    plt.xlabel(\"Academic Year\")\n    plt.legend()\n    plt.grid()\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef national_gender_enrollment_hist(**kwargs):\n    data_boys_primary = kwargs.get('data_boys_primary')\n    data_boys_secondary = kwargs.get('data_boys_secondary')\n    data_girls_primary = kwargs.get('data_girls_primary')\n    data_girls_secondary = kwargs.get('data_girls_secondary')\n\n    # boys primary mean of distribution\n    mu_boys_primary = mean(data_boys_primary.enrollment)\n    mu_girls_primary = mean(data_girls_primary.enrollment)\n    mu_boys_secondary = mean(data_boys_secondary.enrollment)\n    mu_girls_secondary = mean(data_girls_secondary.enrollment)\n\n    sigma_boys_primary = std(data_boys_primary.enrollment)\n    sigma_girls_primary = std(data_girls_primary.enrollment)\n    sigma_boys_secondary = std(data_boys_secondary.enrollment)\n    sigma_girls_secondary = std(data_girls_secondary.enrollment)\n\n    x_mu_boys_primary = mu_boys_primary + sigma_boys_primary * np.random.randn(437)\n    x_mu_girls_primary = mu_girls_primary + sigma_girls_primary * np.random.randn(437)\n    x_mu_boys_secondary = mu_boys_secondary + sigma_boys_secondary * np.random.randn(437)\n    x_mu_girls_secondary = mu_girls_secondary + sigma_girls_secondary * np.random.randn(437)\n    num_bins = 50\n\n    # fig, ax = plt.subplots()\n\n    fig, axs = plt.subplots(2, 2, figsize=(15, 15))\n\n    # the histogram of the data\n    n_boys_primary, bins_boys_primary, patches_boys_primary = axs[0, 0].hist(x_mu_boys_primary, num_bins, density=True)\n    n_boys_secondary, bins_boys_secondary, patches_boys_secondary = axs[0, 1].hist(x_mu_boys_secondary, num_bins,\n                                                                                   density=True)\n    n_girls_primary, bins_girls_primary, patches_girls_primary = axs[1, 0].hist(x_mu_girls_primary, num_bins,\n                                                                                density=True)\n    n_girls_secondary, bins_girls_secondary, patches_girls_secondary = axs[1, 1].hist(x_mu_girls_secondary, num_bins,\n                                                                                      density=True)\n    # add a 'best fit' line\n    y_boys_primary = ((1 \/ (np.sqrt(2 * np.pi) * sigma_boys_primary)) *\n                      np.exp(-0.5 * (1 \/ sigma_boys_primary * (bins_boys_primary - mu_boys_primary)) ** 2))\n    y_boys_secondary = ((1 \/ (np.sqrt(2 * np.pi) * sigma_boys_secondary)) *\n                        np.exp(-0.5 * (1 \/ sigma_boys_secondary * (bins_boys_secondary - mu_boys_secondary)) ** 2))\n    y_girls_primary = ((1 \/ (np.sqrt(2 * np.pi) * sigma_girls_primary)) *\n                       np.exp(-0.5 * (1 \/ sigma_girls_primary * (bins_girls_primary - mu_girls_primary)) ** 2))\n\n    y_girls_secondary = ((1 \/ (np.sqrt(2 * np.pi) * sigma_girls_secondary)) *\n                         np.exp(-0.5 * (1 \/ sigma_girls_secondary * (bins_girls_secondary - mu_girls_secondary)) ** 2))\n\n    for ax in axs.flat:\n        ax.set(xlabel='Enrollment', ylabel='Probability Density')\n\n    # Hide x labels and tick labels for top plots and y ticks for right plots.\n    for ax in axs.flat:\n        ax.label_outer()\n\n    axs[0, 0].plot(bins_boys_primary, y_boys_primary, '--')\n    axs[0, 0].set_title('Primary-Boys')\n\n    axs[0, 1].plot(bins_boys_secondary, y_boys_secondary, '--')\n    axs[0, 1].set_title('Secondary-Boys')\n\n    axs[1, 0].plot(bins_girls_primary, y_girls_primary, '--')\n    axs[1, 0].set_title('Primary-Girls')\n\n    axs[1, 1].plot(bins_girls_secondary, y_girls_secondary, '--')\n    axs[1, 1].set_title('Secondary-Girls')\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef plot_national_education_census(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n\n    title = 'Education Census Over time'\n    plt.figure(figsize=(10, 8))\n    plt.title(title)\n    plt.plot(data['academic_year'], data['age_3_to_4_years'], 'b-',\n             label='Population of Age Group 3-4')\n    plt.plot(data['academic_year'], data['age_5_to_11_years'], 'y-',\n             label='Population of Age Group > 5 and less than 12')\n    plt.plot(data['academic_year'], data['age_12_to_16_years'], 'r-',\n             label='population of children above 12 years old')\n\n    plt.xticks(rotation=60)\n    # plt.ylim(0, max(y) + 100)\n    plt.ylabel(\"Education Census Trends\")\n    plt.xlabel(\"Academic Year\")\n    plt.legend()\n    plt.grid()\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef national_education_census_hist(**kwargs):\n    data = kwargs.get('data')\n    # boys primary mean of distribution\n    mu_data_3_4 = mean(data.age_3_to_4_years)\n    mu_data_5_11 = mean(data.age_5_to_11_years)\n    mu_data_12_16 = mean(data.age_12_to_16_years)\n\n    sigma_data_3_4 = std(data.age_3_to_4_years)\n    sigma_data_5_11 = std(data.age_5_to_11_years)\n    sigma_data_12_16 = std(data.age_12_to_16_years)\n\n    x_mu_data_3_4 = mu_data_3_4 + sigma_data_3_4 * np.random.randn(437)\n    x_mu_data_5_11 = mu_data_5_11 + sigma_data_5_11 * np.random.randn(437)\n    x_mu_data_12_16 = mu_data_12_16 + sigma_data_12_16 * np.random.randn(437)\n    num_bins = 50\n\n    # fig, ax = plt.subplots()\n\n    fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(15, 15))\n\n    # the histogram of the data\n    n_3_4, bins_3_4, patches_3_4 = ax1.hist(x_mu_data_3_4, num_bins, density=True)\n    n_5_11, bins_5_11, patches_5_11 = ax2.hist(x_mu_data_5_11, num_bins, density=True)\n    n_12_16, bins_12_16, patches_12_16 = ax3.hist(x_mu_data_12_16, num_bins, density=True)\n\n    # add a 'best fit' line\n    y_3_4 = ((1 \/ (np.sqrt(2 * np.pi) * sigma_data_3_4)) *\n             np.exp(-0.5 * (1 \/ sigma_data_3_4 * (bins_3_4 - mu_data_3_4)) ** 2))\n    y_5_11 = ((1 \/ (np.sqrt(2 * np.pi) * sigma_data_5_11)) *\n              np.exp(-0.5 * (1 \/ sigma_data_5_11 * (bins_5_11 - mu_data_5_11)) ** 2))\n    y_12_16 = ((1 \/ (np.sqrt(2 * np.pi) * sigma_data_12_16)) *\n               np.exp(-0.5 * (1 \/ sigma_data_12_16 * (bins_12_16 - mu_data_12_16)) ** 2))\n\n    ax1.plot(bins_3_4, y_3_4, '--')\n    ax1.set_title('3 - 4 years')\n\n    ax2.plot(bins_5_11, y_5_11, '--')\n    ax2.set_title('Greater \/ equal 5, Less than 12')\n\n    ax3.plot(bins_12_16, y_12_16, '--')\n    ax3.set_title('>=12 years')\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef plot_national_expenditure(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    title = 'Education Expenditure'\n    plt.figure(figsize=(10, 8))\n    plt.title(title)\n    plt.plot(data['academic_year'], data.educational_expenditure, 'b-',\n             label='Educational Expenditure')\n    plt.plot(data['academic_year'], data['gdp_millions'], 'y-',\n             label='GDP (Million XCD)')\n    plt.plot(data['academic_year'], data['government_expenditure'], 'r-',\n             label='Government Expenditure')\n    plt.plot(data['academic_year'], data['primary_school_expenditure'], 'g-',\n             label='Primary School Expenditure')\n    plt.plot(data['academic_year'], data['secondary_school_expenditure'], 'k-',\n             label='Secondary School Expenditure')\n\n    plt.xticks(rotation=60)\n    # plt.ylim(0, max(y) + 100)\n    plt.ylabel(\"Expenditure Trends\")\n    plt.xlabel(\"Academic Year\")\n    plt.legend()\n    plt.grid()\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef national_expenditure_hist(**kwargs):\n    data = kwargs.get('data')\n    mu_educational_expenditure = mean(data['educational_expenditure'])\n    mu_gdp_millions = mean(data['gdp_millions'])\n    mu_government_expenditure = mean(data['government_expenditure'])\n    mu_primary_school_expenditure = mean(data['primary_school_expenditure'])\n    mu_secondary_school_expenditure = mean(data['secondary_school_expenditure'])\n\n    sigma_educational_expenditure = std(data.educational_expenditure)\n    sigma_gdp_millions = std(data.gdp_millions)\n    sigma_government_expenditure = std(data.government_expenditure)\n    sigma_primary_school_expenditure = std(data.primary_school_expenditure)\n    sigma_secondary_school_expenditure = std(data.secondary_school_expenditure)\n\n    x_mu_educational_expenditure = mu_educational_expenditure + sigma_educational_expenditure * np.random.randn(437)\n    x_mu_gdp_millions = mu_gdp_millions + sigma_gdp_millions * np.random.randn(437)\n    x_mu_government_expenditure = mu_government_expenditure + sigma_government_expenditure * np.random.randn(437)\n    x_mu_primary_school_expenditure = mu_primary_school_expenditure + sigma_primary_school_expenditure * np.random.randn(\n        437)\n    x_mu_secondary_school_expenditure = mu_secondary_school_expenditure + sigma_secondary_school_expenditure * np.random.randn(\n        437)\n    num_bins = 50\n\n    # fig, ax = plt.subplots()\n\n    fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, figsize=(15, 15))\n\n    # the histogram of the data\n    n_educational_expenditure, bins_educational_expenditure, patches_educational_expenditure = \\\n        ax1.hist(x_mu_educational_expenditure, num_bins, density=True)\n    n_gdp_millions, bins_gdp_millions, patches_gdp_millions = \\\n        ax2.hist(x_mu_gdp_millions, num_bins, density=True)\n    n_government_expenditure, bins_government_expenditure, patches_government_expenditure = \\\n        ax3.hist(x_mu_government_expenditure, num_bins, density=True)\n    n_primary_school_expenditure, bins_primary_school_expenditure, patches_primary_school_expenditure = \\\n        ax4.hist(x_mu_primary_school_expenditure, num_bins, density=True)\n    n_secondary_school_expenditure, bins_secondary_school_expenditure, patches_secondary_school_expenditure = \\\n        ax5.hist(x_mu_secondary_school_expenditure, num_bins, density=True)\n    # add a 'best fit' line\n    y_educational_expenditure = ((1 \/ (np.sqrt(2 * np.pi) * sigma_educational_expenditure)) *\n                                 np.exp(-0.5 * (1 \/ sigma_educational_expenditure * (\n                                         bins_educational_expenditure - mu_educational_expenditure)) ** 2))\n    y_gdp_millions = ((1 \/ (np.sqrt(2 * np.pi) * sigma_gdp_millions)) *\n                      np.exp(-0.5 * (1 \/ sigma_gdp_millions * (bins_gdp_millions - mu_gdp_millions)) ** 2))\n    y_government_expenditure = ((1 \/ (np.sqrt(2 * np.pi) * sigma_government_expenditure)) *\n                                np.exp(-0.5 * (1 \/ sigma_government_expenditure * (\n                                        bins_government_expenditure - mu_government_expenditure)) ** 2))\n    y_primary_school_expenditure = ((1 \/ (np.sqrt(2 * np.pi) * sigma_primary_school_expenditure)) *\n                                    np.exp(-0.5 * (1 \/ sigma_primary_school_expenditure * (\n                                            bins_primary_school_expenditure - mu_primary_school_expenditure)) ** 2))\n    y_secondary_school_expenditure = ((1 \/ (np.sqrt(2 * np.pi) * sigma_secondary_school_expenditure)) *\n                                      np.exp(-0.5 * (1 \/ sigma_secondary_school_expenditure * (\n                                              bins_secondary_school_expenditure - mu_secondary_school_expenditure)) ** 2))\n\n    ax1.plot(bins_educational_expenditure, y_educational_expenditure, '--')\n    ax1.set_title('Educational Expenditure')\n\n    ax2.plot(bins_gdp_millions, y_gdp_millions, '--')\n    ax2.set_title('gdp(Million XCD)')\n\n    ax3.plot(bins_government_expenditure, y_government_expenditure, '--')\n    ax3.set_title('Government Expenditure')\n\n    ax4.plot(bins_primary_school_expenditure, y_primary_school_expenditure, '--')\n    ax4.set_title('Primary School Expenditure')\n\n    ax5.plot(bins_secondary_school_expenditure, y_secondary_school_expenditure, '--')\n    ax5.set_title('Secondary School Expenditure')\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef primary_performance_plot(data, district_1, district_2):\n    df = pd.DataFrame(data.values())\n    plt.switch_backend('AGG')\n    years = df['academic_year'].drop_duplicates().str.split(\"\/\")\n    years = [int(y[1]) for y in years]\n    min_year = min(years)\n\n    N_DISTRICTS = District.objects.count()\n\n    tests = np.zeros((len(years), N_DISTRICTS), dtype=int)\n    above_avg = np.zeros((len(years), N_DISTRICTS), dtype=int)\n    performance = np.zeros((len(years), N_DISTRICTS), dtype=float)\n\n    for index, row in df.iterrows():\n        year = int(row['academic_year'].split('\/')[1])\n        school_code = row['school_id']\n        school = School.objects.get(school_code=school_code)\n        district = getattr(school, 'district_name_id')\n        n_tests = int(row['tests_sat'])\n        n_above_avg = int(row['above_average_scores'])\n        if np.isnan(n_tests) or np.isnan(n_above_avg):\n            continue\n        tests[year - min_year][district - 1] += n_tests\n        above_avg[year - min_year][district - 1] += n_above_avg\n\n    for y in range(len(years)):\n        performance[y] = 100 * above_avg[y] \/ tests[y]\n    performance = pd.DataFrame(performance)\n    labels = ['District ' + str(d + 1) for d in range(N_DISTRICTS)]\n    if not (district_1 and district_2):\n        for d in range(N_DISTRICTS):\n            plt.plot(years, performance[d])\n    else:\n        plt.plot(years, performance[district_1 - 1])\n        plt.plot(years, performance[district_2 - 1])\n        labels = ['District ' + str(district_1), 'District' + str(district_2)]\n    plt.xticks([min(years), max(years)])\n    plt.legend(labels, loc='upper left', bbox_to_anchor=(1, 1.05))\n    plt.title(\"Percentage of Students Scoring Above Mean (CEE)\")\n    plt.tight_layout()\n    graph = get_image()\n\n    plt.clf()\n    performance = performance.T\n    performance.columns = np.arange(1999, 2018, step=1)\n    performance.index = ['District ' + str(d + 1) for d in range(N_DISTRICTS)]\n    ax = sns.heatmap(performance, annot=True)\n    ax.set_title(\"Percentage of Students Scoring above Mean (CEE)\")\n    plt.tight_layout()\n    heatmap = get_image()\n    return [graph, heatmap]\n\n\ndef get_sex(character):\n    if character == \"F\":\n        return \"female\"\n    else:\n        return \"male\"\n\n\ndef store_scores(data, required_fields, user_data, type):\n    result = {}\n    lines = data.replace(\"\\r\", \"\").split(\"\\n\")\n    field_names = lines[0].split(\",\")\n    if not set(required_fields).issubset(set(field_names)):\n        diff = set(required_fields) - set(field_names)\n        missing_fields = []\n        for d in diff:\n            missing_fields.append(d)\n        result['missing_fields'] = missing_fields\n        result['error_message'] = 'The following fields are missing:\\n'\n        result['n_scores'] = 0\n    else:\n        succeeded = 0\n        failed = 0\n        for line in lines[1:]:\n            if line:\n                fields = line.split(\",\")\n                data = {}\n                for required_field in required_fields:\n                    if required_field == \"school_id\":\n                        data[\"school\"] = fields[field_names.index(\"school_id\")]\n                    elif required_field == \"primsch_id\":\n                        data[\"primsch\"] = fields[field_names.index(\"primsch_id\")]\n                    elif required_field == \"secsch_id\":\n                        data[\"secsch\"] = fields[field_names.index(\"secsch_id\")]\n                    elif required_field == \"district_id\":\n                        data[\"district\"] = fields[field_names.index(\"district_id\")]\n                    elif required_field == \"sex\":\n                        data[\"sex\"] = get_sex(fields[field_names.index(required_field)])\n                    else:\n                        data[required_field] = fields[field_names.index(required_field)]\n                data = {**data, **user_data}\n                if type == \"CEE\":\n                    form = CEEForm(data)\n                if type == \"CSEC\":\n                    form = CSECForm(data)\n                if form.is_valid():\n                    form.save()\n                    succeeded += 1\n                else:\n                    failed += 1\n        result['n_scores'] = succeeded\n        result['failed'] = failed\n    return result\n\n\n# =======================================================================================\n# Box plots at district level\n# =======================================================================================\n\ndef get_boxplot_district_plot(**kwargs):\n    plt.switch_backend('AGG')\n\n    school_enrollment = kwargs.get('x')\n    school_name = kwargs.get('y')\n\n    input_school_type = kwargs.get('input_school_type')\n    academic_year = kwargs.get('academic_year')\n    district_input = kwargs.get('input_district')\n\n    fig, ax1 = plt.subplots(figsize=(11, 6))\n\n    plt.boxplot(school_enrollment, patch_artist=True,\n                boxprops=dict(facecolor='purple'),\n                meanline=True, showmeans=True)\n\n    plt.xticks([1], [input_school_type])\n    plt.ylabel('Enrollment')\n    plt.title(\n        \"Box Plot for Enrollment in \" + input_school_type + \" schools  in \" + \" District\" + district_input + \" and academic year \" + academic_year)\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\n# =========================================================================================\n# Box plots at national level\n# =========================================================================================\n\ndef get_boxplot_national_plot(**kwargs):\n    plt.switch_backend('AGG')\n\n    school_enrollment = kwargs.get('x')\n    school_name = kwargs.get('y')\n\n    input_school_type = kwargs.get('input_school_type')\n    academic_year = kwargs.get('academic_year')\n\n    fig, ax1 = plt.subplots(figsize=(11, 6))\n\n    plt.boxplot(school_enrollment, patch_artist=True,\n                boxprops=dict(facecolor='purple'),\n                meanline=True, showmeans=True)\n\n    plt.xticks([1], [input_school_type])\n    plt.ylabel('Enrollment')\n    plt.title(\"Box Plot for Enrollment in \" + input_school_type + \" schools \" + \" for academic year \" + academic_year)\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef plot_national_ratio_trend(**kwargs):\n    plt.switch_backend('AGG')\n    data_primary = kwargs.get('data_primary')\n    data_secondary = kwargs.get('data_secondary')\n    for _ in data_secondary.shape:\n        school_enrollment = data_secondary.total_enrollment\n        total_number_of_teachers_secondary = data_secondary.total_number_of_teachers\n        academic_year = data_secondary.academic_year\n        student_teacher_ratio_secondary = (\n            (school_enrollment \/ total_number_of_teachers_secondary).replace(np.inf, 0)).astype(float)\n        fig, ax = plt.subplots(figsize=(12, 10))\n        ax.bar(academic_year, student_teacher_ratio_secondary, width=0.8, color='b',\n               label='Student to teacher ratio in Secondary Schools'\n               , alpha=0.5)\n        ax.set_ylabel(\"Student - Teacher Ratio (7-11)\")\n\n        for tick in ax.xaxis.get_major_ticks():\n            tick.label.set_fontsize(10)\n            tick.label.set_rotation(45)\n        for bar in ax.patches:\n            plt.annotate(format(bar.get_height(), '.2f'),\n                         (bar.get_x() + bar.get_width() \/ 2,\n                          bar.get_height()), ha='center', va='center',\n                         size=7, xytext=(0, 5),\n                         textcoords='offset points')\n            plt.title(\"Student to Teacher Ratio Trends in Secondary Schools\")\n            plt.xlabel('Academic Year')\n            ax.set_ylim([0, max(student_teacher_ratio_secondary) + 100])\n\n            ax.legend()\n\n    plt.tight_layout()\n    # plt.grid()\n    graph = get_image()\n    return graph\n\n\ndef plot_national_ratio_trend_primary(**kwargs):\n    plt.switch_backend('AGG')\n    data_primary = kwargs.get('data_primary')\n    for _ in data_primary.shape:\n        school_enrollment = data_primary.total_enrollment\n        total_number_of_teachers_primary = data_primary.total_number_of_teachers\n        academic_year = data_primary.academic_year\n        student_teacher_ratio_primary = (\n            (school_enrollment \/ total_number_of_teachers_primary).replace(np.inf, 0)).astype(float)\n        fig, ax = plt.subplots(figsize=(12, 10))\n        ax.bar(academic_year, student_teacher_ratio_primary, width=0.8, color='g',\n               label='Student to teacher ratio in Primary Schools'\n               , alpha=0.5)\n        ax.set_ylabel(\"Student - Teacher Ratio (k-6)\")\n\n    for tick in ax.xaxis.get_major_ticks():\n        tick.label.set_fontsize(10)\n        tick.label.set_rotation(45)\n    for bar in ax.patches:\n        plt.annotate(format(bar.get_height(), '.2f'),\n                     (bar.get_x() + bar.get_width() \/ 2,\n                      bar.get_height()), ha='center', va='center',\n                     size=7, xytext=(0, 5),\n                     textcoords='offset points')\n        plt.title(\"Student to Teacher Ratio Trends in Primary Schools\")\n        plt.xlabel('Academic Year')\n        ax.set_ylim([0, max(student_teacher_ratio_primary) + 100])\n\n        ax.legend()\n    plt.tight_layout()\n    # plt.grid()\n    graph = get_image()\n    return graph\n\n\ndef national_ratio_hist(**kwargs):\n    plt.switch_backend('AGG')\n    data = kwargs.get('data')\n    mu_total_enrollment = mean(data['total_enrollment'])\n    mu_number_of_trained_male_teachers = mean(data['number_of_trained_male_teachers'])\n    mu_number_of_trained_female_teachers = mean(data['number_of_trained_female_teachers'])\n    mu_number_of_untrained_male_teachers = mean(data['number_of_untrained_male_teachers'])\n    mu_number_of_untrained_female_teachers = mean(data['number_of_untrained_female_teachers'])\n    mu_total_no_of_teachers = mean(data['total_number_of_teachers'])\n\n    sigma_total_enrollment = std(data['total_enrollment'])\n    sigma_number_of_trained_male_teachers = std(data['number_of_trained_male_teachers'])\n    sigma_number_of_trained_female_teachers = std(data['number_of_trained_female_teachers'])\n    sigma_number_of_untrained_male_teachers = std(data['number_of_untrained_male_teachers'])\n    sigma_number_of_untrained_female_teachers = std(data['number_of_untrained_female_teachers'])\n    sigma_total_no_of_teachers = std(data['total_number_of_teachers'])\n\n    x_mu_total_enrollment = mu_total_enrollment + sigma_total_enrollment * np.random.randn(437)\n    x_mu_number_of_trained_male_teachers = mu_number_of_trained_male_teachers + sigma_number_of_trained_male_teachers * np.random.randn(\n        437)\n    x_mu_number_of_trained_female_teachers = mu_number_of_trained_female_teachers + sigma_number_of_trained_female_teachers * np.random.randn(\n        437)\n    x_mu_number_of_untrained_male_teachers = mu_number_of_untrained_male_teachers + sigma_number_of_untrained_male_teachers * np.random.randn(\n        437)\n    x_mu_number_of_untrained_female_teachers = mu_number_of_untrained_female_teachers + sigma_number_of_untrained_female_teachers * np.random.randn(\n        437)\n    x_mu_total_no_of_teachers = mu_total_no_of_teachers + sigma_total_no_of_teachers * np.random.randn(\n        437)\n    num_bins = 50\n\n    # fig, ax = plt.subplots()\n\n    fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, figsize=(15, 15))\n\n    # the histogram of the data\n    n_total_enrollment, bins_total_enrollment, patches_total_enrollment = \\\n        ax1.hist(x_mu_total_enrollment, num_bins, density=True)\n    n_number_of_trained_male_teachers, bins_number_of_trained_male_teachers, patches_number_of_trained_male_teachers = \\\n        ax2.hist(x_mu_number_of_trained_male_teachers, num_bins, density=True)\n    n_number_of_trained_female_teachers, bins_number_of_trained_female_teachers, patches_number_of_trained_female_teachers = \\\n        ax3.hist(x_mu_number_of_trained_female_teachers, num_bins, density=True)\n    n_number_of_untrained_male_teachers, bins_number_of_untrained_male_teachers, patches_number_of_untrained_male_teachers = \\\n        ax4.hist(x_mu_number_of_untrained_male_teachers, num_bins, density=True)\n    n_number_of_untrained_female_teachers, bins_number_of_untrained_female_teachers, patches_number_of_untrained_female_teachers = \\\n        ax5.hist(x_mu_number_of_untrained_female_teachers, num_bins, density=True)\n    n_total_number_of_teachers, bins_total_number_of_teachers, patches_total_number_of_teachers = \\\n        ax6.hist(x_mu_total_no_of_teachers, num_bins, density=True)\n    # add a 'best fit' line\n    y_total_enrollment = ((1 \/ (np.sqrt(2 * np.pi) * sigma_total_enrollment)) *\n                          np.exp(-0.5 * (1 \/ sigma_total_enrollment * (\n                                  bins_total_enrollment - mu_total_enrollment)) ** 2))\n    y_number_of_trained_male_teachers = ((1 \/ (np.sqrt(2 * np.pi) * sigma_number_of_trained_male_teachers)) *\n                                         np.exp(-0.5 * (1 \/ sigma_number_of_trained_male_teachers * (\n                                                 bins_number_of_trained_male_teachers - mu_number_of_trained_male_teachers)) ** 2))\n    y_number_of_trained_female_teachers = ((1 \/ (np.sqrt(2 * np.pi) * sigma_number_of_trained_female_teachers)) *\n                                           np.exp(-0.5 * (1 \/ sigma_number_of_trained_female_teachers * (\n                                                   bins_number_of_trained_female_teachers - mu_number_of_trained_female_teachers)) ** 2))\n    y_number_of_untrained_male_teachers = ((1 \/ (np.sqrt(2 * np.pi) * sigma_number_of_untrained_male_teachers)) *\n                                           np.exp(-0.5 * (1 \/ sigma_number_of_untrained_male_teachers * (\n                                                   bins_number_of_untrained_male_teachers - mu_number_of_untrained_male_teachers)) ** 2))\n    y_number_of_untrained_female_teachers = ((1 \/ (np.sqrt(2 * np.pi) * sigma_number_of_untrained_female_teachers)) *\n                                             np.exp(-0.5 * (1 \/ sigma_number_of_untrained_female_teachers * (\n                                                     bins_number_of_untrained_female_teachers - mu_number_of_untrained_female_teachers)) ** 2))\n    y_total_no_of_teachers = ((1 \/ (np.sqrt(2 * np.pi) * sigma_total_no_of_teachers)) *\n                              np.exp(-0.5 * (1 \/ sigma_total_no_of_teachers * (\n                                      bins_total_number_of_teachers - mu_total_no_of_teachers)) ** 2))\n\n    ax1.plot(bins_total_enrollment, y_total_enrollment, '--')\n    ax1.set_title('Total Enrollment')\n\n    ax2.plot(bins_number_of_trained_male_teachers, y_number_of_trained_male_teachers, '--')\n    ax2.set_title('Number of Trained Male Teachers')\n\n    ax3.plot(bins_number_of_trained_female_teachers, y_number_of_trained_female_teachers, '--')\n    ax3.set_title('Number of Trained Female Teachers')\n\n    ax4.plot(bins_number_of_untrained_male_teachers, y_number_of_untrained_male_teachers, '--')\n    ax4.set_title('Number of Untrained Male Teachers')\n\n    ax5.plot(bins_number_of_untrained_female_teachers, y_number_of_untrained_female_teachers, '--')\n    ax5.set_title('Untrained Female Teachers')\n\n    ax6.plot(bins_total_number_of_teachers, y_total_no_of_teachers, '--')\n    ax6.set_title('Total Number of Teachers')\n\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef get_prev_yr(year_string):\n    year = int(year_string.split(\"\/\")[0])\n    prev_year = year - 1\n    return str(prev_year) + \"\/\" + str(year)\n\n\ndef get_previous_performance(data):\n    previous = []\n    for index, row in data.iterrows():\n        previous_year = data.loc[(data['school_id'] == row['school_id']) &\n                                 (data['academic_year'] == get_prev_yr(row['academic_year']))]\n        if not previous_year.empty:\n            previous.append(previous_year['performance'].values[0])\n        else:\n            previous.append(np.nan)\n\n    previous = pd.Series(previous)\n    data['previous'] = previous\n    return data\n\n\ndef get_enrollment(data):\n    enrollment = []\n    capacity = []\n    found = 0\n    not_found = 0\n    for index, row in data.iterrows():\n        school = AggregateEnrollment.objects.filter(name_of_school_id=row['school_id'],\n                                                    academic_year=row['academic_year'])\n        if school:\n            enr = getattr(school[0], 'total_enrollment')\n            enrollment.append(enr)\n            capacity.append(enr \/ getattr(school[0], 'capacity_of_school'))\n        else:\n            enrollment.append(np.nan)\n            capacity.append(np.nan)\n\n    enrollment = pd.Series(enrollment)\n    data['enrollment'] = enrollment\n    capacity = pd.Series(capacity)\n    data['capacity'] = capacity\n    return data\n\n\ndef divide_by_enrollment(data):\n    data['teachers'] = data['enrollment'] \/ data['teachers']\n    data['girls'] = data['girls'] \/ data['enrollment']\n    data['total_bursaries'] = data['total_bursaries'] \/ data['enrollment']\n    data['feeding_program'] = data['feeding_program'] \/ data['enrollment']\n    data['repeaters'] = data['repeaters'] \/ data['enrollment']\n    data['trained_teachers'] = data['trained_teachers'] \/ data['teachers']\n    data['primary_enrollment'] = data['primary_enrollment'] \/ data['enrollment']\n    return data\n\n\ndef correlations(data, excluded_fields):\n    plt.switch_backend('AGG')\n    data = pd.DataFrame(data.values())\n    data['performance'] = data['above_average_scores'] \/ data['tests_sat']\n    data = data.drop(columns=excluded_fields)\n\n    data = get_previous_performance(data)\n    data = get_enrollment(data)\n\n    data = data.drop(columns=['academic_year', 'school_id', 'above_average_scores', 'tests_sat'])\n    data = data.apply(pd.to_numeric)\n    data = divide_by_enrollment(data)\n\n    correlation = []\n    spearman = []\n    for f in data.columns:\n        if f == 'performance':\n            continue\n        df = data[data[f].notna()]\n        x = df[f]\n        y = df['performance']\n        correlation.append(stats.pearsonr(x, y))\n        spearman.append(stats.spearmanr(x, y))\n    correlation = pd.DataFrame(correlation)\n    spearman = pd.DataFrame(spearman)\n    correlation.columns = ['r (Pe)', 'p (Pe)']\n    correlation.index = data.columns.drop('performance')\n    spearman.index = data.columns.drop('performance')\n    correlation['r (Sp)'] = spearman['correlation']\n    correlation['p (Sp)'] = spearman['pvalue']\n\n    mask = np.zeros((len(correlation), 4))\n    mask[:, 3] = True\n    mask[:, 1] = True\n    ax = sns.heatmap(correlation, annot=True, mask=mask)\n    ax.set_title(\"Correlations between School Factors and Exam Performance\")\n\n    for (j, i), label in np.ndenumerate(correlation.values):\n        label = \"{:.2e}\".format(label)\n        if i == 1 or i == 3:\n            ax.text(i + 0.5, j + 0.5, label,\n                    fontdict=dict(ha='center', va='center', color='black'))\n    plt.tight_layout()\n    graph = get_image()\n    return graph\n\n\ndef dropcol_importances(rf, X_train, y_train):\n    r = random.randint(1, 999)\n    rf_ = clone(rf)\n    rf_.random_state = r\n    rf_.fit(X_train, y_train)\n    baseline = rf_.oob_score_\n    imp = []\n    for col in X_train.columns:\n        X = X_train.drop(col, axis=1)\n        rf_ = clone(rf)\n        rf_.random_state = r\n        rf_.fit(X, y_train)\n        o = rf_.oob_score_\n        imp.append(baseline - o)\n    imp = np.array(imp)\n    I = pd.DataFrame(\n        data={'Feature': X_train.columns,\n              'Importance': imp})\n    I = I.set_index('Feature')\n    I = I.sort_values('Importance', ascending=True)\n    return I\n\n\ndef rf_model(data, excluded_fields, random):\n    plt.switch_backend('AGG')\n    data = pd.DataFrame(data.values())\n    data['performance'] = data['above_average_scores'] \/ data['tests_sat']\n    data = data.drop(columns=excluded_fields)\n\n    data = get_previous_performance(data)\n    data = get_enrollment(data)\n    data = data.drop(columns=['academic_year', 'school_id', 'above_average_scores', 'tests_sat'])\n\n    data = data.apply(pd.to_numeric)\n    data = divide_by_enrollment(data)\n\n    imp_mean = SimpleImputer(missing_values=np.nan, strategy='median')\n    imp_mean.fit(data)\n    SimpleImputer()\n    imputed_data = pd.DataFrame(imp_mean.transform(data))\n    imputed_data.columns = data.columns\n    imputed_data.index = data.index\n\n    data = imputed_data\n\n    performance = data['performance']\n    data = data.drop(columns=['performance'])\n\n    X_train, X_test, y_train, y_test = train_test_split(data, performance, train_size=0.8)\n\n    clf = RandomForestRegressor(max_features=None, oob_score=True)\n    clf.fit(X_train, y_train)\n\n    accuracy = round(clf.score(X_test, y_test), 3)\n\n    data = data.drop(columns=['previous'])\n    if random:\n        data['random'] = pd.Series([random.random() for x in range(len(data))])\n    importance = dropcol_importances(clf, data, performance)\n\n    # plot feature importance\n    ax = pd.Series(importance['Importance']).plot(kind='barh')\n    y_labels = importance.index\n    ax.set_yticklabels(y_labels)\n    plt.xlabel(\"Change in OOB Error\")\n    plt.title(\"Random Forest Regression Feature Importance\")\n\n    plt.tight_layout()\n    graph = get_image()\n    return [graph, accuracy]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_601","text":"<gh_stars>0\n\"\"\"Models for estimating the aerodynamics of a 3D foil from its sections.\"\"\"\n\nfrom __future__ import annotations\n\nimport abc\nfrom typing import TYPE_CHECKING, Protocol, runtime_checkable\n\nimport numpy as np\nimport scipy.optimize\n\nfrom pfh.glidersim.util import cross3\n\n\nif TYPE_CHECKING:\n    from pfh.glidersim.foil import SimpleFoil\n\n\n__all__ = [\n    \"FoilAerodynamics\",\n    \"ConvergenceError\",\n    \"Phillips\",\n]\n\n\ndef __dir__():\n    return __all__\n\n\n@runtime_checkable\nclass FoilAerodynamics(Protocol):\n    \"\"\"Interface for classes that implement a FoilAerodynamics model.\"\"\"\n\n    @abc.abstractmethod\n    def __call__(self, ai, v_W2f, rho_air, **kwargs):\n        \"\"\"\n        Estimate the forces and moments on a foil.\n\n        Parameters\n        ----------\n        ai : array_like of float\n            Airfoil indices. The shape must be able to broadcast to (K,), where\n            `K` is the number of control points being used by the estimator.\n        v_W2f : array_like of float [m\/s]\n            The velocity of the wind relative to the control points in foil frd\n            coordinates. The shape must be able to broadcast to (K, 3), where\n            `K` is the number of control points being used by the estimator.\n        rho_air : array_like of float [kg\/m^3]\n            Air density\n        \"\"\"\n\n    @abc.abstractmethod\n    def r_CP2LE(self):\n        \"\"\"\n        Compute the control points for the section aerodynamics.\n\n        Returns\n        -------\n        ndarray of float, shape (K,3) [m]\n            Control points relative to the central leading edge `LE`.\n            Coordinates are in canopy frd, and `K` is the number of points\n            being used by the estimation method.\n        \"\"\"\n\n\nclass ConvergenceError(RuntimeError):\n    \"\"\"The estimator failed to converge on a solution.\"\"\"\n\n\nclass Phillips(FoilAerodynamics):\n    \"\"\"\n    A non-linear numerical lifting-line method.\n\n    Uses a set of spanwise bound vortices instead of a single, uniform lifting\n    line. Unlike the Prandtl's classic lifting-line theory, this method allows\n    for wing sweep and dihedral.\n\n    Parameters\n    ----------\n    foil : SimpleFoil\n        Defines the lifting-line and section coefficients.\n    v_ref_mag : float [m\/s]\n        The reference solution airspeed\n    alpha_ref : float [degrees]\n        The reference solution angle of attack\n    s_nodes : array_like of floats, shape (K+1,)\n        Section indices of the `K + 1` section nodes (wing segment endpoints).\n        The `K >= 1` aerodynamic control points are centered between the nodes.\n        Two common point distributions are:\n\n        * Linear: ``np.linspace(-1, 1, K + 1)``\n        * Cosine: ``np.cos(np.linspace(np.pi, 0, K + 1))``\n\n    s_clamp : float, optional\n        Section index to enable clamped output of the aerodynamic coefficients\n        for section indices `abs(s) >= s_clamp`. Instead of returning `nan`,\n        clamping uses the value of the largest `alpha` that produces a\n        non-`nan` coefficient for the given (ai, Re) pair.\n\n        This option is experimental and should be used with caution. Its\n        purpose is to mitigate the fictitious, large angles of attack induced\n        at the wing tips due to the control points being placed on the lifting\n        line. The theory is that if the induced velocity is indeed fictious,\n        then the true angle of attack is likely much closer to the standard\n        range. By limiting clamping to just the outer `s > s_clamp`, if the\n        wing is experiencing a genuinely large angle of attack, then the other\n        non-clamped sections will still fail, thus signalling stall conditions.\n        If the segments are small the error introduced should be negligible.\n\n    References\n    ----------\n    .. [1] <NAME>, \"Modern Adaptation of Prandtl’s Classic\n       Lifting-Line Theory\", Journal of Aircraft, 2000\n\n    .. [2] <NAME> Snyder, \"A lifting-line approach to estimating\n       propeller\/wing interactions\", 2006\n\n    .. [3] McLeanauth, \"Understanding Aerodynamics - Arguing from the Real\n       Physics\", 2013, p382\n\n    Notes\n    -----\n    This implementation uses a single distribution for the entire span, which\n    is suitable for parafoils, which is a continuous lifting surface, but for\n    wings with left and right segments separated by some discontinuity at the\n    root you should distribute the points across each semispan independently.\n    See [1]_ for a related discussion.\n\n    This method does suffer an issue where induced velocity goes to infinity as\n    the segment lengths tend toward zero (as the number of segments increases,\n    or for a poorly chosen point distribution). See [2]_, section 8.2.3.\n    \"\"\"\n\n    def __init__(\n        self,\n        foil: SimpleFoil,\n        v_ref_mag,\n        alpha_ref: float,\n        s_nodes,\n        s_clamp: float | None = None,\n    ) -> None:\n        self.foil = foil\n        self.K = len(s_nodes) - 1  # Number of control points\n        self.s_nodes = np.asarray(s_nodes)\n        self.nodes = self.foil.surface_xyz(self.s_nodes, 0, 0.25, surface=\"chord\")\n        self.s_cps = (self.s_nodes[1:] + self.s_nodes[:-1]) \/ 2\n        self.cps = self.foil.surface_xyz(self.s_cps, 0, 0.25, surface=\"chord\")\n\n        # Enable clamped coefficients at some control points\n        if s_clamp is not None:\n            self.clamped = np.abs(self.s_cps) >= s_clamp\n        else:\n            self.clamped = np.full(self.K, False)\n\n        # axis0 are nodes, axis1 are control points, axis2 are vectors or norms\n        self.R1 = self.cps - self.nodes[:-1, None]\n        self.R2 = self.cps - self.nodes[1:, None]\n        self.r1 = np.linalg.norm(self.R1, axis=2)  # Magnitudes of R_{i1,j}\n        self.r2 = np.linalg.norm(self.R2, axis=2)  # Magnitudes of R_{i2,j}\n\n        # Wing section orientation unit vectors at each control point\n        # Note: Phillip's derivation uses back-left-up coordinates (not `frd`)\n        u = -self.foil.section_orientation(self.s_cps).T\n        self.u_a, self.u_s, self.u_n = u[0].T, u[1].T, u[2].T\n\n        # Define the differential areas as parallelograms by assuming a linear\n        # chord variation between nodes.\n        self.dl = self.nodes[1:] - self.nodes[:-1]\n        node_chords = self.foil.chord_length(self.s_nodes)\n        self.c_avg = (node_chords[1:] + node_chords[:-1]) \/ 2\n        self.dA = self.c_avg * np.linalg.norm(cross3(self.u_a, self.dl), axis=1)\n\n        # Precompute the `v` terms that do not depend on `u_inf`, which are the\n        # first bracketed term in Hunsaker Eq:6.\n        R1, R2, r1, r2 = self.R1, self.R2, self.r1, self.r2  # Shorthand\n        self.v_ij = np.zeros((self.K, self.K, 3))  # Extra terms when `i != j`\n        for ij in [(i, j) for i in range(self.K) for j in range(self.K)]:\n            if ij[0] == ij[1]:  # Skip singularities when `i == j`\n                continue\n            self.v_ij[ij] = (\n                ((r1[ij] + r2[ij]) * cross3(R1[ij], R2[ij]))  # fmt: skip\n                \/ (r1[ij] * r2[ij] * (r1[ij] * r2[ij] + np.dot(R1[ij], R2[ij])))\n            )\n\n        # Precompute a reference solution from a (hopefully easy) base case.\n        # Sets an initial \"solution\" (which isn't actually a solution) just to\n        # bootstrap the `__call__` method with an initial `Gamma` value.\n        alpha_ref = np.deg2rad(alpha_ref)\n        v_mag = np.broadcast_to(v_ref_mag, (self.K, 3))\n        v_W2f_ref = -v_mag * np.array([np.cos(alpha_ref), 0, np.sin(alpha_ref)])\n        self._reference_solution = {\n            \"ai\": 0,\n            \"v_W2f\": v_W2f_ref,\n            \"Gamma\": np.sqrt(1 - self.s_cps**2),  # Naive ellipse\n        }\n        try:\n            _, _, self._reference_solution = self.__call__(0, v_W2f_ref, 1.2)\n        except ConvergenceError as e:\n            raise RuntimeError(\"Phillips: failed to initialize base case\")\n\n    def _compute_Reynolds(self, v_W2f, rho_air):\n        \"\"\"Compute the Reynolds number at each control point.\"\"\"\n        # FIXME: verify that using the total airspeed (including spanwise flow)\n        #        is okay. A few tests show minimal differences, so for now I'm\n        #        not wasting time computing the normal and chordwise flows.\n        u = np.linalg.norm(v_W2f, axis=-1)  # airspeed [m\/s]\n        mu = 1.81e-5  # Standard dynamic viscosity of air\n        Re = rho_air * u * self.c_avg \/ mu\n        return Re\n\n    def r_CP2LE(self):\n        cps = self.cps.view()\n        cps.flags.writeable = False\n        return cps\n\n    def _induced_velocities(self, u_inf):\n        # 2. Compute the \"induced velocity\" unit vectors\n        #  * ref: Phillips, Eq:6\n        R1, R2, r1, r2 = self.R1, self.R2, self.r1, self.r2  # Shorthand\n        v = self.v_ij.copy()\n        v += (\n            cross3(u_inf, R2)\n            \/ (r2 * (r2 - np.einsum(\"k,ijk->ij\", u_inf, R2)))[..., None]\n        )\n        v -= (\n            cross3(u_inf, R1)\n            \/ (r1 * (r1 - np.einsum(\"k,ijk->ij\", u_inf, R1)))[..., None]\n        )\n\n        return v \/ (4 * np.pi)  # axes: (inducer, inducee, 3-vector)\n\n    def _local_velocities(self, v_W2f, Gamma, v):\n        # Compute the local fluid velocities\n        #  * ref: Hunsaker Eq:5\n        #  * ref: Phillips Eq:5 (nondimensional version)\n        V = v_W2f + np.einsum(\"j,jik->ik\", Gamma, v)\n\n        # Compute the local angle of attack for each section\n        #  * ref: Phillips Eq:9 (dimensional) or Eq:12 (dimensionless)\n        V_n = np.einsum(\"ik,ik->i\", V, self.u_n)  # Normal-wise\n        V_a = np.einsum(\"ik,ik->i\", V, self.u_a)  # Chordwise\n        alpha = np.arctan2(V_n, V_a)\n\n        return V, V_n, V_a, alpha\n\n    def _f(self, Gamma, ai, v_W2f, v, Re):\n        # Compute the residual error vector\n        #  * ref: Hunsaker Eq:8\n        #  * ref: Phillips Eq:14\n        V, V_n, V_a, alpha = self._local_velocities(v_W2f, Gamma, v)\n        W = cross3(V, self.dl)\n        W_norm = np.sqrt(np.einsum(\"ik,ik->i\", W, W))\n        Cl = self.foil.sections.Cl(\n            self.s_cps,\n            ai,\n            alpha,\n            Re,\n            clamp=self.clamped,\n        )\n        # return 2 * Gamma * W_norm - np.einsum(\"ik,ik,i,i->i\", V, V, self.dA, Cl)\n        return 2 * Gamma * W_norm - (V_n**2 + V_a**2) * self.dA * Cl\n\n    def _J(self, Gamma, ai, v_W2f, v, Re, verify_J=False):\n        # 7. Compute the Jacobian matrix, `J[ij] = d(f_i)\/d(Gamma_j)`\n        #  * ref: Hunsaker Eq:11\n        V, V_n, V_a, alpha = self._local_velocities(v_W2f, Gamma, v)\n        W = cross3(V, self.dl)\n        W_norm = np.sqrt(np.einsum(\"ik,ik->i\", W, W))\n        Cl = self.foil.sections.Cl(\n            self.s_cps,\n            ai,\n            alpha,\n            Re,\n            clamp=self.clamped,\n        )\n        Cl_alpha = self.foil.sections.Cl_alpha(\n            self.s_cps,\n            ai,\n            alpha,\n            Re,\n            clamp=self.clamped,\n        )\n\n        J = 2 * np.diag(W_norm)  # Additional terms for i==j\n        J2 = 2 * np.einsum(\"i,ik,i,jik->ij\", Gamma, W, 1 \/ W_norm, cross3(v, self.dl))\n        J3 = (\n            np.einsum(\"i,jik,ik->ij\", V_a, v, self.u_n)\n            - np.einsum(\"i,jik,ik->ij\", V_n, v, self.u_a)  # fmt: skip\n        )\n        J3 *= (\n            (self.dA * Cl_alpha)[:, None]\n            * np.einsum(\"ik,ik->i\", V, V)\n            \/ (V_n**2 + V_a**2)\n        )\n        J4 = 2 * np.einsum(\"i,i,ik,jik->ij\", self.dA, Cl, V, v)\n        J += J2 - J3 - J4\n\n        # Compare the analytical gradient to the finite-difference version\n        if verify_J:\n            J_true = self._J_finite(Gamma, ai, v_W2f, v, Re)\n            if not np.allclose(J, J_true):\n                print(\"\\n !!! The analytical Jacobian disagrees. Halting. !!!\")\n                breakpoint()\n\n        return J\n\n    def _J_finite(self, Gamma, ai, v_W2f, v, Re):\n        \"\"\"Compute the Jacobian using a centered finite distance.\n\n        Useful for checking the analytical gradient.\n\n        Examples\n        --------\n        >>> J1 = self._J(Gamma, v_W2f, v, ai)\n        >>> J2 = self._J_finite(Gamma, v_W2f, v, ai)\n        >>> np.allclose(J1, J2)\n        True\n        \"\"\"\n        # This uses the same method as `scipy.optimize.approx_fprime`, but that\n        # function only works for scalar-valued functions.\n        JT = np.empty((self.K, self.K))  # Jacobian transpose  (J_ji)\n        eps = np.sqrt(np.finfo(float).eps)\n\n        # Build the Jacobian column-wise (row-wise of the tranpose)\n        Gp, Gm = Gamma.copy(), Gamma.copy()\n        for k in range(self.K):\n            Gp[k], Gm[k] = Gamma[k] + eps, Gamma[k] - eps\n            fp = self._f(Gp, ai, v_W2f, v, Re)\n            fm = self._f(Gm, ai, v_W2f, v, Re)\n            JT[k] = (fp - fm) \/ (2 * eps)\n            Gp[k], Gm[k] = Gamma[k], Gamma[k]\n\n        return JT.T\n\n    def _solve_circulation(self, ai, v_W2f, Re, Gamma0):\n        \"\"\"\n        Solve for the spanwise circulation distribution.\n\n        Parameters\n        ----------\n        ai : array of float, shape (K,) [radians]\n            Airfoil indices.\n        v_W2f : array of float, shape (K,) [m\/s]\n            Relative wind velocity at each control point.\n        Re : array of float, shape (K,)\n            Reynolds number at each segment\n        Gamma0 : array of float, shape (K,)\n            The initial proposal\n\n        Returns\n        -------\n        Gamma : array of float, shape (K,)\n            Circulation strengths of each segment.\n        v : array, shape (K,K,3) [m\/s]\n            Induced velocities between each segment, indexed as (inducer,\n            inducee).\n        \"\"\"\n        v_mid = v_W2f[self.K \/\/ 2]\n        u_inf = v_mid \/ np.linalg.norm(v_mid)  # FIXME: what if PQR != 0?\n        v = self._induced_velocities(u_inf)\n        args = (ai, v_W2f, v, Re)\n        res = scipy.optimize.root(self._f, Gamma0, args, jac=self._J, tol=1e-4)\n\n        if not res[\"success\"]:\n            raise ConvergenceError\n\n        return res[\"x\"], v\n\n    def __call__(\n        self,\n        ai,\n        v_W2f,\n        rho_air,\n        *,\n        reference_solution: dict | None = None,\n        max_splits: int = 10,\n    ):\n        v_W2f = np.broadcast_to(v_W2f, (self.K, 3))\n        Re = self._compute_Reynolds(v_W2f, rho_air)\n\n        if reference_solution is None:\n            reference_solution = self._reference_solution\n\n        ai_ref = reference_solution[\"ai\"]\n        v_W2f_ref = reference_solution[\"v_W2f\"]\n        Gamma_ref = reference_solution[\"Gamma\"]\n\n        # Try to solve for the target (`Gamma` as a function of `v_W2f` and\n        # `ai`) directly using the `reference_solution`. If that fails, pick a\n        # point between the target and the reference, solve for that easier\n        # case, then use its solution as the new starting point for the next\n        # target. Repeat for intermediate targets until either solving for the\n        # original target, or exceeding `max_splits`.\n        target_backlog = []  # Stack of pending targets\n        num_splits = 0\n        while True:\n            try:\n                Gamma, v = self._solve_circulation(ai, v_W2f, Re, Gamma_ref)\n            except ConvergenceError:\n                if num_splits == max_splits:\n                    raise ConvergenceError(\"max splits reached\")\n                num_splits += 1\n                target_backlog.append((ai, v_W2f))\n                P = 0.5  # Ratio, a point between the reference and the target\n                ai = (1 - P) * ai_ref + P * ai\n                v_W2f = (1 - P) * v_W2f_ref + P * v_W2f\n                continue\n\n            ai_ref = ai\n            v_W2f_ref = v_W2f\n            Gamma_ref = Gamma\n\n            if target_backlog:\n                ai, v_W2f = target_backlog.pop()\n            else:\n                break\n\n        V, V_n, V_a, alpha = self._local_velocities(v_W2f, Gamma, v)\n\n        # Compute the inviscid forces using the 3D vortex lifting law\n        #  * ref: Hunsaker Eq:1\n        #  * ref: Phillips Eq:4\n        dF_inviscid = Gamma * cross3(V, self.dl).T\n\n        # Compute the viscous forces.\n        #  * ref: Hunsaker Eq:17\n        #\n        # The equation in the paper uses the \"characteristic chord\", but I\n        # believe that is a mistake; it produces *massive* drag. Here I use the\n        # section area like they do in \"MachUp_Py\" (see where they compute\n        # `f_parasite_mag` in `llmodel.py:LLModel:_compute_forces`).\n        Cd = self.foil.sections.Cd(\n            self.s_cps,\n            ai,\n            alpha,\n            Re,\n            clamp=self.clamped,\n        )\n        V2 = np.einsum(\"ik,ik->i\", V, V)\n        u_drag = V.T \/ np.sqrt(V2)\n        dF_viscous = 0.5 * V2 * self.dA * Cd * u_drag\n\n        # The total forces applied at each control point\n        dF = dF_inviscid + dF_viscous\n\n        # Compute the section moments.\n        #  * ref: Hunsaker Eq:19\n        #  * ref: Phillips Eq:28\n        #\n        # These are strictly the section moments caused by airflow around the\n        # section. It does not include moments about the aircraft reference\n        # point (commonly the center of gravity); those extra moments must be\n        # calculated by the wing.\n        #  * ref: Hunsaker Eq:19\n        #  * ref: Phillips Eq:28\n        Cm = self.foil.sections.Cm(\n            self.s_cps,\n            ai,\n            alpha,\n            Re,\n            clamp=self.clamped,\n        )\n        dM = -0.5 * V2 * self.dA * self.c_avg * Cm * self.u_s.T\n\n        solution = {\n            \"ai\": ai,\n            \"v_W2f\": v_W2f_ref,\n            \"Gamma\": Gamma_ref,\n        }\n\n        # print(\"\\nFinished `Phillips.__call__`\")\n        # breakpoint()\n\n        dF *= rho_air\n        dM *= rho_air\n\n        return dF.T, dM.T, solution\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_602","text":"<reponame>smujiang\/WSIPenMarkingRemoval<gh_stars>1-10\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"\nCompare two or more images using MSE, PSNR, SNR, SSIM, UQI, PBVIF, MSSIM,\nNQM and WSNR metrics.\n\nFor usage and a list of options, try this:\n$ .\/pymetrikz -h\n\nThis program and its regression test suite live here:\nhttp:\/\/www.sawp.com.br\/projects\/pymetrikz\"\"\"\n\nimport numpy as __n\nfrom scipy.ndimage.filters import gaussian_filter as __gaussian_filter\nfrom scipy.ndimage.filters import convolve as __convolve\nfrom scipy.ndimage.filters import correlate as __correlate\nfrom scipy.fftpack import fftshift as __fftshift\n\n\n__author__ = \"<NAME> <<EMAIL>>\"\n__copyright__ = \"Copyright (c) 2011-2014 <NAME>\"\n__license__ = \"GPLv2\"\n\n\ndef mse(reference, query):\n    \"\"\"Computes the Mean Square Error (MSE) of two images.\n\n    value = mse(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : MSE value\n    \"\"\"\n    (ref, que) = (reference.astype('double'), query.astype('double'))\n    diff = ref - que\n    square = (diff ** 2)\n    mean = square.mean()\n    return mean\n\n\ndef rmse(reference, query):\n    msev = mse(reference, query)\n    return __n.sqrt(msev)\n\n\ndef psnr(reference, query, normal=255):\n    \"\"\"Computes the Peak Signal-to-Noise-Ratio (PSNR).\n\n    value = psnr(reference, query, normalization=255)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n    normal   : normalization value (255 for 8-bit image\n\n    Return\n    ----------\n    value    : PSNR value\n    \"\"\"\n    normalization = float(normal)\n    msev = mse(reference, query)\n    if msev != 0:\n        value = 10.0 * __n.log10(normalization * normalization \/ msev)\n    else:\n        value = float(\"inf\")\n    return value\n\n\ndef snr(reference, query):\n    \"\"\"Computes the Signal-to-Noise-Ratio (SNR).\n\n    value = snr(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : SNR value\n    \"\"\"\n    signal_value = (reference.astype('double') ** 2).mean()\n    msev = mse(reference, query)\n    if msev != 0:\n        value = 10.0 * __n.log10(signal_value \/ msev)\n    else:\n        value = float(\"inf\")\n    return value\n\n\ndef ssim(reference, query):\n    \"\"\"Computes the Structural SIMilarity Index (SSIM).\n\n    value = ssim(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : SSIM value\n    \"\"\"\n    def __get_kernels():\n        k1, k2, l = (0.01, 0.03, 255.0)\n        kern1, kern2 = map(lambda x: (x * l) ** 2, (k1, k2))\n        return kern1, kern2\n\n    def __get_mus(i1, i2):\n        mu1, mu2 = map(lambda x: __gaussian_filter(x, 1.5), (i1, i2))\n        m1m1, m2m2, m1m2 = (mu1 * mu1, mu2 * mu2, mu1 * mu2)\n        return m1m1, m2m2, m1m2\n\n    def __get_sigmas(i1, i2, delta1, delta2, delta12):\n        f1 = __gaussian_filter(i1 * i1, 1.5) - delta1\n        f2 = __gaussian_filter(i2 * i2, 1.5) - delta2\n        f12 = __gaussian_filter(i1 * i2, 1.5) - delta12\n        return f1, f2, f12\n\n    def __get_positive_ssimap(C1, C2, m1m2, mu11, mu22, s12, s1s1, s2s2):\n        num = (2 * m1m2 + C1) * (2 * s12 + C2)\n        den = (mu11 + mu22 + C1) * (s1s1 + s2s2 + C2)\n        return num \/ den\n\n    def __get_negative_ssimap(C1, C2, m1m2, m11, m22, s12, s1s1, s2s2):\n        (num1, num2) = (2.0 * m1m2 + C1, 2.0 * s12 + C2)\n        (den1, den2) = (m11 + m22 + C1, s1s1 + s2s2 + C2)\n        ssim_map = __n.ones(img1.shape)\n        indx = (den1 * den2 > 0)\n        ssim_map[indx] = (num1[indx] * num2[indx]) \/ (den1[indx] * den2[indx])\n        indx = __n.bitwise_and(den1 != 0, den2 == 0)\n        ssim_map[indx] = num1[indx] \/ den1[indx]\n        return ssim_map\n\n    (img1, img2) = (reference.astype('double'), query.astype('double'))\n    (m1m1, m2m2, m1m2) = __get_mus(img1, img2)\n    (s1, s2, s12) = __get_sigmas(img1, img2, m1m1, m2m2, m1m2)\n    (C1, C2) = __get_kernels()\n    if C1 > 0 and C2 > 0:\n        ssim_map = __get_positive_ssimap(C1, C2, m1m2, m1m1, m2m2, s12, s1, s2)\n    else:\n        ssim_map = __get_negative_ssimap(C1, C2, m1m2, m1m1, m2m2, s12, s1, s2)\n    ssim_value = ssim_map.mean()\n    return ssim_value\n\n\ndef uqi(reference, query):\n    \"\"\"Computes the Universal Quality Index (UQI).\n\n    value = uqi(reference, query\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : UQI value\n    \"\"\"\n    def __conv(x):\n        window = __n.ones((BLOCK_SIZE, BLOCK_SIZE))\n        if len(x.shape) < 3:\n            return __convolve(x, window)\n        else:\n            channels = x.shape[2]\n            f = [__convolve(x[:, :, c], window) for c in range(channels)]\n            return __n.array(f)\n\n    def __get_filtered(im1, im2, BLOCK_SIZE):\n        (im1im1, im2im2, im1im2) = (im1 * im1, im2 * im2, im1 * im2)\n        (b1, b2, b3, b4, b5) = map(__conv, (im1, im2, im1im1, im2im2, im1im2))\n        (b6, b7) = (b1 * b2, b1 * b1 + b2 * b2)\n        return (b1, b2, b3, b4, b5, b6, b7)\n\n    def __get_quality_map(b1, b2, b3, b4, b5, b6, b7, BLOCK_SIZE):\n        N = BLOCK_SIZE * BLOCK_SIZE\n        numerator = 4.0 * (N * b5 - b6) * b6\n        denominator1 = N * (b3 + b4) - b7\n        denominator = denominator1 * b7\n        index = __n.bitwise_and(denominator1 == 0, b7 != 0)\n        quality_map = __n.ones(denominator.shape)\n        quality_map[index] = 2.0 * b6[index] \/ b7[index]\n        index = (denominator != 0)\n        quality_map[index] = numerator[index] \/ denominator[index]\n        return quality_map[index]\n\n    BLOCK_SIZE = 8\n    (img1, img2) = (reference.astype('double'), query.astype('double'))\n    (b1, b2, b3, b4, b5, b6, b7) = __get_filtered(img1, img2, BLOCK_SIZE)\n    quality_map = __get_quality_map(b1, b2, b3, b4, b5, b6, b7, BLOCK_SIZE)\n    value = quality_map.mean()\n    return value\n\n\ndef pbvif(reference, query):\n    \"\"\"Computes the Pixel-Based Visual Information Fidelity (PB-VIF).\n\n    value = pbvif(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : PB-VIF value\n    \"\"\"\n    def __get_sigma(win, ref, dist, mu1_sq, mu2_sq, mu1_mu2):\n        sigma1_sq = __filter2(win, ref * ref) - mu1_sq\n        sigma2_sq = __filter2(win, dist * dist) - mu2_sq\n        sigma12 = __filter2(win, ref * dist) - mu1_mu2\n        (sigma1_sq[sigma1_sq < 0], sigma2_sq[sigma2_sq < 0]) = (0.0, 0.0)\n        return (sigma2_sq, sigma12, sigma1_sq)\n\n    def __get_normalized(s1s1, s2s2, s1s2):\n        g = s1s2 \/ (s1s1 + 1e-10)\n        sv_sq = s2s2 - g * s1s2\n        g[s1s1 < 1e-10] = 0\n        sv_sq[s1s1 < 1e-10] = s2s2[s1s1 < 1e-10]\n        s1s1[s1s1 < 1e-10] = 0\n        g[s2s2 < 1e-10] = 0\n        sv_sq[s2s2 < 1e-10] = 0\n        sv_sq[g < 0] = s2s2[g < 0]\n        g[g < 0] = 0\n        sv_sq[sv_sq <= 1e-10] = 1e-10\n        return (g, sv_sq)\n\n    def __get_num(s1s1, sv_sq, sigma_nsq, g):\n        normg = (g ** 2) * s1s1 \/ (sv_sq + sigma_nsq)\n        snr = __n.log10(1.0 + normg).sum()\n        return snr\n\n    def __get_den(s1s1, sigma_nsq):\n        snr = __n.log10(1.0 + s1s1 \/ sigma_nsq)\n        return snr.sum()\n\n    def __get_num_den_level(ref, dist, scale):\n        sig = 2.0\n        N = (2.0 ** (4 - scale + 1.0)) + 1.0\n        win = __get_gaussian_kernel(N, N \/ 5.0)\n        if scale > 1:\n            ref = __filter2(win, ref)\n            dist = __filter2(win, dist)\n            ref = ref[::2, ::2]\n            dist = dist[::2, ::2]\n        (mu1, mu2) = (__filter2(win, ref), __filter2(win, dist))\n        (m1m1, m2m2, m1m2) = (mu1 * mu1, mu2 * mu2, mu1 * mu2)\n        (s2s2, s1s2, s1s1) = __get_sigma(win, ref, dist, m1m1, m2m2, m1m2)\n        (g, svsv) = __get_normalized(s1s1, s2s2, s1s2)\n        (num, den) = (__get_num(s1s1, svsv, sig, g), __get_den(s1s1, sig))\n        return (num, den)\n\n    (ref, dist) = (reference.astype('double'), query.astype('double'))\n    zipped = map(lambda x: __get_num_den_level(ref, dist, x), range(1, 5))\n    (nums, dens) = zip(*zipped)\n    value = sum(nums) \/ sum(dens)\n    return value\n\n\ndef mssim(reference, query):\n    \"\"\"Computes the Multi-Scale SSIM Index (MSSIM).\n\n    value = mssim(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : MSSIM value\n    \"\"\"\n    def __get_filt_kern():\n        n = [131, -199, -101, 962, 932, 962, -101, -199, 131]\n        d = [3463, 8344, 913, 2549, 1093, 2549, 913, 8344, 3463]\n        num = __n.matrix(n).T\n        den = __n.matrix(d).T\n        lod = num.astype('double') \/ den.astype('double')\n        lpf = __n.dot(lod, lod.T)\n        return lpf \/ lpf.sum()\n\n    def __get_ssim(img1, img2, K):\n        comp_ssim = __ssim_modified(img1, img2, K)[1]\n        return (comp_ssim[1], comp_ssim[2])\n\n    def __get_MVR(img1, img2, K, nlevs):\n        (ssim_v, ssim_r) = (__n.zeros((nlevs, 1)), __n.zeros((nlevs, 1)))\n        (ssim_v[0], ssim_r[0]) = __get_ssim(img1, img2, K)\n        filt_kern = __get_filt_kern()\n        for s in range(nlevs - 1):\n            (img1, img2) = map(lambda x: __filter2(filt_kern, x), (img1, img2))\n            (img1, img2) = (img1[::2, ::2], img2[::2, ::2])\n            comp_ssim = __ssim_modified(img1, img2, K)[1]\n            ssim_m = comp_ssim[0]\n            ssim_v[s + 1] = comp_ssim[1]\n            ssim_r[s + 1] = comp_ssim[2]\n        return (ssim_m, ssim_v, ssim_r)\n\n    def __calc_mssim_mvr(img1, img2):\n        (K, weights) = ((0.01, 0.03), (0.0448, 0.2856, 0.3001, 0.2363, 0.1333))\n        (alpha, beta, lvl) = (0.1333, __n.matrix(weights).T, len(weights))\n        (ssim_m, ssim_v, ssim_r) = __get_MVR(img1, img2, K, lvl)\n        m = ssim_m ** alpha\n        v = (ssim_v ** beta).prod()\n        r = (ssim_r ** beta).prod()\n        return (m, v, r)\n\n    (ref, quer) = (reference.astype('double'), query.astype('double'))\n    ssim_mvr = __n.matrix(__calc_mssim_mvr(ref, quer))\n    value = ssim_mvr.prod()\n    return value\n\n\ndef __filter2(B, X, shape='nearest'):\n    B2 = __n.rot90(__n.rot90(B))\n    if len(X.shape) < 3:\n        return __correlate(X, B2, mode=shape)\n    else:\n        channels = X.shape[2]\n        f = [__correlate(X[:, :, c], B2, mode=shape) for c in range(channels)]\n        return __n.array(f)\n\n\ndef __get_gaussian_kernel(N=15, sigma=1.5):\n    (H, W) = ((N - 1) \/ 2, (N - 1) \/ 2)\n    std = sigma\n    (y, x) = __n.mgrid[-H:H + 1, -W:W + 1]\n    arg = -(x * x + y * y) \/ (2.0 * std * std)\n    h = __n.exp(arg)\n    index = h < __n.finfo(float).eps * h.max(0)\n    h[index] = 0\n    sumh = h.sum()\n    if sumh != 0:\n        h = h \/ sumh\n    return h\n\n\ndef __ssim_modified(reference, query, K):\n    def __get_kern(K):\n        L = 255\n        kern = map(lambda x: (x * L) ** 2, K)\n        return (kern[0], kern[1])\n\n    def __get_filtering_window():\n        window = __get_gaussian_kernel(11, 1.5)\n        return window \/ window.sum()\n\n    def __get_mus(img1, img2, window):\n        (mu1, mu2) = map(lambda x: __filter2(window, x), (img1, img2))\n        (m1m1, m2m2, m1m2) = (mu1 * mu1, mu2 * mu2, mu1 * mu2)\n        return (mu1, mu2, m1m1, m2m2, m1m2)\n\n    def __get_sigmas(img1, img2, window, m1m1, m2m2, m1m2):\n        s1s1 = __filter2(window, img1 * img1) - m1m1\n        s2s2 = __filter2(window, img2 * img2) - m2m2\n        s12 = __filter2(window, img1 * img2) - m1m2\n        (s1, s2) = map(__n.sqrt, (__n.abs(s1s1), __n.abs(s2s2)))\n        return (s1s1, s2s2, s1, s2, s12)\n\n    def __MVR_pos_kern(m, kern, s, s_square):\n        (m11, m22, m12) = m\n        (k1, k2) = kern\n        (s1, s2) = s\n        (s1s1, s2s2, s12) = s_square\n        M = (2.0 * m12 + k1) \/ (m11 + m22 + k1)\n        V = (2.0 * s1 * s2 + k2) \/ (s1s1 + s2s2 + k2)\n        R = (s12 + k2 \/ 2.0) \/ (s1 * s2 + k2 \/ 2.0)\n        return (M, V, R)\n\n    def __MVR_neg_kern(m, s, s_square):\n        def __calcM(mu1, m11, m22, m12):\n            ssim_ln = 2.0 * m12\n            ssim_ld = m11 + m22\n            index_l = ssim_ld > 0\n            M = __n.ones(mu1.shape)\n            M[index_l] = ssim_ln[index_l] \/ ssim_ld[index_l]\n            return M\n\n        def __calcV(mu1, s1, s2, s11, s22):\n            ssim_cn = 2.0 * s1 * s2\n            ssim_cd = s11 + s22\n            V = __n.ones(mu1.shape)\n            index_c = ssim_cd > 0\n            V[index_c] = ssim_cn[index_c] \/ ssim_cd[index_c]\n            return V\n\n        def __calcR(mu1, s1, s2, s12):\n            (ssim_sn, ssim_sd) = (s12, s1 * s2)\n            R = __n.ones(mu1.shape)\n            (index1, index2) = (s1 > 0, s2 > 0)\n            index_s1 = index1 * index2 > 0\n            R[index_s1] = ssim_sn[index_s1] \/ ssim_sd[index_s1]\n            index_s2 = index1 * __n.logical_not(index2) > 0\n            R[index_s2] = 0.0\n            return R\n\n        (mu1, mu2, m11, m22, m12) = m\n        (s1, s2) = s\n        (s11, s22, s12) = s_square\n        M = __calcM(mu1, m11, m22, m12)\n        V = __calcV(mu1, s1, s2, s11, s22)\n        R = __calcR(mu1, s1, s2, s12)\n        return (M, V, R)\n\n    def __get_composition_vector(img1, img2):\n        filt = __get_filtering_window()\n        (mu1, mu2, m11, m22, m12) = __get_mus(img1, img2, filt)\n        (s11, s22, s1, s2, s12) = __get_sigmas(img1, img2, filt, m11, m22, m12)\n        (kern1, kern2) = __get_kern(K)\n        if kern1 > 0 and kern2 > 0:\n            (m, kern, s) = ((m11, m22, m12), (kern1, kern2), (s1, s2))\n            s_square = (s11, s22, s12)\n            (M, V, R) = __MVR_pos_kern(m, kern, s, s_square)\n        else:\n            (m, s) = ((mu1, mu2, m11, m22, m12), (s1, s2))\n            s_square = (s11, s22, s12)\n            (M, V, R) = __MVR_neg_kern(m, s, s_square)\n        return (M, V, R)\n\n    def __get_ssim_map(M, V, R):\n        ssim_map = M * V * R\n        return ssim_map\n\n    def __get_ssim_from_composition_vector(M, V, R):\n        ssim_map = __get_ssim_map(M, V, R)\n        ssim = ssim_map.mean()\n        return ssim\n\n    (img1, img2) = reference.astype('double'), query.astype('double')\n    (M, V, R) = __get_composition_vector(img1, img2)\n    composite_mean_vector = (M.mean(), V.mean(), R.mean())\n    ssim = __get_ssim_from_composition_vector(M, V, R)\n    return (ssim, composite_mean_vector)\n\n\ndef __convert_to_luminance(x):\n    return __n.dot(x[..., :3], [0.299, 0.587, 0.144]).astype('double')\n\n\ndef nqm(reference, query):\n    \"\"\"Computes the NQM metric.\n\n    value = nqm(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : NQM value\n    \"\"\"\n    def __ctf(f_r):\n        \"\"\" Bandpass Contrast Threshold Function for RGB\"\"\"\n        (gamma, alpha) = (0.0192 + 0.114 * f_r, (0.114 * f_r) ** 1.1)\n        beta = __n.exp(-alpha)\n        num = 520.0 * gamma * beta\n        return 1.0 \/ num\n\n    def _get_masked(c, ci, a, ai, i):\n        (H, W) = c.shape\n        (c, ci, ct) = (c.flatten(1), ci.flatten(1), __ctf(i))\n        ci[abs(ci) > 1.0] = 1.0\n        T = ct * (0.86 * ((c \/ ct) - 1.0) + 0.3)\n        (ai, a, a1) = (ai.flatten(1), a.flatten(1), (abs(ci - c) - T) < 0.0)\n        ai[a1] = a[a1]\n        return ai.reshape(H, W)\n\n    def __get_thresh(x, T, z, trans=True):\n        (H, W) = x.shape\n        if trans:\n            (x, z) = (x.flatten(1).T, z.flatten())\n        else:\n            (x, z) = (x.flatten(1), z.flatten(1))\n        z[abs(x) < T] = 0.0\n        return z.reshape(H, W)\n\n    def __decompose_cos_log_filter(w1, w2, phase=__n.pi):\n        return 0.5 * (1 + __n.cos(__n.pi * __n.log2(w1 + w2) - phase))\n\n    def __get_w(r):\n        w = [(r + 2) * ((r + 2 <= 4) * (r + 2 >= 1))]\n        w += [r * ((r <= 4) * (r >= 1))]\n        w += [r * ((r >= 2) * (r <= 8))]\n        w += [r * ((r >= 4) * (r <= 16))]\n        w += [r * ((r >= 8) * (r <= 32))]\n        w += [r * ((r >= 16) * (r <= 64))]\n        return w\n\n    def __get_u(r):\n        u = [4 * (__n.logical_not((r + 2 <= 4) * (r + 2 >= 1)))]\n        u += [4 * (__n.logical_not((r <= 4) * (r >= 1)))]\n        u += [0.5 * (__n.logical_not((r >= 2) * (r <= 8)))]\n        u += [4 * (__n.logical_not((r >= 4) * (r <= 16)))]\n        u += [0.5 * (__n.logical_not((r >= 8) * (r <= 32)))]\n        u += [4 * (__n.logical_not((r >= 16) * (r <= 64)))]\n        return u\n\n    def __get_G(r):\n        (w, u) = (__get_w(r), __get_u(r))\n        phase = [__n.pi, __n.pi, 0.0, __n.pi, 0.0, __n.pi]\n        dclf = __decompose_cos_log_filter\n        return [dclf(w[i], u[i], phase[i]) for i in range(len(phase))]\n\n    def __compute_fft_plane_shifted(ref, query):\n        (x, y) = ref.shape\n        (xplane, yplane) = __n.mgrid[-y \/ 2:y \/ 2, -x \/ 2:x \/ 2]\n        plane = (xplane + 1.0j * yplane)\n        r = abs(plane)\n        G = __get_G(r)\n        Gshifted = map(__fftshift, G)\n        return [Gs.T for Gs in Gshifted]\n\n    def __get_c(a, l_0):\n        c = [a[0] \/ l_0]\n        c += [a[1] \/ (l_0 + a[0])]\n        c += [a[2] \/ (l_0 + a[0] + a[1])]\n        c += [a[3] \/ (l_0 + a[0] + a[1] + a[2])]\n        c += [a[4] \/ (l_0 + a[0] + a[1] + a[2] + a[3])]\n        return c\n\n    def __get_ci(ai, li_0):\n        ci = [ai[0] \/ (li_0)]\n        ci += [ai[1] \/ (li_0 + ai[0])]\n        ci += [ai[2] \/ (li_0 + ai[0] + ai[1])]\n        ci += [ai[3] \/ (li_0 + ai[0] + ai[1] + ai[2])]\n        ci += [ai[4] \/ (li_0 + ai[0] + ai[1] + ai[2] + ai[3])]\n        return ci\n\n    def __compute_contrast_images(a, ai, l, li):\n        ci = __get_ci(ai, li)\n        c = __get_c(a, l)\n        return (c, ci)\n\n    def __get_detection_thresholds():\n        viewing_angle = (1.0 \/ 3.5) * (180.0 \/ __n.pi)\n        rotations = [2.0, 4.0, 8.0, 16.0, 32.0]\n        return map(lambda x: __ctf(x \/ viewing_angle), rotations)\n\n    def __get_account_for_supra_threshold_effects(c, ci, a, ai):\n        r = range(len(a))\n        return [_get_masked(c[i], ci[i], a[i], ai[i], i + 1) for i in r]\n\n    def __apply_detection_thresholds(c, ci, d, a, ai):\n        A = [__get_thresh(c[i], d[i], a[i], False) for i in range(len(a))]\n        AI = [__get_thresh(ci[i], d[i], ai[i], True) for i in range(len(a))]\n        return (A, AI)\n\n    def __reconstruct_images(A, AI):\n        return map(lambda x: __n.add.reduce(x), (A, AI))\n\n    def __compute_quality(imref, imquery):\n        return snr(imref, imquery)\n\n    def __get_ref_basis(ref_fft, query_fft, GS):\n        (L_0, LI_0) = map(lambda x: GS[0] * x, (ref_fft, query_fft))\n        (l_0, li_0) = map(lambda x: __n.real(__n.fft.ifft2(x)), (L_0, LI_0))\n        return (l_0, li_0)\n\n    def __compute_inverse_convolution(convolved_fft, GS):\n        convolved = [GS[i] * convolved_fft for i in range(1, len(GS))]\n        return map(lambda x: __n.real(__n.fft.ifft2(x)), convolved)\n\n    def __correlate_in_fourier_domain(ref, query):\n        (ref_fft, query_fft) = map(lambda x: __n.fft.fft2(x), (ref, query))\n        GS = __compute_fft_plane_shifted(ref, query)\n        (l_0, li_0) = __get_ref_basis(ref_fft, query_fft, GS)\n        a = __compute_inverse_convolution(ref_fft, GS)\n        ai = __compute_inverse_convolution(query_fft, GS)\n        return (a, ai, l_0, li_0)\n\n    def __get_correlated_images(ref, query):\n        (a, ai, l_0, li_0) = __correlate_in_fourier_domain(ref, query)\n        (c, ci) = __compute_contrast_images(a, ai, l_0, li_0)\n        d = __get_detection_thresholds()\n        ai = __get_account_for_supra_threshold_effects(c, ci, a, ai)\n        return __apply_detection_thresholds(c, ci, d, a, ai)\n\n    if not len(reference.shape) < 3:\n        reference = __convert_to_luminance(reference)\n        query = __convert_to_luminance(query)\n    (A, AI) = __get_correlated_images(reference, query)\n    (y1, y2) = __reconstruct_images(A, AI)\n    y = __compute_quality(y1, y2)\n    return y\n\n\ndef wsnr(reference, query):\n    \"\"\"Computes the Weighted Signal to Noise Ratio (WSNR) metric.\n\n    value = wsnr(reference, query)\n\n    Parameters\n    ----------\n    reference: original image data.\n    query    : modified image data to be compared.\n\n    Return\n    ----------\n    value    : wsnr value\n    \"\"\"\n    def __genetate_meshgrid(x, y):\n        f = lambda u: u \/ 2 + 0.5 - 1\n        (H, W) = map(f, (x, y))\n        return (H, W)\n\n    def __create_complex_planes(x, y):\n        (H, W) = __genetate_meshgrid(x, y)\n        (xplane, yplane) = __n.mgrid[-H:H + 1, -W:W + 1]\n        return (xplane, yplane)\n\n    def __get_evaluated_contrast_sensivity(plane):\n        w = 0.7\n        angle = __n.angle(plane)\n        return ((1.0 - w) \/ 2.0) * __n.cos(4.0 * angle) + (1.0 + w) \/ 2.0\n\n    def __get_radial_frequency(x, y):\n        (xplane, yplane) = __create_complex_planes(x, y)\n        nfreq = 60\n        plane = (xplane + 1.0j * yplane) \/ x * 2.0 * nfreq\n        s = __get_evaluated_contrast_sensivity(plane)\n        radfreq = abs(plane) \/ s\n        return radfreq\n\n    def __generate_CSF(radfreq):\n        a = -((0.114 * radfreq) ** 1.1)\n        csf = 2.6 * (0.0192 + 0.114 * radfreq) * __n.exp(a)\n        f = radfreq < 7.8909\n        csf[f] = 0.9809\n        return csf\n\n    def __weighted_fft_domain(ref, quer, csf):\n        err = ref.astype('double') - quer.astype('double')\n        err_wt = __fftshift(__n.fft.fft2(err)) * csf\n        im = __n.fft.fft2(ref)\n        return (err, err_wt, im)\n\n    def __get_weighted_error_power(err_wt):\n        return (err_wt * __n.conj(err_wt)).sum()\n\n    def __get_signal_power(im):\n        return (im * __n.conj(im)).sum()\n\n    def __get_ratio(mss, mse):\n        if mse != 0:\n            ratio = 10.0 * __n.log10(mss \/ mse)\n        else:\n            ratio = float(\"inf\")\n        return __n.real(ratio)\n\n    if not len(reference.shape) < 3:\n        reference = __convert_to_luminance(reference)\n        query = __convert_to_luminance(query)\n    size = reference.shape\n    (x, y) = (size[0], size[1])\n    radfreq = __get_radial_frequency(x, y)\n    csf = __generate_CSF(radfreq)\n    (err, err_wt, im) = __weighted_fft_domain(reference, query, csf)\n    mse = __get_weighted_error_power(err_wt)\n    mss = __get_signal_power(im)\n    ratio = __get_ratio(mss, mse)\n    return ratio\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_603","text":"<reponame>naotohori\/cafysis\n#!\/usr\/bin\/env python\n# coding: utf-8\n\n# This program was originally coded by <NAME> as simp.py\n\nimport scipy\nimport scipy.linalg\nimport pylab\nimport sys\n\nclass nya(object):\n    def __init__(self, coords, pdb_Bfactors):\n        self.coords = coords\n        self.pdb_Bfactors = pdb_Bfactors\n        self.num_atoms = len(self.coords)\n        \n    def cmpt_graph_mats(self, cutoff=10.0):\n        dist = scipy.linalg.norm\n        self.adj_mat = scipy.zeros((self.num_atoms, self.num_atoms))\n        self.deg_mat = [0] * self.num_atoms\n        for i in range(self.num_atoms - 1):\n            for j in range(i + 1, self.num_atoms):\n                if dist(self.coords[i, :] - self.coords[j, :]) <= cutoff:\n                    self.deg_mat[i] += 1.0\n                    self.deg_mat[j] += 1.0\n                    self.adj_mat[i, j] = 1.0\n                    self.adj_mat[j, i] = 1.0\n        self.deg_mat = scipy.diag(self.deg_mat)\n        self.lap_mat = self.deg_mat - self.adj_mat\n        \n    def cmpt_graph_eig(self):\n        self.graph_eigval, self.graph_eigvec = scipy.linalg.eigh(self.lap_mat, self.deg_mat)\n\n    def cmpt_hessian(self):\n        self.hessian = scipy.zeros((3*self.num_atoms, 3*self.num_atoms))\n        for i in range(self.num_atoms - 1):\n            for j in range(i + 1, self.num_atoms):\n                v_ij = self.coords[j, :] - self.coords[i, :]\n                d2 = sum(v_ij * v_ij)\n                for a in range(3):\n                    for b in range(3):\n                        self.hessian[3*i + a, 3*j + b] = -v_ij[a] * v_ij[b] \/ d2 * self.adj_mat[i, j]\n                        self.hessian[3*j + b, 3*i + a] = self.hessian[3*i + a, 3*j + b]\n        for i in range(self.num_atoms):\n            for a in range(3):\n                for b in range(a, 3):\n                    for j in range(self.num_atoms):\n                        if j != i: \n                            self.hessian[3*i + a, 3*i + b] += -self.hessian[3*i + a, 3*j + b]\n                    self.hessian[3*i + b, 3*i + a] = self.hessian[3*i + a, 3*i + b]\n\n    def cmpt_en_eig(self):\n        self.en_eigval, self.en_eigvec = scipy.linalg.eigh(self.hessian)\n\n    def cmpt_inverse_hessian(self):\n        self.inverse_hessian = scipy.linalg.pinv(self.hessian)\n\n    def cmpt_Bfactors(self):\n        Bfactors = [self.inverse_hessian[3*i,3*i] +\n                    self.inverse_hessian[3*i+1, 3*i+1] +\n                    self.inverse_hessian[3*i+2, 3*i+2] \n                    for i in range(self.num_atoms)]\n        k = sum(self.pdb_Bfactors) \/ sum(Bfactors)\n        self.Bfactors = [Bfactors[i] * k for i in range(self.num_atoms)]\n\n    def cmpt_cross_correlation(self):\n        self.cross_correlation = scipy.zeros((self.num_atoms, self.num_atoms))\n        self.norm_cross_correlation = scipy.zeros((self.num_atoms, self.num_atoms))\n        for i in range(self.num_atoms):\n            for j in range(i, self.num_atoms):\n                self.cross_correlation[i, j] = (self.inverse_hessian[3*i, 3*j] + \n                                                self.inverse_hessian[3*i+1, 3*j+1] +\n                                                self.inverse_hessian[3*i+2, 3*j+2])\n                self.cross_correlation[j, i] = self.cross_correlation[i, j]\n        for i in range(self.num_atoms):\n            for j in range(i, self.num_atoms):\n                if i == j:\n                    self.norm_cross_correlation[i, i] = 1.0\n                else:\n                    self.norm_cross_correlation[i, j] = (\n                     self.cross_correlation[i, j] \/\n                     scipy.sqrt(self.cross_correlation[i, i] * \n                                self.cross_correlation[j, j]))\n                    self.norm_cross_correlation[j, i] = self.norm_cross_correlation[i, j]\n        \n    \ndef get_lines(filename):\n    lines = []\n    for line in open(filename):\n        if (line[0:6] == \"ATOM  \" and\n            line[12:16] == \" CA \" and\n            (line[16:17] == \" \" or line[16:17] == \"A\") and\n            line[21:22] == \"A\"):\n            lines.append(line)\n    return lines\n\ndef get_coords(lines):\n    def ext_coords(line):\n        try:\n            x = float(line[30:38])\n            y = float(line[38:46])\n            z = float(line[46:54])\n        except ValueError:\n            print(\"Invalid format(coords)\")\n            print(line)\n            quit()\n        return (x, y, z)\n    return [ext_coords(line) for line in lines]\n\ndef get_Bfactors(lines):\n    def ext_Bfactors(line):\n        try:\n            b = float(line[60:66])\n        except ValueError:\n            print(\"Invalid format(B-factors)\")\n            print(line)\n            quit()\n        return b\n    return [ext_Bfactors(line) for line in lines]\n\ndef plot_figs():\n    pylab.subplot(221, aspect=\"equal\")\n    X, Y = pylab.meshgrid(list(range(ins.num_atoms)), list(range(ins.num_atoms)))\n    pylab.pcolor(X, Y, ins.norm_cross_correlation)\n    pylab.colorbar()\n    pylab.clim(-0.15, 0.15)\n    pylab.title(\"Cross Correlations\")\n\n    pylab.subplot(222)\n    pylab.plot(pdb_Bfactors, \"bo-\", label=\"ex.\")\n    pylab.plot(ins.Bfactors, \"ro-\", label=\"calc.\")\n    pylab.legend()\n    pylab.xlabel(\"Residue\")\n#    pylab.ylabel(\"a.u.\")\n    pylab.title(\"B factors\")\n    pylab.grid()\n\n    pylab.subplot(223, aspect=\"equal\")\n    X, Y = pylab.meshgrid(list(range(ins.num_atoms)), list(range(ins.num_atoms)))\n    pylab.pcolor(X, Y, ins.adj_mat)\n    pylab.colorbar()\n    pylab.title(\"Adjacency Mat.\")\n\n    pylab.subplot(224)\n    pylab.plot(ins.graph_eigvec[:, 1], \"go-\")\n    pylab.xlabel(\"Residue\")\n    pylab.grid()\n\n    pylab.show()\n\n\nif __name__ == \"__main__\":\n\n    filename = sys.argv[1]\n\n    lines = get_lines(filename)\n    coords = scipy.array(get_coords(lines))\n    pdb_Bfactors = get_Bfactors(lines)\n\n    ins = nya(coords, pdb_Bfactors)\n    ins.cmpt_graph_mats()\n    ins.cmpt_graph_eig()\n    ins.cmpt_hessian()\n    ins.cmpt_en_eig()\n    ins.cmpt_inverse_hessian()\n    ins.cmpt_Bfactors()\n    ins.cmpt_cross_correlation()\n\n    plot_figs()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_604","text":"<gh_stars>0\nimport numpy as np\nimport pandas as pd\nfrom scipy.spatial.distance import cdist, pdist, squareform\nimport random\nfrom geopy import distance\nimport geoplotlib\nfrom geoplotlib.utils import BoundingBox\nfrom geoplotlib.layers import BaseLayer\nfrom geoplotlib.core import BatchPainter\n\n\ndef geodesic_dist(p1, p2):\n    \"\"\"\n    Compute geodesic distance between points\n    p1 and p2 described by latitude and longitude.\n\n    Args:\n        p1 (numpy.ndarray): The first point\n        p2 (numpy.ndarray): The second point\n    \"\"\"\n    return distance.distance(p1, p2).m\n\n\ndef group_distance(g1, g2, method='average-linkage'):\n    \"\"\"\n    Compute distance between the specified groups using specified method and\n    metric.\n\n    Args:\n        g1 (list): The first group\n        g2 (list): The second group\n        method (str): The method to use (single-linkage, complete-linkage or average-linkage)\n\n    Returns:\n        (float): The evaluated distance between the groups.\n    \"\"\"\n    \n    # Compute distance between groups using specified metric and method.\n    return np.mean(np.ravel(cdist(np.vstack(g1), np.vstack(g2), metric='cityblock')))\n\n\ndef get_groups(data, delta_condition):\n    \"\"\"\n    Merge close nodes into clusters using agglomerative procedure.\n\n    Args:\n        data (np.ndarray): Data points represented as a numpy array\n        delta_condition (float): Distance limit for considering nodes to\n        be part of same cluster.\n\n    Returns:\n        (list): List of clusters represented as numpy arrays.\n    \"\"\"\n    \n    # Initialize list for storing the groups.\n    groups = []\n    \n    # Go over all data-points.\n    for data_idx in range(data.shape[0]):\n\n        # Initialize list for storing indices of merged groups.\n        to_remove = []\n\n        # Consider the next point as a single group.\n        group_nxt = [data[data_idx, :]]\n\n        # Go over all existing groups.\n        for idx, group in enumerate(groups):\n            \n            # Compute distance to next group.\n            dist = group_distance(group_nxt, group)\n\n            # If distance below set threshold, merge groups.\n            if dist < delta_condition:\n                group_nxt = group + group_nxt\n\n                # Add index of merged group to be removed later.\n                to_remove.append(idx)\n        \n        # Remove groups that were merged.\n        for rem_idx in sorted(to_remove, reverse=True):\n            del groups[rem_idx] \n        to_remove = []\n\n        # Append next found group to list of groups.\n        groups.append(group_nxt)\n\n    # Stack data points in groups into numpy arrays.\n    return list(map(np.vstack, groups))\n\n\ndef get_medoids(groups):\n    \"\"\"\n    Get medoids of found groups and stack them\n    into a numpy array.\n\n    Args:\n        groups (list): List of groups\n\n    Returns:\n        (numpy.ndarray): Array of found medoids.\n    \"\"\"\n\n    # Initialize list for found medoids.\n    medoids = []\n\n    # Go over groups and compute medoids.\n    for group in groups:\n        idx_min = np.argmin(np.sum(squareform(pdist(group, metric='cityblock')), axis=0))\n        medoids.append(group[idx_min, :])\n    \n    # Stack medoids into numpy array.\n    return np.vstack(medoids)\n\n\ndef get_grid(n_samples=10000, min_dist=10, return_sample=False):\n    \"\"\"\n    Get grid of points using the sample and cluster process.\n\n    Args:\n        n_samples (int): Number of samples to use in the process\n        min_dist (float): Distance limit for considering nodes to\n        be part of same cluster.\n        return_sample (bool): If true, return all the sampled nodes\n        along the filtered ones as a second return value.\n\n    Returns:\n        (numpy.ndarray): Spatial points forming the grid as well as the corresponding\n        sample indices.\n    \"\"\"\n\n    # Parse list of latitude and longitude values and join.\n    df = pd.read_csv('.\/data\/trip_data\/sampled.csv')\n    lat_1 = df['Pickup_latitude'].to_numpy()\n    lon_1 = df['Pickup_longitude'].to_numpy()\n    lat_2 = df['Dropoff_latitude'].to_numpy()\n    lon_2 = df['Dropoff_longitude'].to_numpy()\n    lat_all = np.hstack((lat_1, lat_2))\n    lon_all = np.hstack((lon_1, lon_2))\n    data = np.vstack((lat_all, lon_all)).T\n\n    # Sample spatial points for grid generation using specified sample size.\n    sample_indices = random.sample(range(data.shape[0]), n_samples)\n    node_sample = data[sample_indices, :]\n\n    # Join nodes in clusters and find medoids.\n    clusters = get_groups(node_sample, min_dist)\n    nodes_filtered = get_medoids(clusters)\n    return nodes_filtered if not return_sample else (nodes_filtered, node_sample)\n\n\ndef draw_grid(nodes, unfiltered=None):\n    \"\"\"\n    Draw grid using computed nodes.\n\n    Args:\n        nodes (numpy.ndarray): Data points to plot\n        unfiltered (numpy.ndarray): Unfiltered data points. If not None,\n        plot using different color.\n    \"\"\"\n    \n    # Layer for plotting the nodes\n    class PointsLayer(BaseLayer):\n\n        def __init__(self, data, color, point_size):\n            self.data = data\n            self.color = color\n            self.point_size = point_size\n\n        def invalidate(self, proj):\n            x, y = proj.lonlat_to_screen(self.data['lon'], self.data['lat'])\n            self.painter = BatchPainter()\n            self.painter.set_color(self.color)\n            self.painter.points(x, y, point_size=self.point_size, rounded=True)\n\n        def draw(self, proj, mouse_x, mouse_y, ui_manager):\n            self.painter.batch_draw()\n\n    # Get grid node data into dict format.\n    data_grid = {\n            'lat' : nodes[:, 0],\n            'lon' : nodes[:, 1]\n            }\n    \n    # If unfiltered nodes specified, get data into dict format.\n    if unfiltered is not None:\n        data_unfiltered = {\n                'lat' : unfiltered[:, 0],\n                'lon' : unfiltered[:, 1]\n                }\n    \n    # If unfiltered nodes specified, plot on layer.\n    if unfiltered is not None:\n        geoplotlib.add_layer(PointsLayer(data_unfiltered, color=[255, 0, 0], point_size=4))\n\n    # Plot grid nodes.\n    geoplotlib.add_layer(PointsLayer(data_grid, color=[0, 0, 255], point_size = 7))\n    \n    # Set bounding box and show.\n    geoplotlib.set_bbox(BoundingBox(north=40.897994, west=-73.199040, south=40.595581, east=-74.55040))\n    geoplotlib.show()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_605","text":"<reponame>ClandininLab\/pasna-acr-currbio2021\nimport itertools\nimport numpy as np\nimport scipy as sp\nimport seaborn as sns\n\ndef nansem(a, axis=0, ddof=1, nan_policy='omit'):\n    '''\n    Returns standard error of the mean, while omitting nan values.\n    '''\n    return sp.stats.sem(a, axis, ddof, nan_policy)\n\ndef mean_ci(data, ci=95, axis=0, bootstrap=True, n_boot=10000):\n    '''\n    Returns mean and 95% confidence intervals, computed by bootstrapping\n    '''\n    a = 1.0 * np.array(data)\n    m = np.nanmean(a, axis=axis)\n    if bootstrap:\n        boots = sns.algorithms.bootstrap(a, n_boot=1000, func=np.nanmean, axis=axis)\n        ci_lo, ci_hi = sns.utils.ci(boots, ci, axis=axis)\n    else:\n        se = nansem(a, axis=axis)\n        h = se * sp.stats.t.ppf((1 + ci\/100) \/ 2., len(a)-1)\n        ci_lo, ci_hi = m-h, m+h\n    return m, ci_lo, ci_hi\n\ndef flatten_nested_list(list_of_lists):\n    '''\n    Flattens a list of lists to a list\n    '''\n    return list(itertools.chain(*list_of_lists))\n\ndef uneven_list2d_to_np(v, fillval=np.nan):\n    '''\n    Given a list of uneven lists, returns a 2-dimensional numpy array in which all lists are padded with fillval\n    to the length of the longest list.\n    '''\n    lens = np.array([len(item) for item in v])\n    if len(np.unique(lens)) == 1:\n        return np.asarray(v)\n    mask = lens[:,None] > np.arange(lens.max())\n    out = np.full(mask.shape,fillval)\n    out[mask] = np.concatenate(v)\n    return out\n\n\ndef generate_standard_timestamp(timestamps, trim=False, min_time=None, max_time=None):\n    '''\n    Finds mean framerate and generates a single timestamp series starting from 0 evenly spaced to the max timestamp.\n\n    timestamps: 2d numpy array with nan padding for uneven timestamp lengths\n    \n    If trim=True, finds the largest of the leftmost timestamps and the smallest of the rightmost timestamps.\n    If min_time or max_time is defined, that value is used regardless of trim.\n    '''\n    if not isinstance(timestamps, np.ndarray):\n        timestamps = uneven_list2d_to_np(timestamps)\n    mean_diff = np.nanmean(np.diff(timestamps))\n    if trim:\n        min_time = np.nanmax(np.nanmin(timestamps,axis=1)) if min_time is None else min_time\n        max_time = np.nanmin(np.nanmax(timestamps,axis=1)) if max_time is None else max_time\n    else:\n        min_time = np.nanmin(timestamps) if min_time is None else min_time\n        max_time = np.nanmax(timestamps) if max_time is None else max_time\n\n    return np.arange(min_time, max_time, mean_diff)\n\ndef interpolate_to_new_timestamp(y, t, nt):\n    '''\n    y: 1d data, length same as t\n    t: original timestamp\n    nt: new timestamp to interpolate to\n    Returns ny, linearly interpolated data at nt\n    '''\n    not_nan = ~np.isnan(y)\n    return np.interp(nt, t[not_nan], y[not_nan], left=np.nan, right=np.nan)\n\n\ndef align_traces_to_standardized_timestamp(ts, xs, ts_standard=None, trim=False, min_time=None, max_time=None):\n    '''\n    Given ts and xs, 2d numpy arrays representing timestamps and corresponding values, \n    returns xs_standardized, xs values interpolated to a standardized timestamp, ts_standard.\n    If ts_standard is not provided, it is computed.\n    '''\n    if ts_standard is None:\n        ts_standard = generate_standard_timestamp(ts, trim=trim, min_time=min_time, max_time=max_time)\n    xs_standardized = np.array([interpolate_to_new_timestamp(xs[i], ts[i], ts_standard) for i in range(len(xs))])\n\n    return ts_standard, xs_standardized"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_606","text":"<filename>barry\/postprocessing\/bao_extractor.py\nimport numpy as np\nfrom barry.postprocessing.postprocessor import PkPostProcess\n\n\nclass PureBAOExtractor(PkPostProcess):\n    \"\"\" The pure BAO extractor detailed in Noda 2017 (1705.01475), Nishimishi 2018 (1708.00375), Noda 2019 (1901.06854)\n\n    See https:\/\/ui.adsabs.harvard.edu\/abs\/2017JCAP...08..007N\n    See https:\/\/ui.adsabs.harvard.edu\/abs\/2018JCAP...01..035N\n    See https:\/\/ui.adsabs.harvard.edu\/abs\/2019arXiv190106854N\n\n    Parameters\n    ----------\n    r_s : float\n        The sound horizon distance. In units of Mpc\/h\n    plot : bool, optional\n        Whether to output debugging plots\n    delta : float, optional\n        The window (in units of `r_s` to smooth)\n    \"\"\"\n\n    def __init__(self, r_s, plot=False, delta=0.6):\n        super().__init__()\n        self.r_s = r_s\n        self.plot = plot\n        self.delta = delta\n\n    def get_krange(self):\n        r\"\"\" Returns $k_s \\Delta$ as defined in Eq 6 of Nishimishi 2018\"\"\"\n        k_s = 2 * np.pi \/ self.r_s  # BAO Wavenumber\n        k_range = self.delta * k_s  # Range of k to sum over\n        return k_range\n\n    def postprocess(self, ks, pk, mask, return_denominator=False, plot=False):\n        \"\"\" Runs the BAO Extractor method and returns the extracted BAO signal.\n\n        Warning that this is the estimator given in Eq5 Nishimichi 2018\n\n        As such, make sure your k values are finely sampled and linearly spaced. Alas for\n        our data, this isn't always possible to do because the window function wrecks us.\n\n        Parameters\n        ----------\n        ks : np.array\n            The k values for the BAO power spectrum\n        pk : np.array\n            The power spectrum at `ks`\n\n        Returns\n        -------\n\n        \"\"\"\n        k_range = self.get_krange()\n\n        result = []\n        denoms = []\n        for k, p in zip(ks, pk):\n            k_diff = np.abs(ks - k)\n            m = k_diff < k_range\n            numerator = (1 - (pk[m] \/ p)).sum()\n            denominator = (1 - np.cos(self.r_s * (ks[m] - k))).sum()\n            res = numerator \/ denominator\n            denoms.append(denominator)\n            result.append(res)\n        result = np.array(result)\n\n        # Plots for debugging purposes to make sure everything looks good\n        if self.plot:\n            import matplotlib.pyplot as plt\n\n            fig, axes = plt.subplots(nrows=2, figsize=(5, 7))\n            axes[0].plot(ks, pk, label=\"Input\")\n            axes[1].plot(ks, result, label=\"Output\")\n            plt.show()\n\n        if mask is None:\n            mask = np.ones(result.shape).astype(np.bool)\n\n        # Optionally return the denominator instead\n        # Used for manually verifying the correctness of the covariance\n        # described in Eq7 (and Noda2019 eq 21,22,23)\n        if return_denominator:\n            return np.array(denoms)[mask]\n        return result[mask]\n\n\nclass BAOExtractor(PureBAOExtractor):\n    \"\"\" Implements the mix of BAO extractor and power spectrum as defined in Noda 2019, with\n    index mixing taken from page 9, paragraph 1 and confirmed via private communication:\n\n    pi_i = {1, 2, 3, 7, 15}\n    rho_i = {4,5,6,8,9,10,11,12,13,14,16,17,18,19,20,21,22,23,24,25}\n\n    \"\"\"\n\n    def __init__(self, r_s, plot=False, delta=0.6, mink=0.06, extra_ks=(0.0925, 0.1775), reorder=True, invert=False):\n        super().__init__(r_s, plot=plot, delta=delta)\n        self.mink = mink\n        self.extra_ks = extra_ks\n        self.reorder = reorder\n        self.invert = invert\n\n    def get_is_extracted(self, ks):\n        # Use indexes to blend the two together\n        indices = np.array(list(range(ks.size)))\n        extra = None\n        for e in self.extra_ks:\n            ind = np.argmin(np.abs(ks - e))\n            if extra is None:\n                extra = indices == ind\n            else:\n                extra |= indices == ind\n        mask_power = (ks < self.mink) | extra\n        if self.invert:\n            return mask_power\n        else:\n            return ~mask_power\n\n    def postprocess(self, ks, pk, mask):\n        \"\"\" Process the power spectrum to get a mix of extracted BAO and P(k)\n\n        Parameters\n        ----------\n        ks : np.ndarray\n            Wavenumbers\n        pk : np.ndarray\n            Power at wavenumber\n        mask : np.ndarray (bool mask), optional\n            Which k values to return at the end. Used to remove k values below \/ above certain values.\n            I pass them in here because if we reorder the k values the masking cannot be done outside this function.\n        \"\"\"\n        if mask is None:\n            mask = np.ones(pk.shape).astype(np.bool)\n        extracted_pk = super().postprocess(ks, pk, None)\n        mask_bao = self.get_is_extracted(ks)\n        if self.reorder:\n            result = np.concatenate((pk[mask & ~mask_bao], extracted_pk[mask & mask_bao]))\n        else:\n            mask_int = mask_bao.astype(np.int)\n            result = (extracted_pk * (mask_int) + pk * (1 - mask_int))[mask]\n        return result\n\n\nif __name__ == \"__main__\":\n    from barry.cosmology import CambGenerator\n\n    camb = CambGenerator(om_resolution=10, h0_resolution=1)\n    ks = camb.ks\n    print(ks.shape)\n    r_s, pk_lin, _ = camb.get_data(0.3, 0.70)\n\n    from scipy.interpolate import splev, splrep\n\n    rep = splrep(ks, pk_lin)\n    # ks2 = np.linspace(ks.min(), 1, 1000)\n    ks2 = np.linspace(0, 0.398, 100)  # Matching the winfit_2 data binning\n    pk_lin2 = splev(ks2, rep)\n\n    print(\"Got pklin\")\n    b = BAOExtractor(r_s)\n    pk_extract = b.postprocess(ks2, pk_lin2)\n    print(\"Got pk_extract\")\n\n    import matplotlib.pyplot as plt\n\n    fig, axes = plt.subplots(nrows=2, figsize=(5, 9), sharex=True)\n    axes[0].plot(ks2, pk_lin2)\n    axes[0].set_title(\"pk_lin\")\n    axes[1].plot(ks2, pk_extract)\n    axes[1].set_title(\"Extracted BAO, using winfit_2 bins (0, 0.398, 100)\")\n    plt.show()\n\n    from barry.datasets.mock_power import MockPowerSpectrum\n\n    dataset = MockPowerSpectrum(name=\"Recon mean\", recon=True, min_k=0.02, step_size=2, postprocess=b)\n    data = dataset.get_data()\n    import seaborn as sb\n\n    sb.heatmap(data[\"corr\"])\n    plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_607","text":"<filename>hw4\/c\/spectral_clustering.py\n#spectral_clustering:\n#1)consruct a matrix representation of the graph;\n#2)matrix decomposition:compute eigenvalue and eigenvectors of the matrix,map each point to a lower dimension\n#3)clustering\nimport time,operator\nimport networkx as nx\nimport numpy as np\nimport scipy,time\nfrom scipy.sparse.linalg import eigs\nfrom sklearn.cluster import KMeans\n\n#construct a grapgh of data\ndef parse(filename):\n    G = nx.Graph()\n    data = open(filename)\n    n1 = []\n    n2 = []\n    edges=[]\n    for i, rows in enumerate(data):\n        if '#' in rows:\n            continue\n        rows = rows.strip().split('\\t')\n        node_a = int(rows[0])\n        node_b = int(rows[1])\n        G.add_edge(node_a, node_b)\n    return G\n\n#consruct a matrix representation of the graph\ndef getLaplacian(m):\n    print time.ctime()\n    d=[row.sum() for row in m]  \n    print time.ctime()\n    D=scipy.sparse.diags(d,0)\n    print D\n    print time.ctime()\n    L=D-m\n    print time.ctime()\n    return L\n\n#matrix decomposition \ndef getLowerDimension(w,k):\n    print w.shape\n    eigValue,eigVec = eigs(w,k=100,which='LR')\n    import cPickle\n    print 'finished'\n    print time.ctime()\n    dim = len(eigValue)\n    print dim\n    print eigValue\n    return eigVec\n\nif __name__ == '__main__':\n    print time.ctime()\n    graph = parse('com-youtube.ungraph.txt')\n    laplacianMat = nx.laplacian_matrix(graph)\n    print time.ctime()\n    print time.ctime()\n    fout = open('spectral_clustering_result.txt','w')\n    np_matrix = nx.to_scipy_sparse_matrix(graph,dtype=np.float32)\n    print 'begin'\n    lapW = getLaplacian(np_matrix)\n    print 'end'\n    reduced_matrix = getLowerDimension(lapW,100)\n    print reduced_matrix.shape\n    print time.ctime()\n    #use Kmean to clustering\n    kmeans_model = KMeans(n_clusters=100,init='k-means++',n_init=10).fit(reduced_matrix)\n    print time.ctime()\n    count=0\n    for i in kmeans_model.labels_:\n        count=count+1\n        fout.write(str(count)+'\t'+str(i)+'\\n')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_593","text":"__author__ = 'dvgodoy'\n\nfrom neurons import Input, Hidden, Output\nfrom losses import LogLoss\nfrom scipy.io import loadmat\nimport os\n\nfrom activations import SigmoidActivation, ReluActivation, TanhActivation\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n\nclass Layer(object):\n    classes = ['Input', 'Hidden', 'Output']\n\n    def __init__(self, n_units, layer_type, **kwargs):\n        assert layer_type in self.classes\n        self._charged = False\n        self.n_units = n_units\n        self.layer_type = layer_type\n        neuron = globals()[layer_type]\n        self.units = [neuron(**kwargs) for _ in range(n_units)]\n\n    def connect(self, layer):\n        assert isinstance(layer, Layer)\n        for source in self.units:\n            for destination in layer.units:\n                source.connect(destination)\n\n    def fire(self):\n        mu, var = self.batch_norm()\n        for unit in self.units:\n            unit.fire(mu, var)\n\n    def feedback(self):\n        for unit in self.units:\n            unit.feedback()\n\n    def examples(self, X):\n        assert X.shape[0] == self.n_units\n        for i, unit in enumerate(self.units):\n            unit.examples(X[i, np.newaxis, :])\n\n    def responses(self, Y):\n        assert Y.shape[0] == self.n_units\n        for i, unit in enumerate(self.units):\n            unit.responses(Y[i, np.newaxis, :])\n\n    def batch_norm(self):\n        mu, var = 0.0, 1.0\n        if np.all([unit.charged for unit in self.units]):\n            z = np.array([unit._z for unit in self.units])\n            mu = z.mean(axis = 0)\n            var = z.var(axis = 0)\n        return mu, var\n\n    @property\n    def activations(self):\n        activations = np.array([unit.activations for unit in self.units])\n        return activations.reshape(activations.shape[0], -1)\n\n    @property\n    def weights(self):\n        weights = np.array([unit.weights for unit in self.units])\n        return weights.reshape(weights.shape[0], -1)\n\n    @property\n    def biases(self):\n        biases = np.array([unit.biases for unit in self.units])\n        return biases.reshape(biases.shape[0], -1)\n\n    @property\n    def cost(self):\n        return np.array([unit.cost for unit in self.units])\n\n\nif __name__ == '__main__':\n    np.random.seed(13)\n\n    name = 'var_u'\n    data = loadmat(os.path.join('..\/data', name + '.mat'))\n\n    sigmoid = SigmoidActivation()\n    relu = ReluActivation()\n    tanh = TanhActivation()\n\n    l_i = Layer(12, 'Input')\n    l_h1 = Layer(10, 'Hidden', activation_function=relu)\n    l_h2 = Layer(7, 'Hidden', activation_function=relu)\n    l_h3 = Layer(5, 'Hidden', activation_function=relu)\n    l_h4 = Layer(4, 'Hidden', activation_function=relu)\n    l_h5 = Layer(3, 'Hidden', activation_function=relu)\n    l_o = Layer(1, 'Output', activation_function=sigmoid, loss_function=LogLoss(), learning_rate=0.0004)\n    layers = [l_i, l_h1, l_h2, l_h3, l_h4, l_h5, l_o]\n\n    l_i.connect(l_h1)\n    l_h1.connect(l_h2)\n    l_h2.connect(l_h3)\n    l_h3.connect(l_h4)\n    l_h4.connect(l_h5)\n    l_h5.connect(l_o)\n\n    epochs = 10000\n    h1_weight_history = []\n    #h2_weight_history = []\n    #h3_weight_history = []\n    cost_history = []\n    examples = data['F'].reshape(12, -1)\n    responses = data['y']\n    batch_size = 4096\n    for epoch in range(epochs):\n        if not (epoch % 100):\n            print(epoch)\n        for n_batch in range(1):\n            examples = data['F'].reshape(12, -1)[:, (n_batch * batch_size):(n_batch * batch_size + batch_size)]\n            responses = data['y'][:, (n_batch * batch_size):(n_batch * batch_size + batch_size)]\n            l_i.examples(examples)\n            l_o.responses(responses)\n            for layer in layers:\n                layer.fire()\n            cost_history.append(l_o.cost)\n            h1_weight_history.append(l_h1.weights)\n            #h2_weight_history.append(l_h2.weights)\n            #h3_weight_history.append(l_h3.weights)\n            for layer in layers[::-1]:\n                layer.feedback()\n        #print(l_o.activations)\n        #print(l_o.cost)\n    print(l_o.activations)\n    predictions = l_o.activations > 0.5\n    print((predictions == responses).mean())\n    #h1_mean = [w.mean() for w in h1_weight_history]\n    #h2_mean = [w.mean() for w in h2_weight_history]\n    #h3_mean = [w.mean() for w in h3_weight_history]\n    #h1_std = [w.std() for w in h1_weight_history]\n    #h2_std = [w.std() for w in h2_weight_history]\n    #h3_std = [w.std() for w in h3_weight_history]\n    #plt.plot(h1_mean, 'k')\n    #plt.plot(h2_mean, 'r')\n    #plt.plot(h3_mean, 'g')\n    #plt.plot(h1_std, 'k--')\n    #plt.plot(h2_std, 'r--')\n    #plt.plot(h3_std, 'g--')\n    plt.plot(cost_history)\n    plt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_224","text":"import numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.optimize\n\ndef funzione (t, A, tau, w, phi, Vbias) :\n    return A * np.exp(-t\/tau) * np.cos(w*t+phi) + Vbias\n\nt, ddp = np.genfromtxt(\"long3.txt\", unpack=True)\n\nx = np.linspace(0, 100000, 4000)\nplt.figure()\nplt.plot(t, ddp, 'o')\nplt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_226","text":"<filename>RoundTrQBlackScholes.py\n\"\"\"\nAuthor : <NAME>\nDate : 2019-08-04\nDesc : Valuing Option Price under Transaction Cost. Re-hedging with round trip method.\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfrom numpy.random import standard_normal, seed\nfrom scipy.stats import norm\n\nimport sys\n\nimport datetime\nimport time\nimport bspline\nimport bspline.splinelab as splinelab\n\nREG_PARAM = 1e-3\n\n\nclass RoundTrQBlackScholes:\n    def __init__(self,\n                 mu: float,\n                 vol: float,\n                 s0: float,\n                 T: int,\n                 K : float,\n                 r: float,\n                 num_steps: int,\n                 num_paths: int,\n                 risk_lambda: float,\n                 tr_alpha: float):\n        self.mu = mu\n        self.vol = vol\n        self.s0 = s0\n        self.T = T\n        self.K = K\n        self.r = r\n        self.num_steps = num_steps\n        self.num_paths = num_paths\n        self.risk_lambda = risk_lambda\n\n        self.dt = T \/ num_steps\n        self.gamma = np.exp(-r * self.dt)\n        self.tr_alpha = tr_alpha\n\n        self.s_values = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n        self.delta_S = None\n        self.s_values[:, 0] = s0 * np.ones(self.num_paths, 'float')\n\n        self.opt_hedge = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n\n        self.X = None\n        self.data = None\n        self.delta_S_hat = None\n        coef = 1.0 \/ (2 * self.gamma * self.risk_lambda)\n        self.coef = coef\n\n        self.pi = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n        self.pi_hat = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n\n        self.q = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n        self.r = np.zeros((self.num_paths, self.num_steps + 1), 'float')\n\n    def gen_path(self):\n        # Path Generator (Black Scholes )\n        seed(42)\n\n        for i in range(1, self.num_steps + 1):\n            std_norm = standard_normal(self.num_paths)\n            exp_pow = (self.mu - self.vol ** 2 \/ 2) * self.dt \\\n                      + self.vol * np.sqrt(self.dt) * std_norm\n            self.s_values[:, i] = self.s_values[:, i - 1] * np.exp(exp_pow)\n\n        delta_S = (1 - self.tr_alpha) * self.s_values[:, 1:] - 1 \/ self.gamma * self.s_values[:, :self.num_steps]\n        self.delta_S = delta_S\n        self.delta_S_hat = np.apply_along_axis(lambda x: x - np.mean(x), axis=0, arr=delta_S)\n        self.X = - (self.mu - 0.5 * self.vol ** 2) * np.arange(self.num_steps + 1) * self.dt + np.log(self.s_values)\n\n        X_min = np.min(np.min(self.X))\n        X_max = np.max(np.max(self.X))\n\n        print(\"Shape of X : {} \\n Max : {} \\n Min : {}\".format(self.X.shape, X_max, X_min))\n\n        self.pi[:, -1] = np.maximum(self.s_values[:, -1] - self.K, 0)\n        self.pi_hat[:, -1] = self.pi[:, -1] - np.mean(self.pi[:, -1])\n\n        self.q[:, -1] = -self.pi[:, -1] - self.risk_lambda * np.var(self.pi[:, -1])\n        self.r[:, -1] = -self.risk_lambda * np.var(self.pi[:, -1])\n\n        p = 4\n        ncolloc = 12\n        tau = np.linspace(X_min, X_max, ncolloc)\n\n        k = splinelab.aptknt(tau, p)\n        basis = bspline.Bspline(k, p)\n\n        num_basis = ncolloc\n        self.data = np.zeros((self.num_steps + 1, self.num_paths, num_basis))\n\n        t0 = time.time()\n        for ix in np.arange(self.num_steps + 1):\n            x = self.X[:, ix]\n            self.data[ix, :, :] = np.array([basis(el) for el in x])\n        t1 = time.time()\n        print(\"\\nTime for basis expansion {}\".format(t1 - t0))\n\n    def function_A_vec(self, t, reg_param=1e-3):\n        \"\"\" Equation for matrix A\n        self.data : T x N_MC x num_basis\n        self.delta_S_hat : N_MC x T\n        :param t:\n        :param reg_param:\n        :return:\n        \"\"\"\n        x_data = self.data[t, :, :]\n        num_basis_funcs = x_data.shape[1]\n        self_dS = self.delta_S_hat[:, t]\n        # hat_dS2 = (self_dS ** 2).reshape(-1, 1)\n        # mat_A = np.dot(x_data.T, x_data * hat_dS2)\n        x_data = x_data.T * self_dS\n        mat_A = x_data @ x_data.T   # Wrong line, its result is scalar ???\n\n\n\n        return mat_A + reg_param * np.eye(num_basis_funcs)\n\n    def function_B_vec(self, t, pi_hat):\n        x_data = self.data[t, :, :]\n        this_dS = self.delta_S_hat[:, t]\n        # coef = 1 \/ (2 * self.gamma * self.risk_lambda)\n        coef = 0\n        mat_B = x_data.T @ (pi_hat * this_dS + coef * self.delta_S[:, t])\n\n        return mat_B\n\n    def roll_backward_hedge(self):\n        \"\"\"\n        Roll backward and get the price and optimal hedge vals\n        :return:\n        \"\"\"\n        for t in range(self.num_steps - 1, -1, -1):\n            pi_next = self.pi[:, t + 1]\n            pi_next_prime = pi_next + self.tr_alpha * self.opt_hedge[:, t + 1] * self.s_values[:, t + 1]\n            pi_prime_hat = pi_next_prime - np.mean(pi_next_prime)\n\n            mat_A = self.function_A_vec(t, REG_PARAM)\n            vec_B = self.function_B_vec(t, pi_prime_hat)\n\n            phi = np.linalg.inv(mat_A) @ vec_B\n            self.opt_hedge[:, t] = np.dot(self.data[t, :, :], phi)\n            self.pi[:, t] = self.gamma * (pi_next_prime - self.opt_hedge[:, t] * self.delta_S[:, t])\n            self.r[:, t] = self.gamma * self.opt_hedge[:, t] * self.delta_S[:, t] \\\n                           - self.risk_lambda * np.var(self.pi[:, t])\n\n\n    def function_C_vec(self, t, reg_param):\n        this_data = self.data[t, :, :]\n        mat_C = this_data.T @ this_data\n        return mat_C + reg_param * np.eye(this_data.shape[1])\n\n\n    def function_D_vec(self, t):\n        this_data = self.data[t, :, :]\n        this_q = self.q[:, t + 1]\n        this_r = self.r[:, t]\n        vec_D = this_data.T @ (this_r + self.gamma * this_q\n                             - self.tr_alpha * self.opt_hedge[:, t + 1] * self.s_values[:, t + 1])\n        return vec_D\n\n    def roll_backward_q(self):\n        \"\"\"\n        Roll backward to get q values\n        :return:\n        \"\"\"\n        start_time = time.time()\n        for t in range(self.num_steps - 1, -1, -1):\n            c_mat = self.function_C_vec(t, REG_PARAM)\n            d_vec = self.function_D_vec(t)\n            omega = np.linalg.inv(c_mat) @ d_vec\n\n            self.q[:, t] = self.data[t, :, :] @ omega\n        print(\"\\n Time : \", time.time() - start_time)\n\n\nif __name__ == \"__main__\":\n    trMC = RoundTrQBlackScholes(0.02, 0.2, 100, 1, 0.04, 25200, 1000, 0.001, 0.001)\n    trMC.gen_path()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_227","text":"from basic import *\nfrom all_genes import all_genes\nfrom scipy.cluster import hierarchy\nfrom scipy.spatial import distance\nimport os\nimport html_colors\nimport parse_tsv\n\nverbose = __name__ == '__main__'\n\n# these helper functions used to do more work, now it's a little silly...\n\ndef get_rep( gene, organism ):\n    assert gene.startswith('TR')\n    return all_genes[organism][gene].rep\n\ndef get_mm1_rep( gene, organism ):\n    assert gene.startswith('TR')\n    return all_genes[organism][gene].mm1_rep\n\ndef get_rep_ignoring_allele( gene, organism ):\n    rep = get_rep( gene, organism )\n    rep = rep[:rep.index('*')]\n    return rep\n\ndef get_mm1_rep_gene_for_counting( allele, organism ):\n    return all_genes[organism][allele].count_rep\n\ndef countreps_from_genes( genes, organism ):\n    return set( ( all_genes[organism][x].count_rep for x in genes ) )\n\n\ndef tree_sort( old_l, distances, return_leaves=True ): ## average linkage\n    assert len(distances) == len(old_l)\n\n    if len(old_l)==1:\n        leaves = [0]\n    else:\n        y = distance.squareform( distances, checks=True )\n        Z = hierarchy.average( y )\n        #c,coph_dists = hierarchy.cophenet(Z,y)\n        leaves = hierarchy.leaves_list( Z )\n\n    new_l = [ old_l[x] for x in leaves ]\n\n    if not return_leaves:\n        return new_l\n    else:\n        return new_l, leaves\n\ndef get_top_genes( blast_hits_string ):\n    hits = dict( [ ( x.split(':')[0], int( x.split(':')[1] ) ) for x in blast_hits_string.split(';') ] )\n    top_score = max( hits.values() )\n    return set( [ x for x,y in hits.iteritems() if y >= top_score ] )\n\ndef get_top_reps( blast_hits_string, organism ):\n    hits = dict( [ ( x.split(':')[0], int( x.split(':')[1] ) ) for x in blast_hits_string.split(';') ] )\n    top_score = max( hits.values() )\n    return set( [ all_genes[organism][x].rep for x,y in hits.iteritems() if y >= top_score ] )\n\n\ndef reps_from_genes( genes, organism, mm1=False, trim_allele=False ):\n    reps = set( ( all_genes[organism][x].mm1_rep for x in genes ) ) if mm1 else \\\n           set( ( all_genes[organism][x].rep     for x in genes ) )\n    if trim_allele:\n        reps = set( ( x[:x.index('*')] for x in reps ) )\n    return reps\n\ndef readme( pngfile, text ):\n    \"\"\"Generate some readme text associated to an image file, that will be incorporated into the\n    big html results file by run_basic_analysis.py\"\"\"\n\n    out = open(pngfile+'.readme','w')\n    cmd = ' '.join(argv)\n    out.write(\"\"\"\n<u>Command<\/u>:\n{}\n<br><br>\n<u>Filename<\/u>:\n{}\n<br><br>\n<u>Readme<\/u>:\n{}\n<br><br>\n\"\"\".format(cmd, pngfile, text))\n    out.close()\n\n\n## setup a mapping that we can use for counting when allowing mm1s and also ignoring alleles\n\n# allele2mm1_rep_gene_for_counting = {}\n# def get_mm1_rep_ignoring_allele( gene, organism ): # helper fxn\n#     rep = get_mm1_rep( gene, organism )\n#     rep = rep[:rep.index('*')]\n#     return rep\n\n# for organism in ['human','mouse']:\n#     allele2mm1_rep_gene_for_counting[ organism ] = {}\n\n#     for chain in 'AB':\n\n#         ## look at gene\/allele maps\n#         vj_alleles = { 'V': [ id for (id,g) in all_genes[organism].iteritems() if g.chain==chain and g.region=='V'],\n#                        'J': [ id for (id,g) in all_genes[organism].iteritems() if g.chain==chain and g.region=='J'] }\n\n#         for vj, alleles in vj_alleles.iteritems():\n#             gene2rep = {}\n#             gene2alleles = {}\n#             rep_gene2alleles = {}\n\n#             for allele in alleles:\n#                 #assert allele[2] == chain\n#                 gene = allele[:allele.index('*')]\n#                 rep_gene = get_mm1_rep_ignoring_allele( allele, organism )\n#                 if rep_gene not in rep_gene2alleles:\n#                     rep_gene2alleles[ rep_gene ] = []\n#                 rep_gene2alleles[ rep_gene ].append( allele )\n\n#                 if gene not in gene2rep:\n#                     gene2rep[gene] = set()\n#                     gene2alleles[gene] = []\n#                 gene2rep[ gene ].add( rep_gene )\n#                 gene2alleles[gene].append( allele )\n\n#             merge_rep_genes = {}\n#             for gene,reps in gene2rep.iteritems():\n#                 if len(reps)>1:\n#                     assert vj=='V'\n#                     if verbose:\n#                         print 'multireps:',organism, gene, reps\n#                         for allele in gene2alleles[gene]:\n#                             print ' '.join(all_genes[organism][allele].cdrs), allele, \\\n#                                 get_rep(allele,organism), get_mm1_rep(allele,organism)\n\n#                     ## we are going to merge these reps\n#                     ## which one should we choose?\n#                     l = [ (len(rep_gene2alleles[rep]), rep ) for rep in reps ]\n#                     l.sort()\n#                     l.reverse()\n#                     assert l[0][0] > l[1][0]\n#                     toprep = l[0][1]\n#                     for (count,rep) in l:\n#                         if rep in merge_rep_genes:\n#                             assert rep == toprep and merge_rep_genes[rep] == rep\n#                         merge_rep_genes[ rep ] = toprep\n\n\n#             for allele in alleles:\n#                 count_rep = get_mm1_rep_ignoring_allele( allele, organism )\n#                 if count_rep in merge_rep_genes:\n#                     count_rep = merge_rep_genes[ count_rep ]\n#                 allele2mm1_rep_gene_for_counting[ organism ][ allele] = count_rep\n#                 if verbose:\n#                     print 'allele2mm1_rep_gene_for_counting:',organism, allele, count_rep\n\n\n\ndef assign_label_reps_and_colors_based_on_most_common_genes_in_repertoire( tcr_infos, organism ):\n    ## assumes that each element of tcr_infos is a dictionary with fields that would have come from parse_tsv_line\n    ## uses the *_countreps info that was filled in by read_pair_seqs.py\n    ## the _label_rep* fields get over-written if they were present\n    for segtype in segtypes_lowercase:\n        countreps_tag = segtype+'_countreps'\n        rep_tag       = segtype+'_label_rep'\n        color_tag     = segtype+'_label_rep_color' ## where we will store the rep info\n\n        counts = {}\n        for tcr_info in tcr_infos:\n            reps = tcr_info[countreps_tag].split(';')\n            for rep in reps:\n                counts[rep] = counts.get(rep,0)+1\n\n        newcounts = {}\n        for tcr_info in tcr_infos:\n            reps = tcr_info[countreps_tag].split(';')\n            toprep = max( [ ( counts[x],x) for x in reps ] )[1]\n            tcr_info[rep_tag] = toprep ## doesnt have allele info anymore\n            newcounts[toprep] = newcounts.get(toprep,0)+1\n\n        l = [(y,x) for x,y in newcounts.iteritems()]\n        l.sort()\n        l.reverse()\n        rep_colors = dict( zip( [x[1] for x in l], html_colors.get_rank_colors_no_lights(len(l)) ) )\n        for tcr_info in tcr_infos:\n            tcr_info[ color_tag ] = rep_colors[ tcr_info[ rep_tag ] ]\n\n    return ## we modified the elements of the tcr_infos list in place\n\n\n## this is not exactly perfect, but probably OK to start with...\n##\ndef detect_fake_chains( clones_file, Achain='A', Bchain='B' ):\n    tcrs = parse_tsv.parse_tsv_file( clones_file, key_fields = [], store_fields = ['va_gene','cdr3a','vb_gene','cdr3b'] )\n    fake_chains = []\n    if len( set( [ (x[0],x[1]) for x in tcrs ] ) )==1:\n        fake_chains.append( Achain )\n    if len( set( [ (x[2],x[3]) for x in tcrs ] ) )==1:\n        fake_chains.append( Bchain )\n    if fake_chains:\n        print 'Fake sequence data detected for chains: {}'.format( ' '.join( fake_chains ) )\n    return fake_chains\n\n\n\n\n\n# if __name__ == '__main__':\n#     for organism in allele2mm1_rep_gene_for_counting:\n#         for allele in allele2mm1_rep_gene_for_counting[ organism ]:\n#             print 'get_mm1_rep_gene_for_counting\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_228","text":"<reponame>zenmood\/IndoorFarmWiz<filename>venv\/lib\/python3.7\/site-packages\/pba\/dists.py<gh_stars>10-100\nif __name__ is not None and \".\" in __name__:\n    from .interval import Interval\nelse:\n    from interval import Interval\n\nif __name__ is not None and \".\" in __name__:\n    from .pbox import Pbox\nelse:\n    from pbox import Pbox\n\nimport scipy.stats as sps\nimport numpy as np\nimport itertools\n\ndists = {\n    'alpha' : sps.alpha,\n    'anglit' : sps.anglit,\n    'arcsine' : sps.arcsine,\n    'argus' : sps.argus,\n    'beta' : sps.beta,\n    'betaprime' : sps.betaprime,\n    'bradford' : sps.bradford,\n    'burr' : sps.burr,\n    'burr12' : sps.burr12,\n    'cauchy' : sps.cauchy,\n    'chi' : sps.chi,\n    'chi2' : sps.chi2,\n    'cosine' : sps.cosine,\n    'crystalball' : sps.crystalball,\n    'dgamma' : sps.dgamma,\n    'dweibull' : sps.dweibull,\n    'erlang' : sps.erlang,\n    'expon' : sps.expon,\n    'exponnorm' : sps.exponnorm,\n    'exponweib' : sps.exponweib,\n    'exponpow' : sps.exponpow,\n    'f' : sps.f,\n    'fatiguelife' : sps.fatiguelife,\n    'fisk' : sps.fisk,\n    'foldcauchy' : sps.foldcauchy,\n    'foldnorm' : sps.foldnorm,\n    # 'frechet_r' : sps.frechet_r,\n    # 'frechet_l' : sps.frechet_l,\n    'genlogistic' : sps.genlogistic,\n    'gennorm' : sps.gennorm,\n    'genpareto' : sps.genpareto,\n    'genexpon' : sps.genexpon,\n    'genextreme' : sps.genextreme,\n    'gausshyper' : sps.gausshyper,\n    'gamma' : sps.gamma,\n    'gengamma' : sps.gengamma,\n    'genhalflogistic' : sps.genhalflogistic,\n    'geninvgauss' : sps.geninvgauss,\n    'gilbrat' : sps.gilbrat,\n    'gompertz' : sps.gompertz,\n    'gumbel_r' : sps.gumbel_r,\n    'gumbel_l' : sps.gumbel_l,\n    'halfcauchy' : sps.halfcauchy,\n    'halflogistic' : sps.halflogistic,\n    'halfnorm' : sps.halfnorm,\n    'halfgennorm' : sps.halfgennorm,\n    'hypsecant' : sps.hypsecant,\n    'invgamma' : sps.invgamma,\n    'invgauss' : sps.invgauss,\n    'invweibull' : sps.invweibull,\n    'johnsonsb' : sps.johnsonsb,\n    'johnsonsu' : sps.johnsonsu,\n    'kappa4' : sps.kappa4,\n    'kappa3' : sps.kappa3,\n    'ksone' : sps.ksone,\n    'kstwobign' : sps.kstwobign,\n    'laplace' : sps.laplace,\n    'levy' : sps.levy,\n    'levy_l' : sps.levy_l,\n    'levy_stable' : sps.levy_stable,\n    'logistic' : sps.logistic,\n    'loggamma' : sps.loggamma,\n    'loglaplace' : sps.loglaplace,\n    'lognorm' : sps.lognorm,\n    'loguniform' : sps.loguniform,\n    'lomax' : sps.lomax,\n    'maxwell' : sps.maxwell,\n    'mielke' : sps.mielke,\n    'moyal' : sps.moyal,\n    'nakagami' : sps.nakagami,\n    'ncx2' : sps.ncx2,\n    'ncf' : sps.ncf,\n    'nct' : sps.nct,\n    'norm' : sps.norm,\n    'norminvgauss' : sps.norminvgauss,\n    'pareto' : sps.pareto,\n    'pearson3' : sps.pearson3,\n    'powerlaw' : sps.powerlaw,\n    'powerlognorm' : sps.powerlognorm,\n    'powernorm' : sps.powernorm,\n    'rdist' : sps.rdist,\n    'rayleigh' : sps.rayleigh,\n    'rice' : sps.rice,\n    'recipinvgauss' : sps.recipinvgauss,\n    'semicircular' : sps.semicircular,\n    'skewnorm' : sps.skewnorm,\n    't' : sps.t,\n    'trapz' : sps.trapz,\n    'triang' : sps.triang,\n    'truncexpon' : sps.truncexpon,\n    'truncnorm' : sps.truncnorm,\n    'tukeylambda' : sps.tukeylambda,\n    'uniform' : sps.uniform,\n    'vonmises' : sps.vonmises,\n    'vonmises_line' : sps.vonmises_line,\n    'wald' : sps.wald,\n    'weibull_min' : sps.weibull_min,\n    'weibull_max' : sps.weibull_max,\n    'wrapcauchy' : sps.wrapcauchy,\n    'bernoulli' : sps.bernoulli,\n    'betabinom' : sps.betabinom,\n    'binom' : sps.binom,\n    'boltzmann' : sps.boltzmann,\n    'dlaplace' : sps.dlaplace,\n    'geom' : sps.geom,\n    'hypergeom' : sps.hypergeom,\n    'logser' : sps.logser,\n    'nbinom' : sps.nbinom,\n    'planck' : sps.planck,\n    'poisson' : sps.poisson,\n    'randint' : sps.randint,\n    'skellam' : sps.skellam,\n    'zipf' : sps.zipf,\n    'yulesimon' : sps.yulesimon\n}\n\ndef __get_bounds(function_name = None,steps = 200,*args):\n\n    # define support\n    x = np.linspace(0.0001,0.9999,steps)\n\n    #get bound arguments\n    new_args = itertools.product(*args)\n\n    bounds = []\n\n    mean_hi = -np.inf\n    mean_lo = np.inf\n    var_lo = np.inf\n    var_hi = 0\n\n    for a in new_args:\n\n        bounds.append(dists[function_name].ppf(x,*a))\n        bmean, bvar = dists[function_name].stats(*a, moments = 'mv')\n\n        if bmean < mean_lo:\n            mean_lo = bmean\n        if bmean > mean_hi:\n            mean_hi = bmean\n        if bvar > var_hi:\n            var_hi = bvar\n        if bvar < var_lo:\n            var_lo = bvar\n\n\n    Left = [min([b[i] for b in bounds]) for i in range(steps)]\n    Right = [max([b[i] for b in bounds]) for i in range(steps)]\n\n    var  = Interval(np.float64(var_lo),np.float64(var_hi))\n    mean = Interval(np.float64(mean_lo),np.float64(mean_hi))\n\n    Left = np.array(Left)\n    Right = np.array(Right)\n\n    return Left, Right, mean, var\n\n\ndef lognormal(mean, var, steps = 200):\n\n    x = np.linspace(0,1,steps)\n\n    if mean.__class__.__name__ != 'Interval':\n        mean = Interval(mean,mean)\n    if var.__class__.__name__ != 'Interval':\n        var = Interval(var,var)\n\n    bound0 = sps.lognorm.ppf(x, mean.left, var.left)\n    bound1 = sps.lognorm.ppf(x, mean.right, var.left)\n    bound2 = sps.lognorm.ppf(x, mean.left, var.right)\n    bound3 = sps.lognorm.ppf(x, mean.right, var.right)\n\n    Left = [min(bound0[i],bound1[i],bound2[i],bound3[i]) for i in range(steps)]\n    Right = [max(bound0[i],bound1[i],bound2[i],bound3[i]) for i in range(steps)]\n\n    Left = np.array(Left)\n    Right = np.array(Right)\n    return Pbox(\n        Left,\n        Right,\n        steps = steps,\n        shape='lognormal',\n        mean_left=mean.left,\n        mean_right=mean.right,\n        var_left=var.left,\n        var_right=var.right)\nlognorm = lognormal\n\ndef alpha(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('alpha',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'alpha',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef anglit(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('anglit',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'anglit',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef arcsine(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('arcsine',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'arcsine',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef argus(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('argus',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'argus',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef beta(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('beta',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'beta',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef betaprime(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('betaprime',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'betaprime',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef bradford(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('bradford',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'bradford',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef burr(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('burr',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'burr',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef burr12(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('burr12',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'burr12',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef cauchy(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('cauchy',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'cauchy',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef chi(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('chi',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'chi',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef chi2(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('chi2',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'chi2',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef cosine(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('cosine',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'cosine',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef crystalball(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('crystalball',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'crystalball',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef dgamma(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('dgamma',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'dgamma',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef dweibull(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('dweibull',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'dweibull',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef erlang(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('erlang',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'erlang',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef expon(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('expon',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'expon',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef exponnorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('exponnorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'exponnorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef exponweib(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('exponweib',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'exponweib',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef exponpow(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('exponpow',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'exponpow',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef f(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('f',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'f',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef fatiguelife(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('fatiguelife',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'fatiguelife',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef fisk(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('fisk',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'fisk',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef foldcauchy(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('foldcauchy',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'foldcauchy',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef foldnorm(mu,s, steps = 200):\n\n    x = np.linspace(0.0001,0.9999,steps)\n    if mu.__class__.__name__ != 'Interval':\n        mu = Interval(mu)\n    if s.__class__.__name__ != 'Interval':\n        s = Interval(s)\n\n    new_args = [\n        [mu.lo()\/s.lo(),0,s.lo()],\n        [mu.hi()\/s.lo(),0,s.lo()],\n        [mu.lo()\/s.hi(),0,s.hi()],\n        [mu.hi()\/s.hi(),0,s.hi()]\n    ]\n\n\n    bounds = []\n\n    mean_hi = -np.inf\n    mean_lo = np.inf\n    var_lo = np.inf\n    var_hi = 0\n\n    for a in new_args:\n\n        bounds.append(sps.foldnorm.ppf(x,*a))\n        bmean, bvar = sps.foldnorm.stats(*a, moments = 'mv')\n\n        if bmean < mean_lo:\n            mean_lo = bmean\n        if bmean > mean_hi:\n            mean_hi = bmean\n        if bvar > var_hi:\n            var_hi = bvar\n        if bvar < var_lo:\n            var_lo = bvar\n\n\n    Left = [min([b[i] for b in bounds]) for i in range(steps)]\n    Right = [max([b[i] for b in bounds]) for i in range(steps)]\n\n    var  = Interval(np.float64(var_lo),np.float64(var_hi))\n    mean = Interval(np.float64(mean_lo),np.float64(mean_hi))\n\n    Left = np.array(Left)\n    Right = np.array(Right)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'foldnorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\n# def frechet_r(*args, steps = 200):\n#     args = list(args)\n#     for i in range(0,len(args)):\n#         if args[i].__class__.__name__ != 'Interval':\n#             args[i] = Interval(args[i])\n\n#     Left, Right, mean, var = __get_bounds('frechet_r',steps,*args)\n\n#     return Pbox(\n#           Left,\n#           Right,\n#           steps      = steps,\n#           shape      = 'frechet_r',\n#           mean_left  = mean.left,\n#           mean_right = mean.right,\n#           var_left   = var.left,\n#           var_right  = var.right\n#           )\n\n# def frechet_l(*args, steps = 200):\n#     args = list(args)\n#     for i in range(0,len(args)):\n#         if args[i].__class__.__name__ != 'Interval':\n#             args[i] = Interval(args[i])\n\n#     Left, Right, mean, var = __get_bounds('frechet_l',steps,*args)\n\n#     return Pbox(\n#           Left,\n#           Right,\n#           steps      = steps,\n#           shape      = 'frechet_l',\n#           mean_left  = mean.left,\n#           mean_right = mean.right,\n#           var_left   = var.left,\n#           var_right  = var.right\n#           )\n\ndef genlogistic(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('genlogistic',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'genlogistic',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gennorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gennorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gennorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef genpareto(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('genpareto',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'genpareto',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef genexpon(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('genexpon',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'genexpon',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef genextreme(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('genextreme',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'genextreme',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gausshyper(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gausshyper',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gausshyper',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gamma(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gamma',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gamma',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gengamma(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gengamma',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gengamma',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef genhalflogistic(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('genhalflogistic',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'genhalflogistic',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef geninvgauss(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('geninvgauss',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'geninvgauss',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gilbrat(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gilbrat',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gilbrat',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gompertz(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gompertz',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gompertz',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gumbel_r(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gumbel_r',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gumbel_r',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef gumbel_l(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('gumbel_l',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'gumbel_l',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef halfcauchy(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('halfcauchy',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'halfcauchy',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef halflogistic(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('halflogistic',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'halflogistic',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef halfnorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('halfnorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'halfnorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef halfgennorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('halfgennorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'halfgennorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef hypsecant(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('hypsecant',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'hypsecant',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef invgamma(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('invgamma',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'invgamma',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef invgauss(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('invgauss',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'invgauss',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef invweibull(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('invweibull',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'invweibull',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef johnsonsb(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('johnsonsb',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'johnsonsb',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef johnsonsu(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('johnsonsu',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'johnsonsu',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef kappa4(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('kappa4',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'kappa4',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef kappa3(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('kappa3',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'kappa3',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef ksone(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('ksone',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'ksone',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef kstwobign(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('kstwobign',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'kstwobign',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef laplace(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('laplace',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'laplace',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef levy(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('levy',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'levy',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef levy_l(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('levy_l',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'levy_l',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef levy_stable(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('levy_stable',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'levy_stable',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef logistic(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('logistic',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'logistic',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef loggamma(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('loggamma',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'loggamma',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef loglaplace(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('loglaplace',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'loglaplace',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef lognorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('lognorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'lognorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef loguniform(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('loguniform',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'loguniform',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef lomax(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('lomax',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'lomax',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef maxwell(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('maxwell',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'maxwell',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef mielke(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('mielke',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'mielke',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef moyal(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('moyal',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'moyal',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef nakagami(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('nakagami',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'nakagami',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef ncx2(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('ncx2',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'ncx2',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef ncf(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('ncf',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'ncf',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef nct(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('nct',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'nct',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef norm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('norm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'norm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef norminvgauss(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('norminvgauss',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'norminvgauss',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef pareto(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('pareto',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'pareto',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef pearson3(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('pearson3',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'pearson3',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef powerlaw(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('powerlaw',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'powerlaw',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef powerlognorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('powerlognorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'powerlognorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef powernorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('powernorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'powernorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef rdist(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('rdist',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'rdist',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef rayleigh(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('rayleigh',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'rayleigh',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef rice(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('rice',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'rice',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef recipinvgauss(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('recipinvgauss',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'recipinvgauss',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef semicircular(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('semicircular',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'semicircular',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef skewnorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('skewnorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'skewnorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef t(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('t',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 't',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef trapz(a,b,c,d , steps = 200):\n    if a.__class__.__name__ != 'Interval':\n        a = Interval(a)\n    if b.__class__.__name__ != 'Interval':\n        b = Interval(b)\n    if c.__class__.__name__ != 'Interval':\n        c = Interval(c)\n    if d.__class__.__name__ != 'Interval':\n        d = Interval(d)\n\n    x = np.linspace(0.0001,0.9999,steps)\n    left = sps.trapz.ppf(x,b.lo()\/d.lo(),c.lo()\/d.lo(),a.lo(),d.lo()-a.lo())\n    right = sps.trapz.ppf(x,b.hi()\/d.hi(),c.hi()\/d.hi(),a.hi(),d.hi()-a.hi())\n\n    return Pbox(\n          left,\n          right,\n          steps      = steps,\n          shape      = 'trapz'\n          )\n\ndef triang(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('triang',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'triang',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef truncexpon(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('truncexpon',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'truncexpon',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef truncnorm(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('truncnorm',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'truncnorm',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef tukeylambda(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('tukeylambda',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'tukeylambda',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\n\ndef uniform(a, b, steps = 200):\n\n    x = np.linspace(0,1,steps)\n\n    if a.__class__.__name__ != 'Interval':\n        a = Interval(a,a)\n    if b.__class__.__name__ != 'Interval':\n        b = Interval(b,b)\n\n    Left = np.linspace(a.left,b.left)\n    Right = np.linspace(a.right,b.right)\n\n    mean = 0.5 * (a+b)\n    var = ((b-a)**2 )\/12\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'uniform',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef vonmises(*args, steps = Pbox.STEPS):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('vonmises',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'vonmises',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef vonmises_line(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('vonmises_line',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'vonmises_line',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef wald(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('wald',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'wald',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef weibull_min(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('weibull_min',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'weibull_min',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef weibull_max(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('weibull_max',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'weibull_max',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef wrapcauchy(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('wrapcauchy',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'wrapcauchy',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef bernoulli(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('bernoulli',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'bernoulli',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef betabinom(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('betabinom',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'betabinom',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef binom(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('binom',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'binom',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef boltzmann(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('boltzmann',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'boltzmann',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef dlaplace(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('dlaplace',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'dlaplace',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef geom(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('geom',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'geom',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef hypergeom(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('hypergeom',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'hypergeom',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef logser(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('logser',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'logser',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef nbinom(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('nbinom',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'nbinom',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef planck(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('planck',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'planck',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef poisson(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('poisson',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'poisson',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef randint(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('randint',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'randint',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef skellam(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('skellam',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'skellam',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef zipf(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('zipf',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'zipf',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\ndef yulesimon(*args, steps = 200):\n    args = list(args)\n    for i in range(0,len(args)):\n        if args[i].__class__.__name__ != 'Interval':\n            args[i] = Interval(args[i])\n\n    Left, Right, mean, var = __get_bounds('yulesimon',steps,*args)\n\n    return Pbox(\n          Left,\n          Right,\n          steps      = steps,\n          shape      = 'yulesimon',\n          mean_left  = mean.left,\n          mean_right = mean.right,\n          var_left   = var.left,\n          var_right  = var.right\n          )\n\n\n### Other distributions\ndef KM(k,m,steps = 200):\n    return beta(Interval(k,k+1),Interval(m,m+1),steps = steps)\n\ndef KN(k,n,steps = 200):\n    return KM(k,n-k,steps=steps)\n\n\n### Alternate names\nnormal = norm\nN = normal\nunif = uniform\nU = uniform\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_229","text":"import numpy as np\nimport itertools\nimport raam\nimport pickle\nfrom raam import features\nfrom scipy import cluster\nfrom warnings import warn\n\ndef degradation(fun,charge,discharge):\n    \"\"\"\n    Constructs a capacity degradation function from given parameters.\n    \n    The functions are D- and D+: the anti-derivatives. See the paper for more details\n    \n    Parameters\n    ----------\n    fun : {\"polynomial\"}\n        Type of the function\n    charge : object\n        List of parameters for the function. \n        polynomial: (charge,discharge)\n            parameters are the coefficients with low to high order    \n    discharge : object\n        List of parameters for the function. \n        polynomial: (charge,discharge)\n            parameters are the coefficients with low to high order    \n\n    Returns\n    -------\n    out : function (x1,x2) \n        x1: initial level\n        x2: new level\n    \"\"\"\n    if fun == 'polynomial':\n        charge_a = np.array(charge)\n        discharge_a = np.array(discharge)\n        def polynomial(x1,x2):\n            if x1 <= x2:    # charge\n                # intentional x2 - x1\n                return np.polynomial.polynomial.polyval(x2,charge_a) - np.polynomial.polynomial.polyval(x1,charge_a) \n            else:           # discharge\n                # intentional: x1 - x2\n                return np.polynomial.polynomial.polyval(x1,discharge_a) - np.polynomial.polynomial.polyval(x2,discharge_a) \n        return polynomial\n    else:\n        raise ValueError('Incorrect function type: \"%s\"' % funtype)\n\nDefaultConfiguration = {\n    \"price_buy\" : [1.2,2.1,3.3],\n    \"price_sell\" : [1,2,3],\n    \"price_probabilities\" : np.array([[0.8, 0.1, 0.1],[0.1, 0.8, 0.1],[0.1, 0.1, 0.8]]),\n    \"initial_capacity\" : 1,\n    \"initial_inventory\" : 0.5,\n    \"degradation\" : {\"fun\":\"polynomial\",\"charge\":[0,0,0.01],\"discharge\":[0.01,0.02,0.01]},\n    \"capacity_cost\" : 1,\n    \"change_capacity\" : True,\n    \"charge_limit\" : 1, # limit on charge in a single step\n    \"discharge_limit\" : 1  # limit on discharge in a single step, absolute value\n    }\n\n\nclass Simulator(raam.Simulator):\n    \"\"\"\n    Simulates the evolution of the inventory, the total capacity, and the price \n    levels. The prices come from a Markov chain process.\n    \n    The initial state is generated from an expectation state \n    \n    State (tuple): \n        - inventory\n        - capacity\n        - priceindex \n    \n    Action: charge change\n        This is not an index but an absolute value of the change in charge\n\n    Parameters\n    ----------\n    config : dict\n        Configuration. See DefaultConfiguration for an example\n    discount : float, optional\n        Discount factor\n    action_cnt : int, optional\n        Number of ticks for discretizing actions.\n    inventory_cnt : int, optional\n        Number of ticks for discretizing inventory states. \n    capacity_cnt : int, optional\n        Discretization set for storage capacity states. \n        This step must be fine enough to capture the small\n        change in capacities\n    \"\"\"\n\n    def __init__(self,config,discount=0.9999,action_cnt=20,inventory_cnt=100,\\\n                    capacity_cnt=100):\n        self._discount = discount\n        self._action_cnt = action_cnt\n        self._inventory_cnt = inventory_cnt\n        self._capacity_cnt = capacity_cnt\n        \n        self.degradation = degradation(**config['degradation'])\n        self.initial_capacity = config['initial_capacity']\n        self.price_buy = config['price_buy']\n        self.price_sell = config['price_sell']\n        self.price_probabilities = config['price_probabilities']\n        self.capacity_cost = config['capacity_cost']\n        self.change_capacity = config['change_capacity']\n        self.initial_inventory = config['initial_inventory']\n\n        if 'charge_limit' not in config:\n            warn('No charge_limit in config, using 1')\n        if 'discharge_limit' not in config:\n            warn('No discharge_limit in config, using 1')\n        self.charge_limit = config['charge_limit'] if 'charge_limit' in config else 1\n        self.discharge_limit = config['discharge_limit'] if 'discharge_limit' in config else 1\n\n        # state and the distributions\n        self._all_states = None\n        self._initial_distribution = None\n\n        assert np.all(np.array(self.price_buy) >= 0)\n        assert np.all(np.array(self.price_sell) >= 0)\n        assert len(self.price_buy) == len(self.price_sell)\n        assert self.price_probabilities.shape[0] == self.price_probabilities.shape[1] == len(self.price_sell)\n        assert np.max(np.abs(np.sum(self.price_probabilities,1) - 1)) < 0.01\n        assert np.all(np.array(self.price_probabilities) >= 0)\n        assert self.capacity_cost >= 0\n        assert type(self.change_capacity) is bool\n        assert self.initial_inventory <= self.initial_capacity and self.initial_inventory >= 0 \n\n    @property\n    def discount(self):\n        return self._discount\n\n    def get_stateindex(self, decstate):\n        \"\"\"\n        Finds the index of the state in the list returned by all_states\n        \"\"\"\n        # lazy initialization\n        if self._all_states is None:\n            self.all_states()\n\n        return self._aggindex2stateindex[self._state_aggregation.classify(decstate)]\n\n\n    def all_states(self):\n        \"\"\"\n        Returns all states (quantized according to the parameters provided in the constructor)\n\n        There is no iteration over capacities if self.change_capacity = False and it is \n        fixed to be 0.\n\n        Important: Use self.get_stateindex() to get index of a state instead of searching this list.\n        It is much more efficient.\n\n        Returns\n        -------\n        out : np.ndarray\n            List of all states\n        \"\"\"\n        \n        # lazy initialization\n        if self._all_states is None:\n\n            pricecount = len(self.price_buy)\n\n            # if the capacity does not change, then aggregate the capacity dimension to only one value\n            if self.change_capacity:\n                # make sure that the centers of price clusters are integer numbers\n                self._state_aggregation = raam.features.GridAggregation(\\\n                         ((0,self.initial_capacity), (0,self.initial_capacity), (-0.5,pricecount-0.5)), \\\n                         (self._inventory_cnt, self._capacity_cnt, pricecount)  )\n            else:\n                self._state_aggregation = raam.features.GridAggregation(\\\n                         ((0,self.initial_capacity), (self.initial_capacity-0.1,self.initial_capacity+0.1), (-0.5,pricecount-0.5)), \\\n                         (self._inventory_cnt, 1, pricecount)  )\n\n            \n            \n            centers = list(self._state_aggregation.centers())\n\n            # select only states that have smaller inventory than capacity,\n            # and construct the mapping from aggregation index to the index in all_states\n            self._all_states, stateindex2aggindex = \\\n                zip(*( (s,i) for i,s in enumerate(centers) \\\n                        if s[0] <= s[1]))\n\n            # invert the aggregation index\n            self._aggindex2stateindex = [None] * len(centers)\n            for si,ai in enumerate(stateindex2aggindex):\n                self._aggindex2stateindex[ai] = si\n\n        return self._all_states\n\n    def initial_distribution(self):\n        \"\"\"\n        Returns initial distributions over states returned be all_states\n        \n        Returns\n        -------\n        out : np.ndarray\n            Initial distribution\n        \"\"\"\n\n        # lazy initialization\n        if self._initial_distribution is None:\n            from scipy import cluster\n            \n            allstates = self.all_states()\n            initialstate = self.initstates().__next__()\n\n            init_index = self.get_stateindex(initialstate)\n\n            distribution = np.zeros(len(allstates))\n            distribution[init_index] = 1.0\n\n            self._initial_distribution = distribution\n\n        return self._initial_distribution\n    \n\n    def all_transitions_continuous(self, decstate, action):\n        \"\"\"\n        Returns all transitions and probabilities for the given state and action.\n\n        The returned states are continuous and are not quantized according to \n        self._all_states()\n\n        Returns\n        -------\n        out : list\n            Sequence of tuples: (nextstate, probability, reward)\n        \"\"\"\n\n        inventory, capacity, priceindex = decstate\n        priceindex = int(priceindex)\n\n        assert(inventory >= 0 and inventory <= capacity)\n        \n        # determine buy and sell prices\n        pricesell = self.price_sell[priceindex]\n        pricebuy = self.price_buy[priceindex]\n        \n        # trim action based on the current inventory\n        action = max(action, - inventory)\n        action = min(action, capacity - inventory)\n        \n        # update the next inventory based on the action\n        ninventory = inventory + action\n        \n        # compute capacity loss\n        capacity_loss = self.degradation(inventory \/ capacity, ninventory \/ capacity) * capacity\n        assert capacity_loss >= -1e-10, 'Cannot have negative capacity loss' \n\n        if self.change_capacity:\n            ncapacity = max(0,capacity - capacity_loss)\n            ninventory = min(ninventory, ncapacity)\n        else:\n            ncapacity = capacity\n\n        # compute the reward for the transition\n        reward = - (pricebuy if action >= 0 else pricesell) * action\n        reward -= capacity_loss * self.capacity_cost\n\n        # sample the next price index\n        return (((ninventory,ncapacity,npriceindex),probability,reward) \\\n                for npriceindex, probability in \\\n                    enumerate(self.price_probabilities[priceindex,:]) if probability > 0)\n\n    def all_transitions(self, stateindex, actionindex):\n        \"\"\"\n        Returns all transitions and probabilities for the given state and action.\n\n        The returned states are continuous and are not quantized according to \n        self._all_states()\n\n        Parameters\n        ----------\n        stateindex : int\n            Index of the state in the list returned by all_states\n        actionindex : int\n            Index of the action in the list returned by actions\n\n        Returns\n        -------\n        out : sequence\n            Sequence of tuples: (nextstate, probability, reward)\n        \"\"\"\n        allstates = self.all_states()\n        decstate = allstates[stateindex]\n\n        allactions = self.actions(decstate)\n        action = allactions[actionindex]\n\n        # map transitions to the state indexes\n        return [(self.get_stateindex(s),p,r) \n            for s,p,r in \n                self.all_transitions_continuous(decstate, action)]\n\n    def transition(self,decstate,action):\n        \"\"\" \n        Represents a transition from a state.\n\n        Charging over the available capacity, or discharging below empty is not possible.\n        Any action that attempts to do that is automatically limited to the capacity.\n\n        Parameters\n        ----------\n        decstate : state\n            inventory,capacity,priceindex\n        action : float\n            change in charge (this is a float value, not the index)\n\n        Returns\n        -------\n        out : expectation state\n            inventory,capacity,reward\n        \"\"\"\n        #TODO: replace by a call to all_transitions\n        inventory, capacity, priceindex = decstate\n        assert inventory >= 0 and inventory <= capacity\n        \n        # determine buy and sell prices\n        pricesell = self.price_sell[priceindex]\n        pricebuy = self.price_buy[priceindex]\n        \n        # trim action based on the current inventory\n        action = max(action, - inventory)\n        action = min(action, capacity - inventory)\n        \n        # update the next inventory based on the action\n        ninventory = inventory + action\n        \n        # compute capacity loss\n        capacity_loss = self.degradation(inventory \/ capacity, ninventory \/ capacity) * capacity\n        assert capacity_loss >= -1e-10, 'Cannot have negative capacity loss' \n\n        if self.change_capacity:\n            ncapacity = max(0,capacity - capacity_loss)\n            ninventory = min(ninventory, ncapacity)\n        else:\n            ncapacity = capacity\n\n        # compute the reward for the transition\n        reward = - (pricebuy if action >= 0 else pricesell) * action\n        reward -= capacity_loss * self.capacity_cost\n\n        # sample the next price index\n        pricecount = self.price_probabilities.shape[1]\n        npriceindex = np.random.choice(\\\n            np.arange(pricecount,dtype=int), \\\n            p=self.price_probabilities[priceindex,:])\n\n        return (reward,(ninventory,ncapacity,npriceindex))\n\n    def actions(self, state):\n        \"\"\"\n        List of applicable actions in the state. Relative change\n        in capacity\n        \"\"\"\n        inventory, capacity, _ = state\n\n        discharge_floor = max(-inventory,-self.discharge_limit)\n        charge_ceil = min(capacity - inventory,self.charge_limit)\n\n        return np.linspace(discharge_floor, charge_ceil, self._action_cnt)\n\n    def initstates(self):\n        \"\"\" The initial state is given by the configuration and the 1st state of the \n        price process. \"\"\"\n        return itertools.repeat( (self.initial_inventory,self.initial_capacity,0) )\n\n    def price_levels(self):\n        \"\"\" Returns the number of price states in the Markov model \"\"\"\n        return self.price_probabilities.shape[0]\n\nclass Features:\n    \"\"\" \n    Suitable features for inventory management \n    \"\"\"\n    linear = (features.piecewise_linear(None), features.piecewise_linear(None))\n\n## Threshold policy definitions\ndef threshold_policy(lowers, uppers, simulator):\n    \"\"\"\n    Construct a threshold policy with different thresholds for different price \n    indexes.\n    \n    Assumes that the capacity of the battery does not change.\n    \n    Lower is the lower inventory target, and upper is the upper inventory target\n    \n    Parameters\n    ----------\n    lowers : list\n        List of lower thresholds\n    uppers : list\n        List of upper thresholds\n    simulator : inventory.Simulator\n        Simulator of the inventory problem (used to determine available actions)\n    \"\"\"    \n    assert len(lowers) == len(uppers)\n    assert np.min(uppers - lowers) >= -1e-4\n    \n    def policy(state):\n        inventory,capacity,priceindex = state\n        \n        # compute the target charge change\n        if inventory < lowers[priceindex]:\n            target = lowers[priceindex] - inventory # the target charge change\n        elif inventory > uppers[priceindex]:\n            target = uppers[priceindex] - inventory # the target charge change\n        else:\n            # if it is between the thresholds, then there is no change\n            target = 0\n        \n        # find the closest (discretized) action\n        actions = simulator.actions(state)\n        actionindex = np.argmin(np.abs(actions - target))\n        return actions[actionindex]\n    \n    return policy\n\n## Threshold Optimization Functions\n\nimport math\nimport random\n \ndef _eval_dimchange(sim,lowers,uppers,dim,l,u,horizon,runs):\n    \"\"\" Evaluates the dimension change impact \"\"\"\n    dim_lowers = lowers.copy()\n    dim_uppers = uppers.copy()\n    \n    dim_lowers[dim] = l\n    dim_uppers[dim] = u\n    \n    policy = raam.examples.inventory.threshold_policy(dim_lowers, dim_uppers, sim)\n    \n    # Common random numbers for the evaluation!\n    np.random.seed(0)\n    random.seed(0)\n    \n    samples = sim.simulate(horizon,policy,runs)\n    \n    print('.', end='')\n    return samples.statistics(sim.discount)['mean_return']\n\n\ndef optimize_jointly(sim,step=0.1,horizon=600,runs=5):\n    \"\"\"\n    Jointly optimizes uppen and lower thresholds for charging and discharging for \n    each dimension.\n    \n    It can be shown (a publication pending) that this method will compute\n    the optimal solution when there is no degradation in the battery.\n    \"\"\"\n    \n    values = [(l,u) for l in np.arange(0,1+step\/2,step) for u in np.arange(l,1+step\/2,step) ]\n    \n    # copy the lower and upper bounds\n    lowers = np.zeros(len(sim.price_buy))    # lower thresholds\n    uppers = np.ones(len(sim.price_buy))     # upper thresholds\n   \n    for iteration in range(10):\n        print('Lowers', lowers)\n        print('Uppers', uppers)\n        \n        for dimension in range(len(sim.price_sell)):\n            print('Dimension', dimension)\n            returns = [_eval_dimchange(sim,lowers,uppers,dimension,l,u,horizon,runs) for (l,u) in values]\n            \n            maxindex = np.argmax(returns)\n            \n            print('\\n', returns[maxindex])\n            l,u = values[maxindex]\n            lowers[dimension] = l\n            uppers[dimension] = u\n    \n    print('Lowers', lowers)\n    print('Uppers', uppers)\n\n\ndef optimize_independently(sim,step=0.1,horizon=600,runs=5):\n    \"\"\"\n    Optimizes the upper and lower thresholds independently. It is not clear \n    that this method actually computes the optimal policy        \n    \"\"\"\n    \n    epsilon = 1e-6                  # small value to deal with numertical issues\n\n    # copy the lower and upper bounds\n    lowers = 0.5*np.ones(len(sim.price_buy))    # lower thresholds\n    uppers = 0.5*np.ones(len(sim.price_buy))     # upper thresholds\n    \n    \n    for iteration in range(10):\n        print('Lowers', lowers)\n        print('Uppers', uppers)\n        \n        weight = 1.0 \/ math.sqrt(iteration + 1)\n        \n        for dimension in range(len(sim.price_sell)):\n            print('Dimension', dimension)\n            \n            print('   lowers')\n            values = np.arange(0,1+_epsilon,step)\n            if len(values) > 0:\n                returns = [_eval_dimchange(sim,lowers,uppers,dimension,\\\n                            l,max(l,uppers[dimension]),horizon,runs)\\\n                             for l in values]\n                maxindex = np.argmax(returns)\n                l = values[maxindex]\n                lowers[dimension] = weight * l + (1-weight)*lowers[dimension]\n                uppers[dimension] = max(uppers[dimension],lowers[dimension])\n                assert lowers[dimension] <= uppers[dimension]\n            \n                print('\\n',returns[maxindex])\n            \n            print('\\n   uppers')\n            values = np.arange(0,1+_epsilon,step)\n            if len(values) > 0:\n                returns = [_eval_dimchange(sim,lowers,uppers,dimension,\\\n                            min(lowers[dimension],u),u,horizon,runs) \\\n                            for u in values]\n                maxindex = np.argmax(returns)\n                u = values[maxindex]\n                uppers[dimension] = weight*u + (1-weight)*uppers[dimension]\n                lowers[dimension] = min(lowers[dimension],uppers[dimension])\n                assert lowers[dimension] <= uppers[dimension]\n            \n                print('\\n',returns[maxindex])\n\n    print('Lowers', lowers)\n    print('Uppers', uppers)\n\n\n## Plotting functions\n\ndef plot_degradation(degrad, ex_inventories = [0.1,0.5,0.9],delta=None):\n    \"\"\"\n    Plots the degradation function for examples of the current inventory\n    \n    Parameters\n    ----------\n    degrad : fun\n        Degradation function, the output of :fun:`degradation`\n    ex_inventories : list, optional\n        List of example inventories to use for plotting\n    delta : dict\n        Two delta functions (the derivative of the degradation)\n    \"\"\"\n    \n    import matplotlib.pyplot as pp\n    \n    x = np.linspace(0,1,100)\n    \n    #ax1 = pp.subplot()\n    \n    for ei in ex_inventories:\n        y = np.array([degrad(ei, ix) for ix in x])\n        pp.plot(100*x,100*y,label=\"$d(x,y-x)$,$x=%2.0f\\\\%%$\" % (100*ei))\n        \n    #ax2 = ax1.twinx()\n    \n    if delta is not None:\n        pp.plot(100*x, 100*delta['charge'](x), '.', label='$\\\\delta_+$')\n        pp.plot(100*x, 100*delta['discharge'](x), '.', label='$\\\\delta_-$')\n        \n    pp.xlabel('New State of Charge (%): $y$')\n    pp.ylabel('Capacity Loss (%): $d(x,y-x)$')\n    \n    pp.legend(loc=9)\n    pp.grid()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_230","text":"<gh_stars>100-1000\n# Copyright (c) 2020 Graphcore Ltd. All rights reserved.\nimport numpy as np\nimport scipy as sp\nfrom scipy import sparse\nimport os\nimport ctypes\nimport popart\n\nso_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),\n                       \"..\/..\/custom_ops.so\")\nctypes.cdll.LoadLibrary(so_path)\n\n\"\"\"\nThis example presents the extension of the sparse_softmax_subblock_demo.py example to multiple inputs\nIn NLP the attention matrix will have dims [batch_size, heads, n_sequence, n_sequence]\nWhere each batch item and head may have a different sparsity pattern.\n\nIn this example there are two attention heads each with a different mask (and number of active blocks)\n\"\"\"\n\n# INPUT DATA\nn_windows = 2\nn_sequence = 256\nwindow_size = n_sequence\/\/n_windows\nblocksize = [16, 16]\n\n\ndef type1_mask(window_size, n_windows, blocksize_x):\n    # Add the sparsity for the first attention head (autoregressive windows)\n    auto_mask = sp.sparse.tril(np.ones([window_size, window_size]), k = 0)\n    summary_mask = sp.sparse.lil_matrix((window_size, window_size))\n    summary_mask[:, window_size-blocksize_x:] = 1\n    global_mask = sp.sparse.kron(sp.sparse.tril(np.ones([n_windows, n_windows]), k = -1), summary_mask)\n    global_mask = (global_mask + sp.sparse.kron(sp.sparse.eye(n_windows), auto_mask)).sign()\n    return global_mask\n\n\ndef type2_mask(n_sequence, blocksize_x):\n    # Local mask attends to local block plus one backward (a bit like reformer)\n    # Autoregressive block on diagonal\n    A = np.expand_dims(sp.sparse.tril(np.ones((blocksize_x, blocksize_x)), 0).toarray(), 0)\n    A = A.repeat(n_sequence\/\/blocksize_x, axis = 0)\n    mask = sp.sparse.block_diag(A)\n\n    # Add full blocks on the -1 diagonal\n    C = sp.sparse.dia_matrix((np.ones((1, n_sequence)), [-1]), shape=[n_sequence\/\/blocksize_x]*2)\n    mask += sp.sparse.kron(C, np.ones((blocksize_x, blocksize_x)))\n    return mask\n\n\ndef mask_to_blocks(global_mask, blocksize):\n    # Get the block sparse format\n    bsr = sp.sparse.bsr_matrix(global_mask, blocksize = blocksize)\n    bsr.eliminate_zeros()  # need to call this to eliminate blocks of all zeros\n\n    # The dense blocks\n    blocks = np.reshape(bsr.data, [bsr.data.shape[0], -1])\n    blocks = sp.float32(list(blocks))\n\n    # Dense mask for each active block\n    mask_data = np.array([[[1]]]*len(bsr.indices))\n    active_mask = sp.sparse.bsr_matrix((mask_data, bsr.indices, bsr.indptr)).toarray()\n    active_mask = list(active_mask.flatten())\n    return blocks, active_mask\n\n# Get the two attention patterns\nhead1_blocks, head1_sparsity = mask_to_blocks(type1_mask(window_size, n_windows, blocksize[0]), blocksize)\nhead2_blocks, head2_sparsity = mask_to_blocks(type2_mask(n_sequence, blocksize[0]), blocksize)\n\n\ndef concat(h1, h2):\n    out = np.concatenate((h1, h2), 0)\n    out = np.tile(out, [2, 1])\n    return out\n\n# Build a matrix which is [2, 2, 256, 256] (B, H, S, S)\nmatrix_dims = [2, 2, n_sequence, n_sequence]\ninput_blocks = concat(head1_blocks, head2_blocks)\nsparsity = np.tile([*head1_sparsity, *head2_sparsity], 2)\n# There are 4 groups in total (B*H)\ngroup_sizes = np.tile([len(head1_blocks), len(head2_blocks)], 2)\n# note that group_sizes are equal to [80, 31, 80, 31]\n\n# #### MODEL CREATION ####\nbuilder = popart.Builder()\nlogits = np.array(list(input_blocks), dtype = sp.float32)\nlogits = builder.addInitializedInputTensor(logits, \"logits\")\n\nprobs = builder.customOp(opName = \"BsSoftmax\",\n                         opVersion = 1,\n                         domain = \"ai.graphcore\",\n                         inputs = [logits],\n                         attributes = {\n                          \"matrixDims\": matrix_dims,\n                          \"blockSize\": blocksize,\n                          \"sparsity\": sparsity.tolist(),\n                          \"groupSizes\": group_sizes.tolist(),\n                          \"subBlockMaskPerGroup\": \"[ZeroUpperTriangle, ZeroUpperTriangle, ZeroUpperTriangle, ZeroUpperTriangle]\"\n                         })[0]\ndlogits = popart.reservedGradientPrefix() + logits  # the gradient tensor's name\nupstream_grad = popart.reservedGradientPrefix() + probs  # the gradient tensor's name\n\n# Make some blocks to regress agains just so there are gradients\nexpected_tokens = np.zeros_like(input_blocks) + np.eye(16).flatten()\nexpected_tokens = -sp.float32(np.array(list(expected_tokens)))  # negative sign for negative logprob\nexpected_tokens = builder.aiOnnx.constant(expected_tokens, 'expected_tokens')\n\npbias = builder.aiOnnx.constant(np.zeros([1, input_blocks.shape[-1]], dtype=np.float32)+1e-6, 'pbias')\nbiased_probs = builder.aiOnnx.add([probs, pbias])\nlogprobs = builder.aiOnnx.log([biased_probs])\n\nout = builder.aiOnnx.mul([logprobs, expected_tokens])\nloss = builder.aiGraphcore.l1loss([out], 1.0)\n\n# Describe how to run the model\nanchor_desc = {probs: popart.AnchorReturnType(\"ALL\"), dlogits: popart.AnchorReturnType(\"ALL\"), upstream_grad: popart.AnchorReturnType(\"ALL\")}\ndataFlow = popart.DataFlow(1, anchor_desc)\n\nsession = popart.TrainingSession(fnModel = builder.getModelProto(),\n                                 loss = loss,\n                                 deviceInfo = popart.DeviceManager().acquireAvailableDevice(1),\n                                 optimizer = popart.ConstSGD(0.01),\n                                 dataFlow = dataFlow)\n\n# Compile graph\nsession.prepareDevice()\n\n# Create buffers to receive results from the execution\nanchors = session.initAnchorArrays()\n\n# TRAINING\nsession.weightsFromHost()\nstepio = popart.PyStepIO({}, anchors)\nsession.run(stepio)\nprint(\"Mean max grad of each row: \", np.mean(np.max(anchors[dlogits].reshape([-1, *blocksize]), axis = -1)))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_231","text":"\"\"\"\nUtility functions needed to compute the HP4-EDA descriptors\n\n@author: <NAME> (<EMAIL>)\n\"\"\"\n# ------------------------------------------------------------------------------------------------- #\n#Import the needed library.\nimport numpy as np\nimport glob, re\nfrom scipy.spatial.distance import pdist, squareform \n\n# ------------------------------------------------------------------------------------------------- #\n#Generic Function that returns a SORTED list of ALL filenames in a given directory(path), in ascending order.\ndef sort_directoryfiles(path, ext):\n    '''\n    INPUTS:\n\t\t(i) path: (Path to the directory containing files. Example: 'c:\/ekpo\/dataset\/')\n\t\t(ii) ext: (Extension of the files we intend to sort. Example: '.txt')\n    OUTPUTS:\n\t\t(i) sortedf: (List of ONLY filenames in 'path'. Example: '1.txt, 2.txt, ..., 9.txt, 10.txt, 11.txt ..., 99.txt, 100.txt,')\n   \n    AUTHOR: <NAME> (<EMAIL>) \n    '''\n    filepaths = glob.glob1(path,'*'+ ext)\n    sortedf = sorted(filepaths, key=lambda x:float(re.findall(\"(\\d+)\",x)[0]))\n    sortedpath = []\n    for i in np.arange(0, len(sortedf)):\n        fullpath = path + sortedf[i]\n        sortedpath.append(fullpath)\n    return sortedpath\n\n\n# ------------------------------------------------------------------------------------------------- #\ndef compare_allDescriptors_EMD(allDescriptors, outputdir, save_matrix_as = True):\n\t'''\n\tPURPOSE:\n\tTo compute the EMD (Wasserstein Distance) between a set of shape-descriptors.\n\n\tINPUTS:\n\t\t(i) allDescriptors: An [M x K] matrix of all descriptors, where M is the total number of models\/objects in the database, and K is the length of each descriptor.\n\t\t(ii) outputdir: Location or Directory, where the output to this function would be saved in. E.g: outputdir = \"c:\/myPyGraphics\/2018_Research_Implementations\/5_May_2018\/ekpoMayImplementations\/\"\n\t\t(iii) save_matrix_as: Default(None): If 'save_matrix_as' is given, This MUST be 'STRING' input, and this function adds the '.matrix' extension. E.g: \"jaccardDistanceMatrix_spbLSD.txt\"\n\tOUTPUT: \n\t\t(i) Dist_matrix: An N x N matrix, where the ij entry is the wasserstein_distance between the shape-descriptor for point cloud i and point cloud j.\n\tAUTHOR: <NAME> (<EMAIL>) \n\t'''\n\tpwdist = pdist(allDescriptors, wasserstein_distance) \n\tDist_matrix = squareform(pwdist)\n\tif save_matrix_as:\n\t\tdescrpath = outputdir + save_matrix_as + \".matrix\"\n\t\tnp.savetxt(descrpath, Dist_matrix, fmt='%f')\n\t\t\n\treturn Dist_matrix\n# ------------------------------------------------------------------------------------------------- #\n\n\ndef compare_allDescriptors_kld(allDescriptors, outputdir, save_matrix_as = True):\n\t'''\n\tPURPOSE:\n\tTo compute the Kullback Leibner Divergence Similarity\/Distance between a set of shape-descriptors.\n\n\tINPUTS:\n\tallDescriptors: An MxK matrix of all descriptors, where M is the total number of models(3D meshes) in the database, and K is the length of each descriptor.\n\toutputdir: Location or Directory, where the output to this function would be saved in. E.g: outputdir = \"c:\/myPyGraphics\/2018_Research_Implementations\/5_May_2018\/ekpoMayImplementations\/\"\n\tsave_matrix_as: Default(None): If 'save_matrix_as' is given, This MUST be 'STRING' input, and this function adds '.txt' extension. E.g: \"kldDistanceMatrix_spbLSD.txt\"\n\n\tOUTPUT: \n\tDist_matrix: An N x N matrix, where the ij entry is the KLD distance between the shape-descriptor for point cloud i and point cloud j.\n\t'''\n\tpw_dist = pdist(allDescriptors, kullback_divergence)\n\tDist_matrix = squareform(pw_dist)\n\tif save_matrix_as:\n\t\tdescrpath = outputdir + save_matrix_as + \".matrix\"\n\t\tnp.savetxt(descrpath, Dist_matrix, fmt='%f')\n\t\t\n\treturn Dist_matrix"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_232","text":"#IMPORTING LIBRARIES\nimport numpy as np \nimport pandas as pd\nimport os\nfrom sklearn import preprocessing\nfrom sklearn.model_selection import train_test_split\nfrom statistics import mean\nfrom sklearn.metrics import accuracy_score\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom scipy.stats import norm\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.preprocessing import LabelEncoder\nfrom scipy import stats\nimport random\nfrom matplotlib import rcParams\nimport re\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport tensorflow as tf\nimport tensorflowjs as tfjs\nfrom tensorflow.keras import models, regularizers\nimport cv2\nimport tensorflow as tf\nfrom tensorflow.keras import Sequential\nfrom tensorflow.keras.layers import Conv2D,MaxPool2D,Dropout,Flatten,Dense,BatchNormalization\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.callbacks import EarlyStopping\nfrom main_module import get_acc,model,split  #IMPORTING FROM main_module.py\nimport warnings\n\n#######################CONFIG_ONLY########################################\n\n#SETTING UP SOME CONFIG\nwarnings.filterwarnings(\"ignore\")\npd.pandas.set_option('display.max_columns',None)\npd.pandas.set_option('display.max_rows',None)\n\n#CHECKING TF VERSIONS\nprint(\"tf version : {}\".format(tf.__version__)) #IN MY CASE ITS 2.3+\nprint(\"tfjs version : {}\".format(tfjs.__version__)) #IN MY CASE ITS 2.7.0\n\n#SEEDING EVERYTHING\ndef seed_everything(seed):\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    os.environ['TF_DETERMINISTIC_OPS'] = '1'\n    os.environ['TF_KERAS'] = '1'\n\nSEED = 42\nseed_everything(SEED)\n\nwidth = 128\nheight = 128\n\n#######################CONFIG_ONLY########################################\n\n\n#FOR GENERATING DATA ON THE FLY\ndatagen = ImageDataGenerator(rescale=1\/255.0, validation_split=0.2)\n\n\n\ntrainDatagen = datagen.flow_from_directory(directory='..\/input\/cell-images-for-detecting-malaria\/cell_images\/cell_images\/',\n                                           target_size=(width,height),\n                                           class_mode = 'binary',\n                                           batch_size = 16,\n                                           subset='training')\n\n\n\nvalDatagen = datagen.flow_from_directory(directory='..\/input\/cell-images-for-detecting-malaria\/cell_images\/cell_images\/',\n                                           target_size=(width,height),\n                                           class_mode = 'binary',\n                                           batch_size = 16,\n                                           subset='validation')\n\n\n\n\n#MODEL ARCHITECTURE\nmodel = Sequential()\nmodel.add(Conv2D(16,(3,3),activation='relu',input_shape=(128,128,3)))\nmodel.add(MaxPool2D(2,2))\nmodel.add(Dropout(0.2))\n\nmodel.add(Conv2D(32,(3,3),activation='relu'))\nmodel.add(MaxPool2D(2,2))\nmodel.add(Dropout(0.3))\n\nmodel.add(Conv2D(64,(3,3),activation='relu'))\nmodel.add(MaxPool2D(2,2))\nmodel.add(Dropout(0.3))\n\nmodel.add(Flatten())\nmodel.add(Dense(64,activation='relu'))\nmodel.add(Dropout(0.5))\n\nmodel.add(Dense(1,activation='sigmoid'))\nmodel.summary()\n\nmodel.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])\n\n\n#ADDING EARLYSTOP\nearly_stop = EarlyStopping(monitor='val_loss',patience=2)\n\n# FITTING DATA TO THE MODEL\nhistory = model.fit_generator(generator = trainDatagen,\n                             steps_per_epoch = len(trainDatagen),\n                              epochs =20,\n                              validation_data = valDatagen,\n                              validation_steps=len(valDatagen),\n                             callbacks=[early_stop])\n\n\ntfjs.converters.save_keras_model(model, 'malaria_model')\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_233","text":"<filename>tests\/opt_matrix_test.py\n\"\"\"\nTest of the basic optimization functionality by basic matrix problems.\n\nMatrices are the simplest tensors.  Here we have simple matrix examples that are\nvery easy to think about.  All the core optimization strategies should first be\ntested here.\n\n\"\"\"\n\nimport pytest\nfrom drudge import Range, Drudge\nfrom sympy import symbols, IndexedBase\n\nfrom gristmill import optimize, verify_eval_seq, get_flop_cost\n\n\n@pytest.fixture\ndef three_ranges(spark_ctx):\n    \"\"\"Fixture with three ranges.\n\n    This drudge has three ranges, named M, N, L with sizes m, n, and l,\n    respectively.  It also has a substitution dictionary setting n = 2m and l\n    = 3m.\n\n    \"\"\"\n\n    dr = Drudge(spark_ctx)\n\n    # The sizes.\n    m, n, l = symbols('m n l')\n\n    # The ranges.\n    m_range = Range('M', 0, m)\n    n_range = Range('N', 0, n)\n    l_range = Range('L', 0, l)\n\n    dr.set_dumms(m_range, symbols('a b c d e f g'))\n    dr.set_dumms(n_range, symbols('i j k l m n'))\n    dr.set_dumms(l_range, symbols('p q r'))\n    dr.add_resolver_for_dumms()\n    dr.set_name(m, n, l)\n\n    dr.substs = {\n        n: m * 2,\n        l: m * 3\n    }\n\n    return dr\n\n\n#\n# Test of core functionality\n# --------------------------\n#\n\n\ndef test_matrix_chain(three_ranges):\n    \"\"\"Test a basic matrix chain multiplication problem.\n\n    Here a very simple matrix chain multiplication problem with three\n    matrices are used to test the factorization facilities.  In this simple\n    test, we will have three matrices :math:`x`, :math:`y`, and :math:`z`,\n    which are of shapes :math:`m\\\\times n`, :math:`n \\\\times l`, and :math:`l\n    \\\\times m` respectively. In the factorization, we are going to set\n    :math:`n = 2 m` and :math:`l = 3 m`.\n\n    \"\"\"\n\n    dr = three_ranges\n    p = dr.names\n    m, n, l = p.m, p.n, p.l\n\n    # The indexed bases.\n    x = IndexedBase('x', shape=(m, n))\n    y = IndexedBase('y', shape=(n, l))\n    z = IndexedBase('z', shape=(l, m))\n\n    target_base = IndexedBase('t')\n    target = dr.define_einst(\n        target_base[p.a, p.b],\n        x[p.a, p.i] * y[p.i, p.p] * z[p.p, p.b]\n    )\n\n    # Perform the factorization.\n    targets = [target]\n    stats = {}\n    eval_seq = optimize(targets, substs=dr.substs, stats=stats)\n    assert stats['Number of nodes'] < 2 ** 3\n    assert len(eval_seq) == 2\n\n    # Check the correctness.\n    assert verify_eval_seq(eval_seq, targets)\n\n    # Check the cost.\n    cost = get_flop_cost(eval_seq)\n    leading_cost = get_flop_cost(eval_seq, leading=True)\n    expected_cost = 2 * l * m * n + 2 * m ** 2 * n\n    assert cost == expected_cost\n    assert leading_cost == expected_cost\n\n\n@pytest.mark.parametrize('rand_constr', [True, False])\ndef test_shallow_matrix_factorization(three_ranges, rand_constr):\n    \"\"\"Test a shallow matrix multiplication factorization problem.\n\n    In this test, there are four matrices involved, X, Y, U, and V.  The final\n    expression to optimize is mathematically\n\n    .. math::\n\n        (2 X - Y) * (2 U + V)\n\n    Here, the expression is to be given in its expanded form originally, and\n    we test if it can be factorized into something similar to what we have\n    above. Here we have the signs and coefficients to have better code\n    coverage for these cases.  This test case more concentrates on the\n    horizontal complexity in the input.\n\n    \"\"\"\n\n    #\n    # Basic context setting-up.\n    #\n\n    dr = three_ranges\n    p = dr.names\n\n    m = p.m\n    a, b, c, d = p.a, p.b, p.c, p.d\n\n    # The indexed bases.\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    u = IndexedBase('U')\n    v = IndexedBase('V')\n    t = IndexedBase('T')\n\n    # The target.\n    target = dr.define_einst(\n        t[a, b],\n        4 * x[a, c] * u[c, b] + 2 * x[a, c] * v[c, b]\n        - 2 * y[a, c] * u[c, b] - y[a, c] * v[c, b]\n    )\n    targets = [target]\n\n    # The actual optimization.\n    res = optimize(targets, rand_constr=rand_constr)\n    assert len(res) == 3\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=False)\n\n    # Test the cost.\n    cost = get_flop_cost(res)\n    leading_cost = get_flop_cost(res, leading=True)\n    assert cost == 2 * m ** 3 + 2 * m ** 2\n    assert leading_cost == 2 * m ** 3\n    cost = get_flop_cost(res, ignore_consts=False)\n    assert cost == 2 * m ** 3 + 4 * m ** 2\n\n\ndef test_deep_matrix_factorization(three_ranges):\n    \"\"\"Test a basic matrix multiplication factorization problem.\n\n    Similar to the shallow factorization test, the final expression to optimize\n    is mathematically\n\n    .. math::\n\n        (X - 2 Y) * U * V\n\n    Different from the shallow test case, here we concentrate more on the\n    treatment of depth complexity in the input.  The sum intermediate needs to\n    be factored again.\n\n    \"\"\"\n\n    #\n    # Basic context setting-up.\n    #\n\n    dr = three_ranges\n    p = dr.names\n\n    m = p.m\n    a, b, c, d = p.a, p.b, p.c, p.d\n\n    # The indexed bases.\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    u = IndexedBase('U')\n    v = IndexedBase('V')\n    t = IndexedBase('T')\n\n    # The target.\n    target = dr.define_einst(\n        t[a, b], x[a, c] * u[c, d] * v[d, b] - 2 * y[a, c] * u[c, d] * v[d, b]\n    )\n    targets = [target]\n\n    # The actual optimization.\n    res = optimize(targets)\n    assert len(res) == 3\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=True)\n\n    # Test the cost.\n    cost = get_flop_cost(res)\n    leading_cost = get_flop_cost(res, leading=True)\n    assert cost == 4 * m ** 3 + m ** 2\n    assert leading_cost == 4 * m ** 3\n    cost = get_flop_cost(res, ignore_consts=False)\n    assert cost == 4 * m ** 3 + 2 * m ** 2\n\n    # Test disabling summation optimization.\n    res = optimize(targets, opt_sum=False)\n    assert verify_eval_seq(res, targets, simplify=True)\n    new_cost = get_flop_cost(res, ignore_consts=False)\n    assert new_cost - cost != 0\n\n\ndef test_factorization_of_two_products(three_ranges):\n    \"\"\"Test a sum where we have two disjoint products.\n\n    The final expression to optimize is\n\n    .. math::\n\n        2 X (3 U + 5 V) - 7 Y (11 U + 13 V) + 17 T\n\n    In this test case, we concentrate on the handling of multiple disjoint\n    possible factorization inside a single sum.\n\n    \"\"\"\n\n    #\n    # Basic context setting-up.\n    #\n\n    dr = three_ranges\n    p = dr.names\n\n    m = p.m\n    a, b, c = p.a, p.b, p.c\n\n    # The indexed bases.\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    u = IndexedBase('U')\n    v = IndexedBase('V')\n    t = IndexedBase('T')\n\n    # The target.\n    target = dr.define_einst(\n        IndexedBase('r')[a, b],\n        6 * x[a, c] * u[c, b] + 10 * x[a, c] * v[c, b]\n        - 77 * y[a, c] * u[c, b] - 91 * y[a, c] * v[c, b]\n        + 17 * t[a, b]\n    )\n    targets = [target]\n\n    # The actual optimization.\n    res = optimize(targets)\n    assert len(res) == 3\n    assert res[-1].n_terms == 3\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=True)\n\n    # Test the cost.\n    cost = get_flop_cost(res)\n    assert cost == 4 * m ** 3 + 4 * m ** 2\n\n\ndef test_general_matrix_problem(three_ranges):\n    \"\"\"Test optimization of a very general matrix computation.\n\n    This is a very general problem trying to test and illustrate many different\n    aspects of the optimization, parenthesization, recursion to newly-formed\n    factors, and sum of disjoint factorizations.  The target to evaluate reads\n\n    .. math::\n\n        (A + 2B) (3C + 5D) (7E + 13F) + (17P + 19Q) (23X + 29Y)\n\n    where\n\n    - A, B, P, Q is over ranges M, L\n    - C, D is over M, N\n    - E, F is over N, L\n    - X, Y is over L, N\n\n    \"\"\"\n\n    dr = three_ranges\n    p = dr.names\n\n    m, n, l = p.m, p.n, p.l\n    a, b = p.a, p.b\n    i = p.i\n    p = p.p\n\n    f1 = IndexedBase('A')[a, i] + 2 * IndexedBase('B')[a, i]\n    f2 = 3 * IndexedBase('C')[i, p] + 5 * IndexedBase('D')[i, p]\n    f3 = 7 * IndexedBase('E')[p, b] + 13 * IndexedBase('F')[p, b]\n    f4 = 17 * IndexedBase('P')[a, i] + 19 * IndexedBase('Q')[a, i]\n    f5 = 23 * IndexedBase('X')[i, b] + 29 * IndexedBase('Y')[i, b]\n\n    target = dr.define_einst(\n        IndexedBase('R')[a, b],\n        (f1 * f2 * f3 + f4 * f5).expand()\n    )\n    targets = [target]\n    assert target.n_terms == 12\n    assert get_flop_cost(targets).subs(dr.substs) == (\n            144 * m ** 4 + 16 * m ** 3 + 11 * m ** 2\n    )\n\n    eval_seq = optimize(targets, substs=dr.substs)\n\n    # Check the correctness.\n    assert verify_eval_seq(eval_seq, targets)\n    assert len(eval_seq) == 7\n    cost = get_flop_cost(eval_seq)\n    assert cost.subs(dr.substs) == 20 * m ** 3 + 16 * m ** 2\n\n\n#\n# Test of special cases\n# ---------------------\n#\n\n\n@pytest.mark.xfail(reason='Flaky until the following test is fixed')\ndef test_disconnected_outer_product_factorization(three_ranges):\n    \"\"\"Test optimization of expressions with disconnected outer products.\n    \"\"\"\n\n    dr = three_ranges\n    p = dr.names\n\n    m = p.m\n    a, b, c, d, e = p.a, p.b, p.c, p.d, p.e\n\n    # The indexed bases.\n    u = IndexedBase('U')\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    z = IndexedBase('Z')\n    t = IndexedBase('T')\n\n    # The target.\n    target = dr.define_einst(\n        t[a, b],\n        u[a, b] * z[c, e] * x[e, c] + u[a, b] * z[c, e] * y[e, c]\n    )\n    targets = [target]\n\n    # The actual optimization.\n    res = optimize(targets)\n    assert len(res) == 3\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=False)\n\n    # Test the cost.\n    cost = get_flop_cost(res)\n    leading_cost = get_flop_cost(res, leading=True)\n    assert cost == 4 * m ** 2\n    assert leading_cost == 4 * m ** 2\n\n\n@pytest.mark.xfail(reason='TODO: Needs investigation')\ndef test_factorization_needing_canonicalization(three_ranges):\n    \"\"\"Test a simple factorization needing canonicalization.\n\n    The inability of gristmill to fully optimize this test is the ultimate\n    reason why the above test is flaky.\n    \"\"\"\n\n    dr = three_ranges\n    p = dr.names\n\n    m = p.m\n    a, b = p.a, p.b\n\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    z = IndexedBase('Z')\n    t = Symbol('T')\n\n    # The target.\n    target = dr.define_einst(\n        t, x[b, a] * z[a, b] + y[a, b] * z[b, a]\n    )\n    targets = [target]\n\n    # The actual optimization.\n    res = optimize(targets)\n    assert len(res) == 2\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=False)\n\n\ndef test_optimization_of_common_terms(three_ranges):\n    \"\"\"Test optimization of common terms in summations.\n\n    In this test, there are just two matrices involved, X, Y.  The target reads\n\n    .. math::\n\n        T[a, b] = X[a, b] - X[b, a] + 2 Y[a, b] - 2 Y[b, a]\n\n    Ideally, it should be evaluated as,\n\n    .. math::\n\n        I[a, b] = X[a, b] + 2 Y[a, b]\n        T[a, b] = I[a, b] - I[b, a]\n\n    or,\n\n    .. math::\n\n        I[a, b] = X[a, b] - 2 Y[b, a]\n        T[a, b] = I[a, b] - I[b, a]\n\n    \"\"\"\n\n    #\n    # Basic context setting-up.\n    #\n    dr = three_ranges\n    p = dr.names\n\n    a, b, c, d = p.a, p.b, p.c, p.d\n\n    # The indexed bases.\n    x = IndexedBase('x')\n    y = IndexedBase('y')\n    t = dr.define_einst(\n        IndexedBase('t')[a, b],\n        x[a, b] - x[b, a] + 2 * y[a, b] - 2 * y[b, a]\n    )\n\n    targets = [t]\n    eval_seq = optimize(targets)\n    assert len(eval_seq) == 2\n    verify_eval_seq(eval_seq, targets)\n\n    # Check the result when the common symmetrization optimization is disabled.\n    eval_seq = optimize(targets, opt_symm=False)\n    assert len(eval_seq) == 1\n    verify_eval_seq(eval_seq, targets)\n\n\ndef test_eval_compression(three_ranges):\n    \"\"\"Test compression of optimized evaluations.\n\n    Here we have two targets,\n\n    .. math::\n\n        U X V + U Y V\n\n    and\n\n    .. math::\n\n        U X W + U Y W\n\n    and it has been deliberately made such that the multiplication with U\n    should be carried out first.  Then after the factorization of U, we have\n    an intermediate U (X + Y), which is a sum of a single product\n    intermediate.  This test succeeds when we have two intermediates only,\n    without the unnecessary addition of a single product.\n\n    \"\"\"\n\n    # Basic context setting-up.\n    dr = three_ranges\n    p = dr.names\n\n    a = p.a  # Small range\n    i, j, k = p.i, p.j, p.k  # Big range\n\n    # The indexed bases.\n    u = IndexedBase('U')\n    v = IndexedBase('V')\n    w = IndexedBase('W')\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n\n    s = IndexedBase('S')\n    t1 = IndexedBase('T1')\n    t2 = IndexedBase('T2')\n\n    # The target.\n    s_def = dr.define_einst(\n        s[i, j],\n        u[i, k] * x[k, j] + u[i, k] * y[k, j]\n    )\n    targets = [dr.define_einst(\n        t1[i, j],\n        s_def[i, a] * v[a, j]\n    ), dr.define_einst(\n        t2[i, j],\n        s_def[i, a] * w[a, j]\n    )]\n\n    # The actual optimization.\n    res = optimize(targets, substs=dr.substs)\n    assert len(res) == 4\n\n    # Test the correctness.\n    assert verify_eval_seq(res, targets, simplify=False)\n\n\n@pytest.mark.parametrize('res_at_end', [True, False])\ndef test_interleaving_res_interm(three_ranges, res_at_end):\n    r\"\"\"Test the interleaving of results and intermediates.\n\n    Here we have intermediate,\n\n    .. math::\n\n        I = X Y\n\n    and result\n\n    .. math::\n        R1 = I * 2\n\n    and result\n\n    .. math::\n\n        R2 = I * tr(R1)\n\n    \"\"\"\n\n    dr = three_ranges\n    p = dr.names\n    a, b, c, d, e = p.a, p.b, p.c, p.d, p.e\n\n    x = IndexedBase('X')\n    y = IndexedBase('Y')\n    r1 = IndexedBase('R1')\n    r2 = IndexedBase('R2')\n\n    r1_def = dr.define_einst(r1[a, b], x[a, c] * y[c, b] * 2)\n    r2_def = dr.define_einst(r2[a, b], x[a, c] * y[c, b] * x[d, e] * y[e, d])\n\n    origs = [r1_def, r2_def]\n    eval_seq = optimize(origs, res_at_end=res_at_end)\n\n    assert verify_eval_seq(eval_seq, origs)\n\n    assert len(eval_seq) == 4\n    if res_at_end:\n        assert eval_seq[2].base == r1\n    else:\n        assert eval_seq[1].base == r1\n    assert eval_seq[3].base == r2\n\n    for i in eval_seq:\n        assert i.if_interm == (not (str(i.base)[0] == 'R'))\n        continue\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_234","text":"import math\nfrom fractions import Fraction\nfrom django.contrib import admin\nfrom products.models import Product, Image\n\n\nclass ProductLabelInlineAdmin(admin.TabularInline):\n    \"\"\"Selection to select labels for a product.\"\"\"\n    model = Product.labels.through\n\nclass ImageInlineAdmin(admin.TabularInline):\n    \"\"\"Selection to select images for a product.\"\"\"\n    model = Image\n\n\nclass ProductAdmin(admin.ModelAdmin):\n    list_display = ('id','name','brand','active','stock')\n    fields = ('id','name','review_calculated','stock','price','active', 'category','brand','description','info','weight','contents', 'label_info')\n    readonly_fields = ('id','info','review_calculated','label_info')\n    list_filter = ('brand',)\n    list_editable = ('active','stock')\n    search_fields = ('name','id','brand__name')\n    inlines = (ProductLabelInlineAdmin, ImageInlineAdmin)\n\n    def has_delete_permission(self, request, obj=None):\n        return False\n\n    def info(self, obj):\n        return \"If the product is not cereal please leave weight & contents fields empty.\"\n\n    def label_info(self, obj):\n        return \"Each label can only be selected once.\"\n\n\nclass ProductDiscountAdmin(admin.ModelAdmin):\n    list_display = ('id', 'name', 'percentage_off', 'price', 'new_price')\n    list_display_links = None\n    fields = ['name', 'brand', 'description', 'contents', 'weight', 'price', 'category', 'active', 'stock',\n              'percentage_off', 'discounted_price']\n    readonly_fields = ('id',)\n    list_filter = ('brand',)\n    list_editable = ('percentage_off',)\n    search_fields = ('name', 'id', 'brand__name')\n\n    def has_delete_permission(self, request, obj=None):\n        return False\n\n    def new_price(self, obj):\n        \"\"\"Returns and sets the discounted price for a given product object.\"\"\"\n\n        # If percentage_off exceeds 100, reset the price\n        if obj.percentage_off > 100 or obj.percentage_off <= 0:\n            obj.percentage_off = 0\n            obj.discounted_price = None\n            obj.save()\n\n            return obj.price\n\n        # Calculate the discounted price\n        price = Fraction(obj.price)\n        percentage_off = Fraction(obj.percentage_off)\n        discount = (percentage_off \/ 100) * price\n        final_price = Fraction(price - discount)\n        new = float(Fraction(math.floor(final_price*100), 100))\n\n        # Save and set the discounted price\n        obj.discounted_price = new\n        obj.save()\n\n        return new\n\n    def has_add_permission(self, request):\n        return False\n\n\nclass ProductDiscount(Product):\n    \"\"\"Proxy model so we can use the Product model\n    on two different admin pages.\"\"\"\n    class Meta:\n        proxy = True\n\n\n# admin.site.register(Label, LabelAdmin)\nadmin.site.register(Product, ProductAdmin)\nadmin.site.register(ProductDiscount, ProductDiscountAdmin)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_235","text":"#! usr\/bin\/env python\nimport numpy as np\nimport seaborn as sns\nimport scipy as sp\nimport functools\nimport numpy as np\nfrom scipy.stats import multivariate_normal\nimport scipy.stats as stats\nimport time\nimport scipy as scipy\nimport sys\nimport pandas as pd\nfrom scipy.stats import norm\nfrom numpy import linalg as la\nimport pandas as pd\nfrom sklearn.ensemble import GradientBoostingRegressor\nfrom sklearn.model_selection import train_test_split\nimport itertools\n__author__ = '<NAME>'\n\n\nclass IBO(object):\n    \"\"\"\n    IBO: Intelligent Bayesian OPtimization\n    A class to perform Bayesian Optimization on a 1D or 2D domain.\n    Can either have an objective function to maximize or a true function\n    to maximize\"\"\"\n\n    def __init__(self, kernel = 'squared_kernel'):\n        \"\"\"Define the parameters for the bayesian optimization.\n\n        The train points should be x,y coordinate that you already know about your\n        function\"\"\"\n        if kernel == 'squared_kernel':\n            self.kernel = self.__squared_kernel__\n        elif kernel == 'matern':\n            self.kernel = self.__matern_kernel__\n\n    def fit(self, train_points_x, train_points_y,\n            test_domain, train_y_func, y_func_type = 'real',\n            samples = 10 , test_points_x = None, test_points_y = None,\n            model_train_points_x = None, model_train_points_y = None,\n            covariance_noise = 5e-5, n_posteriors = 30, kernel_params = None,\n            model_obj = GradientBoostingRegressor,\n            verbose = True):\n        \"\"\"Define the parameters for the GP.\n        PARAMS:\n        train_points_x, - x coordinates to train on\n        train_points_y,  -  resulting output from the function, either objective or\n        true function\n        test_domain - the domain to test\n        test_points_y - If using ab objective function, this is from the\n            train test split data\n        test_points_x = if using an objective function, this is from the\n            train test split\n        model - the model to fit for use with the objective function. Currently\n            works with Gradient Boosting\n        y_func_type - either the real function or the objective function.\n            The objective function implemented in negative MSE (since BO is\n            a maximization procedure)\n        verbose = Whether to print out the points Bayesian OPtimization is\n            picking\n        train_y_func - This can either be an objective function or a true function\n        kernel_params: dictionary of {'length':value} for squaredkernel\n        model_train_points: the training points for the objective function\n        \"\"\"\n\n        try:\n            type(train_points_x).__module__ == np.__name__\n            type(train_points_y).__module__ == np.__name__\n        except Exception as e:\n            print(e)\n            return ' You need to input numpy types'\n        # Store the training points\n        self.train_points_x = train_points_x\n        self.train_points_y = train_points_y\n        self.test_domain = test_domain\n\n        # setup the kernel parameters\n        if kernel_params != None:\n            self.squared_length = kernel_params['rbf_length']\n        else:\n            self.squared_length = None\n\n\n        # Y func can either be an objective function, or the true underlying func.\n        if y_func_type == 'real':\n            self.train_y_func = train_y_func\n        elif y_func_type == 'objective':\n            if model_obj == None:\n                return ' you need to pass in a model (GradientBoostingRegressor)'\n\n            # Only if using an objective function, from the 'test' split\n            self.test_points_x = test_points_x\n            self.test_points_y = test_points_y\n            self.model_train_points_x  = model_train_points_x\n            self.model_train_points_y = model_train_points_y\n            # model to train and fit\n            self.model = model_obj\n            self.train_y_func = self.hyperparam_choice_function\n\n\n\n        # store the testing parameters\n        self.covariance_noise = covariance_noise\n        self.n_posteriors = n_posteriors\n        self.samples = samples\n        self.verbose = verbose\n\n\n        if self.train_points_x.shape[1] ==1: # one dimension\n            self.dimensions ='one'\n        elif self.train_points_x.shape[1] ==2:\n            self.dimensions = 'two'\n        else:\n            print('Either you entered more than two dimensions, \\\n                  or not a numpy array.')\n            print(type(self.train_points_x))\n        # create the generator\n        self.bo_gen = self.__sample_from_function__(verbose=self.verbose)\n\n\n\n\n    def predict(self):\n        \"\"\"returns x_sampled_points, y_sampled_points, best_x, best_y\"\"\"\n\n        x_sampled_points, y_sampled_points, sampled_var, \\\n            best_x, best_y, improvements, domain, mus = next(self.bo_gen)\n\n        return x_sampled_points, y_sampled_points, best_x, best_y\n\n    def maximize(self, n_steps=10, verbose = None):\n        \"\"\"For the n_steps defined, find the best x and y coordinate\n        and return them.\n        Verbose controls whether to print out the points being sampled\"\"\"\n        verbose_ = self.verbose\n        self.samples = n_steps\n        bo_gen = self.__sample_from_function__(verbose = verbose_)\n        for _ in range(self.samples):\n            x_sampled_points, y_sampled_points, sampled_var, \\\n                best_x, best_y, improvements, domain, mus = next(self.bo_gen)\n\n        self.best_x = best_x\n        self.best_y = best_y\n        # return the best PARAMS\n        return best_x, best_y\n\n\n\n    def __test_gaussian_process__(self,  return_cov = False,\n                              return_sample = False):\n        \"\"\"Test one new point in the Gaussian process or an array of points\n        Returns the mu, variance, as well as the posterior vector.\n        Improvements is the expected improvement for each potential test point.\n        Domain, is the domain over which you are searching.\n\n        Return cov = True will return the full covariance matrix.\n\n        If return_sample= True\n        returns samples ( a vector) from the\n        informed posterior and the uninformed prior distribution\n\n        Covariance diagonal noise is used to help enforce positive definite matrices\n\n        \"\"\"\n\n        # Update the covaraince matrices\n        self.covariance_train_train = self.kernel(self.train_points_x,\n                                self.train_points_x, train=True)\n        self.covariance_test_train  = self.kernel(self.test_domain,\n                                                  self.train_points_x)\n        self.covariance_test_test  = self.kernel(self.test_domain,\n                                                 self.test_domain)\n\n\n        # Use cholskey decomposition to increase speed for calculating mean\n        try :# First try,\n            L_test_test = np.linalg.cholesky(self.covariance_test_test + \\\n                    self.covariance_noise * np.eye(len(self.covariance_test_test)))\n            L_train_train = np.linalg.cholesky(self.covariance_train_train + \\\n                    self.covariance_noise * np.eye(len(self.covariance_train_train)))\n            Lk = np.linalg.solve(L_train_train, self.covariance_test_train.T)\n            mus = np.dot(Lk.T, np.linalg.solve(L_train_train,\n                                              self.train_points_y)).reshape(\n                                    (len(self.test_domain),))\n            # Compute the standard deviation so we can plot it\n            s2 = np.diag(self.covariance_test_test) - np.sum(Lk**2, axis=0)\n            stdv = np.sqrt(abs(s2))\n\n        except Exception as e:\n            print(e)#LinAlgError: # In case the covariance matrix is not positive definite\n            # Find the near positive definite matrix to decompose\n            decompose_train_train = self.nearestPD(\n                self.covariance_train_train + self.covariance_noise * np.eye(\n                    len(self.train_points_x)))\n            decompose_test_test = self.nearestPD(\n                self.covariance_test_test + self.covariance_noise * np.eye(\n                    len(self.test_domain)))\n\n            # cholskey decomposition on the nearest PD matrix\n            L_train_train = np.linalg.cholesky(decompose_train_train)\n            L_test_test = np.linalg.cholesky(decompose_test_test)\n            Lk = np.linalg.solve(L_train_train, self.covariance_test_train.T)\n            mus = np.dot(Lk.T, np.linalg.solve(L_train_train,\n                                self.train_points_y)).reshape((len(self.test_domain)),)\n            # Compute the standard deviation so we can plot it\n            s2 = np.diag(self.covariance_test_test) - np.sum(Lk**2, axis=0)\n            stdv = np.sqrt(abs(s2))\n\n    #         ##### FULL INVERSION ####\n    #         mus = covariance_test_train  @ np.linalg.pinv(covariance_train_train) @ train_y_numbers\n    #         s2 = covariance_test_test - covariance_test_train @ np.linalg.pinv(covariance_train_train ) \\\n    #                      @ covariance_test_train.T\n\n        def sample_from_posterior(n_priors=3):\n            \"\"\"Draw samples from the prior distribution of the GP.\n            len(test_x) is the number of samplese to draw.\n            Resource: http:\/\/katbailey.github.io\/post\/gaussian-processes-for-dummies\/.\n\n            N-Posteriors \/ N-Priors tells the number of functions to samples from the dsitribution\"\"\"\n\n\n            try: # try inside sample from posterior function\n                L = np.linalg.cholesky(self.covariance_test_test +\n                    self.covariance_noise * np.eye(\n                        len(self.test_domain))- np.dot(Lk.T, Lk))\n            except Exception as e:\n                print(e)\n                # Find the neareset Positive Definite Matrix\n                near_decompose = self.nearestPD(self.covariance_test_test +\n                    self.covariance_noise * np.eye(\n                        len(self.test_domain)) - np.dot(Lk.T, Lk))\n                L = np.linalg.cholesky(near_decompose.astype(float) )\n                # within posterior\n            # sample from the posterior\n            f_post = mus.reshape(-1,1) + np.dot(L, np.random.normal(\n                size=(len(self.test_domain), self.n_posteriors)))\n\n            # Sample X sets of standard normals for our test points,\n            # multiply them by the square root of the covariance matrix\n            f_prior_uninformed = np.dot(L_test_test,\n                    np.random.normal(size=(len(self.test_domain), n_priors)))\n            # For the posterior, the columns are the vector for that function\n            return (f_prior_uninformed, f_post)\n\n        if return_cov == True:\n            return y_pred_mean.ravel(), var_y_pred_diag.ravel(), var_y_pred\n\n        if return_sample == True:\n            f_prior, f_post = sample_from_posterior()\n            return mus.ravel(), s2.ravel(), f_prior, f_post\n        else:\n            return mus.ravel(), s2.ravel()\n\n\n    def __sample_from_function__(self, verbose=None):\n        \"\"\"Sample N times from the unknown function and for each time find the\n        point that will have the highest expected improvement (find the maxima of the function).\n        Verbose signifies if the function should print out the points where it is sampling\n\n        Returns a generator of x_sampled_points, y_sampled_points, vars_, best_x, best_y, \\\n                    list_of_expected_improvements, testing_domain, mus\n              for improvements. Mus and Vars are the mean and var for each sampled point\n               in the gaussian process.\n\n        Starts off the search for expected improvement with a coarse search and then hones in on\n        the domain the the highest expected improvement.\n\n        Note - the y-function can EITHER by the actual y-function (for evaluation\n        purposes, or an objective function\n        (i.e. - RMSE))\"\"\"\n        verbose = self.verbose\n\n\n        # for plotting the points sampled\n        x_sampled_points = []\n        y_sampled_points = []\n        best_x = self.train_points_x[np.argmax(self.train_points_y ),:]\n        best_y =self.train_points_y [np.argmax(self.train_points_y ),:]\n\n\n\n        for i in range(self.samples):\n            if i == 0:\n                if self.train_points_x .shape[1]==1: ## one dimensional case\n                    testing_domain = np.array([self.test_domain]).reshape(-1,1)\n                else:\n                    testing_domain = self.test_domain\n\n                # find the next x-point to sample\n                mus, vars_, prior, post = self.__test_gaussian_process__(\n                    return_sample = True)\n\n\n                sigmas_post = np.var(post,axis=1)\n                mus_post = np.mean(post,axis=1)\n                # get the expected values from the posterior distribution\n                list_of_expected_improvements = self.expected_improvement(\n                    mus_post, sigmas_post ,best_y)\n\n                max_improv_x_idx = np.argmax(np.array(\n                    list_of_expected_improvements))\n                #print(max_improv_x_idx,'max_improv_x_idx')\n                max_improv_x = testing_domain[max_improv_x_idx]\n                # don't resample the same point\n                c = 1\n                while max_improv_x in x_sampled_points:\n                    if c == 1:\n                        if self.train_points_x .shape[1]==1:\n                            sorted_points_idx = np.argsort(list(np.array(\n                                list_of_expected_improvements)))\n                        else:\n                            sorted_points_idx = np.argsort(list(np.array(\n                                list_of_expected_improvements)),axis=0)\n                    c+=1\n                    max_improv_x_idx = int(sorted_points_idx[c])\n                    max_improv_x = testing_domain[max_improv_x_idx]\n                    # only wait until we've gon through half of the list\n                    if c > round(len(list_of_expected_improvements)\/2):\n                        max_improv_x_idx = int(\n                            np.argmax(list_of_expected_improvements))\n                        max_improv_x = testing_domain[max_improv_x_idx]\n                        break\n                if self.train_points_x.shape[1]==1:\n                    max_improv_y = self.train_y_func(max_improv_x)\n                else: # Two D\n                    try: # see if we are passing in the actual function\n                        max_improv_y = self.train_y_func(\n                            max_improv_x[0], max_improv_x[1])\n                    except: # we are passing the objective function in\n                        max_improv_y = self.train_y_func(\n                            max_improv_x[0], dimensions = 'two',\n                            hyperparameter_value_two = max_improv_x[1])\n                if max_improv_y > best_y: ## use to find out where to search next\n                    best_y = max_improv_y\n                    best_x = max_improv_x\n                if verbose:\n                    print(f\"Bayesian Optimization just sampled point = {best_x}\")\n                    print(f\"Best x (Bayesian Optimization) = {best_x},\\\n                         Best y = {best_y}\")\n                    # append the point to sample\n                    x_sampled_points.append(max_improv_x)\n                    y_sampled_points.append(max_improv_y)\n                    # append our new the newly sampled point to the training data\n                    self.train_points_x = np.vstack((self.train_points_x,\n                                                     max_improv_x))\n                    self.train_points_y = np.vstack((self.train_points_y,\n                                                     max_improv_y))\n\n                    yield x_sampled_points, y_sampled_points, vars_, best_x, best_y, \\\n                        list_of_expected_improvements, testing_domain, mus\n\n                else:\n                    # append the point to sample\n                    x_sampled_points.append(max_improv_x)\n                    y_sampled_points.append(max_improv_y)\n\n                    # append our new the newly sampled point to the training data\n                    self.train_points_x = np.vstack((self.train_points_x, max_improv_x))\n                    self.train_points_y = np.vstack((self.train_points_y, max_improv_y))\n\n                    yield x_sampled_points, y_sampled_points, vars_, best_x, best_y, \\\n                        list_of_expected_improvements, testing_domain, mus\n\n\n            else:\n\n                if self.train_points_x.shape[1]==1:\n                    testing_domain = np.array([testing_domain]).reshape(-1,1)\n                else:\n                    testing_domain = self.test_domain\n\n                mus, vars_, prior, post = self.__test_gaussian_process__(\n                        return_sample = True)\n\n                igmas_post  = np.var(post,axis=1)\n                mus_post = np.mean(post,axis=1)\n                # get the expected values from the posterior distribution\n                list_of_expected_improvements = self.expected_improvement(\n                    mus_post, sigmas_post ,best_y)\n                max_improv_x_idx = np.argmax(list_of_expected_improvements)\n                max_improv_x = testing_domain[max_improv_x_idx]\n                # don't resample the same point\n                c = 1\n                while max_improv_x in x_sampled_points:\n                    if c == 1:\n                        if self.train_points_x .shape[1]==1:\n                            sorted_points_idx = np.argsort(list(np.array(\n                                list_of_expected_improvements)))\n                        else:\n                            sorted_points_idx = np.argsort(list(np.array(\n                                list_of_expected_improvements)),axis=0)\n                    c+=1\n                    max_improv_x_idx = int(sorted_points_idx[c])\n                    max_improv_x = testing_domain[max_improv_x_idx]\n                    # only wait until we've gon through half of the list\n                    if c > round(len(list_of_expected_improvements)\/2):\n                        max_improv_x_idx = int(\n                            np.argmax(list_of_expected_improvements))\n                        max_improv_x = testing_domain[max_improv_x_idx]\n                        break\n                if self.train_points_x .shape[1]==1:\n                    max_improv_y = self.train_y_func(max_improv_x)\n                else: # Two D\n                    try: # see if we are passing in the actual function\n                        max_improv_y = self.train_y_func(\n                            max_improv_x[0], max_improv_x[1])\n\n                    except: # we are passing the objective function in\n                        max_improv_y = self.train_y_func(\n                            max_improv_x[0], dimensions = 'two',\n                            hyperparameter_value_two = max_improv_x[1])\n\n                if max_improv_y > best_y: ## use to find out where to search next\n                    best_y = max_improv_y\n                    best_x = max_improv_x\n                if verbose:\n                    print(f\"Bayesian Optimization just sampled point = {max_improv_x}\")\n                    print(f\"Best x (Bayesian Optimization) = {best_x}, Best y = {best_y}\")\n                    # append the point to sample\n                    x_sampled_points.append(max_improv_x)\n                    y_sampled_points.append(max_improv_y)\n\n\n                    # append our new the newly sampled point to the training data\n                    self.train_points_x = np.vstack((self.train_points_x, max_improv_x))\n                    self.train_points_y = np.vstack((self.train_points_y, max_improv_y))\n\n                    yield x_sampled_points, y_sampled_points, vars_, best_x, best_y, \\\n                        list_of_expected_improvements, testing_domain, mus\n\n                else:\n                    # append the point to sample\n                    x_sampled_points.append(max_improv_x)\n                    y_sampled_points.append(max_improv_y)\n\n                    # append our new the newly sampled point to the training data\n                    self.train_points_x = np.vstack((self.train_points_x, max_improv_x))\n                    self.train_points_y = np.vstack((self.train_points_y, max_improv_y))\n\n                    yield x_sampled_points, y_sampled_points, vars_, best_x, best_y, \\\n                        list_of_expected_improvements, testing_domain, mus\n\n\n\n\n    def hyperparam_choice_function(self, hyperparameter_value,\n                               dimensions = 'one', hyperparameter_value_two = None):\n        \"\"\"Returns the negative MSE of the input hyperparameter for the given\n         hyperparameter.\n        Used with GradientBoostingRegressor estimator currently\n        If dimensions = one, then search n_estimators. if dimension equal\n        two then search over n_estimators and max_depth\"\"\"\n        #definethe model\n        model = self.model\n        # define the training points\n        train_points_x = self.model_train_points_x\n        train_points_y = self.model_train_points_y\n\n        if self.dimensions == 'one':\n            try:\n                m = model(n_estimators= int(hyperparameter_value))\n            except:\n                 m = model(n_estimators= hyperparameter_value)\n            m.fit(train_points_x, train_points_y)\n            pred = m.predict(self.test_points_x )\n            n_mse = self.root_mean_squared_error(self.test_points_y , pred)\n            return n_mse\n        elif self.dimensions =='two':\n            try:\n                m = model(n_estimators = int(hyperparameter_value),\n                          max_depth = int(hyperparameter_value_two))\n            except:\n                m = model(n_estimators = hyperparameter_value,\n                          max_depth = hyperparameter_value_two)\n            m.fit(train_points_x, train_points_y)\n            pred = m.predict(self.test_points_x)\n            n_mse = self.root_mean_squared_error(self.test_points_y , pred)\n            return n_mse\n        else:\n            return ' We do not support this number of dimensions yet'\n\n\n\n    def root_mean_squared_error(self, actual, predicted, negative = True):\n        \"\"\"MSE of actual and predicted value.\n        Negative turn the MSE negative to allow for\n        maximization instead of minimization\"\"\"\n        if negative == True:\n            return - np.sqrt(sum((actual.reshape(-1,1) - predicted.reshape(-1,1)**2))\n                                 \/len(actual))\n        else:\n            return np.sqrt(sum((actual.reshape(-1,1) - predicted.reshape(-1,1)**2))\n                                 \/len(actual))\n\n    def expected_improvement(self, mean_x, sigma_squared_x,\n                             y_val_for_best_hyperparameters, normal_dist=None,\n                              point_est = False):\n        \"\"\"Finds the expected improvement of a point give the current best point.\n        If point_est = False, then computes the expected value on a vector\n        from the posterior distribution.\n        \"\"\"\n\n        with np.errstate(divide='ignore'): # in case sigma equals zero\n            # Expected val for one point\n            if point_est ==True:\n                sigma_x = np.sqrt(sigma_squared_x) # get the standard deviation from the variance\n\n                Z = (mean_x - y_val_for_best_hyperparameters) \/ sigma_x\n\n                if round(sigma_x,8) == 0:\n                    return 0\n                else:\n                    return (mean_x -\n                            y_val_for_best_hyperparameters)*normal_dist.cdf(Z)+\\\n                            sigma_x*normal_dist.pdf(Z)\n\n            else:\n                # Sample from the posterior functions\n                for _ in range(len(mean_x)):\n                    list_of_improvements = []\n                    m_s = []\n                    for m, z, s in zip(mean_x, ((mean_x -y_val_for_best_hyperparameters)\\\n                                         \/ np.std(sigma_squared_x)),np.sqrt(sigma_squared_x) ):\n\n                        list_of_improvements.append(((m-y_val_for_best_hyperparameters)*\\\n                                                     norm().cdf(z)\\\n                                                     +s * norm().pdf(z)))\n                        m_s.append(m)\n\n                    return list_of_improvements\n\n\n\n\n\n    def nearestPD(self, A):\n        \"\"\"\n        #https:\/\/stackoverflow.com\/questions\/43238173\/python-convert-matrix-to-positive-semi-definite\/43244194#43244194\n\n        Find the nearest positive-definite matrix to input\n\n        A Python\/Numpy port of <NAME>'s `nearestSPD` MATLAB code [1], which\n        credits [2].\n\n        [1] https:\/\/www.mathworks.com\/matlabcentral\/fileexchange\/42885-nearestspd\n\n        [2] <NAME>, \"Computing a nearest symmetric positive semidefinite\n        matrix\" (1988): https:\/\/doi.org\/10.1016\/0024-3795(88)90223-6\n        \"\"\"\n        def isPD(B):\n            \"\"\"Returns true when input is positive-definite, via Cholesky\"\"\"\n            try:\n                _ = la.cholesky(B)\n                return True\n            except la.LinAlgError:\n                return False\n\n\n\n        B = (A + A.T) \/ 2\n        _, s, V = la.svd(B)\n\n        H = np.dot(V.T, np.dot(np.diag(s), V))\n\n        A2 = (B + H) \/ 2\n\n        A3 = (A2 + A2.T) \/ 2\n\n        if isPD(A3):\n            return A3\n\n        spacing = np.spacing(la.norm(A))\n        # The above is different from [1]. It appears that MATLAB's `chol` Cholesky\n        # decomposition will accept matrixes with exactly 0-eigenvalue, whereas\n        # Numpy's will not. So where [1] uses `eps(mineig)` (where `eps` is Matlab\n        # for `np.spacing`), we use the above definition. CAVEAT: our `spacing`\n        # will be much larger than [1]'s `eps(mineig)`, since `mineig` is usually on\n        # the order of 1e-16, and `eps(1e-16)` is on the order of 1e-34, whereas\n        # `spacing` will, for Gaussian random matrixes of small dimension, be on\n        # othe order of 1e-16. In practice, both ways converge, as the unit test\n        # below suggests.\n        I = np.eye(A.shape[0])\n        k = 1\n        while not self.isPD(A3):\n            mineig = np.min(np.real(la.eigvals(A3)))\n            A3 += I * (-mineig * k**2 + spacing)\n            k += 1\n\n        return A3\n\n\n\n    def __squared_kernel__(self, a, b, param=2.0, train=False,\n                            train_noise = 5e-3, vertical_scale=1.5):\n        \"\"\"Calculated the squared exponential kernel.\n        Adds a noise term for the covariance of the training data\n        Adjusting the param changes the difference where points will have a positive covariance\n        Returns a covaraince Matrix.\n        Vertical scale controls the vertical scale of the function\"\"\"\n        if self.squared_length != None:\n            vertical_scale = self.squared_length\n\n        if train == False:\n            # ensure a and b are numpy arrays\n            a = np.array(a)\n            b = np.array(b)\n            sqdist = np.sum(a**2,1).reshape(-1,1) + np.sum(b**2,1) - 2*np.dot(a, b.T)\n            return vertical_scale*np.exp(-.5 * (1\/param) * sqdist)\n\n        else:\n            # ensure a and b are numpy arrays\n            a = np.array(a)\n            b = np.array(b)\n            noisy_observations = train_noise*np.eye(len(a))\n            sqdist = np.sum(a**2,1).reshape(-1,1) + np.sum(b**2,1) - 2*np.dot(a, b.T)\n            return vertical_scale*np.exp(-.5 * (1\/param) * sqdist) + noisy_observations\n\n    def __matern_kernel__(self, a,b,C_smoothness=3\/2,train=False, train_noise = 5e-2):\n        \"\"\"The class of Matern kernels is a generalization of the RBF and the\n        absolute exponential kernel parameterized by an additional parameter\n        nu. The smaller nu, the less smooth the approximated function is.\n        For nu=inf, the kernel becomes equivalent to the RBF kernel and for nu=0.5\n        to the absolute exponential kernel. Important intermediate values are\n        nu=1.5 (once differentiable functions) and nu=2.5 (twice differentiable\n        functions).\n\n        c_smoother = inf = RBF\n\n        The train keyword is used to add noisy observations to the matrix\"\"\"\n        if C_smoothness not in [1\/2,3\/2]:\n            return \"You choose an incorrect hyparameter, please choose either 1\/2 or 3\/2\"\n        matrix_norm = np.array([np.linalg.norm(a[i] - b,axis=(1)) for i in range(len(a))])\n        if C_smoothness == 1\/2:\n            if train == True:\n                max(np.var(a),np.var(b)) * np.exp(-matrix_norm) + np.eye(len(matrix_norm))*train_noise\n            else:\n                return max(np.var(a),np.var(b)) * np.exp(-matrix_norm)\n        elif C_smoothness == 3\/2:\n            if train == True:\n                return max(np.var(a),np.var(b))* (1\n                    + np.sqrt(3)*matrix_norm)*np.exp(-np.sqrt(3)*matrix_norm) \\\n                    + np.eye(len(matrix_norm))*train_noise\n            else:\n                return max(np.var(a),np.var(b))* (1 +np.sqrt(3) *\n                                matrix_norm) * np.exp(-np.sqrt(3)*matrix_norm)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_236","text":"<gh_stars>1-10\n\"\"\"Copyright (c) 2021 <NAME>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\"\"\"\n\n\nfrom scipy import integrate\nimport numpy as np\n\n\nfrom percolate.framework import Port\nfrom percolate.framework import InPort\nfrom percolate.framework import OutPort\nfrom percolate.framework import StreamOutput\nfrom percolate.framework import TextOutput\nfrom percolate.framework import StreamInput\nfrom percolate.framework import ArrayOutput\nfrom percolate.framework import FilePathInput\nfrom percolate.framework import DirPathInput\nfrom percolate.framework import MuxInput\nfrom percolate.framework import MuxOutput\nfrom percolate.framework import Param_input\nfrom percolate.framework import func_Output\nfrom percolate.framework import int_input\nfrom percolate.framework import bool_input\nfrom percolate.framework import choice_input\nfrom percolate.framework import Function\n\n\n# toolKit\nfrom percolate.toolkit.step2 import step2\nfrom percolate.toolkit.single_step import single_step\nfrom percolate.toolkit.make_zero_array import make_zero_array\nfrom percolate.toolkit.single_step_xanes import single_step_xanes\nfrom percolate.toolkit.single_step_xanes import pre_edge_fit\n\n\nclass args_step:\n    def __init__(self, parent):\n\n        self.apply_step = parent.apply_step.default\n        self.fit_function = parent.fit_function.default\n\n        self.pre_feature_min = parent.pre_feature_min.default\n        self.pre_feature_max = parent.pre_feature_max.default\n        self.post_feature_min = parent.post_feature_min.default\n        self.post_feature_max = parent.post_feature_max.default\n\n\nclass single_step_subtraction_xanes(Function):\n    \"\"\"TODO: Centre the step function on the peaks energy!\"\"\"\n\n    def __init__(self):\n\n        super().__init__(\"step_subtraction\")\n\n        # Input Ports\n        self.input_array = StreamInput(self, \"input_array\")\n\n        self.apply_step = choice_input(self, \"Apply\", \"off\", [\"off\", \"on\"])\n        self.fit_function = choice_input(\n            self, \"fit_function\", \"Voight\", [\"Voight\", \"Arctan\"]\n        )\n        self.pre_feature_min = int_input(\n            self, \"pre_feature_min\", self.input_array, None\n        )\n        self.pre_feature_max = int_input(\n            self, \"pre_feature_max\", self.input_array, None\n        )\n        self.post_feature_min = int_input(\n            self, \"post_feature_min\", self.input_array, None\n        )\n        self.post_feature_max = int_input(\n            self, \"post_feature_max\", self.input_array, None\n        )\n\n        # output ports\n        self.stepfunction = ArrayOutput(self, \"stepfunction\", self.read_stepfunction)\n        self.subtracted_step = ArrayOutput(\n            self, \"subtracted_step\", self.read_subtracted_step\n        )\n\n\n\n\n    # evaluate method\n    def evaluate(self):\n\n        local_arguments = args_step(self)\n\n        x = self.input_array.read()[\"data\"][0]\n        y = self.input_array.read()[\"data\"][1]\n        pre_feature_min = local_arguments.pre_feature_min\n        pre_feature_max = local_arguments.pre_feature_max\n        post_feature_min = local_arguments.post_feature_min\n        post_feature_max = local_arguments.post_feature_max\n\n        if local_arguments.apply_step == \"off\":\n\n            x = x\n            background = make_zero_array(x)\n            y = y - background\n\n        else:\n            x, y, background = pre_edge_fit(\n                x,\n                y,\n                pre_feature_min,\n                pre_feature_max,\n                post_feature_min,\n                post_feature_max,\n            )\n\n        self.x = x\n        self.y = y\n        self.background = background\n\n        self.lines = [\n            pre_feature_min,\n            pre_feature_max,\n            post_feature_min,\n            post_feature_max,\n        ]\n\n    def read_stepfunction(self):\n        return {\n            \"data\": [self.x, self.background, self.lines],\n            \"label\": self.input_array.read()[\"label\"],\n        }\n        # return self.stepfunction_a\n\n    def read_subtracted_step(self):\n        return {\n            \"data\": [self.x, self.y, self.lines],\n            \"label\": self.input_array.read()[\"label\"],\n        }\n        # return self.post_step_p\n\n    def calculate_fit(self, x, y, argument):\n        pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_237","text":"<reponame>Aaron5210\/yolo_seq_nms<filename>yolo_seqnms.py\n# -*- coding: utf-8 -*-\nimport numpy as np\nimport cv2\nimport time\nimport copy\n#import cPickle as pickle\nimport os, sys\nfrom matplotlib import pyplot as plt\nfrom PIL import Image\nimport scipy.misc\nimport yolo_detection\nimport visualization_utils as vis_util\nimport label_map_util\nfrom seq_nms import *\n\ndef load_image_into_numpy_array(image):\n  (im_width, im_height) = image.size\n  return np.array(image.getdata()).reshape(\n      (im_height, im_width, 3)).astype(np.uint8)\n\ndef get_labeled_image(image_path, path_to_labels, num_classes, boxes, classes, scores):\n    label_map = label_map_util.load_labelmap(path_to_labels)\n    categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=num_classes,\n                                                                use_display_name=True)\n    category_index = label_map_util.create_category_index(categories)\n    image = Image.open(image_path)\n    image_np = load_image_into_numpy_array(image)\n    image_process = vis_util.visualize_boxes_and_labels_on_image_array(\n        image_np,\n        boxes,\n        classes,\n        scores,\n        category_index)\n    return image_process\n\nif __name__ == \"__main__\":\n    # load image\n    load_begin=time.time()\n    pkllistfile=open(os.path.join('video', 'pkllist.txt'))\n    pkllist=pkllistfile.readlines()\n    pkllistfile.close()\n    pkllist=[pkl.strip() for pkl in pkllist]\n    load_end=time.time()\n    print('load: {:.4f}s'.format(load_end - load_begin))\n\n    # detection\n    detect_begin=time.time()\n    if len(sys.argv) > 1 and sys.argv[1]=='tiny':\n        res = yolo_detection.detect_imgs(pkllist, cfg=\"cfg\/tiny-yolo.cfg\", weights=\"tiny-yolo.weights\", nms=0, thresh=0.25)\n    else:\n        res = yolo_detection.detect_imgs(pkllist, nms=0, thresh=0.25)\n    detect_end=time.time()\n    print('total detect: {:.4f}s'.format(detect_end - detect_begin))\n    print('average detect: {:.4f}s'.format((detect_end - detect_begin)\/len(pkllist)))\n\n    # nms\n    nms_begin=time.time()\n    if len(sys.argv) > 1 and sys.argv[1]=='only_person':\n        boxes, classes, scores = dsnms(res, only_person=True)\n    else:\n        boxes, classes, scores = dsnms(res)\n    nms_end=time.time()\n    print('total nms: {:.4f}s'.format(nms_end - nms_begin))\n\n    # save&visualization\n    save_begin=time.time()\n    PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')\n    NUM_CLASSES = 80\n    if not os.path.exists('video\/output'):\n        os.makedirs('video\/output')\n    for i, image_path in enumerate(pkllist):\n        image_process = get_labeled_image(image_path, PATH_TO_LABELS, NUM_CLASSES, np.array(boxes[i]), np.array(classes[i]), np.array(scores[i]))\n        #plt.imshow(image_process)\n        #plt.show()\n        scipy.misc.imsave('video\/output\/frame{}.jpg'.format(i), image_process)\n        if i%100==0:\n            print('finish writing image{}'.format(i))\n    save_end=time.time()\n    print('total writing images: {:.4f}s'.format(save_end - save_begin))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_238","text":"<filename>cnc\/motor_hub\/motor_hub\/set_screw_drill\/params.py\nimport scipy\n\n# Basic layout parameters\nparams = {}\nparams['numParts'] = 5\nparams['partSpacing'] = 2.0 \nlayoutLen = (params['numParts']-1)*params['partSpacing']\nxPosArray = scipy.linspace(-0.5*layoutLen, 0.5*layoutLen,params['numParts'])\nyPosArray = scipy.zeros(xPosArray.size)\nparams['xPosList'] = list(xPosArray)\nparams['yPosList'] = list(yPosArray)\n\nparams['xPosRelDrill'] = 0.0\nparams['yPosRelDrill'] = -0.1\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_239","text":"# Created by <NAME>\n\nfrom scipy.optimize import fmin_cobyla as max\n\ndef farm_optimize(acres, hours, p1, p2, h1, h2): \n    #objective\n    def objective(X, p1, p2):\n        x,y = X\n        return -(p1*x + p2*y)\n    #constraint 1\n    def c1(X, acres, hours, h1, h2):\n        x,y = X\n        return hours - h1*x - h2*y\n    #constraint 2\n    def c2(X, acres, hours, h1, h2):\n        x,y = X\n        return acres - x - y\n    #constraint 3\n    def c3(X, acres, hours, h1, h2):\n        return X[0]\n    #constraint 4\n    def c4(X, acres, hours, h1, h2):\n        return X[1]\n    \n    X = max(objective, x0=[acres, 0], cons=[c1,c2,c3,c4],\n            args=(p1,p2), consargs=(acres, hours, h1, h2))\n    \n    print ('With input:')\n    print (acres,'total acres',hours,'total labor-hours')\n    print ('${}'.format(p1),'corn profit-per-acre',\n           '${}'.format(p2),'oat profit-per-acre')\n    print (h1,'corn labor-hours',h2,'oat labor-hours')\n    print (' We should plant {0:.1f} acres of corn.'.format(X[0]))\n    print (' We should plant {0:.1f} acres of oats.'.format(X[1]))\n    print (' The maximum profit we can earn is ${0:.2f}.'\n           .format(-objective(X, p1, p2)))\n    print ()\n\nfarm_optimize(240, 320, 40, 30, 2, 1)\nfarm_optimize(300, 380, 70, 45, 3, 1)\nfarm_optimize(180, 420, 65, 55, 3, 1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_225","text":"import itertools\nimport logging\nimport multiprocessing\nimport os\nimport typing\n\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\n\nfrom pyextremes.models.model_base import AbstractModelBaseClass\n\nlogger = logging.getLogger(__name__)\n\n\ndef get_fit_parameters(params) -> typing.List[tuple]:\n    n, fit_function, extremes, fixed_parameters, seed = params\n    size = len(extremes)\n    rng_generator = np.random.default_rng(seed=seed)\n    sampler = rng_generator.choice\n    return [\n        fit_function(\n            data=sampler(a=extremes, size=size, replace=True),\n            **fixed_parameters,\n        )\n        for _ in range(n)\n    ]\n\n\nclass MLE(AbstractModelBaseClass):\n    def __init__(\n        self,\n        extremes: pd.Series,\n        distribution: typing.Union[str, scipy.stats.rv_continuous],\n        distribution_kwargs: typing.Optional[dict] = None,\n    ) -> None:\n        \"\"\"\n        Maximum Likelihood Estimate (MLE) model.\n\n        Built around the scipy.stats.rv_continuous.fit method.\n\n        \"\"\"\n        super().__init__(\n            extremes=extremes,\n            distribution=distribution,\n            distribution_kwargs=distribution_kwargs,\n        )\n\n        # Initialize 'fit_parameter_cache' and 'seed_cache'\n        self.fit_parameter_cache: typing.List[tuple] = []\n        self.seed_cache: typing.Set[int] = set()\n\n    @property\n    def name(self) -> str:\n        return \"MLE\"\n\n    def fit(self, **kwargs) -> None:\n        if len(kwargs) != 0:\n            raise TypeError(\n                f\"unrecognized arguments passed in: {', '.join(kwargs.keys())}\"\n            )\n        self._fit_parameters = self.distribution.mle_parameters\n        logger.debug(\n            f\"fit {self.distribution.name} distribution \"\n            f\"with parameters {self.distribution.mle_parameters}\"\n        )\n\n    def get_return_value(\n        self, exceedance_probability, alpha: typing.Optional[float] = None, **kwargs\n    ) -> tuple:\n        \"\"\"\n        Calculate return value and confidence interval bounds.\n\n        Parameters\n        ----------\n        exceedance_probability : array-like\n            Exceedance probability or 1D array of exceedance probabilities.\n            Each exceedance probability must be in the [0, 1) range.\n        alpha : float, optional\n            Width of confidence interval (0, 1).\n            If None (default), return None\n            for upper and lower confidence interval bounds.\n        kwargs\n            n_samples : int, optional\n                Number of bootstrap samples used to estimate\n                confidence interval bounds (default=100).\n\n        Returns\n        -------\n        return_value : array-like\n            Return values.\n        ci_lower : array-like\n            Lower confidence interval bounds.\n        ci_upper : array-like\n            Upper confidence interval bounds.\n\n        \"\"\"\n        # Parse 'kwargs'\n        n_samples = kwargs.pop(\"n_samples\", 100)\n        if not n_samples > 0:\n            raise ValueError(\n                f\"invalid value in {n_samples} for the 'n_samples' \"\n                f\"argument, must be positive number\"\n            )\n        if len(kwargs) != 0:\n            raise TypeError(\n                f\"unrecognized arguments passed in: {', '.join(kwargs.keys())}\"\n            )\n\n        # Convert 'exceedance_probability' to ndarray\n        exceedance_probability = np.asarray(\n            a=exceedance_probability, dtype=np.float64\n        ).copy()\n        if exceedance_probability.ndim == 0:\n            exceedance_probability = exceedance_probability[np.newaxis]\n        if exceedance_probability.ndim != 1:\n            raise ValueError(\n                f\"invalid shape in {exceedance_probability.shape} \"\n                f\"for the 'exceedance_probability' argument, must be 1D array\"\n            )\n\n        # If cache doesn't have enough values, calculate new fit parameters\n        if alpha is not None:\n            n_extra_fit_parameters = n_samples - len(self.fit_parameter_cache)\n            if n_extra_fit_parameters > 0:\n                self._extend_fit_parameter_cache(n=n_extra_fit_parameters)\n\n        # Calculate return values\n        return_value = np.full(\n            shape=exceedance_probability.shape, fill_value=np.nan, dtype=np.float64\n        )\n        ci_lower = return_value.copy()\n        ci_upper = return_value.copy()\n        for i, ep in enumerate(exceedance_probability):\n            key: typing.Tuple[float, typing.Optional[float], int] = (\n                ep,\n                alpha,\n                n_samples,\n            )\n            try:\n                # Try to fetch pre-calculated values from cache\n                rv, cil, ciu = self.return_value_cache[key]\n                logger.debug(\n                    f\"fetched return value for {key} from cache as {(rv, cil, ciu)}\"\n                )\n            except KeyError:\n                # Value not in cache - calculate new return value\n                rv = self.distribution.distribution.isf(\n                    q=ep,\n                    **self.fit_parameters,\n                    **self.distribution._fixed_parameters,\n                )\n\n                # Calculate confidence intervals\n                if alpha is None:\n                    cil = None\n                    ciu = None\n                else:\n                    # Calculate confidence intervals\n                    rv_sample = self.distribution.distribution.isf(\n                        ep, *np.transpose(self.fit_parameter_cache[:n_samples])\n                    )\n                    cil, ciu = np.quantile(\n                        a=rv_sample, q=[(1 - alpha) \/ 2, (1 + alpha) \/ 2]\n                    )\n\n                # Add calculated return value and intervals to cache\n                self.return_value_cache[key] = (rv, cil, ciu)\n                logger.debug(f\"calculated return value for {key} as {(rv, cil, ciu)}\")\n\n            return_value[i] = rv\n            ci_lower[i] = cil\n            ci_upper[i] = ciu\n\n        # Return results\n        if len(return_value) == 1:\n            return return_value[0], ci_lower[0], ci_upper[0]\n        else:\n            return return_value, ci_lower, ci_upper\n\n    def _extend_fit_parameter_cache(self, n: int) -> None:\n        # Prepare local variables used by fit parameter calculator\n        extremes = self.extremes.values\n        fit_function = self.distribution.distribution.fit\n        fixed_parameters = self.distribution.fixed_parameters\n\n        min_samples_per_core = 50\n        if n <= min_samples_per_core:\n            # Calculate without multiprocessing\n            logger.debug(\"getting random seed value for fit parameter sampler\")\n            seed = None\n            while seed is None:\n                _seed = np.random.randint(low=0, high=1e6, size=None)\n                if _seed not in self.seed_cache:\n                    seed = _seed\n                    self.seed_cache.add(_seed)\n\n            logger.debug(f\"calculating {n} additional fit parameters using single core\")\n            new_fit_parameters = get_fit_parameters(\n                params=(\n                    n,\n                    fit_function,\n                    extremes,\n                    fixed_parameters,\n                    seed,\n                )\n            )\n        else:\n            # Find number of cores\n            n_cores = min(\n                os.cpu_count() or 2,\n                int(np.ceil(n \/ min_samples_per_core)),\n            )\n\n            # Calculate number of samples per core\n            min_samples_per_core = int(n \/ n_cores)\n            core_samples = [min_samples_per_core for _ in range(n_cores)]\n\n            # Distribute remaining samples evenly across cores\n            for i in range(n - sum(core_samples)):\n                core_samples[i] += 1\n\n            # Get unique random seed for each core and add it to `self.seed_cache`\n            logger.debug(\"getting random seed values for each core\")\n            seeds: typing.List[int] = []\n            while len(seeds) < n_cores:\n                seed = np.random.randint(low=0, high=1e6, size=None)\n                if seed not in self.seed_cache:\n                    seeds.append(seed)\n                    self.seed_cache.add(seed)\n\n            # Calculate new fit parameters using processor pool\n            logger.debug(\n                f\"calculating {n} additional fit parameters using {n_cores} cores \"\n                f\"having {core_samples} samples accordingly\"\n            )\n            with multiprocessing.Pool(processes=n_cores) as pool:\n                new_fit_parameters = list(\n                    itertools.chain(\n                        *pool.map(\n                            get_fit_parameters,\n                            zip(\n                                core_samples,\n                                [fit_function for _ in range(n_cores)],\n                                [extremes for _ in range(n_cores)],\n                                [fixed_parameters for _ in range(n_cores)],\n                                seeds,\n                            ),\n                        )\n                    )\n                )\n\n        # Extend fit parameter cache\n        logger.debug(f\"extending fit parameter cache with {n} new entries\")\n        self.fit_parameter_cache.extend(new_fit_parameters)\n        return None\n\n    def __repr__(self) -> str:\n        free_parameters = \", \".join(\n            [\n                f\"{parameter}={self.fit_parameters[parameter]:.3f}\"\n                for parameter in self.distribution.free_parameters\n            ]\n        )\n\n        fixed_parameters = \", \".join(\n            [\n                f\"{key}={value:.3f}\"\n                for key, value in self.distribution.fixed_parameters.items()\n            ]\n        )\n        if fixed_parameters == \"\":\n            fixed_parameters = \"all parameters are free\"\n\n        summary = [\n            \"MLE model\",\n            \"\",\n            f\"free parameters: {free_parameters}\",\n            f\"fixed parameters: {fixed_parameters}\",\n            f\"AIC: {self.AIC:.3f}\",\n            f\"loglikelihood: {self.loglikelihood:.3f}\",\n            f\"return value cache size: {len(self.return_value_cache):,d}\",\n            f\"fit parameter cache size: {len(self.fit_parameter_cache):,d}\",\n        ]\n\n        longest_row = max(map(len, summary))\n        summary[1] = \"-\" * longest_row\n        summary.append(summary[1])\n        summary[0] = \" \" * ((longest_row - len(summary[0])) \/\/ 2) + summary[0]\n        for i, row in enumerate(summary):\n            summary[i] += \" \" * (longest_row - len(row))\n\n        return \"\\n\".join(summary)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_112","text":"#!c:\\users\\hooma\\documents\\github\\spinesegmentation\\segmentation_test\\scripts\\python.exe\n\n\"\"\"\nCreates the superimposition image of two label images.\n\nCopyright (C) 2013 <NAME>\n\nThis program is free software: you can redistribute it and\/or modify\nit under the terms of the GNU General Public License as published by\nthe Free Software Foundation, either version 3 of the License, or\n(at your option) any later version.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\nGNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License\nalong with this program.  If not, see <http:\/\/www.gnu.org\/licenses\/>.\n\"\"\"\n\n# build-in modules\nfrom argparse import ArgumentError\nimport argparse\nimport logging\nimport os\n\n# third-party modules\nimport scipy\n\n# path changes\n\n# own modules\nfrom medpy.io import load, save\nfrom medpy.core import Logger\n\n# information\n__author__ = \"<NAME>\"\n__version__ = \"r0.2.1, 2011-01-04\"\n__email__ = \"<EMAIL>\"\n__status__ = \"Release\"\n__description__ = \"\"\"\n                  Takes two label images as input and creates their superimposition i.e.\n                  all the regions borders are preserved and the resulting image contains\n                  more or the same number of regions as the respective input images.\n                  \n                  The resulting image has the same name as the first input image, just\n                  with a '_superimp' suffix.\n                  \n                  Copyright (C) 2013 <NAME>\n                  This program comes with ABSOLUTELY NO WARRANTY; This is free software,\n                  and you are welcome to redistribute it under certain conditions; see\n                  the LICENSE file or <http:\/\/www.gnu.org\/licenses\/> for details.   \n                  \"\"\"\n\n# code\ndef main():\n    # parse cmd arguments\n    parser = getParser()\n    parser.parse_args()\n    args = getArguments(parser)\n    \n    # prepare logger\n    logger = Logger.getInstance()\n    if args.debug: logger.setLevel(logging.DEBUG)\n    elif args.verbose: logger.setLevel(logging.INFO)\n\n    # build output image name\n    image_superimposition_name = args.folder + '\/' + args.image1.split('\/')[-1][:-4] + '_superimp'\n    image_superimposition_name += args.image1.split('\/')[-1][-4:]\n        \n    # check if output image exists\n    if not args.force:\n        if os.path.exists(image_superimposition_name):\n            raise ArgumentError('The output image {} already exists. Please provide the -f\/force flag, if you wish to override it.'.format(image_superimposition_name))\n    \n    # load image1 using\n    logger.info('Loading image {}...'.format(args.image1))\n    image1_data, image1_header = load(args.image1)\n    \n    # load image2 using\n    logger.info('Loading image {}...'.format(args.image2))\n    image2_data, _ = load(args.image2)\n        \n    # check input images to be valid\n    logger.info('Checking input images for correctness...')\n    if image1_data.shape != image2_data.shape:\n        raise ArgumentError('The two input images shape do not match with 1:{} and 2:{}'.format(image1_data.shape, image2_data.shape))\n    int_types = (scipy.uint, scipy.uint0, scipy.uint8, scipy.uint16, scipy.uint32, scipy.uint64, scipy.uintc, scipy.uintp,\n                 scipy.int_, scipy.int0, scipy.int8, scipy.int16, scipy.int32, scipy.int64, scipy.intc, scipy.intp)\n    if image1_data.dtype not in int_types:\n        raise ArgumentError('Input image 1 is of type {}, an int type is required.'.format(image1_data.dtype))\n    if image2_data.dtype not in int_types:\n        raise ArgumentError('Input image 2 is of type {}, an int type is required.'.format(image2_data.dtype))\n    if 4294967295 < abs(image1_data.min()) + image1_data.max() + abs(image2_data.min()) + image2_data.max():\n        raise ArgumentError('The input images contain so many (or not consecutive) labels, that they will not fit in a uint32 range.')\n        \n    # create superimposition of the two label images\n    logger.info('Creating superimposition image...')\n    image_superimposition_data = scipy.zeros(image1_data.shape, dtype=scipy.uint32)\n    translation = {}\n    label_id_counter = 0\n    for x in range(image1_data.shape[0]):\n        for y in range(image1_data.shape[1]):\n            for z in range(image1_data.shape[2]):\n                label1 = image1_data[x,y,z]\n                label2 = image2_data[x,y,z]\n                if not (label1, label2) in translation:\n                    translation[(label1, label2)] = label_id_counter\n                    label_id_counter += 1\n                image_superimposition_data[x,y,z] = translation[(label1, label2)]\n    \n    # save resulting superimposition image\n    logger.info('Saving superimposition image as {} in the same format as input image...'.format(image_superimposition_name))\n    save(image_superimposition_data, args.output, image1_header, args.force)\n    \n    logger.info('Successfully terminated.')\n        \ndef getArguments(parser):\n    \"Provides additional validation of the arguments collected by argparse.\"\n    return parser.parse_args()\n\ndef getParser():\n    \"Creates and returns the argparse parser object.\"\n    parser = argparse.ArgumentParser(description=__description__)\n    parser.add_argument('image1', help='The first input label image.')\n    parser.add_argument('image2', help='The second input label image.')\n    parser.add_argument('output', help='The output image.')\n    parser.add_argument('-v', dest='verbose', action='store_true', help='Display more information.')\n    parser.add_argument('-d', dest='debug', action='store_true', help='Display debug information.')\n    parser.add_argument('-f', dest='force', action='store_true', help='Silently override existing output images.')\n    \n    return parser    \n    \nif __name__ == \"__main__\":\n    main()        \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_113","text":"<reponame>zig1000\/spacechem-level-generator\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\nimport base64\nimport collections\nimport copy\nimport fractions\nimport gzip\nimport io\nimport json\n\nimport elements_data\n\n# Element class is defined in elements_data.py to avoid circular dependencies\n\n'''Classes For more apropros errors'''\nclass FormulaValidityError(ValueError):\n    pass\nclass MoleculeValidityError(ValueError):\n    pass\n\nclass Formula(collections.Counter):\n    '''Represent a chemical formula, as a Counter of elements.'''\n    # Redefine Counter's built-in elements() method to return the list of unique ELements in the\n    # formula, and move its original functionality to 'atoms()'.\n    def elements(self):\n        '''Return a list of unique elements in this formula.'''\n        # Make sure not to include any 0-counts that Counter leaves hanging around\n        return [e for e in self.keys() if self[e] != 0]\n\n    def elements_collection(self):\n        '''Return a list containing each element as many times as its count.'''\n        return list(super().elements())\n\n    # Have to override Counter's add method or else adding two Formulas will make a Counter\n    def __add__(self, other):\n        result = Formula()\n        for k in self.keys():\n            result[k] += self[k]\n        for k in other.keys():\n            result[k] += other[k]\n        return result\n\n    def __mul__(self, other):\n        return Formula({i: other * self[i] for i in self.keys()})\n    __rmul__ = __mul__\n\n    def num_atoms(self):\n        return sum(self.values())\n\n    def least_common_formula(self):\n        '''Return a new formula which is this formula divided by the GCD of its element counts'''\n        gcd = 0\n        for v in self.values():\n            gcd = fractions.gcd(v, gcd)\n\n        new_formula = copy.copy(self)\n        if gcd > 1: # Make sure we don't divide by 0 in empty case\n            for e in new_formula.elements():\n                new_formula[e] = new_formula[e] \/\/ gcd\n        return new_formula\n\n    def get_json_str(self):\n        '''Return a string representing this formula using the Hill System (C, then H, then\n        alphabetized), in the game's accepted format. E.g. Glycine would be 'C~02H~05NO~02'.\n        '''\n        result = ''\n        # Sort Carbon and Hydrogen to the front and alphabetize the rest\n        elements = sorted(self.elements(),\n                          key=lambda e: '0' if e.symbol == 'C'\n                                        else '1' if e.symbol == 'H'\n                                        else e.symbol)\n        for e in elements:\n            result += e.symbol\n            if self[e] != 1:\n                result += '~' + str(self[e]).rjust(2, '0')\n        return result\n    __str__ = get_json_str # For debugging convenience\n\n    def is_valid(self, large_output=False):\n        '''Check if it's possible to form a molecule with this formula within an input\/output zone.\n        Empty formulas are considered invalid. Default 4x4 zone, optionally large (8x4) output zone.\n        '''\n        # Verify size constraints\n        if not 1 <= self.num_atoms() <= 16 + 16*large_output:\n            return False\n\n        # We'll calculate validity based on whether there are enough bonds in the atom list to form\n        # a minimally-connected molecule. To check this, consider a simple linearly connected\n        # molecule with 2 endpoints. An \"endpoint\" element has max bonds 1, while elements with 3 or\n        # 4+ max bonds each allow for 1 or 2 additional endpoints in the molecule, respectively.\n        # Elements of max bonds 2 do not affect the count and thus do not affect the validity of\n        # the formula, apart from the 16 or 32-atom limit of the zone.\n        #\n        # Though not formally proven, it appears that the maximum number of endpoints is in each\n        # case a constant equal to half the number of cells in the zone. By trial and error with the\n        # 4x4 zone it appears that this maximum can be reached with any composition of 3 vs 4 bond\n        # atoms, and a simplifying assumption is made that this holds for the 8x4 case.\n        # The cases for which an incorrect return value by this method could cause an exception\n        # would in any case be prohibitively rare and of little concern, and imo worth the tradeoff\n        # for O(k) runtime (where k is the # of unique elements in the formula).\n\n        # Due to the limited sizes of the zones, each max bound count element can only contribute\n        # extra connections so many times before it reaches its limit. For example, in a 4x4 zone,\n        # only two atoms with max bond count 4 will provide two extra endpoints each. Subsequent\n        # max bond count 4 atoms will only allow for 1 extra endpoint each due to space\n        # constraints. E.g. C3H8 is impossible to construct in a 4x4 zone.\n        #\n        if large_output:\n            extra_endpoints_dict = {3:14, 4:6}\n        else:\n            extra_endpoints_dict = {3:6, 4:2}\n\n        allowed_endpoint_count = 2 # H-H base case\n        for element in self.elements():\n            if element.max_bonds == 0:\n                # A noble gas is only valid as the only atom in a molecule\n                return self.num_atoms() == 1\n            elif element.max_bonds == 1:\n                allowed_endpoint_count -= self[element]\n            # Count one extra allowed endpoint per atom with bond count 3 or more (up to limit)\n            elif element.max_bonds >= 3:\n                # As long as our formula has no negatives this should be fine\n                extra_endpoints = min(self[element], extra_endpoints_dict[3])\n                allowed_endpoint_count += extra_endpoints\n                extra_endpoints_dict[3] -= extra_endpoints\n\n                # Count an additional extra endpoint per atom with bond count 4 or more (up to limit)\n                if element.max_bonds >= 4:\n                    extra_endpoints = min(self[element],\n                                          extra_endpoints_dict[3],\n                                          extra_endpoints_dict[4])\n                    allowed_endpoint_count += extra_endpoints\n                    extra_endpoints_dict[3] -= extra_endpoints\n                    extra_endpoints_dict[4] -= extra_endpoints\n\n        return allowed_endpoint_count >= 0\n\n    def fission_sources(self):\n        '''Return a dict of atomic masses and their counts for all elements that could have fission\n        performed on them to obtain part of this formula.\n        The heavy lifting of this method is tucked away at the bottom of this file in\n        splittable_sources since it's a monster of a function.\n        '''\n        output_masses = collections.Counter({e.atomic_num: count for e, count in self.items()\n                                             if count > 0})\n        return splittable_sources(output_masses)\n\n    def remove_fissile_element(self, element, count):\n        '''Used while converting an output formula to an input formula via inverse fission.\n        Given a fissile element and count, remove the target count of the element from\n        this formula, drilling down into its 'fission tree' as needed.\n        Raise FormulaValidityError if the element \/ its fission tree doesn't add up to the count.\n        '''\n        # Remove as much as we can of this element without fission\n        direct_removals = min(count, self[element])\n        count -= direct_removals\n        self[element] -= direct_removals\n        # Keep this object clean\n        if self[element] == 0:\n            del self[element]\n\n        if count != 0:\n            # If we hit the bottom of the fission tree and aren't done, raise an exception\n            if element.atomic_num == 1:\n                raise FormulaValidityError(f\"Couldn't remove {count} of {element} from formula\")\n\n            try:\n                if element.atomic_num % 2 == 0:\n                    child = elements_data.elements_dict[element.atomic_num \/\/ 2]\n                    self.remove_fissile_element(child, 2*count)\n                else:\n                    child_A, child_B = (elements_data.elements_dict[element.atomic_num \/\/ 2 + 1],\n                                        elements_data.elements_dict[element.atomic_num \/\/ 2])\n                    self.remove_fissile_element(child_A, count)\n                    self.remove_fissile_element(child_B, count)\n            except FormulaValidityError:\n                raise FormulaValidityError(f\"Couldn't remove {count} of {element} from formula\")\n\n# Enum-esque directional vars for convenience\nDIRECTIONS = UP, RIGHT, DOWN, LEFT = (0, 1, 2, 3) # Python, baby\n\ndef opposite_dir(dir):\n    '''Given an Int representing a direction return its opposite direction.'''\n    return (dir + 2) % 4\n\nclass GridPos:\n    '''Represent a 0-indexed (row, col) position within an input\/output zone.\n    Indices increase from left to right and top to bottom.\n    '''\n    num_cols = 4\n\n    def __init__(self, row, col, large_output=False):\n        self.row = row\n        self.col = col\n        self.large_output = large_output\n        self.num_rows = 4 + 4*large_output\n\n    def __str__(self):\n        return f'({self.row}, {self.col})'\n    __repr__ = __str__\n\n    # __eq__ and __hash__ so we can use GridPos as dictionary keys\n    def __eq__(self, other):\n        return type(self) == type(other) and (self.row, self.col) == (other.row, other.col)\n\n    def __hash__(self):\n        return hash((self.row, self.col))\n\n    def is_valid(self):\n        '''Check that this position consists of integer positions within the zone's grid.'''\n        return isinstance(self.row, int) and isinstance(self.col, int) \\\n               and (0 <= self.row < self.num_rows) and (0 <= self.col < self.num_cols)\n\n    def neighbor(self, dir):\n        '''Return the neighbor GridPos in the indicated direction, or None if out-of-bounds.'''\n        if dir == UP:\n            r, c = self.row - 1, self.col\n        elif dir == RIGHT:\n            r, c = self.row, self.col + 1\n        elif dir == DOWN:\n            r, c = self.row + 1, self.col\n        elif dir == LEFT:\n            r, c = self.row, self.col - 1\n        else:\n            raise ValueError(f\"Invalid direction: {dir}\")\n\n        if 0 <= r < self.num_rows and 0 <= c < self.num_cols:\n            return GridPos(r, c, self.large_output)\n        return None\n\n    def neighbors(self):\n        '''Return all orthogonally adjacent positions within the zone's grid.'''\n        return [p for p in (self.neighbor(dir) for dir in DIRECTIONS) if p is not None]\n\n    def dirs_and_neighbors(self):\n        '''Return a list of (dir, pos) pairs for each neighboring position within the grid.'''\n        return [(d, p) for d, p in ((_d, self.neighbor(_d)) for _d in DIRECTIONS) if p is not None]\n\n\nclass Atom:\n    '''Represent an Atom, including its element, grid position, and attached bonds.\n    '''\n    def __init__(self, element, pos):\n        self.bonds = [0, 0, 0, 0] # up, right, down, left\n        self.set_element(element)\n        self.set_pos(pos)\n\n    def __str__(self):\n        return self.symbol.rjust(2) # Pad element symbol to two chars\n\n    def __repr__(self):\n        return f'Atom({self.symbol}, {self.pos}, {self.bonds})'\n\n    def __eq__(self, other):\n        return (type(self) == type(other)\n                and self.element == other.element\n                and self.pos == other.pos\n                and self.bonds == other.bonds)\n\n    def get_json_str(self):\n        '''Return a string representing this atom in the level json's format.'''\n        return f'{self.col}{self.row}{self.atomic_num}{self.bonds[RIGHT]}{self.bonds[DOWN]}'\n\n    def remaining_bonds(self):\n        '''Return the # of remaining bonds this atom is allowed.'''\n        return self.max_bonds - sum(self.bonds)\n\n    def set_pos(self, pos):\n        '''Change this atom's position in the grid.'''\n        self.pos = pos\n        self.row = self.pos.row\n        self.col = self.pos.col\n\n    def set_element(self, element):\n        if sum(self.bonds) > element.max_bonds:\n            raise ValueError(f\"Too many bonds to change atom {self} to element {element}\")\n\n        self.element = element\n\n        # Exposing some sub-attributes for convenience\n        self.atomic_num = element.atomic_num\n        self.symbol = element.symbol\n        self.max_bonds = element.max_bonds\n\nclass Molecule:\n    '''Represents an input\/output zone and the molecule constructed therein.\n    '''\n    def __init__(self, large_output=False):\n        self.name = 'Randite'\n        self.large_output = large_output\n        self.num_rows = 4 + 4*large_output\n        self.num_cols = 4\n        self.formula = Formula()\n        # TODO: Could potentially merge grid and used_posns into a single GridPos:Atom dict.\n        #       The main convenience of the grid at this point is that it'll automatically yell at us\n        #       if we start asking for atoms from a GridPos that's out-of-bounds.\n        self.grid = [[None, None, None, None] for _ in range(self.num_rows)]\n        self.used_posns = set() # Tracked so that we can easily iterate over the atoms in the molecule\n\n        # To optimize the performance of available_positions(), we'll roughly track the # of open\n        # bonds available on this molecule.\n        # An atom with no open adjacencies in the grid contributes 0 to this count.\n        self.open_bonds = 0\n\n    def __getitem__(self, pos):\n        '''Return the atom at the specified grid position or None.'''\n        return self.grid[pos.row][pos.col]\n\n    def __setitem__(self, pos, item):\n        '''Set the specified grid position (item should be None or an Atom).'''\n        self.grid[pos.row][pos.col] = item\n        if item is None:\n            self.used_posns.remove(pos)\n        else:\n            self.used_posns.add(pos)\n\n    def __iter__(self):\n        '''Iterate over each atom in this molecule. Order of iteration is not defined.'''\n        return (self[p] for p in self.used_posns)\n\n    def __len__(self):\n        '''Return the # of atoms in this molecule.'''\n        return len(self.used_posns)\n\n    def __str__(self):\n        '''Pretty-print this molecule.'''\n        result = ' _________________ \\n' # Border of the input\/output zone\n        for r in range(self.num_rows):\n            result += '|'\n            for c in range(self.num_cols):\n                atom = self.grid[r][c]\n                # Represent any atoms here\n                if atom is None:\n                    result += 2*' '\n                else:\n                    result += str(atom).rjust(2)\n                # Represent any bonds to the right of the atom\n                left_atom = atom\n                right_atom = self.grid[r][c + 1] if c + 1 < self.num_cols else None\n\n                bond_str = ' '\n                if left_atom is not None and right_atom is not None \\\n                   and left_atom.bonds[RIGHT] != right_atom.bonds[LEFT]:\n                    bond_str = '?'\n                elif left_atom is not None and left_atom.bonds[RIGHT] != 0:\n                    bond_str = str(left_atom.bonds[RIGHT])\n                elif right_atom is not None and right_atom.bonds[LEFT] != 0:\n                    bond_str = str(right_atom.bonds[LEFT])\n                if c < self.num_cols - 1:\n                    result += ' ' + bond_str + ' '\n            result += '|\\n'\n            # Add a row of vertical bonds\n            if r < self.num_rows - 1:\n                result += '|'\n                for c in range(self.num_cols):\n                    top_atom = self.grid[r][c]\n                    if r + 1 < self.num_rows:\n                        bottom_atom = self.grid[r + 1][c]\n                    else:\n                        bottom_atom = None\n                    bond_str = '  '\n                    if top_atom is not None and bottom_atom is not None \\\n                       and top_atom.bonds[DOWN] != bottom_atom.bonds[UP]:\n                        bond_str = '??'\n                    elif top_atom is not None and top_atom.bonds[DOWN] != 0:\n                        bond_str = ' ' + str(top_atom.bonds[DOWN])\n                    elif bottom_atom is not None and bottom_atom.bonds[UP] != 0:\n                        bond_str = ' ' + str(bottom_atom.bonds[UP])\n                    result += bond_str\n                    if c < self.num_cols - 1:\n                        result += 3*' '\n                result += '|\\n'\n        result += '|_________________|\\n'\n        return result\n\n    __repr__ = __str__\n\n    def get_json_str(self):\n        '''Return a string representing this molecule in the level json's format.'''\n        result = f'{self.name};{self.formula.get_json_str()}'\n        for atom in self:\n            result += ';' + atom.get_json_str()\n        return result\n\n    def update_formula(self):\n        '''To be called after mutating any atom elements. Update the formula of this molecule.'''\n        self.formula = Formula()\n        for atom in self:\n            self.formula[atom.element] += 1\n\n    def update_open_bonds(self):\n        '''Update the count of open bonds. Since we only care about updating it well\n        enough to know when it's 0, we'll ignore the triple bond limit, and count any open side of\n        an atom as adding the remainder of its max bond count to the open bonds.\n        '''\n        self.open_bonds = 0\n        for atom in self:\n            if any(self[pos] is None for pos in atom.pos.neighbors()):\n                self.open_bonds += atom.remaining_bonds() # Not exact but we don't need it to be\n\n    def open_positions(self):\n        '''Return a list of valid grid positions where an atom could be added to this molecule.'''\n        # For an empty molecule, all positions are open\n        if len(self) == 0:\n            return [GridPos(r, c, large_output=self.large_output)\n                    for r in range(self.num_rows) for c in range(self.num_cols)]\n        # If there are no remaining bonds, we can skip the overhead of walking through the atoms\n        elif self.open_bonds == 0:\n            return []\n\n        checked_posns = set() # For O(1) checks on whether a position has already been added\n        for atom in self:\n            if atom.remaining_bonds() > 0:\n                for pos in atom.pos.neighbors():\n                   if self[pos] is None and pos not in checked_posns:\n                      checked_posns.add(pos)\n        return list(checked_posns)\n\n    def add_atom(self, new_atom):\n        '''Adds the given Atom to this molecule. The Atom's position must be open in this molecule.\n        Also adds any bonds specified by the incoming atom to its neighboring atoms.\n        For convenience of more complex operations, it is allowable to add an atom with unfulfilled\n        bonds or which is not connected to the rest of the molecule.\n        '''\n        if self[new_atom.pos] is not None:\n            raise Exception(f\"Conflict with existing atom; cannot add {repr(new_atom)} to \\n{self}\")\n\n        # Add the atom into our grid \/ formula. Then add its bonds while re-calculating self.open_bonds\n        self[new_atom.pos] = new_atom\n        self.used_posns.add(new_atom.pos)\n        self.formula[new_atom.element] += 1\n\n        # Quick helper to check if an atom within this molecule's grid has at least 1 open side\n        def has_open_side(atom):\n            return any(self[pos] is None for pos in atom.pos.neighbors())\n\n        # Partial update of the number of open bonds this molecule has\n        if has_open_side(new_atom):\n            self.open_bonds += new_atom.remaining_bonds()\n\n        # Add bonds to neighbours matching the bonds indicated on this atom\n        for dir, pos in new_atom.pos.dirs_and_neighbors():\n            adj_atom = self[pos]\n            if adj_atom is not None:\n                adj_atom.bonds[opposite_dir(dir)] = new_atom.bonds[dir]\n                # Subtract the bond we just added from the molecule's 'open bonds'\n                self.open_bonds -= new_atom.bonds[dir]\n\n                # If we closed off the neighbor's last open face, we've additionally removed\n                # however many bonds it now has left from the molecule's 'open' bonds\n                if not has_open_side(adj_atom):\n                    self.open_bonds -= adj_atom.remaining_bonds()\n\n    def remove_atom(self, atom):\n        '''Remove the specified atom from this molecule. Must exactly match.'''\n        if self[atom.pos] != atom:\n            raise ValueError(f\"Specified atom {repr(new_atom)} does not match an atom in:\\n{self}\"\n                             + \"\\nCannot be removed.\")\n\n        self[atom.pos] = None\n        self.formula[atom.element] -= 1\n\n        # Remove any now-trailing bonds on neighbors\n        for dir, pos in atom.pos.dirs_and_neighbors():\n            adj_atom = self[pos]\n            if adj_atom is not None:\n                adj_atom.bonds[opposite_dir(dir)] = 0\n        self.update_open_bonds()\n\n    def is_connected(self):\n        '''For the purposes of more advanced construction algorithms we allow adding atoms in\n        unconnected cells. This checks if the molecule is currently 'connected' and thus valid.\n        We'll count empty molecules as unconnected.\n        '''\n        if len(self) == 0:\n            return False\n\n        # Do a DFS starting from one atom and following the bonds of the molecule. If we don't\n        # find every atom, it's not connected\n        sample_pos = next(iter(self.used_posns))\n        stack = [self[sample_pos]]\n        # We don't have to actually 'visit' every atom, seeing them as neighbors is sufficient\n        seen = {sample_pos} # Track the grid positions of seen connected atoms\n        while stack:\n            if len(seen) == len(self):\n                return True\n\n            atom = stack.pop()\n            # Check for connected neighbors. When we see an unseen connected atom, add it to the\n            # stack\n            for dir, adj_pos in atom.pos.dirs_and_neighbors():\n                if atom.bonds[dir] != 0 and adj_pos not in seen:\n                    seen.add(adj_pos)\n                    adj_atom = self[adj_pos]\n                    stack.append(adj_atom)\n        return False\n\n    def shift(self, rows=0, cols=0):\n        '''Shift the current contents of this molecule downward\/rightward by the specified number\n        of rows\/columns. Negative numbers shift upward\/leftward.\n\n        Raise an exception if this would place atoms out-of-bounds.\n        '''\n        # Make sure this is a legal shift\n        for atom in self:\n            if (atom.row + rows < 0 or atom.row + rows > self.num_rows) \\\n               or (atom.col + cols < 0 or atom.col + cols > self.num_cols):\n               raise Exception(f'Cannot shift molecule\\n{self}\\nby {rows} rows and {cols} cols')\n\n        # Wipe the grid clean and re-add the atoms in their new positions\n        atoms = list(self)\n        self.grid = [[None, None, None, None] for r in range(self.num_rows)]\n        self.used_posns = set()\n        for atom in atoms:\n            atom.set_pos(GridPos(atom.row + rows, atom.col + cols, large_output=self.large_output))\n            self[atom.pos] = atom\n\n        # Recount open bonds once we're done since some atoms may no longer have open sides\n        self.update_open_bonds()\n\n    def add_molecule(self, other):\n        '''Add the specified molecule to this molecule. Must not have any atoms in conflicting\n        positions.\n        '''\n        # Check for conflicts\n        if any(self[atom.pos] is not None for atom in other):\n            raise Exception(f'Cannot add molecule\\n{other} to molecule\\n{self}; conflicting atoms')\n\n        # Add the new atoms\n        for atom in other:\n            self.add_atom(atom)\n\nclass Level:\n    '''Parent class for Research and Production levels.'''\n    def __init__(self):\n        self.dict = {}\n\n    def __getitem__(self, item):\n        return self.dict[item]\n\n    def __setitem__(self, item, val):\n        self.dict[item] = val\n\n    def __str__(self):\n        return json.dumps(self.dict)\n\n    def get_code(self):\n        '''Get the mission code - gzip then b64 the level json.'''\n        out = io.BytesIO()\n        with gzip.GzipFile(fileobj=out, mode=\"w\") as f:\n            f.write(json.dumps(self.dict).encode('utf-8'))\n        return base64.b64encode(out.getvalue()).decode()\n\nclass ResearchLevel(Level):\n    def __init__(self):\n        Level.__init__(self)\n        self['input-zones'] = {}\n        self['output-zones'] = {}\n\n        self['has-large-output'] = False\n\n        # Features of the level\n        self['bonder-count'] = 0\n        self['has-sensor'] = False\n        self['has-fuser'] = False\n        self['has-splitter'] = False\n        self['has-teleporter'] = False\n\n        self['type'] = 'research'\n        self['name'] = 'RandomlyGenerated'\n        self['author'] = \"<NAME>\"\n        self['difficulty'] = 0\n\nclass ProductionLevel(Level):\n    def __init__(self):\n        Level.__init__(self)\n        self['terrain'] = 0\n        self['random-input-zones'] = {} # Max 1 random\n        self['fixed-input-zones'] = {} # Max 2 fixed\n        self['output-zones'] = {} # Max 3 outputs\n\n        self['max-reactors'] = 6 # Default maximum allowed\n\n        self['has-starter'] = False\n        self['has-assembly'] = False\n        self['has-disassembly'] = False\n        self['has-advanced'] = False # Sensor reactor\n        self['has-nuclear'] = False\n        self['has-superbonder'] = False\n        self['has-recycler'] = False\n\n        self['type'] = 'production'\n        self['name'] = 'RandomlyGenerated'\n        self['author'] = \"<NAME>\"\n        self['difficulty'] = 0\n\n\ndef splittable_sources(given):\n    '''Given a Counter of ints, return a dict of ints and their total counts that can be\n    non-trivially constructed from the given integers, using only series' of addition of integers\n    within 1 of each other, and where no given int is used more times than its count in the Counter.\n    In other words, we're using the inverse fission operation to calculate viable input elements\n    that could have been split any (non-0) # of times to create part of the given output.\n    '''\n    # NOTE: We ask for a Counter as input because unlike dicts, they implicitly return 0 if\n    #       asked for a key they don't contain, which simplifies our code\n\n    # Tally tracking ints we were given\/discover, the max of each we can create at once, and\n    # some additional helper values - as needed we'll create dicts that track how many N-1 ints\n    # we can create at the same time as any possible count of N's. We'll also track the\n    # 'most balanced' such allocation of N vs N-1, which will allow us to properly get counts for\n    # odd ints, as well as assisting in the creation of higher dicts.\n    tally = {}\n    # Dict of ints that were constructable (not just given), and their max counts\n    constructed = {}\n\n    # Keep a running sum of what we were given so we don't waste time on clearly impossible sums\n    givens_sum = 0\n\n    # To avoid the overhead of a priority queue, use one queue for the given ints,\n    # and one queue for ints we obtained by addition (we'll add them in numerical order).\n    # Loop on whichever's next value is lower\n    given_queue = collections.deque(sorted(given.keys()))\n    added_queue = collections.deque()\n    while given_queue or added_queue:\n        # Pop the element we're iterating on - pop from both queues at once if they match\n        if (not added_queue\n            or (given_queue and given_queue[0] < added_queue[0])):\n            n = given_queue.popleft()\n        else:\n            if given_queue and given_queue[0] == added_queue[0]:\n                given_queue.popleft()\n            n = added_queue.popleft()\n\n        # Calculate how many copies of n we can obtain at once\n        if n % 2 == 0:\n            # If n is even, we only need to update its count, based on\n            # the count of n \/ 2 and however much of n we were given to start\n            component_count = tally[n \/\/ 2]['count'] if n \/\/ 2 in tally else 0\n            this_count = component_count \/\/ 2 + given[n]\n        else:\n            # To count odd n, we must first make a dict that pairs the max # of n \/\/ 2 that can\n            # be created for any given count of n \/\/ 2 + 1. We can do this recursively off\n            # a previous such dict. When creating this dict we will also store the count\n            # of n \/\/ 2 + 1 for which there can simultaneously be created a most closely balanced\n            # count of n \/\/ 2. This can be used directly to count n and also to speed up\n            # the recursive creation of dicts.\n            # However we can skip this if either of n \/\/ 2 or n \/\/ 2 + 1 are unavailable.\n            # Note that even if both are available they may not be addable so our count could\n            # still come out to 0\n            upper_child, lower_child = n \/\/ 2 + 1, n \/\/ 2\n            if upper_child in tally and lower_child in tally:\n                # In this case, calculate and store upper_child's neighbour dict\n                tally[upper_child]['neighbour_counts'] = {}\n                if upper_child == 2: # Calc 2->1 dict\n                    balanced_upper_count, min_count_in_best_balance = -1, -1\n                    for upper_count in range(1, tally[upper_child]['count'] + 1):\n                        lower_count = (tally[lower_child]['count']\n                                       - 2*max(upper_count - given[upper_child], 0))\n                        tally[upper_child]['neighbour_counts'][upper_count] = lower_count\n\n                        # Check how balanced this allocation is\n                        worst_count = min(upper_count, lower_count)\n                        if worst_count >= min_count_in_best_balance:\n                            balanced_upper_count = upper_count\n                            min_count_in_best_balance = worst_count\n                    tally[upper_child]['balanced_count'] = balanced_upper_count\n                elif upper_child == 3: # Calc 3->2 dict\n                    balanced_upper_count, min_count_in_best_balance = -1, -1\n                    for upper_count in range(1, tally[upper_child]['count'] + 1):\n                        nongiven_upper_count = max(upper_count - given[upper_child], 0)\n                        # 2s count = (2s constructable given 1s used in 3s) - (2s used in 3s)\n                        lower_count = (given[2] + (given[1] - nongiven_upper_count) \/\/ 2\n                                       - nongiven_upper_count)\n                        tally[upper_child]['neighbour_counts'][upper_count] = lower_count\n\n                        # Check how balanced this allocation is\n                        worst_count = min(upper_count, lower_count)\n                        if worst_count >= min_count_in_best_balance:\n                            balanced_upper_count = upper_count\n                            min_count_in_best_balance = worst_count\n                    # Store the most balanced count for upper_child\n                    tally[upper_child]['balanced_count'] = balanced_upper_count\n                # If either the upper child or the lower child had no compound components,\n                # the upper_child's neighbour_counts dict is just the max count of lower_child,\n                # regardless of the count of upper_child\n                elif (tally[upper_child]['count'] == given[upper_child]\n                      or tally[lower_child]['count'] == given[lower_child]):\n                    tally[upper_child]['neighbour_counts'] = {\n                            i: tally[lower_child]['count']\n                            for i in range(1, tally[upper_child]['count'] + 1) }\n                    # Since the lower_child gets the same count no matter what, just maximize\n                    # upper_child's count for the 'balanced' allocation\n                    tally[upper_child]['balanced_count'] = tally[upper_child]['count']\n                # Otherwise, based on our recursion principle, the upper child's upper\n                # child must already have its neighbour_counts dict set. Use that to calculate\n                # the upper child's neighbour_counts. The algorithm for this depends on which of\n                # upper_child\/lower_child is even.\n                # We also have a couple of base cases to handle when building the neighbour dict\n                # dict for 3->2 and 2-> 1, since in those cases lower_child is also a component\n                # of upper_child\n                elif upper_child % 2 == 0:\n                    # If the upper child is even, calculate how much of lower_child's components\n                    # are used up by any valid count of upper_child, and thus the max\n                    # lower_child count for that count of upper_child.\n                    # Call A upper_child \/\/ 2 and B the other (lower) component of lower_child\n                    A = upper_child \/\/ 2\n                    balanced_upper_count, min_count_in_best_balance = -1, -1\n                    for upper_count in range(1, tally[upper_child]['count'] + 1):\n                        if upper_count <= given[upper_child]:\n                            lower_count = tally[lower_child]['count']\n                        else:\n                            A_used_in_upper = 2*(upper_count - given[upper_child])\n                            if A_used_in_upper == tally[A]['count']:\n                                lower_count = given[lower_child]\n                            else:\n                                # Search to the right of the original balance point and\/or our\n                                # new A limit, to find a balance given the unusable As:\n                                start_idx = max(tally[A]['balanced_count'], A_used_in_upper + 1)\n                                built_lower_count = 0\n                                for used_A in range(start_idx, tally[A]['count'] + 1):\n                                    worst_count = min(used_A - A_used_in_upper,\n                                                      tally[A]['neighbour_counts'][used_A])\n                                    built_lower_count = max(built_lower_count, worst_count)\n                                lower_count = built_lower_count + given[lower_child]\n                        tally[upper_child]['neighbour_counts'][upper_count] = lower_count\n\n                        # Check how balanced this allocation is\n                        worst_count = min(upper_count, lower_count)\n                        if worst_count >= min_count_in_best_balance:\n                            balanced_upper_count = upper_count\n                            min_count_in_best_balance = worst_count\n                    # Store the most balanced count for upper child\n                    tally[upper_child]['balanced_count'] = balanced_upper_count\n                else:\n                    # If the upper child is odd, call its subchildren A and B, where B =\n                    # lower_child \/\/ 2. Using A's neighbour_counts dict, calculate how much B and\n                    # from that how much lower_child we can make for any valid count of\n                    # upper_child\n                    A = upper_child \/\/ 2 + 1\n                    # For each possible count of upper_child, calculate how many copies of\n                    # lower_child can be simultaneously constructed from the leftovers\n                    # Also track the 'most balanced' count we can assign to upper_child\n                    balanced_upper_count, min_count_in_best_balance = -1, -1\n                    for upper_count in range(1, tally[upper_child]['count'] + 1):\n                        if upper_count <= given[upper_child]:\n                            lower_count = tally[lower_child]['count']\n                        else:\n                            used_A = used_B = upper_count - given[upper_child]\n                            available_B = (tally[A]['neighbour_counts'][used_A] - used_A)\n                            lower_count = available_B \/\/ 2 + given[lower_child]\n                        tally[upper_child]['neighbour_counts'][upper_count] = lower_count\n\n                        # Check how balanced this allocation is\n                        worst_count = min(upper_count, lower_count)\n                        if worst_count >= min_count_in_best_balance:\n                            balanced_upper_count = upper_count\n                            min_count_in_best_balance = worst_count\n                    # Store the most balanced count for upper child\n                    tally[upper_child]['balanced_count'] = balanced_upper_count\n\n                # Calculate the count of n based on upper_child's most balanced count\n                balanced_upper_count = tally[upper_child]['balanced_count']\n                this_count = (min(balanced_upper_count,\n                                  tally[upper_child]['neighbour_counts'][balanced_upper_count])\n                              + given[n])\n            else:\n                # If n only occurred as an input and not a compound, set it to the given count\n                # The n = 1 case is handled here since 1 can never be compound\n                # We don't need to calculate its neighbour dict in this case.\n                this_count = given[n]\n\n        # If the count came out to 0, ignore this int\n        if this_count == 0:\n            continue\n        # Update the tally with the discovered count\n        tally[n] = {'count': this_count}\n        #  Add this int to the output dict if it was possible to construct\n        # (not just obtained from the givens)\n        if this_count != given[n]:\n            constructed[n] = this_count\n\n        # Add any viable sums (restricted to valid atomic masses) obtained from n to the queue\n        # As a mini-optimization, we won't add odd numbers to the queue that exceed the sum of\n        # the givens up to n\n        givens_sum += n*given[n]\n        # If n - 1 is in the tally, add 2n - 1 to the queue\n        if (n - 1 in tally\n            and (2*n - 1 <= 109 or 2*n - 1 in (201, 203))\n            and 2*n - 1 <= givens_sum):\n            added_queue.append(2*n - 1)\n        # If the count for n was at least 2, add 2n to the queue\n        if tally[n]['count'] >= 2 and (2*n <= 109 or 2*n in (200, 202)):\n            added_queue.append(2*n)\n\n    # Once we've looped over all possible sums, return a dict of the relevant ints and their counts\n    return constructed\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_114","text":"<filename>src\/hcb\/tools\/analysis\/probability_util.py\nimport math\nfrom typing import Union, Callable, Sequence, Tuple\n\nimport numpy as np\nfrom scipy.stats import linregress\nfrom scipy.optimize import leastsq\nfrom scipy.stats._stats_mstats_common import LinregressResult\n\n\ndef log_binomial(*, p: Union[float, np.ndarray], n: int, hits: int) -> Union[float, np.ndarray]:\n    r\"\"\"Approximates $\\ln(P(hits = B(n, p)))$; the natural logarithm of a binomial distribution.\n\n    All computations are done in log space to ensure intermediate values can be represented as\n    floating point numbers without underflowing to 0 or overflowing to infinity. This is necessary\n    when computing likelihoods over many samples. For example, if 80% of a million samples are hits,\n    the maximum likelihood estimate is p=0.8. But even this optimal estimate assigns a prior\n    probability of roughly 10^-217322 for seeing *exactly* 80% hits out of a million (whereas the\n    smallest representable double is roughly 10^-324).\n\n    This method can be broadcast over multiple hypothesis probabilities.\n\n    Args:\n        p: The independent probability of a hit occurring for each sample. This can also be an array\n            of probabilities, in which case the function is broadcast over the array.\n        n: The number of samples that were taken.\n        hits: The number of hits that were observed amongst the samples that were taken.\n\n    Returns:\n        $\\ln(P(hits = B(n, p)))$\n    \"\"\"\n    # Clamp probabilities into the valid [0, 1] range (in case float error put them outside it).\n    p_clipped = np.clip(p, 0, 1)\n\n    result = np.zeros(shape=p_clipped.shape, dtype=np.float32)\n    misses = n - hits\n\n    # Handle p=0 and p=1 cases separately, to avoid arithmetic warnings.\n    if hits:\n        result[p_clipped == 0] = -np.inf\n    if misses:\n        result[p_clipped == 1] = -np.inf\n\n    # Multiply p**hits and (1-p)**misses onto the total, in log space.\n    result[p_clipped != 0] += np.log(p_clipped[p_clipped != 0]) * hits\n    result[p_clipped != 1] += np.log1p(-p_clipped[p_clipped != 1]) * misses\n\n    # Multiply (n choose hits) onto the total, in log space.\n    log_n_choose_hits = log_factorial(n) - log_factorial(misses) - log_factorial(hits)\n    result += log_n_choose_hits\n\n    return result\n\n\ndef log_factorial(n: int) -> float:\n    r\"\"\"Approximates $\\ln(n!)$; the natural logarithm of a factorial.\n\n    Uses Stirling's approximation for large n.\n    \"\"\"\n    if n < 20:\n        return sum(math.log(k) for k in range(1, n + 1))\n    return (n + 0.5) * math.log(n) - n + math.log(2 * np.pi) \/ 2\n\n\ndef binary_search(*, func: Callable[[int], float], min_x: int, max_x: int, target: float) -> int:\n    \"\"\"Performs an approximate granular binary search over a monotonically ascending function.\"\"\"\n    while max_x > min_x + 1:\n        med_x = (min_x + max_x) \/\/ 2\n        out = func(med_x)\n        if out < target:\n            min_x = med_x\n        elif out > target:\n            max_x = med_x\n        else:\n            return med_x\n    fmax = func(max_x)\n    fmin = func(min_x)\n    dmax = 0 if fmax == target else fmax - target\n    dmin = 0 if fmin == target else fmin - target\n    return max_x if abs(dmax) < abs(dmin) else min_x\n\n\ndef binary_intercept(*, func: Callable[[float], float], start_x: float, step: float, target_y: float, atol: float) -> float:\n    \"\"\"Performs an approximate granular binary search over a monotonically ascending function.\"\"\"\n    start_y = func(start_x)\n    if abs(start_y - target_y) <= atol:\n        return start_x\n    while (func(start_x + step) >= target_y) == (start_y >= target_y):\n        step *= 2\n        if np.isinf(step) or step == 0:\n            raise ValueError(\"Failed.\")\n    xs = [start_x, start_x + step]\n    min_x = min(xs)\n    max_x = max(xs)\n    increasing = func(min_x) < func(max_x)\n\n    while True:\n        med_x = (min_x + max_x) \/ 2\n        med_y = func(med_x)\n        if abs(med_y - target_y) <= atol:\n            return med_x\n        assert med_x not in [min_x, max_x]\n        if (med_y < target_y) == increasing:\n            min_x = med_x\n        else:\n            max_x = med_x\n\n\ndef least_squares_cost(*, xs: np.ndarray, ys: np.ndarray, intercept: float, slope: float) -> float:\n    assert len(xs.shape) == 1\n    assert xs.shape == ys.shape\n    return np.sum((intercept + slope*xs - ys)**2)\n\n\ndef least_squares_through_point(*, xs: np.ndarray, ys: np.ndarray, required_x: float, required_y: float) -> LinregressResult:\n    xs2 = xs - required_x\n    ys2 = ys - required_y\n\n    def err(slope: float) -> float:\n        return least_squares_cost(xs=xs2, ys=ys2, intercept=0, slope=slope)\n\n    (best_slope,), _ = leastsq(func=err, x0=0.0)\n    intercept = required_y - required_x * best_slope\n    return LinregressResult(best_slope, intercept, None, None, None, intercept_stderr=False)\n\n\ndef least_squares_with_slope(*, xs: np.ndarray, ys: np.ndarray, required_slope: float) -> LinregressResult:\n    def err(intercept: float) -> float:\n        return least_squares_cost(xs=xs, ys=ys, intercept=intercept, slope=required_slope)\n\n    (best_intercept,), _ = leastsq(func=err, x0=0.0)\n    return LinregressResult(required_slope, best_intercept, None, None, None, intercept_stderr=False)\n\n\ndef least_squares_output_range(*,\n                               xs: Sequence[float],\n                               ys: Sequence[float],\n                               target_x: float,\n                               cost_increase: float) -> Tuple[float, float, float]:\n    xs = np.array(xs, dtype=np.float64)\n    ys = np.array(ys, dtype=np.float64)\n    fit = linregress(xs, ys)\n    base_cost = least_squares_cost(xs=xs, ys=ys, intercept=fit.intercept, slope=fit.slope)\n    base_y = float(fit.intercept + target_x * fit.slope)\n\n    def cost_for_y(y2: float) -> float:\n        fit2 = least_squares_through_point(xs=xs, ys=ys, required_x=target_x, required_y=y2)\n        return least_squares_cost(xs=xs, ys=ys, intercept=fit2.intercept, slope=fit2.slope)\n\n    low_y = binary_intercept(start_x=base_y, step=-1, target_y=base_cost + cost_increase, func=cost_for_y, atol=1e-5)\n    high_y = binary_intercept(start_x=base_y, step=1, target_y=base_cost + cost_increase, func=cost_for_y, atol=1e-5)\n    return low_y, base_y, high_y\n\n\ndef least_squares_slope_range(*,\n                              xs: Sequence[float],\n                              ys: Sequence[float],\n                              cost_increase: float) -> Tuple[float, float, float]:\n    xs = np.array(xs, dtype=np.float64)\n    ys = np.array(ys, dtype=np.float64)\n    fit = linregress(xs, ys)\n    base_cost = least_squares_cost(xs=xs, ys=ys, intercept=fit.intercept, slope=fit.slope)\n\n    def cost_for_slope(slope: float) -> float:\n        fit2 = least_squares_with_slope(xs=xs, ys=ys, required_slope=slope)\n        return least_squares_cost(xs=xs, ys=ys, intercept=fit2.intercept, slope=fit2.slope)\n\n    low_slope = binary_intercept(start_x=fit.slope, step=-1, target_y=base_cost + cost_increase, func=cost_for_slope, atol=1e-5)\n    high_slope = binary_intercept(start_x=fit.slope, step=1, target_y=base_cost + cost_increase, func=cost_for_slope, atol=1e-5)\n    return low_slope, fit.slope, high_slope\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_115","text":"from sklearn.ensemble import GradientBoostingClassifier\nfrom commons import variables\nfrom commons import tools\nfrom scipy.stats import mode\n\n\ndef learn(x, y, test_x):\n    # set sample weight\n\n\n    weight_list = []\n    for j in range(len(y)):\n        if y[j] == \"0\":\n            weight_list.append(variables.weight_0_gdbt_b)\n        if y[j] == \"1000\":\n            weight_list.append(variables.weight_1000_gdbt_b)\n        if y[j] == \"1500\":\n            weight_list.append(variables.weight_1500_gdbt_b)\n        if y[j] == \"2000\":\n            weight_list.append(variables.weight_2000_gdbt_b)\n\n    clf = GradientBoostingClassifier(loss='deviance', n_estimators=variables.n_estimators_gdbt_b,\n                                     learning_rate=variables.learning_rate_gdbt_b,\n                                     max_depth=variables.max_depth_gdbt_b, random_state=0,\n                                     min_samples_split=variables.min_samples_split_gdbt_b,\n                                     min_samples_leaf=variables.min_samples_leaf_gdbt_b,\n                                     subsample=variables.subsample_gdbt_b,\n                                     ).fit(x, y, weight_list)\n    prediction_list = clf.predict(test_x)\n\n    return prediction_list\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_117","text":"'''original example for checking how far GAM works\n\nNote: uncomment plt.show() to display graphs\n'''\n\nexample = 2  # 1,2 or 3\n\nimport numpy as np\nimport numpy.random as R\nimport matplotlib.pyplot as plt\n\nfrom statsmodels.sandbox.gam import AdditiveModel\nfrom statsmodels.sandbox.gam import Model as GAM #?\nfrom statsmodels.genmod.families import family\nfrom statsmodels.genmod.generalized_linear_model import GLM\n\nstandardize = lambda x: (x - x.mean()) \/ x.std()\ndemean = lambda x: (x - x.mean())\nnobs = 150\nx1 = R.standard_normal(nobs)\nx1.sort()\nx2 = R.standard_normal(nobs)\nx2.sort()\ny = R.standard_normal((nobs,))\n\nf1 = lambda x1: (x1 + x1**2 - 3 - 1 * x1**3 + 0.1 * np.exp(-x1\/4.))\nf2 = lambda x2: (x2 + x2**2 - 0.1 * np.exp(x2\/4.))\nz = standardize(f1(x1)) + standardize(f2(x2))\nz = standardize(z) * 2 # 0.1\n\ny += z\nd = np.array([x1,x2]).T\n\n\nif example == 1:\n    print \"normal\"\n    m = AdditiveModel(d)\n    m.fit(y)\n    x = np.linspace(-2,2,50)\n\n    print m\n\n    y_pred = m.results.predict(d)\n    plt.figure()\n    plt.plot(y, '.')\n    plt.plot(z, 'b-', label='true')\n    plt.plot(y_pred, 'r-', label='AdditiveModel')\n    plt.legend()\n    plt.title('gam.AdditiveModel')\n\nimport scipy.stats, time\n\nif example == 2:\n    print \"binomial\"\n    f = family.Binomial()\n    b = np.asarray([scipy.stats.bernoulli.rvs(p) for p in f.link.inverse(y)])\n    b.shape = y.shape\n    m = GAM(b, d, family=f)\n    toc = time.time()\n    m.fit(b)\n    tic = time.time()\n    print tic-toc\n\n\nif example == 3:\n    print \"Poisson\"\n    f = family.Poisson()\n    y = y\/y.max() * 3\n    yp = f.link.inverse(y)\n    p = np.asarray([scipy.stats.poisson.rvs(p) for p in f.link.inverse(y)], float)\n    p.shape = y.shape\n    m = GAM(p, d, family=f)\n    toc = time.time()\n    m.fit(p)\n    tic = time.time()\n    print tic-toc\n\n\nplt.figure()\nplt.plot(x1, standardize(m.smoothers[0](x1)), 'r')\nplt.plot(x1, standardize(f1(x1)), linewidth=2)\nplt.figure()\nplt.plot(x2, standardize(m.smoothers[1](x2)), 'r')\nplt.plot(x2, standardize(f2(x2)), linewidth=2)\n\n\n\n\nplt.show()\n\n\n\n##     pylab.figure(num=1)\n##     pylab.plot(x1, standardize(m.smoothers[0](x1)), 'b')\n##     pylab.plot(x1, standardize(f1(x1)), linewidth=2)\n##     pylab.figure(num=2)\n##     pylab.plot(x2, standardize(m.smoothers[1](x2)), 'b')\n##     pylab.plot(x2, standardize(f2(x2)), linewidth=2)\n##     pylab.show()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_118","text":"<gh_stars>0\nimport math\r\nimport os\r\nimport random\r\n\r\nimport bpy\r\nimport scipy.misc\r\n\r\n\r\nIMAGE_SIZE = 64\r\nDISTANCE = 2.732\r\n\r\n\r\ndef set_camera_location(elevation, azimuth, distance):\r\n    # set location\r\n    x = 1 * math.cos(math.radians(-azimuth)) * math.cos(math.radians(elevation)) * distance\r\n    y = 1 * math.sin(math.radians(-azimuth)) * math.cos(math.radians(elevation)) * distance\r\n    z = 1 * math.sin(math.radians(elevation)) * distance\r\n    camera = bpy.data.objects[\"Camera\"]\r\n    camera.location = x, y, z\r\n\r\n    # look at center\r\n    direction = - camera.location\r\n    rot_quat = direction.to_track_quat('-Z', 'Y')\r\n    camera.rotation_euler = rot_quat.to_euler()\r\n\r\n\r\ndef render(directory, elevation=30, distance=DISTANCE):\r\n    for azimuth in range(0, 360, 15):\r\n        filename = os.path.join(directory, 'e%03d_a%03d.png' % (elevation, azimuth))\r\n        set_camera_location(elevation, azimuth, distance) \r\n        bpy.context.scene.render.filepath = filename\r\n        bpy.ops.render.render(write_still=True)\r\n\r\n        if False:\r\n            img = scipy.misc.imread(filename)[:, :, :].astype('float32') \/ 255.\r\n            if False:\r\n                img = (img[::2, ::2] + img[1::2, ::2] + img[::2, 1::2] + img[1::2, 1::2]) \/ 4.\r\n            else:\r\n                import chainer.functions as cf\r\n                img = img.transpose((2, 0, 1))[None, :, :, :]\r\n                img = cf.resize_images(img, (64, 64))\r\n                img = img[0].data.transpose((1, 2, 0))\r\n\r\n            img = (img * 255).clip(0., 255.).astype('uint8')\r\n            scipy.misc.imsave(filename, img)\r\n\r\n\r\ndef setup():\r\n    context = bpy.context\r\n    if False:\r\n        context.scene.render.resolution_x = IMAGE_SIZE * 2\r\n        context.scene.render.resolution_y = IMAGE_SIZE * 2\r\n        context.scene.render.resolution_percentage = 100\r\n        context.scene.render.use_antialiasing = False\r\n    else:\r\n        context.scene.render.resolution_x = IMAGE_SIZE\r\n        context.scene.render.resolution_y = IMAGE_SIZE\r\n        context.scene.render.resolution_percentage = 100\r\n        context.scene.render.use_antialiasing = True\r\n    context.scene.render.use_free_unused_nodes = True\r\n    context.scene.render.use_free_image_textures = True\r\n    context.scene.render.alpha_mode = 'TRANSPARENT'\r\n    bpy.context.scene.render.image_settings.color_mode = 'RGBA'\r\n\r\n    # camera\r\n    camera = bpy.data.cameras.values()[0]\r\n    camera.sensor_width = 1\r\n    camera.sensor_height = 1\r\n    camera.lens = 1.8660254037844388\r\n\r\n    # lighting\r\n    light = bpy.data.objects['Lamp']\r\n    light.data.energy = 1\r\n    context.scene.world.light_settings.use_environment_light = True\r\n    context.scene.world.light_settings.environment_energy = 0.5\r\n    context.scene.world.light_settings.environment_color = 'PLAIN'\r\n\r\n\r\ndef load_obj(filename):\r\n    # filename = '\/home\/hkato\/temp\/obj\/model.obj'\r\n    # filename = '\/media\/disk2\/lab\/large_data\/ShapeNetCore.v1\/03001627\/1bcec47c5dc259ea95ca4adb70946a21\/model.obj'\r\n    bpy.ops.import_scene.obj(filepath=filename, use_smooth_groups=False, use_split_objects=False,\r\n                             use_split_groups=False)\r\n    object_id = len(bpy.data.objects) - 1\r\n    obj = bpy.data.objects[object_id]\r\n    bpy.context.scene.objects.active = obj\r\n\r\n    # get max & min of vertices\r\n    inf = 10000\r\n    vertex_max = [-inf, -inf, -inf]\r\n    vertex_min = [inf, inf, inf]\r\n    for j in range(8):\r\n        for i in range(3):\r\n            vertex_max[i] = max(vertex_max[i], obj.bound_box[j][i])\r\n            vertex_min[i] = min(vertex_min[i], obj.bound_box[j][i])\r\n    dimensions = obj.dimensions  # = max - min\r\n\r\n    # centering\r\n    for i in range(3):\r\n        obj.location[i] += (vertex_max[i] + vertex_min[i]) \/ 2\r\n\r\n    # scaling\r\n    scale = max(dimensions)\r\n    for i in range(3):\r\n        obj.scale[i] = obj.scale[i] \/ scale\r\n\r\n    # materials\r\n    for m in bpy.data.materials:\r\n        m.ambient = 0.5\r\n        m.use_shadeless = False\r\n        m.use_transparency = False\r\n        m.use_raytrace = False\r\n\r\n\r\ndef clear():\r\n    bpy.ops.wm.open_mainfile(filepath='\/home\/hkato\/temp\/untitled.blend')\r\n\r\n\r\ndef run():\r\n    \r\n    #se crea una lista de id, dentro del dataset para entrenar el modelo con esos objetos\r\n    \"\"\"class_ids = [\r\n                    '02691156', '02828884', '02933112', '02958343', '03001627', '03211117', '03636649', '03691459', '04090263',\r\n                    '04256520', '04379243', '04401088', '04530566']\"\"\"\r\n    class_ids = ['02942699']\r\n\r\n    \"\"\"\r\n    directory_shapenet_id = '..\/..\/resource\/shapenetcore_ids'\r\n    directory_rendering = '\/media\/disk2\/lab\/projection\/reconstruction\/shapenet_images_%d_%.1f\/%s\/%s'\r\n    filename_shapenet_obj = '\/media\/disk2\/lab\/large_data\/ShapeNetCore.v1\/%s\/%s\/model.obj'\r\n    \"\"\"\r\n\r\n    \"\"\"\r\n    directory_shapenet_id = '\/media\/gustavo\/gusgus\/TROOPS\/shapenetcore_ids'\r\n    directory_rendering = '\/media\/gustavo\/gusgus\/TROOPS\/mesh_reconstruction\/shapenet_images_%d_%.1f\/%s\/%s'\r\n    filename_shapenet_obj = '\/media\/gustavo\/gusgus\/TROOPS\/ShapeNetCore.v2\/%s\/%s\/model.obj'\r\n    \"\"\"\r\n\r\n    directory_shapenet_id = '\/content\/3D-Sneakers\/shapenetcore_ids'\r\n    directory_rendering = '\/content\/3D-Sneakers\/mesh_reconstruction\/shapenet_images_%d_%.1f\/%s\/%s'\r\n    filename_shapenet_obj = '\/content\/3D-Sneakers\/ShapeNetCore.v2\/%s\/%s\/model.obj'\r\n\r\n    # ce33bf3ec6438e5bef662d1962a11f02\r\n    for class_id in class_ids:\r\n\r\n        ids = open(os.path.join(directory_shapenet_id, '%s_trainids.txt' % class_id), 'w+').readlines()\r\n        ids += open(os.path.join(directory_shapenet_id, '%s_valids.txt' % class_id), 'w+').readlines()\r\n        ids += open(os.path.join(directory_shapenet_id, '%s_testids.txt' % class_id), 'w+').readlines()\r\n        obj_ids = [i.strip().split('\/')[-1] for i in ids if len(i.strip()) != 0]\r\n\r\n        for i, obj_id in enumerate(obj_ids):\r\n            print('rendering: %s %d \/ %d' % (class_id, i, len(obj_ids)))\r\n\r\n            directory = directory_rendering % (IMAGE_SIZE, DISTANCE, class_id, obj_id)\r\n            directory_tmp = directory + '_'\r\n            if os.path.exists(directory):\r\n                continue\r\n            if os.path.exists(directory_tmp):\r\n                continue\r\n            try:\r\n                os.makedirs(directory_tmp)\r\n            except:\r\n                continue\r\n\r\n            clear()\r\n            setup()\r\n            load_obj(filename_shapenet_obj % (class_id, obj_id))\r\n            render(directory_tmp)\r\n            try:\r\n                os.rename(directory_tmp, directory)\r\n            except:\r\n                continue\r\n\r\n\r\nrun()\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_119","text":"# -*- coding: utf-8 -*-\n\n\"\"\"Main module.\"\"\"\nimport numpy as np\nimport scipy.stats as ss\nimport matplotlib.pyplot as plt\nimport argparse\n\n\ndef getinput():\n    input = argparse.ArgumentParser()\n    input.add_argument('--initial_position', type = float, default = 0, help = 'Initial position of the particle, default = 0' )\n    input.add_argument('--initial_velocity', type = float, default = 0, help = 'Initial velocity of the particle, default = 0' )\n    input.add_argument('--temperature', type = float, default = 300, help = 'Temperature of the molecule, default = 300' )\n    input.add_argument('--damping_coefficient', type = float, default = 0.1, help = 'Damping Coefficient of the molecule, default = 0.1' )\n    input.add_argument('--time_step', type = float, default = 0.2, help = 'Time interval of the simulation, default = 0.01' )\n    input.add_argument('--wall_size', type = float, default = 5, help = 'Wall size of the simulation, default = 5' )\n    input.add_argument('--total_time', type = float, default = 1000, help = 'Total time of the simulation, default = 1000' )\n    inp = input.parse_args()\n    return inp\n\ndef acceleration(gamma=0.1,velocity=0,temperature=300,timestep=0.1,mass=1):\n    sigma=np.sqrt(2*temperature*gamma*1*timestep)\n    return (-gamma*velocity\/mass + np.random.normal(0,sigma))*timestep\n\ndef checkwall(position, wallsize):\n    if position >= wallsize or position<=0:\n        return True\n    else:\n        return False\n    \n\ndef lgmotion(velocity,timestep):\n    return velocity*timestep\n\ndef integrate(position=0,velocity=0,temperature=300,gamma=0.1,timestep=0.1,wallsize=5,totaltime=1000,mass=1):\n    \n    timepass=0\n    indexnum=0\n    index=[]\n    \n    while timepass < totaltime :\n        indexnum +=1\n        index.append([indexnum,timepass,position,velocity])\n        timepass+=timestep\n        velocity += acceleration(gamma, velocity, temperature, timestep)\n        position += lgmotion(velocity, timestep)\n        if checkwall(position,wallsize):\n            if position >= wallsize:\n                position = wallsize\n                index.append([indexnum+1,timepass,position,velocity])\n            else:\n                position= 0\n                index.append([indexnum+1,timepass,position,velocity])\n            break\n        \n    return timepass,index\n\n\ndef filecreation(index):\n    indexf=np.array(index)\n    timef=indexf[:,1]\n    positionf=indexf[:,2]\n    velocityf=indexf[:,3]\n    with open('Langevin_Motion.txt','w+') as file:\n        file.write('Index Time Position Velocity \\n')\n        for i in range(len(timef)):\n            file.write('{}  {:.3f}  {:.5f}  {:.5f} \\n'.format(i,timef[i],positionf[i],velocityf[i]))\n\ndef histogram(arr):\n    plt.figure(0)\n    plt.hist(arr,bins=20)\n    plt.title('100 runs of Langevin Motion')\n    plt.xlabel('Time passed')\n    plt.ylabel('Number of runs')\n    plt.savefig('histogram.png')\n\ndef trajectory(x,y):\n    plt.figure(1)\n    plt.plot(x,y)\n    plt.title('Position vs Time')\n    plt.xlabel('Time passed')\n    plt.ylabel('Position')\n    plt.savefig('trajectory.png')\n\n\ndef main():\n    #get input for simulation\n    inp=getinput()\n    \n    #run for 100 times, collecting all the relavant data\n\n    t_arr=[] #time\n    for i in range(100):\n        t,idx=integrate(position=inp.initial_position,velocity=inp.initial_velocity,temperature=inp.temperature,gamma=inp.damping_coefficient,timestep=inp.time_step,wallsize=inp.wall_size,totaltime=inp.total_time,mass=1)\n        t_arr.append(t)\n    \n    \n    #plot the histogram of 100 runs\n    histogram(t_arr)\n\n    #plot the position vs time plot of the last run\n    trjdata=np.array(idx)\n    xdata=trjdata[:,1]\n    ydata=trjdata[:,2]\n    trajectory(xdata,ydata)\n\n    #write the index in to a txt file of the first run\n    filecreation(idx)\n\nif __name__ == '__main__':\n    main()\n\n    \n\n\n    \n    \n\n\n\n\n\n\n\n        \n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_120","text":"<gh_stars>0\nimport numpy as np\nfrom scipy import interpolate\nimport os\nimport sys\nimport subprocess\nimport abc\nfrom six import with_metaclass\n\ntry:\n    devnull = open(os.devnull, 'w')\n    subprocess.call(['gnuplot', '--version'], stdout=devnull, stderr=devnull)\n    import gnuplotpy as gp\n    MPL = False\nexcept:\n    import matplotlib.pylab as plt\n    MPL = True\n\ndef use_gnuplot():\n    \"\"\"\n    Use gnuplot as the plotting tool for any structure related outputs.\n    \"\"\"\n    global gp\n    import gnuplotpy as gp\n    global MPL\n    MPL = False\n\ndef use_matplotlib():\n    \"\"\"\n    Use matplotlib as the plotting tool for any structure related outputs.\n    \"\"\"\n    global plt\n    import matplotlib.pylab as plt\n    global MPL\n    MPL = True\n\nclass _AbstractStructure(with_metaclass(abc.ABCMeta)):\n    @abc.abstractproperty\n    def n(self):\n        '''\n        np.array: A grid of refractive indices representing\n        the refractive index profile of the structure.\n        '''\n        pass\n\n    @property\n    def x_pts(self):\n        '''\n        int: The number of grid points in x.\n        '''\n        return int((self.x_max - self.x_min) \/ self.x_step + 1)\n\n    @property\n    def y_pts(self):\n        '''\n        int: The number of grid points in y.\n        '''\n        return int((self.y_max - self.y_min) \/ self.y_step)\n\n    @property\n    def x_ctr(self):\n        '''\n        float: The centre distance in x.\n        '''\n        return 0.5*(self.x_max + self.x_min)\n\n    @property\n    def y_ctr(self):\n        '''\n        float: The centre distance in y\n        '''\n        return 0.5*(self.y_max + self.y_min)\n\n    @property\n    def xc(self):\n        '''\n        np.array: The centre points of the x points.\n        '''\n        return 0.5*(self.x[1:] + self.x[:-1])\n\n    @property\n    def yc(self):\n        '''\n        np.array: The centre points of the y points.\n        '''\n        return 0.5*(self.y[1:] + self.y[:-1])\n\n    @property\n    def xc_pts(self):\n        '''\n        int: The number of points in `xc`.\n        '''\n        return self.x_pts - 1\n\n    @property\n    def yc_pts(self):\n        '''\n        int: The number of points in `yc`.\n        '''\n        return self.y_pts - 1\n\n    @property\n    def xc_min(self):\n        '''\n        float: The minimum value of `xc`.\n        '''\n        return self.xc[0]\n\n    @property\n    def xc_max(self):\n        '''\n        float: The maximum value of `xc`.\n        '''\n        return self.xc[-1]\n\n    @property\n    def yc_min(self):\n        '''\n        float: The minimum value of `yc`.\n        '''\n        return self.yc[0]\n\n    @property\n    def yc_max(self):\n        '''\n        float: The maximum value of `yc`.\n        '''\n        return self.yc[-1]\n\n    @property\n    def x(self):\n        '''\n        np.array: The grid points in x.\n        '''\n        if None not in (self.x_min, self.x_max, self.x_step) and \\\n                self.x_min != self.x_max:\n            x = np.arange(self.x_min, self.x_max+self.x_step-self.y_step*0.1, self.x_step)\n        else:\n            x = np.array([])\n        return x\n\n    @property\n    def y(self):\n        '''\n        np.array: The grid points in y.\n        '''\n        if None not in (self.y_min, self.y_max, self.y_step) and \\\n                self.y_min != self.y_max:\n            y = np.arange(self.y_min, self.y_max-self.y_step*0.1, self.y_step)\n        else:\n            y = np.array([])\n        return y\n\n    @property\n    def eps(self):\n        '''\n        np.array: A grid of permittivies representing\n        the permittivity profile of the structure.\n        '''\n        return self.n**2\n\n    @property\n    def eps_func(self):\n        '''\n        function: a function that when passed a `x` and `y` values,\n            returns the permittivity profile of the structure,\n            interpolating if necessary.\n        '''\n        interp_real = interpolate.interp2d(self.x, self.y, self.eps.real)\n        interp_imag = interpolate.interp2d(self.x, self.y, self.eps.imag)\n        interp = lambda x, y: interp_real(x, y) + 1.j*interp_imag(x, y)\n        return interp\n\n    @property\n    def n_func(self):\n        '''\n        function: a function that when passed a `x` and `y` values,\n            returns the refractive index profile of the structure,\n            interpolating if necessary.\n        '''\n        return interpolate.interp2d(self.x, self.y, self.n)\n\n    def _add_triangular_sides(self, xy_mask, angle, y_top_right, y_bot_left,\n                              x_top_right, x_bot_left, n_material):\n        angle = np.radians(angle)\n        trap_len = (y_top_right - y_bot_left) \/ np.tan(angle)\n        num_x_iterations = trap_len \/ self.x_step\n        y_per_iteration =  num_x_iterations \/ self.y_pts\n\n        lhs_x_start_index = int(x_bot_left\/ self.x_step + 0.5)\n        rhs_x_stop_index = int(x_top_right\/ self.x_step + 1 + 0.5)\n\n        running_removal_float = y_per_iteration\n        for i, _ in enumerate(xy_mask):\n            if running_removal_float >= 1:\n                removal_int = int(round(running_removal_float))\n                lhs_x_start_index -= removal_int\n                rhs_x_stop_index += removal_int\n                running_removal_float -= removal_int\n            running_removal_float += y_per_iteration\n\n            xy_mask[i][:lhs_x_start_index] = False\n            xy_mask[i][lhs_x_start_index:rhs_x_stop_index] = True\n\n        self.n[xy_mask] = n_material\n        return self.n\n\n    def _add_material(self, x_bot_left, y_bot_left, x_top_right, y_top_right,\n                     n_material, angle=0):\n        '''\n        A low-level function that allows writing a rectangle refractive\n        index profile to a `Structure`.\n\n        Args:\n            x_bot_left (float): The bottom-left x-coordinate of the\n                rectangle.\n            y_bot_left (float): The bottom-left y-coordinate of the\n                rectangle.\n            x_top_right (float): The top-right x-coordinate of the\n                rectangle.\n            y_top_right (float): The top-right y-coordinate of the\n                rectangle.\n            n_material (float): The refractive index of the points\n                encompassed by the defined rectangle.\n            angle (float): The angle in degrees of the sidewalls\n                of the defined rectangle.  Default is 0.  This\n                is useful for creating a ridge with angled\n                sidewalls.\n        '''\n        x_mask = np.logical_and(x_bot_left<=self.x, self.x<=x_top_right)\n        y_mask = np.logical_and(y_bot_left<=self.y, self.y<=y_top_right)\n\n        xy_mask = np.kron(y_mask, x_mask).reshape((y_mask.size, x_mask.size))\n        self.n[xy_mask] = n_material\n\n        if angle:\n            self._add_triangular_sides(xy_mask, angle, y_top_right, y_bot_left,\n                                       x_top_right, x_bot_left, n_material)\n\n        return self.n\n\n    def write_to_file(self, filename='material_index.dat', plot=True):\n        '''\n        Write the refractive index profile to file.\n\n        Args:\n            filename (str): The nominal filename the refractive\n                index data should be saved to.\n            plot (bool): `True` if plots should be generates,\n                otherwise `False`.  Default is `True`.\n        '''\n        path = os.path.dirname(sys.modules[__name__].__file__) + '\/'\n\n        with open(filename, 'w') as fs:\n            for n_row in np.abs(self.n[::-1]):\n                n_str = ','.join([str(v) for v in n_row])\n                fs.write(n_str+'\\n')\n\n        if plot:\n            filename_image_prefix, _ = os.path.splitext(filename)\n            filename_image = filename_image_prefix + '.png'\n            args = {\n                'title': 'Refractive Index Profile',\n                'x_pts': self.x_pts,\n                'y_pts': self.y_pts,\n                'x_min': self.x_min,\n                'x_max': self.x_max,\n                'y_min': self.y_min,\n                'y_max': self.y_max,\n                'filename_data': filename,\n                'filename_image': filename_image\n            }\n\n            if MPL:\n                heatmap = np.loadtxt(args['filename_data'], delimiter=',')\n                structure_plot = plt.figure()\n                plt.clf()\n                plt.title(args['title'])\n                plt.xlabel('$x$')\n                plt.ylabel('$y$')\n                plt.imshow(np.flipud(heatmap),\n                           extent=(args['x_min'], args['x_max'], args['y_min'], args['y_max']),\n                           aspect=\"auto\")\n                plt.colorbar()\n                plt.savefig(filename_image)\n                #plt.show()\n                print(\"Returning structure plot\")\n                return structure_plot\n            else:\n                print(\"using gnu plot\")\n                gp.gnuplot(path+'structure.gpi', args)\n\n    def __str__(self):\n        return self.n.__str__()\n\nclass Structure(_AbstractStructure):\n    def __init__(self, x_step, y_step, x_max, y_max, x_min=0., y_min=0.,\n                 n_background=1.):\n        self.x_min = x_min\n        self.x_max = x_max\n        self.y_min = y_min\n        self.y_max = y_max\n        self.x_step = x_step\n        self.y_step = y_step\n        self.n_background = n_background\n        self._n = np.ones((self.y.size,self.x.size), 'complex_') * n_background\n\n    @property\n    def n(self):\n        return self._n\n\nclass Slabs(_AbstractStructure):\n    '''\n    Class to implement device refractive index\n    profile cross-section designs.\n\n    :class:`Slabs` is a collection of :class:`Slab` objects.  Each\n    slab has a fixed height (usually less than the\n    maximum height of the desired simulation window),\n    and is as wide as the simulation window.\n\n    :class:`Slabs` objects can be index using `[name]` to return\n    the various :class:`Slab` objects.  The bottom slab is\n    returned first and so on up to the top slab.\n\n    .. image:: ..\/images\/slabs.svg\n        :width: 200%\n\n    Args:\n        wavelength (float): The wavelength the structure\n            operates at.\n        y_step (float): The step in y.\n        x_step (float): The step in x.\n        x_max (float): The maximum x-value.\n        x_min (float): The minimum x-value. Default is 0.\n\n    Attributes:\n        slabs (dict): The key is the name of the slab,\n            and the value is the :class:`Slab` object.\n        slab_count (int): The number of :class:`Slab` objects\n            added so far.\n    '''\n    def __init__(self, wavelength, y_step, x_step, x_max, x_min=0.):\n        _AbstractStructure.__init__(self)\n\n        self._wl = wavelength\n        self.x_min = x_min\n        self.x_max = x_max\n        self.x_step = x_step\n        self.y_step = y_step\n        self.y_min = 0\n\n        self.slabs = {}\n        self.slab_count = 0\n        self._next_start = 0.\n\n    def add_slab(self, height, n_background=1., position='top'):\n        '''\n        Creates and adds a :class:`Slab` object.\n\n        Args:\n            height (float): Height of the slab.\n            n_background (float): The nominal refractive\n                index of the slab.  Default is 1 (air).\n\n        Returns:\n            str: The name of the slab.\n        '''\n        assert position in ('top', 'bottom')\n\n        name = str(self.slab_count)\n\n        if not callable(n_background):\n            n_back = lambda wl: n_background\n        else:\n            n_back = n_background\n\n        height_discretised = self.y_step*((height \/\/ self.y_step) + 1)\n\n        y_min = self._next_start\n        y_max = y_min + height_discretised\n        self.slabs[name] = Slab(name, self.x_step, self.y_step, self.x_max,\n                                 y_max, self.x_min, y_min, n_back, self._wl)\n\n        self.y_max = y_max\n        self._next_start = y_min + height_discretised\n        self.slab_count += 1\n\n        if position == 'bottom':\n            slabs = {}\n            for k in self.slabs.keys():\n                slabs[str(int(k)+1)] = self.slabs[k]\n            slabs['0'] = slabs.pop(str(self.slab_count))\n            self.slabs = slabs\n\n        return name\n\n    def change_wavelength(self, wavelength):\n        '''\n        Changes the wavelength of the structure.\n\n        This will affect the mode solver and potentially\n        the refractive indices used (provided functions\n        were provided as refractive indices).\n\n        Args:\n            wavelength (float): The new wavelength.\n        '''\n        for name, slab in self.slabs.items():\n            const_args = slab._const_args\n            mat_args = slab._mat_params\n\n            const_args[8] = wavelength\n\n            s = Slab(*const_args)\n            for mat_arg in mat_args:\n                s.add_material(*mat_arg)\n\n            self.slabs[name] = s\n\n        self._wl = wavelength\n\n    @property\n    def n(self):\n        '''\n        np.array: The refractive index profile matrix\n        of the current slab.\n        '''\n        try:\n            n_mat = self.slabs['0'].n\n            for s in range(1, self.slab_count):\n                n_mat = np.vstack((self.slabs[str(s)].n, n_mat))\n        except KeyError:\n            n_mat = None\n        return n_mat\n\n    def __getitem__(self, slab_name):\n        return self.slabs[str(slab_name)]\n\nclass Slab(Structure):\n    '''\n    A :class:`Slab` represents a horizontal slice of\n    the refractive index profile.\n\n    A :class:`Slabs` object composes many :class:`Slab` objects.\n    The more :class:`Slab` are added, the more horizontal\n    slices are added.  A :class:`Slab` has a chosen fixed\n    height, and a background (nominal) refractive\n    index.  A slab can then be customised to include\n    a desired design.\n\n    Args:\n        name (str): The name of the slab.\n        x_step (float): The step in x.\n        y_step (float): The step in y.\n        x_max (float): The maximum x-value.\n        y_max (float): The maximum y-value.\n        x_min (float): The minimum x-value.\n        y_min (float): The minimum x-value.\n        n_background (float): The nominal refractive\n            index.\n        wavelength (float): The wavelength the structure\n            operates at.\n\n    Attributes:\n        name (str): The name of the :class:`Slab` object.\n        position (int): A unique identifier for the\n        :class:`Slab` object.\n    '''\n    position = 0\n\n    def __init__(self, name, x_step, y_step, x_max, y_max, x_min, y_min,\n                 n_background, wavelength):\n        self._wl = wavelength\n        self.name = name\n        self.position = Slab.position\n        Slab.position += 1\n\n        Structure.__init__(self, x_step, y_step, x_max, y_max, x_min, y_min,\n                           n_background(self._wl))\n\n        self._const_args = [name, x_step, y_step, x_max, y_max, x_min, y_min, n_background, wavelength]\n        self._mat_params = []\n\n    def add_material(self, x_min, x_max, n, angle=0):\n        '''\n        Add a refractive index between two x-points.\n\n        Args:\n            x_min (float): The start x-point.\n            x_max (float): The stop x-point.\n            n (float, function):  Refractive index between\n                 `x_min` and `x_max`.  Either a constant (`float`), or\n                 a function that accepts one parameters, the\n                 wavelength, and returns a float of the refractive\n                 index.  This is useful when doing wavelength\n                 sweeps and solving for the group velocity.  The\n                 function provided could be a Sellmeier equation.\n            angle (float): Angle in degrees of the slope of the\n                sidewalls at `x_min` and `x_max`.  This is useful\n                for defining a ridge with angled sidewalls.\n        '''\n        self._mat_params.append([x_min, x_max, n, angle])\n\n        if not callable(n):\n            n_mat = lambda wl: n\n        else:\n            n_mat = n\n\n        Structure._add_material(self, x_min, self.y_min, x_max, self.y_max, n_mat(self._wl), angle)\n        return self.n\n\nclass StructureAni():\n    r\"\"\"\n    Anisottropic structure object.\n\n    This is used with the fully-vectorial simulation when\n    an anisotropic material is being used.\n\n    The form of the refractive index is\n\n    .. math::\n\n        n = \\begin{bmatrix}\n                n_{xx} & n_{xy} & 0 \\\\\n                n_{yx} & n_{yy} & 0 \\\\\n                0      & 0      & n_{zz}\n            \\end{bmatrix}.\n\n    Args:\n        structure_xx (Structure): The structure with refractive\n            index, :math:`n_{xx}`.\n        structure_yy (Structure): The structure with refractive\n            index, :math:`n_{yy}`.  Presumably the same structure\n            as `structure_xx`, but with different refractive index\n            parameters.\n        structure_zz (Structure): The structure with refractive\n            index, :math:`n_{zz}`.  Presumably the same structure\n            as `structure_xx`, but with different refractive index\n            parameters.\n        structure_xy (None, Structure): The structure with refractive\n            index, :math:`n_{yx}`.  Presumably the same structure\n            as `structure_xx`, but with different refractive index\n            parameters.  Default is `None`.\n        structure_yx (None, Structure): The structure with refractive\n            index, :math:`n_{yx}`.  Presumably the same structure\n            as `structure_xx`, but with different refractive index\n            parameters.  Default is `None`.\n    \"\"\"\n    def __init__(self, structure_xx, structure_yy, structure_zz,\n                 structure_xy=None, structure_yx=None):\n        self.xx = structure_xx\n        self.yy = structure_yy\n        self.zz = structure_zz\n\n        if not structure_xy or not structure_yx:\n            struct_dummy = Structure(self.xx.x_step, self.xx.y_step,\n                                     self.xx.x_max, self.xx.y_max,\n                                     self.xx.x_min, self.xx.y_min,\n                                     n_background=0.)\n            struct_dummy._wl = self.xx._wl\n\n        if structure_xy:\n            self.xy = structure_xy\n        else:\n            self.xy = struct_dummy\n\n        if structure_yx:\n            self.yx = structure_yx\n        else:\n            self.yx = struct_dummy\n\n        assert self.xx._wl == self.xy._wl == self.yx._wl == \\\n               self.yy._wl == self.zz._wl\n\n        self._wl = structure_xx._wl\n\n        self.axes = (self.xx, self.xy, self.yx, self.yy, self.zz)\n        self.axes_str = ('xx', 'xy', 'yx', 'yy', 'zz')\n\n    @property\n    def n(self):\n        return [a.n for a in self.axes]\n\n    @property\n    def x_step(self):\n        return self.xx.x_step\n\n    @property\n    def y_step(self):\n        return self.xx.y_step\n\n    @property\n    def x_pts(self):\n        return int((self.xx.x_max - self.xx.x_min) \/ self.xx.x_step + 1)\n\n    @property\n    def y_pts(self):\n        return int((self.xx.y_max - self.xx.y_min) \/ self.xx.y_step)\n\n    @property\n    def x_ctr(self):\n        return 0.5*(self.xx.x_max + self.xx.x_min)\n\n    @property\n    def y_ctr(self):\n        return 0.5*(self.xx.y_max + self.xx.y_min)\n\n    @property\n    def xc(self):\n        return 0.5*(self.xx.x[1:] + self.xx.x[:-1])\n\n    @property\n    def yc(self):\n        return 0.5*(self.xx.y[1:] + self.xx.y[:-1])\n\n    @property\n    def xc_pts(self):\n        return self.xx.x_pts - 1\n\n    @property\n    def yc_pts(self):\n        return self.xx.y_pts - 1\n\n    @property\n    def xc_min(self):\n        return self.xx.xc[0]\n\n    @property\n    def xc_max(self):\n        return self.xx.xc[-1]\n\n    @property\n    def yc_min(self):\n        return self.xx.yc[0]\n\n    @property\n    def yc_max(self):\n        return self.xx.yc[-1]\n\n    @property\n    def x(self):\n        if None not in (self.xx.x_min, self.xx.x_max, self.xx.x_step) and \\\n                self.xx.x_min != self.xx.x_max:\n            x = np.arange(self.xx.x_min, self.xx.x_max+self.xx.x_step-self.xx.y_step*0.1, self.xx.x_step)\n        else:\n            x = np.array([])\n        return x\n\n    @property\n    def y(self):\n        if None not in (self.xx.y_min, self.xx.y_max, self.xx.y_step) and \\\n                self.xx.y_min != self.xx.y_max:\n            y = np.arange(self.xx.y_min, self.xx.y_max-self.xx.y_step*0.1, self.xx.y_step)\n        else:\n            y = np.array([])\n        return y\n\n    @property\n    def eps(self):\n        eps_ani = [a.n**2 for a in self.axes]\n        return eps_ani\n\n    @property\n    def eps_func(self):\n        return lambda x,y: tuple(axis.eps_func(x,y) for axis in self.axes)\n\n    @property\n    def n_func(self):\n        return lambda x,y: tuple(axis.n_func(x,y) for axis in self.axes)\n\n    def write_to_file(self, filename='material_index.dat', plot=True):\n        '''\n        Write the refractive index profile to file.\n\n        Args:\n            filename (str): The nominal filename the refractive\n                index data should be saved to.\n            plot (bool): `True` if plots should be generates,\n                otherwise `False`.  Default is `True`.\n        '''\n        path = os.path.dirname(sys.modules[__name__].__file__) + '\/'\n\n        dir_plot = 'material_index\/'\n        if not os.path.exists(dir_plot):\n            os.makedirs(dir_plot)\n\n        for axis, name in zip(self.axes, self.axes_str):\n            root, ext = os.path.splitext(filename)\n            fn = dir_plot + root + '_'+ name + ext\n            with open(fn, 'w') as fs:\n                for n_row in np.abs(axis.n[::-1]):\n                    n_str = ','.join([str(v) for v in n_row])\n                    fs.write(n_str+'\\n')\n\n            if plot:\n                filename_image_prefix, _ = os.path.splitext(fn)\n                filename_image = filename_image_prefix + '.png'\n                args = {\n                    'title': 'Refractive Index Profile: %s' % name,\n                    'x_pts': self.xx.x_pts,\n                    'y_pts': self.xx.y_pts,\n                    'x_min': self.xx.x_min,\n                    'x_max': self.xx.x_max,\n                    'y_min': self.xx.y_min,\n                    'y_max': self.xx.y_max,\n                    'filename_data': fn,\n                    'filename_image': filename_image\n                }\n                if MPL:\n                    heatmap = np.loadtxt(args['filename_data'], delimiter=',')\n                    plt.clf()\n                    plt.title(args['title'])\n                    plt.xlabel('$x$')\n                    plt.ylabel('$y$')\n                    plt.imshow(np.flipud(heatmap),\n                               extent=(args['x_min'], args['x_max'], args['y_min'], args['y_max']),\n                               aspect=\"auto\")\n                    plt.colorbar()\n                    plt.savefig(filename_image)\n                else:\n                    gp.gnuplot(path+'structure.gpi', args, silent=False)\n\n    def change_wavelength(self, wavelength):\n        '''\n        Changes the wavelength of the structure.\n\n        This will affect the mode solver and potentially\n        the refractive indices used (provided functions\n        were provided as refractive indices).\n\n        Args:\n            wavelength (float): The new wavelength.\n        '''\n        for axis in self.axes:\n            if issubclass(type(axis), Slabs):\n                axis.change_wavelength(wavelength)\n        self.xx, self.xy, self.yx, self.yy, self.zz = self.axes\n        self._wl = wavelength\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_121","text":"# -*- coding: utf-8 -*-\nimport numpy as np\nimport cvxpy as cp\nimport random\nimport time\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.neighbors import KernelDensity\nfrom sklearn.mixture import GaussianMixture\nfrom sklearn.model_selection import GridSearchCV, KFold\nfrom sklearn.decomposition import PCA\nfrom sklearn.datasets import load_iris, load_digits, load_breast_cancer, load_boston, load_wine\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.utils import shuffle\n\nfrom plausible_counterfactuals import HighDensityEllipsoids, PlausibleCounterfactualOfHyperplaneClassifier, PlausibleCounterfactualOfDecisionTree\n\n\ndef load_house_prices(file_path=\"housepricesdataset.npz\"):\n    X, y = load_boston(return_X_y=True)\n    y = y >= 20\n    y = y.astype(np.int).flatten()\n\n    return X, y\n\n\nif __name__ == \"__main__\":\n    use_decision_tree = False   # If False, softmax regression is used!\n\n    # Load data set\n    X, y = load_iris(return_X_y=True);pca_dim=None\n    #X, y = load_breast_cancer(return_X_y=True);pca_dim=5\n    #X, y = load_house_prices();pca_dim=10\n    #X, y = load_wine(return_X_y=True);pca_dim=8\n    X, y = load_digits(return_X_y=True);pca_dim=40\n\n    X, y = shuffle(X, y, random_state=42)\n\n    # k-fold cross validation\n    scores_with_density_constraint = []\n    scores_without_density_constraint = []\n\n    original_data = []\n    original_data_labels = []\n    cfs_with_density_constraint = []\n    cfs_without_density_constraint = []\n    cfs_target_label = []\n    computation_time_without_density_constraint = []\n    computation_time_with_density_constraint = []\n    distances_with_density_constraint = []\n    distances_without_density_constraint = []\n\n    kf = KFold(n_splits=5, random_state=42)\n    for train_index, test_index in kf.split(X):\n        # Split data into training and test set\n        X_train, X_test = X[train_index], X[test_index]\n        y_train, y_test = y[train_index], y[test_index]\n\n        # Choose target labels\n        y_test_target = []\n        labels = np.unique(y)\n        for i in range(X_test.shape[0]):\n            y_test_target.append(random.choice(list(filter(lambda l: l != y_test[i], labels))))\n        y_test_target = np.array(y_test_target)\n\n        # If requested: Reduce dimensionality\n        X_train_orig = np.copy(X_train)\n        X_test_orig = np.copy(X_test)\n        projection_matrix = None\n        projection_mean_sub = None\n        pca = None\n        if pca_dim is not None:\n            pca = PCA(n_components=pca_dim)\n            pca.fit(X_train)\n\n            projection_matrix = pca.components_ # Projection matrix\n            projection_mean_sub = pca.mean_\n\n            X_train = np.dot(X_train - projection_mean_sub, projection_matrix.T)\n            X_test = np.dot(X_test - projection_mean_sub, projection_matrix.T)\n\n        # Fit classifier\n        model = LogisticRegression(multi_class=\"multinomial\", solver=\"lbfgs\", random_state=42)\n        if use_decision_tree is True:\n            model = DecisionTreeClassifier(max_depth=7, random_state=42)\n        model.fit(X_train, y_train)\n\n        # Compute accuracy on test set\n        print(\"Accuracy: {0}\".format(accuracy_score(y_test, model.predict(X_test))))\n\n        # For each class, fit density estimators\n        density_estimators = {}\n        kernel_density_estimators = {}\n        labels = np.unique(y)\n        for label in labels:\n            # Get all samples with the 'correct' label\n            idx = y_train == label\n            X_ = X_train[idx, :]\n\n            # Optimize hyperparameters\n            cv = GridSearchCV(estimator=KernelDensity(), iid=False, param_grid={'bandwidth': np.arange(0.1, 10.0, 0.05)}, n_jobs=-1, cv=5)\n            cv.fit(X_)\n            bandwidth = cv.best_params_[\"bandwidth\"]\n            print(\"bandwidth: {0}\".format(bandwidth))\n\n            cv = GridSearchCV(estimator=GaussianMixture(covariance_type='full'), iid=False, param_grid={'n_components': range(2, 10)}, n_jobs=-1, cv=5)\n            cv.fit(X_)\n            n_components = cv.best_params_[\"n_components\"]\n            print(\"n_components: {0}\".format(n_components))\n\n            # Build density estimators\n            kde = KernelDensity(bandwidth=bandwidth)\n            kde.fit(X_)\n\n            de = GaussianMixture(n_components=n_components, covariance_type='full', random_state=42)\n            de.fit(X_)\n\n            density_estimators[label] = de\n            kernel_density_estimators[label] = kde\n\n        # For each point in the test set\n        # Compute and plot counterfactual without density constraints\n        print(\"n_test_samples: {0}\".format(X_test.shape[0]))\n        for i in range(X_test.shape[0]):\n            x_orig = X_test[i,:]\n            x_orig_orig = X_test_orig[i,:]\n            y_orig = y_test[i]\n            y_target = y_test_target[i]\n\n            if(model.predict([x_orig]) == y_target):  # Model already predicts target label!\n                print(\"Requested prediction already satisfied\")\n                continue\n\n            # Compute and plot counterfactual WITH kernel density constraints\n            idx = y_train == y_target\n            X_ = X_train[idx, :]\n\n            # Build density estimator\n            de = density_estimators[y_target]\n            kde = kernel_density_estimators[y_target]\n\n            # Compute media NLL of training samples\n            # TODO: Move this to the outer loop\n            from scipy.stats import multivariate_normal\n            densities_training_samples = []\n            densities_training_samples_ex = []\n            for j in range(X_.shape[0]):\n                x = X_[j,:]\n                z = []\n                dim = x.shape[0]\n                for i in range(de.weights_.shape[0]):\n                    x_i = de.means_[i]\n                    w_i = de.weights_[i]\n                    cov = de.covariances_[i]\n                    cov = np.linalg.inv(cov)\n\n                    b = -2.*np.log(w_i) + dim*np.log(2.*np.pi) - np.log(np.linalg.det(cov))\n                    z.append(np.dot(x - x_i, np.dot(cov, x - x_i)) + b) # NLL\n\n                densities_training_samples.append(np.min(z))\n                densities_training_samples_ex.append(z)\n\n            densities_training_samples = np.array(densities_training_samples)\n            densities_training_samples_ex = np.array(densities_training_samples_ex)\n\n            # Compute soft cluster assignments\n            cluster_prob_ = de.predict_proba(X_)\n            density_threshold = np.median(densities_training_samples)\n            # Compute high density ellipsoids - constraint: test if sample is included in ellipsoid -> this is the same as the proposed constraint but nummerically much more stable, in particular when we add a dimensionality reduction from a high dimensional space to a low dimensional space\n            r = HighDensityEllipsoids(X_, densities_training_samples_ex, cluster_prob_, de.means_, de.covariances_, density_threshold).compute_ellipsoids()\n            \n            # Compute counterfactual without any density\/plausibility\/feasibility constraints\n            xcf_t1 = time.time()\n            cf = None\n            if use_decision_tree is False:\n                cf = PlausibleCounterfactualOfHyperplaneClassifier(model.coef_, model.intercept_, n_dims=X_train.shape[1], density_constraint=False, ellipsoids_r=r, gmm_weights=de.weights_, gmm_means=de.means_, gmm_covariances=de.covariances_, projection_matrix=projection_matrix, projection_mean_sub=projection_mean_sub)\n            else:\n                cf = PlausibleCounterfactualOfDecisionTree(model, n_dims=X_train.shape[1], density_constraint=False, ellipsoids_r=r, gmm_weights=de.weights_, gmm_means=de.means_, gmm_covariances=de.covariances_, projection_matrix=projection_matrix, projection_mean_sub=projection_mean_sub)\n            xcf = cf.compute_counterfactual(x_orig_orig, y=y_target)\n            xcf_t1 = time.time() - xcf_t1\n            if xcf is None:\n                print(\"No counterfactual found!\")\n                continue\n\n            # Compute counterfactul with proposed density constraint\n            xcf_t2 = time.time()\n            cf2 = None\n            if use_decision_tree is False:\n                cf2 = PlausibleCounterfactualOfHyperplaneClassifier(model.coef_, model.intercept_, n_dims=X_train.shape[1], ellipsoids_r=r, gmm_weights=de.weights_, gmm_means=de.means_, gmm_covariances=de.covariances_, projection_matrix=projection_matrix, projection_mean_sub=projection_mean_sub, density_threshold=density_threshold)\n            else:\n                cf2 = PlausibleCounterfactualOfDecisionTree(model, n_dims=X_train.shape[1], ellipsoids_r=r, gmm_weights=de.weights_, gmm_means=de.means_, gmm_covariances=de.covariances_, projection_matrix=projection_matrix, projection_mean_sub=projection_mean_sub, density_threshold=density_threshold)\n            xcf2 = cf2.compute_counterfactual(x_orig_orig, y=y_target)\n            xcf_t2 = time.time() - xcf_t2\n            if xcf2 is None:\n                print(\"No counterfactual found!\")\n                continue\n\n            original_data.append(x_orig_orig)\n            original_data_labels.append(y_orig)\n            cfs_with_density_constraint.append(xcf2)\n            cfs_without_density_constraint.append(xcf)\n            cfs_target_label.append(y_target)\n            computation_time_without_density_constraint.append(xcf_t1)\n            computation_time_with_density_constraint.append(xcf_t2)\n            distances_with_density_constraint.append(np.sum(np.abs(x_orig_orig - xcf2)))\n            distances_without_density_constraint.append(np.sum(np.abs(x_orig_orig - xcf)))\n\n            if pca is not None: # If necessary: Project the counterfactuals to the lower dimensional space where we did the density estimation\n                xcf = pca.transform([xcf])\n                xcf2 = pca.transform([xcf2])\n\n            # Evaluate\n            scores_without_density_constraint.append(kde.score_samples(xcf.reshape(1, -1)))\n            scores_with_density_constraint.append(kde.score_samples(xcf2.reshape(1, -1)))\n\n    # Final evaluation\n    print(\"Without density constrain: Median: {0} Mean: {1} Var: {2}\".format(np.median(scores_without_density_constraint), np.mean(scores_without_density_constraint), np.var(scores_without_density_constraint)))\n    print(\"With density constrain: Median: {0} Mean: {1} Var: {2}\".format(np.median(scores_with_density_constraint), np.mean(scores_with_density_constraint), np.var(scores_with_density_constraint)))\n    \n    print(\"Computation time: With density constraint: {0} Without density constraint: {1}\".format(np.median(computation_time_with_density_constraint), np.median(computation_time_without_density_constraint)))\n    print(\"Distances: With density constraint: {0} {1} Without density constraint: {2} {3}\".format(np.median(distances_with_density_constraint), np.mean(distances_with_density_constraint), np.median(distances_without_density_constraint), np.mean(distances_without_density_constraint)))\n\n    #\"\"\"\n    # Plot some samples: Counterfactual generated with vs. without density constraint\n    original_data = np.array(original_data)\n    original_data_labels = np.array(original_data_labels)\n    cfs_with_density_constraint = np.array(cfs_with_density_constraint)\n    cfs_without_density_constraint = np.array(cfs_without_density_constraint)\n    cfs_target_label = np.array(cfs_target_label)\n    np.savez(\"cfs_comparision_data_softmax_regression\", X_original=original_data, y_original=original_data_labels, y_target=cfs_target_label, X_with_density_constraint=cfs_with_density_constraint, X_without_density_constraint=cfs_without_density_constraint)\n    #\"\"\"\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_122","text":"<gh_stars>1-10\nimport os\nimport scipy.interpolate as spi\n\ndataLabel = [\"one\", \"two\", \"three\", \"four\"]\n\ndataRoot = \"..\/toneclassifier\/train\"\n\nnormalLen = 200\n\nfor label in dataLabel:\n    subsetPath = dataRoot + \"\/\" + label\n    dataset = set()\n    for filename in os.listdir(subsetPath):\n        if filename[0] == \".\":\n            continue\n        if \".engy\" in filename:\n            dataset.add(filename[0:-5])\n        elif \".f0\" in filename:\n            dataset.add(filename[0:-3])\n    try:\n        os.makedirs(\"..\/data-process-output\/trim-interpolation\/train\/\" + label)\n    except OSError as err:\n        pass\n\n    for dataname in dataset:\n        engyfile = open(subsetPath + \"\/\" + dataname + \".engy\", \"r\")\n        f0file = open(subsetPath + \"\/\" + dataname + \".f0\", \"r\")\n        engy = map(float, engyfile.readlines())\n        f0 = map(float, f0file.readlines())\n        engyfile.close()\n        f0file.close()\n\n        start = None\n        end = None\n\n        for i in xrange(len(f0)):\n            if (f0[i] > 1e-5):\n                start = i\n                break\n        for i in xrange(len(f0) - 1, -1, -1):\n            if (f0[i] > 1e-5):\n                end = i + 1\n                break\n        engy = engy[start:end]\n        f0 = f0[start:end]\n\n        dataLen = len(engy)\n        k = float(normalLen - 1) \/ float(dataLen - 1)\n\n        x = [i * k for i in xrange(dataLen)]\n        newX = [i * 1.0 for i in xrange(normalLen)]\n        newX[-1] = x[-1]\n        # tck = spi.splrep(x, engy)\n        # newEngy = spi.splev(newX, tck)\n        # tck = spi.splrep(x, f0)\n        # newF0 = spi.splev(newX, tck)\n        func = spi.interp1d(x, engy, kind='cubic')\n        newEngy = func(newX)\n        func = spi.interp1d(x, f0, kind='cubic')\n        newF0 = func(newX)\n\n        engyfile = open(\"..\/data-process-output\/trim-interpolation\/train\/\" + label + \"\/\" + dataname + \".engy\", \"w\")\n        f0file = open(\"..\/data-process-output\/trim-interpolation\/train\/\" + label + \"\/\" + dataname + \".f0\", \"w\")\n        for i in xrange(normalLen):\n            engyfile.write(\"%.5f\\n\" % newEngy[i])\n            f0file.write(\"%.5f\\n\" % newF0[i])\n        engyfile.close()\n        f0file.close()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_123","text":"import matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport glob\nimport numpy as np\nfrom scipy.optimize import curve_fit\nimport traceback\nfrom lmfit import minimize, Parameters\nfrom uncertainties import ufloat\nimport pandas as pd\nimport Settings\nimport sys\n\n# todo: check program with several different settings\n# todo: solve the problems with manual fitting\n\n# todo: adjust the plotting function to write the parameters better in the tight_layout\n# todo: implement R2' calculations, sorting, and adding them to the plots\n#       R'2 = 1 - MQres\/MQTcorr; MQTcor = SQTcor \/ I-1; MQres = SQres \/ I-p\n#       I: degrees of freedom. p: number of parameters in the model\n#       SQTcor = sum(yi - mean(y)) ^ 2\n#       SQres = chisqr\n# todo: check why the R2 on the automatic linear fit is buggy\n\n# todo: Check the results file, if the correct parameters are being recorded\n# todo: check if converting GP and Eta to ndarrays at the beginning breaks anything.\n\n# todo: Remove the prev_extracted setting and try to guess this parameter\n\n# todo: remove the debugging setting. Just use the debugging tools.\n\nclass Fitter:\n    def __init__(self, filename, settings, do_fit=True):\n        self.VISC_LIMIT = 10000000\n        self.l_first_point = 0\n        self.l_last_point = -1\n        self.nl_first_point = 0\n        self.nl_last_point = -1\n        self.manip = FileManip()\n        self.filename = filename\n        self.settings = settings\n        self.model = self.settings.NL_FITTING_METHOD\n        self.l_R2 = 0\n        self.nl_R2 = 0\n        self.wait = float(settings.WAIT)\n        self.fixed_fp = settings.FIXED_FP_NL\n        if not self.fixed_fp:\n            self.max_fp = int(settings.MAX_FP_NL)\n        else:\n            self.max_fp = 0\n\n        self.lin_done = False\n        self.nl_done = False\n\n        if self.model == 'Cross':\n            #self.param_names = ['eta_0', 'eta_inf', 'GP_b', 'n']\n            self.param_names = 'eta_0 eta_inf GP_b n'\n        elif self.model == 'Carreau':\n            #self.param_names = ['eta_0', 'eta_inf', 'GP_b', 'n']\n            self.param_names = 'eta_0 eta_inf GP_b n'\n        elif self.model == 'Carreau-Yasuda':\n            #self.param_names = ['eta_0', 'eta_inf', 'lambda', 'a', 'n']\n            self.param_names = 'eta_0 eta_inf lambda a n'\n        else:\n            raise NameError(f'Did not understand model {self.model}')\n\n        self.param_names_lin = ['Int', 'Slp']  # todo: check if this is the correct order.\n\n        if self.settings.DO_LIN:\n            self.int = 50\n            self.int_err = 0.1\n            self.slp = 0\n            self.slp_err = 0\n        elif self.settings.DO_NL:\n            if self.model == 'Carreau' or self.model == 'Cross' or self.model == 'Carreau-Yasuda':\n                self.params = [0, 0, 0, 0]\n                self.param_errs = [0, 0, 0, 0]\n            else:\n                raise ValueError(f'Unknown model: {model}')\n\n        try:\n            if self.settings.PREV_EXTRACTED:\n                self.GP, self.Eta = self.manip.ExtractData_pd(filename)\n                self.GP = np.array(self.GP)\n                self.Eta = np.array(self.Eta)\n            else:\n                self.GP, self.Eta = self.manip.ExtractData(filename)\n                self.GP = np.array(self.GP)\n                self.Eta = np.array(self.Eta)\n        except ValueError:\n            self.manip.logger(filename, 'Failed to open')\n            raise ValueError(f'!!!! No Flow Curve data was found! Re-export the data on file{filename}.')\n        except KeyError:\n            self.manip.logger(filename, 'Failed to open')\n            raise ValueError(f'!!!! No Flow Curve data was found! Re-export the data on file{filename}.')\n\n        if len(self.GP) != len(self.Eta):\n            self.manip.logger(self.filename, 'Failed to open')\n            raise ValueError(f'!!!! GP and Eta have different lengths. '\n                             f'Re-export {filename} or fix the problem manually.')\n\n        if do_fit:\n            self._fit()\n\n    def _fit(self):  # Uses fit_curve. Does not provide an R2 value.\n        if self.settings.DO_LIN:\n            if self.settings.AUTO_LIN:\n                self.automatic_lin_fitting(True)\n            else:  # todo: plot, save and ask for the required points\n                self.manual_fit(0, -1, 'Linear')\n        if self.settings.DO_NL:\n            if self.settings.AUTO_NL:\n                self.automatic_nl_fitting(True)\n            else:\n                self.manual_fit(0, -1, self.settings.NL_FITTING_METHOD, True)\n\n    def fit(self):\n        if self.settings.DO_LIN:\n            if self.settings.AUTO_LIN:\n                self.automatic_lin_fitting_lm(True)\n            else:  # todo: plot, save and ask for the required points\n                self.manual_fit(0, -1, 'Linear')\n        if self.settings.DO_NL:\n            if self.settings.AUTO_NL:\n                self.automatic_nl_fitting_lm(True)\n            else:\n                self.manual_fit(0, -1, self.settings.NL_FITTING_METHOD, True)\n\n    @staticmethod\n    def fit_Carreau(GP, eta_0, eta_inf, GP_b, n):\n        \"\"\"Eta = eta_inf + (eta_0 - eta_inf) \/ (1+(GP\/GP_b)**2)**(n\/2)\n        GP_b is a constant with the dimension of time and n is a dimensionless constant\"\"\"\n        return eta_inf + (eta_0 - eta_inf) \/ (1 + (GP \/ GP_b) ** 2) ** (n \/ 2)\n\n    @staticmethod\n    def fit_Cross(GP, eta_0, eta_inf, GP_b, n):\n        return eta_inf + (eta_0 - eta_inf) \/ (1 + (GP \/ GP_b) ** n)\n\n    @staticmethod\n    def fit_PowerLaw(GP, k, n):\n        \"\"\"Power Law: eta = k * GP ** (n-1)\"\"\"\n        return k * GP ** (n - 1)\n\n    @staticmethod\n    def fit_CarreauYasuda(GP, eta_0, eta_inf, lbda, a, n):\n        \"\"\"Carreau-Yasuda: eta(GP) = eta_inf + (eta_0 - eta_inf)(1+(lambda * GP)**a)**((n-1)\/a)\"\"\"\n        return eta_inf + (eta_0 - eta_inf) \/ (1 + (lbda * GP) ** a) ** ((n - 1) \/ a)\n\n    @staticmethod\n    def fit_lin(x, a, b):\n        \"\"\"Simple function for a linear fit, with a as the linear coefficient and b the angular coefficient.\"\"\"\n        return a + b * x\n\n    @staticmethod\n    def carr_uncertainty(GP, eta0, etainf, GPb, n, eta0_err, etainf_err, GPb_err, n_err):\n        \"\"\"Uses the uncertainty package to calculate the Carreau model values. GP\n        can be a numpy array, which returns two lists of values and errors, a float64,\n        float or int and returns a tuple (val, err)\"\"\"\n        f_eta0 = ufloat(eta0, eta0_err)\n        f_etainf = ufloat(etainf, etainf_err)\n        f_GPb = ufloat(GPb, GPb_err)\n        f_n = ufloat(n, n_err)\n        Carr = f_etainf + (f_eta0 - f_etainf) \/ (1 + (GP \/ f_GPb) ** 2) ** (f_n \/ 2)\n\n        # Extracts all val +- err pairs if GP is an ndarray\n        if type(GP) is np.ndarray:\n            Carr_val = [a.nominal_value for a in Carr]\n            Carr_err = [a.std_dev for a in Carr]\n\n        # If GP is numeric, separates the two values.\n        if (type(GP) is np.float64) or (type(GP) is float) or (type(GP) is int):\n            Carr_val = Carr.nominal_value\n            Carr_err = Carr.std_dev\n\n        return Carr_val, Carr_err\n\n    @staticmethod\n    def cross_uncertainty(GP, eta0, etainf, GPb, n, eta0_err, etainf_err, GPb_err, n_err):\n        f_eta0 = ufloat(eta0, eta0_err)\n        f_etainf = ufloat(etainf, etainf_err)\n        f_GPb = ufloat(GPb, GPb_err)\n        f_n = ufloat(n, n_err)\n        Cross = f_etainf + (f_eta0 - f_etainf) \/ (1 + (GP \/ f_GPb) ** f_n)\n\n        # Extracts all val +- err pairs if GP is an ndarray\n        if type(GP) is np.ndarray:\n            Cross_val = [a.nominal_value for a in Cross]\n            Cross_err = [a.std_dev for a in Cross]\n\n        # If GP is numeric, separates the two values.\n        if (type(GP) is np.float64) or (type(GP) is float) or (type(GP) is int):\n            Cross_val = Cross.nominal_value\n            Cross_err = Cross.std_dev\n\n        return Cross_val, Cross_err\n\n    @staticmethod\n    def carryas_uncertainty(GP, eta0, etainf, lbda, a, n, eta0_err, etainf_err, lbda_err, a_err, n_err):\n        f_eta0 = ufloat(eta0, eta0_err)\n        f_etainf = ufloat(etainf, etainf_err)\n        f_n = ufloat(n, n_err)\n        f_lbda = ufloat(lbda, lbda_err)\n        f_a = ufloat(a, a_err)\n        CY = f_etainf + (f_eta0 - f_etainf) * (1 + (f_lbda * GP) ** f_a) ** ((f_n - 1) \/ f_a)\n\n        # Extracts all val +- err pairs if GP is an ndarray\n        if type(GP) is np.ndarray:\n            CY_val = [a.nominal_value for a in CY]\n            CY_err = [a.std_dev for a in CY]\n\n        # If GP is numeric, separates the two values.\n        if (type(GP) is np.float64) or (type(GP) is float) or (type(GP) is int):\n            CY_val = CY.nominal_value\n            CY_err = CY.std_dev\n\n        return CY_val, CY_err\n\n    # todo: alterar o termo int para outro valor para impedir que haja um clash.\n    def lm_curvefit(self, GP, Eta, do_lin=False):\n        params = Parameters()\n        SStot = sum((Eta - np.mean(Eta)) ** 2)\n        if do_lin:  # todo: Check why R2 is very weird here.\n            params.add('Int', 50, vary=True, min=0)\n            params.add('Slp', 0, vary=False)\n            fit = minimize(self.residual_lin, params, args=(GP, Eta))\n            slp = fit.params['Slp'].value\n            int = fit.params['Int'].value\n            slp_err = fit.params['Slp'].stderr\n            int_err = fit.params['Int'].stderr\n            chisqr = fit.chisqr\n            R2 = 1 - fit.chisqr \/ SStot\n            return [slp, int], [slp_err, int_err], R2\n        elif self.model == 'Carreau':\n            params.add('eta_0', 100, vary=True, min=0)\n            params.add('eta_inf', 1, vary=True, min=0)\n            params.add('GP_b', 5, vary=True, min=0)\n            params.add('n', 1, vary=True, min=0)\n            fit = minimize(self.residual, params, args=(GP, Eta))\n            params = [fit.params[par].value for par in fit.params]\n            param_errs = [fit.params[par].stderr for par in fit.params]\n            R2 = 1 - fit.chisqr \/ SStot\n            return params, param_errs, R2\n        elif self.model == 'Cross':\n            params.add('eta_0', 100, vary=True, min=0)\n            params.add('eta_inf', 1, vary=True, min=0)\n            params.add('GP_b', 5, vary=True, min=0)\n            params.add('n', 1, vary=True, min=0)\n            fit = minimize(self.residual, params, args=(GP, Eta))\n            params = [fit.params[par].value for par in fit.params]\n            param_errs = [fit.params[par].stderr for par in fit.params]\n            R2 = 1 - fit.chisqr \/ SStot\n            return params, param_errs, R2\n        elif self.model == 'Carreau-Yasuda':\n            params.add('eta_0', 100, vary=True, min=0)\n            params.add('eta_inf', 1, vary=True, min=0)\n            params.add('lbda', 5, vary=True, min=0)\n            params.add('a', 1, vary=True, min=0)\n            params.add('n', 1, vary=True, min=0)\n            fit = minimize(self.residual, params, args=(GP, Eta))\n            params = [fit.params[par].value for par in fit.params]\n            param_errs = [fit.params[par].stderr for par in fit.params]\n            SSres = fit.chisqr\n            R2 = 1 - SSres \/ SStot\n            return params, param_errs, R2\n\n    def residual(self, params, x, dataset):\n        if self.model == 'Carreau':\n            mod = self.fit_Carreau(x, params['eta_0'], params['eta_inf'], params['GP_b'], params['n'])\n        elif self.model == 'Cross':\n            mod = self.fit_Cross(x, params['eta_0'], params['eta_inf'], params['GP_b'], params['n'])\n        elif self.model == 'Carreau-Yasuda':\n            mod = self.fit_CarreauYasuda(x, params['eta_0'], params['eta_inf'], params['lbda'], params['a'],\n                                         params['n'])\n        resid = dataset - mod\n        return resid\n\n    def residual_lin(self, params, x, dataset):\n        if type(x) == list:\n            x = np.array(x)\n        mod = params['Int'] + params['Slp'] * x\n        resid = dataset - mod\n        return resid\n\n    def automatic_lin_fitting_lm(self, save=True):\n        length = len(self.GP)\n        fittings = []\n\n        # Go through several possible ranges to fit, and fit them, then get the best fit\n        for first_point in range(0, length\/\/3, 1):\n            for last_point in range(first_point + 3, length \/\/ 2, 1):\n                GP_arr = np.array(self.GP[first_point:last_point + 1])  # todo: check if this conversion is necessary\n                Eta_arr = np.array(self.Eta[first_point:last_point + 1])\n                try:\n                    #popt, pcov = curve_fit(self.fit_lin, GP_arr, Eta_arr, p0=(30, 0),\n                    #                   bounds=(0, [self.VISC_LIMIT, 0.0001]))\n                    params, param_errs, R2 = self.lm_curvefit(GP_arr, Eta_arr, do_lin=True)\n                except:  # todo: test here and find what types of errors can occur\n                    print(f'Error while using linear fit for file {self.filename}')\n                    print(traceback.format_exc())\n                    self.manip.logger(self.filename, 'Generic')\n\n                #perr = np.sqrt(np.diag(pcov))\n                fittings.append((first_point, last_point, params, param_errs, R2))\n\n        if self.settings.LIN_SORTING_METHOD == 'by_error':\n            fittings.sort(key=lambda x: np.log(x[3][0]))\n        elif self.settings.LIN_SORTING_METHOD == 'by_error_length':\n            fittings.sort(key=lambda x: np.log(x[2][1]) \/ (x[1] - x[0]))\n        elif self.settings.LIN_SORTING_METHOD == 'by_R2':\n            fittings.sort(key=lambda x: x[4])\n\n        self.l_first_point = fittings[0][0]\n        # todo: add variable names to first and last points of linear and nl\n        self.l_last_point = fittings[0][1]\n        self.int = fittings[0][2][1]\n        self.int_err = fittings[0][3][1]\n        self.l_R2 = fittings[0][4]\n        self.lin_done = True\n\n        if self.settings.DEBUG:\n            print('Debug: fittings_sorted: ', fittings)\n            print('Debug: a: ', self.int)\n            print('Debug: aerr: ', self.int_err)\n\n        if save:\n            self.manip.record_fit('linear', self.int, self.int_err, silent=False,\n                                  extra=f\"{fittings[0][0]};{fittings[0][1]};\")\n            # todo: check how this was done before, for consistency\n\n        return self.int, self.int_err, self.l_R2\n\n    def automatic_lin_fitting(self, save=True):\n        \"\"\"Goes through all the files, fits them and selects the best fit according to two algorithms.\n        First, it selects two points, a beginning and an end point, the first starting at point 0\n        and going to a third of the curve. The second, starting at points to the right,\n        going until the middle of the curve.\n        Then, it fits the data by fixing the slope at 0 and goes through every possible combination\n        of the first and second points.\n        It selects the data based on two criteria:\n        1. sorting = 'by_error': finds the minimal error. Tends to select less points overall and\n            gives a fitting with a less than ideal representation overall.\n        2. sorting = 'by_error_length': divides the error by how many points were used in the fit.\n            May result in a higher overall error, but gives a better representation of the curve.\n        \"\"\"\n\n        length = len(self.GP)\n        fittings = []\n\n        # Go through several possible ranges to fit, and fit them, then get the best fit\n        for first_point in range(0, length\/\/3, 1):\n            for last_point in range(first_point + 3, length \/\/ 2, 1):\n                GP_arr = np.array(self.GP[first_point:last_point + 1])\n                Eta_arr = np.array(self.Eta[first_point:last_point + 1])\n                try:\n                    popt, pcov = curve_fit(self.fit_lin, GP_arr, Eta_arr, p0=(30, 0),\n                                       bounds=(0, [self.VISC_LIMIT, 0.0001]))\n                except:  # todo: test here and find what types of errors can occur\n                    print(f'Error while using linear fit for file {self.filename}')\n                    print(traceback.format_exc())\n                    self.manip.logger(self.filename, 'Generic')\n\n                perr = np.sqrt(np.diag(pcov))\n                fittings.append((first_point, last_point, popt, perr))\n\n        if self.settings.LIN_SORTING_METHOD == 'by_error':\n            fittings.sort(key=lambda x: np.log(x[3][0]))  # gets perr of eta_0\n        elif self.settings.LIN_SORTING_METHOD == 'by_error_length':\n            fittings.sort( key=lambda x: np.log(x[3][0]) \/ (x[1] - x[0]) ) # divides perr by last-first\n\n        self.int = fittings[0][2][0]\n        self.int_err = fittings[0][3][0]\n        self.l_first_point = fittings[0][0]  # todo: add variable names to first and last points of linear and nl\n        self.l_last_point = fittings[0][1]\n        self.lin_done = True\n\n        if self.settings.DEBUG:\n            print('Debug: fittings_sorted: ', fittings)\n            print('Debug: a: ', self.int)\n            print('Debug: aerr: ', self.int_err)\n\n        if save:\n            self.manip.record_fit(self.filename, self.int, self.int_err, silent=False,\n                                  extra=f\"{fittings[0][0]};{fittings[0][1]};\")\n\n        return self.int, self.int_err\n\n    # todo: change from curve_fit to lm_fit.\n    # todo: calculate R2 for all fittings and add it in the end to the class\n    # todo: add options to sort by R2.\n\n    def automatic_nl_fitting_lm(self, save=True):\n        fittings = []\n        try:\n            max_range = len(self.GP) \/\/ self.max_fp\n        except ZeroDivisionError:\n            max_range = 1\n\n        for first_point in range(0, max_range, 1):\n            GP_arr = np.array(self.GP[first_point:])\n            Eta_arr = np.array(self.Eta[first_point:])\n            nonlinear_has_error = ''\n            try:\n                params, param_errs, R2 = self.lm_curvefit(GP_arr, Eta_arr, do_lin=False)\n            except FloatingPointError:  # todo: check if these exceptions work\n                print('!!!! Overflow detected on one of the parameters. Could not determine all parameters')\n                nonlinear_has_error = ';param_overflow_during_fitting'\n                self.manip.logger(self.filename, 'Overflow')\n            except RuntimeError:\n                print('!!!! Overflow detected on one of the parameters. Could not determine all parameters')\n                nonlinear_has_error = ';param_overflow_during_fitting'\n                self.manip.logger(self.filename, 'Overflow')\n            except OverflowError:\n                print('!!!! Overflow detected on one of the parameters.')\n                self.manip.logger(self.filename, 'Overflow')\n\n            fittings.append((first_point, params, param_errs, R2))\n\n        if self.settings.NL_SORTING_METHOD == 'eta_0':\n            fittings.sort(key=lambda x: x[2][0])\n        elif self.settings.NL_SORTING_METHOD == 'overall':\n            # fittings.sort(key=lambda x: x[2][0] + x[2][1] + x[2][2] + x[2][3])\n            fittings.sort(key=lambda x: sum(x[2]))  # sums the errors\n        elif self.settings.NL_SORTING_METHOD == 'R2':\n            fittings.sort(key=lambda x: x[3])\n        else:\n            raise ValueError(f'Could not understand the sorting method {self.settings.NL_SORTING_METHOD}')\n\n        self.nl_first_point = fittings[0][0]\n        self.params = fittings[0][1]\n        self.param_errs = fittings[0][2]\n        self.nl_R2 = fittings[0][3]\n\n        if save:  # todo: check here to return a good destination file\n            try:\n                self.manip.record_fit(\n                    self.filename, self.params[0],\n                    self.param_errs[0], silent=False,\n                    extra=f\"{fittings[0][0]};{fittings[0][1]};nonlinear_auto_{self.settings.NL_FITTING_METHOD};\"\n                          f\"{nonlinear_has_error}\", fdest_name=self.settings.NL_FITTING_METHOD + '.csv'\n                )\n            except UnboundLocalError:\n                print('Unable to write to file because the subroutine did not return the fitting parameters')\n                print(traceback.format_exc())\n                self.manip.record_fit(self.filename, 0, 0, extra=f'nonlinear_auto_{self.settings.NL_FITTING_METHOD};'\n                                                                 f'unable_to_find_viscosity',\n                                      fdest_name=self.settings.NL_FITTING_METHOD + '.csv')\n                self.manip.logger(self.filename, 'No Viscosity')\n\n        self.nl_done = True\n        return self.nl_first_point, self.params, self.param_errs, self.nl_R2\n\n    def automatic_nl_fitting(self, save=True):\n        fittings = []\n        try:\n            max_range = len(self.GP) \/\/ self.max_fp\n        except ZeroDivisionError:\n            max_range = len(self.GP)\n\n        for first_point in range(0, max_range, 1):\n            GP_arr = np.array(self.GP[first_point:])\n            Eta_arr = np.array(self.Eta[first_point:])\n            nonlinear_has_error = ''\n            try:\n                if self.settings.NL_FITTING_METHOD == 'Carreau':\n                    popt, pcov = curve_fit(self.fit_Carreau, GP_arr, Eta_arr, bounds=(0, np.inf))\n                elif self.settings.NL_FITTING_METHOD == 'Cross':\n                    popt, pcov = curve_fit(self.fit_Cross, GP_arr, Eta_arr, bounds=(0, np.inf))\n                elif self.settings.NL_FITTING_METHOD == 'Carreau-Yasuda':\n                    popt, pcov = curve_fit(self.fit_CarreauYasuda, GP_arr, Eta_arr)\n                else:\n                    raise ValueError(f'Model not present: {self.settings.NL_FITTING_METHOD}')\n\n            except FloatingPointError:\n                print('!!!! Overflow detected on one of the parameters. Could not determine all parameters')\n                nonlinear_has_error = ';param_overflow_during_fitting'\n                self.manip.logger(self.filename, 'Overflow')\n                continue\n            except RuntimeError:\n                print('!!!! Overflow detected on one of the parameters. Could not determine all parameters')\n                nonlinear_has_error = ';param_overflow_during_fitting'\n                self.manip.logger(self.filename, 'Overflow')\n                continue\n            except OverflowError:\n                print('!!!! Overflow detected on one of the parameters.')\n                self.manip.logger(self.filename, 'Overflow')\n                continue\n\n            perr = np.sqrt(np.diag(pcov))\n            fittings.append((first_point, popt, perr))\n\n            if self.settings.DEBUG:\n                fitting_params_str = ' '.join([str(round(i, 2)) + '+\/-' +\n                                               str(round(j,2)) for i, j in zip(popt, perr) ])\n                                                # 'a+\/-aerr b+\/-berr ...'\n                print(f\"{self.settings.NL_FITTING_METHOD} fitting: {fitting_params_str}\")\n\n        if self.settings.NL_SORTING_METHOD == 'eta_0':\n            fittings.sort(key=lambda x: x[2][0])\n        elif self.settings.NL_SORTING_METHOD == 'overall':\n            #fittings.sort(key=lambda x: x[2][0] + x[2][1] + x[2][2] + x[2][3])\n            fittings.sort(key=lambda x: sum(x[2])) # sums the errors\n        else:\n            raise ValueError(f'Could not understand the sorting method {self.settings.NL_SORTING_METHOD}')\n\n        self.nl_first_point = fittings[0][0]\n        self.params = fittings[0][1]\n        self.param_errs = fittings[0][2]\n\n        if save:  # todo: check here to return a good destination file\n            try:\n                self.manip.record_fit(\n                    self.filename, self.params[0],\n                    self.param_errs[0], silent=False,\n                    extra=f\"{fittings[0][0]};{fittings[0][1]};nonlinear_auto_{self.settings.NL_FITTING_METHOD};\"\n                          f\"{nonlinear_has_error}\", fdest_name=self.settings.NL_FITTING_METHOD + '.csv'\n                )\n            except UnboundLocalError:\n                print('Unable to write to file because the subroutine did not return the fitting parameters')\n                print(traceback.format_exc())\n                self.manip.record_fit(self.filename, 0, 0, extra=f'nonlinear_auto_{self.settings.NL_FITTING_METHOD};'\n                                                                 f'unable_to_find_viscosity',\n                                      fdest_name=self.settings.NL_FITTING_METHOD+'.csv')\n                self.manip.logger(self.filename, 'No Viscosity')\n\n        self.nl_done = True\n        return self.nl_first_point, self.params, self.param_errs\n\n    # TODO: check if the bounds are correct\n    # TODO: increment this function to be able to accept multiple fittings\n    def manual_fit(self, first, last, fit_types, save=True):\n        GP_arr = np.array(self.GP[first:last + 1])\n        Eta_arr = np.array(self.Eta[first:last + 1])\n        fittings = []\n\n        for type in fit_types:\n            if 'Linear' in type:\n                popt, pcov = curve_fit(self.fit_lin, GP_arr, Eta_arr, p0=(30, 0),\n                                       bounds=(0, [self.VISC_LIMIT, 0.0001]))\n            elif 'Carreau' in type:\n                popt, pcov = curve_fit(self.fit_Carreau, GP_arr, Eta_arr, p0=(30, 0),\n                                       bounds=(0, np.inf))\n            elif 'Cross' in type:\n                popt, pcov = curve_fit(self.fit_Carreau, GP_arr, Eta_arr, p0=(30, 0),\n                                       bounds=(0, np.inf))\n            elif 'Carreau-Yasuda' in type:\n                popt, pcov = curve_fit(self.fit_CarreauYasuda, GP_arr, Eta_arr, p0=(30, 0),\n                                       bounds=(0, np.inf))\n            else:\n                raise NameError(f'Could not understand the list fit_types {fit_types}')\n\n            perr = np.sqrt(np.diag(pcov))\n\n            self.params = popt  # Will be continuously overwritten. todo: will this be a problem?\n            self.param_errs = perr\n\n            if self.settings.DEBUG:\n                # 'a+\/-aerr b+\/-berr ...'\n                fitting_params_str = ' '.join([str(round(i, 2)) + '+\/-' +\n                                               str(round(j, 2)) for i, j in zip(popt, perr)])\n                print(f\"{fit_types} fitting: {fitting_params_str}\")\n\n            if save:  # todo: check here to return a good destination file\n                self.manip.record_fit(self.settings.NL_FITTING_METHOD, self.params,\n                                      self.param_errs, silent=False)\n\n            fittings.append((type, popt, perr))\n\n        return fittings\n\n    # todo: use AnchoredText instead of text to write the fitting results;\n    # from mpl_toolkits.axes_grid.anchored_artists import AnchoredText\n    # at = AnchoredText(\"Figure 1a\",\n    #                   prop=dict(size=8), frameon=True,\n    #                   loc=2,\n    #                   )\n    # at.patch.set_boxstyle(\"round,pad=0.,rounding_size=0.2\")\n    # ax.add_artist(at)\n    def plot_error_graphs(self): # todo: If it has both plots, make them side by side\n        from mpl_toolkits.axes_grid.anchored_artists import AnchoredText\n        TEXT_FILENAME_X = 0.1\n        TEXT_PARAMS_X = 0.3\n        TEXT_Y = 0.98\n        x = np.logspace(np.log10(self.GP[0]), np.log10(self.GP[-1]))\n\n        if self.settings.DEBUG:\n            print('Debug: x', x)\n            print('Debug: params', self.params)\n            print('Debug: GP', self.GP, 'Eta', self.Eta)\n\n        if self.nl_done:\n            if self.model == 'Carreau':\n                y, yerr = self.carr_uncertainty(x, *self.params, *self.param_errs)\n            elif self.model == 'Cross':\n                y, yerr = self.cross_uncertainty(x, *self.params, *self.param_errs)\n            elif self.model == 'Carreau-Yasuda':\n                y, yerr = self.carryas_uncertainty(x, *self.params, *self.param_errs)\n        if self.lin_done:\n            y_l, yerr_l = np.ones(len(x)) * self.int, np.ones(len(x)) * self.int_err\n            # Creates a horizontal line with n points\n\n        if self.nl_done and self.lin_done:\n            fig, [axn, axl] = plt.subplots(ncols=2, nrows=1, figsize=(12, 4))\n        elif self.nl_done and not self.lin_done:\n            fig, axn = plt.subplots(ncols=1, nrows=1, figsize=(6, 4))\n        elif not self.nl_done and not self.lin_done:\n            fig, axl = plt.subplot(ncols=1, nrows=1, figsize=(6, 4))\n\n        if self.nl_done:\n            axn.set_xscale('log')\n            axn.set_yscale('log')\n            axn.plot(self.GP, self.Eta, linewidth=0, marker='o', markersize=5)\n            axn.errorbar(x, y, yerr=yerr)\n            axn.annotate(str(self.nl_first_point + 1), (self.GP[self.nl_first_point], self.Eta[self.nl_first_point]), color='red')\n            if self.nl_last_point == -1:\n                axn.annotate(str(len(self.GP)), (self.GP[self.nl_last_point], self.Eta[self.nl_last_point]),\n                             color='red')  # todo: check this function\n            else:\n                axn.annotate(str(self.nl_last_point), (self.GP[self.nl_last_point], self.Eta[self.nl_last_point]), color='red')\n            model_param_names = 'Model: ' + self.model + ' Params: ' + self.param_names\n            param_text = \" \".join([str(round(par, 2)) + '+\/-' + str(round(err, 2))\n                                   for par, err in zip(self.params, self.param_errs)])\n\n            total_text = f'{self.filename}\\n{model_param_names}\\n{param_text}\\n$R^2$={round(self.nl_R2, 2)}'\n            anchored_text = AnchoredText(total_text, loc=3, frameon=True, prop={'fontsize':'small'})\n            axn.add_artist(anchored_text)\n\n        if self.lin_done:\n            axl.set_xscale('log')\n            axl.set_yscale('log')\n            axl.plot(self.GP, self.Eta, linewidth=0, marker='o', markersize=5)\n            axl.errorbar(x, y_l, yerr=yerr_l)\n            axl.annotate(str(self.l_first_point + 1), (self.GP[self.l_first_point], self.Eta[self.l_first_point]), color='red')\n            if self.l_last_point == -1:\n                axl.annotate(str(len(self.GP)), (self.GP[self.l_last_point], self.Eta[self.l_last_point]),\n                             color='red')  # todo: check this function\n            else:\n                axl.annotate(str(self.l_last_point), (self.GP[self.l_last_point], self.Eta[self.l_last_point]), color='red')\n            \n            model_param_names = 'Model: Linear. Params: Intercept'\n            param_text = f\"int = {self.int}+\/-{self.int_err}\"\n            total_text = f'{self.filename}\\n{model_param_names}\\n{param_text}\\n$R^2$={round(self.l_R2, 2)}'\n            anchored_text = AnchoredText(total_text, loc=3, frameon=True, prop={'fontsize':'small'})\n            axl.add_artist(anchored_text)\n\n        plt.tight_layout()\n\n        if self.settings.SAVE_GRAPHS:\n            fig.savefig(self.filename[:-4] + '.png')\n            print('Figure saved.')\n        if not self.settings.INLINE_GRAPHS and self.settings.PLOT_GRAPHS:\n            plt.draw()\n            plt.pause(self.wait)\n            #plt.clf()\n            plt.close(fig)\n        elif self.settings.PLOT_GRAPHS:\n            plt.show()\n        return\n\n\nclass FileManip:\n    #def __init__(self, sett):\n    #    self.settings = sett\n\n    @staticmethod\n    def ExtractData(fname, FC_segment=0):\n        \"\"\"Opens the file fname and extracts the data based on where it finds the word 'Eta' and 'GP', these being\n        the Viscosity and the Shear Rate (gamma point). If the file has multiple segments, for example, when multiple\n        experiments were done in succession, FC_segment indicates which of those experiments was a Flow Curve.\"\"\"\n        fhand = open(fname, 'r')\n        GP = []\n        Eta = []\n        column_eta = 0\n        column_gp = 0\n        # FC_segment = '3'\n\n        # while FC_segment == 0:\n        #    FC_segment = input(\"What is the segment that has the flow curves? (eg. [1], 2, 3) If you do not know, don't write anything. \")\n        #    if FC_segment == '':\n        #        print(fhand.read())\n        #    elif FC_segment.isnumeric():\n        #        break\n        #    else:\n        #        print('Not a valid number')\n\n        for line in fhand:\n            if line.startswith(';'):\n                column_names = line.rstrip().split(';')\n                # if settings['DEBUG']:\n                #     print('Debug: column names', column_names)\n                for i, column in enumerate(column_names):\n                    if 'Eta' in column and 'Eta*' not in column:\n                        column_eta = i\n                        #if settings['DEBUG']:\n                        #    print('Debug: Found Eta at', column_eta)\n                    if 'GP' in column:\n                        column_gp = i\n                        #if settings['DEBUG']:\n                        #    print('Debug: Found GP at', column_gp)\n            try:\n                GP.append(float(line.replace(',', '.').split(';')[column_gp]))\n                Eta.append(float(line.replace(',', '.').split(';')[column_eta]))\n            except:\n                pass\n\n            # if line.startswith(FC_segment + '|'):\n            #    line = line.rstrip()\n            #    num, gp, tau, eta, *rest = line.replace(',','.').split(';')\n            #    GP.append(float(gp))\n            #    Eta.append(float(eta))\n            #    #print(line)\n\n        fhand.close()\n        if len(GP) == 0:\n            # print('!!!!No Flow Curve data was found! Re-export the data on file', fname)\n            raise ValueError\n        # return pd.Series(GP), pd.Series(Eta)\n        # if settings['DEBUG']:\n        #     print('Debug: Extracted Data: GP:', GP, 'Eta:', Eta)\n        return GP, Eta\n\n    @staticmethod\n    def ExtractData_pd(fname):\n        \"\"\"Uses pandas do extract the data if it was exported using the data extraction tool\"\"\"\n        pd_temp = pd.read_csv(fname, delimiter=';', encoding='latin1', decimal=',')\n        pd_temp = pd_temp[pd_temp > 0].dropna()\n\n        col_GP = ''\n        col_Eta = ''\n\n        for col in pd_temp.columns:\n            if 'GP' in col:\n                col_GP = col\n                # print('achou GP em', col)\n            if 'Eta' in col:\n                col_Eta = col\n                # print('achou Eta em', col)\n\n        GP = pd_temp[col_GP].tolist()\n        Eta = pd_temp[col_Eta].tolist()\n        return GP, Eta\n\n    @staticmethod\n    def record_fit(name, eta0, eta0_err, silent=False, extra='', fdest_name='results.csv'):\n        if not silent:\n            print(f\"{name}: Intercept={eta0} +- {eta0_err}. Extra={extra}\")\n            #print(name + ':', 'Intercept', eta0, '+-', eta0_err, extra)\n\n        with open(fdest_name, 'a', encoding='utf-8') as fdest:\n            #fdest.write(name + ';' + str(eta0) + ';' + str(eta0_err) + ';' + extra + '\\n')\n            fdest.write(f\"{name};{eta0};{eta0_err};{extra}\\n\")\n\n    @staticmethod\n    def select_files():\n        files = []\n        extension = input('What is the file extension? txt, dat, etc:\\n')\n        allfiles = glob.glob('*.' + extension)\n        print(*[str(num) + ')' + file + '\\n' for num, file in enumerate(allfiles)], sep='')\n        while True:\n            file_to_add = input('Which file to add? Number, nothing to continue or \"quit\" to exit: ')\n            if file_to_add == 'quit':\n                return []\n            elif file_to_add == '':\n                break\n            else:\n                try:\n                    files.append(allfiles[int(file_to_add)])\n                except IndexError:\n                    print('Invalid value')\n                except ValueError:\n                    print('Enter a number, not text')\n        if len(files) == 0:\n            print('No file was selected! The program will now quit.')\n            return files\n        print('====Selected files:====')\n        print(*[file + '\\n' for file in files], sep='', end='')\n        print('=======================')\n        return files\n\n    @staticmethod\n    def logger(file, type, extra=''):\n        with open('log', 'a') as log:\n            if type == 'Overflow':\n                log.write(f'Parameter overflow while trying to fit file {file}: {extra}\\n')\n            if type == 'No Viscosity':\n                log.write(f'Unable to find viscosity for file {file}\\n')\n            if type == 'Failed to open':\n                log.write(f'Failed to open file {file}. Re-export the data.')\n            else:  # type == 'Generic'\n                log.write(f'Error while processing {file}: {extra}\\n')\n\n\ndef test():\n    settings = Settings.Settings()\n    settings.NL_FITTING_METHOD = 'Carreau-Yasuda'\n    filename = 'CF_Sac50-3--0.csv'\n    fit = Fitter(filename, settings, do_fit=False)\n    fit.automatic_nl_fitting_lm(save=True)\n    print(fit.model, fit.nl_R2, *fit.params)\n\n    return fit\n\n\ndef main():\n    settings = Settings.Settings()\n    manip = FileManip()\n    settings.print_settings()\n    do_change = input('Do you want to change the settings? y\/[n]')\n    if do_change == 'y':\n        settings.edit_settings()\n\n    if settings.TREAT_ALL:\n        files = glob.glob(f'*.{settings.EXT}')\n        if len(files) == 0:\n            print(f'No files with the extension {settings.EXT} found.'\n                  f' Please select them manually or change EXT accordingly.')\n            files = manip.select_files()\n\n    else:\n        files = manip.select_files()\n\n    if len(files) == 0:\n        print('No files selected. Quitting.')\n        sys.exit()\n\n    for file in files:\n        try:\n            fit = Fitter(file, settings, do_fit=True)\n        except ValueError:  # todo: debug and check what would be needed here.\n            print(f'Skipping {file}: Value Error')\n            continue\n        except KeyError:\n            print(f'Skipping {file} Key Error')\n            continue\n            #print(traceback.format_exc())\n\n        if settings.PLOT_GRAPHS or settings.SAVE_GRAPHS:\n            try:\n                fit.plot_error_graphs()\n            except OverflowError:  # todo: write which parameter has overflown\n                print('!!!! Overflow detected on one of the parameters. Could not plot the data')\n                nonlinear_has_error = ';param_overflow_during_fitting'\n                # todo: log this\n            except UnboundLocalError:\n                print('Not able to write to file because the subroutine did not return the fitting parameters')\n                # todo: log this\n\n\n            #fit.plot_error_graphs(file[:-4] + '_lin_' + file[-4:], fit.params, fit.first_point, fit.last_point,\n            #                      model=fit.settings.NL_FITTING_METHOD, param_names=[''])\n\n                # # except:\n                # #     print('Error found while plotting the linear fit')\n                # #     print(traceback.format_exc())\n                # #     lin_has_error = 'error_during_fitting'\n                # record(file, a, aerr,\n                #        extra='linear automatic;FP=' + str(lin_points[0]) + 'LP=' + str(lin_points[1]) +\n                #              lin_has_error, fdest_name='linear.csv')\n\n\n            #         if settings['PLOT_GRAPHS']:\n            #             plot_error_graphs(file[:-4] + '_carr_' + file[-4:], GP, Eta,\n            #                               params=np.concatenate((popt, perr)),\n            #                               first_point=nl_first, model=settings['NL_FITTING_METHOD'],\n            #                               param_names=Param_names_errs[settings['NL_FITTING_METHOD']])\n            #     except OverflowError:  # todo: write which parameter has overflown\n            #         print('!!!! Overflow detected on one of the parameters. Could not plot the data')\n            #         nonlinear_has_error = ';param_overflow_during_fitting'\n            #     try:\n            #         record(file, popt[0], perr[0], extra='nonlinear_auto_' + settings['NL_FITTING_METHOD'] +\n            #                                              nonlinear_has_error,\n            #                fdest_name=settings['NL_FITTING_METHOD'] + '.csv')\n            #     except UnboundLocalError:\n            #         print('Not able to write to file because the subroutine did not return the fitting parameters')\n            #         record(file, 0, 0, extra='nonlinear_auto_' + settings['NL_FITTING_METHOD'] + ';' +\n            #                                  'unable_to_find_viscosity',\n            #                fdest_name=settings['NL_FITTING_METHOD'] + '.csv')\n            #         with open('log', 'a') as log:\n        #     #             log.write('Unable to find viscosity for file ' + file + '\\n')\n        # except:\n        #     print('!!!!We have encountered an error while processing file', file)\n        #     print(traceback.format_exc())\n        #     with open('log', 'a') as log:\n        #         log.write('Error while processing ' + file + '\\n')\n        #         log.write(traceback.format_exc())\n\nif __name__ == '__main__':\n    fit = main()\n    #main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_124","text":"def EDMFanalysis(numberofsensor,numberofmodelinstance,meanuncertaintydata,stduncertaintydata,ID_to_be_excluded,finalpathprediction,finalpathmeas,sidakvalue,uncmultiplier,indextext):\n    \"\"\"\n        Perform EDMF analysis with all uploaded files and intermediate results\n\n        Developed by :   <NAME> (ETH Singapore)\n        Contact :        <EMAIL>\n        Date:            August 03, 2021\n\n        INPUTS:\n            numberofsensor : number of sensors involved in the studied problem.\n            numberofmodelinstance : number of initial model instances involved in the studied problem.\n            ID_to_be_excluded: index of measurements to be excluded for EDMF analysis.\n            finalpathprediction : directory of the Prediction(Geo).xlsx.\n            finalpathmeas: directory of the Measurements(Geo).xlsx.\n            sidakvalue: target reliability of identification\n            uncmultiplier : multiplier for uncertainty to assess sensitivity of results to uncertainty definitions\n            indextext: index of measurements to be excluded for EDMF analysis in the original format.\n        OUTPUTS:\n            prediction : predictions made with candidate models.\n            measurement : measurement data.\n            finalresults: logic results of initial model instances: 0 represents falsified model; 1 represents candidate model\n            IMS: initial model instances\n            CMS: candidate models\n            CMSID: location reference of candidate models\n        NOTE:\n            These inputs will be automatically read from other functions. No maunal actions are needed.\n        \"\"\"\n\n    import numpy\n    import os\n    import xlrd\n    from openpyxl import load_workbook\n    import pandas\n    from scipy.stats import norm\n\n\n    #########for validation\n    fullset = numpy.arange(numberofsensor)+1\n    ID_to_be_included_ = set(ID_to_be_excluded) ^ set(fullset)\n    ID_to_be_included = numpy.zeros((len(ID_to_be_included_), 1))\n    for i in range(0, len(ID_to_be_included_)):\n        ID_to_be_included[i][0] = (list(ID_to_be_included_)[i])\n    ID_to_be_included = ID_to_be_included.astype(numpy.int64)-1\n\n    #####load uncertainty excel\n    excelfileuncertainty1_ = meanuncertaintydata\n    excelfileuncertainty2_ = stduncertaintydata\n\n    excelfileprediction = pandas.read_excel(finalpathprediction,sheet_name = 'Prediction', engine = 'openpyxl')\n\n    excelfilemeas = pandas.read_excel(finalpathmeas,header = None,sheet_name = 'Measurement', engine = 'openpyxl')\n\n    ##########read uncertainty\n    excelsheetuncertainty1 = excelfileuncertainty1_[0:numberofmodelinstance, 0:numberofsensor]\n    ucombinemean = excelsheetuncertainty1\n\n    excelsheetuncertainty2 = excelfileuncertainty2_[0:numberofmodelinstance, 0:numberofsensor]\n    ucombinesd = excelsheetuncertainty2\n\n\n    ###########calculate sidak\n    lowerbound = numpy.zeros((numberofmodelinstance, numberofsensor))\n    upperbound = numpy.zeros((numberofmodelinstance, numberofsensor))\n\n    sidak = sidakvalue ** (1 \/ len(ID_to_be_included))\n\n    for i in range(0,numberofmodelinstance):\n        for s in range(0,numberofsensor):\n            bound1_ = norm.ppf((1-sidak)\/2,loc = ucombinemean[i][s]*uncmultiplier,scale = ucombinesd[i][s])\n            bound2_ = norm.ppf(1-(1-sidak)\/2,loc = ucombinemean[i][s]*uncmultiplier,scale = ucombinesd[i][s])\n            lowerbound[i][s] = bound1_\n            upperbound[i][s] = bound2_\n\n\n    #######falsification\n    #######load predictions and measurements from other functions or excel\n    excelsheetprediction = excelfileprediction.to_numpy()\n    prediction = numpy.zeros((numberofmodelinstance, numberofsensor))\n    for i in range(0,numberofmodelinstance):\n        for s in range(0,numberofsensor):\n            excelsheetpredictionvalue_= excelsheetprediction[i,s+2]\n            prediction[i][s] = excelsheetpredictionvalue_\n\n    excelsheetmeas = excelfilemeas.to_numpy()\n    measurement = numpy.zeros((numberofsensor,1))\n    for s in range(0,numberofsensor):\n        excelsheetmeasvalue_= excelsheetmeas[0,s]\n        measurement[s][0] = excelsheetmeasvalue_\n\n    falsification = numpy.zeros((numberofmodelinstance, numberofsensor))\n\n    for i in range(0,numberofmodelinstance):\n        for s in range(0,numberofsensor):\n            residual = prediction[i][s] - measurement[s][0]\n            falsification_ = (residual<upperbound[i][s] and residual>lowerbound[i][s])\n            if falsification_==True:\n                falsification[i][s] = 1\n            else:\n                falsification[i][s] = 0\n\n    ##########for validation\n    falsificationfinal = numpy.zeros((numberofmodelinstance,len(ID_to_be_included)))\n    for i in range(0,len(ID_to_be_included)):\n        for s in range(0,numberofmodelinstance):\n            falsificationfinal[s][i] = falsification[s,int(ID_to_be_included[i][0])]\n\n    final = sum(numpy.transpose(falsificationfinal))\n    is_candidate = numpy.zeros((numberofmodelinstance,1))\n\n    for i in range(0,numberofmodelinstance):\n        if final[i] == float(len(ID_to_be_included)):\n            is_candidate[i][0] = 1\n        else:\n            is_candidate[i][0] = 0\n\n    ###write to excel\n    finalpathCMS = finalpathprediction\n    savefile = load_workbook(finalpathCMS)\n    savesheets = savefile.sheetnames\n    sheetCMS = savefile[savesheets[1]]\n\n    for s in range(0,numberofmodelinstance):\n        sheetCMS.cell(row = s+3, column = 5).value = is_candidate[s][0]\n\n    savefile.save(finalpathCMS)\n\n    ###########load IMS\n    excelsheetIMS = excelfileprediction.to_numpy()[0:numberofmodelinstance, 0:2]\n    ims = numpy.zeros((numberofmodelinstance, 2))\n    for i in range(0,numberofmodelinstance):\n        for s in range(0,2):\n            excelsheetIMSvalue_= excelsheetIMS[i,s]\n            ims[i][s] = excelsheetIMSvalue_\n\n    ########CMS\n    cmsID = numpy.where(is_candidate == 1)\n    cms = ims[cmsID[0], :]\n\n    ########write to excel\n    from f_resultsexcel_Geo import f_resultsexcel_Geo\n    f_resultsexcel_Geo(ims, prediction, is_candidate,uncmultiplier,sidakvalue, indextext)\n\n    return prediction,measurement,is_candidate,ims,cms,cmsID,sidakvalue,indextext,uncmultiplier"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_125","text":"import scipy.io\nimport scipy.misc\nfrom glob import glob\nimport os\nimport numpy as np\nfrom ops import *\nimport tensorflow as tf\nfrom tensorflow import contrib\nfrom menpo_functions import *\nfrom logging_functions import *\nfrom data_loading_functions import *\n\n\nclass DeepHeatmapsModel(object):\n\n    \"\"\"facial landmark localization Network\"\"\"\n\n    def __init__(self, mode='TRAIN', train_iter=100000, batch_size=10, learning_rate=1e-3, adam_optimizer=True,\n                 momentum=0.95, step=100000, gamma=0.1, reg=0, weight_initializer='xavier', weight_initializer_std=0.01,\n                 bias_initializer=0.0, image_size=256, c_dim=3, num_landmarks=68, sigma=1.5, scale=1, margin=0.25,\n                 bb_type='gt', approx_maps=True, win_mult=3.33335, augment_basic=True, basic_start=0,\n                 augment_texture=False, p_texture=0., augment_geom=False, p_geom=0., artistic_step=-1, artistic_start=0,\n                 output_dir='output', save_model_path='model', save_sample_path='sample', save_log_path='logs',\n                 test_model_path='model\/deep_heatmaps-50000', pre_train_path='model\/deep_heatmaps-50000',load_pretrain=False,\n                 img_path='data', test_data='full', valid_data='full', valid_size=0, log_valid_every=5,\n                 train_crop_dir='crop_gt_margin_0.25', img_dir_ns='crop_gt_margin_0.25_ns',\n                 print_every=100, save_every=5000, sample_every=5000, sample_grid=9, sample_to_log=True,\n                 debug_data_size=20, debug=False, epoch_data_dir='epoch_data', use_epoch_data=False, menpo_verbose=True):\n\n        # define some extra parameters\n\n        self.log_histograms = False  # save weight + gradient histogram to log\n        self.save_valid_images = True  # sample heat maps of validation images\n        self.log_artistic_augmentation_probs = False  # save p_texture & p_geom to log\n        self.sample_per_channel = False  # sample heatmaps separately for each landmark\n        self.approx_maps_gpu = False  # create heat-maps on gpu. NOT RECOMMENDED. TODO: REMOVE\n\n        # for fine-tuning, choose reset_training_op==True. when resuming training, reset_training_op==False\n        self.reset_training_op = False\n\n        self.allocate_once = True  # create batch images\/landmarks\/maps zero arrays only once\n\n        self.fast_img_gen = True\n\n        self.compute_nme = True  # compute normalized mean error\n\n        self.config = tf.ConfigProto()\n        self.config.gpu_options.allow_growth = True\n\n        # sampling and logging parameters\n        self.print_every = print_every  # print losses to screen + log\n        self.save_every = save_every  # save model\n        self.sample_every = sample_every  # save images of gen heat maps compared to GT\n        self.sample_grid = sample_grid  # number of training images in sample\n        self.sample_to_log = sample_to_log  # sample images to log instead of disk\n        self.log_valid_every = log_valid_every  # log validation loss (in epochs)\n\n        self.debug = debug\n        self.debug_data_size = debug_data_size\n        self.use_epoch_data = use_epoch_data\n        self.epoch_data_dir = epoch_data_dir\n\n        self.load_pretrain = load_pretrain\n        self.pre_train_path = pre_train_path\n\n        self.mode = mode\n        self.train_iter = train_iter\n        self.learning_rate = learning_rate\n\n        self.image_size = image_size\n        self.c_dim = c_dim\n        self.batch_size = batch_size\n\n        self.num_landmarks = num_landmarks\n\n        self.save_log_path = save_log_path\n        self.save_sample_path = save_sample_path\n        self.save_model_path = save_model_path\n        self.test_model_path = test_model_path\n        self.img_path=img_path\n\n        self.momentum = momentum\n        self.step = step  # for lr decay\n        self.gamma = gamma  # for lr decay\n        self.reg = reg  # weight decay scale\n\n        self.weight_initializer = weight_initializer  # random_normal or xavier\n        self.weight_initializer_std = weight_initializer_std\n        self.bias_initializer = bias_initializer\n        self.adam_optimizer = adam_optimizer\n\n        self.sigma = sigma  # sigma for heatmap generation\n        self.scale = scale  # scale for image normalization 255 \/ 1 \/ 0\n        self.win_mult = win_mult  # gaussian filter size for cpu\/gpu approximation: 2 * sigma * win_mult + 1\n        self.approx_maps_cpu = approx_maps  # create heat-maps by inserting gaussian filter around landmark locations\n\n        self.test_data = test_data  # if mode is TEST, this choose the set to use full\/common\/challenging\/test\/art\n        self.train_crop_dir = train_crop_dir\n        self.img_dir_ns = os.path.join(img_path, img_dir_ns)\n        self.augment_basic = augment_basic  # perform basic augmentation (rotation,flip,crop)\n        self.augment_texture = augment_texture  # perform artistic texture augmentation (NS)\n        self.p_texture = p_texture  # initial probability of artistic texture augmentation\n        self.augment_geom = augment_geom  # perform artistic geometric augmentation\n        self.p_geom = p_geom  # initial probability of artistic geometric augmentation\n        self.artistic_step = artistic_step  # increase probability of artistic augmentation every X epochs\n        self.artistic_start = artistic_start  # min epoch to start artistic augmentation\n        self.basic_start = basic_start  # min epoch to start basic augmentation\n\n        self.valid_size = valid_size\n        self.valid_data = valid_data\n\n        # load image, bb and landmark data using menpo\n        self.bb_dir = os.path.join(img_path, 'Bounding_Boxes')\n        self.bb_dictionary = load_bb_dictionary(self.bb_dir, mode, test_data=self.test_data)\n\n        if self.use_epoch_data:\n            epoch_0 = os.path.join(self.epoch_data_dir, '0')\n            self.img_menpo_list = load_menpo_image_list(\n                img_path, train_crop_dir=epoch_0, img_dir_ns=None, mode=mode, bb_dictionary=self.bb_dictionary,\n                image_size=self.image_size,test_data=self.test_data, augment_basic=False, augment_texture=False,\n                augment_geom=False, verbose=menpo_verbose)\n        else:\n            self.img_menpo_list = load_menpo_image_list(\n                img_path, train_crop_dir, self.img_dir_ns, mode, bb_dictionary=self.bb_dictionary,\n                image_size=self.image_size, margin=margin, bb_type=bb_type, test_data=self.test_data,\n                augment_basic=(augment_basic and basic_start == 0),\n                augment_texture=(augment_texture and artistic_start == 0 and p_texture > 0.), p_texture=p_texture,\n                augment_geom=(augment_geom and artistic_start == 0 and p_geom > 0.), p_geom=p_geom,\n                verbose=menpo_verbose)\n\n        if mode == 'TRAIN':\n\n            train_params = locals()\n            print_training_params_to_file(train_params)  # save init parameters\n\n            self.train_inds = np.arange(len(self.img_menpo_list))\n\n            if self.debug:\n                self.train_inds = self.train_inds[:self.debug_data_size]\n                self.img_menpo_list = self.img_menpo_list[self.train_inds]\n\n            if valid_size > 0:\n\n                self.valid_bb_dictionary = load_bb_dictionary(self.bb_dir, 'TEST', test_data=self.valid_data)\n                self.valid_img_menpo_list = load_menpo_image_list(\n                    img_path, train_crop_dir, self.img_dir_ns, 'TEST', bb_dictionary=self.valid_bb_dictionary,\n                    image_size=self.image_size, margin=margin, bb_type=bb_type, test_data=self.valid_data,\n                    verbose=menpo_verbose)\n\n                np.random.seed(0)\n                self.val_inds = np.arange(len(self.valid_img_menpo_list))\n                np.random.shuffle(self.val_inds)\n                self.val_inds = self.val_inds[:self.valid_size]\n\n                self.valid_img_menpo_list = self.valid_img_menpo_list[self.val_inds]\n\n                if self.approx_maps_cpu:\n                    self.valid_images_loaded, self.valid_gt_maps_loaded, self.valid_landmarks_loaded =\\\n                        load_images_landmarks_approx_maps(\n                            self.valid_img_menpo_list, np.arange(self.valid_size), primary=True, image_size=self.image_size,\n                            num_landmarks=self.num_landmarks, c_dim=self.c_dim, scale=self.scale, win_mult=self.win_mult,\n                            sigma=self.sigma, save_landmarks=True)\n                else:\n                    self.valid_images_loaded, self.valid_gt_maps_loaded, self.valid_landmarks_loaded =\\\n                        load_images_landmarks_maps(\n                            self.valid_img_menpo_list, np.arange(self.valid_size), primary=True, image_size=self.image_size,\n                            c_dim=self.c_dim, num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                            save_landmarks=True)\n\n                if self.allocate_once:\n                    self.valid_landmarks_pred = np.zeros([self.valid_size, self.num_landmarks, 2]).astype('float32')\n\n                if self.valid_size > self.sample_grid:\n                    self.valid_gt_maps_loaded = self.valid_gt_maps_loaded[:self.sample_grid]\n            else:\n                self.val_inds = None\n\n            self.epoch_inds_shuffle = train_val_shuffle_inds_per_epoch(\n                self.val_inds, self.train_inds, train_iter, batch_size, save_log_path)\n\n    def add_placeholders(self):\n\n        if self.mode == 'TEST':\n            self.images = tf.placeholder(\n                tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'images')\n\n            self.heatmaps_small = tf.placeholder(\n                tf.float32, [None, int(self.image_size\/4), int(self.image_size\/4), self.num_landmarks], 'heatmaps_small')\n            self.lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'lms_small')\n            self.pred_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'pred_lms_small')\n\n        elif self.mode == 'TRAIN':\n            self.images = tf.placeholder(\n                tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'train_images')\n\n            self.heatmaps_small = tf.placeholder(\n                tf.float32, [None, int(self.image_size\/4), int(self.image_size\/4), self.num_landmarks], 'train_heatmaps_small')\n\n            self.train_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'train_lms_small')\n            self.train_pred_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'train_pred_lms_small')\n\n            self.valid_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'valid_lms_small')\n            self.valid_pred_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'valid_pred_lms_small')\n\n            self.p_texture_log = tf.placeholder(tf.float32, [])\n            self.p_geom_log = tf.placeholder(tf.float32, [])\n\n            self.sparse_hm_small = tf.placeholder(tf.float32, [None, int(self.image_size\/4), int(self.image_size\/4), 1])\n\n            if self.sample_to_log:\n                row = int(np.sqrt(self.sample_grid))\n                self.log_image_map = tf.placeholder(\n                    tf.uint8, [None,row * int(self.image_size\/4), 3 * row *int(self.image_size\/4), self.c_dim], 'sample_img_map')\n                if self.sample_per_channel:\n                    row = np.ceil(np.sqrt(self.num_landmarks)).astype(np.int64)\n                    self.log_map_channels = tf.placeholder(\n                        tf.uint8, [None, row * int(self.image_size\/4), 2 * row * int(self.image_size\/4), self.c_dim],\n                        'sample_map_channels')\n\n    def heatmaps_network(self, input_images, reuse=None, name='pred_heatmaps'):\n\n        with tf.name_scope(name):\n\n            if self.weight_initializer == 'xavier':\n                weight_initializer = contrib.layers.xavier_initializer()\n            else:\n                weight_initializer = tf.random_normal_initializer(stddev=self.weight_initializer_std)\n\n            bias_init = tf.constant_initializer(self.bias_initializer)\n\n            with tf.variable_scope('heatmaps_network'):\n                with tf.name_scope('primary_net'):\n\n                    l1 = conv_relu_pool(input_images, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,\n                                        reuse=reuse, var_scope='conv_1')\n                    l2 = conv_relu_pool(l1, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,\n                                        reuse=reuse, var_scope='conv_2')\n                    l3 = conv_relu(l2, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,\n                                   reuse=reuse, var_scope='conv_3')\n\n                    l4_1 = conv_relu(l3, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_1')\n                    l4_2 = conv_relu(l3, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_2')\n                    l4_3 = conv_relu(l3, 3, 128, conv_dilation=3, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_3')\n                    l4_4 = conv_relu(l3, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_4')\n\n                    l4 = tf.concat([l4_1, l4_2, l4_3, l4_4], 3, name='conv_4')\n\n                    l5_1 = conv_relu(l4, 3, 256, conv_dilation=1, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_1')\n                    l5_2 = conv_relu(l4, 3, 256, conv_dilation=2, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_2')\n                    l5_3 = conv_relu(l4, 3, 256, conv_dilation=3, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_3')\n                    l5_4 = conv_relu(l4, 3, 256, conv_dilation=4, conv_ker_init=weight_initializer,\n                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_4')\n\n                    l5 = tf.concat([l5_1, l5_2, l5_3, l5_4], 3, name='conv_5')\n\n                    l6 = conv_relu(l5, 1, 512, conv_ker_init=weight_initializer,\n                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_6')\n                    l7 = conv_relu(l6, 1, 256, conv_ker_init=weight_initializer,\n                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_7')\n                    primary_out = conv(l7, 1, self.num_landmarks, conv_ker_init=weight_initializer,\n                                            conv_bias_init=bias_init, reuse=reuse, var_scope='conv_8')\n\n                self.all_layers = [l1, l2, l3, l4, l5, l6, l7, primary_out]\n\n                return primary_out\n\n    def build_model(self):\n        self.pred_hm_p = self.heatmaps_network(self.images,name='heatmaps_prediction')\n\n    def build_hm_generator(self):  # TODO: remove\n        # generate heat-maps using:\n        # a sparse base (matrix of zeros with 1's in landmark locations) and convolving with a gaussian filter\n        print (\"*** using convolution to create heat-maps. use this option only with GPU support ***\")\n\n        # create gaussian filter\n        win_small = int(self.win_mult * self.sigma)\n        x_small, y_small = np.mgrid[0:2*win_small+1, 0:2*win_small+1]\n\n        gauss_small = (8. \/ 3) * self.sigma * gaussian(x_small, y_small, win_small, win_small, sigma=self.sigma)\n        gauss_small = tf.constant(gauss_small, tf.float32)\n        gauss_small = tf.reshape(gauss_small, [2 * win_small + 1, 2 * win_small + 1, 1, 1])\n\n        # convolve sparse map with gaussian\n        self.filt_hm_small = tf.nn.conv2d(self.sparse_hm_small, gauss_small, strides=[1, 1, 1, 1], padding='SAME')\n        self.filt_hm_small = tf.transpose(\n            tf.concat(tf.split(self.filt_hm_small, self.batch_size, axis=0), 3), [3, 1, 2, 0])\n\n    def create_loss_ops(self):  # TODO: calculate NME on resized maps to 256\n\n        def l2_loss_norm_eyes(pred_landmarks, real_landmarks, normalize=True, name='NME'):\n\n            with tf.name_scope(name):\n                with tf.name_scope('real_pred_landmarks_rmse'):\n                    landmarks_rms_err = tf.reduce_mean(\n                        tf.sqrt(tf.reduce_sum(tf.square(pred_landmarks - real_landmarks), axis=2)), axis=1)\n                if normalize:\n                    with tf.name_scope('inter_pupil_dist'):\n                        with tf.name_scope('left_eye_center'):\n                            p1 = tf.reduce_mean(tf.slice(real_landmarks, [0, 42, 0], [-1, 6, 2]), axis=1)\n                        with tf.name_scope('right_eye_center'):\n                            p2 = tf.reduce_mean(tf.slice(real_landmarks, [0, 36, 0], [-1, 6, 2]), axis=1)\n\n                        eye_dist = tf.sqrt(tf.reduce_sum(tf.square(p1 - p2), axis=1))\n\n                    return landmarks_rms_err \/ eye_dist\n                else:\n                    return landmarks_rms_err\n\n        if self.mode is 'TRAIN':\n            primary_maps_diff = self.pred_hm_p-self.heatmaps_small\n            self.total_loss = 1000.*tf.reduce_mean(tf.square(primary_maps_diff))\n\n            # add weight decay\n            self.total_loss += self.reg * tf.add_n(\n                [tf.nn.l2_loss(v) for v in tf.trainable_variables() if 'bias' not in v.name])\n\n            if self.compute_nme:\n                self.nme_loss = tf.reduce_mean(l2_loss_norm_eyes(self.train_pred_lms_small,self.train_lms_small))\n\n            if self.valid_size > 0 and self.compute_nme:\n                self.valid_nme_loss = tf.reduce_mean(l2_loss_norm_eyes(self.valid_pred_lms_small,self.valid_lms_small))\n\n        elif self.mode == 'TEST' and self.compute_nme:\n            self.nme_per_image = l2_loss_norm_eyes(self.pred_lms_small, self.lms_small)\n            self.nme_loss = tf.reduce_mean(self.nme_per_image)\n\n    def predict_landmarks_in_batches(self, image_paths, session):\n\n        num_batches = int(1.*len(image_paths)\/self.batch_size)\n        if num_batches == 0:\n            batch_size = len(image_paths)\n            num_batches = 1\n        else:\n            batch_size = self.batch_size\n\n        img_inds = np.arange(len(image_paths))\n        for j in range(num_batches):\n            batch_inds = img_inds[j * batch_size:(j + 1) * batch_size]\n\n            batch_images, _, batch_lms_small = \\\n                load_images_landmarks_maps(\n                    self.img_menpo_list, batch_inds, primary=True, image_size=self.image_size,\n                    c_dim=self.c_dim, num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                    save_landmarks=self.compute_nme)\n\n            batch_maps_small_pred = session.run(self.pred_hm_p, {self.images: batch_images})\n            batch_pred_landmarks = batch_heat_maps_to_landmarks(\n                batch_maps_small_pred, batch_size=batch_size, image_size=int(self.image_size\/4),\n                num_landmarks=self.num_landmarks)\n\n            if j == 0:\n                all_pred_landmarks = batch_pred_landmarks.copy()\n                all_gt_landmarks = batch_lms_small.copy()\n            else:\n                all_pred_landmarks = np.concatenate((all_pred_landmarks,batch_pred_landmarks),0)\n                all_gt_landmarks = np.concatenate((all_gt_landmarks, batch_lms_small), 0)\n\n        reminder = len(image_paths)-num_batches*batch_size\n\n        if reminder > 0:\n            reminder_inds = img_inds[-reminder:]\n\n            batch_images, _, batch_lms_small = \\\n                load_images_landmarks_maps(\n                    self.img_menpo_list, reminder_inds, primary=True, image_size=self.image_size,\n                    c_dim=self.c_dim, num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                    save_landmarks=self.compute_nme)\n\n            batch_maps_small_pred = session.run(self.pred_hm_p, {self.images: batch_images})\n            batch_pred_landmarks = batch_heat_maps_to_landmarks(\n                batch_maps_small_pred, batch_size=reminder, image_size=int(self.image_size\/4),\n                num_landmarks=self.num_landmarks)\n\n            all_pred_landmarks = np.concatenate((all_pred_landmarks, batch_pred_landmarks), 0)\n            all_gt_landmarks = np.concatenate((all_gt_landmarks, batch_lms_small), 0)\n\n        return all_pred_landmarks, all_gt_landmarks\n\n    def predict_landmarks_in_batches_loaded(self, images, session):\n\n        num_images = int(images.shape[0])\n        num_batches = int(1.*num_images\/self.batch_size)\n        if num_batches == 0:\n            batch_size = num_images\n            num_batches = 1\n        else:\n            batch_size = self.batch_size\n\n        for j in range(num_batches):\n\n            batch_images = images[j * batch_size:(j + 1) * batch_size,:,:,:]\n            batch_maps_small_pred = session.run(self.pred_hm_p, {self.images: batch_images})\n            if self.allocate_once:\n                batch_heat_maps_to_landmarks_alloc_once(\n                    batch_maps=batch_maps_small_pred,\n                    batch_landmarks=self.valid_landmarks_pred[j * batch_size:(j + 1) * batch_size, :, :],\n                    batch_size=batch_size, image_size=int(self.image_size\/4), num_landmarks=self.num_landmarks)\n            else:\n                batch_pred_landmarks = batch_heat_maps_to_landmarks(\n                    batch_maps_small_pred, batch_size=batch_size, image_size=int(self.image_size\/4),\n                    num_landmarks=self.num_landmarks)\n\n                if j == 0:\n                    all_pred_landmarks = batch_pred_landmarks.copy()\n                else:\n                    all_pred_landmarks = np.concatenate((all_pred_landmarks, batch_pred_landmarks), 0)\n\n        reminder = num_images-num_batches*batch_size\n        if reminder > 0:\n\n            batch_images = images[-reminder:, :, :, :]\n            batch_maps_small_pred = session.run(self.pred_hm_p, {self.images: batch_images})\n            if self.allocate_once:\n                batch_heat_maps_to_landmarks_alloc_once(\n                    batch_maps=batch_maps_small_pred,\n                    batch_landmarks=self.valid_landmarks_pred[-reminder:, :, :],\n                    batch_size=reminder, image_size=int(self.image_size\/4), num_landmarks=self.num_landmarks)\n            else:\n                batch_pred_landmarks = batch_heat_maps_to_landmarks(\n                    batch_maps_small_pred, batch_size=reminder, image_size=int(self.image_size\/4),\n                    num_landmarks=self.num_landmarks)\n\n                all_pred_landmarks = np.concatenate((all_pred_landmarks, batch_pred_landmarks), 0)\n\n        if not self.allocate_once:\n            return all_pred_landmarks\n\n    def create_summary_ops(self):\n\n        self.batch_summary_op = tf.summary.scalar('l_total', self.total_loss)\n\n        if self.compute_nme:\n            l_nme = tf.summary.scalar('l_nme', self.nme_loss)\n            self.batch_summary_op = tf.summary.merge([self.batch_summary_op, l_nme])\n\n        if self.log_histograms:\n            var_summary = [tf.summary.histogram(var.name, var) for var in tf.trainable_variables()]\n            grads = tf.gradients(self.total_loss, tf.trainable_variables())\n            grads = list(zip(grads, tf.trainable_variables()))\n            grad_summary = [tf.summary.histogram(var.name + '\/grads', grad) for grad, var in grads]\n            activ_summary = [tf.summary.histogram(layer.name, layer) for layer in self.all_layers]\n            self.batch_summary_op = tf.summary.merge([self.batch_summary_op, var_summary, grad_summary, activ_summary])\n\n        if self.augment_texture and self.log_artistic_augmentation_probs:\n            p_texture_summary = tf.summary.scalar('p_texture', self.p_texture_log)\n            self.batch_summary_op = tf.summary.merge([self.batch_summary_op, p_texture_summary])\n\n        if self.augment_geom and self.log_artistic_augmentation_probs:\n            p_geom_summary = tf.summary.scalar('p_geom', self.p_geom_log)\n            self.batch_summary_op = tf.summary.merge([self.batch_summary_op, p_geom_summary])\n\n        if self.valid_size > 0 and self.compute_nme:\n            self.valid_summary = tf.summary.scalar('valid_l_nme', self.valid_nme_loss)\n\n        if self.sample_to_log:\n            img_map_summary =tf.summary.image('compare_map_to_gt',self.log_image_map)\n            if self.sample_per_channel:\n                map_channels_summary = tf.summary.image('compare_map_channels_to_gt', self.log_map_channels)\n                self.img_summary = tf.summary.merge([img_map_summary, map_channels_summary])\n            else:\n                self.img_summary = img_map_summary\n            if self.valid_size >= self.sample_grid:\n                img_map_summary_valid = tf.summary.image('compare_map_to_gt_valid', self.log_image_map)\n                if self.sample_per_channel:\n                    map_channels_summary_valid = tf.summary.image('compare_map_channels_to_gt_valid', self.log_map_channels)\n                    self.img_summary_valid = tf.summary.merge([img_map_summary_valid, map_channels_summary_valid])\n                else:\n                    self.img_summary_valid = img_map_summary_valid\n\n    def eval(self):\n\n        self.add_placeholders()\n        # build model\n        self.build_model()\n        self.create_loss_ops()\n\n        if self.debug:\n            self.img_menpo_list = self.img_menpo_list[:np.min([self.debug_data_size, len(self.img_menpo_list)])]\n\n        num_images = len(self.img_menpo_list)\n        img_inds = np.arange(num_images)\n\n        sample_iter = np.ceil(1. * num_images \/ self.sample_grid).astype('int')\n\n        with tf.Session(config=self.config) as sess:\n\n            # load trained parameters\n            print ('loading test model...')\n            saver = tf.train.Saver()\n            saver.restore(sess, self.test_model_path)\n\n            _, model_name = os.path.split(self.test_model_path)\n\n            gt_provided = self.img_menpo_list[0].has_landmarks  # check if GT landmarks provided\n\n            for i in range(sample_iter):\n\n                batch_inds = img_inds[i * self.sample_grid:(i + 1) * self.sample_grid]\n\n                if not gt_provided:\n                    batch_images = load_images(self.img_menpo_list, batch_inds, image_size=self.image_size,\n                                               c_dim=self.c_dim, scale=self.scale)\n\n                    batch_maps_small_pred = sess.run(self.pred_hm_p, {self.images: batch_images})\n\n                    batch_maps_gt = None\n                else:\n                    # TODO: add option for approx maps + allocate once\n                    batch_images, batch_maps_gt, _ = \\\n                        load_images_landmarks_maps(\n                            self.img_menpo_list, batch_inds, primary=True, image_size=self.image_size,\n                            c_dim=self.c_dim, num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                            save_landmarks=False)\n\n                    batch_maps_small_pred = sess.run(self.pred_hm_p, {self.images: batch_images})\n\n                sample_path_imgs = os.path.join(\n                    self.save_sample_path, model_name +'-'+ self.test_data+'-sample-%d-to-%d-1.png' % (\n                        i * self.sample_grid, (i + 1) * self.sample_grid))\n\n                merged_img = merge_images_landmarks_maps_gt(\n                    batch_images.copy(), batch_maps_small_pred, batch_maps_gt, image_size=self.image_size,\n                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale, circle_size=0,\n                    fast=self.fast_img_gen)\n\n                scipy.misc.imsave(sample_path_imgs, merged_img)\n\n                if self.sample_per_channel:\n                    map_per_channel = map_comapre_channels(\n                        batch_images.copy(), batch_maps_small_pred,batch_maps_gt, image_size=int(self.image_size\/4),\n                        num_landmarks=self.num_landmarks, scale=self.scale)\n\n                    sample_path_channels = os.path.join(\n                        self.save_sample_path, model_name + '-' + self.test_data + '-sample-%d-to-%d-3.png' % (\n                            i * self.sample_grid, (i + 1) * self.sample_grid))\n\n                    scipy.misc.imsave(sample_path_channels, map_per_channel)\n\n                print ('saved %s' % sample_path_imgs)\n\n            if self.compute_nme and self.test_data in ['full', 'challenging', 'common', 'training', 'test']:\n                print ('\\n Calculating NME on: ' + self.test_data + '...')\n                pred_lms, lms_gt = self.predict_landmarks_in_batches(self.img_menpo_list, sess)\n                nme = sess.run(self.nme_loss, {self.pred_lms_small: pred_lms, self.lms_small: lms_gt})\n                print ('NME on ' + self.test_data + ': ' + str(nme))\n\n    def train(self):\n        # set random seed\n        tf.set_random_seed(1234)\n        np.random.seed(1234)\n        # build a graph\n        # add placeholders\n        self.add_placeholders()\n        # build model\n        self.build_model()\n        # create loss ops\n        self.create_loss_ops()\n        # create summary ops\n        self.create_summary_ops()\n\n        # create optimizer and training op\n        global_step = tf.Variable(0, trainable=False)\n        lr = tf.train.exponential_decay(self.learning_rate,global_step, self.step, self.gamma, staircase=True)\n        if self.adam_optimizer:\n            optimizer = tf.train.AdamOptimizer(lr)\n        else:\n            optimizer = tf.train.MomentumOptimizer(lr, self.momentum)\n\n        train_op = optimizer.minimize(self.total_loss,global_step=global_step)\n\n        # TODO: remove\n        if self.approx_maps_gpu:  # create heat-maps using tf convolution. use only with GPU support!\n            self.build_hm_generator()\n\n        with tf.Session(config=self.config) as sess:\n\n            tf.global_variables_initializer().run()\n\n            # load pre trained weights if load_pretrain==True\n            if self.load_pretrain:\n                print\n                print('*** loading pre-trained weights from: '+self.pre_train_path+' ***')\n                loader = tf.train.Saver()\n                loader.restore(sess, self.pre_train_path)\n                print(\"*** Model restore finished, current global step: %d\" % global_step.eval())\n\n            # for fine-tuning, choose reset_training_op==True. when resuming training, reset_training_op==False\n            if self.reset_training_op:\n                print (\"resetting optimizer and global step\")\n                opt_var_list = [optimizer.get_slot(var, name) for name in optimizer.get_slot_names()\n                                 for var in tf.global_variables() if optimizer.get_slot(var, name) is not None]\n                opt_var_list_init = tf.variables_initializer(opt_var_list)\n                opt_var_list_init.run()\n                sess.run(global_step.initializer)\n\n            # create model saver and file writer\n            summary_writer = tf.summary.FileWriter(logdir=self.save_log_path, graph=tf.get_default_graph())\n            saver = tf.train.Saver()\n\n            print\n            print('*** Start Training ***')\n\n            # initialize some variables before training loop\n            resume_step = global_step.eval()\n            num_train_images = len(self.img_menpo_list)\n            batches_in_epoch = int(float(num_train_images) \/ float(self.batch_size))\n            epoch = int(resume_step \/ batches_in_epoch)\n            img_inds = self.epoch_inds_shuffle[epoch, :]\n            p_texture = self.p_texture\n            p_geom = self.p_geom\n            artistic_reload = False\n            basic_reload = True\n            log_valid = True\n            log_valid_images = True\n\n            if self.allocate_once:\n                batch_images = np.zeros([self.batch_size, self.image_size, self.image_size, self.c_dim]).astype('float32')\n                batch_lms_small = np.zeros([self.batch_size, self.num_landmarks, 2]).astype('float32')\n                batch_lms_small_pred = np.zeros([self.batch_size, self.num_landmarks, 2]).astype('float32')\n                if self.approx_maps_gpu:\n                    batch_hm_base_small = np.zeros((self.batch_size * self.num_landmarks,\n                                                    int(self.image_size\/4), int(self.image_size\/4), 1)).astype('float32')\n                else:\n                    batch_maps_small = np.zeros((self.batch_size, int(self.image_size\/4),\n                                                 int(self.image_size\/4), self.num_landmarks)).astype('float32')\n\n            if self.approx_maps_cpu:\n                gaussian_filt = create_gaussian_filter(sigma=self.sigma, win_mult=self.win_mult)\n\n            for step in range(resume_step, self.train_iter):\n\n                j = step % batches_in_epoch  # j==0 if we finished an epoch\n\n                if step > resume_step and j == 0:  # if we finished an epoch and this isn't the first step\n                    epoch += 1\n                    img_inds = self.epoch_inds_shuffle[epoch, :]  # get next shuffled image inds\n                    artistic_reload = True\n                    log_valid = True\n                    log_valid_images = True\n                    if self.use_epoch_data:\n                        epoch_dir = os.path.join(self.epoch_data_dir, str(epoch))\n                        self.img_menpo_list = load_menpo_image_list(\n                            self.img_path, train_crop_dir=epoch_dir, img_dir_ns=None, mode=self.mode,\n                            bb_dictionary=self.bb_dictionary, image_size=self.image_size, test_data=self.test_data,\n                            augment_basic=False, augment_texture=False, augment_geom=False)\n\n                # add basic augmentation (if basic_start > 0 and augment_basic is True)\n                if basic_reload and (epoch >= self.basic_start) and self.basic_start > 0 and self.augment_basic:\n                    basic_reload = False\n                    self.img_menpo_list = reload_menpo_image_list(\n                        self.img_path, self.train_crop_dir, self.img_dir_ns, self.mode, self.train_inds,\n                        image_size=self.image_size, augment_basic=self.augment_basic,\n                        augment_texture=(self.augment_texture and epoch >= self.artistic_start), p_texture=p_texture,\n                        augment_geom=(self.augment_geom and epoch >= self.artistic_start), p_geom=p_geom)\n                    print (\"****** adding basic augmentation ******\")\n\n                # increase artistic augmentation probability\n                if ((epoch % self.artistic_step == 0 and epoch >= self.artistic_start and self.artistic_step != -1)\n                    or (epoch == self.artistic_start)) and (self.augment_geom or self.augment_texture)\\\n                        and artistic_reload:\n\n                    artistic_reload = False\n\n                    if epoch == self.artistic_start:\n                        print (\"****** adding artistic augmentation ******\")\n                        print (\"****** augment_geom: \" + str(self.augment_geom) + \", p_geom: \" + str(p_geom) + \" ******\")\n                        print (\"****** augment_texture: \" + str(self.augment_texture) + \", p_texture: \" +\n                               str(p_texture) + \" ******\")\n\n                    if epoch % self.artistic_step == 0 and self.artistic_step != -1:\n                        print (\"****** increasing artistic augmentation probability ******\")\n\n                        p_geom = 1.- 0.95 ** (epoch\/self.artistic_step)\n                        p_texture = 1. - 0.95 ** (epoch\/self.artistic_step)\n\n                        print (\"****** augment_geom: \" + str(self.augment_geom) + \", p_geom: \" + str(p_geom) + \" ******\")\n                        print (\"****** augment_texture: \" + str(self.augment_texture) + \", p_texture: \" +\n                               str(p_texture) + \" ******\")\n\n                    self.img_menpo_list = reload_menpo_image_list(\n                        self.img_path, self.train_crop_dir, self.img_dir_ns, self.mode, self.train_inds,\n                        image_size=self.image_size, augment_basic=(self.augment_basic and epoch >= self.basic_start),\n                        augment_texture=self.augment_texture, p_texture=p_texture,\n                        augment_geom=self.augment_geom, p_geom=p_geom)\n\n                # get batch images\n                batch_inds = img_inds[j * self.batch_size:(j + 1) * self.batch_size]\n\n                if self.approx_maps_gpu:  # TODO: remove\n                    if self.allocate_once:\n                        load_images_landmarks_alloc_once(\n                            self.img_menpo_list, batch_inds, images=batch_images, landmarks_small=batch_lms_small,\n                            landmarks=None, primary=True, image_size=self.image_size, scale=self.scale)\n\n                        create_heat_maps_base_alloc_once(\n                            landmarks_small=batch_lms_small.astype(int), landmarks=None,\n                            hm_small=batch_hm_base_small, hm_large=None, primary=True, num_images=self.batch_size,\n                            num_landmarks=self.num_landmarks)\n                    else:\n                        batch_images, batch_lms_small = load_images_landmarks(\n                            self.img_menpo_list, batch_inds, primary=True, image_size=self.image_size, c_dim=self.c_dim,\n                            num_landmarks=self.num_landmarks, scale=self.scale)\n\n                        batch_hm_base_small = create_heat_maps_base(\n                            landmarks_small=batch_lms_small.astype(int), landmarks=None, primary=True,\n                            num_images=self.batch_size, image_size=self.image_size, num_landmarks=self.num_landmarks)\n\n                    batch_maps_small = sess.run(self.filt_hm_small, {self.sparse_hm_small: batch_hm_base_small})\n                elif self.approx_maps_cpu:\n                    if self.allocate_once:\n                        load_images_landmarks_approx_maps_alloc_once(\n                            self.img_menpo_list, batch_inds, images=batch_images, maps_small=batch_maps_small,\n                            maps=None, landmarks=batch_lms_small, primary=True, image_size=self.image_size,\n                            num_landmarks=self.num_landmarks, scale=self.scale, gauss_filt_small=gaussian_filt,\n                            win_mult=self.win_mult, sigma=self.sigma, save_landmarks=self.compute_nme)\n                    else:\n                        batch_images, batch_maps_small, batch_lms_small = load_images_landmarks_approx_maps(\n                            self.img_menpo_list, batch_inds, primary=True, image_size=self.image_size,\n                            num_landmarks=self.num_landmarks, c_dim=self.c_dim, scale=self.scale,\n                            gauss_filt_small=gaussian_filt, win_mult=self.win_mult, sigma=self.sigma,\n                            save_landmarks=self.compute_nme)\n                else:\n                    if self.allocate_once:\n                        load_images_landmarks_maps_alloc_once(\n                            self.img_menpo_list, batch_inds, images=batch_images, maps_small=batch_maps_small,\n                            landmarks=batch_lms_small, maps=None, primary=True, image_size=self.image_size,\n                            num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                            save_landmarks=self.compute_nme)\n                    else:\n                        batch_images, batch_maps_small, batch_lms_small = load_images_landmarks_maps(\n                            self.img_menpo_list, batch_inds, primary=True, image_size=self.image_size, c_dim=self.c_dim,\n                            num_landmarks=self.num_landmarks, scale=self.scale, sigma=self.sigma,\n                            save_landmarks=self.compute_nme)\n\n                feed_dict_train = {self.images: batch_images, self.heatmaps_small: batch_maps_small}\n\n                sess.run(train_op, feed_dict_train)\n\n                # save to log and print status\n                if step == resume_step or (step + 1) % self.print_every == 0:\n\n                    # log probability of artistic augmentation\n                    if self.log_artistic_augmentation_probs and (self.augment_geom or self.augment_texture):\n                        if self.augment_geom and not self.augment_texture:\n                            art_augment_prob_dict = {self.p_geom_log: p_geom}\n                        elif self.augment_texture and not self.augment_geom:\n                            art_augment_prob_dict = {self.p_texture_log: p_texture}\n                        else:\n                            art_augment_prob_dict = {self.p_texture_log: p_texture, self.p_geom_log: p_geom}\n\n                    # train data log\n                    if self.compute_nme:\n                        batch_maps_small_pred = sess.run(self.pred_hm_p, {self.images: batch_images})\n                        if self.allocate_once:\n                            batch_heat_maps_to_landmarks_alloc_once(\n                                batch_maps=batch_maps_small_pred, batch_landmarks=batch_lms_small_pred,\n                                batch_size=self.batch_size, image_size=int(self.image_size\/4),\n                                num_landmarks=self.num_landmarks)\n                        else:\n                            batch_lms_small_pred = batch_heat_maps_to_landmarks(\n                                batch_maps_small_pred, self.batch_size, image_size=int(self.image_size\/4),\n                                num_landmarks=self.num_landmarks)\n\n                        train_feed_dict_log = {\n                            self.images: batch_images, self.heatmaps_small: batch_maps_small,\n                            self.train_lms_small: batch_lms_small, self.train_pred_lms_small: batch_lms_small_pred}\n                        if self.log_artistic_augmentation_probs and (self.augment_geom or self.augment_texture):\n                            train_feed_dict_log.update(art_augment_prob_dict)\n\n                        summary, l_t, l_nme = sess.run(\n                            [self.batch_summary_op, self.total_loss, self.nme_loss], train_feed_dict_log)\n\n                        print (\n                            'epoch: [%d] step: [%d\/%d] primary loss: [%.6f] NME: [%.6f]' % (\n                                epoch, step + 1, self.train_iter, l_t, l_nme))\n                    else:\n                        train_feed_dict_log = {self.images: batch_images, self.heatmaps_small: batch_maps_small}\n                        if self.log_artistic_augmentation_probs and (self.augment_geom or self.augment_texture):\n                            train_feed_dict_log.update(art_augment_prob_dict)\n\n                        summary, l_t = sess.run(\n                            [self.batch_summary_op, self.total_loss], train_feed_dict_log)\n\n                        print (\n                            'epoch: [%d] step: [%d\/%d] primary loss: [%.6f]' % (\n                                epoch, step + 1, self.train_iter, l_t))\n\n                    summary_writer.add_summary(summary, step)\n\n                    # valid data log\n                    if self.valid_size > 0 and (log_valid and epoch % self.log_valid_every == 0)\\\n                            and self.compute_nme:\n                        log_valid = False\n\n                        if self.allocate_once:\n                            self.predict_landmarks_in_batches_loaded(self.valid_images_loaded, sess)\n                            valid_feed_dict_log = {\n                                self.valid_lms_small: self.valid_landmarks_loaded,\n                                self.valid_pred_lms_small: self.valid_landmarks_pred}\n                        else:\n                            valid_pred_lms = self.predict_landmarks_in_batches_loaded(self.valid_images_loaded, sess)\n                            valid_feed_dict_log = {\n                                self.valid_lms_small: self.valid_landmarks_loaded,\n                                self.valid_pred_lms_small: valid_pred_lms}\n\n                        v_summary,l_v_nme = sess.run([self.valid_summary, self.valid_nme_loss], valid_feed_dict_log)\n                        summary_writer.add_summary(v_summary, step)\n\n                        print (\n                            'epoch: [%d] step: [%d\/%d] valid NME: [%.6f]' % (\n                                epoch, step + 1, self.train_iter, l_v_nme))\n\n                # save model\n                if (step + 1) % self.save_every == 0:\n                    saver.save(sess, os.path.join(self.save_model_path, 'deep_heatmaps'), global_step=step + 1)\n                    print ('model\/deep-heatmaps-%d saved' % (step + 1))\n\n                # save images. TODO: add option to allocate once\n                if step == resume_step or (step + 1) % self.sample_every == 0:\n\n                    if not self.compute_nme:\n                        batch_maps_small_pred = sess.run(self.pred_hm_p,  {self.images: batch_images})\n                        batch_lms_small_pred=None\n\n                    merged_img = merge_images_landmarks_maps_gt(\n                        batch_images.copy(), batch_maps_small_pred, batch_maps_small,\n                        landmarks=batch_lms_small_pred, image_size=self.image_size,\n                        num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale,\n                        circle_size=0, fast=self.fast_img_gen)\n\n                    if self.sample_per_channel:\n                        map_per_channel = map_comapre_channels(\n                            batch_images.copy(), batch_maps_small_pred,batch_maps_small,\n                            image_size=int(self.image_size\/4), num_landmarks=self.num_landmarks, scale=self.scale)\n\n                    if self.sample_to_log:\n                        if self.sample_per_channel:\n                            summary_img = sess.run(\n                                self.img_summary, {self.log_image_map: np.expand_dims(merged_img, 0),\n                                                   self.log_map_channels: np.expand_dims(map_per_channel, 0)})\n                        else:\n                            summary_img = sess.run(\n                                self.img_summary, {self.log_image_map: np.expand_dims(merged_img, 0)})\n\n                        summary_writer.add_summary(summary_img, step)\n\n                        if (self.valid_size >= self.sample_grid) and self.save_valid_images and\\\n                                (log_valid_images and epoch % self.log_valid_every == 0):\n                            log_valid_images=False\n\n                            batch_maps_small_pred_val = sess.run(\n                                self.pred_hm_p, {self.images: self.valid_images_loaded[:self.sample_grid]})\n\n                            merged_img = merge_images_landmarks_maps_gt(\n                                self.valid_images_loaded[:self.sample_grid].copy(), batch_maps_small_pred_val,\n                                self.valid_gt_maps_loaded, image_size=self.image_size,\n                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid,\n                                scale=self.scale, circle_size=0, fast=self.fast_img_gen)\n\n                            if self.sample_per_channel:\n                                map_per_channel = map_comapre_channels(\n                                    self.valid_images_loaded[:self.sample_grid].copy(), batch_maps_small_pred_val,\n                                    self.valid_gt_maps_loaded, image_size=int(self.image_size\/4),\n                                    num_landmarks=self.num_landmarks, scale=self.scale)\n\n                                summary_img = sess.run(\n                                    self.img_summary_valid, {self.log_image_map: np.expand_dims(merged_img, 0),\n                                                       self.log_map_channels: np.expand_dims(map_per_channel, 0)})\n                            else:\n                                summary_img = sess.run(\n                                    self.img_summary_valid, {self.log_image_map: np.expand_dims(merged_img, 0)})\n                            summary_writer.add_summary(summary_img, step)\n\n                    else:\n                        sample_path_imgs = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-1.png'\n                                                        % (epoch, step + 1))\n                        scipy.misc.imsave(sample_path_imgs, merged_img)\n                        if self.sample_per_channel:\n                            sample_path_ch_maps = os.path.join(self.save_sample_path, 'epoch-%d-train-iter-%d-3.png'\n                                                               % (epoch, step + 1))\n                            scipy.misc.imsave(sample_path_ch_maps, map_per_channel)\n\n            print('*** Finished Training ***')\n\n    def get_maps_image(self, test_image, reuse=None):\n        self.add_placeholders()\n        # build model\n        pred_hm_p = self.heatmaps_network(self.images,reuse=reuse)\n\n        with tf.Session(config=self.config) as sess:\n            # load trained parameters\n            saver = tf.train.Saver()\n            saver.restore(sess, self.test_model_path)\n            _, model_name = os.path.split(self.test_model_path)\n\n            test_image = test_image.pixels_with_channels_at_back().astype('float32')\n            if self.scale is '255':\n                test_image *= 255\n            elif self.scale is '0':\n                test_image = 2 * test_image - 1\n\n            test_image_map = sess.run(pred_hm_p, {self.images: np.expand_dims(test_image,0)})\n\n        return test_image_map\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_126","text":"import random\nimport numpy as np\nfrom statistics import mean\n\n# Using \"random\" to create a dataset\ndef create_dataset(hm, variance, step=2, correlation=False):\n    val = 1\n    sy = []\n    for i in range(hm):\n        y = val + random.randrange(-variance, variance)\n        sy.append(y)\n        if correlation and correlation == 'pos':\n            val += step\n        elif correlation and correlation == 'neg':\n            val -= step\n\n    sx = [i for i in range(len(sy))]\n\n    return np.array(sx, dtype=np.float64), np.array(sy, dtype=np.float64)\n\n\n# finding best fit slope and intercept of dataset\ndef best_fit_slope_and_intercept(sx, sy):\n    m = (((mean(sx) * mean(sy)) - mean(sx * sy)) \/\n         ((mean(sx) * mean(sx)) - mean(sx * sx)))\n\n    b = mean(sy) - m * mean(sx)\n\n    return m, b\n\n\n# dataset - coefficient of determination\ndef coefficient_of_determination(sy_orig, sy_line):\n    y_mean_line = [mean(sy_orig) for y in sy_orig]\n\n    squared_error_regr = sum((sy_line - sy_orig) * (sy_line - sy_orig))\n    squared_error_y_mean = sum((y_mean_line - sy_orig) * (y_mean_line - sy_orig))\n\n    print(squared_error_regr)\n    print(squared_error_y_mean)\n\n    r_squared = 1 - (squared_error_regr \/ squared_error_y_mean)\n\n    return r_squared\n\n\ndef get_result():\n    sx, sy = create_dataset(20, 10, 3)\n    m, b = best_fit_slope_and_intercept(sx, sy)\n    regression_line = [(m * x) + b for x in sx]\n    r_squared = coefficient_of_determination(sy, regression_line)\n    print('Rsquared result: ')\n    return r_squared"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_127","text":"import os\nimport pandas as pd\nimport numpy as np\n\nimport tsfresh.feature_extraction.feature_calculators as fc\n\nfrom scipy.fftpack import fft\nfrom notebook.pca_reduction import PCAReduction\nfrom notebook.utils import general_normalization, universal_normalization, trim_or_pad_data,\tfeature_matrix_extractor\nfrom notebook.utils import modelAndSave\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn import svm\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import classification_report\n\n\nTRIM_DATA_SIZE_BUY = 30\nGESTURE = 'buy'\n\ndef feature_vector_buy_ind(trimmed_data, column_name, isBuy=False, test=False):\n\n    r = trimmed_data[column_name]\n    if column_name == 'rightWrist_x':\n        normRawColumn = universal_normalization(r, trimmed_data, x_norm=True)\n    else:\n        normRawColumn = universal_normalization(r, trimmed_data, x_norm=False)\n    normRawColumn = general_normalization(normRawColumn)\n\n    diffNormRawData = np.diff(normRawColumn)\n\n    zeroCrossingArray = np.array([])\n    maxDiffArray = np.array([])\n\n    # Fast Fourier Transform\n    fftArray = np.array([])\n    fftVal = []\n    fft_coefficients = fft(diffNormRawData, n=6)[1:]\n    fft_coefficients_real = [value.real for value in fft_coefficients]\n    fftVal += fft_coefficients_real\n    fftArray = np.append(fftArray, fftVal)\n\n    # Windowed Mean for each second of the video\n    windowedVal = np.array([])\n    for i in range(0,diffNormRawData.shape[0],30):\n        windowedVal = np.append(windowedVal, fc.mean(diffNormRawData[i:i+30]))\n\n    # Other features\n    if diffNormRawData[0] > 0:\n        initSign = 1\n    else:\n        initSign = 0\n\n    windowSize = 5\n\n    for x in range(1, len(diffNormRawData)):\n\n        if diffNormRawData[x] > 0:\n            newSign = 1\n        else:\n            newSign = 0\n\n        if initSign != newSign:\n            zeroCrossingArray = np.append(zeroCrossingArray, x)\n            initSign = newSign\n            maxIndex = np.minimum(len(diffNormRawData), x + windowSize)\n            minIndex = np.maximum(0, x - windowSize)\n\n            maxVal = np.amax(diffNormRawData[minIndex:maxIndex])\n            minVal = np.amin(diffNormRawData[minIndex:maxIndex])\n\n            maxDiffArray = np.append(maxDiffArray, (maxVal - minVal))\n\n    index = np.argsort(-maxDiffArray)\n\n    featureVector = np.array([])\n    featureVector = np.append(featureVector, fftArray)\n    featureVector = np.append(featureVector, windowedVal)\n    featureVector = np.append(featureVector, maxDiffArray[index[0:5]])\n\n    if TRIM_DATA_SIZE_BUY - 1 > featureVector.shape[0]:\n        featureVector = np.pad(featureVector, (0, TRIM_DATA_SIZE_BUY - featureVector.shape[0] - 1), 'constant')\n    featureVector = featureVector[:TRIM_DATA_SIZE_BUY - 1]\n    if not test:\n        if isBuy:\n            featureVector = np.append(featureVector, 1)\n        else:\n            featureVector = np.append(featureVector, 0)\n    return featureVector\n\n\ndef feature_vector_buy(data, isBuy=False, test=False):\n    trimmed_data = trim_or_pad_data(data, TRIM_DATA_SIZE_BUY)\n    featureVector = feature_vector_buy_ind(trimmed_data, 'rightWrist_x', isBuy, test=True)\n    featureVector = np.append(featureVector, feature_vector_buy_ind(trimmed_data, 'rightWrist_y', isBuy, test))\n\n    return featureVector\n\n\ndef modeling_buy(dirPath):\n    listDir = ['buy']\n    featureMatrixBuy = feature_matrix_extractor(dirPath, listDir, feature_vector_buy, pos_sample=True)\n    buy_df = pd.DataFrame(featureMatrixBuy)\n\n    # Number of negative samples per folder needed to balance the dataset with positive and negative samples\n    count_neg_samples = buy_df.shape[0] \/ 5\n    listDir = ['communicate', 'really', 'hope', 'mother', 'fun']\n    featureMatrixNotBuy = feature_matrix_extractor(dirPath, listDir, feature_vector_buy, pos_sample=False,\n                                                      th=count_neg_samples)\n    not_buy_df = pd.DataFrame(featureMatrixNotBuy)\n\n    final_df = pd.concat([buy_df, not_buy_df], ignore_index=True)\n    shuffled_df = final_df.sample(frac=1, random_state=42).reset_index(drop=True)\n    labelVector = shuffled_df.pop(shuffled_df.shape[1]-1)\n    labelVector = labelVector.astype(int).tolist()\n\n    final_df, pca, minmax = PCAReduction(shuffled_df)\n\n    modelAndSave(final_df, labelVector, GESTURE, pca, minmax)\n\n    # clf = svm.SVC(random_state=42, probability=True)\n    # clf = svm.SVC(random_state=42)\n    clf = LogisticRegression(random_state=42)\n    # clf = MLPClassifier(max_iter=5000, random_state=42)\n    # clf = GaussianNB()\n\n\n    # 70:30 Train-Test Split\n    train_size = int(final_df.shape[0] * 70 \/ 100)\n    clf.fit(final_df.iloc[:train_size, :], labelVector[:train_size])\n    pred_labels = clf.predict(final_df.iloc[train_size:, :])\n    true_labels = labelVector[train_size:]\n    print(classification_report(true_labels, pred_labels))\n\n\n# TEST Function:\n# modeling_buy(os.path.abspath('..\/JSON'))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_116","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Apr 10 14:19:04 2020\n\n@author: corkep\n\n\"\"\"\n\n\nimport numpy as np\nimport numpy.testing as nt\nimport unittest\nfrom math import pi\nimport math\nfrom scipy.linalg import logm, expm\n\nfrom spatialmath.base.transforms3d import *\nfrom spatialmath.base.numeric import *\nfrom spatialmath.base.transformsNd import isR, t2r, r2t, rt2tr\n\nimport matplotlib.pyplot as plt\n\n\nclass TestVelocity(unittest.TestCase):\n    def test_numjac(self):\n\n        # test on algebraic example\n        def f(X):\n            x = X[0]\n            y = X[1]\n            return np.r_[x, x ** 2, x * y ** 2]\n\n        nt.assert_array_almost_equal(\n            numjac(f, [2, 3]),\n            np.array([[1, 0], [4, 0], [9, 12]]),  # x, 0  # 2x, 0  # y^2, 2xy\n        )\n\n        # test on rotation matrix\n        nt.assert_array_almost_equal(numjac(rotx, [0], SO=3), np.array([[1, 0, 0]]).T)\n\n        nt.assert_array_almost_equal(\n            numjac(rotx, [pi \/ 2], SO=3), np.array([[1, 0, 0]]).T\n        )\n\n        nt.assert_array_almost_equal(numjac(roty, [0], SO=3), np.array([[0, 1, 0]]).T)\n\n        nt.assert_array_almost_equal(numjac(rotz, [0], SO=3), np.array([[0, 0, 1]]).T)\n\n    def test_rpy2jac(self):\n\n        # ZYX order\n        gamma = [0, 0, 0]\n        nt.assert_array_almost_equal(rpy2jac(gamma), numjac(rpy2r, gamma, SO=3))\n        gamma = [pi \/ 4, 0, -pi \/ 4]\n        nt.assert_array_almost_equal(rpy2jac(gamma), numjac(rpy2r, gamma, SO=3))\n        gamma = [-pi \/ 4, pi \/ 2, pi \/ 4]\n        nt.assert_array_almost_equal(rpy2jac(gamma), numjac(rpy2r, gamma, SO=3))\n\n        # XYZ order\n        f = lambda gamma: rpy2r(gamma, order=\"xyz\")\n        gamma = [0, 0, 0]\n        nt.assert_array_almost_equal(\n            rpy2jac(gamma, order=\"xyz\"), numjac(f, gamma, SO=3)\n        )\n        f = lambda gamma: rpy2r(gamma, order=\"xyz\")\n        gamma = [pi \/ 4, 0, -pi \/ 4]\n        nt.assert_array_almost_equal(\n            rpy2jac(gamma, order=\"xyz\"), numjac(f, gamma, SO=3)\n        )\n        f = lambda gamma: rpy2r(gamma, order=\"xyz\")\n        gamma = [-pi \/ 4, pi \/ 2, pi \/ 4]\n        nt.assert_array_almost_equal(\n            rpy2jac(gamma, order=\"xyz\"), numjac(f, gamma, SO=3)\n        )\n\n    def test_eul2jac(self):\n\n        # ZYX order\n        gamma = [0, 0, 0]\n        nt.assert_array_almost_equal(eul2jac(gamma), numjac(eul2r, gamma, SO=3))\n        gamma = [pi \/ 4, 0, -pi \/ 4]\n        nt.assert_array_almost_equal(eul2jac(gamma), numjac(eul2r, gamma, SO=3))\n        gamma = [-pi \/ 4, pi \/ 2, pi \/ 4]\n        nt.assert_array_almost_equal(eul2jac(gamma), numjac(eul2r, gamma, SO=3))\n\n    def test_exp2jac(self):\n\n        # ZYX order\n        gamma = np.r_[1, 0, 0]\n        nt.assert_array_almost_equal(exp2jac(gamma), numjac(exp2r, gamma, SO=3))\n        print(numjac(exp2r, gamma, SO=3))\n\n        gamma = np.r_[0.2, 0.3, 0.4]\n        nt.assert_array_almost_equal(exp2jac(gamma), numjac(exp2r, gamma, SO=3))\n        gamma = np.r_[0, 0, 0]\n        nt.assert_array_almost_equal(exp2jac(gamma), numjac(exp2r, gamma, SO=3))\n\n    def test_rot2jac(self):\n\n        gamma = [0.1, 0.2, 0.3]\n        R = rpy2r(gamma, order=\"zyx\")\n        A = rot2jac(R, representation=\"rpy\/zyx\")\n        self.assertEqual(A.shape, (6, 6))\n        A3 = np.linalg.inv(A[3:6, 3:6])\n        nt.assert_array_almost_equal(A3, rpy2jac(gamma, order=\"zyx\"))\n\n        gamma = [0.1, 0.2, 0.3]\n        R = rpy2r(gamma, order=\"xyz\")\n        A = rot2jac(R, representation=\"rpy\/xyz\")\n        self.assertEqual(A.shape, (6, 6))\n        A3 = np.linalg.inv(A[3:6, 3:6])\n        nt.assert_array_almost_equal(A3, rpy2jac(gamma, order=\"xyz\"))\n\n        gamma = [0.1, 0.2, 0.3]\n        R = eul2r(gamma)\n        A = rot2jac(R, representation=\"eul\")\n        self.assertEqual(A.shape, (6, 6))\n        A3 = np.linalg.inv(A[3:6, 3:6])\n        nt.assert_array_almost_equal(A3, eul2jac(gamma))\n\n        gamma = [0.1, 0.2, 0.3]\n        R = trexp(gamma)\n        A = rot2jac(R, representation=\"exp\")\n        self.assertEqual(A.shape, (6, 6))\n        A3 = np.linalg.inv(A[3:6, 3:6])\n        nt.assert_array_almost_equal(A3, exp2jac(gamma))\n\n    def test_angvelxform(self):\n\n        gamma = [0.1, 0.2, 0.3]\n        A = angvelxform(gamma, full=False, representation=\"rpy\/zyx\")\n        Ai = angvelxform(gamma, full=False, inverse=True, representation=\"rpy\/zyx\")\n        nt.assert_array_almost_equal(Ai, rpy2jac(gamma, order=\"zyx\"))\n        nt.assert_array_almost_equal(A @ Ai, np.eye(3))\n\n        gamma = [0.1, 0.2, 0.3]\n        A = angvelxform(gamma, full=False, representation=\"rpy\/xyz\")\n        Ai = angvelxform(gamma, full=False, inverse=True, representation=\"rpy\/xyz\")\n        nt.assert_array_almost_equal(Ai, rpy2jac(gamma, order=\"xyz\"))\n        nt.assert_array_almost_equal(A @ Ai, np.eye(3))\n\n        gamma = [0.1, 0.2, 0.3]\n        A = angvelxform(gamma, full=False, representation=\"eul\")\n        Ai = angvelxform(gamma, full=False, inverse=True, representation=\"eul\")\n        nt.assert_array_almost_equal(Ai, eul2jac(gamma))\n        nt.assert_array_almost_equal(A @ Ai, np.eye(3))\n\n        gamma = [0.1, 0.2, 0.3]\n        A = angvelxform(gamma, full=False, representation=\"exp\")\n        Ai = angvelxform(gamma, full=False, inverse=True, representation=\"exp\")\n        nt.assert_array_almost_equal(Ai, exp2jac(gamma))\n        nt.assert_array_almost_equal(A @ Ai, np.eye(3))\n\n    # def test_angvelxform_dot(self):\n\n    #     gamma = [0.1, 0.2, 0.3]\n    #     options = dict(full=False, representation='rpy\/zyx')\n\n    #     f = lambda gamma: angvelxform(gamma, options)\n\n    #     nt.assert_array_almost_equal(angvelxform_dot(gamma, options), numjac(f))\n\n\n# ---------------------------------------------------------------------------------------#\nif __name__ == \"__main__\":\n\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_128","text":"#!\/usr\/bin\/env python\n\n\"\"\"\nUsage:\n>> server.py --time 60 --batch 64\n>> .\/make_gif.py transition --name transition --time 15 --batch 64\n\"\"\"\nimport os\nos.environ[\"KERAS_BACKEND\"] = \"tensorflow\"\nimport time\nimport cv2\nfrom keras import callbacks as cbks\nfrom keras import backend as K\nimport logging\nimport tensorflow as tf\nimport numpy as np\nfrom scipy.misc import imsave, imresize\nfrom tqdm import *\n\nfrom server import client_generator\nmixtures = 1\n\n\nif __name__ == \"__main__\":\n  import argparse\n  parser = argparse.ArgumentParser(description='MiniBatch server')\n  parser.add_argument('model', type=str, default=\"transition\", help='Model definitnion file')\n  parser.add_argument('--name', type=str, default=\"transition\", help='Name of the model.')\n  parser.add_argument('--host', type=str, default=\"localhost\", help='Data server ip address.')\n  parser.add_argument('--port', type=int, default=5557, help='Port of server.')\n  parser.add_argument('--time', type=int, default=1, help='How many temporal frames in a single input.')\n  parser.add_argument('--batch', type=int, default=256, help='Batch size.')\n  parser.add_argument('--epoch', type=int, default=200, help='Number of epochs.')\n  parser.add_argument('--gpu', type=int, default=0, help='Which gpu to use')\n  parser.add_argument('--loadweights', dest='loadweights', action='store_true', help='Start from checkpoint.')\n  parser.set_defaults(skipvalidate=False)\n  parser.set_defaults(loadweights=False)\n  args = parser.parse_args()\n\n  MODEL_NAME = args.model\n  logging.info(\"Importing get_model from {}\".format(args.model))\n  exec(\"from models.\"+MODEL_NAME+\" import get_model, load, save\")\n  # try to import `cleanup` from model file\n  try:\n    exec(\"from models.\"+MODEL_NAME+\" import cleanup\")\n  except:\n    cleanup = old_cleanup\n\n  model_code = open('models\/'+MODEL_NAME+'.py').read()\n\n  with tf.Session() as sess:\n    K.set_session(sess)\n    g_train, d_train, sampler, saver, loader, [G, E, T] = get_model(sess=sess, name=args.name, batch_size=args.batch, gpu=args.gpu)\n\n    print(\"loading weights...\")\n    G.load_weights(\".\/results_autoencoder\/G_weights.keras\".format(args.name))\n    E.load_weights(\".\/results_autoencoder\/E_weights.keras\".format(args.name))\n    checkpoint_dir = '.\/results_' + args.name\n    T.load_weights(checkpoint_dir+\"\/T_weights.keras\")\n\n    if not os.path.exists(\".\/video_\"+args.name):\n      os.makedirs(\".\/video_\"+args.name)\n\n    # get data\n    data = client_generator(hwm=20, host=\"localhost\", port=5557)\n    X = next(data)[0]  # [:, ::2]\n    sh = X.shape\n    X = X.reshape((-1, 3, 160, 320))\n    X = np.asarray([cv2.resize(x.transpose(1, 2, 0), (160, 80)) for x in X])\n    X = X\/127.5 - 1.\n    x = X.reshape((sh[0], args.time, 80, 160, 3))\n\n    # estimate frames\n    z_dim = 512\n    I = E.input\n    E_out = E(I)\n    O = G.input\n    G_out = G(O)\n    print \"Sampling...\"\n    for i in tqdm(range(128)):\n      x = x.reshape((-1, 80, 160, 3))\n      # code = E.predict(x, batch_size=args.batch*args.time)[0]\n      code = sess.run([E_out[0]], feed_dict={I: x, K.learning_phase(): 1})[0]\n      code = code.reshape((args.batch, args.time, z_dim))\n      inp = code[:, :5]  # context is based on the first 5 frames only\n      outs = T.predict(inp, batch_size=args.batch)\n      imgs = sess.run([G_out], feed_dict={O: outs.reshape((-1, z_dim)), K.learning_phase(): 1})[0]\n      # imgs = G.predict(outs[:, 0], batch_size=args.batch)\n      x = x.reshape((args.batch, args.time, 80, 160, 3))\n      x[0, :-1] = x[0, 1:]\n      x[0, -1] = imgs[0]\n      imsave(\"video_\"+args.name+\"\/%03d.png\" % i, imresize(imgs[0], (160, 320)))\n\n    cmd = \"ffmpeg -y -i .\/video_\"+args.name+\"\/%03d.png .\/video_\"+args.name+\"\/output.gif -vf fps=1\"\n    print(cmd)\n    os.system(cmd)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_129","text":"<reponame>vafaei-ar\/pymce\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport sys\nimport numpy as np\nimport pylab as plt\nfrom pandas import DataFrame\nfrom .splitters import Splitter\nfrom sklearn.metrics import roc_auc_score\nfrom sklearn.neighbors import VALID_METRICS\nfrom sklearn.ensemble import IsolationForest\nfrom sklearn.metrics import matthews_corrcoef\nfrom sklearn.neighbors import LocalOutlierFactor\nfrom scipy.spatial.distance import braycurtis,canberra,chebyshev,cityblock\nfrom scipy.spatial.distance import correlation,minkowski,wminkowski\n\nfrom .utils import COLORS\n\nall_metrics = ['cityblock','L2','L4','braycurtis',\n               'canberra','chebyshev','correlation']\n\ndef plot_main_shapes(X,labels,cl=16):\n\n    ll = int(np.sqrt(len(np.unique(labels))))\n    l1 = ll+1\n    l2 = len(np.unique(labels))\/\/l1+1\n    fig,axs = plt.subplots(l2,l1,figsize=(4*l1,4*l2))\n\n    [axi.set_xticks([]) for axi in axs.ravel()]\n    [axi.set_yticks([]) for axi in axs.ravel()]\n\n    clrs = 4*COLORS\n    for i in np.unique(labels).astype(int):\n        X0 = X[labels==i]\n        try:\n            ax = axs[i\/\/l1,i%l1]\n        except:\n            ax = axs[i\/\/l1]\n        ax.set_title(X0.shape[0],y=0.9)\n        ax.plot(np.percentile(X0,50,axis=0),color=clrs[i])\n        ax.plot(np.mean(X0,axis=0),ls='-.',color='k')\n        ax.fill_between(np.arange(X0.shape[1]),\n                         np.percentile(X0,cl,axis=0),\n                         np.percentile(X0,100-cl,axis=0),\n                         color=clrs[i],\n                         alpha=0.5)\n\n    plt.subplots_adjust(wspace=0.01,hspace=0.01)\n\n\ndef get_main_shapes(X,labels,trsh=0.1):\n    main_shapes = []\n    for i in np.unique(labels).astype(int):\n        filt = labels==i\n        if np.mean(filt)<trsh: continue\n        X0 = X[filt]\n        main_shapes.append(np.mean(X0,axis=0))\n    return np.array(main_shapes)\n\ndef clip(x ,a_min=None, a_max=None):\n    if a_min is None:\n        a_min = x.min()\n    if a_max is None:\n        a_max = x.max()  \n    return np.clip(x,a_min,a_max)\n\ndef L2(u, v):\n    return minkowski(u, v, 2)\ndef L4(u, v):\n    return minkowski(u, v, 4)\ndef expL4(u, v):\n    x = clip(minkowski(u, v, 4),a_min=0,a_max=700)\n    return np.exp(x)\n\ndist_funcs = {'braycurtis':braycurtis,'canberra':canberra,'chebyshev':chebyshev,\n                            'cityblock':cityblock,'correlation':correlation,'L2':L2\n                            ,'L4':L4,'expL4':expL4}\n\ndef dist(metr,comp,X,w=None,w_norm=False):\n    func = dist_funcs[metr]\n    n_test = X.shape[0]\n    n_c = comp.shape[0]\n    all_dist = np.zeros(n_c)\n    dist = np.zeros(n_test)\n    for i in range(n_test):\n        for j in range(n_c):\n            if metr=='correlation':\n                if np.std(X[i])==0:\n                    X[i][0] += 1e-7\n                if np.std(comp[j])==0:\n                    comp[j][0] += 1e-7                    \n            if w is None:\n                all_dist[j] = func(X[i],comp[j])\n            else:\n                if w_norm:\n                    w = w-w.min()+0.01\n                    w = w\/w.max()\n                all_dist[j] = func(X[i],comp[j],w[j])\n        dist[i] = np.nan_to_num(np.min(all_dist))\n    return dist\n\ndef outliers_real(X,components,metrics=None):\n\n    if isinstance(metrics, str):\n        metrics = [metrics]\n\n    if metrics is None:\n        metrics = ['cityblock','L2','L4','expL4','braycurtis',\n                   'canberra','chebyshev','correlation']\n    distance = {}\n    for metric in metrics:\n        distance_test = dist(metric,np.array(components),X)\n        distance[metric] = distance_test\n    return distance\n\ndef MCC(outliers,v,n_o=None):\n    if n_o is None:\n        n_o = int(outliers.sum())\n    o_ind = np.argsort(v)[::-1]\n    o_ind = o_ind[:n_o]\n    pred = np.zeros(outliers.shape)\n    pred[o_ind] = 1\n    return matthews_corrcoef(outliers.astype(int),pred)\n\ndef rws_score(outliers,v,n_o=None):\n    if n_o is None:\n        n_o = int(outliers.sum())\n    b_s = np.arange(n_o)+1\n    o_ind = np.argsort(v)[::-1]\n    o_ind = o_ind[:n_o]\n    return 1.*np.sum(b_s*outliers[o_ind].reshape(-1))\/b_s.sum()\n\ndef golden_distance(X,labels,cl=16):\n    distances = []\n    for i in np.unique(labels).astype(int):\n        X0 = X[labels==i]\n        sm = np.percentile(X0,50,axis=0)\n    #     np.mean(X0,axis=0)\n        sl = np.percentile(X0,cl,axis=0)\n        su = np.percentile(X0,100-cl,axis=0)\n        distances.append(np.abs(X-sm)\/(su-sl))\n    distances = np.array(distances)\n    return np.min(np.mean(distances,axis=-1),axis=0)\n    \n\ndef sk_check(X_train,X_test,y_test,o_list):\n    \n    f_f = [LocalOutlierFactor(n_neighbors=5),\\\n    LocalOutlierFactor(n_neighbors=10),\\\n    LocalOutlierFactor(n_neighbors=35),\\\n    IsolationForest(max_samples='auto')]\n    f_name = ['LOF5','LOF10','LOF35','i-forest']\n\n    columns = ['method']+['AUC','MCC','RWS']\n    n_row = 2\n    index = np.arange(n_row) # array of numbers for the number of samples\n    df = DataFrame(columns=columns, index = index)\n    y_test = np.array(y_test)\n    exec('T_o ='+(' | '.join(['(y_test=='+str(i)+')' for i in o_list])),locals(),globals())\n\n    auc_max = -1\n    for i in range(3):\n        lof = f_f[i]\n        lof.fit(X_test)\n        outliers = -lof.negative_outlier_factor_\n\n        auc_test = roc_auc_score(T_o, outliers)\n        if auc_test>auc_max:\n            auc_max = auc_test\n            df['method'][0] = f_name[i]\n            df['MCC'][0] = MCC(T_o, outliers)\n            df['AUC'][0] = auc_max\n            df['RWS'][0] = rws_score(T_o, outliers)\n\n    df['method'][1] = f_name[3]\n    isof = f_f[3]\n    isof.fit(X_train)\n    scores_pred = isof.decision_function(X_test)\n    outliers = scores_pred.max()-scores_pred\n    df['MCC'][1] = MCC(T_o, outliers)\n    df['AUC'][1] = roc_auc_score(T_o, outliers)\n    df['RWS'][1] = rws_score(T_o, outliers)\n\n    return df\n    \ndef d_lof(X_seen,X_unseen=None,n_neighbors=20,algorithm='auto',metric='minkowski'):\n    lof = LocalOutlierFactor(n_neighbors = n_neighbors,\n                             algorithm = algorithm,\n                             metric = metric,\n                             novelty=not (X_unseen is None),\n                             n_jobs=-1)\n    lof.fit(X_seen)\n    if X_unseen is None:\n        return -lof.negative_outlier_factor_\n    else:\n        return -lof.score_samples(X_unseen)\n\ndef grid_run_lof(X_seen,y_seen=None,\n                 X_unseen=None,y_unseen=None,\n                 n_neighbors = [5,20,35],\n                 algorithms = ['ball_tree', 'kd_tree', 'brute'],\n                 metrics=None):\n    '''         \n    This function is able to deal with three modes:\n    1- Unsupervised outlier detection \n    2- Semi-supervised outlier detection\n    3- Novelty detection  \n    '''      \n    \n    novelty = 0   \n    semisupervised = 0 \n    if (np.all(y_seen==0)) | (y_seen is None):\n        novelty = 1\n        X_unseen_p = X_unseen\n        y_seen = y_unseen\n        print('Novelty detection mode.')\n        conds = (X_unseen is not None and y_unseen is not None)\n        assert conds,'In novelty detection you need to input the unseen data sets.'\n    elif y_unseen is not None and X_unseen is not None:\n        semisupervised = 1\n#        print('Semi-supervised option is not available for novelty detection.')\n        X_unseen_p = None\n        print('Semi-supervised outlier detection mode.')\n    elif X_seen is not None:\n        X_unseen_p = X_unseen\n        print('Unsupervised outlier detection mode.')\n    else:\n        assert 0, 'The configuration is not recognized!'\n        \n    aucs,mccs,rwss,conf = [],[],[],[]\n\n    for nn in n_neighbors:\n        for al in algorithms:\n            if metrics is None:\n                metrics = VALID_METRICS[al]\n            for mt in metrics:\n                try:\n                    outliers = d_lof(X_seen=X_seen,X_unseen=X_unseen_p,n_neighbors=nn,algorithm=al,metric=mt)\n                    conf.append([nn,al,mt])\n                    aucs.append(roc_auc_score(y_seen, outliers))\n                    mccs.append(MCC(y_seen, outliers))\n                    rwss.append(rws_score(y_seen, outliers))\n                except:\n                    pass\n\n                    \n    if semisupervised:\n        nn,al,mt = conf[np.argmax(aucs)]\n        outliers = d_lof(X_seen=X_unseen,n_neighbors=nn,algorithm=al,metric=mt)\n        auc = roc_auc_score(y_unseen, outliers)\n        \n        nn,al,mt = conf[np.argmax(mccs)]\n        outliers = d_lof(X_seen=X_unseen,n_neighbors=nn,algorithm=al,metric=mt)\n        mcc = roc_auc_score(y_unseen, outliers)\n        \n        nn,al,mt = conf[np.argmax(rwss)]\n        outliers = d_lof(X_seen=X_unseen,n_neighbors=nn,algorithm=al,metric=mt)\n        rws = roc_auc_score(y_unseen, outliers)\n        \n        return auc,mcc,rws\n    \n    else:\n        return np.array(aucs),np.array(mccs),np.array(rwss),np.array(conf)\n\ndef d_iforest(X_seen,X_unseen=None,n_estimators=100,max_features=1.0,bootstrap=False):\n    isof = IsolationForest(n_estimators=n_estimators,\n                           max_features=max_features,\n                           bootstrap=bootstrap,\n                           behaviour=\"new\",\n                           n_jobs=-1)\n    isof.fit(X_seen)\n    if X_unseen is None:\n        scores_pred = isof.decision_function(X_seen)\n    else:\n        scores_pred = isof.decision_function(X_unseen)\n    return scores_pred.max()-scores_pred\n\ndef grid_run_iforest(X_seen,y_seen,\n                     X_unseen=None,y_unseen=None,\n                     n_estimators= [50,100,150],\n                     max_features= [0.2,0.5,1.0],\n                     bootstrap=[False,True]):\n                 \n    '''         \n    This function is able to deal with three modes:\n    1- Unsupervised outlier detection \n    2- Semi-supervised outlier detection\n    3- Novelty detection  \n    '''      \n    \n    novelty = 0   \n    semisupervised = 0 \n    if (np.all(y_seen==0)) | (y_seen is None):\n        novelty = 1\n        X_unseen_p = X_unseen\n        y_seen = y_unseen\n        print('Novelty detection mode.')\n        conds = (X_unseen is not None and y_unseen is not None)\n        assert conds,'In novelty detection you need to input the unseen data sets.'\n    elif y_unseen is not None and X_unseen is not None:\n        semisupervised = 1\n#        print('Semi-supervised option is not available for novelty detection.')\n        X_unseen_p = None\n        print('Semi-supervised outlier detection mode.')\n    elif X_seen is not None:\n        X_unseen_p = X_unseen\n        print('Unsupervised outlier detection mode.')\n    else:\n        assert 0, 'The configuration is not recognized!'\n\n    aucs,mccs,rwss,conf = [],[],[],[]\n\n    for ns in n_estimators:\n        for mf in max_features:\n            for bs in bootstrap:\n                conf.append([ns,mf,bs])\n                outliers = d_iforest(X_seen,X_unseen_p,n_estimators=ns,max_features=mf,bootstrap=bs)\n                aucs.append(roc_auc_score(y_seen, outliers))\n                mccs.append(MCC(y_seen, outliers))\n                rwss.append(rws_score(y_seen, outliers))\n                \n    if semisupervised:\n        ns,mf,bs = conf[np.argmax(aucs)]\n        outliers = d_iforest(X_unseen,n_estimators=ns,max_features=mf,bootstrap=bs)\n        auc = roc_auc_score(y_unseen, outliers)\n        \n        ns,mf,bs = conf[np.argmax(mccs)]\n        outliers = d_iforest(X_unseen,n_estimators=ns,max_features=mf,bootstrap=bs)\n        mcc = roc_auc_score(y_unseen, outliers)\n        \n        ns,mf,bs = conf[np.argmax(rwss)]\n        outliers = d_iforest(X_unseen,n_estimators=ns,max_features=mf,bootstrap=bs)\n        rws = roc_auc_score(y_unseen, outliers)\n        \n        return auc,mcc,rws\n    \n    else:\n        return np.array(aucs),np.array(mccs),np.array(rwss),np.array(conf)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_130","text":"<reponame>DocVaughan\/CRAWLAB-Code-Snippets\n#! \/usr\/bin\/env python \n\n##########################################################################################\n# trajectory_animation.py\n#\n# Script to a demonstrate a simple animation of a trajectory showing a vector\n# force field \n#\n# NOTE: Plotting is set up for output, not viewing on screen.\n#       So, it will likely be ugly on screen. The saved PDFs should look\n#       better.\n# \n# Created: 12\/6\/13 \n#   - <NAME> \n#   - <EMAIL>\n#   - http:\/\/www.ucs.louisiana.edu\/~jev9637\n#\n# Modified:\n#   * 06\/26\/20 - JEV \n#       - updated for new animation API\n#       - styling updated to match CRAWLAB norms\n#\n##########################################################################################\n\n\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\n\n\ndef eq_of_motion(states, t, p):\n    \"\"\"\n    Defines the differential equations for the coupled spring-mass system.\n\n    Arguments:\n        states :  vector of the state variables:\n        t :  time\n        p :  vector of the parameters:\n    \"\"\"\n    x, x_dot, y, y_dot = states\n    m, kp, kd, L, StartTime, Fmax, FcurAmp, FcurAngle = p\n\n    # Create system diff eq\n    sysODE = [x_dot,\n              1\/m * (np.dot(F(t, states, p),  [1, 0]) + np.dot(Fcur(t, p), [1, 0])),\n              y_dot,\n              1\/m * (np.dot(F(t, states, p), [0, 1]) + np.dot(Fcur(t, p), [0, 1]))]\n    \n    return sysODE\n    \n    \ndef F(t, states, p):\n    \"\"\" \n    Defines the force\/control input to the system. Is limited by Fmax\n    \n    Note: This is not tuned for best performance. It's effectively placeholder.\n    \"\"\"\n    x, x_dot, y, y_dot = states\n    m, kp, kd, L, StartTime, Fmax, FcurAmp, FcurAngle = p\n\n    Lx, Ly = L\n    endpoint = des_pos(t,L,StartTime)\n    xd = endpoint[0]\n    yd = endpoint[1]\n    \n    # We're using the non-derivative kick version of the PD controller\n    Fx = kp * (xd - x) + kd * (-x_dot)\n    Fy = kp * (yd - y) + kd * (-y_dot)\n    \n    # Limit the force to within symmetric limits defined by Umax\n    #   There are more clever\/faster ways to do this, but this is most easiest \n    #   to understand.\n    F_amp = np.sqrt(Fx**2 + Fy**2)\n    F_ang = np.arctan2(Fy, Fx)\n    \n    if F_amp > Fmax:\n        F_amp = Fmax\n    \n    Fx = F_amp * np.cos(F_ang)\n    Fy = F_amp * np.sin(F_ang)\n    \n    F = np.array([Fx, Fy])\n    \n    return F\n        \n\ndef Fcur(t,p):\n    \"\"\"\n    Defines the current disturbance input to the system\n    \"\"\"\n    \n    # Unpack variables\n    m, kp, kd, L, StartTime, Fmax, FcurAmp, FcurAngle = p\n    \n    Current_Amplitude = FcurAmp\n    cur_angle = FcurAngle\n    \n    Fcur = Current_Amplitude * np.asarray([np.cos(cur_angle), np.sin(cur_angle)])\n    \n    return Fcur\n    \n\ndef des_pos(t, L, StartTime):\n    \"\"\"\n    defines the desired trajectory\n    \"\"\"\n    \n    Lx, Ly = L   # unpack the two desired end coords\n    \n    xd = 5 * np.cos(0.1 * 2 * np.pi * t)\n    yd = 5 * np.sin(0.1 * 2 * np.pi * t)\n    \n    des_pos = np.array([xd, yd])\n    \n    return des_pos\n\n\n#---- Main script -----------------------------------------------------------------------\n\n# System Parameters\nm = 1.0             # mass\nkp = 40.0\nkd = 35.0\nFmax = 100\n\n# Water current parameters\nFcurAmp = 25.0                   # amplitude of the effective current force\nFcurAngle = np.deg2rad(30.0)     # angle of the effective current force\n\n\n# Input Parameters\nLx = 100.0                # Desired X position\nLy = 100.0                # Desired Y position\nStartTime = 0.0           # Time of command start\n\n# ODE solver parameters\nabserr = 1.0e-8\nrelerr = 1.0e-6\nstoptime = 15.0\nnumpoints = 1501\nstepmax = 0.01\n\n# Create the time samples for the output of the ODE solver.\n# create a time array from 0..100 sampled at 0.1 second steps\ndt = 0.05\nt = np.arange(0.0, stoptime + dt, dt)\n\n\n# Pack up the parameters and initial conditions:\nL = [Lx, Ly]\np = [m, kp, kd, L, StartTime, Fmax, FcurAmp, FcurAngle]\n\n# Initial conditions\nx_init, y_init = des_pos(0,L,StartTime)\nx_dot_init = 0.0\ny_dot_init = 0.0\n# Pack them into a vector\nx0 = [x_init, x_dot_init, y_init, y_dot_init]\n\n\n# Call the ODE solver.\nresp = odeint(eq_of_motion, x0, t, args=(p,), atol=abserr, rtol=relerr)\n\n# get the x and y position responses for plotting\nx_resp = resp[:,0]\ny_resp = resp[:,2]\n\n# Save the desired trajectory for plotting too\ndesired_traj = des_pos(t, L, StartTime)\nx_desired = desired_traj[0]\ny_desired = desired_traj[1]\n\n# Get current for plotting\nFcurrent = np.zeros((len(t), 2))\n\n# Set up vector field of current\nfor ii in np.arange(len(t)):\n    Fcurrent[ii,:] = Fcur(t[ii], p)\n    \n# Define the range of x and y coordinates to draw the current quivers over\nxrange = np.linspace(-20, 20, 8) \nyrange = np.linspace(-10, 10, 8)\n    \ncurX, curY = np.meshgrid(xrange, yrange)\n\n\n# Set the plot size - 16x9 aspect ratio is best for videos\n# We are mostly setting up the size and overall plot formatting here.\n# The data here is just a placeholder, it will be filled during the animation\nfig = plt.figure(figsize=(8, 4.5))\nax = plt.gca()\nplt.subplots_adjust(bottom=0.17, left=0.17, top=0.96, right=0.96)\n\n# Change the axis units font\nplt.setp(ax.get_ymajorticklabels(),fontsize=18)\nplt.setp(ax.get_xmajorticklabels(),fontsize=18)\n\nax.spines['right'].set_color('none')\nax.spines['top'].set_color('none')\n\nax.xaxis.set_ticks_position('bottom')\nax.yaxis.set_ticks_position('left')\n\n# Turn on the plot grid and set appropriate linestyle and color\nax.grid(True, linestyle=':', color='0.75')\nax.set_axisbelow(True)\n\n# Define the X and Y axis labels\nplt.xlabel('X Position (m)', fontsize=22, weight='bold', labelpad=5)\nplt.ylabel('Y Position (m)', fontsize=22, weight='bold', labelpad=10)\n \n \n#  , '#377eb8', '#4daf4a', '#984ea3', '#ff7f00', '#ffff33', '#a65628'\n \n# define items to animate\ntime_template = 'Time = {:5.2f} s'\ntime_text = ax.text(0.05, 0.95, '', \n                    transform=ax.transAxes, \n                    fontsize=18, \n                    bbox=dict(facecolor='white', edgecolor='white', alpha=0.75))\n\nplt.plot(x_desired, y_desired, linewidth=2, color='#4daf4a', linestyle='-.', label=r'Desired')\n\n# This marker will serve as the vehicle\nmarker = ax.annotate('',xy=(x_resp[0], y_resp[0]),\n                    xytext=(x_resp[1], y_resp[1]),\n                    xycoords='data',\n                    arrowprops=dict(width=2, headlength=16, facecolor='#e41a1c', edgecolor='#e41a1c'),\n                    animated=True)\n\n# We'll trail the past behind the marker\nghost, = ax.plot([],[], '#e41a1c', linewidth=2, linestyle='-', alpha=1, label=r'Actual')\n\n# And use a quiver plot to represent the wind\/current\/etc\nQ = ax.quiver(curX, curY, \n              Fcurrent[:,0], Fcurrent[:,1], \n              color='#377eb8', \n              edgecolors=('#377eb8'), \n              alpha = 0.5,\n              width=0.0025, \n              animated=True)\n\n# uncomment below and set limits if needed\nplt.axis('equal')\nplt.xlim(-15, 15)\nplt.ylim(-10, 10)\n\n# Create the legend, then fix the fontsize\nleg = plt.legend(loc='upper right', ncol = 1, fancybox=True)\nltext  = leg.get_texts()\nplt.setp(ltext,fontsize=18)\n\n# Adjust the page layout filling the page using the new tight_layout command\nplt.tight_layout(pad=0.5)\n\n\n\n\ndef init():\n    '''\n    Define the items to animate\n    '''\n    \n    marker.xytext = ([], [])\n    marker.xy = ([], [])\n    \n    ghost.set_data([], [])\n    time_text.set_text('')\n    \n    ax.set_xlim(-15, 15)\n    ax.set_ylim(-10, 10)\n    \n    return marker, ghost, Q,\n    \n    \ndef animate(i):\n    ''' \n    Do the actual animation by updating values at each time step\n    '''\n    ax.set_xlim(-15, 15)\n    ax.set_ylim(-10, 10)\n    \n    Q.set_UVC(Fcurrent[i,0], Fcurrent[i,1])\n    \n    x = x_resp[i]\n    y = y_resp[i]\n    \n    \n    # Here, I just use the difference between the last position and the current\n    # one to get the angle. You can also use a heading response to determine\n    # this angle.\n    if i == 0:\n        last_x, last_y = 0, 0\n    else:\n        last_x, last_y = x_resp[i - 1], y_resp[i - 1]\n        \n    angle = np.arctan2((y - last_y), (x - last_x))\n    \n    x_base = x - 1.0\/2 * np.cos(angle)\n    y_base = y - 1.0\/2 * np.sin(angle)\n\n    marker.set_position((x_base, y_base))\n    marker.xytext = (x_base, y_base)\n    marker.xy = (x, y)\n        \n    # Leave a \"trail\" behind the boat to show the path it took\n    # You can leave the full trail\n    x_ghost = x_resp[:i]\n    y_ghost = y_resp[:i]\n    \n    # Or just a portion of it.\n    # Here, we have it hard coded to be a two second trail (2\/dt steps)\n    # x_ghost = x_resp[np.max((0, i-int(2\/dt))):i]\n    # y_ghost = y_resp[np.max((0, i-int(2\/dt))):i]\n    \n    ghost.set_data(x_ghost, y_ghost)\n    \n    time_text.set_text(time_template.format(i * dt))\n    \n    return marker, ghost, Q,\n    \n\n# Call the matplotlib animation function\nanim = animation.FuncAnimation(fig, \n                               animate, \n                               np.arange(1, len(resp)), \n                               init_func=init,\n                               interval=20, \n                               blit=True)\n\n\n# save the animation as an mp4.  This requires ffmpeg or mencoder to be\n# installed.  The extra_args ensure that the x264 codec is used, so that\n# the video can be embedded in html5.  You may need to adjust this for\n# your system: for more information, see\n# http:\/\/matplotlib.sourceforge.net\/api\/animation_api.html\nanim.save('trajectory_animation.mp4', fps=30, dpi=300, bitrate = 2500, extra_args=['-vcodec', 'libx264'])\n\n# close \"Figure\" - actually just removes from queue to show at next show() command\nplt.close(fig)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_131","text":"#!\/usr\/bin\/env python2\nfrom __future__ import print_function\nimport roslib\nimport sys\nimport rospy\nimport numpy as np\nimport datetime\nimport time\nfrom geometry_msgs.msg import PoseArray\nfrom geometry_msgs.msg import Pose\nfrom geometry_msgs.msg import PoseWithCovariance\nfrom nav_msgs.msg import Odometry\nfrom dse_msgs.msg import PoseMarkers\nfrom std_msgs.msg import Float64MultiArray\nfrom std_msgs.msg import MultiArrayLayout\nfrom std_msgs.msg import MultiArrayDimension\nfrom dse_msgs.msg import InfFilterResults\nfrom visualization_msgs.msg import Marker\nfrom scipy.spatial.transform import Rotation as R\nfrom gazebo_msgs.msg import LinkStates\nimport tf_conversions\nimport tf2_ros\n\nimport dse_lib\nimport dse_constants\nroslib.load_manifest('dse_simulation')\n\n\nclass information_filter:\n\n    # Define initial\/setup values\n    def __init__(self):\n\n        # Get parameters from launch file\n        self.ros_prefix = rospy.get_param('~prefix')\n        if len(self.ros_prefix) != 0 and self.ros_prefix[0] != '\/':\n            self.ros_prefix = '\/' + self.ros_prefix\n        self.tf_pretix = self.ros_prefix[1:]\n        self.this_agent_id = rospy.get_param('~id')\n        self.dim_state = rospy.get_param('~dim_state')\n\n        # self.ros_prefix = '\/tb3_0'\n        # self.tf_pretix = self.ros_prefix[1:]\n        # self.this_agent_id = 5\n        # self.dim_state = 6\n\n        self.camera_pose_sub = rospy.Subscriber(self.ros_prefix + \"\/dse\/pose_markers\", PoseMarkers, self.measurement_callback)\n        self.inf_results_sub = rospy.Subscriber(self.ros_prefix + \"\/dse\/inf\/results\", InfFilterResults, self.results_callback)\n        self.meas_vis_pub = rospy.Publisher(self.ros_prefix + \"\/dse\/vis\/measurement\", PoseArray, queue_size=10)\n\n        self.est_ids = []\n        self.est_vis_pubs = []#rospy.Publisher(self.ros_prefix + \"\/dse\/vis\/estimates\", PoseArray, queue_size=10)\n\n        if self.dim_state == 6:\n            self.dim_obs = 3\n        elif self.dim_state == 12:\n            self.dim_obs = 6\n        else:\n            rospy.signal_shutdown('invalid state dimension passed in')\n\n        # Define static variables\n        self.dt = 0.1\n        self.t_last = rospy.get_time()\n        self.gzbo_ref_obj_state = None\n        self.pthn_ref_obj_state = None\n\n    # Create pose_array for measurement data\n    def measurement_callback(self, data):\n        poses = PoseArray()\n        for pose_stamped in data.pose_array:\n            poses.poses += [pose_stamped.pose.pose]\n        poses.header.stamp = rospy.Time.now()\n        if self.ros_prefix == '':\n            poses.header.frame_id = 'odom'\n        else:\n            poses.header.frame_id = self.tf_pretix + '\/odom'\n        self.meas_vis_pub.publish(poses)\n\n    # Create pose_array for the information results\n    def results_callback(self, data):\n        inf_id_list = np.array(data.ids)\n        inf_Y = dse_lib.multi_array_2d_output(data.inf_matrix)\n        inf_y = dse_lib.multi_array_2d_output(data.inf_vector)\n        self.inf_x = np.linalg.inv(inf_Y).dot(inf_y)\n        inf_P = np.linalg.inv(inf_Y)\n        inf_P[inf_P < 0] = 0\n        inf_P = np.sqrt(inf_P)\n\n        odom = Odometry()\n        odom.header.stamp = rospy.Time.now()\n        odom.header.frame_id = self.tf_pretix + '\/odom'\n        # if self.ros_prefix == '':\n        #     odom.header.frame_id = 'base_footprint'\n        # else:\n        #     odom.header.frame_id = self.tf_pretix + '\/base_footprint'\n\n        for id in inf_id_list:\n            if id not in self.est_ids:\n                self.est_ids.append(id)\n                self.est_vis_pubs.append(rospy.Publisher(self.ros_prefix + \"\/dse\/vis\/estimates\/\" + str(id), Odometry, queue_size=10))\n\n        for id in inf_id_list:\n            i = np.where(inf_id_list == id)[0][0]\n            j = self.est_ids.index(id)\n\n            i_min = i * self.dim_state\n            i_max = i_min + self.dim_state\n            odom.pose.pose = dse_lib.pose_from_state_3D(self.inf_x[i_min:i_max])\n            cov = dse_lib.sub_matrix(inf_P, inf_id_list, id, self.dim_state)\n            cov = dse_lib.state_cov_to_covariance_matrix(cov)\n            odom.pose.covariance = list(dse_lib.covariance_to_ros_covariance(cov))\n            self.est_vis_pubs[j].publish(odom)\n\n\ndef main(args):\n\n    rospy.init_node('dse_gazebo_visualization_node', anonymous=True)\n    imf = information_filter()\n    try:\n        rospy.spin()\n    except KeyboardInterrupt:\n        print(\"Shutting down\")\n\n\nif __name__ == '__main__':\n    main(sys.argv)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_133","text":"#!\/usr\/bin\/env python\n\"\"\"MAGeCK test module\nCopyright (c) 2014 <NAME>, <NAME>, <NAME> lab\nThis code is free software; you can redistribute it and\/or modify it\nunder the terms of the BSD License (see the file COPYING included with\nthe distribution).\n@status:  experimental\n@version: $Revision$\n@author:  <NAME>\n@contact: li.david.wei AT gmail.com\n\"\"\"\n\n\nfrom __future__ import print_function\nimport sys\nimport math\nimport types\nimport logging\n\nfrom mageck.mageckCount import *\n\nfrom mageck.fileOps import *\nfrom mageck.testVisual import *\n\nfrom mageck.fdr_calculation import *\n\n\n\n\n# debug\n# try:\n#   from IPython.core.debugger import Tracer\n# except:\n#   pass\n\ndef mmedian(lst):\n  \"\"\"\n  get the median value\n  \"\"\"\n  sortedLst = sorted(lst)\n  lstLen = len(lst)\n  if lstLen==0:\n    return 0.0\n  index = (lstLen - 1) \/\/ 2\n\n  if (lstLen % 2):\n    return sortedLst[index]\n  else:\n    return (sortedLst[index] + sortedLst[index + 1])\/2.0\n\ndef getgeomean(v):\n  meanval=sum([math.log(vx+0.1,2) for vx in v])\/float(len(v))\n  return 2**meanval-0.1\n\ndef getMeans(matt):\n  # arithmatic mean\n  #meanvalue=[sum(v)\/float(len(v)) for v in matt]\n  # geometric mean\n  meanvalue=[getgeomean(v) for v in matt]\n  return meanvalue\n\ndef getVars(matt):\n  meanvalue=getMeans(matt)\n  varvalue=[ sum([ (kj-meanvalue[i])*(kj-meanvalue[i])  for kj in matt[i]  ]  )\/(float(len(matt[i]))-1)    for i in range(len(meanvalue))]\n  #varvalue={k:sum([ (x-meanvalue[k])*(x-meanvalue[k]) for x in v])\/(float(len(v))-1)  for (k,v) in ctable.iteritems()}\n  return varvalue\n\ndef leastsquare(x,y,weight=None):\n  \"\"\"\n  least squares fitting\n  coefficients from y= a+bx\n  return (b,a)\n  reference: http:\/\/mathworld.wolfram.com\/LeastSquaresFitting.html\n  For weighted least square: http:\/\/goo.gl\/pGpTZ6\n  \"\"\"\n  n=len(x)\n  if n != len(y):\n    logging.error('Unequal length of vectors of x and y in least square')\n    sys.exit(-1)\n  if weight is None:\n    sy=sum(y)\n    sx=sum(x)\n    sx2=sum([t*t for t in x])\n    sxy=sum([x[i]*y[i] for i in range(n)])\n    a=(sy*sx2-sx*sxy)\/(n*sx2-sx*sx)\n    b=(n*sxy-sx*sy)\/(n*sx2-sx*sx)\n    return (b,a)\n  else:\n    nw=sum(weight)\n    sy=sum([y[i]*weight[i] for i in range(n)])\n    sx=sum([x[i]*weight[i] for i in range(n)])\n    sx2=sum([x[i]*x[i]*weight[i] for i in range(n)])\n    sxy=sum([x[i]*y[i]*weight[i] for i in range(n)])\n    a=(sy*sx2-sx*sxy)\/(nw*sx2-sx*sx)\n    b=(nw*sxy-sx*sy)\/(nw*sx2-sx*sx)\n    return (b,a)\n\ndef modelmeanvar(ctable,method='edger'):\n  \"\"\"\n  model the relation between mean and variance\n  \"\"\"\n  # calculate the mean and variance\n  tablemat=ctable.values()\n  meanvalue=getMeans(tablemat)\n  varvalue=getVars(tablemat)\n  # choose values with variance greater than mean\n  meangood=[meanvalue[i] for i in range(len(meanvalue)) if meanvalue[i]<varvalue[i]]\n  vargood=[varvalue[i]-meanvalue[i] for i in range(len(varvalue)) if meanvalue[i]<varvalue[i]]\n  if len(meangood)<10:\n    logging.warning('The variances between control replicates are too small. If they are technical replicates, merge these into one sample.')\n    meangood=[meanvalue[i] for i in range(len(meanvalue)) ]\n    vargood=[(lambda x: x if x>0.01 else 0.01 )(varvalue[i]-meanvalue[i]) for i in range(len(varvalue)) ]\n  # log\n  meanglog=[math.log(x+1,2) for x in meangood]\n  varglog=[math.log(x+1,2) for x in vargood]\n  # Tracer()()\n  if method=='linear':\n    # least square\n    (k,b)=leastsquare(meanglog,varglog,meangood)\n    if k<1:\n      k=1\n    if b<0:\n      b=0\n    return (k,b)\n  elif method=='edger':\n    dy=varglog\n    dx=[2*x for x in meanglog]\n    ret=(sum(dy)-sum(dx))*1.0\/len(dx)\n    return ret\n  else:\n    return 0\n\n\ndef getadjustvar(coef,meanval,method='mixed'):\n  \"\"\"\n  From the model, get the adjusted variance\n  \"\"\"\n  if method=='linear':\n    k=coef[0];b=coef[1]\n    if type(meanval) is types.FloatType:\n      return (meanval**k)*(2**b)+meanval\n    if type(meanval) is types.ListType:\n      return [(z**k)*(2**b)+z for z in meanval]\n  elif method=='edger':\n    if type(meanval) is types.FloatType:\n      return (meanval**2)*(2**coef)+meanval\n    if type(meanval) is types.ListType:\n      return [(z**2)*(2**coef)+z for z in meanval]\n  elif method=='mixed':\n    var1=getadjustvar(coef,meanval,method='linear')\n    var2=getadjustvar(coef[2],meanval,method='edger')\n    return [ (lambda x,y: x if x>y else y)(var1[i],var2[i]) for i in range(len(var1))]\n  else:\n    return meanval\n\ndef getnormcdf(x,lowertail=True):\n  \"\"\"\n  Get the normal CDF function. used to calculate p-value\n  \"\"\"\n  # ax=math.fabs(x)\n  #axv=math.erfc(x\/(2**0.5))\/2; # higher tail\n  if lowertail==False:\n    #return axv\n    return math.erfc(x\/(2**0.5))\/2\n  else:\n    #return 1-axv\n    return math.erfc(-x\/(2**0.5))\/2\n  #if (x>0 and lowertail==False) or (x<0 and lowertail==True):\n  #  return axv\n  #else:\n  #  return 1-axv\n\ndef getNormalPValue(mean0,var0,mean1, lower=False):\n  \"\"\"\n  Use truncated normal distribution to calculate the pvalue\n  \"\"\"\n  # use ttmean to calculate the pvalue\n  n=len(mean0)\n  minmean1=min([x for x in mean1 if x>0])\n  mean1_adj=[(lambda x: x if x >minmean1 else minmean1)(t) for t in mean1]\n  # first, convert to standard normal distribution values\n  t_theta=[(mean1_adj[i]-mean0[i])\/math.sqrt(var0[i]) for i in range(n)]\n  t_theta_0=[(0.0-mean0[i])\/math.sqrt(var0[i]) for i in range(n)]\n  #\n  t_p=[getnormcdf(x,lowertail=lower) for x in t_theta]\n  t_p_0=[getnormcdf(x,lowertail=True) for x in t_theta_0]\n  if lower==True:\n    return [(t_p[i]-t_p_0[i])\/(1-t_p_0[i]) for i in range(n)]\n  else:\n    return [t_p[i]\/(1-t_p_0[i]) for i in range(n)]\n\n\ndef getNBPValue(mean0,var0,mean1, lower=False,log=False):\n  \"\"\"\n  Use negative binomial to calculate p-value\n  Reference:\n  http:\/\/docs.scipy.org\/doc\/scipy\/reference\/generated\/scipy.stats.nbinom.html#scipy.stats.nbinom\n  \"\"\"\n  from scipy.stats import nbinom\n  n=len(mean0)\n  nb_p=[mean0[i]\/var0[i] for i in range(n)]; # consisitent with R\n  nb_n0=[mean0[i]*mean0[i]\/(var0[i]-mean0[i]) for i in range(n)]\n  nb_n=[ (lambda t: t if t>=1 else 1)(x) for x in nb_n0]\n  #\n  if lower==True:\n    if log==False:\n      nb_p_low=nbinom.cdf(mean1,nb_n,nb_p)\n    else:\n      nb_p_low=nbinom.logcdf(mean1,nb_n,nb_p)\n    return list(nb_p_low)\n  else:\n    if log==False:\n      nb_p_low=nbinom.sf(mean1,nb_n,nb_p)\n    else:\n      nb_p_low=nbinom.logsf(mean1,nb_n,nb_p)\n    return list(nb_p_low)\n\ndef calculate_gene_lfc(args,lfcval,sort_id,n_lower,sgrna2genelist,destkeys,ispos=False):\n  \"\"\"\n  Calculate gene LFC using different methods\n  Parameters:\n    args\n        Arguments\n    lfcval\n        sgRNA log fold change vector\n    sortid\n        sgRNA sort index\n    n_lower\n        alpha cutoff (integer)\n    sgrna2genelist\n        a {sgrnaid:gene} dict\n    destkeys\n        a [sgrnaid] vector\n    ispos\n        a boolean vector to indicate whether this is a positive selection\n  Return value:\n    genelfc\n        a {geneid:lfc} dict\n  \"\"\"\n  genesglfc={}\n  ni=0\n  for i in sort_id:\n    ni+=1\n    targetgene=sgrna2genelist[destkeys[i]]\n    if targetgene not in genesglfc:\n      genesglfc[targetgene]=[]\n    if args.gene_lfc_method=='alphamean' or args.gene_lfc_method=='alphamedian':\n      if ni*1.0<=n_lower:\n        genesglfc[targetgene]+=[lfcval[i]]\n    else:\n      genesglfc[targetgene]+=[lfcval[i]]\n  genelfc={}\n  for (gid,vl) in genesglfc.items():\n    if args.gene_lfc_method=='median' or args.gene_lfc_method=='alphamedian':\n      lfc=mmedian(vl)\n    elif args.gene_lfc_method=='secondbest':\n      if ispos:\n        vll=sorted(vl,reverse=True)\n      else:\n        vll=sorted(vl)\n      if len(vll)>1:\n        lfc=vll[1]\n      else:\n        lfc=0.0\n    elif args.gene_lfc_method=='mean' or args.gene_lfc_method=='alphamean':\n      if len(vl)>0:\n        lfc=sum(vl)\/len(vl)\n      else:\n        lfc=0.0\n    else:\n      lfc=0.0\n    genelfc[gid]=lfc\n  return genelfc\n\ndef crispr_test(tab,ctrlg,testg, destfile,sgrna2genelist,args):\n  \"\"\"\n  main function of crispr test\n  Parameters:\n    tab\n        Read count table\n    ctrlg\n        Index for control samples\n    testg\n        Index for treatment samples\n    destfile\n        Prefix for output file (sgrna_summary.txt)\n    sgrna2genelist\n        {sgrna:gene} mapping\n    args\n        Arguments\n  Return value:\n    (lowp,highp,sgrnalfc)\n    lowp\n        alpha cutoff for neg. selection\n    highp\n        alpha cutoff for pos. selection\n    lower_gene_lfc\n        {gene:lfc} dict. lfc is for neg. selection\n    higher_gene_lfc\n        {gene:lfc} dict. lfc is for pos. selection\n  \"\"\"\n  n=len(tab)\n  # control and test matrix\n  tabctrl={k:[v[i] for i in range(len(v)) if i in ctrlg] for (k,v) in tab.iteritems()}\n  tabtest={k:[v[i] for i in range(len(v)) if i in testg] for (k,v) in tab.iteritems()}\n  # control matrix for mean-var estimation\n  if len(ctrlg)>1 and args.variance_from_all_samples==False: # more than 1 controls\n    tabctrlmod={k:[v[i] for i in range(len(v)) if i in ctrlg] for (k,v) in tab.iteritems()}\n  else: # only 1 control: use all the samples for estimation\n    tabctrlmod={k:[v[i] for i in range(len(v)) if i in (ctrlg+testg)] for (k,v) in tab.iteritems()}\n  # training using control samples\n  model1=modelmeanvar(tabctrlmod,method='linear')\n  #model2=modelmeanvar(tabctrl,method='edger')\n  model=[x for x in model1];#+[model2]\n  if type(model) is types.ListType:\n    logging.debug('Adjusted model: '+'\\t'.join([str(x) for x in model]))\n  else:\n    logging.debug('Adjusted model: k='+str(model))\n\n  tabctrl_mat=tabctrl.values()\n  tabctrlmodel_mat=tabctrlmod.values()\n  tabc_mean=getMeans(tabctrl_mat)\n  tabcmodel_mean=getMeans(tabctrlmodel_mat)\n  #\n  # setup the valid sgRNA flag\n  validsgrna=[1]*n\n  if hasattr(args,\"remove_zero\") and ( args.remove_zero==\"control\" or args.remove_zero==\"both\"):\n    validsgrna=[ (lambda x: 1 if x>0 else 0)(t) for t in tabc_mean]\n  # if mean of the control samples is 0: set it to greater than 0\n  tabc_min=min([x for x in tabc_mean if x>0])\n  tabc_mean=[ (lambda x: x if x>tabc_min else tabc_min)(t) for t in tabc_mean]\n  tabc_var=getVars(tabctrlmodel_mat)\n  tabc_adjvar=getadjustvar(model,tabc_mean,method='linear')\n\n  # testing using tebtest\n  nt=tabtest[tabtest.keys()[0]]\n  ttmat=tabtest.values()\n  ttmean=getMeans(ttmat)\n  # set up the valid sgRNA flag\n  if hasattr(args,\"remove_zero\") and ( args.remove_zero==\"treatment\" or args.remove_zero==\"both\"):\n    validsgrna2=[ (lambda x: 1 if x>0 else 0)(t) for t in ttmean]\n    validsgrna=[validsgrna[t]*validsgrna2[t] for t in range(n)]\n  # use ttmean to calculate the pvalue\n  # first, convert to standard normal distribution values\n  tt_theta=[(ttmean[i]-tabc_mean[i])\/math.sqrt(tabc_adjvar[i]) for i in range(n)]\n  tt_abstheta=[math.fabs(tt_theta[i]) for i in range(n)]\n  #\n  try:\n    # for consistency, use normal p values\n    tt_p_lower=getNormalPValue(tabc_mean,tabc_adjvar,ttmean,lower=True)\n    tt_p_higher=getNormalPValue(tabc_mean,tabc_adjvar,ttmean,lower=False)\n    #tt_p_lower=getNBPValue(tabc_mean,tabc_adjvar,ttmean,lower=True)\n    #tt_p_higher=getNBPValue(tabc_mean,tabc_adjvar,ttmean,lower=False)\n\n    # tt_p_lower_score=getNBPValue(tabc_mean,tabc_adjvar,ttmean,lower=True,log=True)\n    # tt_p_higher_score=getNBPValue(tabc_mean,tabc_adjvar,ttmean,lower=False,log=True)\n  #except ImportError:\n  #  #logging.warning('An error occurs while trying to compute p values using scipy. Will use normal model instead of Negative Binomial model, but please check with your scipy installation.')\n  #  #tt_p_lower=getNormalPValue(tabc_mean,tabc_adjvar,ttmean,lower=True)\n  #  #tt_p_higher=getNormalPValue(tabc_mean,tabc_adjvar,ttmean,lower=False)\n  except:\n    logging.error('An error occurs while trying to compute p values. Quit..')\n    sys.exit(-1)\n  #\n  #\n  tt_p_twosided=[ (lambda x,y: 2*x if x<y else 2*y)(tt_p_lower[i],tt_p_higher[i]) for i in range(n)]\n  tt_p_fdr=pFDR(tt_p_twosided,method=args.adjust_method)\n  #\n  # map sgRNA to genes\n  gene_list = []\n  sgrna_list = tabctrl.keys()\n  for sgrna in sgrna_list:\n    if sgrna2genelist is not None:\n      gene_list.append(sgrna2genelist[sgrna])\n    else:\n      gene_list.append('NA')\n  # normalize sgRNA scores and sort according to score\n  CNVnorm = False\n  if args.cnv_norm is not None and args.cell_line is not None:\n    from mageck.cnv_normalization import read_CNVdata,sgRNAscore_piecewisenorm\n    logging.info('Performing copy number normalization.')\n    (CN_arr,CN_celldict,CN_genedict) = read_CNVdata(args.cnv_norm,[args.cell_line])\n    if args.cell_line in CN_celldict:\n      logging.info('Normalizing by copy number with' + args.cell_line + 'as the reference cell line.')\n      CNVnorm = True\n      norm_tt_theta = sgRNAscore_piecewisenorm(tt_theta,gene_list,CN_arr,CN_genedict)\n      norm_tt_abstheta=[math.fabs(norm_tt_theta[i]) for i in range(n)]\n      sort_id=[i[0] for i in sorted(enumerate(norm_tt_abstheta), key=lambda x:x[1],reverse=True)]\n      # replace the original values of tt_theta\n      tt_theta=norm_tt_theta\n      tt_abstheta=norm_tt_abstheta\n    else:\n      logging.warning(args.cell_line + ' is not represented in the inputted copy number variation data.')\n      sort_id=[i[0] for i in sorted(enumerate(tt_abstheta), key=lambda x:x[1],reverse=True)]\n  else:\n    sort_id=[i[0] for i in sorted(enumerate(tt_abstheta), key=lambda x:x[1],reverse=True)]\n  #\n  # lower_score and higher_score are used to sort sgRNAs\n  tt_p_lower_score=tt_theta\n  tt_p_higher_score=[-1*x for x in tt_theta]\n  # write to file\n  destfname=destfile+'.sgrna_summary.txt'\n  destf=open(destfname,'w')\n  destkeys=tabctrl.keys()\n  dfmt=\"{:.5g}\"\n\n  # sgRNA log fold change\n  sgrnalfc=[0.0]*n\n  # output to file\n  header = ['sgrna','Gene','control_count','treatment_count','control_mean','treat_mean', 'LFC', 'control_var','adj_var','score','p.low','p.high','p.twosided','FDR','high_in_treatment']\n  #if CNVnorm:\n  #  header += ['CNVadj_score']\n  print('\\t'.join(header),file=destf)\n  for i in sort_id:\n    # sgRNA mapping to genes?\n    if sgrna2genelist is not None:\n      destkeygene=sgrna2genelist[destkeys[i]]\n    else:\n      destkeygene='None'\n    report=[destkeys[i], destkeygene, '\/'.join([dfmt.format(x) for x in tabctrl_mat[i]]), '\/'.join([dfmt.format(x) for x in ttmat[i]])]\n    t_r=[tabc_mean[i],ttmean[i]]\n    lfcval=math.log(ttmean[i]+1.0,2)-math.log(tabc_mean[i]+1.0,2)\n    t_r+=[ lfcval ] # log fold change\n    sgrnalfc[i]=lfcval # save log fold change\n    t_r+=[tabc_var[i],tabc_adjvar[i],tt_abstheta[i],tt_p_lower[i],tt_p_higher[i],tt_p_twosided[i],tt_p_fdr[i]]\n    report+=[dfmt.format(x) for x in t_r]\n    report+=[ttmean[i]>tabc_mean[i]]\n    #if CNVnorm:\n    #  report+=[dfmt.format(norm_tt_abstheta[i])] # add CNV-adjusted sgRNA scores\n    print('\\t'.join([str(x) for x in report]),file=destf)\n  destf.close()\n  #\n  # prepare files for gene test\n  if sgrna2genelist is not None:\n    destfname=destfile+'.plow.txt'\n    destkeys=tabctrl.keys()\n    sort_id=[i[0] for i in sorted(enumerate(tt_p_lower_score), key=lambda x:x[1],reverse=False)]\n    # output to file\n    destf=open(destfname,'w')\n    print('\\t'.join(['sgrna','symbol','pool','p.low','prob','chosen']),file=destf)\n    for i in sort_id:\n      report=[destkeys[i], sgrna2genelist[destkeys[i]],'list', tt_p_lower_score[i], '1', validsgrna[i]]\n      print('\\t'.join([str(x) for x in report]),file=destf)\n    destf.close()\n    tt_p_lower_fdr=pFDR(tt_p_lower,method=args.adjust_method)\n    n_lower=sum([1 for x in tt_p_lower if x <= args.gene_test_fdr_threshold])\n    n_lower_p=n_lower*1.0\/len(tt_p_lower)\n    logging.debug('lower test FDR cutoff: '+str(n_lower_p))\n    # calculate gene lfc\n    lower_gene_lfc=calculate_gene_lfc(args,sgrnalfc,sort_id,n_lower,sgrna2genelist,destkeys)\n    #\n    destfname=destfile+'.phigh.txt'\n    destf=open(destfname,'w')\n    destkeys=tabctrl.keys()\n    sort_id=[i[0] for i in sorted(enumerate(tt_p_higher_score), key=lambda x:x[1],reverse=False)]\n    # output to file\n    print('\\t'.join(['sgrna','symbol','pool','p.high','prob','chosen']),file=destf)\n    for i in sort_id:\n      report=[destkeys[i], sgrna2genelist[destkeys[i]],'list', tt_p_higher_score[i], '1', validsgrna[i]]\n      print('\\t'.join([str(x) for x in report]),file=destf)\n    destf.close()\n    tt_p_higher_fdr=pFDR(tt_p_higher,method=args.adjust_method)\n    n_higher=sum([1 for x in tt_p_higher if x <= args.gene_test_fdr_threshold])\n    if n_higher>0:\n      n_higher_p=n_higher*1.0\/len(tt_p_higher)\n    else:\n      n_higher_p=0.01\n    logging.debug('higher test FDR cutoff: '+str(n_higher_p))\n    # calculate gene lfc\n    higher_gene_lfc=calculate_gene_lfc(args,sgrnalfc,sort_id,n_higher,sgrna2genelist,destkeys,ispos=True)\n    #\n    return (n_lower_p,n_higher_p,lower_gene_lfc,higher_gene_lfc)\n  else:\n    return (None,None,None,None)\n\ndef rank_association_test(file,outfile,cutoff,args,adjustcutoff=True):\n  if adjustcutoff: # adjust the alpha threshold to 0.05-0.5\n    if cutoff<0.05:\n      cutoff=0.05\n    if cutoff>0.5:\n      cutoff=0.5\n  #rrapath='\/'.join(sys.argv[0].split('\/')[:-1]+[\"..\/bin\/RRA\"])\n  rrapath='RRA'\n  command=rrapath+\" -i \"+file+\" -o \"+outfile+\" -p \"+str(cutoff)\n  if hasattr(args,'control_sgrna') and args.control_sgrna != None :\n    command+=\" --control \"+args.control_sgrna\n  if hasattr(args,'skip_gene'):\n    if args.skip_gene != None :\n      for g in args.skip_gene:\n        command+=\" --skip-gene \"+g\n    else:\n      command+=\" --skip-gene NA --skip-gene na \"\n  else:\n    command+=\" --skip-gene NA \"\n  # command+=\" --min-number-goodsgrna 2 \"\n  if hasattr(args,\"additional_rra_parameters\") and args.additional_rra_parameters != None:\n    command+=\" \"+args.additional_rra_parameters+\" \"\n  systemcall(command)\n\n\ndef magecktest_removetmp(prefix):\n  tmpfile=[prefix+'.plow.txt',prefix+'.phigh.txt',prefix+'.gene.low.txt',prefix+'.gene.high.txt']\n  for f in tmpfile:\n    systemcall('rm '+f,cmsg=False)\n\n\ndef magecktest_parsetreatmentsfromday0(args,samplelabelindex):\n  \"\"\"\n  Reconstruct the groups of treatment and control from --day0-label\n  \"\"\"\n  samples=[s for s in samplelabelindex.keys()]\n  day0labelstr=args.day0_label\n  args.day0_label=args.day0_label.split(',')\n  for dl in args.day0_label:\n    if dl not in samples:\n      logging.error('Label '+dl+' specified in the --day0-label option does not match count table. Please double check.')\n      sys.exit(-1)\n  nonday0sample=[x for x in samples if x not in args.day0_label]\n  if len(nonday0sample)==0:\n    logging.error('At least 1 non day0-label sample should be specified.')\n    sys.exit(-1)\n  args.treatment_id=nonday0sample\n  args.control_id=[day0labelstr]*len(nonday0sample)\n\n\ndef magecktest_main(args):\n  \"\"\"\n  Main entry for MAGeCK test function\n  \"\"\"\n\n  # stat test\n  if args.subcmd == 'run' or args.subcmd == 'test':\n    # read counts from file\n    if args.subcmd == 'test':\n      mapres=getcounttablefromfile(args.count_table)\n    else:\n      mapres=getcounttablefromfile(args.output_prefix+'.count.txt')\n    cttab=mapres[0]\n    sgrna2genelist=mapres[1]\n    samplelabelindex=mapres[2]\n\n    if len(cttab)==0:\n      sys.exit(-1)\n    nsample=len(cttab[cttab.keys()[0]])\n\n    # process day0-label\n    if args.day0_label != None:\n      magecktest_parsetreatmentsfromday0(args,samplelabelindex)\n\n    # iterate control group and treatment group\n    supergroup_control=args.control_id\n    supergroup_treat=args.treatment_id\n    # control group and treatment group labels\n    labellist_control=[]\n    labellist_treat=[]\n    # R visualization init\n    vrv=VisualRValue()\n    vrv.outprefix=args.output_prefix\n    vrv.genesummaryfile=args.output_prefix+'.gene_summary.txt'\n    vrv.startRTemplate()\n    vrvrnwcplabel=[]; # labels to write in rnw\n\n    # loop by comparisons\n    for cpindex in range(len(supergroup_treat)):\n      # convert the sample label to sample index\n      if cpindex==0:\n        cp_prefix=args.output_prefix\n      else:\n        cp_prefix=args.output_prefix+'.'+str(cpindex)\n      # labels\n      (treatgroup,treatgrouplabellist)=parse_sampleids(supergroup_treat[cpindex],samplelabelindex)\n      treatgroup_label=str(supergroup_treat[cpindex])\n      logging.info('Treatment samples:'+treatgroup_label)\n      logging.info('Treatment sample index:'+','.join([str(x) for x in treatgroup]))\n      labellist_treat+=[treatgroup_label]\n      if supergroup_control != None:\n        (controlgroup,controlgrouplabellist)=parse_sampleids(supergroup_control[cpindex],samplelabelindex)\n        controlgroup_label=str(supergroup_control[cpindex]); # only for display\n        logging.info('Control samples:'+controlgroup_label)\n      else:\n        #controlgroup=[x for x in range(nsample) if x not in treatgroup]\n        #controlgrouplabellist=[samplelabelindex[x] for x in range(nsample) if x not in treatgroup]\n        xls=[x for x in range(nsample) if x not in treatgroup]\n        (controlgroup,controlgrouplabellist)=parse_sampleids(','.join([str(t) for t in xls]),samplelabelindex)\n        controlgroup_label='rest'\n        logging.info('Control samples: the rest of the samples')\n      logging.info('Control sample index:'+','.join([str(x) for x in controlgroup]))\n      labellist_control+=[controlgroup_label]\n      # read the sgRNA-gene table for rank association\n      # normalization\n      cttab_sel={k:([v[i] for i in controlgroup + treatgroup]) for (k,v) in cttab.iteritems()}; # controlgroup do not overlap with treatgroup\n      if hasattr(args,'norm_method'):\n        nttab=normalizeCounts(cttab_sel,method=args.norm_method,controlsgfile=args.control_sgrna)\n      else:\n        nttab=normalizeCounts(cttab_sel)\n      # write normalized counts to file\n      if hasattr(args,'normcounts_to_file'):\n        if args.normcounts_to_file:\n          # counts\n          mageck_printdict(nttab,args,sgrna2genelist,samplelabelindex,controlgroup+treatgroup)\n      controlgroup_ids=list(range(len(controlgroup)))\n      treatgroup_ids=list(range(len(controlgroup),len(controlgroup+treatgroup)))\n      # perform sgRNA test, and prepare files for gene test\n      gene_as_cutoff=crispr_test(nttab, controlgroup_ids, treatgroup_ids, cp_prefix,sgrna2genelist,args)\n      #\n      if gene_as_cutoff[0] is not None:\n        rank_association_test(cp_prefix+'.plow.txt',cp_prefix+'.gene.low.txt',gene_as_cutoff[0],args)\n      if gene_as_cutoff[1] is not None:\n        rank_association_test(cp_prefix+'.phigh.txt',cp_prefix+'.gene.high.txt',gene_as_cutoff[1],args,adjustcutoff=False) # update: fpr positive selection, do not adjust alpha cutoff\n      # merge different files\n      merge_rank_files(cp_prefix+'.gene.low.txt',cp_prefix+'.gene.high.txt',cp_prefix+'.gene_summary.txt',args,gene_as_cutoff)\n      if cpindex>0:\n        if cpindex>1:\n          label1=''\n        else:\n          if len(labellist_treat)>0:\n            label1=labellist_treat[0]+'_vs_'+labellist_control[0]+'|'\n          else:\n            label1=''\n        label2=treatgroup_label+'_vs_'+controlgroup_label+'|'\n        merge_rank_summary_files(args.output_prefix+'.gene_summary.txt',cp_prefix+'.gene_summary.txt',args.output_prefix+'.gene_summary.txt',args,lowfile_prefix=label1,highfile_prefix=label2)\n      # visualization: load top k genes\n      # print(str(samplelabelindex))\n      vrv.cplabel=treatgroup_label+'_vs_'+controlgroup_label+' neg.'\n      vrvrnwcplabel+=[vrv.cplabel]\n      vrv.cpindex=[2+12*cpindex+1]\n      vrv.loadTopKWithExp(cp_prefix+'.gene.low.txt',nttab,sgrna2genelist,controlgrouplabellist+treatgrouplabellist)\n      vrv.cplabel=treatgroup_label+'_vs_'+controlgroup_label+' pos.'\n      vrvrnwcplabel+=[vrv.cplabel]\n      vrv.cpindex=[2+12*cpindex+6+1]\n      vrv.loadTopKWithExp(cp_prefix+'.gene.high.txt',nttab,sgrna2genelist,controlgrouplabellist+treatgrouplabellist)\n\n      # clean the file\n      if args.keep_tmp==False:\n        magecktest_removetmp(cp_prefix)\n        if cpindex>0:\n          systemcall('rm '+cp_prefix+'.gene_summary.txt',cmsg=False)\n          systemcall('rm '+cp_prefix+'.sgrna_summary.txt',cmsg=False)\n      # end cleaning\n    # end cpindex loop\n\n    # generate pdf file\n    # write to rnw file buffer\n    vrv.genesummaryfile=args.output_prefix+'.gene_summary.txt'\n    vrv.getGeneSummaryStat(args,isplot=False)\n    vrv.comparisonlabel=vrvrnwcplabel; # replace the label field\n    vrv.writeGeneSummaryStatToBuffer()\n    # write to rnw and R file\n    vrv.closeRTemplate()\n    if hasattr(args, \"pdf_report\") and args.pdf_report:\n      vrv.generatePDF(args.keep_tmp)\n  # end if\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_134","text":"<gh_stars>0\n#!\/usr\/bin\/python\n# -*- coding: utf-8 -*-\nfrom optparse import OptionParser\nimport os\nfrom scipy.stats import norm\nfrom collections import defaultdict\nimport bz2\nimport random\nimport math\n#from get_data_set import FILE_TYPES\n\nFILE_TYPES = ['malware', 'non_malware', 'file']\n\nALLOWED_EXTENSIONS = dict([ (ext, num) for (ext, num) in zip(FILE_TYPES, range(1,len(FILE_TYPES)+1))])\n\n# Arbitrary mapping from extensions we're interested in to numerical labels\n\n##---------------------- Feature Calculators ----------------------------- ##\n\n# All the below functions take as input a file fragment, as a raw string. They\n# return a list (in many cases of length one) describing some feature of the\n# file fragment.\n\ndef unigram_counts(fragment):\n    counts = defaultdict(int)\n    for byte in fragment:\n        counts[byte] += 1\n\n    c= [ counts[chr(byte)] for byte in range(255) ]\n    mean, std = norm.fit(c)\n    return [mean, std]\n\ndef entropy_and_bigram_counts(fragment):\n    \"\"\"Package together to avoid having to calculate this a second time when\n    calculating entropy.\n    \"\"\"\n    counts = defaultdict(int)\n    for i in range(len(fragment)-1):\n        counts[fragment[i]+fragment[i+1]] += 1\n\n    bigram_frequencies = [counts[chr(b1)+chr(b2)] for b1 in range(255) for b2 in range(255)]\n    mean, std = norm.fit(bigram_frequencies)\n    entropy = 0.0\n    #bigram_frequencies = bigram_counts(fragment)\n    for i in range(len(bigram_frequencies)):\n        if bigram_frequencies[i] > 0.0:\n            entropy += bigram_frequencies[i] * math.log10(bigram_frequencies[i])\n    entropy = -entropy\n\n    #return [entropy]\n\n    return [entropy] + [mean, std]\ndef entropy_and_trigram_counts(fragment):\n    \"\"\"Package together to avoid having to calculate this a second time when\n    calculating entropy.\n    \"\"\"\n    counts = defaultdict(int)\n    for i in range(len(fragment)-1):\n        counts[fragment[i]+fragment[i+1]] += 1\n\n    bigram_frequencies = [counts[chr(b1)+chr(b2)+chr(b3)] for b1 in range(255) for b2 in range(255) for b3 in range(255)]\n    mean, std = norm.fit(bigram_frequencies)\n    entropy = 0.0\n    #bigram_frequencies = bigram_counts(fragment)\n    for i in range(len(bigram_frequencies)):\n        if bigram_frequencies[i] > 0.0:\n            entropy += bigram_frequencies[i] * math.log10(bigram_frequencies[i])\n    entropy = -entropy\n\n    #return [entropy]\n\n    return [entropy] + [mean, std]\n\ndef contiguity(fragment):\n    \"\"\" A vague measurement of the average contiguity from byte to byte.\n    \"\"\"\n    total_diff = 0\n    total = 0\n    for i in range(len(fragment)-1):\n        total_diff += abs(ord(fragment[i]) - ord(fragment[i+1]))\n        total += 1\n\n    return [total_diff\/(total+0.0)]\n\ndef mean_byte_value(fragment):\n    return [ sum([ord(char) for char in fragment]) ]\n\ndef longest_streak(fragment):\n    \"\"\" The length of the longest repeating subsequence.\n    \"\"\"\n    longest = 0\n    last = fragment[0]\n    current_streak = 1\n    for char in fragment[1:]:\n        if char == last:\n            current_streak += 1\n        else:\n            if current_streak > longest:\n                longest = current_streak\n            last = char\n            current_streak = 1\n\n    return [longest]\n\ndef compressed_length(fragment):\n    \"\"\"Return a feature vector with the ratio of the compressed length of the\n    file fragment to the actual length of the file fragment\n    \"\"\"\n    return [ float( len(bz2.compress(fragment)) ) \/ float(len(fragment)) ]\n\ndef entropy(fragment):\n    entropy = 0.0\n    bigram_frequencies = bigram_counts(fragment)\n    for i in range(len(bigram_frequencies)):\n        if bigram_frequencies[i] > 0.0:\n            entropy += bigram_frequencies[i] * math.log10(bigram_frequencies[i])\n    entropy = -entropy\n\n    return [entropy]\n\ndef chi_squared(fragment):\n    chi_squared = 0.0\n    C2 = 0.0\n    expected = 2.0 #expected frequency of a byte (fileSize\/number of possible byte values)->(512\/256)\n\n    for index in range(0,256):\n        observed = feature_vector_1grams[index]\n        C2 += ((observed-expected)**2)\/expected\n\n    chi_squared = stats.achisqprob(C2,255)\n\n    return [chi_squared]\n\ndef hamming_weight(fragment):\n    hamming_weight = 0.0\n    for i in range(len(fragment)):\n        current_byte = ord(fragment[i])\n    while current_byte != 0:\n        hamming_weight += float(current_byte & 1)\n        current_byte = current_byte >> 1\n    hamming_weight \/= float(8 * len(fragment))\n\n    return [hamming_weight]\n\n## ----------------------------------------------------------------------- ##\n\n\ndef to_vectorfile_format(label, vector):\n    \"\"\"\n    Given a label (e.g. 1, 2, 3, 4) and a list representing a vector, return a\n    vector string that fits the format used by libsvm and svm-light.\n    \"\"\"\n    vector_string = str(label)\n    feat_index = 1 # Start from 1 rather than 0, oddly\n    for value in vector:\n        # Can save a ton of space by ignoring 0-valued features\n\n        #if value != 0:\n\tvector_string += \" \" + \",\" + str(value)\n        feat_index += 1\n    #vector_string += ''\n\n    return vector_string\n\nif __name__ == '__main__':\n    parser = OptionParser()\n    parser.add_option(\"-i\", \"--input-dir\", dest=\"input_dir\", default=\"fragments\",\n        help=\"Directory containing the files to be processed (default .\/fragments)\")\n    parser.add_option(\"-o\", \"--output-dir\", dest=\"output_dir\", default=\"\/h\/90\/oles\/csc2208h\/vectors\",\n        help=\"Directory to write vector file to (default .\/vectors)\")\n    parser.add_option(\"-l\", \"--label\", dest=\"label\", default=\"\",\n        help=\"String to be added to the name of the output vector file\")\n    parser.add_option(\"-n\", \"--limit\", dest=\"limit\", type=int, default=0,\n        help=\"Limit to the number of fragments to take of each type. Default: 0=unlimited.\")\n\n    parser.add_option(\"--omit\", dest=\"omit\", type=int, default=-1,\n        help=\"Omit the feature with the given index (should be from 0-6). Default:-1 -> don't omit anything\")\n\n    print(\"Starting\")\n    (options, args) = parser.parse_args()\n\n    features = [unigram_counts, entropy_and_trigram_counts, contiguity, mean_byte_value, longest_streak, compressed_length, hamming_weight, entropy_and_bigram_counts]\n    if options.omit != -1:\n        features = features[:features.omit] + features[features.omit+1:]\n\n    output_fname = os.path.join(options.output_dir, 'vector' + options.label + '.svm')\n    out = open(output_fname, 'w')\n\n    fragments_seen = 0\n    options1 = dict()\n\n    files_parsed = 0\n\n    print(\"Converting\")\n    for subdir in os.listdir(options.input_dir):\n        fulldir = os.path.join(options.input_dir, subdir)\n        frags = os.listdir(fulldir)\n        # If we're only taking a subset of the fragments (when options.limit is set), we want to make sure it's a random one\n        random.shuffle(frags)\n\n        for fragment_name in (frags[:options.limit] if options.limit else frags):\n            fragments_seen += 1\n            if (fragments_seen % 1000) == 0:\n                print \"On %dth fragment\" % (fragments_seen)\n            f = open(os.path.join(fulldir, fragment_name))\n            fragment = f.read()\n            f.close()\n\n            #ext is the name of the folder fragment came directory\n            if (subdir == \"malware\"):\n                ext = 0\n            else:\n                ext = 1\n\n            files_parsed = files_parsed + 1\n            print ('subdir: %s' %subdir)\n            print ('files_parsed: %f\\n' %files_parsed)\n\n            vector = sum([feature_calc(fragment) for feature_calc in features], [])\n\n            # ext = 0 is a malware fragment\n            # ext = 1 is a non-malware fragment\n            vector_str = to_vectorfile_format(ext, vector) + '\\n'\n\n            #write features\n            out.write(vector_str)\n\n    out.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_135","text":"<reponame>thara3\/FosterCauer_CauerFoster\n# # Foster to Cauer\n# 2019\/05\/06 created by <NAME>\nimport argparse\nimport sympy\nimport datetime\n\n# version of this script\nmyVersion = '0.0.01'\n\n##############################################################################\n# arg parsing\n##############################################################################\nparser = argparse.ArgumentParser(\n    prog='Foster2Cauer.py',\n    usage='Convert Foster RC network to Cauer RC network.',\n    epilog='end',\n    add_help=True\n    )\n\nparser.add_argument('input_file', help='specify input filename',\n                    action='store', type=str)\nparser.add_argument('output_file', help='specify output filename',\n                    action='store', type=str)\n\nparser.add_argument('-r', '--rational_rth',\n                    help='better accuracy but computationally expensive',\n                    action='store_true')\nparser.add_argument('--version', action='version',\n                    version='%(prog)s ' + myVersion)\n\nargs = parser.parse_args()\n\n# Input file, output file, and flag(s):\ninput_file = args.input_file\noutput_file = args.output_file\nrational_rth = args.rational_rth\n\n##############################################################################\n\n\"\"\"\nhttps:\/\/stackoverflow.com\/questions\/13890935\/does-pythons-time-time-return-the-local-or-utc-timestamp\n\"\"\"\n# time stamp when the script started.\ntimestamp = str(datetime.datetime.now()).split('.')[0].replace(\":\", \"-\")\n\n\nsympy.init_printing()\n\ns = sympy.Symbol('s')\ncc1, rc1, tauc1 = sympy.symbols(r\"C_c1, R_c1, \\tau_{c1}\")\ncc2, rc2, tauc2 = sympy.symbols(r\"C_c2, R_c2, \\tau_{c2}\")\ncc3, rc3, tauc3 = sympy.symbols(r\"C_c3, R_c3, \\tau_{c3}\")\n\n# CauerMatSample3x3 used for debugging at jupyter\nCauerMatSample3x3 = sympy.Matrix([[cc1, rc1, tauc1],\n                                 [cc2, rc2, tauc2],\n                                 [cc3, rc3, tauc3]])\n\n\nwith open(input_file, 'r', encoding=\"utf-8\") as fileobj:\n    datastr = fileobj.read()         # read all data from a file\n    adatastr = datastr.rstrip()      # remove the last \"\\n\"\n    datalist = adatastr.split(\"\\n\")  # create a list (size: n row * 1 column)\n\nc_list = list()                      # a list for foster network Cth\nr_list = list()                      # a list for foster network Rth\n\nfor line in datalist:                # read one row at a time\n    tmplist = line.split()           # split a row into a list\n    # print(tmplist)\n    if tmplist == []:                # skip empty rows\n        continue\n    if tmplist[0][0] == '#':         # skip comment rows\n        continue\n    if tmplist[0][0:6] == \"STAGES\":  # number of RC stages\n        stages = int(tmplist[1])\n        print(\"stages = \" + str(stages))\n        continue\n    # start reading actual data\n    # (1st column is stage number)\n    c_list.append(tmplist[1])        # Cth on the 2nd column\n    r_list.append(tmplist[2])        # Rth on the 3rd column\n\n\nCauerMat = sympy.zeros(stages, 3)    # Final results will be stored here.\n\nFosterMat = sympy.zeros(stages, 3)   # Input data will be stored here\n\nfor i in range(stages):\n    FosterMat[i, 0] = sympy.Rational(c_list[i])\n\n    # By default, reduced the accuracy level by not Rationalizing Rth.\n    FosterMat[i, 1] = sympy.Rational(r_list[i]) if rational_rth else r_list[i]\n\n    FosterMat[i, 2] = FosterMat[i, 0] * FosterMat[i, 1]\n\n\n# ### As shown in the CauerMatSample3x3, variables line up in ascending order.\n# Cc1 and Rc1 pair represents the first stage of the Cauer model.\n# They are next to Junction.\n# So as the Cf1 and Rf1 of the Foster model.\n\n\n# # FosterMatrix\n# This is a faster way to calculate the coeffcients of pf and qf,\n# in higher stages.\n\naMatFoster = sympy.zeros(stages, stages+1)\nbMatFoster = sympy.zeros(stages+1, stages+1)\n\naMatFoster[0, 1] = FosterMat[stages-1, 1]\nbMatFoster[0, 1] = 1\nbMatFoster[1, 1] = FosterMat[stages-1, 2]\n\nfor i in range(2, stages+1):\n    aMatFoster[:i, i] = \\\n        FosterMat[stages - i, 2] * \\\n        aMatFoster[:i-1, i-1].row_insert(0, sympy.Matrix([0])) + \\\n        aMatFoster[:i-1, i-1].row_insert(i-1, sympy.Matrix([0])) + \\\n        FosterMat[stages - i, 1] * bMatFoster[:i, i-1]\n\n    bMatFoster[:i+1, i] = \\\n        FosterMat[stages - i, 2] * \\\n        bMatFoster[:i, i-1].row_insert(0, sympy.Matrix([0])) + \\\n        bMatFoster[:i, i-1].row_insert(i, sympy.Matrix([0]))\n\nsvector4Coeff_a = sympy.Matrix(stages, 1, lambda i, j: s**i)\nsvector4Coeff_b = sympy.Matrix(stages+1, 1, lambda i, j: s**i)\nsvector4Coeff_a, svector4Coeff_b, stages\n\nZfall = \\\n    sympy.Poly(sympy.transpose(\n        aMatFoster.col(stages)).dot(svector4Coeff_a), s) \/ \\\n    sympy.Poly(sympy.transpose(\n        bMatFoster.col(stages)).dot(svector4Coeff_b), s)\n\n\n# # Recursive Foster to Cauer conversion\n# For details, check\n#  \"20190504_Foster2Cauer3rdOrder_MatrixCalc.ipynb\" and\n#  \"20190504_Foster2Cauer3rdOrder_MatrixCalc_recursive_pre.ipynb\"\n\nfor i in range(stages):\n    (pf, qf) = sympy.fraction(Zfall)\n    pf = sympy.Poly(pf, s)\n    qf = sympy.Poly(qf, s)\n    CauerMat[i, 0] = qf.nth(stages-i)\/pf.nth(stages-1-i)\n\n    Yfall = (1\/Zfall - CauerMat[i, 0]*s).cancel()\n    (qf, pf) = sympy.fraction(Yfall)\n    qf = sympy.Poly(qf, s)\n    pf = sympy.Poly(pf, s)\n    CauerMat[i, 1] = pf.nth(stages-1-i)\/qf.nth(stages-1-i)\n\n    # calculate tauc\n    CauerMat[i, 2] = CauerMat[i, 0] * CauerMat[i, 1]\n\n    Zfall = (1\/Yfall - CauerMat[i, 1]).cancel()\n\n\n# # Final results in floating values\n\nCauerMat_float = sympy.zeros(stages, 3)\nfor i in range(stages):\n    for j in range(3):\n        CauerMat_float[i, j] = float(CauerMat[i, j])\n\n\n# # Resistance sum value check\nRc_all = 0\nRf_all = 0\nfor i in range(stages):\n    Rc_all = Rc_all + CauerMat_float[i, 1]\n    Rf_all = Rf_all + FosterMat[i, 1]\nprint(\"Rc_all = %g, Rf_all = %g\" % (Rc_all, Rf_all))\n\nepsilon = 1e-8\nres = float(abs(Rc_all - Rf_all))\nif res > epsilon:\n    print(\"Rc_all and Rf_all don't match, ERROR!!!\")\n\n\n# # output results\nwith open(output_file, \"w\") as fileobj:\n    tmpstring = \"\"\n    # header\n    tmpstring = \"## Foster2Cauer results \" + str(stages) + \"stages\\n\"\n    fileobj.write(tmpstring)\n    tmpstring = \"## Created: \" + timestamp + \"\\n\"\n    fileobj.write(tmpstring)\n    tmpstring = \"# First stage (Cc1 and Rc1) is connected to Junction.\\n\"\n    fileobj.write(tmpstring)\n    tmpstring = \"STAGES=\\t\" + str(stages) + \"\\n\\n\"\n    fileobj.write(tmpstring)\n\n    tmpstring = \"# stage\" + \"\\t\" + \"C_cauer\" + \"\\t\\t\\t\" + \\\n                \"R_cauer\" + \"\\t\\t\\t\" + \"Tau_cauer\\n\"\n    fileobj.write(tmpstring)\n    for i in range(stages):\n        tmpstring = str(i+1) + \"\\t\" + \\\n            str(CauerMat_float[i, 0]) + \"\\t\" + \\\n            str(CauerMat_float[i, 1]) + \"\\t\" + \\\n            str(CauerMat_float[i, 2]) + \"\\n\"\n        fileobj.write(tmpstring)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_136","text":"from copy import deepcopy\nfrom IPython.display import Math\nfrom ipywidgets import *\nimport numpy as np\nimport pandas as pd\nfrom patsy import dmatrix\nimport scipy.sparse as sp\nfrom scipy.special import comb\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error\nimport sys\nfrom tqdm import tnrange, tqdm_notebook\nimport warnings\n\ndef TauPath(lam_1 = None,\n            lam_2 = None,\n            beta = None,\n            zeta = None,\n            delta = None,\n            alpha = None,\n            P = None,\n            P_interaction = None,\n            taus = np.logspace(start=0, stop=-2, num=50, base=10),\n            CD_J_AS = None,\n            active_set = None,\n            active_interaction_set = None,\n            B = None,\n            B_interaction = None,\n            K_main = None, \n            K_interaction = None, \n            Xval = None,\n            Xmin = None,\n            Xmax = None,\n            Y = None,\n            Yval = None,\n            y_scaler = None,\n            S = None,\n            S_interaction = None,\n            interaction_terms = None,\n            eval_criteria = None,\n            path = None,\n            r = None,\n            logging = False):\n    \"\"\"Hyperparameter grid search for tau penalty for nonparametric additive models with interactions under hierarchy\n    \n    Args:\n        lam_1: smoothness penalty for b-splines, float scaler.\n        lam_2: L0 penalty for b-splines, float scaler.\n        beta: coefficients for main effects, list of arrays of shapes [(Ki+1, 1), ...].\n        zeta: binary vector to track which main effects are in the active set, a bool array of shape (1, d)\n            corresponds to z_i's in the paper.\n        delta: coefficients for interaction effects, list of arrays of shapes [(Kij+1, 1), ...].\n            corresponds to theta in the paper.\n        alpha: binary vector to track which interactions effects are in the active interaction set, a bool array of shape (1, Imax)\n            corresponds to z_ij's in the paper.\n        P: B^T*B + 2*N*(lam_1*S_i + eps*I) matrices for main effects, list of sparse matrices of shapes [(Ki+1, Ki+1), ...].\n            eps is a small epsilon for numerical stability.\n        P_interaction: B^T*B + 2*N*(lam_1*S_ij + eps*I) matrices for interaction effects, list of sparse matrices of shapes [(Kij+1, Kij+1), ...].\n            eps is a small epsilon for numerical stability.\n        taus: thresholding penalty for generating feasible subsets of main\/interaction effects that maintain strong hierarchy, array of float scalers.\n        CD_J_AS: function for cyclic block coordinate descent over an active set, callable.\n        active_set: indices of main effects to optimize over, a numpy int array.\n        active_interaction_set: indices of interaction effects to optimize over, a numpy int array.\n        B: B-spline transformed sparse matrices for main effects, list of sparse matrices of shapes [(N, Ki+1), ...].\n        B_interaction: B-spline transformed sparse matrices for interaction effects, list of sparse matrices of shapes [(N, Kij+1), ...].\n        K_main: Number of knots used for each main effect, a list of int scalers of shape (d,) \n        K_interaction: Number of knots used for each interaction effect, a list of int scalers of shape (Imax,) \n        Xval: validation covariates, a float numpy array of shape (Nval, p).\n        Xmin: minimum values of X for all covariates, needed for spline generation, a float numpy array of shape (1, d).\n        Xmax: maximum values of X for all covariates, needed for spline generation, a float numpy array of shape (1, d).\n        Y: training target responses, a float numpy array of shape (N,).\n        Yval: validation target responses, a float numpy array of shape (Nval,).\n        y_scaler: sklearn transformation object on responses to inverse transform the responses, see data_utils.py\n            supports z-normalization\/identity.\n        S: Smoothness matrices for main effects, list of sparse matrices of shapes [(Ki+1, Ki+1), ...].\n        S_interaction: Smoothness matrices for interaction effects, list of sparse matrices of shapes [(Kij+1, Kij+1), ...].\n        interaction_terms: list of interaction effects to consider if only a subset need to be considered, \n            a 2D numpy array of of shape (Imax, 2).\n        eval_criteria: evaluation metric for hyperparameter tuning,\n          - 'mse', 'mae'\n        path: folder path to log results to, str.\n        r: relative scaling factor for L0 penalty between main and interaction effects.\n            We consider r=1.0 (corresponds to alpha symbol in the paper), float scaler. \n        logging: whether to log results to a file, bool scaler.\n        \n    Returns:\n        optimal_solution_path: (beta_opt, delta_opt, zeta_opt, alpha_opt, tau_opt, J_opt, active_set_opt, active_interaction_set_opt, val_loss_opt).\n        sparse_solution_path: (beta_sp, delta_sp, zeta_sp, alpha_sp, tau_sp, J_sp, active_set_sp, active_interaction_set_sp, val_loss_sp).\n    \"\"\"\n    \n    d = len(B)\n    N = Y.shape[0]\n    val_loss_opt = np.inf\n    val_loss = np.inf*np.ones((taus.shape[0],),dtype=float)\n    val_std_err = np.inf*np.ones((taus.shape[0],),dtype=float)\n    sparsity = (active_set.shape[0]+active_interaction_set.shape[0])*np.ones((taus.shape[0],),dtype=float)\n    J = np.zeros((taus.shape[0],),dtype=float)\n    eps = 1e-8\n    if eval_criteria == 'mse':\n        evaluate = mean_squared_error\n    elif eval_criteria == 'mae':\n        evaluate = mean_absolute_error\n    else:\n        raise ValueError(\"Evaluation criteria {} is not supported\".format(eval_criteria))\n    \n     \n    # Generate b-splines for validation set for active set\n    Bval = [None]*d\n    for k in active_set:\n        Bval[k] = sp.csr_matrix(dmatrix(\"bs(x, df={}, degree=3, include_intercept=False, lower_bound={}, upper_bound={})\".format(K_main[k], Xmin[k], Xmax[k]), {\"x\": Xval[:,k]}),dtype=np.float64)\n    Bval_interaction = [None]*len(interaction_terms)\n    for k in active_interaction_set:\n        f_i, f_j = interaction_terms[k]\n        Bval_interaction[k] = sp.csr_matrix(dmatrix(\"te(bs(x1, df={}, degree=3, include_intercept=False, lower_bound={}, upper_bound={}), bs(x2, df={}, degree=3, include_intercept=False, lower_bound={}, upper_bound={}))\".format(K_interaction[f_i], Xmin[f_i], Xmax[f_i], K_interaction[f_j], Xmin[f_j], Xmax[f_j]), {\"x1\": Xval[:,f_i], \"x2\": Xval[:,f_j]}),dtype=np.float64)\n\n    # Tau path\n    beta_HS = [deepcopy(beta)]*taus.shape[0]\n    zeta_HS = [deepcopy(zeta)]*taus.shape[0]\n    delta_HS = [deepcopy(delta)]*taus.shape[0]\n    alpha_HS = [deepcopy(alpha)]*taus.shape[0]\n        \n    for i, tau in tqdm_notebook(enumerate(taus),desc='$\\\\tau$'):\n        \n        if i==0:\n            beta_current = deepcopy(beta_HS[0])\n            delta_current = deepcopy(delta_HS[0])\n        else:\n            beta_current = deepcopy(beta_HS[i-1])\n            delta_current = deepcopy(delta_HS[i-1])\n        \n        if len(active_set)==0 and len(active_interaction_set)==0:\n            Ypred = np.mean(Y)*np.ones(Y.shape,dtype=float)\n        elif len(active_set)==0 and len(active_interaction_set)>0:\n            Ypred = np.mean(Y)*np.ones(Y.shape,dtype=float)\\\n                    +np.array(sum([(B_interaction[k]).dot(delta_current[k]) for k in active_interaction_set])).reshape(Y.shape)\n        elif len(active_set)>0 and len(active_interaction_set)==0:\n            Ypred = np.mean(Y)*np.ones(Y.shape,dtype=float)\\\n                    +np.array(sum([(B[k]).dot(beta_current[k]) for k in active_set])).reshape(Y.shape)\n        elif len(active_set)>0 and len(active_interaction_set)>0:\n            Ypred = np.mean(Y)*np.ones(Y.shape,dtype=float)\\\n                    +np.array(sum([(B[k]).dot(beta_current[k]) for k in active_set])).reshape(Y.shape)\\\n                    +np.array(sum([(B_interaction[k]).dot(delta_current[k]) for k in active_interaction_set])).reshape(Y.shape)        \n \n        z_max = np.max([np.max(zeta_HS[i]), np.max(alpha_HS[i])])\n        zeta_HS[i] = np.where((zeta_HS[i]\/z_max)>tau,\n                              np.ones(zeta_HS[i].shape,dtype=float),\n                              np.zeros(zeta_HS[i].shape,dtype=float))\n        alpha_HS[i] = np.where((alpha_HS[i]\/z_max)>tau,\n                               np.ones(alpha_HS[i].shape,dtype=float),\n                               np.zeros(alpha_HS[i].shape,dtype=float))\n        Ypred, beta_HS[i], zeta_HS[i], delta_HS[i], alpha_HS[i] = CD_J_AS(Ypred = Ypred,\n                                              beta = [deepcopy(beta_current), deepcopy(delta_current)],\n                                              zeta = [zeta_HS[i], alpha_HS[i]],\n                                              active_set = [np.where(zeta_HS[i][0,:]>tau)[0], np.where(alpha_HS[i][0,:]>tau)[0]],\n                                              lam = [lam_1, 0.0],\n                                              P = P, \n                                              P_interaction = P_interaction)\n        train_loss = evaluate(y_scaler.inverse_transform(Y), y_scaler.inverse_transform(Ypred))\n\n\n        if len(active_set)==0 and len(active_interaction_set)==0:\n            Yvalpred = np.mean(Y)*np.ones(Yval.shape,dtype=float)\n        elif len(active_set)==0 and len(active_interaction_set)>0:\n            Yvalpred = np.mean(Y)*np.ones(Yval.shape,dtype=float)\\\n                       +np.array(sum([(Bval_interaction[k]).dot(delta_HS[i][k]) for k in active_interaction_set])).reshape(Yval.shape)\n        elif len(active_set)>0 and len(active_interaction_set)==0:\n            Yvalpred = np.mean(Y)*np.ones(Yval.shape,dtype=float)\\\n                       +np.array(sum([(Bval[k]).dot(beta_HS[i][k]) for k in active_set])).reshape(Yval.shape)\n        elif len(active_set)>0 and len(active_interaction_set)>0:\n            Yvalpred = np.mean(Y)*np.ones(Yval.shape,dtype=float)\\\n                       +np.array(sum([(Bval[k]).dot(beta_HS[i][k]) for k in active_set])).reshape(Yval.shape)\\\n                       +np.array(sum([(Bval_interaction[k]).dot(delta_HS[i][k]) for k in active_interaction_set])).reshape(Yval.shape)        \n        val_loss[i] = evaluate(y_scaler.inverse_transform(Yval), y_scaler.inverse_transform(Yvalpred))\n        val_std_err[i] = (mean_squared_error(y_scaler.inverse_transform(Yval), y_scaler.inverse_transform(Yvalpred))**0.5)\/(Yval.shape[0]**0.5)\n        sparsity[i] = np.count_nonzero(zeta_HS[i][0,:]) + np.count_nonzero(alpha_HS[i][0,:])\n        J[i] = 0.5*mean_squared_error(Y, Ypred)+\\\n               lam_1*sum([(np.transpose(beta_HS[i][k])).dot(S[k].dot(beta_HS[i][k]))[0,0] for k in active_set])+\\\n               lam_1*sum([(np.transpose(delta_HS[i][k])).dot(S_interaction[k].dot(delta_HS[i][k]))[0,0] for k in active_interaction_set])+\\\n               eps*sum([np.dot(beta_HS[i][k][:,0],beta_HS[i][k][:,0]) for k in active_set])+\\\n               eps*sum([np.dot(delta_HS[i][k][:,0],delta_HS[i][k][:,0]) for k in active_interaction_set])+\\\n               lam_2*(np.sum(zeta_HS[i][0,:]))+\\\n               r*lam_2*(np.sum(alpha_HS[i][0,:]))    \n        if logging ==True:\n            with open(path+'\/Training-HS.csv', \"a\") as f:\n                f.write('{:.7f},{:.7f},{:.6f},{:.6f},{:.6f},{:.6f},{},{}\\n'.format(lam_1,lam_2,tau,train_loss, val_loss[i], J[i],np.count_nonzero(zeta_HS[i][0,:]),np.count_nonzero(alpha_HS[i][0,:]))) \n        print('{:.7f},{:.7f},{:.6f},{:.6f},{:.6f},{:.6f},{},{}\\n'.format(lam_1,lam_2,tau,train_loss, val_loss[i], J[i],np.count_nonzero(zeta_HS[i][0,:]),np.count_nonzero(alpha_HS[i][0,:])))\n#             display(Math(r'\\lambda_1: {:.6f}, \\lambda_2: {:.6f}, Train-MAE: {:.6f}, Val-MAE: {:.6f}, Obj: {:.0f},'.format(lam_1,lam_2,train_loss, val_loss, J)+'\\sum_{j \\in S^c} z_j: '+'{},'.format(np.count_nonzero(zeta[j][0,:]))+'\\sum_{ij \\in S^c} z_{ij}: '+'{}.'.format(np.count_nonzero(alpha[j][0,:]))))\n        df = pd.DataFrame(columns=[lam_1, lam_2, tau, *(zeta_HS[i][0,:])])\n        with open(os.path.join(path, 'main_support_regularization_path.csv'), 'a') as f:\n            df.to_csv(f, header=True, index=False)\n        df = pd.DataFrame(columns=[lam_1, lam_2, tau, *(alpha_HS[i][0,:])])\n        with open(os.path.join(path, 'interaction_support_regularization_path.csv'), 'a') as f:\n            df.to_csv(f, header=True, index=False)\n        if val_loss[i] <  val_loss_opt:\n            val_loss_opt = deepcopy(val_loss[i])\n            val_std_err_opt = deepcopy(val_std_err[i])\n            beta_opt = deepcopy(beta_HS[i]) \n            zeta_opt = deepcopy(zeta_HS[i]) \n            delta_opt = deepcopy(delta_HS[i]) \n            alpha_opt = deepcopy(alpha_HS[i])\n            active_set_opt = np.where(zeta_HS[i][0,:] == 1)[0] \n            active_interaction_set_opt = np.where(alpha_HS[i][0,:] == 1)[0]\n            tau_opt = deepcopy(tau)        \n            J_opt = deepcopy(J[i])\n            \n#     val_loss_percent = ((val_loss-val_loss_opt*np.ones((taus.shape[0],),dtype=float))\/(val_loss_opt*np.ones((taus.shape[0],),dtype=float)))*100\n    if eval_criteria == 'mse':\n        val_loss_diff = val_loss**0.5 - val_loss_opt**0.5\n    elif eval_criteria == 'mae':\n        val_loss_diff = val_loss - val_loss_opt\n    else:\n        raise ValueError(\"Evaluation criteria {} is not supported\".format(eval_criteria))\n#     subset_indices = np.where(val_loss_percent<1)[0]                         \n    subset_indices = np.where(val_loss_diff<val_std_err_opt)[0]                         \n    sparsity_subset = sparsity[subset_indices]  \n    min_sparsity_subset_indices = subset_indices[np.argwhere(sparsity_subset == np.amin(sparsity_subset))].reshape(-1,)\n    min_sparsity_min_val_index = min_sparsity_subset_indices[np.argwhere(val_loss[min_sparsity_subset_indices] == np.amin(val_loss[min_sparsity_subset_indices])).reshape(-1,)][0]\n                         \n    val_loss_sp = deepcopy(val_loss[min_sparsity_min_val_index])\n    beta_sp = deepcopy(beta_HS[min_sparsity_min_val_index]) \n    zeta_sp = deepcopy(zeta_HS[min_sparsity_min_val_index]) \n    delta_sp = deepcopy(delta_HS[min_sparsity_min_val_index]) \n    alpha_sp = deepcopy(alpha_HS[min_sparsity_min_val_index])\n    active_set_sp = np.where(zeta_HS[min_sparsity_min_val_index][0,:] == 1)[0]\n    active_interaction_set_sp = np.where(alpha_HS[min_sparsity_min_val_index][0,:] == 1)[0] \n    tau_sp = deepcopy(taus[min_sparsity_min_val_index])\n    J_sp = deepcopy(J[min_sparsity_min_val_index])\n    \n    return (beta_opt, delta_opt, zeta_opt, alpha_opt, tau_opt, J_opt, active_set_opt, active_interaction_set_opt, val_loss_opt), (beta_sp, delta_sp, zeta_sp, alpha_sp, tau_sp, J_sp, active_set_sp, active_interaction_set_sp, val_loss_sp)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_137","text":"\"\"\" generate_data.py generates toy data for the Subtype-Oriented Disease Axes \r\n(SODA) project. It generates two files: \r\n\"\"\"\r\nimport numpy as np\r\nimport scipy.stats\r\n\r\nnp.random.seed(0)\r\n\r\nn_features = 20\r\nn_id = 100\r\nn_class = 5\r\n\r\n# Randomly generate classes and features.\r\n\r\nclass_ii = np.zeros([n_id, n_class], int)\r\n\r\nclass_ii[:, :n_class - 1] = 1 + np.random.choice(2, [n_id, n_class - 1], p = [.3, .7])\r\n\r\nclass_ii[:, -1] = 1 + np.random.choice(4, n_id, p = [.2, .2, .2, .4])\r\n\r\nfeature_ii = np.zeros([n_id, n_features])\r\n\r\nfeature_class = n_features \/\/ n_class\r\n\r\nfor cc in range(n_class):\r\n    unique_cc = np.unique(class_ii[:, cc])\r\n    for cccc in unique_cc:\r\n        Sigma = scipy.stats.wishart.rvs(feature_class, np.eye(feature_class))\r\n        mu = np.random.normal(0, size = 4)\r\n        n_cccc = (class_ii[:, cc] == cccc).sum()\r\n        feature_ii[class_ii[:, cc] == cccc, cc * feature_class : (cc + 1) * feature_class] = \\\r\n            np.random.multivariate_normal(mu, Sigma, size = n_cccc)\r\n        \r\n\r\n# Randomly generate missing labels\r\n\r\nmissing = np.array(np.random.binomial(1, .1, size = [n_id, n_class]), bool)\r\nclass_ii[missing] = -1\r\n\r\n# Save to the file cluster.csv\r\n\r\nf = open(\"cluster.csv\", \"w\")\r\n\r\nheader = \"id\" + (\",Cluster{}\" * n_class).format(\r\n            *[ii + 1 for ii in range(n_class)]\r\n        ) + \"\\n\"\r\n\r\nf.write(header)\r\nfor ii in range(n_id):\r\n    f.write(\"XX{0:06d}\".format(ii + 1))\r\n    f.write( ( (\",{}\" * n_class).format(*class_ii[ii, :]) ).replace(\"-1\", \"NA\"))\r\n    f.write(\"\\n\")\r\n\r\nf.close()\r\n\r\n# Save to the file data.csv\r\n\r\nf = open(\"data.csv\", \"w\")\r\n\r\nheader = \"id\" + (\",Feature{}\" * n_features).format(\r\n            *[ii + 1 for ii in range(n_features)]\r\n        ) + \"\\n\"\r\n        \r\n\r\nf.write(header) \r\nfor ii in range(n_id):\r\n    f.write(\"XX{0:06d}\".format(ii + 1))\r\n    f.write( (\",{:.2f}\" * n_features).format(*feature_ii[ii, :]) )\r\n    f.write(\"\\n\")\r\n\r\n\r\nf.close()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_138","text":"from keras.applications import mobilenetv2\nfrom os import listdir, path\nimport numpy as np\nimport cv2\nfrom scipy import spatial\n\n\npatch_size = 96\n\nimages_directory = \"\/Users\/user\/Desktop\/household_sample_patches\"\n\nfeature_net = mobilenetv2.MobileNetV2(weights=\"imagenet\", include_top=False, input_shape=(96, 96, 3))\n\nimages = [(e, path.join(images_directory, e)) for e in listdir(images_directory)]\n\ndef patch_descriptors(image_windows):\n\n    if image_windows.shape[1] != patch_size or image_windows.shape[2] != patch_size:\n        resized_image_patches = np.empty((image_windows.shape[0], patch_size, patch_size, image_windows.shape[3]))\n        for i in range(image_windows.shape[0]):\n            resized_image_patches[i] = cv2.resize(image_windows[i], (patch_size, patch_size), interpolation=cv2.INTER_CUBIC)\n    else:\n        resized_image_patches = image_windows\n\n    feats = feature_net.predict(resized_image_patches)\n\n    reduced_feats = np.zeros((feats.shape[0], feats.shape[3]))\n\n    for i in range(feats.shape[0]):\n\n        patch_feats = feats[i] # 3x3x1280\n\n        tot = np.zeros((patch_feats.shape[2],))\n\n        for j in range(patch_feats.shape[0]):\n            for k in range(patch_feats.shape[1]):\n                tot = tot + patch_feats[j, k]\n\n        avg = tot \/ (patch_feats.shape[0] * patch_feats.shape[1])\n\n        reduced_feats[i] = avg\n\n    return reduced_feats\n\n\nwindows = np.zeros((len(images), 192, 192, 3))\n\nnames = []\nfor i in range(len(images)):\n\n    image_path = images[i][1]\n    image_name = images[i][0]\n    names.append(image_name)\n    windows[i] = cv2.imread(image_path)\n\nprint('windows.shape', windows.shape)\n\ndes = patch_descriptors(windows)\n\nprint('des.shape', des.shape)\n\nfor i in range(len(des)):\n    for j in range(len(des)):\n        print(names[i], names[j], spatial.distance.cosine(des[i], des[j]))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_139","text":"import statistics\nimport help\nfrom statistics import *\n\nhelper = {'\/stats' : '<list>: Calculate statistics'}\n\n\ndef stats(lst):\n\tif len(lst) < 2:\n\t\thelp.helper(\"stats\")\n\t\treturn None\n\tlist = []\n\tfor x in lst[1:]:\n\t\tlist.append(int(x))\n\t#print(list)\n\tst= {}\n\ttry:\n\t\tst[\"mean\"] = mean(list)\n\t\tst[\"standard deviation\"] = stdev(list)\n\t\tst[\"median\"] = median(list)\n\t\tst[\"mode\"] = mode(list)\n\texcept:\n\t\tpass\n\tfor x,y in st.items():\n\t\tprint(\"%s = %d\" % (x,y))\n\ncoms = {'\/stats' : stats}\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_140","text":"<gh_stars>100-1000\n\"\"\"\nScript with classes and functions for nucleosome calling.\n\n@author: <NAME>, Greenleaf Lab, Stanford University\n\"\"\"\n\nimport numpy as np\nfrom scipy import optimize, signal\nfrom copy import copy\nfrom bisect import bisect_left\nimport pyximport; pyximport.install(setup_args={\"include_dirs\":np.get_include()})\nfrom nucleoatac.multinomial_cov import calculateCov\nfrom nucleoatac.Occupancy import OccupancyTrack\nfrom pyatac.tracks import Track, CoverageTrack\nfrom pyatac.chunk import Chunk\nfrom pyatac.utils import call_peaks, reduce_peaks, read_chrom_sizes_from_bam\nfrom pyatac.chunkmat2d import FragmentMat2D, BiasMat2D\nfrom pyatac.bias import InsertionBiasTrack, PWM\n\n\n#import warnings\n#warnings.filterwarnings('error')\n\n\nclass SignalTrack(Track):\n    \"\"\"Class for getting V-plot signal\"\"\"\n    def __init__(self, chrom, start, end):\n        Track.__init__(self, chrom, start, end, \"signal\")\n    def calculateSignal(self, mat, vmat):\n        offset=self.start-mat.start-vmat.w\n        if offset<0:\n            raise Exception(\"Insufficient flanking region on \\\n                    mat to calculate signal\")\n        self.vals = signal.correlate(mat.get(vmat.lower,vmat.upper,\n                                              mat.start + offset, mat.end - offset),\n                                       vmat.mat,mode = 'valid')[0]\n\nclass NormSignalTrack(Track):\n    \"\"\"Class for storing normalized signal track\"\"\"\n    def __init__(self, chrom, start, end):\n        Track.__init__(self, chrom, start, end, \"normalized signal\")\n    def calculateNormSignal(self, raw, bias):\n        self.vals = raw.get(self.start, self.end) - bias.get(self.start,self.end)\n\nclass BiasTrack(Track):\n    \"\"\"Class for getting Bias Signal Track-- Background model\"\"\"\n    def __init__(self, chrom, start, end):\n        Track.__init__(self, chrom, start, end, \"bias\")\n    def calculateBackgroundSignal(self, mat, vmat, nuc_cov):\n        offset=self.start-mat.start-vmat.w\n        if offset<0:\n            raise Exception(\"Insufficient flanking region on \\\n                    mat to calculate signal\")\n        self.vmat = vmat\n        self.bias_mat = mat\n        self.cov = CoverageTrack(self.chrom, self.start, self.end)\n        self.cov.calculateCoverage(self.bias_mat, vmat.lower,\n                                   vmat.upper, vmat.w*2+1)\n        self.nuc_cov = nuc_cov.vals\n        self.vals = signal.correlate(self.bias_mat.get(vmat.lower,vmat.upper,\n                                                         self.bias_mat.start + offset,\n                                                         self.bias_mat.end - offset),\n                                       vmat.mat,mode = 'valid')[0]\n        self.vals = self.vals * self.nuc_cov\/ self.cov.vals\n\n\n\nclass SignalDistribution:\n    \"\"\"Class for determining distribution of signal\"\"\"\n    def __init__(self, position, vmat, bias_mat, reads):\n        self.position = position\n        self.reads = reads\n        self.vmat = vmat\n        bias_mat = bias_mat.get(vmat.lower,vmat.upper,position - vmat.w,position  + vmat.w + 1)\n        self.prob_mat = bias_mat \/ np.sum(bias_mat)\n        self.probs = self.prob_mat.flatten()\n    def simulateReads(self):\n        sim_vect = np.random.multinomial(self.reads,self.probs)\n        sim_mat = np.reshape(sim_vect, self.vmat.mat.shape)\n        return sim_mat\n    def simulateDist(self, numiters = 1000):\n        self.scores = map(lambda x: np.sum(self.simulateReads() * self.vmat.mat),range(numiters))\n    def analStd(self):\n        flatv = np.ravel(self.vmat.mat)\n        var = calculateCov(self.probs, flatv, self.reads)\n        return np.sqrt(var)\n    def analMean(self):\n        return np.sum(self.prob_mat * self.vmat.mat * self.reads)\n\n\n\ndef norm(x, v, w, mean):\n    \"\"\"compute values of normal pdf with given mean and sd at values in x\"\"\"\n    norm = (1.0\/(np.sqrt(2*np.pi*v)) *\n        np.exp(-(x - mean)**2\/(2*v)))\n    norm = norm * (w\/max(norm))\n    return norm\n\nclass Nucleosome(Chunk):\n    \"\"\"Class for storing information about a single nucleosome\"\"\"\n    def __init__(self, pos,nuctrack):\n        self.chrom = nuctrack.chrom\n        self.start = pos\n        self.end = pos + 1\n        self.nfr_cov = nuctrack.nfr_cov.get(pos = pos)\n        self.nuc_cov = nuctrack.nuc_cov.get(pos = pos)\n        self.nuc_signal = nuctrack.nuc_signal.get(pos = pos)\n        self.norm_signal = nuctrack.norm_signal.get(pos = pos)\n        self.smoothed = nuctrack.smoothed.get(pos= pos)\n    def getLR(self,nuctrack):\n        mat = nuctrack.mat.get(nuctrack.params.lower,nuctrack.params.upper,\n                                self.start - nuctrack.params.vmat.w, self.start + nuctrack.params.vmat.w +1)\n        null_mat = nuctrack.bias_mat.get(nuctrack.params.lower,nuctrack.params.upper,\n                                self.start - nuctrack.params.vmat.w, self.start + nuctrack.params.vmat.w +1)\n        bias_mat =nuctrack.bias_mat_prenorm.get(nuctrack.params.lower,nuctrack.params.upper,\n                                self.start - nuctrack.params.vmat.w, self.start + nuctrack.params.vmat.w +1)\n        nuc_model = nuctrack.params.vmat.mat * bias_mat\n        nuc_model = nuc_model \/ np.sum(nuc_model)\n        null_model = null_mat \/ np.sum(null_mat)\n        nuc_lik = np.sum(np.log(nuc_model) * mat)\n        null_lik = np.sum(np.log(null_model) * mat)\n        self.lr = nuc_lik - null_lik\n    def getZScore(self, nuctrack):\n        s = SignalDistribution(self.start, nuctrack.params.vmat, nuctrack.bias_mat,\n                                self.nuc_cov)\n        std = s.analStd()\n        self.z = self.norm_signal \/ std\n    def getOcc(self, nuctrack):\n        try:\n            self.occ = nuctrack.occ.get(pos = self.start)\n            self.occ_lower = nuctrack.occ_lower.get(pos = self.start)\n            self.occ_upper = nuctrack.occ_upper.get(pos = self.start)\n        except:\n            self.occ = np.nan\n            self.occ_lower = np.nan\n            self.occ_upper = np.nan\n    def getFuzz(self, nuctrack):\n        def addNorms(x,params):\n            \"\"\"Add several normal distributions together\"\"\"\n            l = len(x)\n            fit = np.zeros(l)\n            i = len(params)\/3\n            for j in range(i):\n                fit += norm(x,params[j*3],params[3*j+1],params[3*j+2])\n            return fit\n        def err_func(pars,y):\n            \"\"\"error function for normal fit; to be used for fitNorm\"\"\"\n            x = np.linspace(0,len(y)-1,len(y))\n            return sum((addNorms(x, pars) - y)**2)\n        def fitNorm(guess, bound, sig):\n            \"\"\"Fit a normal to the signal with lower and upperbounds to sd\"\"\"\n            a = (sig,)\n            res = optimize.minimize(err_func,guess,args = a, bounds=bound,method=\"L-BFGS-B\")\n            return res\n        index = self.start - nuctrack.start\n        allnucs = nuctrack.sorted_nuc_keys\n        x = bisect_left(allnucs,index)\n        if x == 0:\n            left = index - nuctrack.params.nonredundant_sep\/3\n            means = (nuctrack.params.nonredundant_sep\/3,)\n        elif index - allnucs[x-1] < nuctrack.params.nonredundant_sep:\n            left = allnucs[x-1]\n            means = (index - allnucs[x-1],0)\n        else:\n            left = index - nuctrack.params.nonredundant_sep\/3\n            means = (nuctrack.params.nonredundant_sep\/3,)\n        if x == len(allnucs)-1:\n            right = index + nuctrack.params.nonredundant_sep\/3 + 1\n        elif allnucs[x+1] - index < nuctrack.params.nonredundant_sep:\n            right = allnucs[x+1]\n            means += (allnucs[x+1] - left,)\n        else:\n            right = index + nuctrack.params.nonredundant_sep\/3 +1\n        sig = nuctrack.smoothed.vals[left:right]\n        sig[sig<0] = 0\n        if len(means)==1:\n            bounds = ((2**2,50**2),(0.001,max(sig)*1.1),(means[0]-10,means[0]+10))\n            guesses = (nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[0])\n        elif len(means)==2:\n            bounds = ((2**2,50**2),(0.001,max(sig)*1.1),(means[0]-10,means[0]+10),\n                        (2**2,50**2),(0.001,max(sig)*1.1),(means[1]-10,means[1]+10))\n            guesses = (nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[0],\n                    nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[1])\n        elif len(means)==3:\n            bounds = ((2**2,50**2),(0.001,max(sig)*1.1),(means[0]-10,means[0]+10),\n                        (2**2,50**2),(0.001,max(sig)*1.1),(means[1]-10,means[1]+10),\n                        (2**2,50**2),(0.001,max(sig)*1.1),(means[2]-10,means[2]+10))\n            guesses = (nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[0],\n                    nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[1],\n                    nuctrack.params.smooth_sd ** 2,max(sig)*0.9,means[2])\n        res= fitNorm(guesses, bounds, sig)\n        self.fuzz= np.sqrt(res['x'][0])\n        self.weight = res['x'][1]\n        self.fit_pos = res['x'][2]+left\n    def asBed(self):\n        out = \"\\t\".join(map(str,[self.chrom, self.start, self.end, self.z, self.occ, self.occ_lower, self.occ_upper, self.lr,\n               self.norm_signal, self.nuc_signal, self.nuc_cov, self.nfr_cov,\n                self.fuzz]))\n        return out\n    def write(self, handle):\n       handle.write(self.asBed() + \"\\n\")\n\n\nclass NucParameters:\n    \"\"\"Class for storing parameters related to nucleosome calling\"\"\"\n    def __init__(self, vmat, fragmentsizes, bam, fasta, pwm,\n                 occ_track = None, atac = True,\n                 sd = 25, nonredundant_sep = 120, redundant_sep = 25,\n                 min_z = 3, min_lr = 0, min_reads = 1):\n        self.atac = atac\n        self.vmat = vmat\n        self.lower = vmat.lower\n        self.upper= vmat.upper\n        self.window = vmat.mat.shape[1]\n        self.fragmentsizes= fragmentsizes\n        self.min_reads = min_reads\n        self.min_z = min_z\n        self.min_lr = min_lr\n        self.smooth_sd = sd\n        self.redundant_sep = redundant_sep\n        self.nonredundant_sep = nonredundant_sep\n        self.fasta = fasta\n        self.pwm = PWM.open(pwm)\n        self.chrs = read_chrom_sizes_from_bam(bam)\n        self.bam = bam\n        self.occ_track = occ_track\n\n\n\nclass NucChunk(Chunk):\n    \"\"\"Class for storing and determining collection of nucleosome positions\n    \"\"\"\n    def __init__(self, chunk):\n        self.start = chunk.start\n        self.end = chunk.end\n        self.chrom = chunk.chrom\n    def initialize(self, parameters):\n        self.params = parameters\n    def getFragmentMat(self):\n        self.mat = FragmentMat2D(self.chrom, self.start - max(self.params.window,self.params.upper\/2+1),\n                                 self.end + max(self.params.window,self.params.upper\/2+1), 0, self.params.upper, atac = self.params.atac)\n        self.mat.makeFragmentMat(self.params.bam)\n    def makeBiasMat(self):\n        self.bias_mat = BiasMat2D(self.chrom, self.start - self.params.window,\n                                 self.end + self.params.window, 0, self.params.upper)\n        bias_track = InsertionBiasTrack(self.chrom, self.start - self.params.window - self.params.upper\/2,\n                                  self.end + self.params.window + self.params.upper\/2 + 1, log = True)\n        if self.params.fasta is not None:\n            bias_track.computeBias(self.params.fasta, self.params.chrs, self.params.pwm)\n            self.bias_mat.makeBiasMat(bias_track)\n        self.bias_mat_prenorm = BiasMat2D(self.chrom, self.start - self.params.window,\n                                 self.end + self.params.window, 0, self.params.upper)\n        self.bias_mat_prenorm.mat = copy(self.bias_mat.mat)\n        self.bias_mat.normByInsertDist(self.params.fragmentsizes)\n    def getNucSignal(self):\n        \"\"\"Gets Nucleosome Signal Track\"\"\"\n        self.nuc_cov = CoverageTrack(self.chrom, self.start,\n                                     self.end)\n        self.nuc_cov.calculateCoverage(self.mat, self.params.lower, self.params.upper,\n                                        self.params.window)\n        self.bias = BiasTrack(self.chrom, self.start,\n                                     self.end)\n        self.bias.calculateBackgroundSignal(self.bias_mat, self.params.vmat, self.nuc_cov)\n        self.nuc_signal = SignalTrack(self.chrom, self.start,\n                                     self.end)\n        self.nuc_signal.calculateSignal(self.mat, self.params.vmat)\n        self.norm_signal = NormSignalTrack(self.chrom, self.start, self.end)\n        self.norm_signal.calculateNormSignal(self.nuc_signal,self.bias)\n    def getNFR(self):\n        \"\"\"get number of reads of sub-nucleosomal length\"\"\"\n        self.nfr_cov = CoverageTrack(self.chrom, self.start, self.end)\n        self.nfr_cov.calculateCoverage(self.mat, 0, self.params.lower,\n                                                        self.params.window)\n    def smoothSignal(self):\n        \"\"\"Smooth thenormalized signal track\"\"\"\n        window_len = 6 * self.params.smooth_sd + 1\n        self.smoothed = Track(self.chrom,self.start,self.end, \"Smooth Signal\")\n        tmp = copy(self.norm_signal.vals)\n        self.smoothed.assign_track(tmp)\n        self.smoothed.vals[ self.smoothed.vals < 0] = 0\n        self.smoothed.smooth_track(window_len, window = \"gaussian\",\n                             sd = self.params.smooth_sd, mode = 'same',\n                             norm = True)\n    def getOcc(self):\n        \"\"\"gets occupancy track-- either reads in from bw handle given, or makes new\"\"\"\n        self.occ = Track(self.chrom,self.start,self.end,\"Occupancy\")\n        self.occ.read_track(self.params.occ_track)\n        lower_file = self.params.occ_track[:-11] + 'lower_bound.bedgraph.gz'\n        self.occ_lower = Track(self.chrom,self.start,self.end,\"Occupancy\")\n        self.occ_lower.read_track(lower_file)\n        upper_file = self.params.occ_track[:-11] + 'upper_bound.bedgraph.gz'\n        self.occ_upper = Track(self.chrom,self.start,self.end,\"Occupancy\")\n        self.occ_upper.read_track(upper_file)\n    def findAllNucs(self):\n        \"\"\"Find peaks in data\"\"\"\n        self.nuc_collection = {}\n        combined = self.norm_signal.vals + self.smoothed.vals\n        #find peaks in normalized sigal\n        cands1 = call_peaks(combined, min_signal = 0,\n                                sep = self.params.redundant_sep,\n                                boundary = self.params.nonredundant_sep\/2, order = self.params.redundant_sep\/2)\n        for i in cands1:\n            nuc = Nucleosome(i + self.start, self)\n            if nuc.nuc_cov > self.params.min_reads:\n                nuc.getLR(self)\n                if nuc.lr > self.params.min_lr:\n                    nuc.getZScore(self)\n                    if nuc.z >= self.params.min_z:\n                        nuc.getOcc(self)\n                        self.nuc_collection[i] = nuc\n        self.sorted_nuc_keys = np.array(sorted(self.nuc_collection.keys()))\n        self.nonredundant = reduce_peaks( self.sorted_nuc_keys,\n                                            map(lambda x: self.nuc_collection[x].z, self.sorted_nuc_keys),\n                                                self.params.nonredundant_sep)\n        self.redundant = np.setdiff1d(self.sorted_nuc_keys, self.nonredundant)\n    def fit(self):\n        x = np.linspace(0,self.length() -1, self.length())\n        fit = np.zeros(self.length())\n        for nuc in self.sorted_nuc_keys:\n            self.nuc_collection[nuc].getFuzz(self)\n            fit += norm(x,self.nuc_collection[nuc].fuzz**2, self.nuc_collection[nuc].weight, self.nuc_collection[nuc].fit_pos)\n        self.fitted = Track(self.chrom, self.start, self.end,\n                            \"Fitted Nucleosome Signal\")\n        self.fitted.assign_track(fit)\n    def makeInsertionTrack(self):\n        \"\"\"make insertion track for chunk\"\"\"\n        self.ins = self.mat.getIns()\n    def process(self, params):\n        \"\"\"wrapper to carry out all methods needed to call nucleosomes and nfrs\"\"\"\n        self.initialize(params)\n        self.getFragmentMat()\n        self.makeBiasMat()\n        self.getNucSignal()\n        self.getNFR()\n        self.smoothSignal()\n        if params.occ_track is not None:\n            self.getOcc()\n        self.findAllNucs()\n        self.fit()\n        self.makeInsertionTrack()\n    def removeData(self):\n        \"\"\"remove data from chunk-- deletes all attributes\"\"\"\n        names = self.__dict__.keys()\n        for name in names:\n            delattr(self,name)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_141","text":"import numpy as np\n\n# for interactive drawing\nimport tkanvas\nimport pykalman\nimport scipy.stats\n\n\ndef kf_loglik(C, mean, cov, obs):\n    pred_obs_mean = np.dot(C, mean)\n    pred_obs_cov = np.dot(C, np.dot(cov, C.T))\n    obs_arr = np.array(obs)\n    # likelihood of this sample\n    return scipy.stats.multivariate_normal.logpdf(\n        obs_arr, mean=pred_obs_mean, cov=pred_obs_cov\n    )\n\nclass KFDisplay(object):\n    def __init__(self, A, C, sigma_a, sigma_c, mu_0, sigma_0, path, frame_time=2000, reject_lik=None):\n        self.track = True\n        self.A = A\n        self.C = C\n        self.reject_lik = reject_lik\n        self.sigma_c = sigma_c\n        \n        self.path = iter(path)\n        self.kalman_filter = pykalman.KalmanFilter(\n            transition_matrices=A,\n            observation_matrices=C,\n            transition_covariance=sigma_a,\n            observation_covariance=sigma_c,\n            initial_state_mean=mu_0,\n            initial_state_covariance=sigma_0,\n        )\n        self.obs_path = []\n        self.track_path = []\n        self.obs = next(self.path)\n        self.src = tkanvas.TKanvas(\n            draw_fn=self.kalman_draw,\n            frame_time=frame_time,\n            w=800,\n            h=800,\n            bgcolor=\"black\",\n        )\n        self.mean, self.cov = mu_0, sigma_0\n        self.new_mean, self.new_cov = self.kalman_filter.filter_update(\n            self.mean, self.cov, observation=self.obs\n        )\n        self.lik = kf_loglik(self.C, self.new_mean, self.cov, self.obs)\n\n        self.kalman_iter = self.draw_kalman_filter()\n\n    # Draw each step of the Kalman filter onto a TKinter canvas\n    def draw_kalman_filter(self):\n\n        self.src.clear()\n        font = (\"Arial\", 24)\n        for p in self.obs_path:\n            self.src.circle(p[0], p[1], 2, fill=\"white\")\n        for p in self.track_path:\n            self.src.circle(p[0], p[1], 2, fill=\"blue\")\n        if self.obs is not None:\n            self.obs_path.append(self.obs)\n        self.track_path.append(self.new_mean[:2])\n        # don't bother drawing circles when at speed\n\n        # draw the prior\n        self.src.normal(self.mean[:2], self.cov[:2, :2], outline=\"#0000ff\")\n        loglik = self.src.text(\n            20, 40, text=\"%.0f\"%self.lik, anchor=\"w\", fill=\"gray\", font=(\"Arial\", 10)\n        )\n        if self.src.frame_time < 50:\n            return\n        text = self.src.text(\n            20, 20, text=\"Prior P(X_t)\", anchor=\"w\", fill=\"gray\", font=font\n        )\n        self.src.to_front(text)\n        yield 0  # this is a trick to allow to \"return\" here but resume later\n        ax = np.dot(self.A, self.mean)\n        acov = np.dot(np.dot(self.A, self.cov), self.A.T)\n        # prediction after linear dynamics\n        self.src.normal(ax[:2], acov[:2, :2], outline=\"#00ff00\", dash=(2, 4))\n        self.src.modify(text, text=\"Prediction f(x_(t-1)) -> x_t\")\n        self.src.to_front(text)\n        yield 0\n        # prediction after linear dynamics\n        self.src.normal(ax[:2], acov[:2, :2], outline=\"#dd00ff\", dash=(2, 2))\n        self.src.modify(text, text=\"Expected observation y_t g(x_t) -> y'_t\")\n        self.src.to_front(text)\n        yield 0\n        if self.obs is not None:\n            # observation (if there is one)\n            self.src.circle(self.obs[0], self.obs[1], 5, fill=\"#ffffff\")\n            # src.modify(text, text=\"Observation y_t\")\n            # uncertainty of observation\n            self.src.normal(\n                self.obs, self.sigma_c[:2, :2], outline=\"#6600ff\", dash=(2, 2)\n            )\n            self.src.modify(text, text=\"Observation w\/uncertainty\")\n            self.src.to_front(text)\n            yield 0\n            yield 0\n        # posterior\n        self.src.normal(self.new_mean[:2], self.new_cov[:2, :2], outline=\"#8899ff\")\n        self.src.modify(text, text=\"Posterior P(Xt|Yt)\")\n        self.src.to_front(text)\n        yield 0\n\n    # draw the Kalman filter updates interactively\n\n    def kalman_draw(self, src):\n\n        if self.src.frame_time > 20:\n            # slowly speed up over time\n            self.src.frame_time = src.frame_time * 0.95\n        try:\n            next(self.kalman_iter)\n        # we've drawn all the steps, so make another update\n        except StopIteration:\n            self.mean, self.cov = self.new_mean, self.new_cov\n            try:\n                self.obs = next(self.path)   \n            except StopIteration:\n                src.quit(None)\n                return\n        \n            self.lik = kf_loglik(self.C, self.mean, self.cov, self.obs)\n            if self.reject_lik is None or self.lik>self.reject_lik: \n                self.new_mean, self.new_cov = self.kalman_filter.filter_update(\n                    self.mean, self.cov, observation=self.obs\n                )\n              \n            self.kalman_iter = self.draw_kalman_filter()\n            return\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_142","text":"from IPython.display import Image\nfrom IPython.core.display import HTML \nimport numpy as np\nimport sympy as sp\nimport random as r\nimport time\nimport matplotlib.pyplot as plt\nimport ipyturtle as turtle\n\nfrom scipy.ndimage.filters import gaussian_filter1d\nfrom scipy.signal import savgol_filter"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_143","text":"<filename>src\/S_optic.py\n## Calculation of optic mode contributions to entropy (S)\r\n\r\nimport math\r\nimport numpy as np\r\nfrom scipy.integrate import quad\r\n\r\n#import params.py for all input parameters\r\nfrom params import *\r\n\r\n##########################################################################\r\n\r\nS_o = []\r\n\r\nfor i in ATEMP:\r\n    x_L = wc_L*CONV\/i #define lower bound of optic box integral\r\n    \r\n    x_U = wc_U*CONV\/i #define upper bound of optic box integral\r\n    \r\n    def optic_1(x1):\r\n        return x1\/(math.exp(x1)-1.)\r\n\r\n    optic_quad_1, error = quad(optic_1, x_L, x_U)\r\n\r\n    optic_S_1 = 3.*AVO*BOLTZ*(1.0-1.\/(Natoms*Z)-q_c)*optic_quad_1\r\n\r\n    # Set up second function\r\n\r\n    def optic_2(x2):\r\n        return math.log(1. - math.exp(-x2))\r\n\r\n    optic_quad_2, error = quad(optic_2, x_L, x_U)\r\n    \r\n    optic_S_2 = 3.*AVO*BOLTZ*(1.0-1.\/(Natoms*Z)-q_c)*optic_quad_2\r\n\r\n    S_o.append(optic_S_1 - optic_S_2)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_132","text":"################################################################################\n#                                                                              #\n# Advection in 2D of a Passive Scalar                                          #\n#                                                                              #\n################################################################################\n\nfrom __future__ import print_function, division\nimport os\nimport sys; sys.dont_write_bytecode = True\nsys.path.insert(0, '..\/script\/')\nsys.path.insert(0, '..\/script\/analysis')\nfrom subprocess import call\nfrom shutil import copyfile\nimport glob\nimport numpy as np\nimport scipy as sp\nfrom scipy import optimize\nimport hdf5_to_dict as io\nimport util\nfrom bhlight import bcall\nimport multiprocessing\n\nTMP_DIR = 'TMP'\nTMP_BUILD = 'build_tmp.py'\nutil.safe_remove(TMP_DIR)\n\nPROBLEM = 'advection2d'\nAUTO = '-auto' in sys.argv\nMPI = '-mpi' in sys.argv\nMOVIE = '-movie' in sys.argv\nRES = [64,128,256]\nif AUTO:\n    import pickle\nelse:\n    import matplotlib as mpl; mpl.use('Agg')\n    from matplotlib import animation, rc\n    from matplotlib import pyplot as plt\n    rc('font',size=18)\n\nkwave = 2*np.pi\namp = 1.0\nnspace = 2.0\nddiag = np.sqrt(nspace)\ncadv = 0.5*ddiag\ncsqr = cadv**2\ngamma = np.sqrt(1.\/(1. - csqr))\nqsqr = gamma**2 - 1.0\nu1d = np.sqrt(qsqr\/nspace)\nc1d = cadv \/ ddiag\n\ndef phi_true(t,x,y):\n    phi_x = np.cos(kwave*(x - c1d*t))\n    phi_y = np.cos(kwave*(y - c1d*t))\n    return amp*phi_x*phi_y\n\nutil.make_dir(TMP_DIR)\nos.chdir('..\/prob\/' + PROBLEM)\ncopyfile('build.py', TMP_BUILD)\n\n# Since this test is designed to run on a single machine (no batch scripts)\n# set openmpi to only use a few threads. Let MPI handle the rest.\nif MPI:\n    num_mpi = 4\n    num_cpus = multiprocessing.cpu_count()\n    os.environ['OMP_NUM_THREADS'] = str(int(np.max([2,num_cpus\/num_mpi])))\n\n# COMPILE CODE AT MULTIPLE RESOLUTIONS USING SEPARATE BUILD FILE\nfor n,res in enumerate(RES):\n    for d in [1,2]:\n        util.change_cparm('N{}TOT'.format(d), res, TMP_BUILD)\n    if MPI:\n        for d in [1,2]:\n            util.change_cparm('N{}CPU'.format(d), 2, TMP_BUILD)\n    call([sys.executable, TMP_BUILD, '-dir', TMP_DIR])\n    parm_src = os.path.join(os.getcwd(), TMP_DIR, 'param_template.dat')\n    parm_dest = '..\/..\/test\/' +  TMP_DIR + '\/param.dat'\n    call(['cp', os.path.join(os.getcwd(), TMP_DIR, 'bhlight'),\n          '..\/..\/test\/' + TMP_DIR + '\/bhlight_' + str(res)])\n    copyfile(parm_src,parm_dest)\nutil.safe_remove(TMP_BUILD)\nutil.safe_remove(TMP_DIR)\nos.chdir('..\/..\/test\/')\nos.chdir(TMP_DIR)\n\n# and convergence plot\nprint(\"Convergence test...\")\nerrs = [None for res in RES]\nfor n,res in enumerate(RES):\n    print(\"Res = {}\".format(res))\n    call_string = ['.\/bhlight_' + str(res), '-p', 'param.dat']\n    if MPI:\n        bcall(call_string,int(num_mpi))\n    else:\n        bcall(call_string)\n    dfiles = sorted(glob.glob('dumps\/dump*.h5'))\n    hdr = io.load_hdr(dfiles[-1])\n    geom = io.load_geom(hdr, recalc=True)\n    dump = io.load_dump(dfiles[-1],geom)\n    N1,N2 = [hdr['N{}'.format(d)] for d in [1,2]]\n    mshape = (N1,N2)\n    t = dump['t']\n    x,y = [geom[d].reshape(mshape) for d in ['x','y']]\n    phi = dump['var0'].reshape(mshape)\n    error = phi - phi_true(t,x,y)\n    max_error = np.max(np.abs(error))\n    errs[n] = max_error\n\nprint(\"Richardson extrapolating...\")\nerrf = lambda h, alpha, p: alpha*(h**p)\np0 = 2.0\nh0 = 1.0\/RES[0]\nerr0 = errs[0]\nalpha0 = err0*h0*h0\nhs = 1.0\/np.array(RES)\n(alpha,p),pcov = optimize.curve_fit(errf,hs,errs,p0=(alpha0,p0))\nprint(\"Convergence data:\\nalpha = {}, p = {}\\npcov = {}\\n\".format(\n    alpha,p,pcov))\n\nif AUTO:\n    os.chdir(\"..\/\")\n    data = {}\n    data['SOL'] = [np.array([0.0]), np.array([2.0])]\n    data['CODE'] = [np.array([0.0]), np.array([p])]\n    data['THRESHOLD'] = 0.03\n    pickle.dump(data, open('data.p', 'wb'))\n    util.safe_remove(TMP_DIR)\n    sys.exit()\n\nprint(\"Plotting convergence...\")\nplt.loglog(RES,errf(hs,alpha,p),lw=2,ls='--',\n           label=(r'$%.2f h^{%.2f}$' % (alpha,p)))\nplt.loglog(RES,errs,'ro',ms=12,label='measured')\nplt.xlabel('Resolution')\nplt.ylabel(r'$\\left| \\phi^h - \\phi_{true} \\right|_\\infty$')\nplt.legend()\nplt.savefig('..\/{}.png'.format(PROBLEM),bbox_inches='tight')\nplt.clf()\n\nif MOVIE:\n    print(\"Making movie\")\n    dfiles = sorted(glob.glob('dumps\/dump*.h5'))\n    hdr = io.load_hdr(dfiles[0])\n    geom = io.load_geom(hdr)\n    N1,N2 = [hdr['N{}'.format(d)] for d in [1,2]]\n    mshape = (N1,N2)\n    x,y = [geom[d].reshape(mshape) for d in ['x','y']]\n    def get_phi(i):\n        dump = io.load_dump(dfiles[i],geom)\n        phi = dump['var0'].reshape(mshape)\n        return phi\n    phi0 = get_phi(0)\n    fig, ax = plt.subplots()\n    ax.set_xlim((0,1))\n    ax.set_ylim((0,1))\n    ax.set_xlabel('x')\n    ax.set_ylabel('y')\n    pc = ax.pcolormesh(x,y,phi0,\n                       cmap='viridis',\n                       shading='gouraud')\n    cbar = fig.colorbar(pc)\n    cbar.set_clim(-1.1,1.1)\n    cbar.set_label(r'$\\phi$')\n\n    def init():\n        pc.set_array(phi0.ravel())\n        return pc\n    def animate(i):\n        phi = get_phi(i)\n        pc.set_array(phi.ravel())\n        return pc\n\n    anim = mpl.animation.FuncAnimation(fig,animate,\n                                       init_func=init,\n                                       frames=101,\n                                       interval=20,blit=False)\n\n    anim.save(\"..\/{}.mp4\".format(PROBLEM),\n              writer='ffmpeg',\n              extra_args=['-loglevel','verbose'])\n\nprint(\"Done.\")\nutil.safe_remove(TMP_DIR)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_80","text":"<reponame>asantentata\/Stats-project\n#!\/usr\/bin\/env python\n# Function which takes as inputs a hidden satate x_i and a pixel intensity y_i and then gives the \n#probability that the observed intensity of pixel i is y_i and does not consider information from\n#neigbouring particles\n\nfrom scipy import stats\nimport numpy as np\nimport matplotlib.pyplot as plt\n#import cv as cv2\nfrom PIL import Image\n\n#importing image and turning into greyscale (each pixel an array of values from 0-255)\nimport Image\nimage = Image.open(\"noisy_logo.png\")\ngray = np.asarray(image.convert('L'))\n \n\n#defining the outputs of function\ndef likelihood(y_i,x_i):\t\t\t\t\t\n\tif x_i == 1 and y_i <127:\n\t\t\tprobability = 0.15\n\tif x_i == 1 and y_i >=127:\n\t\t\tprobability = 0.85\n\tif x_i == 0 and y_i <127:\n\t\t\tprobability = 0.85\n\tif x_i == 0 and y_i >=127:\n\t\t\tprobability = 0.15\t\n\treturn probability\n\n\n#Testing function by making plot#\nx_i = 1\t\t\t#value of hidden state x_i\nprobability = []\t\t#array of probabilities\nfor y_i in range(0,255):\n\tprobability.append(likelihood(y_i,x_i))\nplt.plot(range(0,255),probability)\nplt.show()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_81","text":"<filename>components\/outlier-detection\/mahalanobis\/CoreMahalanobis.py\nimport logging\nimport numpy as np\nfrom scipy.linalg import eigh\n\nlogger = logging.getLogger(__name__)\n\nclass CoreMahalanobis(object):\n    \"\"\" Outlier detection using the Mahalanobis distance.\n    \n    Parameters\n    ----------\n        threshold (float) : Mahalanobis distance threshold used to classify outliers\n        n_components (int) : number of principal components used\n        n_stdev (float) : stdev used for feature-wise clipping of observations\n        start_clip (int) : number of observations before clipping is applied\n        max_n (int) : algorithm behaves as if it has seen at most max_n points\n     \n    Functions\n    ----------\n        predict : detect and return outliers\n        transform_input : detect outliers and return input features\n        send_feedback : add target labels as part of the feedback loop\n        tags : add metadata for input transformer\n        metrics : return custom metrics\n    \"\"\"\n    def __init__(self,threshold=25,n_components=3,n_stdev=3,start_clip=50,max_n=-1):\n        \n        logger.info(\"Initializing model\")\n        self.threshold = threshold\n        self.n_components = n_components\n        self.max_n = max_n\n        self.n_stdev = n_stdev\n        self.start_clip = start_clip\n        \n        self.clip = None\n        self.mean = 0\n        self.C = 0\n        self.n = 0\n        self.nb_outliers = 0\n    \n    \n    def predict(self, X, feature_names):\n        \"\"\" Return outlier predictions.\n\n        Parameters\n        ----------\n        X : array-like\n        feature_names : array of feature names (optional)\n        \"\"\"\n        logger.info(\"Using component as a model\")\n        return self._get_preds(X)\n    \n    \n    def transform_input(self, X, feature_names):\n        \"\"\" Transform the input. \n        Used when the outlier detector sits on top of another model.\n\n        Parameters\n        ----------\n        X : array-like\n        feature_names : array of feature names (optional)\n        \"\"\"\n        logger.info(\"Using component as an outlier-detector transformer\")\n        self.prediction_meta = self._get_preds(X)\n        return X\n    \n    \n    def _get_preds(self,X):\n        \"\"\" Detect outliers using the Mahalanobis distance threshold.  \n        \n        Parameters\n        ----------\n        X : array-like\n        \"\"\"\n\n        nb = X.shape[0] # batch size\n        p = X.shape[1] # number of features\n        n_components = min(self.n_components,p)\n        if self.max_n>0:\n            n = min(self.n,self.max_n) # n can never be above max_n\n        else:\n            n = self.n\n        \n        # Clip X\n        if self.n > self.start_clip:\n            Xclip = np.clip(X,self.clip[0],self.clip[1])\n        else:\n            Xclip = X\n            \n        # Tracking the mean and covariance matrix\n        roll_partial_means = Xclip.cumsum(axis=0)\/(np.arange(nb)+1).reshape((nb,1))\n        coefs = (np.arange(nb)+1.)\/(np.arange(nb)+n+1.)\n        new_means = self.mean + coefs.reshape((nb,1))*(roll_partial_means-self.mean)\n        new_means_offset = np.empty_like(new_means)\n        new_means_offset[0] = self.mean\n        new_means_offset[1:] = new_means[:-1]\n\n        coefs = ((n+np.arange(nb))\/(n+np.arange(nb)+1.)).reshape((nb,1,1))\n        B = coefs*np.matmul((Xclip - new_means_offset)[:,:,None],(Xclip - new_means_offset)[:,None,:])\n        cov_batch = (n-1.)\/(n+max(1,nb-1.))*self.C + 1.\/(n+max(1,nb-1.))*B.sum(axis=0)\n\n        # PCA\n        eigvals, eigvects = eigh(cov_batch,eigvals=(p-n_components,p-1))\n    \n        # Projections\n        proj_x = np.matmul(X,eigvects)\n        proj_x_clip = np.matmul(Xclip,eigvects)\n        proj_means = np.matmul(new_means_offset,eigvects)\n        if type(self.C) == int and self.C == 0:\n            proj_cov = np.diag(np.zeros(n_components))\n        else:\n            proj_cov = np.matmul(eigvects.transpose(),np.matmul(self.C,eigvects))\n\n        # Outlier detection in the PC subspace\n        coefs = (1.\/(n+np.arange(nb)+1.)).reshape((nb,1,1))\n        B = coefs*np.matmul((proj_x_clip - proj_means)[:,:,None],(proj_x_clip - proj_means)[:,None,:])\n\n        all_C_inv = np.zeros_like(B)\n        c_inv = None\n        _EPSILON = 1e-8\n\n        for i, b in enumerate(B):\n            if c_inv is None:\n                if abs(np.linalg.det(proj_cov)) > _EPSILON:\n                    c_inv = np.linalg.inv(proj_cov)\n                    all_C_inv[i] = c_inv\n                    continue\n                else:\n                    if n + i == 0:\n                        continue\n                    proj_cov = (n + i -1. )\/(n + i)*proj_cov + b\n                    continue\n            else:\n                c_inv = (n + i - 1.)\/float(n + i - 2.)*all_C_inv[i-1]\n            BC1 = np.matmul(B[i-1],c_inv)\n            all_C_inv[i] = c_inv - 1.\/(1.+np.trace(BC1))*np.matmul(c_inv,BC1)\n\n        # Updates\n        self.mean = new_means[-1]\n        self.C = cov_batch\n        stdev = np.sqrt(np.diag(cov_batch))\n        self.n += nb\n        if self.n > self.start_clip:\n            self.clip = [self.mean-self.n_stdev*stdev,self.mean+self.n_stdev*stdev]\n        \n        # Outlier scores and predictions\n        x_diff = proj_x-proj_means\n        self.score = np.matmul(x_diff[:,None,:],np.matmul(all_C_inv,x_diff[:,:,None])).reshape(nb)\n        self.prediction = np.array([1 if s > self.threshold else 0 for s in self.score]).astype(int)\n\n        return self.prediction\n    \n    \n    def send_feedback(self,X,feature_names,reward,truth):\n        \"\"\" Return additional data as part of the feedback loop.\n        \n        Parameters\n        ----------\n            X : array of the features sent in the original predict request\n            feature_names : array of feature names. May be None if not available.\n            reward (float): the reward\n            truth : array with correct value (optional)\n        \"\"\"\n        logger.info(\"Send feedback called\")\n        return []\n    \n    \n    def tags(self):\n        \"\"\"\n        Use predictions made within transform to add these as metadata\n        to the response. Tags will only be collected if the component is\n        used as an input-transformer.\n        \"\"\"\n        try:\n            return {\"outlier-predictions\": self.prediction_meta.tolist()}\n        except AttributeError:\n            logger.info(\"No metadata about outliers\")\n            \n            \n    def metrics(self):\n        \"\"\" Return custom metrics averaged over the prediction batch.\n        \"\"\"\n        self.nb_outliers += np.sum(self.prediction)\n        \n        is_outlier = {\"type\":\"GAUGE\",\"key\":\"is_outlier\",\"value\":np.mean(self.prediction)}\n        outlier_score = {\"type\":\"GAUGE\",\"key\":\"outlier_score\",\"value\":np.mean(self.score)}\n        nb_outliers = {\"type\":\"GAUGE\",\"key\":\"nb_outliers\",\"value\":int(self.nb_outliers)}\n        fraction_outliers = {\"type\":\"GAUGE\",\"key\":\"fraction_outliers\",\"value\":int(self.nb_outliers)\/self.n}\n        obs = {\"type\":\"GAUGE\",\"key\":\"observation\",\"value\":self.n}\n        threshold = {\"type\":\"GAUGE\",\"key\":\"threshold\",\"value\":self.threshold}\n\n        return [is_outlier,outlier_score,nb_outliers,fraction_outliers,obs,threshold]"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_82","text":"<gh_stars>0\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import\nimport math\nfrom scipy.special import gamma\nfrom abc import ABCMeta, abstractmethod\nfrom utils.utils import *\n\nclass Distribution(metaclass=ABCMeta):\n    @abstractmethod\n    def __init__(self):\n        pass\nclass ReparametrizedGaussian(Distribution):\n    \"\"\"\n    Diagonal ReparametrizedGaussian distribution with parameters mu (mean) and rho. The standard\n    deviation is parametrized as sigma = log(1 + exp(rho))\n    A sample from the distribution can be obtained by sampling from a unit Gaussian,\n    shifting the samples by the mean and scaling by the standard deviation:\n    w = mu + log(1 + exp(rho)) * epsilon\n    \"\"\"\n    def __init__(self, mu, rho):\n        self.mean = mu\n        self.rho = rho\n        self.normal = torch.distributions.Normal(0, 1)\n        self.point_estimate = self.mean\n\n    @property\n    def std_dev(self):\n        return torch.log1p(torch.exp(self.rho))\n\n#     def sample(self, n_samples=1):\n#         epsilon = torch.distributions.Normal(0, 1).sample(sample_shape=(n_samples, *self.mean.size()))\n#         return self.mean + self.std_dev * epsilon\n\n    def sample(self):\n        epsilon = torch.distributions.Normal(0, 1).sample(self.mean.size())\n        return self.mean + self.std_dev * epsilon\n    \n    def logprob(self, target):\n        return (-math.log(math.sqrt(2 * math.pi))\n                    - torch.log(self.std_dev)\n                    - ((target - self.mean) ** 2) \/ (2 * self.std_dev ** 2)).sum()\n\n    def entropy(self):\n        \"\"\"\n        Computes the entropy of the Diagonal Gaussian distribution.\n        Details on the computation can be found in the 'diagonal_gaussian_entropy' notes in the repo\n        \"\"\"\n        if self.mean.dim() > 1:\n            n_inputs, n_outputs = self.mean.shape\n        else:\n            n_inputs = len(self.mean)\n            n_outputs = 1\n\n        part1 = (n_inputs * n_outputs) \/ 2 * (torch.log(torch.tensor([2 * math.pi])) + 1)\n        part2 = torch.sum(torch.log(self.std_dev))\n\n        return part1 + part2\n\nclass Gamma(Distribution):\n    \"\"\" Gamma distribution \"\"\"\n    def __init__(self, shape, rate):\n        \"\"\"\n        Class constructor, sets parameters\n        Args:\n            shape: float, shape parameter of the distribution\n            rate: float, rate parameter of the distribution\n        Raises:\n            TypeError: if given rate or shape are not floats\n            ValueError: if given rate or shape are not positive\n        \"\"\"\n        if not isinstance(shape, float) or not isinstance(rate, float):\n            raise TypeError(\"Shape and rate should be floats!\")\n\n        if shape < 0 or rate < 0:\n            raise ValueError(\"Shape and rate must be positive!\")\n\n        self.shape = shape\n        self.rate = rate\n        self.mean = self.shape \/ self.rate\n        self.variance = self.shape \/ self.rate**2\n        self.point_estimate = self.mean\n\n    def update(self, shape, rate):\n        \"\"\"\n        Updates mean and variance automatically when a and b get updated\n        Args:\n            shape: float, shape parameter of the distribution\n            rate: float, rate parameter of the distribution\n        Raises:\n            TypeError: if given rate or shape are not floats\n            ValueError: if given rate or shape are not positive\n        \"\"\"\n        if not isinstance(shape, float) or not isinstance(rate, float):\n            raise TypeError(\"Shape and rate should be floats!\")\n\n        if shape < 0 or rate < 0:\n            raise ValueError(\"Shape and rate must be positive!\")\n\n        self.shape = shape\n        self.rate = rate\n        self.mean = shape \/ rate\n        self.variance = shape \/ rate ** 2\n\nclass InverseGamma(Distribution):\n    \"\"\" Inverse Gamma distribution \"\"\"\n    def __init__(self, shape, rate):\n        \"\"\"\n        Class constructor, sets parameters of the distribution.\n        Args:\n            shape: torch tensor of floats, shape parameters of the distribution\n            rate: torch tensor of floats, rate parameters of the distribution\n        \"\"\"\n        self.shape = shape\n        self.rate = rate\n\n    def exp_inverse(self):\n        \"\"\"\n        Calculates the expectation E[1\/x], where x follows\n        the inverse gamma distribution\n        \"\"\"\n        return self.shape \/ self.rate\n\n    def exp_log(self):\n        \"\"\"\n        Calculates the expectation E[log(x)], where x follows\n        the inverse gamma distribution\n        \"\"\"\n        exp_log = torch.log(self.rate) - torch.digamma(self.shape)\n        return exp_log\n\n    def entropy(self):\n        \"\"\"\n        Calculates the entropy of the inverse gamma distribution\n        \"\"\"\n        entropy =  self.shape + torch.log(self.rate) + torch.lgamma(self.shape) \\\n                     - (1 + self.shape) * torch.digamma(self.shape)\n        return torch.sum(entropy)\n\n    def logprob(self, target):\n        \"\"\"\n        Computes the value of the predictive log likelihood at the target value\n        Args:\n            target: Torch tensor of floats, point(s) to evaluate the logprob\n        Returns:\n            loglike: float, the log likelihood\n        \"\"\"\n        part1 = (self.rate**self.shape) \/ gamma(self.shape)\n        part2 = target**(-self.shape - 1)\n        part3 = torch.exp(-self.rate \/ target)\n\n        return torch.log(part1 * part2 * part3)\n\n    def update(self, shape, rate):\n        \"\"\"\n        Updates shape and rate of the distribution\n        Args:\n            shape: float, shape parameter of the distribution\n            rate: float, rate parameter of the distribution\n        \"\"\"\n        self.shape = shape\n        self.rate = rate\n\nclass Discrete_Flatten_Laplace(Distribution):\n    \"\"\"\n    Flatten Laplace Distribution with mode interval [mu_dowm, mu_up], and precision parameter tau.\n    \"\"\"\n    def __init__(self, mu_down, mu_up, tau, D):\n        self.mu_up = torch.tensor(mu_up)\n        self.mu_down = torch.tensor(mu_down)\n        self.tau = tau\n        self.domain = torch.tensor(np.linspace(0, D, D + 1)).float()\n\n    @property\n    def constant(self):\n        return torch.sum(torch.exp(- self.tau * torch.sqrt(self.flatten(self.domain) ** 2)))\n\n    def pmf(self):\n        return torch.exp(- self.tau * torch.sqrt(self.flatten(self.domain) ** 2)) \/ self.constant\n\n    def sample(self):\n        return torch.multinomial(self.pmf(), 1, replacement=False)\n\n    def flatten(self, x):\n        return torch.max(\n            torch.max(torch.max(self.mu_down - x, torch.zeros(1)), torch.max(-self.mu_up + x, torch.zeros(1))),\n            torch.zeros(1))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_83","text":"from scipy.stats._discrete_distns import zipf_gen\nimport requests\nimport threading\nimport json\nimport codecs\nimport time\nimport os\nimport urllib\nimport errno\nimport zipfile\nfrom wsd.database import MySQLDatabase\nfrom conf import *\n\n\n\n#MEDIAWIKI_API_ENDPOINT = 'https:\/\/en.wikipedia.org\/w\/api.php?action=parse&format=json&prop=text&oldid=' #see:\n#MEDIAWIKI_API_ENDPOINT = 'https:\/\/en.wikipedia.org\/w\/index.php?oldid='#alternative for getting the html\nMEDIAWIKI_API_ENDPOINT = 'https:\/\/en.wikipedia.org\/api\/rest_v1\/page\/html\/'# see: https:\/\/en.wikipedia.org\/api\/rest_v1\/?doc\n\n# Limit the number of threads.\npool = threading.BoundedSemaphore(20)\n\ndef worker(u, article, iteration_number):\n    headers = {'user-agent': EMAIL}\n    # Request passed URL.\n    r = requests.get(u, headers=headers, stream=True)\n    directory = STATIC_HTML_DUMP_ARTICLES_DIR+str(iteration_number)\n    try:\n        os.mkdir(directory)\n    except OSError, e:\n        if e.errno == errno.EEXIST and os.path.isdir(directory):\n            # File exists, and it's a directory,\n            # another process beat us to creating this dir, that's OK.\n            pass\n        else:\n            # Our target dir exists as a file, or different error,\n            # reraise the error!\n            raise\n    error_directory = STATIC_HTML_DUMP_ERRORS_DIR+str(iteration_number)\n    try:\n        os.mkdir(error_directory)\n    except OSError, e:\n        if e.errno == errno.EEXIST and os.path.isdir(error_directory):\n            # File exists, and it's a directory,\n            # another process beat us to creating this dir, that's OK.\n            pass\n        else:\n            # Our target dir exists as a file, or different error,\n            # reraise the error!\n            raise\n    if not os.path.exists(error_directory):\n        os.makedirs(error_directory)\n    if r.status_code == 200:\n        html_article_filename = STATIC_HTML_DUMP_ARTICLES_DIR+str(iteration_number)+'\/article_'+str(article['id'])+'_' +\\\n                           str(article['rev_id'])+'.html'\n        zip_article_filename = STATIC_HTML_DUMP_ARTICLES_DIR+str(iteration_number)+'\/article_'+str(article['id'])+'_' +\\\n                                   str(article['rev_id'])+'.zip'\n        handle_response(r, html_article_filename, zip_article_filename)\n    else:\n        html_article_filename = STATIC_HTML_DUMP_ERRORS_DIR+str(iteration_number)+'\/article_'+str(article['id'])+'_' +\\\n                                   str(article['rev_id'])+'.html'\n        zip_article_filename = STATIC_HTML_DUMP_ERRORS_DIR+str(iteration_number)+'\/article_'+str(article['id'])+'_' +\\\n                                   str(article['rev_id'])+'.zip'\n        handle_response(r, html_article_filename, zip_article_filename)\n\n    # Release lock for other threads.\n    pool.release()\n    # Show the number of active threads.\n    #print threading.active_count()\n\ndef req():\n    # Get URLs from a text file, remove white space.\n    db = MySQLDatabase(DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)\n    db_worker_view = db.get_work_view()\n    articles = db_worker_view.retrieve_all_articles()\n    #articles = db_worker_view.retrieve_all_articles_questionmark()\n    # measure time\n    start = time.clock()\n    start_time_iteration = start\n    iteration_number = 483\n    for i, article in enumerate(articles):\n        # print some progress\n        if i % 10000 == 0:\n            #print time for the iteration\n            seconds = time.clock() - start_time_iteration\n            m, s = divmod(seconds, 60)\n            h, m = divmod(m, 60)\n            print \"Number of crawled articles: %d. Total time for last iteration of 10000 articles: %d:%02d:%02d\" % (i, h, m, s)\n            start_time_iteration = time.clock()\n            iteration_number += 1\n\n        # Thread pool.\n        # Blocks other threads (more than the set limit).\n        pool.acquire(blocking=True)\n        # Create a new thread.\n        # Pass each URL (i.e. u parameter) to the worker function.\n        t = threading.Thread(target=worker, args=(MEDIAWIKI_API_ENDPOINT+urllib.quote(article['title'])+'\/'+str(article['rev_id']), article, iteration_number))\n\n        # Start the newly create thread.\n        t.start()\n    seconds = time.clock() - start\n    m, s = divmod(seconds, 60)\n    h, m = divmod(m, 60)\n    print \"Total time: %d:%02d:%02d\" % (h, m, s)\n\n\ndef handle_response(r, html_article_filename, zip_article_filename):\n    with open(html_article_filename, 'wb') as outfile:\n        for chunk in r.iter_content(1024):\n            outfile.write(chunk)\n        outfile.flush()\n        outfile.close()\n    zf = zipfile.ZipFile(zip_article_filename, mode='w', compression=zipfile.ZIP_DEFLATED)\n    try:\n        zf.write(html_article_filename, os.path.basename(html_article_filename))\n        os.remove(html_article_filename)\n    finally:\n        zf.close()\n\n\nreq()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_84","text":"<reponame>cliu3\/pf_geolocation\nfrom __future__ import print_function\nimport numpy as np\nimport matplotlib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.basemap import Basemap\nimport scipy.io\nimport scipy.stats\nfrom astropy.time import Time\nimport pandas as pd\nfrom my_project import *\nimport os.path\n#from config import *\nimport sys\n\n\n#tagid = 7\n# try:\ntagid = int(sys.argv[1])\n#tagid = 12\n# except:\n\n\n# load tag file\npath_to_tags = '\/home\/cliu3\/pf_geolocation\/data\/tag_files'\ntag=scipy.io.loadmat(path_to_tags+'\/'+str(tagid)+'_raw.mat',squeeze_me =False,struct_as_record=True)\ntag=tag['tag'][0,0]\nrelease_lon = tag['release_lon'][0,0]\nrelease_lat = tag['release_lat'][0,0]\n[release_x, release_y] = my_project(release_lon, release_lat, 'forward')\nrecapture_lon = tag['recapture_lon'][0,0]\nrecapture_lat = tag['recapture_lat'][0,0]\n[recapture_x, recapture_y] = my_project(recapture_lon, recapture_lat, 'forward')\n\ntagname = str(tagid)+'_'+tag['tag_id'][0]\n\n# load result file\nresult = scipy.io.loadmat('result'+tagname+'.mat',squeeze_me =False,struct_as_record=True)\nparticles = result['particles']\nmpt_idx =  result['mpt_idx']\n# determine most probable track\nmpt_x = particles[:,mpt_idx,0].flatten()\nmpt_y = particles[:,mpt_idx,1].flatten()\n(mpt_lon, mpt_lat) = my_project(mpt_x, mpt_y, 'reverse')\n\nday_dnum = np.array(range(int(tag['dnum'][0]), int(tag['dnum'][-1])+1))\ndate = Time(day_dnum-678942,format='mjd',scale='utc').datetime\nMPT = pd.DataFrame({'date':date, 'lon':mpt_lon, 'lat':mpt_lat, 'X':mpt_x, 'Y':mpt_y})\nMPT['date'] = pd.to_datetime(MPT['date'])\nMPT = MPT[['date', 'X', 'Y', 'lat', 'lon']]\nMPT.to_csv('mpt_'+tagname+'.csv')\n#-- calculate cumulative probability distribution\n# construct daily distrubution using kernel density estimation\nxmin = particles[:,:,0].min()\nxmax = particles[:,:,0].max()\nymin = particles[:,:,1].min()\nymax = particles[:,:,1].max()\nX, Y = np.meshgrid(np.linspace(xmin,xmax,50), np.linspace(ymin,ymax,50))\npositions = np.vstack([X.ravel(), Y.ravel()])\n\nndays = len(particles)\nudist = np.zeros_like(X)\n\n# for i in range(ndays):\n#     print(\"Processing kde for Day \"+str(i+1)+\"\/\"+str(ndays)+\"...\")\n#     values = particles[i].T\n#     kernel = scipy.stats.gaussian_kde(values)\n#     Z = np.reshape(kernel(positions).T, X.shape)\n#     Z = Z\/Z.max()\n#     udist += Z\nprint(\"Processing kde...\")\nvalues = np.vstack([particles[:,:,0].flatten(), particles[:,:,1].flatten()])\nkernel = scipy.stats.gaussian_kde(values)\nudist = np.reshape(kernel(positions).T, X.shape)\nudist = udist\/udist.max()\n\nscipy.io.savemat('UD_'+tagname+'.mat',{'X':X, 'Y':Y, 'udist':udist})\n\n# create basemap\nprint('Generating plot...')\nlatStart = 41.15\nlatEnd   = 43.15\nlonStart =-71\nlonEnd   =-68\n\nmap = Basemap(projection='merc', lat_0 = 42, lon_0 = -70,resolution = 'h', area_thresh = 0.1,llcrnrlon=lonStart, llcrnrlat=latStart,\n    urcrnrlon=lonEnd, urcrnrlat=latEnd)\nmap.fillcontinents(color = 'green')\n\n#-- plot mpt\nmptlon, mptlat = my_project(mpt_x, mpt_y, 'inverse')\nmptx, mpty = map(mptlon, mptlat)\nmap.plot(mptx,mpty,'b-')\n#plot release and recapture location\n\nmap.plot(mptx[0],mpty[0],'kx',label=\"Release\")\nrecap_x, recap_y = map(recapture_lon, recapture_lat)\nmap.plot(recap_x, recap_y,'k^',markeredgecolor='k',label=\"Reported Recapture\")\nmap.plot(mptx[-1],mpty[-1],'bv',markeredgecolor='b',label=\"Simulated Recapture\")\n\n\n#-- plot uncertainty distribution\nlon_g, lat_g = my_project(X, Y, 'inverse')\nmap.pcolormesh(lon_g, lat_g,udist,cmap=plt.cm.cubehelix_r,latlon=True,shading='gouraud')\n\nplt.legend(numpoints=1,prop={'size':16},loc='lower right')\nplt.title(tagname+' gpu')\n\nplt.savefig('track'+tagname+'_gpu.pdf', dpi=300, bbox_inches='tight')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_85","text":"<gh_stars>0\nimport time\n\nfrom typing import Tuple\nimport math\n\nfrom vendor.nfb.pynfb.protocols.ssd.topomap_selector_ica import ICADialog\n\nimport numpy as np\nimport mne\nfrom numpy.linalg import svd\nfrom scipy.optimize import linprog\nfrom sklearn.preprocessing import normalize\nfrom mne.preprocessing import find_outliers\nfrom mne.minimum_norm import apply_inverse_raw  # , make_inverse_operator\nfrom mne.minimum_norm import make_inverse_operator as mne_make_inverse_operator\nfrom mne.beamformer import apply_lcmv_raw\nfrom ..helpers.make_lcmv import make_lcmv\n\nfrom .node import ProcessorNode\nfrom ..helpers.matrix_functions import (make_time_dimension_second,\n                                        put_time_dimension_back_from_second,\n                                        last_sample)\nfrom ..helpers.inverse_model import (get_default_forward_file,\n                                     get_clean_forward,\n                                     make_inverse_operator,\n                                     matrix_from_inverse_operator)\n\nfrom ..helpers.pynfb import (pynfb_ndarray_function_wrapper,\n                             ExponentialMatrixSmoother)\nfrom ..helpers.channels import channel_labels_saver\nfrom ..helpers.aux_tools import nostdout\nfrom .. import TIME_AXIS\nfrom vendor.nfb.pynfb.signal_processing import filters\n\n\nclass Preprocessing(ProcessorNode):\n    CHANGES_IN_THESE_REQUIRE_RESET = ('collect_for_x_seconds', )\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info', )\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info': channel_labels_saver}\n\n    def __init__(self, collect_for_x_seconds: int=60):\n        super().__init__()\n        self.collect_for_x_seconds = collect_for_x_seconds  # type: int\n\n        self._samples_collected = None  # type: int\n        self._samples_to_be_collected = None  # type: int\n        self._enough_collected = None  # type: bool\n        self._means = None  # type: np.ndarray\n        self._mean_sums_of_squares = None  # type: np.ndarray\n        self._bad_channel_indices = None  # type: List[int]\n        self._interpolation_matrix = None  # type: np.ndarray\n\n        self._reset_statistics()\n\n    def _initialize(self):\n        self.mne_info = self.traverse_back_and_find('mne_info')\n        frequency = self.mne_info['sfreq']\n        self._samples_to_be_collected = int(math.ceil(\n            self.collect_for_x_seconds * frequency))\n\n    def _update(self):\n        # Have we collected enough samples without the new input?\n        enough_collected = self._samples_collected >=\\\n                self._samples_to_be_collected\n        if not enough_collected:\n            if self.input_node.output is not None and\\\n                    self.input_node.output.shape[TIME_AXIS] > 0:\n                self._update_statistics()\n\n        elif not self._enough_collected:  # We just got enough samples\n            self._enough_collected = True\n            standard_deviations = self._calculate_standard_deviations()\n            self._bad_channel_indices = find_outliers(standard_deviations)\n            if any(self._bad_channel_indices):\n                # message = Message(there_has_been_a_change=True,\n                #                   output_history_is_no_longer_valid=True)\n                # self._deliver_a_message_to_receivers(message)\n                # self.mne_info['bads'].append(self._bad_channel_indices)\n                # self.mne_info['bads'] = self._bad_channel_indices\n\n                # TODO: handle emergent bad channels on the go\n                pass\n\n        self.output = self.input_node.output\n\n    def _reset(self) -> bool:\n        self._reset_statistics()\n        self._input_history_is_no_longer_valid = True\n        return self._input_history_is_no_longer_valid\n\n    def _reset_statistics(self):\n        self._samples_collected = 0\n        self._enough_collected = False\n        self._means = 0\n        self._mean_sums_of_squares = 0\n        self._bad_channel_indices = []\n\n    def _update_statistics(self):\n        input_array = self.input_node.output.astype(np.dtype('float64'))\n        # Using float64 is necessary because otherwise rounding error\n        # in recursive formula accumulate\n        n = self._samples_collected\n        m = input_array.shape[TIME_AXIS]  # number of new samples\n        self._samples_collected += m\n\n        self._means = (\n            self._means * n + np.sum(input_array, axis=TIME_AXIS)) \/ (n + m)\n        self._mean_sums_of_squares = (\n            self._mean_sums_of_squares * n +\n            np.sum(input_array ** 2, axis=TIME_AXIS)) \/ (n + m)\n\n    def _calculate_standard_deviations(self):\n        n = self._samples_collected\n        return np.sqrt(\n            n \/ (n - 1) * (self._mean_sums_of_squares - self._means ** 2))\n\n    def _on_input_history_invalidation(self):\n        self._reset_statistics()\n\n    def _check_value(self, key, value):\n        pass\n\n\nclass InverseModel(ProcessorNode):\n    SUPPORTED_METHODS = ['MNE', 'dSPM', 'sLORETA']\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info', )\n    CHANGES_IN_THESE_REQUIRE_RESET = ('mne_inverse_model_file_path',\n                                      'mne_forward_model_file_path',\n                                      'snr', 'method')\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info': channel_labels_saver}\n\n    def __init__(self, forward_model_path=None, snr=1.0, method='MNE'):\n        super().__init__()\n\n        self.snr = snr\n        self._user_provided_forward_model_file_path = forward_model_path\n        self._default_forward_model_file_path = None\n        self.mne_info = None\n        self.fwd = None\n\n        self._inverse_model_matrix = None\n        self.method = method\n\n    def _initialize(self):\n        mne_info = self.traverse_back_and_find('mne_info')\n        self._bad_channels = mne_info['bads']\n\n        if self._user_provided_forward_model_file_path is None:\n            self._default_forward_model_file_path =\\\n                get_default_forward_file(mne_info)\n\n        self.fwd, missing_ch_names = get_clean_forward(\n            self.mne_forward_model_file_path, mne_info)\n        mne_info['bads'] = list(set(mne_info['bads'] + missing_ch_names))\n\n        inverse_operator = make_inverse_operator(self.fwd, mne_info)\n        self._inverse_model_matrix = matrix_from_inverse_operator(\n            inverse_operator=inverse_operator, mne_info=mne_info,\n            snr=self.snr, method=self.method)\n\n        frequency = mne_info['sfreq']\n        # channel_count = self._inverse_model_matrix.shape[0]\n        channel_count = self.fwd['nsource']\n        channel_labels = ['vertex #{}'.format(i + 1)\n                          for i in range(channel_count)]\n        self.mne_info = mne.create_info(channel_labels, frequency)\n\n    def _update(self):\n        mne_info = self.traverse_back_and_find('mne_info')\n        bads = mne_info['bads']\n        if bads != self._bad_channels:\n            inverse_operator = make_inverse_operator(self.fwd, mne_info)\n            self._inverse_model_matrix = matrix_from_inverse_operator(\n                inverse_operator=inverse_operator, mne_info=mne_info,\n                snr=self.snr, method=self.method)\n            self._bad_channels = bads\n\n        input_array = self.input_node.output\n        raw_array = mne.io.RawArray(input_array, mne_info, verbose='ERROR')\n        raw_array.pick_types(eeg=True, meg=False, stim=False, exclude='bads')\n        data = raw_array.get_data()\n        self.output = self._apply_inverse_model_matrix(data)\n\n    def _on_input_history_invalidation(self):\n        # The methods implemented in this node do not rely on past inputs\n        pass\n\n    def _check_value(self, key, value):\n        if key == 'method':\n            if value not in self.SUPPORTED_METHODS:\n                raise ValueError(\n                    'Method {} is not supported.'.format(value) +\n                    ' Use one of: {}'.format(self.SUPPORTED_METHODS))\n\n        if key == 'snr':\n            if value <= 0:\n                raise ValueError(\n                    'snr (signal-to-noise ratio) must be a positive number.')\n\n    def _reset(self):\n        self._should_reinitialize = True\n        self.initialize()\n        output_history_is_no_longer_valid = True\n        return output_history_is_no_longer_valid\n\n    @property\n    def mne_forward_model_file_path(self):\n        return self._user_provided_forward_model_file_path or\\\n                self._default_forward_model_file_path\n\n    @mne_forward_model_file_path.setter\n    def mne_forward_model_file_path(self, value):\n        # This setter is for public use, hence the \"user_provided\"\n        self._user_provided_forward_model_file_path = value\n\n    def _apply_inverse_model_matrix(self, input_array: np.ndarray):\n        W = self._inverse_model_matrix  # VERTICES x CHANNELS\n        output_array = W.dot(make_time_dimension_second(input_array))\n        return put_time_dimension_back_from_second(output_array)\n\n\nclass LinearFilter(ProcessorNode):\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info', )\n    CHANGES_IN_THESE_REQUIRE_RESET = ('lower_cutoff', 'upper_cutoff')\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info':\n                                           lambda info: (info['nchan'], )}\n\n    def __init__(self, lower_cutoff, upper_cutoff):\n        super().__init__()\n        self.lower_cutoff = lower_cutoff\n        self.upper_cutoff = upper_cutoff\n        self._linear_filter = None  # type: filters.ButterFilter\n\n    def _initialize(self):\n        mne_info = self.traverse_back_and_find('mne_info')\n        frequency = mne_info['sfreq']\n        channel_count = mne_info['nchan']\n        if not (self.lower_cutoff is None and self.upper_cutoff is None):\n            band = (self.lower_cutoff, self.upper_cutoff)\n\n            self._linear_filter = filters.ButterFilter(\n                band, fs=frequency, n_channels=channel_count)\n\n            self._linear_filter.apply = pynfb_ndarray_function_wrapper(\n                self._linear_filter.apply)\n        else:\n            self._linear_filter = None\n\n    def _update(self):\n        input = self.input_node.output\n        if self._linear_filter is not None:\n            self.output = self._linear_filter.apply(input)\n        else:\n            self.output = input\n\n    def _check_value(self, key, value):\n        if value is None:\n            pass\n\n        elif key == 'lower_cutoff':\n            if (hasattr(self, 'upper_cutoff') and\n                    self.upper_cutoff is not None and\n                    value > self.upper_cutoff):\n                raise ValueError(\n                    'Lower cutoff can`t be set higher that the upper cutoff')\n            if value < 0:\n                raise ValueError('Lower cutoff must be a positive number')\n\n        elif key == 'upper_cutoff':\n            if (hasattr(self, 'upper_cutoff') and\n                    self.lower_cutoff is not None and\n                    value < self.lower_cutoff):\n                raise ValueError(\n                    'Upper cutoff can`t be set lower that the lower cutoff')\n            if value < 0:\n                raise ValueError('Upper cutoff must be a positive number')\n\n    def _on_input_history_invalidation(self):\n        if self._linear_filter is not None:\n            self._linear_filter.reset()\n\n    def _reset(self):\n        self._should_reinitialize = True\n        self.initialize()\n        output_history_is_no_longer_valid = True\n        return output_history_is_no_longer_valid\n\n\nclass EnvelopeExtractor(ProcessorNode):\n    def __init__(self, factor=0.9):\n        super().__init__()\n        self.method = 'Exponential smoothing'\n        self.factor = factor\n        self._envelope_extractor = None  # type: ExponentialMatrixSmoother\n\n    def _initialize(self):\n        channel_count = self.traverse_back_and_find('mne_info')['nchan']\n        self._envelope_extractor = ExponentialMatrixSmoother(\n            factor=self.factor, column_count=channel_count)\n        self._envelope_extractor.apply = pynfb_ndarray_function_wrapper(\n            self._envelope_extractor.apply)\n\n    def _update(self):\n        input = self.input_node.output\n        self.output = self._envelope_extractor.apply(np.abs(input))\n\n    def _check_value(self, key, value):\n        if key == 'factor':\n            if value <= 0 or value >= 1:\n                raise ValueError('Factor must be a number between 0 and 1')\n\n        if key == 'method':\n            if value not in self.SUPPORTED_METHODS:\n                raise ValueError(\n                    'Method {} is not supported.' +\n                    ' Use one of: {}'.format(value, self.SUPPORTED_METHODS))\n\n    def _reset(self):\n        self._should_reinitialize = True\n        self.initialize()\n        output_history_is_no_longer_valid = True\n        return output_history_is_no_longer_valid\n\n    def _on_input_history_invalidation(self):\n        self._envelope_extractor.reset()\n\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info', )\n    CHANGES_IN_THESE_REQUIRE_RESET = ('method', 'factor')\n    SUPPORTED_METHODS = ('Exponential smoothing', )\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info':\n                                           lambda info: (info['nchan'],)}\n\n\nclass Beamformer(ProcessorNode):\n\n    SUPPORTED_OUTPUT_TYPES = ('power', 'activation')\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info',)\n    CHANGES_IN_THESE_REQUIRE_RESET = ('snr', 'output_type', 'is_adaptive',\n                                      'fixed_orientation',\n                                      'mne_forward_model_file_path')\n\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info': channel_labels_saver}\n\n    def __init__(self, snr: float=1.0, output_type: str='power',\n                 is_adaptive: bool=False, fixed_orientation: bool=True,\n                 forward_model_path: str=None,\n                 forgetting_factor_per_second: float=0.99):\n        super().__init__()\n\n        self.snr = snr  # type: float\n        self._user_provided_forward_model_file_path = forward_model_path\n        self._default_forward_model_file_path = None  # type: str\n        self.mne_info = None  # type: mne.Info\n\n        self.output_type = output_type  # type: np.dtype\n        self.is_adaptive = is_adaptive  # type: bool\n        self._initialized_as_adaptive = None  # type: bool\n        self.fixed_orientation = fixed_orientation  # type: bool\n        self._initialized_as_fixed = None  # type: bool\n\n        self._channel_indices = None  # type: list\n        self._gain_matrix = None  # type: np.ndarray\n        self._Rxx = None  # type: np.ndarray\n        self.forgetting_factor_per_second = forgetting_factor_per_second\n        self._forgetting_factor_per_sample = None  # type: float\n\n    def _initialize(self):\n        mne_info = self.traverse_back_and_find('mne_info')\n\n        if self._user_provided_forward_model_file_path is None:\n            self._default_forward_model_file_path = get_default_forward_file(\n                    mne_info)\n\n        try:\n            fwd, missing_ch_names = get_clean_forward(\n                self.mne_forward_model_file_path, mne_info)\n        except ValueError:\n            raise Exception('BAD FORWARD + DATA COMBINATION!')\n\n        mne_info['bads'] = list(set(mne_info['bads'] + missing_ch_names))\n        self._gain_matrix = fwd['sol']['data']\n        G = self._gain_matrix\n        if self.is_adaptive is False:\n            Rxx = G.dot(G.T)\n        elif self.is_adaptive is True:\n            Rxx = np.zeros([G.shape[0], G.shape[0]])  # G.dot(G.T)\n\n        goods = mne.pick_types(mne_info, eeg=True, meg=False, exclude='bads')\n        ch_names = [mne_info['ch_names'][i] for i in goods]\n\n        self._Rxx = mne.Covariance(Rxx, ch_names, mne_info['bads'],\n                                   mne_info['projs'], nfree=1)\n\n        self._mne_info = mne_info\n\n        frequency = mne_info['sfreq']\n        self._forgetting_factor_per_sample = np.power(\n                self.forgetting_factor_per_second, 1 \/ frequency)\n\n        n_vert = fwd['nsource']\n        channel_labels = ['vertex #{}'.format(i + 1) for i in range(n_vert)]\n        self.mne_info = mne.create_info(channel_labels, frequency)\n        self._initialized_as_adaptive = self.is_adaptive\n        self._initialized_as_fixed = self.fixed_orientation\n\n        self.fwd_surf = mne.convert_forward_solution(\n                    fwd, surf_ori=True, force_fixed=False)\n        if not self.is_adaptive:\n            self._filters = make_lcmv(\n                    info=self._mne_info, forward=self.fwd_surf,\n                    data_cov=self._Rxx, reg=0.05, pick_ori='max-power',\n                    weight_norm='unit-noise-gain', reduce_rank=False)\n        else:\n            self._filters = None\n\n    def _update(self):\n        t1 = time.time()\n        input_array = self.input_node.output\n        raw_array = mne.io.RawArray(\n            input_array, self._mne_info, verbose='ERROR')\n\n        raw_array.pick_types(eeg=True, meg=False, stim=False, exclude='bads')\n        raw_array.set_eeg_reference(ref_channels='average', projection=True)\n        t2 = time.time()\n        self.logger.debug('Prepare arrays in {:.1f} ms'.format(\n                    (t2 - t1) * 1000))\n\n        if self.is_adaptive:\n            self._update_covariance_matrix(input_array)\n            t1 = time.time()\n            self._filters = make_lcmv(info=self._mne_info,\n                                      forward=self.fwd_surf,\n                                      data_cov=self._Rxx, reg=0.5,\n                                      pick_ori='max-power',\n                                      weight_norm='unit-noise-gain',\n                                      reduce_rank=False)\n            t2 = time.time()\n            self.logger.debug('Assembled lcmv instance in {:.1f} ms'.format(\n                        (t2 - t1) * 1000))\n\n        self._filters['source_nn'] = []\n        t1 = time.time()\n        stc = apply_lcmv_raw(raw=raw_array, filters=self._filters,\n                             max_ori_out='signed')\n        t2 = time.time()\n        self.logger.debug('Applied lcmv inverse in {:.1f} ms'.format(\n                    (t2 - t1) * 1000))\n\n        output = stc.data\n        t1 = time.time()\n        if self.fixed_orientation is True:\n            if self.output_type == 'power':\n                output = output ** 2\n        else:\n            vertex_count = self.fwd_surf['nsource']\n            output = np.sum(\n                np.power(output, 2).reshape((vertex_count, 3, -1)), axis=1)\n            if self.output_type == 'activation':\n                output = np.sqrt(output)\n\n        self.output = output\n        t2 = time.time()\n        self.logger.debug(\n                'Finalized in {:.1f} ms'.format(\n                    (t2 - t1) * 1000))\n\n    @property\n    def mne_forward_model_file_path(self):\n        # TODO: fix this\n        return (self._user_provided_forward_model_file_path or\n                self._default_forward_model_file_path)\n\n    @mne_forward_model_file_path.setter\n    def mne_forward_model_file_path(self, value):\n        # This setter is for public use, hence the \"user_provided\"\n        self._user_provided_forward_model_file_path = value\n\n    def _reset(self) -> bool:\n\n        # Only change adaptiveness or fixed_orientation requires reinit\n        # if (self._initialized_as_adaptive is not self.is_adaptive\n        #         or self._initialized_as_fixed is not self.fixed_orientation):\n        self._should_reinitialize = True\n        self.initialize()\n\n        output_history_is_no_longer_valid = True\n        return output_history_is_no_longer_valid\n\n    def _on_input_history_invalidation(self):\n        # Only adaptive version relies on history\n        if self._initialized_as_adaptive is True:\n            self._should_reinitialize = True\n            self.initialize()\n\n    def _check_value(self, key, value):\n        if key == 'output_type':\n            if value not in self.SUPPORTED_OUTPUT_TYPES:\n                raise ValueError(\n                    'Method {} is not supported.' +\n                    ' Use one of: {}'.format(\n                        value, self.SUPPORTED_OUTPUT_TYPES))\n\n        if key == 'snr':\n            if value <= 0:\n                raise ValueError(\n                    'snr (signal-to-noise ratio) must be a positive number')\n\n        if key == 'is_adaptive':\n            if not isinstance(value, bool):\n                raise ValueError(\n                    'Beamformer type (adaptive vs nonadaptive) is not set')\n\n    def _update_covariance_matrix(self, input_array):\n        t1 = time.time()\n        alpha = self._forgetting_factor_per_sample\n        sample_count = input_array.shape[TIME_AXIS]\n        self.logger.debug('Number of samples: {}'.format(sample_count))\n        new_Rxx_data = self._Rxx.data\n\n        raw_array = mne.io.RawArray(\n            input_array, self._mne_info, verbose='ERROR')\n        raw_array.pick_types(eeg=True, meg=False, stim=False, exclude='bads')\n        raw_array.set_eeg_reference(ref_channels='average', projection=True)\n        input_array_nobads = raw_array.get_data()\n\n        t2 = time.time()\n        self.logger.debug(\n            'Prepared covariance update in {:.2f} ms'.format((t2 - t1) * 1000))\n        samples = make_time_dimension_second(input_array_nobads).T\n        new_Rxx_data = (alpha * new_Rxx_data +\n                        (1 - alpha) * samples.T.dot(samples))\n        t3 = time.time()\n        self.logger.debug(\n            'Updated matrix data in {:.2f} ms'.format((t3 - t2) * 1000))\n\n        self._Rxx = mne.Covariance(new_Rxx_data, self._Rxx.ch_names,\n                                   raw_array.info['bads'],\n                                   raw_array.info['projs'], nfree=1)\n        t4 = time.time()\n        self.logger.debug('Created instance of covariance' +\n                          ' in {:.2f} ms'.format((t4 - t4) * 1000))\n\n\n# TODO: implement this function\ndef pynfb_filter_based_processor_class(pynfb_filter_class):\n    \"\"\"\n    Returns a ProcessorNode subclass with the functionality of\n    pynfb_filter_class\n\n    pynfb_filter_class: subclass of pynfb.signal_processing.filters.BaseFilter\n\n    Sample usage 1:\n\n    LinearFilter = pynfb_filter_based_processor_class(filters.ButterFilter)\n    linear_filter = LinearFilter(band, fs, n_channels, order)\n\n    Sample usage 2\n    (this would correspond to a different implementation of this function):\n\n    LinearFilter = pynfb_filter_based_processor_class(filters.ButterFilter)\n    linear_filter = LinearFilter(band, order)\n\n    In this case LinearFilter should provide\n    fs and n_channels parameters to filters.ButterFilter automatically\n\n    \"\"\"\n    class PynfbFilterBasedProcessorClass(ProcessorNode):\n        def _on_input_history_invalidation(self):\n            pass\n\n        def _check_value(self, key, value):\n            pass\n\n        @property\n        def CHANGES_IN_THESE_REQUIRE_RESET(self) -> Tuple[str]:\n            pass\n\n        @property\n        def UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION(self) -> Tuple[str]:\n            pass\n\n        def _reset(self):\n            pass\n\n        def __init__(self):\n            pass\n\n        def _initialize(self):\n            pass\n\n        def _update(self):\n            pass\n    return PynfbFilterBasedProcessorClass\n\n\nclass MCE(ProcessorNode):\n    input = []\n    output = []\n\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ()\n    CHANGES_IN_THESE_REQUIRE_RESET = ('mne_forward_model_file_path', 'snr')\n\n    def __init__(self, snr=1.0, forward_model_path=None, n_comp=40):\n        super().__init__()\n        self.snr = snr\n        self.mne_forward_model_file_path = forward_model_path\n        self.n_comp = n_comp\n        self.mne_info = None\n        # pass\n\n    def _initialize(self):\n        print('INITIALIZING MCE NODE ...')\n        mne_info = self.traverse_back_and_find('mne_info')\n        # mne_info['custom_ref_applied'] = True\n        # -------- truncated svd for fwd_opr operator -------- #\n        fwd, missing_ch_names = get_clean_forward(\n            self.mne_forward_model_file_path, mne_info)\n        mne_info['bads'] = list(set(mne_info['bads'] + missing_ch_names))\n        fwd_fix = mne.convert_forward_solution(\n                fwd, surf_ori=True, force_fixed=False)\n\n        self._gain_matrix = fwd_fix['sol']['data']\n\n        print('MCE: COMPUTING SVD OF THE FORWARD OPERATOR')\n        U, S, V = svd(self._gain_matrix)\n\n        Sn = np.zeros([self.n_comp, V.shape[0]])\n        Sn[:self.n_comp, :self.n_comp] = np.diag(S[:self.n_comp])\n\n        self.Un = U[:, :self.n_comp]\n        self.A_non_ori = Sn @ V\n        # ---------------------------------------------------- #\n\n        # -------- leadfield dims -------- #\n        N_SEN = self._gain_matrix.shape[0]\n        # -------------------------------- #\n\n        # ------------------------ noise-covariance ------------------------ #\n        cov_data = np.identity(N_SEN)\n        ch_names = np.array(mne_info['ch_names'])[mne.pick_types(mne_info,\n                                                                 eeg=True,\n                                                                 meg=False)]\n        ch_names = list(ch_names)\n        noise_cov = mne.Covariance(\n                cov_data, ch_names, mne_info['bads'],\n                mne_info['projs'], nfree=1)\n        # ------------------------------------------------------------------ #\n\n        self.mne_inv = mne_make_inverse_operator(\n                mne_info, fwd_fix, noise_cov, depth=0.8,\n                loose=1, fixed=False, verbose='ERROR')\n        self.mne_info = mne_info\n        self.Sn = Sn\n        self.V = V\n\n    def _update(self):\n        input_array = self.input_node.output\n        last_slice = last_sample(input_array)\n        n_src = self.mne_inv['nsource']\n        n_times = input_array.shape[1]\n        output_mce = np.empty([n_src, n_times])\n\n        raw_slice = mne.io.RawArray(np.expand_dims(last_slice, axis=1),\n                                    self.mne_info, verbose='ERROR')\n        raw_slice.pick_types(eeg=True, meg=False, stim=False, exclude='bads')\n        raw_slice.set_eeg_reference(ref_channels='average', projection=True)\n\n        # ------------------- get dipole orientations --------------------- #\n        stc_slice = apply_inverse_raw(raw_slice, self.mne_inv,\n                                      pick_ori='vector',\n                                      method='MNE', lambda2=1, verbose='ERROR')\n        Q = normalize(stc_slice.data[:, :, 0])  # dipole orientations\n        # ----------------------------------------------------------------- #\n\n        # -------- setup linprog params -------- #\n        n_sen = self.A_non_ori.shape[0]\n        A_eq = np.empty([n_sen, n_src])\n        for i in range(n_src):\n            A_eq[:, i] = self.A_non_ori[:, i * 3: (i + 1) * 3] @ Q[i, :].T\n        data_slice = raw_slice.get_data()[:, 0]\n        b_eq = self.Un.T @ data_slice\n        c = np.ones(A_eq.shape[1])\n        # -------------------------------------- #\n\n        with nostdout():\n            sol = linprog(c, A_eq=A_eq, b_eq=b_eq,\n                          method='interior-point', bounds=(0, None),\n                          options={'disp': False})\n        output_mce[:, :] = sol.x[:, np.newaxis]\n\n        self.output = output_mce\n        self.sol = sol\n        return Q, A_eq, data_slice, b_eq, c\n\n    def _on_input_history_invalidation(self):\n        # The methods implemented in this node do not rely on past inputs\n        pass\n\n    def _reset(self):\n        self._should_reinitialize = True\n        self.initialize()\n        output_history_is_no_longer_valid = True\n        return output_history_is_no_longer_valid\n\n    def _check_value(self, key, value):\n        if key == 'snr':\n            if value <= 0:\n                raise ValueError(\n                    'snr (signal-to-noise ratio) must be a positive number.')\n\n\nclass ICARejection(ProcessorNode):\n\n    def __init__(self, collect_for_x_seconds: int=60):\n        super().__init__()\n        self.collect_for_x_seconds = collect_for_x_seconds  # type: int\n\n        self._samples_collected = None  # type: int\n        self._samples_to_be_collected = None  # type: int\n        self._enough_collected = None  # type: bool\n\n        self._reset_statistics()\n        self._ica_rejector = None\n\n    def _on_input_history_invalidation(self):\n        self._reset_statistics()\n\n    def _check_value(self, key, value):\n        pass\n\n    CHANGES_IN_THESE_REQUIRE_RESET = ('collect_for_x_seconds', )\n\n    def _initialize(self):\n        self._mne_info = self.traverse_back_and_find('mne_info')\n        self._frequency = self._mne_info['sfreq']\n        self._good_ch_inds = mne.pick_types(self._mne_info, eeg=True,\n                                            meg=False, stim=False,\n                                            exclude='bads')\n\n        channels = self._mne_info['chs']\n        self._ch_locs = np.array([ch['loc'] for ch in channels])\n\n        n_ch = len(self._good_ch_inds)\n        self._samples_to_be_collected = int(math.ceil(\n            self.collect_for_x_seconds * self._frequency))\n        self._collected_timeseries = np.zeros(\n                [n_ch, self._samples_to_be_collected])\n        self._linear_filter = filters.ButterFilter(\n                [1, 200], fs=self._frequency,\n                n_channels=len(self._good_ch_inds))\n        self._linear_filter.apply = pynfb_ndarray_function_wrapper(\n                self._linear_filter.apply)\n\n    def _reset(self) -> bool:\n        self._reset_statistics()\n        self._input_history_is_no_longer_valid = True\n        return self._input_history_is_no_longer_valid\n\n    def _reset_statistics(self):\n        self._samples_collected = 0\n        self._enough_collected = False\n\n    def _update(self):\n        # Have we collected enough samples without the new input?\n        self.output = self.input_node.output\n\n        enough_collected = self._samples_collected >=\\\n            self._samples_to_be_collected\n        if not enough_collected:\n            if self.input_node.output is not None and\\\n                    self.input_node.output.shape[TIME_AXIS] > 0:\n                self._update_statistics()\n\n        elif not self._enough_collected:  # We just got enough samples\n            self._enough_collected = True\n            print('COLLECTED ENOUGH SAMPLES')\n            ica = ICADialog(\n                self._collected_timeseries.T,\n                list(np.array(self._mne_info['ch_names'])[self._good_ch_inds]),\n                self._ch_locs[self._good_ch_inds, :], self._frequency)\n\n            ica.exec_()\n            self._ica_rejector = ica.rejection.val.T\n        else:\n            self.output[self._good_ch_inds, :] = np.dot(\n                    self._ica_rejector,\n                    self.input_node.output[self._good_ch_inds, :])\n\n    def _update_statistics(self):\n        input_array = self.input_node.output.astype(np.dtype('float64'))\n        n = self._samples_collected\n        m = input_array.shape[TIME_AXIS]  # number of new samples\n        self._samples_collected += m\n        self._collected_timeseries[:, n:n + m] = self._linear_filter.apply(\n                input_array[self._good_ch_inds, :])\n        # Using float64 is necessary because otherwise rounding error\n        # in recursive formula accumulate\n        pass\n\n    UPSTREAM_CHANGES_IN_THESE_REQUIRE_REINITIALIZATION = ('mne_info', )\n    SAVERS_FOR_UPSTREAM_MUTABLE_OBJECTS = {'mne_info': channel_labels_saver}\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_86","text":"import numpy as np\nfrom scipy import optimize\nimport matplotlib.pyplot as plt\n\nclass Neural_Network(object):\n    def __init__(self):\n        # Define Hyperparameters\n        # self.inputLayerSize = 2\n        # self.outputLayerSize = 1\n        # self.hiddenLayerSize = 3\n        self.inputLayerSize = 784\n        self.outputLayerSize = 1\n        self.hiddenLayerSize = 100000\n\n        # Weights (parameters)\n        self.W1 = np.random.randn(self.inputLayerSize, self.hiddenLayerSize)\n        self.W2 = np.random.randn(self.hiddenLayerSize, self.outputLayerSize)\n\n    def forward(self, X):\n        # Propogate inputs though network\n        self.z2 = np.dot(X, self.W1)\n        self.a2 = self.sigmoid(self.z2)\n        self.z3 = np.dot(self.a2, self.W2)\n        yHat = self.sigmoid(self.z3)\n        return yHat\n\n    def sigmoid(self, z):\n        # Apply sigmoid activation function to scalar, vector, or matrix\n        return 1 \/ (1 + np.exp(-z))\n\n    def sigmoidPrime(self, z):\n        # Gradient of sigmoid\n        return np.exp(-z) \/ ((1 + np.exp(-z)) ** 2)\n\n    def costFunction(self, X, y):\n        # Compute cost for given X,y, use weights already stored in class.\n        self.yHat = self.forward(X)\n        J = 0.5 * sum((y - self.yHat) ** 2)\n        return J\n\n    def costFunctionPrime(self, X, y):\n        # Compute derivative with respect to W and W2 for a given X and y:\n        self.yHat = self.forward(X)\n\n        delta3 = np.multiply(-(y - self.yHat), self.sigmoidPrime(self.z3))\n        dJdW2 = np.dot(self.a2.T, delta3)\n\n        delta2 = np.dot(delta3, self.W2.T) * self.sigmoidPrime(self.z2)\n        dJdW1 = np.dot(X.T, delta2)\n\n        return dJdW1, dJdW2\n\n    # Helper Functions for interacting with other classes:\n    def getParams(self):\n        # Get W1 and W2 unrolled into vector:\n        params = np.concatenate((self.W1.ravel(), self.W2.ravel()))\n        return params\n\n    def setParams(self, params):\n        # Set W1 and W2 using single paramater vector.\n        W1_start = 0\n        W1_end = self.hiddenLayerSize * self.inputLayerSize\n        self.W1 = np.reshape(params[W1_start:W1_end], (self.inputLayerSize, self.hiddenLayerSize))\n        W2_end = W1_end + self.hiddenLayerSize * self.outputLayerSize\n        self.W2 = np.reshape(params[W1_end:W2_end], (self.hiddenLayerSize, self.outputLayerSize))\n\n    def computeGradients(self, X, y):\n        dJdW1, dJdW2 = self.costFunctionPrime(X, y)\n        return np.concatenate((dJdW1.ravel(), dJdW2.ravel()))\n\nclass trainer(object):\n    def __init__(self, N):\n        # Make Local reference to network:\n        self.N = N\n\n    def callbackF(self, params):\n        self.N.setParams(params)\n        self.J.append(self.N.costFunction(self.X, self.y))\n\n    def costFunctionWrapper(self, params, X, y):\n        self.N.setParams(params)\n        cost = self.N.costFunction(X, y)\n        grad = self.N.computeGradients(X, y)\n\n        return cost, grad\n\n    def train(self, X, y):\n        # Make an internal variable for the callback function:\n        self.X = X\n        self.y = y\n\n        # Make empty list to store costs:\n        self.J = []\n\n        params0 = self.N.getParams()\n\n        options = {'maxiter': 200, 'disp': False}\n        _res = optimize.minimize(self.costFunctionWrapper, params0, jac=True, method='L-BFGS-B', \\\n                                 args=(X, y), options=options, callback=self.callbackF)\n\n        self.N.setParams(_res.x)\n        self.optimizationResults = _res\n\nimport  mnist\nif __name__ == '__main__':\n    x_train, t_train, x_test, t_test = mnist.load()\n    print(x_train.shape)\n    print(t_train.shape)\n    print(x_test.shape)\n    print(t_test.shape)\n    # # X = (hours sleeping, hours studying), y = Score on test\n    # X = np.array(([3, 5], [5, 1], [10, 2]), dtype=float)\n    # y = np.array(([75], [82], [93]), dtype=float)\n    # # Normalize\n    # X = X \/ np.amax(X, axis=0)\n    # y = y \/ 100  # Max test score is 100\n\n    train_number=100\n    X =x_train[0:train_number,:]\n    y=t_train[0:train_number]\n    y=y.reshape((len(y),1))\n\n    NN = Neural_Network()\n\n    print('y is ',y[0:10])\n    yHat=NN.forward(X)\n    print('yHat before train ',yHat[0:10])\n\n    T = trainer(NN)\n    T.train(X, y)\n    yHat = np.round(NN.forward(X))\n    print('yHat after is ',yHat[0:10])\n\n    # # plt.plot(T.J)\n    # # plt.grid(1)\n    # # plt.xlabel('Iterations')\n    # # plt.ylabel('Cost')\n    # # plt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_87","text":"\"\"\"Miscellaneous stuff that doesn't really fit anywhere else.\"\"\"\n\nfrom textwrap import fill, dedent\n\n# if you use\n# filldedent('''\n#             the text''')\n# a space will be put before the first line because dedent will\n# put a \\n as the first line and fill replaces \\n with spaces\n# so we strip off any leading and trailing \\n since printed wrapped\n# text should not have leading or trailing spaces.\nfilldedent = lambda s: '\\n' + fill(dedent(s).strip('\\n'))\n\ndef default_sort_key(item, order=None):\n    \"\"\"\n    A default sort key for lists of SymPy objects to pass to functions like sorted().\n\n    This uses the default ordering. If you want a nonstandard ordering, you will\n    have to create your own sort key using the sort_key() method of the object.\n\n    Examples\n    ========\n\n    >>> from sympy import Basic, S, I, default_sort_key\n    >>> from sympy.abc import x\n\n    >>> sorted([S(1)\/2, I, -I], key=default_sort_key)\n    [1\/2, -I, I]\n    >>> a = [S(1)\/2, I, -I]\n    >>> a.sort(key=default_sort_key)\n    >>> a\n    [1\/2, -I, I]\n\n    >>> b = S(\"[x, 1\/x, 1\/x**2, x**2, x**(1\/2), x**(1\/4), x**(3\/2)]\")\n    >>> b.sort(key=default_sort_key)\n\n    The built-in functions min() and max() also take a key function (in Python\n    2.5 or higher), that this can be used for.\n    \"\"\"\n\n    #XXX: The following should also be in the docstring, but orders do not\n    # actually work at the moment.\n\n    # To use a nonstandard order, you must create your own sort key.  The default\n    # order is lex.\n\n    # >>> from sympy import sympify\n    # >>> mykey = lambda item: sympify(item).sort_key(order='rev-lex')\n    # >>> sorted([x, x**2, 1], key=default_sort_key)\n    # [x**2, x, 1]\n    # >>> sorted([x, x**2, 1], key=mykey)\n    # [1, x, x**2]\n\n    from sympy.core import S, Basic\n    from sympy.core.sympify import sympify, SympifyError\n    from sympy.core.compatibility import iterable\n\n    if isinstance(item, Basic):\n        return item.sort_key(order=order)\n\n    if iterable(item, exclude=basestring):\n        if isinstance(item, dict):\n            args = item.items()\n        else:\n            args = list(item)\n\n        args = [default_sort_key(arg, order=order) for arg in args]\n\n        if isinstance(item, dict):\n            args = sorted(args)\n\n        cls_index, args = 10, (len(args), tuple(args))\n    else:\n        if not isinstance(item, basestring):\n            try:\n                item = sympify(item)\n            except SympifyError:\n                pass\n\n        if isinstance(item, Basic):\n            return item.sort_key(order=order)\n\n        cls_index, args = 0, (1, (str(item),))\n\n    return (cls_index, 0, item.__class__.__name__), args, S.One.sort_key(), S.One\n\nimport sys\nsize = getattr(sys, \"maxint\", None)\nif size is None: #Python 3 doesn't have maxint\n    size = sys.maxsize\nif size > 2**32:\n    ARCH = \"64-bit\"\nelse:\n    ARCH = \"32-bit\"\n\ndef debug(*args):\n    \"\"\"\n    Print ``*args`` if SYMPY_DEBUG is True, else do nothing.\n    \"\"\"\n    from sympy import SYMPY_DEBUG\n    if SYMPY_DEBUG:\n        for a in args:\n            print a,\n        print\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_88","text":"import numpy as np\nimport pylab as pl\nimport matplotlib.pyplot as plt\n\nfrom matplotlib.ticker import AutoMinorLocator\nfrom matplotlib.ticker import MultipleLocator\n\nfrom scipy import interpolate\n\nimport importlib\nimport sys\nimport os\n\nimport paths;  importlib.reload(paths)\nimport pltaux; importlib.reload(pltaux)\nimport sysaux; importlib.reload(sysaux)\n\nmu = ['1.00', '0.90', '0.80', '0.70', '0.60', '0.50', '0.40', '0.30', '0.20', '0.10', '0.05']\n\nidxs_mu = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n\nip = np.zeros(len(mu))\n\nfor i in range(len(mu)): ip[i] = np.sqrt(1.0 - float(mu[i])**2.0)\n\nclv_n = np.loadtxt(paths.it0f + 'murmean_r_atl_abd\/CLV_RAD')\nclv_a = np.loadtxt(paths.out  + 'atl_clv_86.dat')\n\nwvl_n = clv_n[:, 0] * 1e4 \/ 1e8\nwvl_a = clv_a[:, 0] * 1e4 \/ 1e7; wvl = wvl_a\n\nidx_n = np.where((wvl > min(wvl_n)) & (wvl < max(wvl_n)))\n\nwvl = wvl[idx_n]\n\n#sysaux.clean_dir(paths.figdir)\n\npltaux.figpar(fontsize = 20)\n\nfig, ax = plt.subplots(nrows = 1, ncols = 1, figsize = (12, 10))\n\nfig.tight_layout()\n\np = str(ip[0])[0 : 6]\n\nits_a = clv_a[idx_n[0], 1]\n\nits_n = interpolate.interp1d(wvl_n, clv_n[:, 1])(wvl)\n\nax.plot(wvl, its_n \/ its_a, color = 'k', label = '$\\mu =$ ' + mu[0] + ', $p =$ ' + p + '000')\n\nfor idx_mu in idxs_mu:\n\n    if idx_mu != 1:\n\n        p = str(ip[idx_mu - 1])[0 : 6]\n\n        if len(p) == 3: p = p + '000'\n\n        its_a = clv_a[idx_n[0], idx_mu]\n\n        its_n = interpolate.interp1d(wvl_n, clv_n[:, idx_mu])(wvl)\n\n        ax.plot(wvl, its_n \/ its_a, label = '$\\mu =$ ' + mu[idx_mu - 1] + ', $p =$ ' + p)\n\nax.xaxis.set_major_locator(MultipleLocator(10))\nax.yaxis.set_major_locator(MultipleLocator(0.002))\n\nax.set_xlabel('Wavelength, [$\\mu$m]')\nax.set_ylabel('NESSY \/ ATLAS')\n\nax.grid(True)\n\nax.set_xlim(7, 160)\n#ax.set_ylim(1.002, 1.022)\nax.set_ylim(0.998, 1.020)\n\nleg = ax.legend(frameon = True, framealpha = 1, loc = 2, prop={'size': 15})\n\nfor handle in leg.legendHandles: handle.set_linewidth(3.0)\n\npltaux.savepdf('nesatl_rad')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_89","text":"<reponame>ariolwork\/uni_conditional_gradient\nfrom scipy.optimize import linprog\nimport math\n# от рукинаписанные нужные части numpy\nfrom my_numpy import np, my_list\neps = 0.00001\n\n\n# class that contain function, it's derivative and spetial combination for optimization\nclass Func:\n    def __init__(self, func, func_der):\n        self.f = func # function J(u)\n        self.fder = func_der # function derivate J'(u)\n        \n    def J_k(self, u_k, u):\n        return sum(self.fder(u_k) * (u - u_k)) #function J_k(u)\n        \n# class that contain some type frames for optimisation and minimization method for this type of frames and linear function\nclass Frames:\n    #-----------------------------------------------\n    #type 0: frames like a_i <= u_i <= b_i\n    def __set_frames0(self, a, b):\n        self.a = a\n        self.b = b\n    #type 1: frame for symplex method\n    def __set_frames1(self, A, b):\n        self.A = A\n        self.b = b\n        \n    __setframesfuncs = {\n        0: __set_frames0,\n        1: __set_frames1\n    }\n    #-----------------------------------------------\n    def __set_size0(self):\n        if len(self.a) == len(self.b):\n            return len(self.a)\n        else:\n            return -1\n    def __set_size1(self):\n        if len(self.A) == len(self.b):\n            return len(self.b)\n        else:\n            return -1\n        \n    __setSize = {\n        0: __set_size0,\n        1: __set_size1\n    }\n    #------------------------------------------------\n    def __init__(self, type_of_conditions, minimize_func):\n        self.type = type_of_conditions\n        self.minimize = minimize_func\n        self.setframes = self.__setframesfuncs.get(type_of_conditions)\n        self.size = self.__setSize.get(type_of_conditions)\n        \n    def get_size(self):\n        return self.size(self)    \n\n# class of task contains function, frames and some help functions and parameters\nclass Job:\n    def __init__(self, func, frames, u_0, alpha):\n        self.f = func\n        self.frames = frames\n        self.u_0 = u_0  # start point\n        self.u_k = u_0 # the point got last time\n        self.__alpha = alpha # rule(function) for alpha calculation\n        self.k = 0 # step number\n     \n    # сheck task by\n    # compare dimension of function, derivative, frames and x \n    def check_errors(self):\n        a = type(self.f.f(self.u_0))\n        b = len(self.f.fder(self.u_0))\n        c = self.frames.get_size()\n        print(\"func:\",a,\"\\nframes:\",c,\"\\nder:\",b,\"\\nu_0:\", len(self.u_0), \"\\n\")\n    \n    # calculate new point using previus\n    def get_next_u(self, u1_k):\n        self.k+=1\n        return self.u_k + (u1_k - self.u_k)*self.__alpha(self, u1_k)\n    \n    # find abutting poin\n    def find_u1_k(self):\n        return self.frames.minimize(self.f, self.frames, self.u_k)\n\n\n# one variable function minimisation methods\nclass One_variable_function_minimisation_methods:    \n    #---------------------------------------------------\n    @staticmethod\n    def golden_ratio_method(func, a, b, eps=0.000001):\n        __MAGIC_CONSTANT_1 = (3 - math.sqrt(5))\/2\n        __MAGIC_CONSTANT_2 = (math.sqrt(5) - 1)\/2\n        while True:\n            if b-a < eps:\n                return (a+b)\/2\n            u1 = a + __MAGIC_CONSTANT_1*(b-a)\n            u2 = a + __MAGIC_CONSTANT_2*(b-a)\n            if func(u1)<=func(u2):\n                b = u2\n            else:\n                a = u1\n        return -1\n    #---------------------------------------------------\n    @staticmethod\n    def tangent_method(func, a, b, eps=0.000001):\n        while True:\n            if func.fder(a)>=0:\n                return a\n            if func.fder(b)<=0:\n                return b\n            if abs(a-b)<eps:\n                return (a+b)\/2\n            un = (func.f(a)-func.f(b)+b*func.fder(b)-a*func.fder(a))\/(func.fder(b)-func.fder(a))\n            if func.fder(un)<0:\n                a = un\n            else:\n                b = un\n\n\n#testng of one variable function minimisation methods\n#print(One_variable_function_minimisation_methods.bisection_method((lambda x: x*x*x-x*x), -5, 1))\n#print(One_variable_function_minimisation_methods.golden_ratio_method((lambda x: x*x*x-x*x), -5, 1))\n#print(One_variable_function_minimisation_methods.tangent_method(Func((lambda x: x*x), (lambda x: 2.0*x)), -1, 2))\n\n# alpha calculate rule 1\ndef alpha_1(J, u1_k):\n    return 1.0\/(J.k+1)\n\n# alpha calculate rule 2\ndef alpha_2(J, u1_k):\n    alpha = 1.0\n    while True:\n        u_k1 = J.u_k + alpha*(u1_k - J.u_k)\n        if J.f.f(u_k1) < J.f.f(J.u_k):\n            return alpha\n        if alpha < eps:\n            break\n        alpha\/=2.0\n    return 0.0\n\n# alpha calculate rule 3 (safety)\ndef alpha_3(J, u1_k):\n    def f_k(alpha):\n        return J.f.f(J.u_k+alpha*(u1_k-J.u_k))\n    def f_k_der(alpha):\n        return np.dot((u1_k-J.u_k),J.f.fder(J.u_k+alpha*(u1_k-J.u_k)))\n    return One_variable_function_minimisation_methods.tangent_method(Func(f_k, f_k_der), 0, 1)\n\n\n# minimazation function for spetial frames type (a<x<b)\ndef frames_minnimize_function(func, frames, u_k):\n    ans = []\n    der = func.fder(u_k)\n    for i in range(0, len(der)):\n        if der[i]>0:\n            ans.append(frames.a[i])\n        elif der[i]<0:\n            ans.append(frames.b[i])\n        else:\n            ans.append((frames.a[i]+frames.b[i])\/2)\n    return np.array(ans)\n\n# minimisation function(symplex method) for spetioal(linear) type of frames\ndef symplex_meyhod_minimize_function(func, frames, u_k):\n    return np.array(linprog(func.fder(u_k), frames.A, frames.b).x)\n    \n\n# method for different stop rules\ndef calculate_m(job, eps, steps):\n    def method_full(J, eps, steps):\n        f_sequ = []\n        u_k_sequ = []\n        k = 0\n        f_sequ.append(J.f.f(J.u_k))\n        u_k_sequ.append(J.u_k)\n        u_k = 0\n        while True:\n            u1_k = J.find_u1_k()\n            u_k = J.u_k\n            J.u_k = J.get_next_u(u1_k)\n            f_sequ.append(J.f.f(J.u_k))\n            u_k_sequ.append(J.u_k)\n            if k>steps or np.all(J.u_k == u_k) or abs(J.f.f(J.u_k) - J.f.f(u_k)) <= eps:\n                break\n            k+=1\n        return J.f.f(J.u_k), J.u_k, f_sequ, u_k_sequ, k, abs(J.f.f(J.u_k) - J.f.f(u_k))\n    def method_eps(J, eps):\n        f_sequ = []\n        u_k_sequ = []\n        k = 0\n        f_sequ.append(J.f.f(J.u_k))\n        u_k_sequ.append(J.u_k)\n        u_k = 0\n        while True:\n            u1_k = J.find_u1_k()\n            u_k = J.u_k\n            J.u_k = J.get_next_u(u1_k)\n            f_sequ.append(J.f.f(J.u_k))\n            u_k_sequ.append(J.u_k)\n            if k>100000000 or np.all(J.u_k == u_k) or abs(J.f.f(J.u_k) - J.f.f(u_k)) <= eps:\n                break\n            k+=1\n        return J.f.f(J.u_k), J.u_k, f_sequ, u_k_sequ, k, abs(J.f.f(J.u_k) - J.f.f(u_k))\n    def method_steps(J, steps):\n        f_sequ = []\n        u_k_sequ = []\n        k = 0\n        f_sequ.append(J.f.f(J.u_k))\n        u_k_sequ.append(J.u_k)\n        u_k = 0\n#       print(\"u_k:{}, f:{}\".format(J.u_k, J.f.f(J.u_k)))\n        while True:\n            u1_k = J.find_u1_k()\n            u_k = J.u_k\n            J.u_k = J.get_next_u(u1_k)\n #           print(\"u_k:{}, f:{}, u1_k:{}\".format(J.u_k, J.f.f(J.u_k), u1_k))\n            f_sequ.append(J.f.f(J.u_k))\n            u_k_sequ.append(J.u_k)\n            if k>steps or np.all(J.u_k == u_k):\n                break\n            k+=1\n        return J.f.f(J.u_k), J.u_k, f_sequ, u_k_sequ, k+1, abs(J.f.f(J.u_k) - J.f.f(u_k))\n\n    if steps == -1:\n        return method_eps(job, eps)\n    elif eps == -1:\n        return method_steps(job, steps)\n    return method_full(job, eps, steps)\n\n#calculate_m(job1, -1, 100)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_90","text":"<reponame>dangeng\/infiniteGANorama\nimport os.path\nfrom data.base_dataset import BaseDataset, get_transform\nfrom data.image_folder import make_dataset\nimport numpy as np\nfrom PIL import Image\nfrom scipy.misc import imresize\n\n\nclass FrankensteinDataset(BaseDataset):\n    @staticmethod\n    def modify_commandline_options(parser, is_train):\n        return parser\n\n    def initialize(self, opt):\n        self.opt = opt\n        self.root = opt.dataroot\n        self.dir_A = os.path.join(opt.dataroot)\n\n        self.A_paths = make_dataset(self.dir_A)\n\n        self.A_paths = sorted(self.A_paths)\n\n        self.transform = get_transform(opt)\n\n    def random_crop(self, im, size=500, resize=256):\n        h,w,_ = im.shape\n        h_start, w_start = np.random.randint(h-size), np.random.randint(w-size)\n        crop = im[h_start:h_start+size, w_start:w_start+size, :].copy()\n        if resize:\n            return imresize(crop, (resize, resize))\n        else:\n            return crop\n\n    def __getitem__(self, index):\n        idx_l = np.random.randint(len(self.A_paths))\n        idx_r = np.random.randint(len(self.A_paths))\n        A_path_l = self.A_paths[idx_l]\n        A_path_r = self.A_paths[idx_r]\n        A_img_l = Image.open(A_path_l).convert('RGB')\n        A_img_r = Image.open(A_path_r).convert('RGB')\n\n        A_l = np.array(A_img_l)\n        A_r = np.array(A_img_r)\n\n        #A_l, A_r = self.random_crop(A_l), self.random_crop(A_r) # CHANGE\n\n        h,w,c = A_l.shape\n\n        A_img = np.zeros_like(A_l)\n        A_img[:,:w\/\/2,:] = A_l[:,:w\/\/2,:]\n        A_img[:,w\/\/2:,:] = A_r[:,w\/\/2:,:]\n        A_img = Image.fromarray(A_img)\n\n        A = self.transform(A_img)\n        if self.opt.direction == 'BtoA':\n            input_nc = self.opt.output_nc\n        else:\n            input_nc = self.opt.input_nc\n\n        if input_nc == 1:  # RGB to gray\n            tmp = A[0, ...] * 0.299 + A[1, ...] * 0.587 + A[2, ...] * 0.114\n            A = tmp.unsqueeze(0)\n\n        return {'A': A, 'A_paths': '[{}]+[{}]]'.format(A_path_l, A_path_r)}\n\n    def __len__(self):\n        return len(self.A_paths)\n\n    def name(self):\n        return 'FrankensteinImageDataset'\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_91","text":"import vertica_python\nimport numpy as np\nimport scipy.stats as ss\nimport math\nfrom collections import Counter\n\n\ndef XHash(token, hash_size=128):\n    number_of_ones = 5\n    char = [' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',\n            'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n    segment_size_dict = {64: 1, 128: 3, 256: 6, 512: 13}\n    segment_size = segment_size_dict[hash_size]\n    length_bit_start = 37 * segment_size\n    result = 0\n    cnt_dict = Counter(token)\n    selected_chars = [y[0] for y in sorted(cnt_dict.items(), key=lambda x: (x[1], x[0]), reverse=False)[:number_of_ones]]\n    for c in selected_chars:\n        if c not in char:\n            continue\n        indices = [i for i, ltr in enumerate(token) if ltr == c]\n        mean_index = np.mean(indices)\n        token_size = len(token)\n        for i in np.arange(segment_size):\n            if mean_index <= ((i + 1) * token_size \/ segment_size):\n                location = char.index(c) * segment_size + i\n                break\n        result = result | int(math.pow(2, location))\n\n    # rotation\n    n = int(result)\n    d = int((length_bit_start * (len(token) % (hash_size - length_bit_start))) \/ (\n                hash_size - length_bit_start))\n    INT_BITS = int(length_bit_start)\n    x = n << d\n    y = n >> (INT_BITS - d)\n    r = int(math.pow(2, INT_BITS))\n    result = int((x | y) % r)\n\n    result = int(result) | int(math.pow(2, len(token) % (hash_size - length_bit_start)) * math.pow(2, length_bit_start))\n\n    return result\n\ndef generate_index(hash_size = 128):\n    conn_info = {'host': 'SERVER_IP_ADDRESS',\n                 'port': 5433,\n                 'user': 'USERNAME',\n                 'password': 'PASSWORD',\n                 'database': 'DATABASE_NAME',\n                 'session_label': 'some_label',\n                 'read_timeout': 6000,\n                 'unicode_error': 'strict',\n                 }\n\n    connection = vertica_python.connect(**conn_info)\n    cur = connection.cursor()\n    cur.execute('SELECT tableid, MAX(rowid) FROM main_tokenized GROUP BY tableid LIMIT 10;')\n\n    for row in cur.fetchall():\n        tableid = int(row[0])\n        rowid_max = int(row[1])\n        for rowid in np.arange(rowid_max):\n            cur.execute('SELECT tokenized FROM main_tokenized WHERE tableid = {} AND rowid = {};'.format(tableid, rowid))\n\n            row_tokens = cur.fetchall()\n            row_tokens = [item for sublist in row_tokens for item in sublist]\n\n            superkey = 0\n            for token in row_tokens:\n                superkey = superkey | XHash(str(token), hash_size)\n\n            cur.execute('UPDATE main_tokenized SET superkey = {} WHERE tableid = {} AND rowid = {}; COMMIT;'.format(superkey, tableid, rowid))\n\n\ngenerate_index()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_92","text":"<filename>vmf_embeddings\/evaluate.py<gh_stars>1-10\n# coding=utf-8\n# Copyright 2021 The vMF Embeddings Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Functions for performing fixed-set and open-set validation of a model.\"\"\"\n\nimport faiss\nimport numpy as np\nfrom scipy.stats import mode\nfrom sklearn.neighbors import KNeighborsClassifier\nimport torch\nimport torch.nn.functional as F\n\nfrom vmf_embeddings import utils\nfrom vmf_embeddings.third_party.hyperbolic_image_embeddings import hypnn\nfrom vmf_embeddings.third_party.s_vae_pytorch import distributions\n\n\ndef fixed_set_val_loop(arch, ds, method, cfg):\n  \"\"\"Performs fixed-set validation by computing accuracy.\n\n  Args:\n    arch: An archs.arch.Arch object (e.g., ResNet50 or N-digit MNIST arch).\n    ds: A datasets object (e.g., MNIST, CIFAR10).\n    method: A methods.methods softmax cross-entropy object (e.g., ArcFace).\n    cfg: The configuration dictionary from Hydra.\n\n  Returns:\n    Validation accuracy.\n  \"\"\"\n  method_name = method.__class__.__name__\n  arch.train(False)\n  ds.switch_split(\"valid\")\n  loader = utils.get_data_loader(\"sequential\", ds, cfg.num_workers,\n                                 {\"batch_size\": 128})\n  n_correct = 0\n  with torch.no_grad():\n    for batch in loader:\n      examples = batch[\"examples\"]\n      ids = batch[\"ids\"]\n      if torch.cuda.is_available():\n        examples = examples.cuda()\n        ids = ids.cuda()\n      # vMF has samples, so computing validation accuracy differs\n      if method_name == \"VMFSoftmax\":\n        preds, _ = method(\n            examples,\n            ids,\n            get_predictions=True,\n            n_samples=method.n_samples,\n        )\n        preds = torch.mean(F.softmax(preds, dim=2), dim=1)\n        preds = torch.argmax(preds, dim=1)\n        n_correct += torch.sum((preds == ids).int()).item()\n      # Compute n_correct for deterministic methods\n      else:\n        preds, _ = method(examples, ids, get_predictions=True)\n        n_correct += torch.sum((torch.argmax(preds, dim=1) == ids).int()).item()\n  return n_correct \/ float(len(ds))\n\n\ndef open_set_val_loop(arch, ds, method, cfg):\n  \"\"\"Performs open-set validation by computing recall@1.\n\n  Args:\n    arch: An archs.arch.Arch object (e.g., ResNet50 or N-digit MNIST arch).\n    ds: A datasets object (e.g., MNIST, CIFAR10).\n    method: A methods.methods softmax cross-entropy object (e.g., ArcFace).\n    cfg: The configuration dictionary from Hydra.\n\n  Returns:\n    Validation recall@1.\n  \"\"\"\n  method_name = method.__class__.__name__\n  arch.train(False)\n  ds.switch_split(\"valid\")\n  loader = utils.get_data_loader(\"sequential\", ds, cfg.num_workers,\n                                 {\"batch_size\": 128})\n\n  # Extract embeddings and ids\n  embs = []\n  ids = []\n  with torch.no_grad():\n    for batch in loader:\n      ids.append(batch[\"ids\"].detach().cpu().numpy())\n      examples = batch[\"examples\"]\n      if torch.cuda.is_available():\n        examples = examples.cuda()\n      embs.append(method.get_embeddings(examples).detach().cpu().numpy())\n  embs = np.concatenate(embs, axis=0)\n  ids = np.concatenate(ids, axis=0)\n\n  # For l2-normalized methods\n  if method_name in [\"VMFSoftmax\", \"ArcFace\", \"NormalizedSoftmaxCE\"]:\n    norm_method = utils.get_norm_method_by_name(\"l2\")\n    embs, norms = norm_method(embs, use_torch=False, return_norms=True)\n  # For hyperbolic softmax\n  elif method_name == \"HyperbolicSoftmaxCE\":\n    norm_method = utils.get_norm_method_by_name(\"hyperbolic\")\n    embs = norm_method(embs, use_torch=False, return_norms=False, c=method.c)\n\n  # For vMF, need to marginalize over samples\n  if method_name == \"VMFSoftmax\":\n    with torch.no_grad():\n      z = torch.from_numpy(embs)\n      z_norms = torch.from_numpy(norms)\n      if torch.cuda.is_available():\n        z = z.cuda()\n        z_norms = z_norms.cuda()\n      z_dist = distributions.VonMisesFisher(z, z_norms)\n      z_samples = (\n          z_dist.sample(torch.Size([method.n_samples\n                                   ])).permute(1, 0, 2).detach().cpu().numpy())\n\n    norms = norms.squeeze(1)\n    corrects = []\n    for i in range(method.n_samples):\n      z = z_samples[:, i, :]\n      index = faiss.IndexFlatIP(z.shape[1])\n      # pylint: disable=no-value-for-parameter\n      index.add(z)\n      # pylint: disable=no-value-for-parameter\n      _, idxs = index.search(z, 2)\n      preds = ids[idxs[:, 1]]\n      correct = ids == preds\n      corrects.append(correct)\n    corrects = np.array(corrects)\n    valid_acc = np.mean(mode(corrects, axis=0)[0])\n\n  # For hyperbolic, need to compute Poincare distance matrix\n  elif method_name == \"HyperbolicSoftmaxCE\":\n    # Since hyperbolic distance is non-trivial to compute, we use numpy instead\n    # of faiss\n    dist_matrix = hypnn.pairwise_dist_matrix(embs, method.c, batch_size=256)\n    # NOTE: Need to use kNN with precomputed distances since we're using\n    # hyperbolic distance\n    knn = KNeighborsClassifier(n_neighbors=1, n_jobs=1, metric=\"precomputed\")\n    knn.fit(dist_matrix, ids)\n    idxs = knn.kneighbors(return_distance=False)\n    preds = np.squeeze(ids[idxs], axis=1)\n    correct = ids == preds\n    valid_acc = np.mean(correct)\n\n  # For all other methods, just compute pairwise distances\n  else:\n    index = faiss.IndexFlatL2(embs.shape[1])\n    # pylint: disable=no-value-for-parameter\n    index.add(embs)\n    # pylint: disable=no-value-for-parameter\n    _, idxs = index.search(embs, 2)\n    preds = ids[idxs[:, 1]]\n    correct = ids == preds\n    valid_acc = np.mean(correct)\n\n  return valid_acc\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_93","text":"<reponame>gkuznetsov\/veles.znicz\n# encoding: utf-8\n\"\"\"\n.. invisible:\n     _   _ _____ _     _____ _____\n    | | | |  ___| |   |  ___\/  ___|\n    | | | | |__ | |   | |__ \\ `--.\n    | | | |  __|| |   |  __| `--. \\\n    \\ \\_\/ \/ |___| |___| |___\/\\__\/ \/\n     \\___\/\\____\/\\_____|____\/\\____\/\n\nCreated on July 30, 2014\n\n███████████████████████████████████████████████████████████████████████████████\n\nLicensed to the Apache Software Foundation (ASF) under one\nor more contributor license agreements.  See the NOTICE file\ndistributed with this work for additional information\nregarding copyright ownership.  The ASF licenses this file\nto you under the Apache License, Version 2.0 (the\n\"License\"); you may not use this file except in compliance\nwith the License.  You may obtain a copy of the License at\n\n  http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing,\nsoftware distributed under the License is distributed on an\n\"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, either express or implied.  See the License for the\nspecific language governing permissions and limitations\nunder the License.\n\n███████████████████████████████████████████████████████████████████████████████\n\"\"\"\n\ntry:\n    import cv2\nexcept ImportError:\n    import warnings\n    warnings.warn(\"Failed to import OpenCV bindings\")\nimport numpy\nimport scipy.stats\nimport statsmodels as sm\n\n\ndef is_background(pic_path, thr=8.0):\n    \"\"\"\n    Reads an image in grayscale, then fits its color intensity distribution\n        as normal. Then compares fitted CDF with empirical CDF. If they are\n        similar, thinks, that it is background\n\n    Args:\n        pic_path(str): path to image\n        the(float): a threshold\n    Returns:\n        bool\n\n    \"\"\"\n    pic_ravel = cv2.imread(pic_path, 0).ravel()\n    mu, std = scipy.stats.norm.fit(pic_ravel)\n    x_array = numpy.linspace(0, 255, num=256)\n    cdf = scipy.stats.norm.cdf(x_array, mu, std)\n    ecdf = sm.tools.tools.ECDF(pic_ravel)(x_array)\n\n    delta = numpy.sum(numpy.abs(ecdf - cdf))\n\n    return delta < thr\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_94","text":"# -*- coding: utf-8 -*-\r\n\"\"\"\r\n@author: <NAME>\r\n\"\"\"\r\n\r\n\r\nsource_directory     = 'point to source directory here'\r\nprojects_directory   = 'point to SEEG data directory here'\r\n\r\nimport numpy as np\r\nimport csv\r\nimport cPickle as pick\r\nimport sys\r\nimport copy\r\nsys.path.append(source_directory + 'Python27\\\\Utilities')\r\nimport CF_functions as cffun\r\nimport plot_functions as plots\r\nimport matplotlib.pyplot as mpl\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.colors as colors\r\nimport time\r\nimport bootstrap as bst\r\nfrom scipy import stats as stat\r\nimport statsmodels.sandbox.stats.multicomp as multicomp\r\n\r\n\r\n### CF type and PS metric\r\n\r\nCF_type     = 'CFS'                             # 'PAC' or 'CFS'\r\nPS_metric   = 'wPLI'                            # 'PLV' or 'wPLI'\r\n\r\nsign_z_CFC  = 2.42\r\nif PS_metric == 'PLV':\r\n    sign_z_PS   = 2.42                                \r\nelse:\r\n    sign_z_PS = 2.33\r\n\r\n\r\n\r\n### subject, frequency and parcellation settings\r\nsubjects = ['S' + str(i+1).zfill(3) for i in range(59)]\r\n   \r\ndirectory     = projects_directory+'resting_state\\\\RS_CF_SEEG\\\\'\r\n\r\n\r\nCFM_filename  = directory + '_support_files\\\\CF_matrix_SEEG.csv'\r\nfreqs_filename= directory + '_support_files\\\\all_frequencies_SEEG.csv'\r\nCFM           = np.genfromtxt(CFM_filename, delimiter=';')    \r\nLFs           = CFM[:,0]\r\nfreqs         = np.genfromtxt(freqs_filename, delimiter=';')                                                \r\n\r\nparc      = 'parc2009'       \r\nN_freq    = len(freqs)\r\nN_LF      = len(LFs)\r\nN_subj    = len(subjects)\r\nN_ratios  = 6  \r\ncutoff_PS = 100      \r\ncutoff_CF = 350    \r\nxlims_PS  = [1,100]\r\nxlims_CFC = [1,100]  \r\n\r\nHFs       = []     \r\nfor f in range(len(LFs)):\r\n    x   = CFM[f,1:N_ratios+1]\r\n    xx = x[np.intersect1d(np.where(x<cutoff_CF),np.where(x>0)) ] \r\n    if len(xx) >0:\r\n        HFs.append(xx)    \r\nHFs_env = [CFM[:30,i+1] for i in range(6)] \r\n\r\nfreq_bands    = [range(0,5),range(5,11),range(11,18),range(18,25),range(25,N_freq)]\r\nfreq_bands_LF = [range(1,6),range(3,10),range(9,16),range(16,22),range(22,N_LF)]\r\n   \r\nratios  = ['1:'+str(i+2) for i in range(N_ratios)]    \r\nratios2 = ['1-'+str(i+2) for i in range(N_ratios)]   \r\n\r\n\r\n### get epileptic-contact-masks and distance masks\r\n\r\ndist_thresholds = [0.02]    \r\nall_dist = np.empty(0)\r\ndist           = [None for i in subjects]\r\nmasks          = [None for i in subjects]\r\nch_per_subject = [None for i in subjects]\r\nfor s,subject in enumerate(subjects):\r\n     dist_filename = directory + '_support_files\\\\distances\\\\' + subject + '.csv'\r\n     dist[s]       = np.genfromtxt(dist_filename, delimiter=';') \r\n     mask_filename = directory + '_support_files\\\\masks\\\\' + subject + '.csv'\r\n     masks[s]      = np.genfromtxt(mask_filename, delimiter=';') \r\n     d2            = dist[s]*masks[s]\r\n     all_dist      = np.append(all_dist,d2.reshape(len(dist[s])**2))                      \r\n     ch_per_subject[s] = len(list(masks[s]))\r\nall_dist = all_dist[np.where(all_dist>0)]  \r\ndist_thresholds.extend(np.percentile(all_dist,[33.3333,66.66667]))\r\ndist_max = max(all_dist)\r\ndist_thresholds.extend([dist_max])\r\ndist_strs = ['{:.1f}'.format(d*100) for d in dist_thresholds]  \r\nN_dist_bins = len(dist_thresholds)-1   \r\ndistances = [dist_strs[i]+'-'+dist_strs[i+1]+'cm' for i in range(N_dist_bins)]\r\n\r\ndists_short = ['short','mid','long']\r\n\r\n\r\n\r\n\r\n### get GMPI info\r\n\r\nGMPI_vals     = [[] for i in subjects]\r\nGMPI_list     = [[] for i in subjects]\r\nGMPI_vals_all = []\r\n\r\nfor s,subject in enumerate(subjects):\r\n     gmpi_filename = directory + '_support_files\\\\gmpi\\\\' + subject + '.csv'\r\n     with open(gmpi_filename, 'rb') as csvfile:\r\n         reader = csv.reader(csvfile, delimiter = ';')\r\n         for row in reader:\r\n             GMPI_list[s].append(row)   \r\n             GMPI_vals[s].append(float(row[1]))\r\n             GMPI_vals_all.append(float(row[1]))\r\n             \r\n             \r\n### get layer interaction masks   \r\n             \r\nGMPI_vals_all=filter(lambda v: v==v, GMPI_vals_all)             # remove nans       \r\nN_layer_int       = 4   \r\nN_layer           = 3      \r\nlayer_int_masks   = [[None for j in range(N_layer_int)] for i in subjects]        # 0: deep-to-deep, 1: sup-to-sup, 2: deep-to-sup\r\nN_pairs_layer_int = [[None for j in range(N_layer_int)] for i in subjects]\r\nlayer_int         = ['superf-surf','deep-deep','superf-deep','deep-superf']\r\nlayers            = ['superf','interm','deep']\r\nchannel_layers    = [None for s in subjects]\r\nN_ch_layer_s      = np.zeros([N_subj,N_layer])\r\n\r\nfor s,subject in enumerate(subjects):\r\n     channel_layers[s] = np.full(ch_per_subject[s],np.nan)\r\n     for l in range(N_layer_int):   \r\n        layer_int_masks[s][l] = np.zeros([ch_per_subject[s],ch_per_subject[s]])     \r\n     for ch1,g1 in enumerate(GMPI_vals[s]):\r\n        if ( 0.5 < g1 < 1.2):\r\n             channel_layers[s][ch1] = 0              # surface\r\n        if ( 0   < g1 < 0.5):\r\n             channel_layers[s][ch1] = 1              # intermed.\r\n        if (-0.3 < g1 < 0 ): \r\n             channel_layers[s][ch1] = 2              # deep\r\n     for ch1,g1 in enumerate(GMPI_vals[s]):             \r\n        for ch2,g2 in enumerate(GMPI_vals[s]):\r\n            if (0.5 < g1 < 1.2 and 0.5 < g2 < 1.2 ):           # surface to surface\r\n                layer_int_masks[s][0][ch1,ch2]=1\r\n            if (-0.3 < g1 < 0 and -0.3 < g2 < 0 ):             # deep to deep\r\n                layer_int_masks[s][1][ch1,ch2]=1 \r\n            if (0.5 < g1 < 1.2 and -0.3  < g2 < 0):            # surf to deep\r\n                layer_int_masks[s][3][ch1,ch2]=1            \r\n            if (-0.3 < g1 < 0 and 0.5 < g2 < 1.2 ):            # deep to surface\r\n                layer_int_masks[s][2][ch1,ch2]=1\r\n     \r\n     for l in range(N_layer_int):   \r\n        mask1 = copy.copy(masks[s])\r\n        layer_int_masks[s][l]   = layer_int_masks[s][l]*mask1        \r\n        N_pairs_layer_int[s][l] = int(np.sum(layer_int_masks[s][l])) - np.sum(np.diag(layer_int_masks[s][l])>0)   \r\n     for l in range(N_layer):           \r\n        N_ch_layer_s[s,l] = np.sum(channel_layers[s]==l)\r\n\r\nN_ch_layer   = np.nansum(N_ch_layer_s,0)\r\n   \r\n\r\n\r\n### colormaps for plotting\r\nmy_cmap  = plots.make_cmap([(1.0, 0.0, 0.0), (0.0, 0.0, 1.0), (0.0, 1.0, 0.0), (0.8, 0.0, 1.0)])\r\nmy_cmap2 = plots.make_cmap([(0.0, 0.0, 0.0), (0.5, 0.5, 1.0), (0.6, 0.6, 1.0), (0.7, 0.7, 1.0), (0.8, 0.8, 1.0),(0.9, 0.9, 1.0), (1, 1, 1)])\r\nmy_cmap3 = plots.make_cmap([(1.0, 0.0, 0.0), (0.0, 0.6, 0.0), (1.0, 0.5, 0.0), (0.5, 0.0, 1.0), (0.6, 0.4, 0.4)]) \r\nmy_cmap4 = plots.make_cmap([(0.8, 0.6, 0.0), (1.0, 0.0, 0.0), (0.0, 0.8, 0.0), (0.1, 0.1, 0.1), (1.0, 0.4, 0.9), (0.0, 0.0, 1.0), (0.8, 0.0, 0.9)])\r\nmy_cmap5 = plots.make_cmap([(1,0,0), (0,1,0), (0,0,1)])\r\nmy_cmap6 = plots.make_cmap([(1,0,0), (0,0.7,0), (0,0,1), (1, 0.4, 0.4), (0.4,1,0.4), (0.4,0.4,1) ])\r\nmy_cmap7 = plots.make_cmap([(0.0, 0.0, 1.0), (1.0, 0.0, 0.0), (0.0, 0.6, 0.0), (1.0, 0.5, 0.0), (0.5, 0.0, 1.0), (0.6, 0.4, 0.4)]) \r\n\r\n\r\n\r\n### set matplotlib parameters    \r\nmpl.rcParams['pdf.fonttype'] = 42                 # for PDF compatibility with Illustrator\r\nmpl.rcParams.update({'font.size': 8})\r\nmpl.rcParams.update({'axes.titlesize': 8})\r\nmpl.rcParams.update({'axes.labelsize': 8})\r\nmpl.rcParams.update({'legend.fontsize': 6})\r\nmpl.rcParams.update({'xtick.labelsize': 7})\r\nmpl.rcParams.update({'ytick.labelsize': 7})\r\n\r\n\r\n\r\n\r\n### initialize lists\r\nPS           =  [[   None for i in range(N_freq)] for j in range(N_subj)]    \r\nPS_dist      =  [[[  None for b in range(N_dist_bins)] for i in range(N_freq)] for j in range(N_subj)]  \r\nPS_layer     =  [[[  None for b in range(N_layer_int)] for i in range(N_freq)] for j in range(N_subj)] \r\nCFC          =  [[[  None for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\nCFC_dist     =  [[[[ None for b in range(N_dist_bins)] for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\nCFC_layer    =  [[[[ None for b in range(N_layer_int)] for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\nPS_ENV       =  [[[  None for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\nPS_ENV_dist  =  [[[[ None for b in range(N_dist_bins)] for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\nPS_ENV_layer =  [[[[ None for b in range(N_layer_int)] for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\n\r\n\r\n      \r\n    \r\n\r\n#### compute PS single-subject stats    \r\nfor s,subject in enumerate(subjects): \r\n    for f,F in enumerate(freqs):  \r\n        F_str     = '{:.2f}'.format(F)             \r\n        mask      = copy.copy(masks[s])\r\n        N_pot     = np.nansum(mask)     \r\n        if PS_metric == 'wPLI':                                  \r\n            file1     = directory + '_data\\\\_PS_wPLI\\\\' + subject + ' f=' + F_str + '.csv'\r\n            file2     = directory + '_data\\\\_PS_wPLI\\\\' + subject + ' f=' + F_str + '_surr.csv'\r\n        else:  \r\n            file1     = directory + '_data\\\\_PS_PLV\\\\'  + subject + ' f=' + F_str + '.csv'\r\n            file2     = directory + '_data\\\\_PS_PLV\\\\'  + subject + ' f=' + F_str + '_surr.csv'\r\n        data      = mask*np.genfromtxt(file1, delimiter=';') \r\n        data_surr = mask*np.genfromtxt(file2, delimiter=';') \r\n        stats = cffun.K_stats_PS_2(data,data_surr,sign_z_PS,PS_metric)\r\n\r\n        PS[s][f] = stats \r\n        \r\n        for d in range(N_dist_bins):\r\n            dist_mask        = mask * ( ( (dist[s]>dist_thresholds[d]) * (dist[s]<=dist_thresholds[d+1]) )>0)\r\n            N_potD           = np.nansum(dist_mask)                                       \r\n            dataD            = data*dist_mask       \r\n            if N_potD>0:\r\n                stats      = cffun.K_stats_PS_2(dataD,data_surr,sign_z_PS,PS_metric)    \r\n            else:\r\n                stats = cffun.Stats_PS(np.nan)    \r\n            PS_dist[s][f][d] = stats\r\n\r\n        for l in range(N_layer_int):\r\n            layer_mask       = mask * layer_int_masks[s][l]\r\n            N_potL           = np.nansum(layer_mask)                                        \r\n            dataL            = data*layer_mask\r\n            if N_potL>0:\r\n                stats      = cffun.K_stats_PS_2(dataL,data_surr,sign_z_PS,PS_metric)  \r\n            else:\r\n                stats = cffun.Stats_PS(np.nan)    \r\n            PS_layer[s][f][l] = stats\r\n                      \r\n    print(time.strftime(\"%Y-%m-%d %H:%M\") + '          ' + subject)\r\n \r\n\r\n#### for PAC: compute PLV single-subject stats of LF-envelope filtered HF data \r\nif CF_type == 'PAC':\r\n    for s,subject in enumerate(subjects): \r\n        mask=masks[s]  \r\n        for lf,LF in enumerate(LFs):\r\n            for hf,HF in enumerate(HFs[lf]):  \r\n                np.fill_diagonal(mask,1)      \r\n                path        = directory + '_data\\\\_ENV\\\\'\r\n                LF_str      = '{:.2f}'.format(LF)                \r\n                HF_str      = '{:.2f}'.format(HF)  \r\n                file1       = path + subject + ' LF= ' + LF_str + ' HF= ' + HF_str + '.csv'            \r\n                file2       = path + subject + ' LF= ' + LF_str + ' HF= ' + HF_str + '_surr.csv'\r\n                N_pot       = np.nansum(mask)                \r\n                data        = mask*np.genfromtxt(file1, delimiter=';') \r\n                data_surr   = mask*np.genfromtxt(file2, delimiter=';') \r\n                stats       = cffun.K_stats_PS_2(data,data_surr,sign_z_PS,PS_metric)\r\n                PS_ENV[s][lf][hf]= stats                 \r\n                for d in range(N_dist_bins):\r\n                    dist_mask        = mask * ( ( (dist[s]>dist_thresholds[d]) * (dist[s]<=dist_thresholds[d+1]) )>0)\r\n                    N_potD           = np.nansum(dist_mask)                                       \r\n                    dataD            = data*dist_mask       \r\n                    if N_potD>0:\r\n                        stats      = cffun.K_stats_PS_2(dataD,data_surr,sign_z_PS,PS_metric)    \r\n                    else:\r\n                        stats = cffun.Stats_PS(np.nan)    \r\n                    PS_ENV_dist[s][lf][hf][d] = stats\r\n    \r\n                for l in range(N_layer_int):\r\n                    layer_mask       = mask * layer_int_masks[s][l]\r\n                    N_potL           = np.nansum(layer_mask)                                         \r\n                    dataL            = data*layer_mask\r\n                    if N_potL>0:\r\n                        stats      = cffun.K_stats_PS_2(dataL,data_surr,sign_z_PS,PS_metric)   \r\n                    else:\r\n                        stats = cffun.Stats_PS(np.nan)    \r\n                    PS_ENV_layer[s][lf][hf][l] = stats\r\n                              \r\n        print(time.strftime(\"%Y-%m-%d %H:%M\") + '          ' + subject)\r\n \r\n\r\n############################################################################################################################\r\n\r\n\r\n\r\n############ SEEG: compute CFC or PAC stats ############                                    \r\nfor s,subject in enumerate(subjects):    \r\n    mask=copy.copy(masks[s])\r\n    for lf,LF in enumerate(LFs):\r\n        for hf,HF in enumerate(HFs[lf]):  \r\n                np.fill_diagonal(mask,1)                            # for local!\r\n                LF_str       = '{:.2f}'.format(LF)                \r\n                HF_str       = '{:.2f}'.format(HF)  \r\n                LF_idx       = np.where(freqs==LF)[0][0]                    \r\n                LF_PS        = PS[s][LF_idx].data_sign              \r\n                if CF_type == 'CFS':                \r\n                    HF_idx       = np.where(freqs==HF)[0][0]                 \r\n                    HF_PS    = PS[s][HF_idx].data_sign\r\n                    path     = directory + '_data\\\\_CFS\\\\'  \r\n                    file0       = path + subject + ' LF=' + LF_str + ' HF=' + HF_str + '.csv'  \r\n                    file_surr   = path + subject + ' LF=' + LF_str + ' HF=' + HF_str + '_surr.csv'\r\n                else: \r\n                    HF_PS   = PS_ENV[s][lf][hf].data_sign\r\n                    path    = directory + '_data\\\\_PAC\\\\'              \r\n                    file0       = path + subject + ' LF= ' + LF_str + ' HF= ' + HF_str + '.csv'  \r\n                    file_surr   = path + subject + ' LF= ' + LF_str + ' HF= ' + HF_str + '_surr.csv'\r\n                masked_data   = np.genfromtxt(file0,  delimiter=';') * mask\r\n                surr_data   = np.genfromtxt(file_surr, delimiter=';') * mask\r\n                np.fill_diagonal(mask,0)                            \r\n                N_CH        = len(mask)\r\n                N_pot       = np.nansum(masked_data>0) - np.trace(masked_data>0)  \r\n                if N_pot > 0 and np.nansum(masked_data)-np.trace(masked_data)>0:    \r\n                   stats   = cffun.K_stats_CFC_2(masked_data,surr_data,sign_z_CFC,LF_PS,HF_PS) \r\n                else:\r\n                    stats       = cffun.Stats_CFC(np.nan)\r\n                CFC[s][lf][hf] = stats \r\n                \r\n                for d in range(len(distances)):\r\n                    dist_mask        = mask * ((dist[s]>dist_thresholds[d]) * (dist[s]<=dist_thresholds[d+1])) >0\r\n                    np.fill_diagonal(dist_mask,1)                                                           # 1 so that local CFC is preserved in data\r\n                    masked_dataD     = masked_data * dist_mask                        \r\n                    np.fill_diagonal(dist_mask,0)                                                           # 0 so that local CFC is removed in subfunction\r\n                    N_potD = np.sum(masked_dataD>0)-np.trace(masked_dataD>0)\r\n                    if N_potD>0:                     \r\n                        upper_idx     = np.triu_indices(N_CH)\r\n                        statsD   = cffun.K_stats_CFC_2(masked_dataD,surr_data,sign_z_CFC,LF_PS,HF_PS) \r\n                    else:\r\n                        statsD        = cffun.Stats_CFC(np.nan)          # set K to 0 if no edges in dist mask\r\n                    CFC_dist[s][lf][hf][d] = statsD   \r\n                    \r\n                for l in range(N_layer_int):\r\n                    layer_mask        = mask * layer_int_masks[s][l]\r\n                    np.fill_diagonal(layer_mask,1)                                                           # 1 so that local CFC is preserved in data\r\n                    masked_dataL     = masked_data * layer_mask    \r\n                    N_potL = np.sum(masked_dataL>0)-np.trace(masked_dataL>0)\r\n                    if N_potL>0:                     \r\n                        upper_idx     = np.triu_indices(N_CH)\r\n                        statsL   = cffun.K_stats_CFC_2(masked_dataL,surr_data,sign_z_CFC,LF_PS,HF_PS)  \r\n                    else:\r\n                        statsL        = cffun.Stats_CFC(np.nan)          # set K to 0 if no edges in dist mask\r\n                    CFC_layer[s][lf][hf][l] = statsL   \r\n                    \r\n    print(time.strftime(\"%Y-%m-%d %H:%M\") + '          ' + subject)\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#################            SAVE DATA WITH PICKLE            #################\r\n\r\n\r\nsave=1\r\nif save:\r\n    fileout1 = directory + '_results\\\\_pickle dump\\\\SEEG ' + PS_metric + ', z=' + '{:.2f}'.format(sign_z_PS) + ', ' + time.strftime(\"%Y-%m-%d\") + '.dat'\r\n    fileout2 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' corrected with ' + PS_metric + ', z=' + '{:.2f}'.format(sign_z_PS) + ', '  + time.strftime(\"%Y-%m-%d\") + '.dat'\r\n    fileout3 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' by layer interaction corrected with ' + PS_metric +', z=' + '{:.2f}'.format(sign_z_PS) + ', '  + time.strftime(\"%Y-%m-%d\") + '.dat'\r\n    fileout4 = directory + '_results\\\\_pickle dump\\\\SEEG PLV Envelope ' + time.strftime(\"%Y-%m-%d\") + '.dat'\r\n    pick.dump([PS,PS_dist],open(fileout1,'wb'))\r\n    pick.dump([CFC,CFC_dist],open(fileout2,'wb'))\r\n    pick.dump([PS_layer,CFC_layer],open(fileout3,'wb'))   \r\n    if CF_type=='PAC':\r\n            pick.dump([PS_ENV,PS_ENV_dist,PS_ENV_layer],open(fileout4,'wb'))   \r\n\r\n\r\n\r\n\r\n###############################################################################    \r\n##############                     LOAD DATA                  #################\r\n    \r\nuse_IMs = False                                   # only need to be loaded for degree and directionality analyses\r\n    \r\nif use_IMs:\r\n    file_in1 = directory + '_results\\\\_pickle dump\\\\SEEG ' + PS_metric + '.dat'\r\n    file_in2 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' corrected with ' + PS_metric + '.dat'    \r\n    file_in3 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' by layer interaction corrected with ' + PS_metric + '.dat'    \r\nelse:  \r\n    file_in1 = directory + '_results\\\\_pickle dump\\\\SEEG ' + PS_metric + '_no_IMS' + '.dat'\r\n    file_in2 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' corrected with ' + PS_metric + '_no_IMS'  + '.dat'    \r\n    file_in3 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' by layer interaction corrected with ' + PS_metric + '_no_IMS'  + '.dat'\r\n\r\n\r\nPS,PS_dist            = pick.load(open(file_in1,'rb'))\r\nCFC,CFC_dist          = pick.load(open(file_in2,'rb'))\r\nPS_layer,CFC_layer    = pick.load(open(file_in3,'rb'))\r\n\r\nfile_in4 = directory + '_results\\\\_pickle dump\\\\SEEG PLV Envelope.dat'\r\nPS_ENV,PS_ENV_dist,PS_ENV_layer    = pick.load(open(file_in4,'rb'))\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n###############################################################################\r\n#########                         PLOT PS                  \r\n                \r\n    \r\n\r\n### get numbers of edges for PS \r\nN_edges                  = 0\r\nN_edges_dist             = np.zeros([N_dist_bins])\r\nN_edges_layer            = np.zeros([N_layer_int])\r\nN_edges_subj             = np.zeros(N_subj)\r\nN_edges_dist_subj        = np.zeros([N_subj,N_dist_bins])\r\nN_edges_layer_subj       = np.zeros([N_subj,N_layer_int])\r\nN_CH_subj                = np.zeros(N_subj)\r\nN_subj_contr             = 0                        # number of contributing subjects\r\nN_subj_contr_dist        = np.zeros(N_dist_bins)\r\nN_layer_contr_dist       = np.zeros(N_layer_int)\r\n\r\nfor s in range(N_subj):    \r\n    N_edges                 += np.nan_to_num(PS[s][0].N_pot)        \r\n    N_subj_contr            += np.nan_to_num(int(PS[s][0].N_pot>0))\r\n    N_edges_subj[s]          = PS[s][0].N_pot\r\n\r\n    for d in range(N_dist_bins):\r\n        N_edges_dist[d]                += np.nan_to_num(PS_dist[s][0][d].N_pot)\r\n        N_edges_dist_subj[s,d]          = np.nan_to_num(PS_dist[s][0][d].N_pot)\r\n        N_subj_contr_dist[d]           += np.nan_to_num(int(PS_dist[s][0][d].N_pot>0))\r\n        \r\n    for l in range(N_layer_int):\r\n        N_edges_layer[l]                += np.nan_to_num(PS_layer[s][0][l].N_pot)\r\n        N_edges_layer_subj[s,l]          = np.nan_to_num(PS_layer[s][0][l].N_pot)\r\n        N_layer_contr_dist[l]           += np.nan_to_num(int(PS_layer[s][0][l].N_pot>0))\r\n        \r\n         \r\n### set divisors for mean calculation         \r\ndiv1 = N_edges\r\ndiv2 = N_edges_dist       \r\ndiv3 = N_edges_subj  \r\ndiv4 = N_edges_layer\r\n      \r\n### init PS arrays\r\nPLV_PS_ps        = np.zeros([N_subj,N_freq])                           # PS = \"Phase Synch\", ps = \"per subject\"\r\nK_PS_ps          = np.zeros([N_subj,N_freq])\r\nPLV_PS_dist_ps   = np.zeros([N_subj,N_freq,N_dist_bins])\r\nK_PS_dist_ps     = np.zeros([N_subj,N_freq,N_dist_bins])\r\nPLV_PS_layer_ps  = np.zeros([N_subj,N_freq,N_layer_int])\r\nK_PS_layer_ps    = np.zeros([N_subj,N_freq,N_layer_int])\r\n\r\n### get PS values\r\nfor f,F in enumerate(freqs): \r\n   for s in range(N_subj):    \r\n       PLV_PS_ps[s,f]        = PS[s][f].mean_masked * PS[s][f].N_pot                             \r\n       K_PS_ps[s,f]          = 100*PS[s][f].K           * PS[s][f].N_pot           \r\n       for d in range(N_dist_bins):   \r\n           PLV_PS_dist_ps[s,f,d]   = PS_dist[s][f][d].mean_masked * PS_dist[s][f][d].N_pot\r\n           K_PS_dist_ps[s,f,d]     = 100*PS_dist[s][f][d].K           * PS_dist[s][f][d].N_pot    \r\n       for l in range(N_layer_int):                             \r\n           PLV_PS_layer_ps[s,f,l]   = PS_layer[s][f][l].mean_masked * PS_layer[s][f][l].N_pot\r\n           K_PS_layer_ps[s,f,l]     = 100*PS_layer[s][f][l].K           * PS_layer[s][f][l].N_pot                   \r\n  \r\n                            \r\n### get bootstrap stats for PS\r\nN_boot = 1000    \r\nK_PS_stats         = [np.array(bst.CI_from_bootstrap(K_PS_ps,N_boot,  2.5,97.5,N_edges_subj))-1] \r\nPLV_PS_stats       = [bst.CI_from_bootstrap(PLV_PS_ps,N_boot,2.5,97.5,N_edges_subj)] \r\nK_PS_stats_dist    = [np.array(bst.CI_from_bootstrap(K_PS_dist_ps[:,:,i],   N_boot,2.5,97.5, N_edges_dist_subj[:,i]))-1 for i in range(N_dist_bins)] \r\nPLV_PS_stats_dist  = [bst.CI_from_bootstrap(PLV_PS_dist_ps[:,:,i], N_boot,2.5,97.5, N_edges_dist_subj[:,i]) for i in range(N_dist_bins)] \r\nK_PS_stats_layer   = [np.array(bst.CI_from_bootstrap(K_PS_layer_ps[:,:,i],  N_boot,2.5,97.5, N_edges_layer_subj[:,i]))-1 for i in range(N_layer_int)] \r\nPLV_PS_stats_layer = [bst.CI_from_bootstrap(PLV_PS_layer_ps[:,:,i],N_boot,2.5,97.5, N_edges_layer_subj[:,i]) for i in range(N_layer_int)] \r\n\r\n### get PS means            \r\nmean_K_PS           =  [(np.nansum(K_PS_ps,0)\/div1)-1]\r\nmean_PLV_PS         =  [(np.nansum(PLV_PS_ps,0)\/div1)]    \r\nmean_K_PS_dist      =   np.transpose(np.nansum(K_PS_dist_ps,0)\/div2)-1\r\nmean_PLV_PS_dist    =   np.transpose(np.nansum(PLV_PS_dist_ps,0)\/div2)  \r\nmean_K_PS_layer     =   np.transpose(np.nansum(K_PS_layer_ps,0)\/div4)-1\r\nmean_PLV_PS_layer   =   np.transpose(np.nansum(PLV_PS_layer_ps,0)\/div4)   \r\nK_PS_ps             =   (K_PS_ps\/div3[:,np.newaxis])-1\r\nPLV_PS_ps           =   (PLV_PS_ps\/div3[:,np.newaxis])   \r\n    \r\n\r\n### PLOT PS \r\n    \r\nfigsize = [6.1,2.3]\r\nrows    = 2\r\ncols    = 3\r\ndataL   = [PLV_PS_stats,PLV_PS_stats_dist,PLV_PS_ps,K_PS_stats,K_PS_stats_dist,K_PS_ps]\r\nxlimA   = [xlims_PS for i in range(6)]\r\nylimA   = [[0,0.2],[0,0.2],[0,0.3],[0,100],[0,100],[0,100]]\r\ntitlesA = ['' for i in range(6)]   ###['mean '+PS_metric,'mean '+PS_metric+' per distance','mean '+PS_metric+' per subject','mean K','mean K per distance','mean K per subject']\r\nlegendA = [None, distances, None, None, distances, None]\r\nylabA   = [PS_metric,PS_metric,PS_metric,'K [%]','K [%]','K [%]']\r\ncmapA   = ['brg','brg','brg','brg','brg','brg']\r\nCI      = [0.2,0.2,None,0.2,0.2,None]\r\nlegend_posA = [None,'ur',None,None,None,None]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,freqs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI)   \r\n\r\n## export .pdf\r\no66 = directory + '_results\\\\SEEG PS new\\\\SEEG ' + PS_metric + '.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,freqs,xlimA,ylabA,titlesA,cmapA,legendA,o66,legend_posA,ylimA,False,1,CI)   \r\n\r\n\r\n### PLOT PS with distances and layers  \r\n\r\nfigsize = [7.7,3]\r\nrows    = 2\r\ncols    = 3\r\ndataL   = [PLV_PS_stats,PLV_PS_stats_dist,PLV_PS_stats_layer[:3],K_PS_stats,K_PS_stats_dist,K_PS_stats_layer[:3]]\r\nxlimA   = [xlims_PS for i in range(6)]\r\nylimA   = [[0,0.2],[0,0.2],[0,0.2],[0,100],[0,100],[0,100]]\r\ntitlesA = ['mean '+PS_metric, 'mean '+PS_metric+' per distance','mean '+PS_metric+' per layer int.',\r\n           'mean K','mean K per distance', 'mean K per layer int.']\r\nlegendA = [None, distances, layer_int[:3], None, distances, layer_int[:3]]\r\nylabA   = [PS_metric,'','','K','','']\r\ncmapA   = ['brg','brg',my_cmap,'brg','brg',my_cmap,]\r\nCI      = [0.2 for i in range(6)]\r\nlegend_posA = [None,'ur','ur',None,'ur','ur']\r\nxlab    = [0,0,0,1,1,1]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,freqs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab)   \r\n\r\n## export .pdf\r\no67 = directory + '_results\\\\SEEG PS new\\\\SEEG '+PS_metric + '_with layers.pdf'    \r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,freqs,xlimA,ylabA,titlesA,cmapA,legendA,o67,legend_posA,ylimA,False,1,CI,xlab)   \r\n\r\n\r\n#### export plot data as csv files\r\n\r\no31  =  directory + '_results\\\\_plot_data_new\\\\PS\\\\SEEG\\\\SEEG ' + PS_metric + ' K.csv'\r\no32  =  directory + '_results\\\\_plot_data_new\\\\PS\\\\SEEG\\\\SEEG ' + PS_metric + ' GS.csv'\r\no33a = [directory + '_results\\\\_plot_data_new\\\\PS\\\\SEEG\\\\SEEG ' + PS_metric + ' K, ' + dists_short[i] + '.csv' for i in range(3)] \r\no34a = [directory + '_results\\\\_plot_data_new\\\\PS\\\\SEEG\\\\SEEG ' + PS_metric + ' GS, ' + dists_short[i] + '.csv' for i in range(3)] \r\n\r\nnp.savetxt(o31,K_PS_stats[0][:3],delimiter=';')\r\nnp.savetxt(o32,PLV_PS_stats[0][:3],delimiter=';')\r\nfor i in range(3):\r\n    np.savetxt(o33a[i],K_PS_stats_dist[i][:3],delimiter=';')\r\n    np.savetxt(o34a[i],PLV_PS_stats_dist[i][:3],delimiter=';')\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n###############################################################################\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n###############################################################################\r\n\r\n##############         PLOT  CFC              \r\n\r\n\r\n### get numbers of edges for CFC\r\n\r\nN_CH_subj                = np.zeros(N_subj)\r\nN_pot_subj_CF            = np.zeros(N_subj)\r\nN_pot_subj_CF_mod        = np.zeros([N_subj,N_LF,N_ratios])\r\nN_pot_subj_CF_excl       = np.zeros([N_subj,N_LF,N_ratios])\r\nN_pot_dist_subj_CF       = np.zeros([N_subj,N_dist_bins])\r\nN_pot_dist_subj_CF_mod   = np.zeros([N_subj,N_dist_bins,N_LF,N_ratios])\r\nN_pot_dist_subj_CF_excl  = np.zeros([N_subj,N_dist_bins,N_LF,N_ratios])\r\nN_pot_layer_subj_CF      = np.zeros([N_subj,N_layer_int])\r\nN_pot_layer_subj_CF_mod  = np.zeros([N_subj,N_layer_int,N_LF,N_ratios])\r\nN_pot_layer_subj_CF_excl = np.zeros([N_subj,N_layer_int,N_LF,N_ratios])\r\n\r\n\r\nN_subj_contr             = 0                        # number of contributing subjects\r\nN_subj_contr_dist        = np.zeros(N_dist_bins)\r\nN_subj_contr_layer       = np.zeros(N_layer_int)\r\n\r\nfor s in range(N_subj):     \r\n      N_pot_subj_CF[s]       = CFC[s][0][0].N_pot                        # these are dependent on mask only\r\n      N_CH_subj[s]           = CFC[s][0][0].N_CH\r\n      for lf in range(N_LF):\r\n         for hf in range(N_ratios):    \r\n             try:\r\n                N_pot_subj_CF_mod[s,lf,hf]   = CFC[s][lf][hf].N_pot_mod\r\n                N_pot_subj_CF_excl[s,lf,hf]  = CFC[s][lf][hf].N_pot_excl              \r\n                N_subj_contr                += np.int(N_pot_subj_CF[s]>0) \r\n             except:\r\n                pass    \r\n        \r\nfor s in range(N_subj):  \r\n    for d in range(N_dist_bins):   \r\n        N_pot_dist_subj_CF[s,d]       = np.nan_to_num(CFC_dist[s][0][0][d].N_pot)\r\n        N_subj_contr_dist[d]         += np.int(N_pot_dist_subj_CF[s,d]>0)\r\n        for lf in range(N_LF):\r\n            for hf in range(N_ratios):    \r\n                try:        \r\n                    N_pot_dist_subj_CF_mod[s,d,lf,hf]   = np.nan_to_num(CFC_dist[s][lf][hf][d].N_pot_mod)\r\n                    N_pot_dist_subj_CF_excl[s,d,lf,hf]  = np.nan_to_num(CFC_dist[s][lf][hf][d].N_pot_excl)\r\n                except:\r\n                    pass\r\n                \r\n    for l in range(N_layer_int):   \r\n        N_pot_layer_subj_CF[s,l]       = np.nan_to_num(CFC_layer[s][0][0][l].N_pot)\r\n        N_subj_contr_layer[l]         += np.int(N_pot_layer_subj_CF[s,l]>0)\r\n        for lf in range(N_LF):\r\n            for hf in range(N_ratios):    \r\n                try:        \r\n                    N_pot_layer_subj_CF_mod[s,l,lf,hf]   = np.nan_to_num(CFC_layer[s][lf][hf][l].N_pot_mod)\r\n                    N_pot_layer_subj_CF_excl[s,l,lf,hf]  = np.nan_to_num(CFC_layer[s][lf][hf][l].N_pot_excl)\r\n                except:\r\n                    pass\r\n  \r\nN_pot_CF            = np.nansum(N_pot_subj_CF)     \r\nN_pot_CF_mod        = np.nansum(N_pot_subj_CF_mod,0)  \r\nN_pot_CF_excl       = np.nansum(N_pot_subj_CF_excl,0)  \r\n\r\nN_pot_dist_CF       = np.nansum(N_pot_dist_subj_CF,0)\r\nN_pot_dist_CF_mod   = np.nansum(N_pot_dist_subj_CF_mod,0)\r\nN_pot_dist_CF_excl  = np.nansum(N_pot_dist_subj_CF_excl,0)\r\nN_pot_dist_CF_mod2  = np.moveaxis(N_pot_dist_CF_mod,0,-1)\r\n\r\nN_pot_layer_CF      = np.nansum(N_pot_layer_subj_CF,0)\r\nN_pot_layer_CF_mod  = np.nansum(N_pot_layer_subj_CF_mod,0)\r\nN_pot_layer_CF_excl = np.nansum(N_pot_layer_subj_CF_excl,0)\r\nN_pot_layer_CF_mod2 = np.moveaxis(N_pot_layer_CF_mod,0,-1)\r\n                \r\n       \r\n\r\n\r\n## initialize arrays    \r\nPLV_CFC_ps             = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nPLV_CFC_local_ps       = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nPLV_CFC_ps_mod         = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nPLV_CFC_ps_excl        = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nPLV_CFC_dist_ps        = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)    \r\nPLV_CFC_dist_ps_mod    = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\nPLV_CFC_dist_ps_excl   = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\nPLV_CFC_layer_ps       = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)    \r\nPLV_CFC_layer_ps_mod   = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\nPLV_CFC_layer_ps_excl  = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\nnPLV_CFC_dist_ps       = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)    \r\nN_CFC_ps               = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nN_CFC_local_ps         = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nN_CFC_ps_mod           = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nN_CFC_ps_excl          = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nN_CFC_dist_ps          = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)    \r\nN_CFC_dist_ps_mod      = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\nN_CFC_layer_ps         = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)    \r\nN_CFC_layer_ps_mod     = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\nN_CFC_layer_ps_excl    = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\n\r\n\r\n   \r\n# get CFC values\r\nfor lf,LF in enumerate(LFs): \r\n   for hf,HF in enumerate(HFs[lf]):\r\n       if HF<cutoff_CF:\r\n           for s in range(N_subj):                    \r\n               \r\n               PLV_CFC_ps[s,lf,hf]        = CFC[s][lf][hf].N_pot * CFC[s][lf][hf].mean_masked   \r\n               PLV_CFC_ps_mod[s,lf,hf]    = CFC[s][lf][hf].N_pot * CFC[s][lf][hf].mean_mod                       \r\n               PLV_CFC_ps_excl[s,lf,hf]   = CFC[s][lf][hf].N_pot * CFC[s][lf][hf].mean_excl\r\n               PLV_CFC_local_ps[s,lf,hf]  = CFC[s][lf][hf].N_CH  * CFC[s][lf][hf].mean_local  \r\n               N_CFC_ps[s,lf,hf]          = 100*CFC[s][lf][hf].N                     \r\n               N_CFC_ps_mod[s,lf,hf]      = 100*CFC[s][lf][hf].N_mod            \r\n               N_CFC_ps_excl[s,lf,hf]     = 100*CFC[s][lf][hf].N_excl       \r\n               N_CFC_local_ps[s,lf,hf]    = 100*CFC[s][lf][hf].N_local       \r\n               \r\n               for d in range(N_dist_bins):                   \r\n                   PLV_CFC_dist_ps[s,lf,hf,d]       = CFC_dist[s][lf][hf][d].N_pot * CFC_dist[s][lf][hf][d].mean_masked\r\n                   PLV_CFC_dist_ps_mod[s,lf,hf,d]   = CFC_dist[s][lf][hf][d].N_pot * CFC_dist[s][lf][hf][d].mean_mod                           \r\n                   PLV_CFC_dist_ps_excl[s,lf,hf,d]  = CFC_dist[s][lf][hf][d].N_pot * CFC_dist[s][lf][hf][d].mean_excl     \r\n                   try:\r\n                       nPLV_CFC_dist_ps[s,lf,hf,d]      = CFC_dist[s][lf][hf][d].N_pot * CFC_dist[s][lf][hf][d].mean_masked \/ CFC_dist[s][lf][hf][d].mean_surr_masked\r\n                   except:\r\n                       pass\r\n                       \r\n                   N_CFC_dist_ps[s,lf,hf,d]         = 100*CFC_dist[s][lf][hf][d].N\r\n                   N_CFC_dist_ps_mod[s,lf,hf,d]     = 100*CFC_dist[s][lf][hf][d].N_mod\r\n              \r\n                       \r\n               for l in range(N_layer_int):                   \r\n                   PLV_CFC_layer_ps[s,lf,hf,l]      = CFC_layer[s][lf][hf][l].N_pot * CFC_layer[s][lf][hf][l].mean_masked\r\n                   PLV_CFC_layer_ps_mod[s,lf,hf,l]  = CFC_layer[s][lf][hf][l].N_pot * CFC_layer[s][lf][hf][l].mean_mod                           \r\n                   PLV_CFC_layer_ps_excl[s,lf,hf,l] = CFC_layer[s][lf][hf][l].N_pot * CFC_layer[s][lf][hf][l].mean_excl                               \r\n                   N_CFC_layer_ps[s,lf,hf,l]        = 100*CFC_layer[s][lf][hf][l].N\r\n                   N_CFC_layer_ps_mod[s,lf,hf,l]    = 100*CFC_layer[s][lf][hf][l].N_mod\r\n                   N_CFC_layer_ps_excl[s,lf,hf,l]   = 100*CFC_layer[s][lf][hf][l].N_excl\r\n\r\n\r\n\r\n# get CFC stats for Figure 3 with 95% confidence intervals\r\nN_boot = 1000\r\n\r\nPLV_CFC_stats        = [bst.CI_from_bootstrap(PLV_CFC_ps      [:,:,i],N_boot,2.5,97.5,N_pot_subj_CF) for i in range(N_ratios)] # returns [mean, mean_boot, lower, upper] x freq x ratio\r\nPLV_CFC_local_stats  = [bst.CI_from_bootstrap(PLV_CFC_local_ps[:,:,i],N_boot,2.5,97.5,N_CH_subj) for i in range(N_ratios)]\r\nK_CFC_stats          = [np.array(bst.CI_from_bootstrap(N_CFC_ps      [:,:,i],N_boot,2.5,97.5,N_pot_subj_CF            )) -1 for i in range(N_ratios)]  \r\nK_CFC_stats_mod      = [np.array(bst.CI_from_bootstrap(N_CFC_ps_mod  [:,:,i],N_boot,2.5,97.5,N_pot_subj_CF_mod[:,:,i] )) -1 for i in range(N_ratios)] \r\nK_CFC_stats_excl     = [np.array(bst.CI_from_bootstrap(N_CFC_ps_excl [:,:,i],N_boot,2.5,97.5,N_pot_subj_CF_excl[:,:,i])) -1 for i in range(N_ratios)] \r\nK_CFC_local_stats    = [np.array(bst.CI_from_bootstrap(N_CFC_local_ps[:,:,i],N_boot,2.5,97.5,N_CH_subj                )) -1 for i in range(N_ratios)]  \r\n\r\n  \r\n# get stats for Figure 5 (dist)\r\nPLV_CFC_dist_12_stats     = [bst.CI_from_bootstrap(PLV_CFC_dist_ps[:,:,0,i],N_boot,2.5,97.5,N_pot_dist_subj_CF[:,i]) for i in range(N_dist_bins)] # returns [mean, lower, upper, mean_boot] x freq x dist\r\nPLV_CFC_dist_13_stats     = [bst.CI_from_bootstrap(PLV_CFC_dist_ps[:,:,1,i],N_boot,2.5,97.5,N_pot_dist_subj_CF[:,i]) for i in range(N_dist_bins)] \r\nK_CFC_dist_12_stats       = [np.array(bst.CI_from_bootstrap(N_CFC_dist_ps[:,:,0,i],N_boot,2.5,97.5,N_pot_dist_subj_CF[:,i]))-1 for i in range(N_dist_bins)] \r\nK_CFC_dist_13_stats       = [np.array(bst.CI_from_bootstrap(N_CFC_dist_ps[:,:,1,i],N_boot,2.5,97.5,N_pot_dist_subj_CF[:,i]))-1 for i in range(N_dist_bins)]\r\nK_CFC_dist_12_stats_mod   = [np.array(bst.CI_from_bootstrap(N_CFC_dist_ps_mod[:,:,0,i],N_boot,2.5,97.5,N_pot_dist_subj_CF_mod[:,i,:,0]))-1 for i in range(N_dist_bins)] \r\nK_CFC_dist_13_stats_mod   = [np.array(bst.CI_from_bootstrap(N_CFC_dist_ps_mod[:,:,1,i],N_boot,2.5,97.5,N_pot_dist_subj_CF_mod[:,i,:,1]))-1 for i in range(N_dist_bins)] \r\n\r\n# get stats for Figure 6 (layer)\r\nPLV_CFC_layer_12_stats    = [bst.CI_from_bootstrap(PLV_CFC_layer_ps[:,:,0,i],N_boot,2.5,97.5,N_pot_layer_subj_CF[:,i]) for i in range(N_layer_int)] # returns [mean, lower, upper, mean_boot] x freq x layer\r\nPLV_CFC_layer_13_stats    = [bst.CI_from_bootstrap(PLV_CFC_layer_ps[:,:,1,i],N_boot,2.5,97.5,N_pot_layer_subj_CF[:,i]) for i in range(N_layer_int)] \r\nK_CFC_layer_12_stats      = [np.array(bst.CI_from_bootstrap(N_CFC_layer_ps[:,:,0,i],N_boot,2.5,97.5,N_pot_layer_subj_CF[:,i]))-1 for i in range(N_layer_int)] \r\nK_CFC_layer_13_stats      = [np.array(bst.CI_from_bootstrap(N_CFC_layer_ps[:,:,1,i],N_boot,2.5,97.5,N_pot_layer_subj_CF[:,i]))-1 for i in range(N_layer_int)]\r\nK_CFC_layer_12_stats_mod  = [np.array(bst.CI_from_bootstrap(N_CFC_layer_ps_mod[:,:,0,i],N_boot,2.5,97.5,N_pot_layer_subj_CF_mod[:,i,:,0]))-1 for i in range(N_layer_int)] \r\nK_CFC_layer_13_stats_mod  = [np.array(bst.CI_from_bootstrap(N_CFC_layer_ps_mod[:,:,1,i],N_boot,2.5,97.5,N_pot_layer_subj_CF_mod[:,i,:,1]))-1 for i in range(N_layer_int)] \r\n\r\n# get CFC means                              \r\nmean_K_CFC             = np.transpose(np.nansum(N_CFC_ps,0)  \/N_pot_CF) -1\r\nmean_PLV_CFC           = np.transpose(np.nansum(PLV_CFC_ps,0)\/N_pot_CF)    \r\nmean_K_CFC_dist        = np.nansum(N_CFC_dist_ps,0)  \/N_pot_dist_CF -1\r\nmean_PLV_CFC_dist      = np.nansum(PLV_CFC_dist_ps,0)\/N_pot_dist_CF \r\nmean_K_CFC_mod         = np.transpose(np.nansum(N_CFC_ps_mod,0)  \/N_pot_CF_mod) -1\r\nmean_PLV_CFC_mod       = np.transpose(np.nansum(PLV_CFC_ps_mod,0)\/N_pot_CF_mod) \r\nmean_K_CFC_dist_mod    = np.nansum(N_CFC_dist_ps_mod,0)  \/N_pot_dist_CF_mod2 -1\r\nmean_PLV_CFC_dist_mod  = np.nansum(PLV_CFC_dist_ps_mod,0)\/N_pot_dist_CF_mod2    \r\n\r\nmean_K_CFC_layer       = np.nansum(N_CFC_layer_ps,0)  \/N_pot_layer_CF -1\r\nmean_PLV_CFC_layer     = np.nansum(PLV_CFC_layer_ps,0)\/N_pot_layer_CF \r\nmean_K_CFC_layer_mod   = np.nansum(N_CFC_layer_ps_mod,0)  \/N_pot_layer_CF_mod2 -1\r\nmean_PLV_CFC_layer_mod = np.nansum(PLV_CFC_layer_ps_mod,0)\/N_pot_layer_CF_mod2     \r\n\r\n# divide by edge number to get get individual K and PLVs\r\n\r\nK_CFC_ps_2            = N_CFC_ps*(1\/div3[:,np.newaxis,np.newaxis])\r\nPLV_CFC_ps_2          = PLV_CFC_ps*(1\/div3[:,np.newaxis,np.newaxis])\r\nK_CFC_ps_mod_2        = N_CFC_ps_mod*(1\/div3[:,np.newaxis,np.newaxis])\r\nPLV_CFC_ps_mod_2      = PLV_CFC_ps_mod*(1\/div3[:,np.newaxis,np.newaxis])    \r\nmean_K_CFC_local      = np.transpose(np.nansum(N_CFC_local_ps,0)\/sum(N_CH_subj))-1\r\nmean_PLV_CFC_local    = np.transpose(np.nansum(PLV_CFC_local_ps,0)\/sum(N_CH_subj))     \r\n    \r\n# get means per subject\r\nmean_PLV_CFC_ps_12        = (PLV_CFC_ps_2[:,:,0])\r\nmean_PLV_CFC_ps_13        = (PLV_CFC_ps_2[:,:,1])    \r\nmean_K_CFC_ps_12          = (K_CFC_ps_2[:,:,0])\r\nmean_K_CFC_ps_13          = (K_CFC_ps_2[:,:,1])    \r\nmean_PLV_CFC_dist_12      = np.transpose(mean_PLV_CFC_dist[:,0,:])\r\nmean_PLV_CFC_dist_13      = np.transpose(mean_PLV_CFC_dist[:,1,:])    \r\nmean_K_CFC_dist_12        = np.transpose(mean_K_CFC_dist[:,0,:])\r\nmean_K_CFC_dist_13        = np.transpose(mean_K_CFC_dist[:,1,:])\r\nmean_PLV_CFC_layer_12     = np.transpose(mean_PLV_CFC_layer[:,0,:])\r\nmean_PLV_CFC_layer_13     = np.transpose(mean_PLV_CFC_layer[:,1,:])    \r\nmean_K_CFC_layer_12       = np.transpose(mean_K_CFC_layer[:,0,:])\r\nmean_K_CFC_layer_13       = np.transpose(mean_K_CFC_layer[:,1,:])\r\nmean_PLV_CFC_ps_12_mod    = (PLV_CFC_ps_mod[:,:,0])\r\nmean_PLV_CFC_ps_13_mod    = (PLV_CFC_ps_mod[:,:,1])    \r\nmean_K_CFC_ps_12_mod      = (N_CFC_ps_mod[:,:,0])\r\nmean_K_CFC_ps_13_mod      = (N_CFC_ps_mod[:,:,1])       \r\nmean_PLV_CFC_dist_12_mod  = np.transpose(mean_PLV_CFC_dist_mod[:,0,:])\r\nmean_PLV_CFC_dist_13_mod  = np.transpose(mean_PLV_CFC_dist_mod[:,1,:])    \r\nmean_K_CFC_dist_12_mod    = np.transpose(mean_K_CFC_dist_mod[:,0,:])\r\nmean_K_CFC_dist_13_mod    = np.transpose(mean_K_CFC_dist_mod[:,1,:])\r\nmean_PLV_CFC_layer_12_mod = np.transpose(mean_PLV_CFC_layer_mod[:,0,:])\r\nmean_PLV_CFC_layer_13_mod = np.transpose(mean_PLV_CFC_layer_mod[:,1,:])    \r\nmean_K_CFC_layer_12_mod   = np.transpose(mean_K_CFC_layer_mod[:,0,:])\r\nmean_K_CFC_layer_13_mod   = np.transpose(mean_K_CFC_layer_mod[:,1,:])\r\nmax_PLV_CFC               = np.nanmax(mean_PLV_CFC)\r\nmax_K_CFC                 = np.nanmax(mean_K_CFC)   \r\nmax_PLV_CFC_local         = np.nanmax(mean_PLV_CFC_local)\r\nmax_K_CFC_local           = np.nanmax(mean_K_CFC_local)   \r\nmax_PLV_CFC_dist_13       = np.nanmax(mean_PLV_CFC_dist_13)\r\nmax_K_CFC_dist_13         = np.nanmax(mean_K_CFC_dist_13)\r\n\r\n### remove 0 entries in higher ratios\r\nmean_K_CFC    = list(mean_K_CFC)\r\nmean_K_CFC    = [np.array(filter(lambda a: a != -0.01, i)) for i in mean_K_CFC]\r\n#mean_PLV_CFC  = list(mean_PLV_CFC)\r\n#mean_PLV_CFC  = [np.array(filter(lambda a: a != 0, i)) for i in mean_PLV_CFC]\r\n#mean_K_CFC_mod    = list(mean_K_CFC_mod)\r\n#mean_K_CFC_mod    = [np.array(filter(lambda a: a != -0.01, i)) for i in mean_K_CFC_mod]\r\n#mean_PLV_CFC_mod  = list(mean_PLV_CFC_mod)\r\n#mean_PLV_CFC_mod  = [np.array(filter(lambda a: a != 0, i)) for i in mean_PLV_CFC_mod]    \r\n#mean_K_CFC_local     = list(mean_K_CFC_local )\r\n#mean_K_CFC_local     = [np.array(filter(lambda a: a != -1, i)) for i in mean_K_CFC_local]\r\nmean_PLV_CFC_local     = list(mean_PLV_CFC_local )\r\nmean_PLV_CFC_local     = [np.array(filter(lambda a: a != 0, i)) for i in mean_PLV_CFC_local]  \r\nmean_K_CFC_dist_13     = list(mean_K_CFC_dist_13 )\r\nmean_K_CFC_dist_13     = [np.array(filter(lambda a: a != -1, i)) for i in mean_K_CFC_dist_13]\r\nmean_K_CFC_dist_13_mod = list(mean_K_CFC_dist_13_mod )\r\nmean_K_CFC_dist_13_mod = [np.array(filter(lambda a: a != -1, i)) for i in mean_K_CFC_dist_13_mod]\r\nmean_PLV_CFC_dist_13   = list(mean_PLV_CFC_dist_13 )\r\nmean_PLV_CFC_dist_13   = [np.array(filter(lambda a: a != 0, i)) for i in mean_PLV_CFC_dist_13]\r\n\r\nPLV_CFC_stats                = [[np.array(filter(lambda a: a !=  0   , i)) for i in j] for j in PLV_CFC_stats] \r\nPLV_CFC_local_stats          = [[np.array(filter(lambda a: a !=  0,    i)) for i in j] for j in PLV_CFC_local_stats]\r\nPLV_CFC_dist_13_stats        = [[np.array(filter(lambda a: a != -0   , i)) for i in j] for j in PLV_CFC_dist_13_stats] \r\nK_CFC_stats                  = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_stats]\r\nK_CFC_stats_mod              = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_stats_mod]\r\nK_CFC_local_stats            = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_local_stats]  \r\n\r\nK_CFC_stats                  = [[K_CFC_stats[rat][i]*(K_CFC_stats[rat][i]>=0) for i in range(4)] for rat in range(6)]\r\nK_CFC_stats_mod              = [[K_CFC_stats_mod[rat][i]*(K_CFC_stats_mod[rat][i]>=0) for i in range(4)] for rat in range(6)]\r\nK_CFC_dist_12_stats          = [[K_CFC_dist_12_stats[dist][i]*(K_CFC_dist_12_stats[dist][i]>=0) for i in range(4)] for dist in range(3)]\r\nK_CFC_dist_12_stats_mod      = [[K_CFC_dist_12_stats_mod[dist][i]*(K_CFC_dist_12_stats_mod[dist][i]>=0) for i in range(4)] for dist in range(3)]\r\nK_CFC_dist_13_stats          = [[K_CFC_dist_13_stats[dist][i]*(K_CFC_dist_13_stats[dist][i]>=0) for i in range(4)] for dist in range(3)]\r\nK_CFC_dist_13_stats_mod      = [[K_CFC_dist_13_stats_mod[dist][i]*(K_CFC_dist_13_stats_mod[dist][i]>=0) for i in range(4)] for dist in range(3)]\r\nK_CFC_layer_12_stats         = [[K_CFC_layer_12_stats[layer][i]*(K_CFC_layer_12_stats[layer][i]>=0) for i in range(4)] for layer in range(4)]\r\nK_CFC_layer_12_stats_mod     = [[K_CFC_layer_12_stats_mod[layer][i]*(K_CFC_layer_12_stats_mod[layer][i]>=0) for i in range(4)] for layer in range(4)]\r\nK_CFC_layer_13_stats         = [[K_CFC_layer_13_stats[layer][i]*(K_CFC_layer_13_stats[layer][i]>=0) for i in range(4)] for layer in range(4)]\r\nK_CFC_layer_13_stats_mod     = [[K_CFC_layer_13_stats_mod[layer][i]*(K_CFC_layer_13_stats_mod[layer][i]>=0) for i in range(4)] for layer in range(4)]\r\n\r\nPLV_CFC_layer_13_stats       = [[np.array(filter(lambda a: a != -0   , i)) for i in j] for j in PLV_CFC_layer_13_stats] \r\nPLV_CFC_local_layer_13_stats = [[np.array(filter(lambda a: a != -0   , i)) for i in j] for j in PLV_CFC_local_layer_13_stats] \r\nK_CFC_dist_13_stats          = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_dist_13_stats]\r\nK_CFC_dist_13_stats_mod      = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_dist_13_stats_mod]\r\nK_CFC_layer_13_stats         = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_layer_13_stats]\r\nK_CFC_layer_13_stats_mod     = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_layer_13_stats_mod]\r\nK_CFC_local_layer_13_stats   = [[np.array(filter(lambda a: a != -1, i)) for i in j] for j in K_CFC_local_layer_13_stats]\r\n\r\nPLV_CFC_stats                = [[np.array(filter(lambda a: a != np.nan, i)) for i in j] for j in PLV_CFC_stats] \r\nPLV_CFC_local_stats          = [[np.array(filter(lambda a: a != np.nan, i)) for i in j] for j in PLV_CFC_local_stats]\r\nK_CFC_stats                  = [[np.array(filter(lambda a: a != np.nan, i)) for i in j] for j in K_CFC_stats]\r\nK_CFC_stats_mod              = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_stats_mod]\r\nK_CFC_local_stats            = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_local_stats]    \r\nK_CFC_dist_13_stats          = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_dist_13_stats]\r\nK_CFC_dist_13_stats_mod      = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_dist_13_stats_mod]\r\nK_CFC_layer_13_stats         = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_layer_13_stats]\r\nK_CFC_layer_13_stats_mod     = [[np.array(i[~np.isnan(i)]) for i in j] for j in K_CFC_layer_13_stats_mod]\r\n\r\n\r\n###############################################################################\r\n##########              plot CFC     \r\n\r\n\r\nfigsize = [6.3,2.3]  \r\n#figsize = [12.7,3.6]   \r\n \r\nrows    = 2\r\ncols    = 3\r\ndataL   = [PLV_CFC_stats[:1],K_CFC_stats[:1],K_CFC_stats_mod[:1],\r\n           PLV_CFC_stats[1:],K_CFC_stats[1:],K_CFC_stats_mod[1:]]    \r\nxlimA   = [xlims_CFC for i in range(6)]\r\ntitlesA = ['' for i in range(6)] #['mean PLV','mean K','mean K (controlled)','','','']\r\nif CF_type == 'CFS':\r\n    ylimA   = [[-0.005,0.049], [-1.4, 14], [-1.4,14], [-0.005,0.049], [-0.25,2.5], [-0.25,2.5]]  \r\nelse:\r\n    ylimA   = [[-0.007,0.069],  [-2.9, 29], [-2.9,29],  [-0.007,0.069], [-2.9,29],  [-2.9,29]] \r\nlegendA = [ratios[:1],ratios[:1],ratios[:1],\r\n           ratios[1:],ratios[1:],ratios[1:],]    \r\nylabA   = ['GS','K [%]','K [%]', 'GS','K [%]','K [%]']\r\ncmapA   = ['brg','brg','brg',my_cmap3,my_cmap3,my_cmap3]\r\nlegend_posA = ['ur',None,None,'ur',None,None]\r\nCI      = [0.2 for i in range(6)]\r\nxlab    = [0,0,0,1,1,1]\r\nRyt     = [1,1,1,1,1,1]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\n\r\n## export PDF\r\no80 = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ', controlled with ' + PS_metric + '.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,o80,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\n\r\n\r\n\r\n#### plot as heatmap\r\n\r\ndata1 = np.transpose(mean_K_CFC)\r\ndata2 = np.transpose(mean_K_CFC_mod)\r\nfigsize_hm = [1.6,1.9]\r\n\r\nif CF_type == 'CFS':\r\n    zmax1  = 12\r\n    zmax2  = 4\r\n    ztix1  = [0,3,6,9,12] \r\n    ztix2  = [0,1,2,3,4]    \r\nelse:\r\n    zmax1  = 24\r\n    zmax2  = 8\r\n    ztix1  = [0,6,12,18,24] \r\n    ztix2  = [0,2,4,6,8]  \r\n    \r\n\r\nLF_ics = [0,3,6,9,12,15,18,21,24,27,29]    \r\nLF_map = ['1.2', '2.4', '3.7', '5.9', '8.6', '13.2', '19.5', '29.5', '47.3', '68.1', '94.5']\r\n   \r\nplots.simple_CF_plot(data1,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax1,ztix=ztix1,outfile=None)             \r\nplots.simple_CF_plot(data2,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax2,ztix=ztix2,outfile=None)             \r\n  \r\n# export PDFs \r\no90  = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ' heatmap.pdf'\r\no90a = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ' heatmap, controlled with ' + PS_metric + '.pdf'\r\nplots.simple_CF_plot(data1,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax1,ztix=ztix1,outfile=o90)             \r\nplots.simple_CF_plot(data2,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax2,ztix=ztix2,outfile=o90a)             \r\n   \r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#####              GROUPS STATS AND PLOTS FOR ENVELOPE    \r\n\r\n# init ENV arrays\r\nK_ENV_ps               = np.full([N_subj,N_LF,N_ratios,],np.nan)\r\nPLV_ENV_ps             = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nK_ENV_local_ps         = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nPLV_ENV_local_ps       = np.full([N_subj,N_LF,N_ratios],np.nan)\r\nK_ENV_dist_ps          = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\nPLV_ENV_dist_ps        = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)    \r\n\r\n### get ENV values\r\nfor lf,LF in enumerate(LFs): \r\n   for hf,HF in enumerate(HFs[lf]):\r\n       for s,ss in enumerate(subjects):             \r\n           K_ENV_ps       [s,lf,hf]        = 100*PS_ENV[s][lf][hf].K\r\n           PLV_ENV_ps     [s,lf,hf]        = PS_ENV[s][lf][hf].mean_masked\r\n           for d in range(N_dist_bins):                                  \r\n               PLV_ENV_dist_ps [s,lf,hf,d] = PS_ENV_dist[s][lf][hf][d].mean_masked\r\n               K_ENV_dist_ps   [s,lf,hf,d] = 100*PS_ENV_dist[s][lf][hf][d].K\r\n\r\n\r\n### get ENV means and 95% confidence intervals\r\nN_boot=1000    \r\nPLV_ENV_stats          = [np.array(bst.CI_from_bootstrap(PLV_ENV_ps[:,:,i]))       for i in range(N_ratios)] # returns [mean, mean_boot, lower, upper] x freq x ratio\r\nK_ENV_stats            = [np.array(bst.CI_from_bootstrap(K_ENV_ps[:,:,i])) -1      for i in range(N_ratios)]  \r\nPLV_ENV_dist_12_stats  = [bst.CI_from_bootstrap(PLV_ENV_dist_ps[:,:,0,i]) for i in range(N_dist_bins)] # returns [mean, mean_boot, lower, upper] x freq x dist\r\nPLV_ENV_dist_13_stats  = [bst.CI_from_bootstrap(PLV_ENV_dist_ps[:,:,1,i]) for i in range(N_dist_bins)] # returns [mean, mean_boot, lower, upper] x freq x dist \r\nK_ENV_dist_12_stats    = [np.array(bst.CI_from_bootstrap(K_ENV_dist_ps[:,:,0,i]))-1 for i in range(N_dist_bins)] # returns [mean, mean_boot, lower, upper] x freq x dist\r\nK_ENV_dist_13_stats    = [np.array(bst.CI_from_bootstrap(K_ENV_dist_ps[:,:,1,i]))-1 for i in range(N_dist_bins)] # returns [mean, mean_boot, lower, upper] x freq x dist\r\n\r\n\r\n###############################################################################\r\n###########    plot amplitude envelope\r\n\r\nfigsize = [5.3,2.3]  \r\nrows    = 2\r\ncols    = 2\r\ndataL   = [PLV_ENV_stats,K_ENV_stats,\r\n           PLV_ENV_stats,K_ENV_stats,]    \r\nxlimA   = [[1,330] for i in range(4)]\r\ntitlesA = ['' for i in range(4)] #['mean PLV','mean K','mean K (controlled)','','','']\r\nylimA   = [[-0.007,0.07],  [-2, 22],[-0.007,0.07],  [-2,22], ] \r\nlegendA = [ratios,ratios,\r\n           ratios,ratios,]    \r\nylabA   = ['GS','K [%]', 'GS','K [%]',]\r\ncmapA   = [my_cmap7,my_cmap7,my_cmap7,my_cmap7]\r\nlegend_posA = [None,None,None,None,]\r\nCI      = [0.2 for i in range(4)]\r\nxlab    = [0,0,1,1,]\r\nRyt     = [1,1,1,1,]\r\n\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,     xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,HFs_env,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\n\r\n\r\n## export PDF\r\no80e = directory + '_results\\\\SEEG CF new\\\\SEEG Envelopes LFx.pdf'\r\no80f = directory + '_results\\\\SEEG CF new\\\\SEEG Envelopes HFx.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,    xlimA,ylabA,titlesA,cmapA,legendA,o80e,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,HFs_env,xlimA,ylabA,titlesA,cmapA,legendA,o80f,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\n\r\n\r\n#### plot as heatmap\r\ndata1 = np.transpose(mean_K_CFC)\r\nfigsize_hm = [1.6,1.9]\r\nzmax1  = 20\r\nzmax2  = 4\r\nztix1  = [0,5,10,15,20] \r\nztix2  = [0,1,2,3,4] \r\nLF_ics = [0,3,6,9,12,15,18,21,24,27,29]    \r\nLF_map = ['1.2', '2.4', '3.7', '5.9', '8.6', '13.2', '19.5', '29.5', '47.3', '68.1', '94.5'] \r\nplots.simple_CF_plot(data1,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax1,ztix=ztix1,outfile=None)             \r\n\r\n## export pdf\r\no99  = directory + '_results\\\\SEEG CF new\\\\SEEG Envelope heatmap.pdf'\r\nplots.simple_CF_plot(data1,figsize_hm,'ratio','Low Frequency [Hz]',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax1,ztix=ztix1,outfile=o99)             \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#####      plot CFC in distance bins \r\n\r\n\r\nfigsize = [6.3,2.3]  \r\nrows    = 2\r\ncols    = 3\r\ndataL   = [PLV_CFC_dist_12_stats, K_CFC_dist_12_stats, K_CFC_dist_12_stats_mod,\r\n           PLV_CFC_dist_13_stats, K_CFC_dist_13_stats, K_CFC_dist_13_stats_mod]        \r\nxlimA   = [xlims_CFC for i in range(6)]\r\ntitlesA = ['' for i in range(6)] \r\nif CF_type =='CFS':\r\n    ylimA   = [[-0.005,0.049], [-2, 19], [-2,19], [-0.005,0.049], [-0.35,3.4], [-0.35,3.4]]      \r\nelse:\r\n    ylimA   = [[-0.007,0.067],  [-3.8, 38],  [-3.8,38], [-0.007,0.067],  [-3.8, 38],  [-3.8,38]]                  # PAC           \r\nlegendA = [distances for i in range(6)]\r\nylabA   = ['GS','K [%]','K [%]', 'GS','K [%]','K [%]']\r\ncmapA   = ['brg','brg','brg','brg','brg','brg']\r\nlegend_posA = ['ur']+[None for i in range(5)]\r\nCI      = [0.2 for i in range(6)]\r\nxlab    = [0,0,0,1,1,1]\r\nRyt     = [1,1,1,1,1,1]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\n\r\n## export PDF\r\no81 = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ' controlled with ' + PS_metric + ', distance bins.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,o81,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#####             plot CF by layer combination\r\n\r\nfigsize = [6.3,2.3]  \r\nrows    = 2\r\ncols    = 3\r\ndataL   = [PLV_CFC_layer_12_stats, K_CFC_layer_12_stats, K_CFC_layer_12_stats_mod,\r\n           PLV_CFC_layer_13_stats, K_CFC_layer_13_stats, K_CFC_layer_13_stats_mod]        \r\nxlimA   = [xlims_CFC for i in range(6)]\r\ntitlesA = ['' for i in range(6)]       \r\nif CF_type =='CFS':\r\n    ylimA   = [[-0.005,0.049], [-2, 19], [-2,19], [-0.005,0.049], [-0.44,4.6], [-0.44,4.6]]      \r\nelse:\r\n    ylimA   = [[-0.007,0.067],  [-3.8, 38],  [-3.8,38], [-0.007,0.067],  [-3.8, 38],  [-3.8,38]]                   # PAC         \r\nlegendA = [layer_int for i in range(6)]\r\nylabA   = ['GS','K [%]','K [%]', 'GS','K [%]','K [%]']\r\ncmapA   = [my_cmap for i in range(6)]\r\nlegend_posA = [None,None,'ur',None,None,None ]\r\nCI      = [0.2 for i in range(6)]\r\nxlab    = [0,0,0,1,1,1]\r\nRyt     = [1,0,1,1,1,1]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\n\r\n## export PDF\r\no82 = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ' controlled with ' + PS_metric + ', layer interation.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,o82,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#####              plot local CF \r\n\r\nfigsize = [4.1,2.3] \r\nfigsize = [4.5,2.3]  \r\nrows    = 2\r\ncols    = 2\r\ndataL   = [PLV_CFC_local_stats[:1], K_CFC_local_stats[:1], \r\n           PLV_CFC_local_stats[1:], K_CFC_local_stats[1:]]        \r\nxlimA   = [xlims_CFC for i in range(4)]\r\ntitlesA = ['', '', '', '']\r\nif CF_type == 'CFS':\r\n    ylimA   = [[-0.01,0.13], [-0.01,100], [-0.005,0.044],  [-0.01,30]]     \r\nelse:\r\n    ylimA   = [[-0.02,0.2], [-0.01,100],    [-0.02,0.2], [-0.01,100]]          \r\nlegendA = [ratios[:1],ratios[:1],\r\n           ratios[1:],ratios[1:],] \r\nylabA   = ['GS','K','GS','K']\r\ncmapA   = ['brg','brg',my_cmap3,my_cmap3]\r\nlegend_posA = [None,None,None,None]\r\nCI      = [0.2,0.2,0.2,0.2]\r\nxlab    = [0,0,1,1]\r\nRyt     = [0,0,0,0]\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,None,legend_posA,ylimA,True,1,CI,xlab,Ryt)   \r\n\r\n# export PDF\r\no83 = directory + '_results\\\\SEEG CF new\\\\SEEG local ' + CF_type + '.pdf'\r\nplots.semi_log_plot_multi(figsize,rows,cols,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,o83,legend_posA,ylimA,False,1,CI,xlab,Ryt)   \r\n\r\n\r\n### plot heatmap\r\ndata = np.transpose(np.array(mean_K_CFC_local))\r\nfigsize_hm = [1.6,1.9]\r\nzmax   = 80 \r\nztix   = [0,20,40,60,80] \r\nLF_ics = [0,3,6,9,12,15,18,21,24,27,29]    \r\nLF_map = ['1.2', '2.4', '3.7', '5.9', '8.6', '13.2', '19.5', '29.5', '47.3', '68.1', '94.5']    \r\nplots.simple_CF_plot(data,figsize_hm,'ratio','LF',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax,ztix=ztix,outfile=None)             \r\n   \r\n# export PDF \r\no93 = directory + '_results\\\\SEEG CF new\\\\SEEG local ' + CF_type + ' heatmap.pdf'\r\nplots.simple_CF_plot(data,figsize_hm,'ratio','LF',np.arange(0.5,5.6,1),LF_ics,ratios,LF_map,zmax=zmax,ztix=ztix,outfile=o93)             \r\n\r\n\r\n\r\n\r\n\r\n\r\n###### save plot data as csv files\r\n\r\no41a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '\\\\SEEG\\\\SEEG ' + CF_type  + ' K ' + r + '.csv' for r in ratios2 ]\r\no41b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '\\\\SEEG\\\\SEEG ' + CF_type  + ' K_mod using ' + PS_metric + ' ' + r + '.csv' for r in ratios2 ]\r\no41c = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '\\\\SEEG\\\\SEEG ' + CF_type  + ' GS ' + r + '.csv' for r in ratios2 ]\r\no42a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 K, ' + d + ' .csv' for d in dists_short ]\r\no42b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 K_mod using ' + PS_metric + ', ' + d + '.csv' for d in dists_short ]\r\no42c = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 GS, ' + d + ' .csv' for d in dists_short ]\r\no43a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 K, ' + d + '.csv' for d in dists_short ]\r\no43b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 K_mod using ' + PS_metric + ', ' + d + '.csv' for d in dists_short ]\r\no43c = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_dist\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 GS, ' + d + '.csv' for d in dists_short ]\r\no44a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_local\\\\SEEG\\\\SEEG local ' + CF_type  + ' K ' + r + '.csv' for r in ratios2 ]\r\no44b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_local\\\\SEEG\\\\SEEG local ' + CF_type  + ' GS ' + r + '.csv' for r in ratios2 ]       \r\no45a = [directory + '_results\\\\_plot_data_new\\\\ENV\\\\SEEG\\\\SEEG ENV K ' + r + '.csv' for r in ratios2 ]\r\no45b = [directory + '_results\\\\_plot_data_new\\\\ENV\\\\SEEG\\\\SEEG ENV GS ' + r + '.csv' for r in ratios2 ]\r\no46a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 K, ' + l + ' .csv' for l in layer_int ]\r\no46b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 K_mod using ' + PS_metric + ', ' + l + '.csv' for l in layer_int ]\r\no46c = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-2 GS, ' + l + ' .csv' for l in layer_int ]\r\no47a = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 K, ' + l + '.csv' for l in layer_int ]\r\no47b = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 K_mod using ' + PS_metric + ', ' + l + '.csv' for l in layer_int ]\r\no47c = [directory + '_results\\\\_plot_data_new\\\\' + CF_type + '_layer\\\\SEEG\\\\SEEG ' + CF_type + ' 1-3 GS, ' + l + '.csv' for l in layer_int ]\r\nfor r in range(6):\r\n    np.savetxt(o41a[r],K_CFC_stats      [r][:3],delimiter=';')\r\n    np.savetxt(o41b[r],K_CFC_stats_mod  [r][:3],delimiter=';')\r\n    np.savetxt(o41c[r],PLV_CFC_stats    [r][:3],delimiter=';')\r\n    for d in range(3):\r\n        np.savetxt(o42a[d],K_CFC_dist_12_stats      [d][:3],delimiter=';')\r\n        np.savetxt(o42b[d],K_CFC_dist_12_stats_mod  [d][:3],delimiter=';')\r\n        np.savetxt(o42c[d],PLV_CFC_dist_12_stats    [d][:3],delimiter=';')\r\n        np.savetxt(o43a[d],K_CFC_dist_13_stats      [d][:3],delimiter=';')\r\n        np.savetxt(o43b[d],K_CFC_dist_13_stats_mod  [d][:3],delimiter=';')\r\n        np.savetxt(o43c[d],PLV_CFC_dist_13_stats    [d][:3],delimiter=';')   \r\n    np.savetxt(o44a[r],K_CFC_local_stats[r][:3],delimiter=';')\r\n    np.savetxt(o44b[r],PLV_CFC_local_stats[r][:3],delimiter=';')\r\n    if CF_type == 'PAC':\r\n        np.savetxt(o45a[r],K_ENV_stats[r][:3],delimiter=';')\r\n        np.savetxt(o45b[r],PLV_ENV_stats[r][:3],delimiter=';')\r\n    for l in range(4):\r\n        np.savetxt(o46a[l],K_CFC_layer_12_stats      [l][:3],delimiter=';')\r\n        np.savetxt(o46b[l],K_CFC_layer_12_stats_mod  [l][:3],delimiter=';')\r\n        np.savetxt(o46c[l],PLV_CFC_layer_12_stats    [l][:3],delimiter=';')\r\n        np.savetxt(o47a[l],K_CFC_layer_13_stats      [l][:3],delimiter=';')\r\n        np.savetxt(o47b[l],K_CFC_layer_13_stats_mod  [l][:3],delimiter=';')\r\n        np.savetxt(o47c[l],PLV_CFC_layer_13_stats    [l][:3],delimiter=';')\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n#######     compare long distance vs short dist. with Wilcoxon\r\n\r\nK_CFC_dist_ps     = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\nK_CFC_dist_ps_mod = np.full([N_subj,N_LF,N_ratios,N_dist_bins],np.nan)\r\n   \r\n# get CFC values\r\nfor lf,LF in enumerate(LFs): \r\n   for hf,HF in enumerate(HFs[lf]):\r\n           for s in range(N_subj):                                      \r\n               for d in range(N_dist_bins): \r\n                       PLV_CFC_dist_ps[s,lf,hf,d]      = CFC_dist[s][lf][hf][d].mean_masked\r\n                       K_CFC_dist_ps[s,lf,hf,d]        = CFC_dist[s][lf][hf][d].K\r\n                       K_CFC_dist_ps_mod[s,lf,hf,d]    = CFC_dist[s][lf][hf][d].K_mod\r\n                                \r\nwilc_pm     = np.zeros([N_LF,2,3])\r\nwilc_p      = np.zeros([N_LF,2,3])\r\nwilc_p_mod  = np.zeros([N_LF,2,3])\r\n\r\ncombo1      = [0,0,1]\r\ncombo2      = [1,2,2]\r\n\r\nfor lf,LF in enumerate(LFs): \r\n   for rat in range(2):\r\n      for co in range(3):\r\n          c1 = combo1[co]\r\n          c2 = combo2[co]\r\n          aaa, wilc_pm[lf,rat,co]    = stat.wilcoxon(PLV_CFC_dist_ps  [:,lf,rat,c1], PLV_CFC_dist_ps  [:,lf,rat,c2])\r\n          aaa, wilc_p[lf,rat,co]     = stat.wilcoxon(K_CFC_dist_ps    [:,lf,rat,c1], K_CFC_dist_ps    [:,lf,rat,c2])\r\n          aaa, wilc_p_mod[lf,rat,co] = stat.wilcoxon(K_CFC_dist_ps_mod[:,lf,rat,c1], K_CFC_dist_ps_mod[:,lf,rat,c2])\r\n      \r\n      \r\ns_12_ps  = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_pm   [:,0],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\ns_13_ps  = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_pm   [:,1],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\ns_12     = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p    [:,0],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\ns_13     = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p    [:,1],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\ns_12_mod = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p_mod[:,0],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\ns_13_mod = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p_mod[:,1],N_LF*3), method ='fdr_bh')[0]),[N_LF,3])\r\n\r\ndists_short = ['short', 'mid', 'long']\r\n\r\n### plot long vs short bin results\r\nfor co in range(3):\r\n    combo_str = dists_short[combo1[co]] + '-' + dists_short[combo2[co]] \r\n    dataA = [[s_12_ps[:,co]],[s_12[:,co]],[s_12_mod[:,co]],[s_13_ps[:,co]],[s_13[:,co]],[s_13_mod[:,co]]]\r\n    cmapA = ['brg','brg','brg','brg','brg','brg']\r\n    xlimA = [xlims_CFC for i in range(6)]\r\n    ylabA = ['','','','','','','']\r\n    ylimA = [1,1,1,1,1,1] \r\n    titlesA = ['1-2','1-2','1-2 c','1-3','1-3','1-3 c']\r\n    plots.semi_log_plot_multi([7.7,3],2,3,dataA,LFs,xlimA,ylabA,titlesA,cmapA,None,None,None,None,True,1,None,None,None,'auto',8,3)   \r\n    \r\n    # save pdf\r\n    o85 = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ', controlled with ' + PS_metric + ', distance comparison ' + combo_str + '.pdf'\r\n    plots.semi_log_plot_multi([7.7,3],2,3,dataA,LFs,xlimA,ylabA,titlesA,cmapA,None,o85,None,ylimA,True,1,None,None,None,'auto',8,3)   \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n########    compare superficial vs. deep layer int with Wilcoxon\r\n\r\nK_CFC_layer_ps     = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\nK_CFC_layer_ps_mod = np.full([N_subj,N_LF,N_ratios,N_layer_int],np.nan)\r\n\r\n# get CFC values\r\nfor lf,LF in enumerate(LFs): \r\n   for hf,HF in enumerate(HFs[lf]):\r\n           for s in range(N_subj):                                      \r\n               for d in range(N_layer_int): \r\n                       PLV_CFC_layer_ps[s,lf,hf,d]      = CFC_layer[s][lf][hf][d].mean_masked\r\n                       K_CFC_layer_ps[s,lf,hf,d]        = CFC_layer[s][lf][hf][d].K\r\n                       K_CFC_layer_ps_mod[s,lf,hf,d]    = CFC_layer[s][lf][hf][d].K_mod\r\n              #         K_CFC_layer_ps_excl[s,lf,hf,d]   = CFC_layer[s][lf][hf][d].K_excl                       \r\n                       \r\nwilc_pps    = np.zeros([N_LF,2,6])\r\nwilc_p      = np.zeros([N_LF,2,6])\r\nwilc_p_mod  = np.zeros([N_LF,2,6])\r\n\r\ncombo1      = [0,0,0,1,1,2]\r\ncombo2      = [1,2,3,2,3,3]\r\n\r\nfor lf,LF in enumerate(LFs): \r\n   for rat in range(2):\r\n       for co in range(6):\r\n           c1 = combo1[co]\r\n           c2 = combo2[co]           \r\n           aaa, wilc_pps  [lf,rat,co] = stat.wilcoxon(PLV_CFC_layer_ps  [:,lf,rat,c1], PLV_CFC_layer_ps  [:,lf,rat,c2])\r\n           aaa, wilc_p    [lf,rat,co] = stat.wilcoxon(K_CFC_layer_ps    [:,lf,rat,c1], K_CFC_layer_ps    [:,lf,rat,c2])\r\n           aaa, wilc_p_mod[lf,rat,co] = stat.wilcoxon(K_CFC_layer_ps_mod[:,lf,rat,c1], K_CFC_layer_ps_mod[:,lf,rat,c2])\r\n  \r\n\r\ns_12_ps  = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_pps  [:,0],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\ns_13_ps  = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_pps  [:,1],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\ns_12     = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p    [:,0],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\ns_13     = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p    [:,1],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\ns_12_mod = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p_mod[:,0],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\ns_13_mod = np.reshape( (1.*multicomp.multipletests(np.reshape(wilc_p_mod[:,1],N_LF*6), method ='fdr_bh')[0]),[N_LF,6])\r\n\r\n\r\n\r\ns_12_ps[s_12_ps==0]=np.nan\r\ns_12[s_12==0]=np.nan\r\ns_12_mod[s_12_mod==0]=0.01\r\ns_13_ps[s_13_ps==0]=0.01\r\ns_13[s_13==0]=0.01\r\ns_13_mod[s_13_mod==0]=0.01\r\n\r\nlay_sh = ['SS','DD','SD','DS']\r\n\r\n\r\nfor co in range(6):\r\n    dataA = [[s_12_ps[:,co]],[s_12[:,co]],[s_12_mod[:,co]],[s_13_ps[:,co]],[s_13[:,co]],[s_13_mod[:,co]]]\r\n    cmapA = ['brg','brg','brg','brg','brg','brg']\r\n    xlimA   = [xlims_CFC for i in range(6)]\r\n    ylimA = [[0,1.1] for i in range(6)]\r\n    ylabA = ['','','','','','']\r\n    ylabA = ['','','','','','']\r\n    titlesA = ['1-2','1-2','1-2 c','1-3','1-3','1-3 c']\r\n    plots.semi_log_plot_multi([7.7,3],2,3,dataA,LFs,xlimA,ylabA,titlesA,cmapA,None,None,None,ylimA,True,1,None,None,None,'auto',8,3)   \r\n\r\n\r\n    combo_str_l = lay_sh[combo1[co]] + '-' + lay_sh[combo2[co]]\r\n\r\n    ## save pdf\r\n    o86 = directory + '_results\\\\SEEG CF new\\\\SEEG ' + CF_type + ', controlled with ' + PS_metric + ', layer comparison ' + combo_str_l + '.pdf'\r\n    plots.semi_log_plot_multi([7.7,3],2,3,dataA,LFs,xlimA,ylabA,titlesA,cmapA,None,o86,None,ylimA,True,1,None,None,None,'auto',8,3)   \r\n    \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n########  initialize morphing ops and networks, get degrees and strengths  \r\n\r\n\r\nfile_in1 = directory + '_results\\\\_pickle dump\\\\SEEG ' + PS_metric  + '.dat'\r\nfile_in2 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' corrected with ' + PS_metric + '.dat'    \r\nfile_in3 = directory + '_results\\\\_pickle dump\\\\SEEG ' + CF_type + ' by layer interaction corrected with ' + PS_metric  + '.dat'\r\nPS,PS_dist            = pick.load(open(file_in1,'rb'))\r\nCFC,CFC_dist          = pick.load(open(file_in2,'rb'))\r\nPS_layer,CFC_layer    = pick.load(open(file_in3,'rb'))\r\n\r\n### initialize networks \r\nnetwork_names   = ['C','DM','DA','Lim','VA','SM','Vis']\r\nN_network       = 7\r\n\r\nfile_networks   = 'M:\\\\SEEG_Morlet\\\\_RAW_line_filtered\\\\_support_files\\\\networks parc2009.csv'\r\nnetwork_indices = np.array(np.genfromtxt(file_networks, delimiter=';'),'int')\r\n\r\n\r\nnetworks        = [np.where(network_indices==i)[0] for i in range(7)] \r\n\r\n\r\n\r\n### do edge counting    \r\nN, edges        = cffun.edge_counting(directory,subjects,ch_per_subject,freqs[:37],LFs,HFs,PS,CFC,CFC_dist,CFC_layer,'parc2009',channel_layers)\r\n\r\n### do edge counting in layers\r\n\r\nN_layer     = [[] for i in range(4)]\r\nedges_layer = [[] for i in range(4)]\r\nCFC_dummy   = [[[  None for i in range(N_ratios)] for j in range(N_LF)] for k in range(N_subj)]\r\n\r\n\r\n\r\nreload(cffun)\r\nfor l in range(4):    \r\n    for c1 in range(58):\r\n        for c2 in range(30):\r\n            for c3 in range(6):\r\n                CFC_dummy[c1][c2][c3] = CFC_layer[c1][c2][c3][l]    \r\n    N_layer[l], edges_layer[l]        = cffun.edge_counting(directory,subjects_red,ch_per_subject,freqs[:37],LFs,HFs,PS,CFC_dummy,'parc2009',channel_layers)\r\n    print l\r\n\r\n# save layer edges to pickle dump\r\nfileout37 = directory + '_results\\\\_pickle dump\\\\Edges in layers ' + CF_type + ', ' + PS_metric + ', ' + parc + ', '  + time.strftime(\"%Y-%m-%d\") + '.dat'  # save with pickle\r\npick.dump([N_layer,edges_layer],open(fileout37,'wb'))\r\n\r\n\r\nfor l in range(4):\r\n    D = cffun.degree_analysis(edges_layer[l],N_layer[l],networks)\r\n    cffun.write_degrees(directory,D,ratios2,'parc2009',CF_type, add_inf=layer_int) \r\n\r\n\r\n### analyze local CF and write to .csv\r\nN, edges        = cffun.analyze_local(N,edges,networks,N_ch_layer)\r\ncffun.write_csv_local(directory,edges,ratios2,parc,CF_type, add_inf='')\r\n\r\n### analyze PS per parcel and network ####################\r\nN, edges =  cffun.analyze_PS(N,edges,networks,N_ch_layer)\r\n\r\n### save edges to pickle dump\r\nfileout24 = directory + '_results\\\\_pickle dump\\\\Edges ' + CF_type + ', ' + PS_metric + ', ' + parc + ', '  + time.strftime(\"%Y-%m-%d\") + '.dat'  # save with pickle\r\npick.dump([N,edges],open(fileout24,'wb'))\r\n\r\n\r\n### load edges\r\nif CF_type == 'CFS':\r\n    filein24 = 'M:\\\\SEEG_Morlet\\\\_RAW_line_filtered\\\\_results\\\\_pickle dump\\\\Edges CFC, wPLI, parc2009.dat'\r\n\r\nelse:        \r\n    filein24 = 'M:\\\\SEEG_Morlet\\\\_RAW_line_filtered\\\\_results\\\\_pickle dump\\\\Edges PAC, wPLI, parc2009.dat'\r\n\r\n[N,edges] = pick.load(open(filein24,'rb'))\r\n\r\n\r\n\r\nxlimA   = [xlims_CFC for i in range(6)]\r\n\r\n\r\n\r\n########     plot local CFC per network    \r\n\r\ndataL   = [edges.mean_PLV_local_pn[:,:,0],edges.K_local_pn [:,:,0],edges.mean_PLV_local_pn[:,:,1],edges.K_local_pn[:,:,1]]\r\ntitlesA = ['local str 1:2','local K [%] 1:2','local str 1:3','local K [%] 1:3' ]\r\nylabA   = ['Str','K [%]','GS','K [%]']\r\ncmapA   = [my_cmap2 for i in dataL]\r\nlegendA = [network_names for i in dataL]\r\nfigsize = [7,4]\r\nplots.semi_log_plot_multi(figsize,2,2,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,None,['ur',None,None,None],None,1,1,None,None,Nyt=[1,1,1,1],'auto',fontsize=8,markersize=0)\r\n\r\no15 = directory + '_results\\\\results by system\\\\Local ' + CF_type + ' by system.pdf'\r\nplots.semi_log_plot_multi(figsize,2,2,dataL,LFs,xlimA,ylabA,titlesA,cmapA,legendA,o15,['ur',None,None,None],None,1,1,None,None,Nyt=[1,1,1,1],'auto',fontsize=8,markersize=0)\r\n\r\n\r\n\r\n\r\n##################################################################\r\n#### get regular and relative degrees, in-degrees and out-degrees\r\n\r\nD = cffun.degree_analysis(edges,N,networks)\r\ncffun.write_degrees(directory,D,ratios2,'parc2009',CF_type, add_inf='') \r\n\r\n\r\n\r\n\r\n\r\n\r\n###############################################################################\r\n##########                       low-high analysis \r\n\r\n### run low-high analysis with Wilcoxon and permutation tests\r\nalpha = 0.05\r\nN_perm = 1000\r\nN_rat  = 6\r\nN, lh = cffun.low_to_high_analysis(edges,N,LFs,HFs,alpha,N_perm,parc,directory,networks,N_rat=N_rat)                        \r\nN_min = 8\r\nlh_thr    = cffun.low_to_high_threshold(lh,N,N_min,networks)           # apply N_min threshold \r\nlh = lh_thr\r\n   \r\n### save results with pickle\r\nfileout4 = directory + '_results\\\\_pickle dump\\\\Low-high ' + CF_type + ', ' + PS_metric + ', ' + parc + ' ' + time.strftime(\"%Y-%m-%d\") + '.dat'  # save with pickle\r\npick.dump(lh,open(fileout4,'wb'))\r\n\r\n### load results\r\nfilein4 =  directory + '_results\\\\_pickle dump\\\\Low-high ' + CF_type + ', ' + PS_metric + ', parc2009, N_rat=2.dat'\r\nlh = pick.load(open(filein4,'rb'))\r\n\r\n\r\n  \r\n### write in&out values csv\r\ncffun.write_csv_low_to_high(directory,lh_thr,ratios2,parc, CF_type,add_inf=' corr')\r\n\r\n### plot out-in\r\nplots.semi_log_plot([10,5],lh.out_minus_in_degree_pn[:,:,0],LFs, [1,50], 'degree', network_names,None,'ur',None,True,cmap=my_cmap4,ncols=2,CI=False)   \r\nplots.semi_log_plot([10,5],lh.out_minus_in_degree_pn[:,:,1],LFs, [1,50], 'degree', network_names,None,'ur',None,True,cmap=my_cmap4,ncols=2,CI=False)   \r\n\r\n\r\n### plot results of difference tests: Wilc and perm.\r\ndataL = [[lh.K_LTH_wilc[:,0]],[lh.K_LTH_wilc[:24,1]],[lh.K_LH[:,0]],[lh.K_LH[:24,1]]]    \r\nylimA = [[0,0.3] for i in range(4)]\r\nplots.semi_log_plot_multi([7,4],2,2,dataL,LFs,[[0,50] for i in range(4)],['K','K','K','K'],['wilc 1:2','wilc 1:3','perm 1:2','perm 1:3'],['brg','brg','brg','brg'],ylimA=ylimA,show=True,xlab=[0,0,1,1],fontsize=12)\r\n\r\n\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_95","text":"# importing packages\nimport math\nimport numpy as np\nimport pandas as pd\nimport scipy.stats as stats\nimport sklearn\nimport imblearn\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nplt.style.use('ggplot')\n\nfrom imblearn.over_sampling import RandomOverSampler\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.svm import LinearSVC\nimport xgboost as xgb \nfrom sklearn import metrics\nfrom imblearn.over_sampling import SMOTE\nfrom imblearn.over_sampling import ADASYN\nimport math\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.ensemble import GradientBoostingClassifier\nfrom sklearn.model_selection import KFold\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.utils import shuffle\nfrom sklearn.preprocessing import MinMaxScaler\nfrom sklearn.calibration import CalibratedClassifierCV\nfrom collections import Counter\n\nclass modelpipeline:\n    def __init__(self):\n        pass\n    \n    def run_model(self, df, varlist, response, standardize, sampletype, modelname, text, n_fold):\n        # Remove any features not wanted based on varlist input and re-order based on varlist\n        df = df[varlist]\n        # We have to remove response from varlist - varlist_noresponse - as it is used later to subset out features\n        # Refer to the for loop for the cross validation where X_train and X_test is created at the end of loop\n        varlist_noresponse = []\n        for col in varlist:\n            if col != response:\n                varlist_noresponse.append(col)\n            \n            \n        if isinstance(n_fold, int) and n_fold > 1:\n            # Initialize dictionary to store results\n            self.store = {\"accuracy\": [], \"actual_accuracy\": [], \"sensitivity\": [], \"specificity\": [], \n                          \"precision\": [], \"f1\": [], \"auc\": [], \"pr_auc\": [], \"final\": {}}\n            \n            # Split dataframes into 2, one for positive response and one for negative\n            df_zero = df[df[response] == 0]\n            df_one = df[df[response] == 1]\n            \n            # Shuffle dataframe for response=0 and =1 so that train-test will not be biased in case rows that are similar are placed side by side\n            # Later on, we will reset the index and select by the index number by sections\n            df_zero = shuffle(df_zero, random_state=42)\n            df_one = shuffle(df_one, random_state=42)\n            df_zero = df_zero.reset_index(drop=True)\n            df_one = df_one.reset_index(drop=True)\n        \n            # Get the average number of records required for negative response and positive response for test records\n            # Train records will then have all the other records not in the test records\n            # n_fold is the number of folds for cross validation\n            start_index_one = 0\n            end_index_one = math.floor(df_one.shape[0]\/n_fold)\n            start_index_zero = 0\n            end_index_zero = math.floor(df_zero.shape[0]\/n_fold)\n            \n            for i in range(1,n_fold+1):\n                if i != n_fold:\n                    print('Getting TEST DF for response 1 from index ' + str(start_index_one) + ' to ' + str(end_index_one))\n                    df_one_test = df_one.iloc[start_index_one:end_index_one]\n                    print('Getting TRAIN DF for response 1 from index 0 to ' + str(start_index_one) + ' and from index ' + str(end_index_one) + ' to ' + str(df_one.shape[0]))\n                    df_one_train = pd.concat([df_one.iloc[0:start_index_one],df_one.iloc[end_index_one:]], axis=0)\n                    start_index_one += math.floor(df_one.shape[0]\/n_fold)\n                    end_index_one += math.floor(df_one.shape[0]\/n_fold)\n                    \n                    print('Getting TEST DF for response 0 from index ' + str(start_index_zero) + ' to ' + str(end_index_zero))\n                    df_zero_test = df_zero.iloc[start_index_zero:end_index_zero]\n                    print('Getting TRAIN DF for response 0 from index 0 to ' + str(start_index_zero) + ' and from index ' + str(end_index_zero) + ' to ' + str(df_zero.shape[0]))\n                    df_zero_train = pd.concat([df_zero.iloc[0:start_index_zero],df_zero.iloc[end_index_zero:]], axis=0)\n                    start_index_zero += math.floor(df_zero.shape[0]\/n_fold)\n                    end_index_zero += math.floor(df_zero.shape[0]\/n_fold)\n\n                else:\n                    # Last section of split needs to reach the end of dataset\n                    print('Getting TEST DF for response 1 from index ' + str(start_index_one) + ' to ' + str(df_one.shape[0]))\n                    df_one_test = df_one.iloc[start_index_one:df_one.shape[0]]\n                    print('Getting TRAIN DF for response 1 from index 0 to ' + str(start_index_one))\n                    df_one_train = df_one.iloc[0:start_index_one]\n                    \n                    # Last section of split needs to reach the end of dataset\n                    print('Getting TEST DF for response 0 from index ' + str(start_index_zero) + ' to ' + str(df_zero.shape[0]))\n                    df_zero_test = df_zero.iloc[start_index_zero:df_zero.shape[0]]\n                    print('Getting TRAIN DF for response 0 from index 0 to ' + str(start_index_zero))\n                    df_zero_train = df_zero.iloc[0:start_index_zero]\n                    \n                # Combine the subsetted sections for negatives and postives for both train and test before oversampling  \n                df_train = pd.concat([df_one_train, df_zero_train], axis=0)\n                df_test = pd.concat([df_one_test, df_zero_test], axis=0)\n                # varlist_noresponse has the feature list X without Y while response is the Y\n                # print(varlist_noresponse)\n                X_train = df_train[varlist_noresponse]\n                # print('Check X train vars after combining pds')\n                # print(X_train.columns.values)\n                y_train = df_train[response]\n                X_test = df_test[varlist_noresponse]\n                y_test = df_test[response]\n                \n                if standardize == True:\n                    scaling = MinMaxScaler(feature_range=(-1,1)).fit(X_train)\n                    X_train = scaling.transform(X_train)\n                    X_test = scaling.transform(X_test)\n                    X_train = pd.DataFrame(X_train, columns=varlist_noresponse)\n                    X_test = pd.DataFrame(X_test, columns=varlist_noresponse)\n\n                if sampletype == 'smote':\n                    X_train, X_test, y_train, y_test = sampling.smote_oversample(X_train, X_test, y_train, y_test, response)\n                elif sampletype == 'adasyn':\n                    X_train, X_test, y_train, y_test = sampling.adasyn_oversample(X_train, X_test, y_train, y_test, response)\n                elif sampletype == 'naive':\n                    X_train, X_test, y_train, y_test = sampling.naive_oversample(X_train, X_test, y_train, y_test, response)\n                else:\n                    # Convert all DF to numpy array for model building later\n                    X_train = X_train.values\n                    y_train = y_train.values\n                    X_test = X_test.values\n                    y_test = y_test.values\n                \n                # Build model in current fold\/iteration and get accuracy, sensitivity, specificity, precision, f1, auc\n                self.store = self.build_model(X_train, X_test, y_train, y_test, text, modelname, i, n_fold, self.store)\n                \n                # test model with all actual fraud results\n                if standardize == True:\n                    df_acc = pd.concat([pd.DataFrame(scaling.transform(df[varlist_noresponse]),columns=varlist_noresponse),df[response]],axis=1)\n                    # print(df)\n                    self.store['actual_accuracy'].append(evaluate.actual_acc(df_acc, self.store['model'], response))\n                else:\n                    self.store['actual_accuracy'].append(evaluate.actual_acc(df, self.store['model'], response))\n                \n            # Before results are returned, get average of all evaluation metrics and store in store['final'] section\n            self.store['final']['accuracy'] = self.avg(self.store['accuracy'])\n            self.store['final']['sensitivity'] = self.avg(self.store['sensitivity'])\n            self.store['final']['specificity'] = self.avg(self.store['specificity'])\n            self.store['final']['precision'] = self.avg(self.store['precision'])\n            self.store['final']['f1'] = self.avg(self.store['f1'])\n            self.store['final']['auc'] = self.avg(self.store['auc'])\n            self.store['final']['pr_auc'] = self.avg(self.store['pr_auc'])\n            self.store['final']['actual_accuracy'] = self.avg(self.store['actual_accuracy'])\n            \n            print('Final Results of ' + str(n_fold) + ' fold CV:')\n            print(self.store['final'])\n            return self.store\n        \n        else:\n            print('n fold must be an integer greater than 1')\n            return self.store\n    \n    def build_model(self, X_train, X_test, y_train, y_test, text, modelname, i, n_fold, store):\n        if modelname == 'LogisticRegression':\n            model = LogisticRegression(max_iter=300, C=0.8, solver='liblinear')\n            model.fit(X_train,y_train)\n        elif modelname == 'XGBoost':\n            model = xgb.XGBClassifier(seed=42, nthread=1, max_depth=math.ceil(math.sqrt(X_train.shape[1])),\n                                      n_estimators=100, random_state=42)\n            model.fit(X_train, y_train, eval_set=[(X_train, y_train), (X_test, y_test)], verbose=5)\n        elif modelname == 'XGBoostminus1':\n            # XGBoost with one less depth\n            model = xgb.XGBClassifier(seed=42, nthread=1, max_depth=math.ceil(math.sqrt(X_train.shape[1])-1),\n                                      n_estimators=100, random_state=42)\n            model.fit(X_train, y_train, eval_set=[(X_train, y_train), (X_test, y_test)], verbose=5)\n        elif modelname == 'XGBoostplus1':\n            # XGBoost with one more depth\n            model = xgb.XGBClassifier(seed=42, nthread=1, max_depth=math.ceil(math.sqrt(X_train.shape[1]))+1,\n                                      n_estimators=100, random_state=42)\n            model.fit(X_train, y_train, eval_set=[(X_train, y_train), (X_test, y_test)], verbose=5)\n        elif modelname == 'XGBoostplus3':\n            # XGBoost with 3 more depth\n            model = xgb.XGBClassifier(seed=42, nthread=1, max_depth=math.ceil(math.sqrt(X_train.shape[1]))+3,\n                                      n_estimators=100, random_state=42)\n            model.fit(X_train, y_train, eval_set=[(X_train, y_train), (X_test, y_test)], verbose=5)\n            \n        # Use Linear SVC instead of sklearn svm.SVC as the former as way faster processing speed\n        # However, LinearSVC does not have .predict_proba function to get probability of response 1\n        # Hence, we need to use CalibratedClassifier that provides .predict_proba functionality\n        # On the bad side, it has it's own CV, so we put 10 fold CV to minimize the dataset loss due to train-test fold\n        # Ideally, we should use the older pipeline code that does not do customized k-fold CV (refer to SCI16. Jupyter Notebook)\n        elif modelname == 'SVM_Linear':\n            model = LinearSVC(random_state=42) # default C=1 (regularization parameter)\n            model = CalibratedClassifierCV(model, cv=10)\n            model.fit(X_train,y_train)\n        elif modelname == 'SVM_Linear2':\n            model = LinearSVC(random_state=42, C=2)\n            model = CalibratedClassifierCV(model, cv=10)\n            model.fit(X_train,y_train)\n        elif modelname == 'SVM_Linear0.5':\n            model = LinearSVC(random_state=42, C=0.5)\n            model = CalibratedClassifierCV(model, cv=10)\n            model.fit(X_train,y_train)\n        elif modelname == 'SVM_Linear0.3':\n            model = LinearSVC(random_state=42, C=0.3)\n            model = CalibratedClassifierCV(model, cv=10)\n            model.fit(X_train,y_train)\n        elif modelname == 'RandomForest':\n            treedepth = math.ceil(math.sqrt(X_train.shape[1]))\n            model = RandomForestClassifier(random_state=42, max_depth=treedepth, n_estimators=100)\n            model.fit(X_train,y_train)\n        elif modelname == 'RandomForestminus1':\n            treedepth = math.ceil(math.sqrt(X_train.shape[1]))-1\n            model = RandomForestClassifier(random_state=42, max_depth=treedepth, n_estimators=100)\n            model.fit(X_train,y_train)\n        elif modelname == 'RandomForestminus2':\n            treedepth = math.ceil(math.sqrt(X_train.shape[1]))-2\n            model = RandomForestClassifier(random_state=42, max_depth=treedepth, n_estimators=100)\n            model.fit(X_train,y_train)\n        elif modelname == 'RandomForestplus2':\n            treedepth = math.ceil(math.sqrt(X_train.shape[1]))+2\n            model = RandomForestClassifier(random_state=42, max_depth=treedepth, n_estimators=100)\n            model.fit(X_train,y_train)\n        elif modelname == 'RandomForestplus4':\n            treedepth = math.ceil(math.sqrt(X_train.shape[1]))+4\n            model = RandomForestClassifier(random_state=42, max_depth=treedepth, n_estimators=100)\n            model.fit(X_train,y_train)\n        else:\n            # Parameters based on gridsearchcv of modelname = logistic regresion\n            # Leave parameter blank for modelname to run this instance of logistic regression\n            model = LogisticRegression(C=0.8, max_iter=300, solver='liblinear')\n            model.fit(X_train,y_train)\n        \n        y_predict = model.predict(X_test)\n        y_predictprob = model.predict_proba(X_test)[:, 1]\n        store = evaluate.model_results(y_test, y_predict, y_predictprob, text, store, i, n_fold)\n        \n        # Store model for usage in measuring actual accuracy of fraud cases\n        store['model'] = model\n        print(\"Iteration \" + str(i) + \" out of \" + str(n_fold) + \" of CV for model fitting and obtaining results is complete!\")\n        print(\"\\n\")\n        return store\n    \n    \n    def avg(self, array):\n        return sum(array) \/ len(array)\n\nclass sampling:\n    def __init__(self):\n        pass\n    @staticmethod\n    def naive_oversample(X_train, X_test, y_train, y_test, response):\n        ros = RandomOverSampler(random_state=42)\n        X_train, y_train = ros.fit_resample(X_train, y_train)\n        # train test split keeps X_test and y_test as pd series, oversampler converts X_train, y_train to numpy\n        # Convert all to numpy array for XGBoost to not have bugs\n        X_test = X_test.values\n        y_test = y_test.values\n        print(\"Oversampling is complete!\")\n        return X_train, X_test, y_train, y_test\n    \n    @staticmethod\n    def smote_oversample(X_train, X_test, y_train, y_test, response):\n        X_train, y_train = SMOTE().fit_resample(X_train, y_train)\n        # train test split keeps X_test and y_test as pd series, oversampler converts X_train, y_train to numpy\n        # Convert all to numpy array for XGBoost to not have bugs\n        X_test = X_test.values\n        y_test = y_test.values\n        print(\"Number of Xs and Ys for SMOTE:\")\n        print(sorted(Counter(y_train).items()))\n        print(\"Oversampling is complete!\")\n        return X_train, X_test, y_train, y_test\n    \n    @staticmethod\n    def adasyn_oversample(X_train, X_test, y_train, y_test, response):\n        X_train, y_train = ADASYN().fit_resample(X_train, y_train)\n        # train test split keeps X_test and y_test as pd series, oversampler converts X_train, y_train to numpy\n        # Convert all to numpy array for XGBoost to not have bugs\n        X_test = X_test.values\n        y_test = y_test.values\n        print(\"Number of Xs and Ys for ADASYN:\")\n        print(sorted(Counter(y_train).items()))\n        print(\"Oversampling is complete!\")\n        return X_train, X_test, y_train, y_test\n\n\n\nclass evaluate:\n    def __init__(self):\n        pass\n    \n    @staticmethod\n    def model_results(y_test, y_predict, y_predictprob, text, store, i, n_fold):\n        cm = metrics.confusion_matrix(y_test, y_predict)\n        print(cm)\n        RFC_CM = pd.DataFrame(cm, ['Actual 0', 'Actual 1'], ['Predict 0', 'Predict 1'])\n        sns.heatmap(RFC_CM, annot=True, annot_kws={\"size\": 16}, cmap='Greens', linewidths=1, fmt='g')# font size\n        sns.set(font_scale=1.4)#for label size\n        plt.title(\"Confusion Matrix for \" + text)\n\n        # fix for mpl bug that cuts off top\/bottom of seaborn viz\n        b, t = plt.ylim() \n        b += 0.5 \n        t -= 0.5 \n        plt.ylim(b, t) \n        plt.figure(1,figsize=(4,4))\n        plt.show() \n\n        accuracy = metrics.accuracy_score(y_test, y_predict)\n        # print('Accuracy: ' + str(accuracy))\n        sensitivity = cm[1][1] \/ (cm[1][1] + cm[1][0])\n        recall = sensitivity\n        # print('Sensitivity: ' + str(sensitivity))\n        specificity = cm[0][0] \/ (cm[0][0] + cm[0][1])\n        # print('Specificity: ' + str(specificity))\n        precision = cm[1][1] \/ (cm[1][1] + cm[0][1])\n        # print('Precision: ' + str(precision))\n        f1 = 2 * (recall * precision)\/(recall + precision)\n        # print('f1 score: ' + str(f1))\n        auc, pr_auc = evaluate.ROC(y_test, y_predictprob, text, i, n_fold)\n        \n        store['accuracy'].append(accuracy)\n        store['sensitivity'].append(sensitivity)\n        store['specificity'].append(specificity)\n        store['precision'].append(precision)\n        store['f1'].append(f1)\n        store['auc'].append(auc)\n        store['pr_auc'].append(pr_auc)\n\n        return store\n    \n#     @staticmethod\n#     def ROC(y_test, y_predictprob, text):\n#         # IMPORTANT: first argument is true values, second argument is predicted probabilities\n#         auc = metrics.roc_auc_score(y_test, y_predictprob)\n#         # print(\"AUC value is: \" + str(auc))\n#         fpr, tpr, thresholds = metrics.roc_curve(y_test, y_predictprob)\n#         # print(\"AUC value is also: \" + str(metrics.auc(fpr, tpr)))\n#         plt.plot(fpr, tpr)\n#         plt.xlim([0.0, 1.0])\n#         plt.ylim([0.0, 1.0])\n#         plt.title('ROC curve for ' + text)\n#         plt.xlabel('False Positive Rate (1 - Specificity)')\n#         plt.ylabel('True Positive Rate (Sensitivity)')\n#         plt.grid(True)\n#         return auc\n\n    @staticmethod\n    def ROC(y_test, y_predictprob, text, i, n_fold):\n        # IMPORTANT: first argument is true values, second argument is predicted probabilities\n        auc = metrics.roc_auc_score(y_test, y_predictprob)\n        # print(\"AUC value is: \" + str(auc))\n        print(\"AUC value is: \" + str(auc))\n        fpr, tpr, thresholds = metrics.roc_curve(y_test, y_predictprob)\n        # print(\"AUC value is also: \" + str(metrics.auc(fpr, tpr)))\n        # Calculate precision and recall for each threshold\n        precision, recall, _ = metrics.precision_recall_curve(y_test, y_predictprob)\n        pr_auc = metrics.auc(recall, precision)\n        # Only show ROC-AUC graph and PR-AUC graph on last iteration as they look very similar\n        # The full results can be obtained in the results section\n        if n_fold == i:\n            fullgraph = plt.figure(1,figsize=(10,20))\n            plt.style.use('ggplot')\n            ROCAUC_plot = fullgraph.add_subplot(211)\n            ROCAUC_plot.plot(fpr, tpr, color='blue')\n            ROCAUC_plot.set_title('ROC curve for ' + text)\n            ROCAUC_plot.set_xlabel('False Positive Rate (1 - Specificity)')\n            ROCAUC_plot.set_ylabel('True Positive Rate (Sensitivity)')\n            ROCAUC_plot.set_xlim([0.0, 1.0])\n            ROCAUC_plot.set_ylim([0.0, 1.0])\n            ROCAUC_plot.grid(True)\n            PRAUC_plot = fullgraph.add_subplot(212)\n            PRAUC_plot.plot(precision, recall, color='purple')\n            PRAUC_plot.set_title('Precision-Recall curve for ' + text)\n            PRAUC_plot.set_xlabel('Recall')\n            PRAUC_plot.set_ylabel('Precision')\n            PRAUC_plot.set_xlim([0.0, 1.0])\n            PRAUC_plot.set_ylim([0.0, 1.0])\n            PRAUC_plot.grid(True)\n        return auc, pr_auc\n\n    @staticmethod\n    def actual_acc(df, model, response):\n        allpositive = df[df[response] == 1]\n        x_positive = allpositive.drop([response], axis=1)\n        y_positive = allpositive[response]\n        # Convert to numpy array due to XGBoost model.predict not working well for pandas\n        x_positive = x_positive.values\n        y_positive = y_positive.values\n        y_pospredict = model.predict(x_positive)\n        accuracy_positive = metrics.accuracy_score(y_positive, y_pospredict)\n        # print(\"Accuracy with all fraud results is \" + str(accuracy_positive * 100) + \"%\")\n        return accuracy_positive"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_496","text":"import numpy as np\n\nimport torch\n\nfrom scipy.stats import wasserstein_distance\n\nfrom generate.metrics import ca_metrics, amino_acid_metrics, secondary_sequence_metrics\n\nclass MMD:\n    \"\"\"\n    Compute the Maximum Mean Discrepancy (MMD) between the predicted graph and a set of target ones.\n\n    Graph statistics include amino acid sequence information and secondary structure sequence information.\n\n    Source\n    ------\n    https:\/\/torchdrift.org\/notebooks\/note_on_mmd.html\n\n    Attributes\n    ----------\n    pred_graph : (torch.Tensor, torch.Tensor)\n        The predicted graph consisting of the predicted node features and the predicted distance matrix.\n    target_graphs : list of (torch.Tensor, torch.Tensor)\n        The target graphs, where each entry consists of the node features and the distance matrix.\n    median_subset : int\n        The size of the subset to use to compute `sigma`.\n    \"\"\"\n\n    def __init__(self, pred_graph, target_graphs, median_subset=100):\n        \"\"\"\n        Initialize the class.\n\n        Parameters\n        ----------\n        pred_graph : (torch.Tensor, torch.Tensor)\n            The predicted graph consisting of the predicted node features and the predicted distance matrix.\n        target_graphs : list of (torch.Tensor, torch.Tensor)\n            The target graphs, where each entry consists of the node features and the distance matrix.\n        median_subset : int, optional\n            The size of the subset to use to compute `sigma`. The default is 100.\n        \"\"\"\n        self.pred_graph = pred_graph\n        self.target_graphs = target_graphs\n        self.median_subset = median_subset\n\n    def _wasserstein_kernel(self, x, y, sigma):\n        x_flat, y_flat = x.detach().view(-1), y.detach().view(-1)\n        return torch.exp(wasserstein_distance(x_flat, y_flat)\/2*(sigma**2))\n\n    def _mmd(self, x, y):\n        # Get number of samples\n        n, m = x.shape[0], y.shape[0]\n        # Compute sigma\n        dists = torch.pdist(torch.cat([x.detach(), y.detach()], dim=0)[:,None])\n        sigma = dists[:self.median_subset].median()\/2\n        # Compute the mmd\n        xx, yy, xy = 0, 0, 0\n        for i in range(n):\n            for j in range(n):\n                xx += self._wasserstein_kernel(x[i], x[j], sigma)\n        for i in range(m):\n            for j in range(m):\n                yy += self._wasserstein_kernel(y[i], y[j], sigma)\n        for i in range(n):\n            for j in range(m):\n                xy += self._wasserstein_kernel(x[i], y[j], sigma)\n        return xx + yy - 2*xy\n\n    def compare_graphs(self):\n        \"\"\"\n        Compare the graphs.\n\n        Returns\n        -------\n        scores : numpy.ndarray\n            The comparison scores.\n        \"\"\"\n        scores = []\n        # Compute MMD score of the predicted graph\n        x_aa = amino_acid_metrics(self.pred_graph[0])\n        x_ss = secondary_sequence_metrics(self.pred_graph[0])\n        x = torch.cat((x_aa,x_ss))\n        for target_graph in self.target_graphs:\n            y_aa = amino_acid_metrics(target_graph[0])\n            y_ss = secondary_sequence_metrics(target_graph[0])\n            y = torch.cat((y_aa,y_ss))\n            # Compare\n            scores.append(self._mmd(x, y))\n        scores = np.array(scores)\n        return scores\n\nclass QCP:\n    \"\"\"\n    Compute the superimposition RMSD of the predicted atoms against validation ones.\n\n    The idea of this control is that if the overall RMSD is low, then the generated protein is likely to be\n    realistic.\n\n    Attributes\n    ----------\n    pred_coords : numpy.ndarray\n        The coordinates of the generated C-alpha atoms.\n    target_proteins : list of Bio.PDB.Structure\n        The list of target proteins.\n    \"\"\"\n\n    def __init__(self, pred_coords, target_proteins):\n        \"\"\"\n        Initialize the class.\n\n        Parameters\n        ----------\n        pred_coords : torch.tensor\n            The coordinates of the generated C-alpha atoms. The input should be a PyTorch tensor, which it then\n            converted to a Numpy array.\n        target_proteins : list of Bio.PDB.Structure\n            The list of target proteins.\n        \"\"\"\n        self.pred_coords = pred_coords\n        self.target_proteins = target_proteins\n\n    def _get_target_ca_atoms_coords(self):\n        target_coords_list = []\n        for protein in self.target_proteins:\n            coords = []\n            for model in protein:\n                for chain in model:\n                    for residue in chain:\n                        if 'CA' in residue:\n                            coords.append(residue['CA'].get_coord())\n            target_coords_list.append(np.array(coords))\n        return target_coords_list\n\n    def _get_shifted_coords(self, coords_long, coords_short):\n        shifted_coords, i = [], 0\n        while i + len(coords_short) <= len(coords_long):\n            shifted_coords.append(coords_long[i:i+len(coords_short)])\n            i += 1\n        return shifted_coords\n\n    def superimpose(self):\n        \"\"\"\n        Compute the superimposition.\n\n        Returns\n        -------\n        numpy.ndarray\n            The array of RMSD scores (each i-th entry corresponds to the comparison of the generated atoms with the\n            i-th protein)\n        \"\"\"\n        scores = []\n        target_coords_list = self._get_target_ca_atoms_coords()\n        for target_coords in target_coords_list:\n            if len(target_coords) == len(self.pred_coords):\n                scores.append(ca_metrics(target_coords, self.pred_coords))\n            elif len(target_coords) > len(self.pred_coords):\n                shifted_coords = self._get_shifted_coords(target_coords, self.pred_coords)\n                rmsds = []\n                for scs in shifted_coords:\n                    rmsds.append(ca_metrics(scs, self.pred_coords))\n                scores.append(np.min(np.array(rmsds)))\n            else:\n                shifted_coords = self._get_shifted_coords(self.pred_coords, target_coords)\n                rmsds = []\n                for scs in shifted_coords:\n                    rmsds.append(ca_metrics(target_coords, scs))\n                scores.append(np.min(np.array(rmsds)))\n        scores = np.array(scores)\n        return scores"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_497","text":"import itertools\nfrom functools import partial\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.stats\n\n# --- Preliminaries ---\n\n# - Partitioning techniques -\nclass BestSolutionHolder:\n    \"\"\"\n        Keeps in memory the best solution of a partitioning technique,\n        is used in the function below.\n    \"\"\"\n    def __init__(self, crit, n_pos, n_neg, frontier, orient,\n                 left_n_right=False, n_pos_tot=None, n_neg_tot=None):\n        self.crit = crit\n        self.left_n_right = left_n_right\n        if left_n_right:\n            if n_pos_tot is None or n_neg_tot is None:\n                raise ValueError(\"Please indicate the total number of positives or negatives.\")\n            self.n_pos_tot = n_pos_tot\n            self.n_neg_tot = n_neg_tot\n\n        self.best_val = None\n        self.best_front = None\n        self.best_orient = None\n\n        self.calls = 0\n\n        self.save_sol(n_pos, n_neg, frontier, orient)\n\n    def save_sol(self, n_pos, n_neg, frontier, orient):\n        \"\"\"Saves a proposition as solution if it is better than before.\"\"\"\n        self.calls += 1\n\n        val = self.crit(n_pos, n_neg)\n\n        if self.best_val is None or val > self.best_val:\n            self.best_val = val\n            self.best_front = frontier\n            self.best_orient = orient\n\n        if self.left_n_right:\n            val = self.crit(self.n_pos_tot - n_pos, self.n_neg_tot - n_neg)\n\n            if self.best_val is None or val > self.best_val:\n                self.best_val = val\n                self.best_front = frontier\n                self.best_orient = not orient\n\ndef bipart_partition(X, Y, criterion, epsilon=0.001):\n    \"\"\"\n    Takes values in R associated to a class in {-1, +1}, a criterion that depends solely\n    on the number of positive or negative values in a partition and finds the partition\n    that maximizes the criterion.\n    \"\"\"\n    # crit = lambda np, nn : np - nn\n    n = X.shape[0]\n    n_pos_tot = (Y == +1).sum()\n    n_neg_tot = n - n_pos_tot\n    XY = np.vstack([X, Y]).transpose()\n    sorted_XY = XY[np.argsort(XY[:, 0])]\n    n_pos, n_neg = 0, 0\n    best_value = BestSolutionHolder(criterion, n_pos, n_neg, sorted_XY[0, 0]-epsilon, False,\n                                    left_n_right=True, n_pos_tot=n_pos_tot, n_neg_tot=n_neg_tot)\n    i = 0\n    for xy, xyp in zip(sorted_XY, sorted_XY[1:]):\n        x, y = xy\n        xp, yp = xyp\n        frontier = (x + xp)\/2\n        # assumed the density of X continuous hence xp > x\n        n_pos += int(y == +1)\n        n_neg += int(y == -1)\n        best_value.save_sol(n_pos, n_neg, frontier, False)\n        i += 1\n\n    frontier = xp + epsilon\n    n_pos += int(yp == +1)\n    n_neg += int(yp == -1)\n    best_value.save_sol(n_pos, n_neg, frontier, False)\n    return best_value.best_front, best_value.best_val, best_value.best_orient\n\n# - Plotting utils -\n\ndef plot_eta(a_collection, param_fun, n_points=100):\n    \"\"\"\n    Plots a family of functions defined on [0,1] indexed by a\n    for a set of possible values for a.\n    \"\"\"\n    plt.figure(figsize=(4, 4))\n\n    x_ax = np.linspace(0., 1., n_points)\n\n    for a in a_collection:\n        eta_fun = partial(param_fun, a=a)\n        plt.plot(x_ax, list(map(eta_fun, x_ax)),\n                 label=\"$a = {:0.2f}$\".format(a))\n\n    plt.title(r\"The function $\\eta_a$ for different a\")\n    plt.xlabel(\"x\")\n    plt.ylabel(r\"$\\eta_a$(x)\")\n    plt.grid()\n    plt.legend()\n    plt.show()\n\ndef plot_distribution(a_collection, gen_datafun):\n    \"\"\"\n    Plots the distributions induced by posterior probability functions defined on [0,1]\n    indexed by a for a set of possible values for a.\n    \"\"\"\n    plt.figure(figsize=(8, 10))\n\n    for i, a in enumerate(a_collection):\n        plt.subplot(5, 2, i + 1)\n\n        X, Y = gen_datafun(n=500, a=a)\n        plt.grid()\n        plt.hist(X[Y == -1], bins=30, color=\"red\", normed=True, alpha=0.5)\n        plt.hist(X[Y == 1], bins=30, color=\"green\", normed=True, alpha=0.5)\n        plt.title(\"Sample distribution, $a = {:2.2f}$\".format(a))\n    plt.tight_layout()\n    plt.show()\n\ndef GetSlope(df_int, quant_val=0.9):\n    \"\"\"\n    Gets the slope corresponding to the log of a quantile of\n    the generalization error regressed by the logarithm of n, number of data points.\n    Parameters:\n    * df_int: Dataframe containing the columns \"n\" and \"gen_error\"\n        with enough entries for each value of \"n\".\n    * quant_val: quantile value that we choose.\n    Returns:\n    * constant, slope: values in R.\n    \"\"\"\n    groupby_quant = df_int.groupby(\"n\").quantile(quant_val)\n    vals_med = groupby_quant[\"gen_error\"].values\n    ns = df_int[\"n\"].unique()\n    reg = scipy.stats.linregress(np.log(ns), np.log(vals_med))\n    return np.exp(reg.intercept), reg.slope\n\ndef boxplot_slopes(df, quant=0.5, ylim=[10**(-4), 10**(0)]):\n    \"\"\"\n    Does a boxplot for each a of the results, to show the different generalization speeds.\n    Parameters:\n    * df: Dataframe containing the columns \"a\", \"n\" and \"gen_error\"\n        with enough entries for each values of \"n\",\"a\".\n    * quant_val: quantile value that we choose to regress the empirical generalization speed.\n    \"\"\"\n    plt.figure(figsize=(20, 12))\n\n    x_n_plots = len(df[\"a\"].unique())\/\/2 + 1\n    for i, a in enumerate(df[\"a\"].unique()):\n        df_int = df[df[\"a\"] == a]\n        ns = df_int[\"n\"].unique()\n        bxplt_vals = [df_int[df_int[\"n\"] == n_val][\"gen_error\"].values\n                      for n_val in df_int[\"n\"].unique()]\n\n        correct_width = [5] + list(map(lambda x: x \/ 4, ns[1:]))\n        plt.subplot(x_n_plots, 4, i + 1)\n        plt.boxplot(bxplt_vals, positions=ns,\n                    widths=correct_width)\n        plt.xscale(\"log\")\n        plt.yscale(\"log\")\n\n        reg_med_const, reg_med_slope = GetSlope(df_int, quant_val=quant)\n\n        plt.plot(ns, reg_med_const * np.power(ns, reg_med_slope), '-b')\n\n        theo_slope = -1. \/ (2. - a)\n        plt.plot(ns, 10**(theo_slope * np.log10(ns)), '-g')\n\n        plt.title(\"Experiment $a = {:1.1f}$\\nSlope med (blue): ${:0.2f}$\\n\".format(\n            a, reg_med_slope) + \"Theoretical bound slope (green) : ${:0.2f}$\".format(\n                theo_slope))\n        plt.ylim(ylim)\n\n        plt.xlabel(\"$n$\")\n        plt.ylabel(\"Regret\")\n        plt.grid()\n\n    plt.tight_layout()\n\n    plt.show()\n\n\ndef slopes_quants(df, quant_values=np.linspace(0.7, 0.9, 5)):\n    \"\"\"\n    Compares the theoretical generalization slope and the empirical generalization slope.\n    Parameters:\n    * df: Dataframe containing the columns \"a\", \"n\" and \"gen_error\"\n        with enough entries for each values of \"n\",\"a\".\n    * quant_values: quantile values that we choose to regress the empirical generalization speed.\n    \"\"\"\n    plt.figure(figsize=(8, 15))\n    a_collection = df[\"a\"].unique()\n\n    theo_slopes = [-1. \/ (2. - a) for a in a_collection]\n    emp_vals = []\n\n    for i, quant in enumerate(quant_values):\n        reg_med_slopes = list()\n        for a in a_collection:\n            df_int = df[df[\"a\"] == a]\n            reg_med_slopes.append(GetSlope(df_int, quant_val=quant)[1])\n        emp_vals.append(reg_med_slopes)\n        plt.subplot(5, 2, i + 1)\n        plt.plot(theo_slopes, reg_med_slopes, \"bo\")\n        plt.plot([-1, -0.5], [-1, -0.5], color=\"red\")\n        plt.xlabel(\"Theoretical slopes\")\n        plt.ylabel(\"Experimental slopes\\n(quantile at ${:2.2f}$)\".format(quant))\n        plt.grid()\n\n    plt.tight_layout()\n\n    plt.show()\n\ndef grid_count(grid, X):\n    \"\"\"Counts the number of elements on a grid.\"\"\"\n    del_elems = X < grid[0]\n    remaining_X = X[~del_elems]\n    res = list()\n    for thre in grid[1:]:\n        del_elems = remaining_X < thre\n        remaining_X = X[~del_elems]\n        res.append(del_elems.sum())\n    return res\n\ndef plot_select_eta(a_collection, eta_fun_of_a, datagen_fun_of_a, n=1000,\n                    n_points=100, n_bins=20):\n    \"\"\"\n        Plots the empirical distribution of the data, as well as the theoretical\n        distribution of it.\n    \"\"\"\n    x_ax = np.linspace(0., 1., n_points)\n\n    grid = np.linspace(0., 1., n_bins+1)\n    sizebin = grid[1]-grid[0]\n    plt.figure(figsize=(12, 6))\n    for i, a in enumerate(a_collection):\n        ax1 = plt.subplot(1, 2, i + 1)\n\n        eta_fun = lambda x, a=a: 2*eta_fun_of_a(x, a=a)\n\n        X, Y = datagen_fun_of_a(n=n, a=a)\n        gridXpos = grid_count(grid, X[Y == +1])\n        gridXneg = grid_count(grid, X[Y == -1])\n        ax2 = ax1.twinx()\n        ax2.bar(grid[0:n_bins], gridXpos, width=sizebin, align=\"edge\",\n                color=\"green\", alpha=0.5, label=\"class 1\")\n        ax2.bar(grid[0:n_bins], gridXneg, width=sizebin, align=\"edge\",\n                bottom=gridXpos, color=\"red\", alpha=0.5, label=\"class 2\")\n        ax1.plot(x_ax, list(map(eta_fun, x_ax)),\n                 label=r\"$\\mu_1(x)$\", color=\"black\", linewidth=3)\n\n        lines, labels = ax1.get_legend_handles_labels()\n        lines2, labels2 = ax2.get_legend_handles_labels()\n        ax2.legend(lines + lines2, labels + labels2, loc=\"lower right\") # \"upper left\") #\n        if i == 0:\n            ax1.set_ylabel(r\"$\\mu_1(x)$\")\n        else:\n            ax2.set_ylabel(r\"$P_n(X \\in $ bin $  \\; | \\; Y = i)$, $i \\in \\{1,2\\}$\",\n                           labelpad=20)\n        plt.title(\"$a = \" + str(a)+\"$\")\n        # if i == 1:\n        ax1.set_xlabel(\"$x$\")\n    plt.tight_layout()\n\ndef plot_possible_alpha_values(min_max_alpha, a_collection, m, alpha, sup_inc_simrank=False):\n    \"\"\"\n    Plot the possible alpha values.\n    \"\"\"\n    plt.figure(figsize=(4, 3))\n    zipped_int_alpha = list(map(lambda a: min_max_alpha(a, m), a_collection))\n    inf_alphas = [v[0] for v in zipped_int_alpha]\n    sup_alphas = [v[1] for v in zipped_int_alpha]\n    plt.plot(a_collection, inf_alphas, label=\"min for $\\\\alpha$ ($C>0$)\")\n    plt.plot(a_collection, sup_alphas, label=\"max for $\\\\alpha$ ($C<1\/2$)\")\n    plt.plot(a_collection, [alpha]*len(a_collection), label=\"chosen $\\\\alpha$ \")\n    if sup_inc_simrank: # Only for the similarity ranking case.\n        sup_inc = [0.5 - 0.5*np.power(np.abs(2*m-1), (1-a)\/a) for a in a_collection]\n        plt.plot(a_collection, sup_inc, label=r\"$\\eta$ increasing\")\n    plt.xlabel(\"$a$\")\n    plt.ylabel(\"$\\\\alpha$\")\n    plt.title(\"Limitations on the possible value for $\\\\alpha$\")\n    plt.legend()\n    plt.grid()\n    plt.show()\n\ndef plot_emp_mammen(gendata_fun_of_a, eta_fun_of_a, a_collection, n_obs=1000, simrank=False):\n    \"\"\"\n    Tries and show visually what the Mammen-Tsybakov assumption means.\n    \"\"\"\n    plt.figure(figsize=(3, 3))\n\n    for a in a_collection:\n        X, _ = gendata_fun_of_a(n=n_obs, a=a)\n\n        if simrank:\n            all_pairs = itertools.combinations(X, 2)\n            all_vals = list(map(lambda x, a=a: abs(eta_fun_of_a(x[0], x[1], a=a)-0.5), all_pairs))\n        else:\n            all_vals = [np.abs(eta_fun_of_a(x, a=a) - 0.5) for x in X]\n\n        plt.hist(all_vals, bins=50, alpha=0.5, cumulative=True,\n                 normed=True, label=\"$a = {:0.2f}$\".format(a))\n\n    plt.title(r\"The distribution of $|\\eta-1\/2|$ for different $a$\")\n    plt.xlabel(r\"$|\\eta-1\/2|$\")\n    plt.ylabel(r\"$P ( X \\le t)$\")\n    plt.legend()\n    plt.grid()\n    plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_498","text":"<filename>phone_display_demo.py\n\"\"\"\r\nCopyright (C) 2011-2012 <NAME>\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy of\r\nthis software and associated documentation files (the \"Software\"), to deal in\r\nthe Software without restriction, including without limitation the rights to\r\nuse, copy, modify, merge, publish, distribute, sublicense, and\/or sell copies\r\nof the Software, and to permit persons to whom the Software is furnished to do\r\nso, subject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all\r\ncopies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\nSOFTWARE.\r\n\r\nDisplays either day or nighttime traffic image processing in a mock-up UI\r\nbased on the HTC Desire smartphone.\r\n\"\"\"\r\nimport numpy as np\r\nimport scipy\r\nimport scipy.ndimage as ndimg\r\nfrom collections import deque\r\nfrom copy import *\r\nimport PIL\r\nimport ImageOps\r\nimport pylab\r\nimport cv2\r\nimport os\r\nimport fnmatch\r\nimport sys\r\nimport pymorph\r\nimport night\r\nimport day\r\nimport argparse\r\n\r\nclass PhoneDemo(object):\r\n    \"\"\" Object to run the phone UI demo. \"\"\"\r\n\r\n    TYPE_DAY = \"DAY\"\r\n    TYPE_NIGHT = \"NIGHT\"\r\n    HISTORY_FRAMES = 600\r\n\r\n    class DayProcessor(object):\r\n        \"\"\" Object used to process day sequences. \"\"\"\r\n\r\n        GMM_K = 3\r\n        GMM_NUM_FRAMES = 25\r\n        GMM_W_INIT = 0.1\r\n        GMM_VAR_INIT = 20\r\n        GMM_MAHA_THRESH = 3\r\n        MASK_OVERLAY_ALPHA = 0.4\r\n\r\n        def __init__(self, rgb):\r\n\r\n            assert(rgb.dtype == 'uint8')\r\n\r\n            self._gmm = day.GaussianMixtureModelUV(self.GMM_K, rgb.shape,\r\n                                                   self.GMM_NUM_FRAMES,\r\n                                                   self.GMM_W_INIT,\r\n                                                   self.GMM_VAR_INIT,\r\n                                                   self.GMM_MAHA_THRESH)\r\n            self._ycbcr = np.zeros(rgb.shape, dtype='uint8')\r\n            self._mask = np.zeros(rgb.shape[:2], dtype='uint8')\r\n            self._red_mask = np.zeros(rgb.shape, dtype='uint8')\r\n            self._rgb_red_masked = np.zeros(rgb.shape, dtype='uint8')\r\n            self._process_count = 0\r\n\r\n        def next(self, rgb):\r\n            \"\"\" Process the next file and return the results. \"\"\"\r\n\r\n            # Do GMM steps.\r\n            self._gmm.rgb2ycbcr(rgb, self._ycbcr)\r\n            self._gmm.segment_cl(self._mask)\r\n            self._gmm.update_cl(self._ycbcr)\r\n            # Save total pixels in foreground.\r\n            fg_pixel_count = np.sum(self._mask)\r\n            # Pull alpha and render red overlay\r\n            # (channels are reversed RGB = BGR).\r\n            self._red_mask[:,:,2] = self._mask * 255\r\n            self._rgb_red_masked[:,:] = \\\r\n                (self.MASK_OVERLAY_ALPHA * self._red_mask) + \\\r\n                ((1. - self.MASK_OVERLAY_ALPHA) * rgb)\r\n\r\n            # Ignore the first GMM_NUM_FRAMES \/ 2 frames.\r\n            self._process_count = self._process_count + 1\r\n            if self._process_count > self.GMM_NUM_FRAMES \/ 2:\r\n                return fg_pixel_count, self._rgb_red_masked\r\n            else:\r\n                return 0, self._rgb_red_masked\r\n\r\n\r\n    class NightProcessor(object):\r\n        \"\"\" Object used to process day sequences. \"\"\"\r\n\r\n        def __init__(self, rgb):\r\n\r\n            pass\r\n\r\n        def next(self, rgb):\r\n            \"\"\" Process the next file and return the results. \"\"\"\r\n\r\n            def blackout_date_regions(image, blackout_rects):\r\n                \"\"\" Black out specified regions. \"\"\"\r\n\r\n                for rect in blackout_rects:\r\n                    image[rect[1]:rect[3], rect[0]:rect[2]] = 0\r\n\r\n            # Do bright object detection.\r\n            blackout_date_regions(rgb, night.BLACKOUT_RECTS)\r\n            steps = night.bright_object_detection(rgb)\r\n            # Return results (channels are reversed RGB = BGR).\r\n            label_img = pymorph.overlay(steps['luminance'].astype('uint8'),\r\n                                        blue=steps['detect_dilate'])\r\n            return steps['bright_blob_count'], label_img\r\n\r\n\r\n    def __init__(self):\r\n\r\n      # Initialize plotting parameters.\r\n      self._history_raw = deque()\r\n      self._history_filtered = deque()\r\n      self._max_sample = 0.001\r\n      self._ui = PhoneDisplay()\r\n      self._filter_exp = 0.1\r\n      self._sample_exp_filter = 0.\r\n\r\n    def run_sequence(self, type, filepath, seq_range=None, filter_exp=None):\r\n        \"\"\" Run a TYPE_DAY or TYPE_NIGHT sequence. \"\"\"\r\n\r\n        QUIT_KEY_CODES = [ 27, 113, 81 ]\r\n        PAUSE_KEY_CODES = [ 32, 112, 80 ]\r\n\r\n        def pause():\r\n            \"\"\" Poll input until the pause key is pressed. \"\"\"\r\n\r\n            while True:\r\n                key = cv2.waitKey(100)\r\n                if PAUSE_KEY_CODES.count(key) > 0:\r\n                    break\r\n\r\n        def bound_queue_push(val, q, maxlen=None):\r\n            \"\"\" Push to bounded queue. \"\"\"\r\n\r\n            q.append(val)\r\n            if maxlen is not None and len(q) > maxlen:\r\n                q.popleft()\r\n\r\n        assert(type == self.TYPE_DAY or type == self.TYPE_NIGHT)\r\n\r\n        # TODO(reissb) -- The history frames and filtering need to become\r\n        #   parameterized in some way. The history frames is fixed by the\r\n        #   camera framerate. The filtering is fixed by the required\r\n        #   detection sensitivity.\r\n        if filter_exp is not None:\r\n            self._filter_exp = filter_exp\r\n        else:\r\n            self._filter_exp = 0.1\r\n\r\n        # Clear state.\r\n        self._ui.clear()\r\n        self._history_raw = deque()\r\n        self._history_filtered = deque()\r\n        self._max_sample = 0.001\r\n        self._sample_exp_filter = 0.\r\n\r\n        # Extract command-line parameters. This is the name of one file in the\r\n        # series.\r\n        path, filename = os.path.split(filepath)\r\n        file_name, file_ext = os.path.splitext(os.path.basename(filename))\r\n        series_name_end = file_name.rindex('_')\r\n        series_name = file_name[:series_name_end]\r\n        print \"Processing image series {0} in path {1}.\".format(series_name,\r\n                                                                path)\r\n        files_in_path = os.listdir(path)\r\n        series_pattern = series_name + '_[0-9]*' + file_ext\r\n        print \"Processing files matching pattern {0}.\".format(series_pattern)\r\n        series_suffixes = [int(os.path.splitext(fn)[0].split('_')[-1]) \\\r\n                           for fn in files_in_path \\\r\n                           if fnmatch.fnmatch(fn, series_pattern)]\r\n        series_suffixes.sort()\r\n        num_files = len(series_suffixes)\r\n        print \"Found {0} files in image series {1}.\".format(num_files,\r\n                                                            series_name)\r\n        # Check for limited range.\r\n        if seq_range is not None:\r\n            assert(seq_range[1] > seq_range[0] and seq_range[0] >= 0)\r\n            print \"Filtering series range [{},{}).\".format(seq_range[0],\r\n                                                           seq_range[1])\r\n            series_suffixes = np.array(series_suffixes)\r\n            f = (series_suffixes >= seq_range[0]) * \\\r\n                (series_suffixes < seq_range[1])\r\n            series_suffixes = np.sort(series_suffixes * f)\r\n            remove_count = len(series_suffixes) - np.sum(f)\r\n            series_suffixes = np.delete(series_suffixes, range(remove_count))\r\n\r\n        # Load first file and process.\r\n        series_filename = series_name + '_' + str(series_suffixes[0]) + \\\r\n                          file_ext\r\n        rgb = ndimg.imread(os.path.join(path, series_filename))\r\n        # Initilaize the processor.\r\n        type_processor = self.DayProcessor(rgb) if type is self.TYPE_DAY \\\r\n                         else self.NightProcessor(rgb)\r\n        # Process the files.\r\n        quit_flag = False\r\n        process_count = 0\r\n        history_n = int(self.HISTORY_FRAMES \/ \\\r\n                        (self._ui.history_frame_count - 1))\r\n        for suffix in series_suffixes:\r\n            # Process the next file.\r\n            series_filename = series_name + '_' + str(suffix) + file_ext\r\n            print \"Processing file {0}.\".format(series_filename)\r\n            rgb = ndimg.imread(os.path.join(path, series_filename))\r\n            sample_raw, display_img = type_processor.next(rgb)\r\n            self._sample_exp_filter = \\\r\n                ((1. - self._filter_exp) * self._sample_exp_filter) + \\\r\n                (self._filter_exp * sample_raw)\r\n            # Put new samples on queues.\r\n            bound_queue_push(sample_raw,\r\n                             self._history_raw, self.HISTORY_FRAMES)\r\n            bound_queue_push(self._sample_exp_filter,\r\n                             self._history_filtered, self.HISTORY_FRAMES)\r\n            # Update UI.\r\n            self._max_sample = max(self._max_sample,\r\n                                   self._sample_exp_filter * 1.1)\r\n            ybound = (0, self._max_sample)\r\n            plot_img = self.plot_history(self._history_raw,\r\n                                         self._history_filtered,\r\n                                         ybound)\r\n            self._ui.set_main_video_frame(display_img)\r\n            self._ui.set_plot(plot_img)\r\n            # Space history frames evenly over interval.\r\n            if 0 == (process_count % history_n):\r\n                self._ui.push_history_frame(display_img)\r\n            process_count = process_count + 1\r\n            # Show UI.\r\n            cv2.imshow(\"Phone Display\", self._ui.ui_image)\r\n            key = cv2.waitKey(1)\r\n            # Catch escape or 'q' or 'Q':\r\n            if QUIT_KEY_CODES.count(key) > 0:\r\n                quit_flag = True\r\n                break\r\n            # Catch spacebar, 'p' or 'P':\r\n            if PAUSE_KEY_CODES.count(key) > 0:\r\n                pause()\r\n\r\n        # Cleanup GUI on complete.\r\n        if not quit_flag:\r\n            cv2.waitKey(-1)\r\n        cv2.destroyAllWindows()\r\n\r\n    @staticmethod\r\n    def plot_history(raw, filtered, ybound):\r\n        \"\"\" Make plot of raw and history and return as image. \"\"\"\r\n\r\n        p = pylab.subplot('111')\r\n        p.clear()\r\n        p.figure.set_size_inches(4, 3);\r\n        p.plot(raw, '.r')\r\n        p.plot(filtered, '-b')\r\n        p.axes.set_ybound(ybound)\r\n        p.figure.canvas.draw()\r\n        buf = np.fromstring(p.figure.canvas.tostring_rgb(), dtype='uint8')\r\n        h, w = p.figure.canvas.get_width_height()\r\n        buf.shape = (w, h, 3)\r\n        return buf\r\n\r\n\r\nclass PhoneDisplay(object):\r\n\r\n    # Dictionary of UI resources.\r\n    RESOURCES = {\r\n        # Name of the phone UI image.\r\n        \"UI_BASE\": \"ui_base.jpg\"\r\n        }\r\n    # Coordinates for the phone image display area.\r\n    UI_LAYOUT = {\r\n        \"MARGIN\": 15,\r\n        \"DISPLAY_RECT\": { \"UpperLeft\": (255, 59), \"LowerRight\": (1106, 596) },\r\n        \"MAIN_VIDEO_SIZE\": (360, 480),\r\n        \"PLOT_SIZE\": (240, 320),\r\n        \"HISTORY_FRAME_COUNT\": 5,\r\n        \"CLEAR_COLOR\": np.array([60, 85, 45])\r\n        }\r\n\r\n    def __init__(self):\r\n        \"\"\" Setup phone UI. \"\"\"\r\n\r\n        # Load UI base resource and set slice of display area.\r\n        self._ui_base = ndimg.imread(self.RESOURCES[\"UI_BASE\"])\r\n        up_lt = self.UI_LAYOUT[\"DISPLAY_RECT\"][\"UpperLeft\"]\r\n        lw_rt = self.UI_LAYOUT[\"DISPLAY_RECT\"][\"LowerRight\"]\r\n        self._ui_display_area = self._ui_base[up_lt[1]:lw_rt[1] + 1,\r\n                                              up_lt[0]:lw_rt[0] + 1]\r\n        self._ui_display_area[:,:] = self.UI_LAYOUT[\"CLEAR_COLOR\"]\r\n        self._ui_display_area_size = self._ui_display_area.shape[:2]\r\n        self._ui_main_video_size = self.UI_LAYOUT[\"MAIN_VIDEO_SIZE\"]\r\n        self._plot_size = self.UI_LAYOUT[\"PLOT_SIZE\"]\r\n\r\n        margin = self.UI_LAYOUT[\"MARGIN\"]\r\n        # Get main video frame area.\r\n        vid_frm_x1 = self._ui_display_area_size[1] - margin\r\n        vid_frm_x0 = vid_frm_x1 - self._ui_main_video_size[1]\r\n        vid_frm_y0 = margin\r\n        vid_frm_y1 = vid_frm_y0 + self._ui_main_video_size[0]\r\n        self._ui_main_video_frame = self._ui_display_area[vid_frm_y0:\r\n                                                          vid_frm_y1,\r\n                                                          vid_frm_x0:\r\n                                                          vid_frm_x1]\r\n        # Get plot area.\r\n        plt_frm_x0 = margin\r\n        plt_frm_x1 = plt_frm_x0 + self._plot_size[1]\r\n        plt_frm_y0 = margin\r\n        plt_frm_y1 = plt_frm_y0 + self._plot_size[0]\r\n        self._ui_plot_frame = self._ui_display_area[plt_frm_y0: plt_frm_y1,\r\n                                                    plt_frm_x0: plt_frm_x1]\r\n        # Compute history frame areas.\r\n        his_frm_count = self.UI_LAYOUT[\"HISTORY_FRAME_COUNT\"]\r\n        his_frm_wid = int((self._ui_display_area_size[1] -\r\n                          ((his_frm_count + 1)  * margin)) \/ his_frm_count)\r\n        his_frm_ht = int((3.\/4.) * his_frm_wid)\r\n        self._ui_history_frame_size = (his_frm_ht, his_frm_wid)\r\n        his_frm_y0 = (2 * margin) + self._ui_main_video_size[0]\r\n        his_frm_x0_fn = lambda n: margin + ((margin + his_frm_wid) * n)\r\n        his_frm_x1_fn = lambda n: (margin + his_frm_wid) * (n + 1)\r\n        self._ui_history_frames = map(\r\n            lambda n: self._ui_display_area[\r\n                his_frm_y0: his_frm_y0 + his_frm_ht,\r\n                his_frm_x0_fn(n):his_frm_x1_fn(n)],\r\n            range(self.UI_LAYOUT[\"HISTORY_FRAME_COUNT\"]))\r\n\r\n    def clear_display_area(self, color=np.array([0, 0, 0])):\r\n        \"\"\" Clear UI base display area to given color. \"\"\"\r\n\r\n        self._ui_display_area[:,:] = color\r\n\r\n    def set_main_video_frame(self, frame):\r\n        \"\"\" Set the main video frame in the UI layout. \"\"\"\r\n\r\n        h, w = self._ui_main_video_size\r\n        img = np.array(ImageOps.fit(PIL.Image.fromarray(frame), (w, h)))\r\n        self._ui_main_video_frame[:,:] = img\r\n\r\n    def push_history_frame(self, frame):\r\n        \"\"\" Push a frame to the top of the history images. \"\"\"\r\n\r\n        # Shift back.\r\n        for n in range(len(self._ui_history_frames) - 1):\r\n            self._ui_history_frames[n][:,:] = self._ui_history_frames[n+1][:,:]\r\n        # Update.\r\n        h, w = self._ui_history_frame_size\r\n        img = np.array(ImageOps.fit(PIL.Image.fromarray(frame), (w, h)))\r\n        self._ui_history_frames[-1][:,:] = img\r\n\r\n    def set_plot(self, plot):\r\n        \"\"\" Set the plot image in the UI layout. \"\"\"\r\n\r\n        h, w = self._plot_size\r\n        img = np.array(ImageOps.fit(PIL.Image.fromarray(plot), (w, h)))\r\n        self._ui_plot_frame[:,:] = img\r\n\r\n    def clear(self):\r\n        \"\"\" Reset the UI. \"\"\"\r\n\r\n        ui_base = ndimg.imread(self.RESOURCES[\"UI_BASE\"])\r\n        self._ui_base[:,:,:] = ui_base\r\n        self._ui_display_area[:,:] = self.UI_LAYOUT[\"CLEAR_COLOR\"]\r\n\r\n    def get_ui_image(self):\r\n        return self._ui_base\r\n    def get_history_frame_count(self):\r\n        return len(self._ui_history_frames)\r\n\r\n    ui_image = property(get_ui_image, doc=\"The main display image.\")\r\n    history_frame_count = property(get_history_frame_count,\r\n                                   doc=\"Count of history frames.\")\r\n\r\n\r\ndef main():\r\n    #  Parse arguments for\r\n    #    PhoneDemo.run_sequence(type, filepath, seq_range, filter_exp):\r\n    parser = argparse.ArgumentParser(description='Run a UI demo of ' +\r\n                                                 'image-based traffic ' +\r\n                                                 'analysis algorithms.')\r\n    parser.add_argument('SEQUENCE_TYPE', type=str, choices=('D', 'N'),\r\n                        help='day or night image type')\r\n    parser.add_argument('SEQUENCE_IMAGE_PATH', type=str,\r\n                        help='path to an image within sequence')\r\n    parser.add_argument('-r', '--range', default=None, nargs=2, type=int,\r\n                        help='range of frames to process as in \\'-r 0 100\\'')\r\n    parser.add_argument('-e', '--filter_exp', default=None, type=float,\r\n                        help='exponential filter strength')\r\n    args = parser.parse_args(sys.argv[1:])\r\n    demo = PhoneDemo()\r\n    demo.run_sequence(PhoneDemo.TYPE_DAY if 'D' == args.SEQUENCE_TYPE\r\n                                         else PhoneDemo.TYPE_NIGHT,\r\n                      args.SEQUENCE_IMAGE_PATH, args.range, args.filter_exp)\r\n\r\nif __name__ == \"__main__\":\r\n    main()\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_499","text":"<reponame>loicmiller\/policy-analysis<gh_stars>0\n###############################################################################\n# Imports\n\nimport sys\nimport argparse # Argument parser\n\nfrom mgtoolkit.library import *\nimport networkx as nx\n\nfrom sympy import to_dnf\nfrom sympy.parsing.sympy_parser import parse_expr\n\nimport random # Random indices of list\n\nimport os\n\n\n###############################################################################\n# General utility\n\n# Exit the program\ndef terminate_app(code):\n    print(\"Exiting program...\")\n    sys.exit(code)\n\n\n###############################################################################\n# Argument parser\n\nclass Range(object):\n    def __init__(self, start, end):\n        self.start = start\n        self.end = end\n    def __eq__(self, other):\n        return self.start <= other <= self.end\n\ndef get_parser():\n    # Get parser for command line arguments\n    parser = argparse.ArgumentParser(description=\"Workflow specification to Rego\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n    parser.add_argument(\"--version\", action=\"version\", version='%(prog)s 1.0')\n    parser.add_argument(\"-v\", \"--verbose\", action=\"count\", default=0, help=\"increase output verbosity\")\n    parser.add_argument(\"workflow\", type=str, metavar=\"FILE\", help=\"workflow to generate policy from\")\n    parser.add_argument(\"-e\", \"--error-rate\", type=float, choices=[Range(0.0, 1.0)], metavar=\"ERROR_RATE\", default=0.0, help=\"rate of errors in the generated workflow\")\n\n    return parser\n\n\n###############################################################################\n# Functions\n\n\n###############################################################################\n# Main\n\ndef main(verbose, workflow):\n    global glob_verbose\n    glob_verbose = verbose\n\n    print(\"\\n\\n###############################################################################\")\n    print(\"Loading workflow specification from file\")\n    print(\"###############################################################################\")\n\n    with open(workflow, 'r') as workflow_file:\n        workflow_edges = workflow_file.readlines()\n        workflow_edges = [(set(src.lstrip('{').rstrip('}').split(', ')), set(dst.lstrip('{').rstrip('}').split(', ')), attributes) for src, dst, attributes in (edge.rstrip().split(';') for edge in workflow_edges)]\n\n    if glob_verbose >= 1:\n        print(\"Edges\")\n        for edge in workflow_edges:\n            print(edge)\n\n\n    print(\"\\n\\n###############################################################################\")\n    print(\"Turning workflow graph into metagraph\")\n    print(\"###############################################################################\")\n\n    workflow_variables_set = set()\n    workflow_propositions_set = set()\n    workflow_edges_set = []\n\n    # Simplify boolean expressions (Use simpy) https:\/\/stackoverflow.com\/questions\/52416781\/how-to-simplify-these-boolean-statements\n    for src, dst, attributes in workflow_edges:\n        if glob_verbose >= 2:\n            print(\"Edge: {} {} {}\".format(src, dst, attributes))\n\n        # Add src and dst to variable set if they are not present yet\n        workflow_variables_set.update(src)\n        workflow_variables_set.update(dst)\n\n\n        # Parse policy into expression for simpy\n        if attributes:\n            edge_policy = parse_expr(attributes)\n            if glob_verbose >= 2:\n                print(\"Edge policy: {}\".format(edge_policy))\n\n            # Convert policy to Disjunctive Normal Form (DNF)\n            # I think we don't want to simplify the expression for the comparison\n            # since it is not simplified in the metagraph generated from the policy\n            # https:\/\/en.wikipedia.org\/wiki\/Disjunctive_normal_form\n            # https:\/\/docs.sympy.org\/latest\/modules\/logic.html\n            # https:\/\/docs.sympy.org\/latest\/modules\/parsing.html\n            edge_policy_dnf = to_dnf(edge_policy, simplify=False)\n            if glob_verbose >= 2:\n                print(\"DNF: {}\".format(edge_policy_dnf))\n\n\n            # Metagraph nodes\n            # Each element in metagraph_nodes is the proposition part of a node in the metagraph\n            metagraph_nodes = str(edge_policy_dnf).split(\"|\")\n            if glob_verbose >= 2:\n                print(\"Metagraph nodes: {}\".format(metagraph_nodes))\n\n            # Policy elements in nodes\n            # Each element is a part of the propositions_set\n            for node_propositions in metagraph_nodes:\n                policy_elements = node_propositions.split('&')\n                policy_elements = [policy_element.strip().lstrip('(').rstrip(')') for policy_element in policy_elements] # Remove leading and trailing whitespaces, plus leading and trailing parentheses\n\n                # Add policy_elements to propositions_set\n                for index, policy_element in enumerate(policy_elements):\n                    # Add ')' back for equalities\n                    if 'Eq' in policy_element:\n                        policy_element = policy_element + ')'\n                        policy_elements[index] = policy_elements[index] + ')'\n                    workflow_propositions_set.add(policy_element)\n                workflow_edges_set.append(Edge(src, dst, attributes=policy_elements))\n\n                if glob_verbose >= 2:\n                    print(\"Policy elements: {}\".format(policy_elements))\n\n            if glob_verbose >= 2:\n                print(\"\\n\")\n        else:\n            workflow_edges_set.append(Edge(src, dst, attributes=\"\"))\n\n\n    if glob_verbose >= 4:\n        print(\"Variables set: {}\".format(workflow_variables_set))\n        print(\"Propositions set: {}\\n\".format(workflow_propositions_set))\n        print(\"Metagraph edges: {}\\n\".format(workflow_edges_set))\n\n    # Create workflow metagraph\n    print(\"Creating workflow metagraph\")\n    workflow_metagraph = ConditionalMetagraph(workflow_variables_set, workflow_propositions_set)\n    workflow_metagraph.add_edges_from(workflow_edges_set)\n\n    if glob_verbose >= 4:\n        print(\"Policy metagraph\\n{}\\n\".format(repr(workflow_metagraph)))\n\n    if glob_verbose >= 4:\n        print(\"Workflow metagraph edges\")\n        print(\"{} {}\".format(\"INVERTEX\", \"OUTVERTEX\"))\n        for edge in workflow_metagraph.edges:\n            print(\"{} {}\".format(list(edge.invertex), list(edge.outvertex)))\n\n    return workflow_metagraph\n\n\n\nif __name__ == '__main__':\n    print(\"\\n\\n###############################################################################\")\n    print(\"Getting arguments\")\n    print(\"###############################################################################\")\n\n    parser = get_parser() # Create a parser\n    args = parser.parse_args() # Parse arguments\n    print(args)\n\n    # Call main\n    main(args.verbose, args.workflow)\n\n    terminate_app(0)\n\n\n###############################################################################\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_500","text":"<gh_stars>1-10\n################################################################################\n#\n# Copyright (c) 2009 The MadGraph5_aMC@NLO Development team and Contributors\n#\n# This file is a part of the MadGraph5_aMC@NLO project, an application which \n# automatically generates Feynman diagrams and matrix elements for arbitrary\n# high-energy processes in the Standard Model and beyond.\n#\n# It is subject to the MadGraph5_aMC@NLO license which should accompany this \n# distribution.\n#\n# For more information, visit madgraph.phys.ucl.ac.be and amcatnlo.web.cern.ch\n#\n################################################################################\nfrom madgraph.core import base_objects\n\"\"\"Methods and classes to import v4 format model files.\"\"\"\n\nimport fractions\nimport logging\nimport os\nimport re\n\nfrom madgraph import InvalidCmd, MG4DIR, ReadWrite\n\nimport madgraph.core.color_algebra as color\nimport madgraph.iolibs.files as files\nimport madgraph.iolibs.save_load_object as save_load_object\n\nimport madgraph.various.misc as misc\n\nfrom madgraph.core.base_objects import Particle, ParticleList\nfrom madgraph.core.base_objects import Interaction, InteractionList\n\nlogger = logging.getLogger('madgraph.import_v4')\n\n#===============================================================================\n# import_v4model\n#===============================================================================\ndef import_model(model_path, mgme_dir = MG4DIR, absolute=True):\n    \"\"\"create a model from a MG4 model directory.\"\"\"\n\n    # Check for a valid directory\n    model_path_old = model_path\n    model_path = find_model_path(model_path, mgme_dir, absolute)\n\n    files_list = [os.path.join(model_path, 'particles.dat'),\\\n                  os.path.join(model_path, 'interactions.dat')]\n    \n    for filepath in files_list:\n        if not os.path.isfile(filepath):\n            if not absolute:\n                raise InvalidCmd,  \"%s directory is not a valid v4 model\" % \\\n                                                                    (model_path)\n            else:\n                return import_model(model_path_old, mgme_dir, False)\n                                                                \n    # use pickle files if defined\n    if files.is_uptodate(os.path.join(model_path, 'model.pkl'), files_list):\n        model = save_load_object.load_from_file( \\\n                                          os.path.join(model_path, 'model.pkl'))\n        if model.has_key('version_tag') and model.get('version_tag') == os.path.realpath(model_path) + str(misc.get_pkg_info()):\n            return model, model_path\n\n    model = base_objects.Model()    \n    model.set('particles',files.read_from_file( \\\n                                  os.path.join(model_path, 'particles.dat'),\n                                  read_particles_v4))\n    \n    model.set('interactions',files.read_from_file( \\\n                                  os.path.join(model_path, 'interactions.dat'),\n                                  read_interactions_v4,\n                                  model['particles']))\n    \n    model.set('name', os.path.split(model_path)[-1])  \n\n    # save in a pickle files to fasten future usage\n    if ReadWrite:\n        try:\n            save_load_object.save_to_file(os.path.join(model_path, 'model.pkl'), model)\n        except Exception:\n            logger.warning(\"fail to write %s. This is perfectly fine will just prevent speed boost in future load of this model\" %\\\n                           os.path.join(model_path, 'model.pkl'))\n    return model, model_path  \n\n    \ndef find_model_path(model_path, mgme_dir, absolute=True):\n    \"\"\"Find the path to the model, starting with path model_path.\"\"\"\n\n    # treat simple case (model_path is a valid path\/ mgme_dir doesn't exist)\n    if os.path.isdir(model_path) and absolute:\n        return model_path\n    elif mgme_dir and os.path.isdir(os.path.join(mgme_dir, 'models',\n                                                 model_path + \"_v4\")):\n        model_path = os.path.join(mgme_dir, 'models', model_path + \"_v4\")\n    elif mgme_dir and os.path.isdir(os.path.join(mgme_dir, 'Models', model_path)):\n        model_path = os.path.join(mgme_dir, 'Models', model_path)\n    elif not mgme_dir:\n        error_text = \"Path %s is not a valid pathname\\n\" % model_path\n        error_text += \"and no MG_ME installation detected in order to search in Models\"\n        raise InvalidCmd(error_text)\n\n    # Try to build the valid path\n    path_possibilities = [os.path.join(mgme_dir, 'Models', model_path),\n                         os.path.join(mgme_dir, 'models', model_path + \"_v4\"),    \n                         os.path.join(mgme_dir, 'models', model_path)            \n                         ]\n\n    for path in path_possibilities:\n        if os.path.exists(path) and \\\n                        not os.path.exists(os.path.join(path, 'particles.py')):\n            return path\n    \n    # No valid path found\n    raise InvalidCmd(\"Path %s is not a valid pathname\" % model_path)\n\n#===============================================================================\n# read_particles_v4\n#===============================================================================\ndef read_particles_v4(fsock):\n    \"\"\"Read a list of particle from stream fsock, using the old v4 format\"\"\"\n\n    spin_equiv = {'s': 1,\n                  'f': 2,\n                  'v': 3,\n                  't': 5}\n\n    color_equiv = {'s': 1,\n                   't': 3,\n                   '6': 6,\n                   'o': 8}\n\n    line_equiv = {'d': 'dashed',\n                  's': 'straight',\n                  'w': 'wavy',\n                  'c': 'curly'}\n\n    logger.info('load particles')\n\n    mypartlist = ParticleList()\n\n    for line in fsock:\n        mypart = Particle()\n\n        if line.find(\"MULTIPARTICLES\") != -1:\n            break # stop scanning if old MULTIPARTICLES tag found\n\n        line = line.split(\"#\", 2)[0] # remove any comment\n        line = line.strip() # makes the string clean\n\n        if line != \"\":\n            values = line.split()\n            if len(values) != 9:\n                # Not the right number tags on the line\n                raise ValueError, \\\n                    \"Unvalid initialization string:\" + line\n            else:\n                try:\n                    mypart.set('name', values[0].lower())\n                    mypart.set('antiname', values[1].lower())\n\n                    if mypart['name'] == mypart['antiname']:\n                        mypart['self_antipart'] = True\n\n                    if values[2].lower() in spin_equiv.keys():\n                        mypart.set('spin',\n                                   spin_equiv[values[2].lower()])\n                    else:\n                        raise ValueError, \"Invalid spin %s\" % \\\n                                values[2]\n\n                    if values[3].lower() in line_equiv.keys():\n                        mypart.set('line',\n                                   line_equiv[values[3].lower()])\n                    else:\n                        raise ValueError, \\\n                                \"Invalid line type %s\" % values[3]\n\n                    mypart.set(\"mass\", values[4])\n                    mypart.set(\"width\", values[5])\n\n                    if values[6].lower() in color_equiv.keys():\n                        mypart.set('color',\n                                   color_equiv[values[6].lower()])\n                    else:\n                        raise ValueError, \\\n                            \"Invalid color rep %s\" % values[6]\n\n                    #mypart.set(\"texname\", values[7])\n                    mypart.set(\"pdg_code\", int(values[8]))\n\n                    mypart.set('charge', 0.)\n                    #mypart.set('antitexname', mypart.get('texname'))\n\n                except (Particle.PhysicsObjectError, ValueError), why:\n                    logger.warning(\"Warning: %s, particle ignored\" % why)\n                else:\n                    mypartlist.append(mypart)\n\n    return mypartlist\n\n\n#===============================================================================\n# read_interactions_v4\n#===============================================================================\ndef read_interactions_v4(fsock, ref_part_list):\n    \"\"\"Read a list of interactions from stream fsock, using the old v4 format.\n    Requires a ParticleList object as an input to recognize particle names.\"\"\"\n\n    logger.info('load interactions')\n    myinterlist = InteractionList()\n\n    if not isinstance(ref_part_list, ParticleList):\n        raise ValueError, \\\n            \"Object %s is not a valid ParticleList\" % repr(ref_part_list)\n\n    for line in fsock:\n        myinter = Interaction()\n\n        line = line.split(\"#\", 2)[0] # remove any comment\n        line = line.strip() # makes the string clean\n\n        if line != \"\": # skip blank\n            values = line.split()\n            part_list = ParticleList()\n\n            try:\n                for str_name in values:\n                    curr_part = ref_part_list.get_copy(str_name.lower())\n                    if isinstance(curr_part, Particle):\n                        # Look at the total number of strings, stop if \n                        # anyway not enough, required if a variable name \n                        # corresponds to a particle! (eg G)\n                        if len(values) >= 2 * len(part_list) + 1:\n                            part_list.append(curr_part)\n                        else: break\n                    # also stops if string does not correspond to \n                    # a particle name\n                    else: break\n\n                if len(part_list) < 3:\n                    raise Interaction.PhysicsObjectError, \\\n                        \"Vertex with less than 3 known particles found.\"\n\n                # Flip part\/antipart of first part for FFV, FFS, FFT vertices\n                # according to v4 convention\n                spin_array = [part['spin'] for part in part_list]\n                if spin_array[:2] == [2, 2] and \\\n                   not part_list[0].get('self_antipart'):\n                    part_list[0]['is_part'] = not part_list[0]['is_part']\n\n                myinter.set('particles', part_list)\n\n                # Give color structure\n                # Order particles according to color\n                # Don't consider singlets\n                color_parts = sorted(enumerate(part_list), lambda p1, p2:\\\n                                     p1[1].get_color() - p2[1].get_color())\n                color_ind = [(i, part.get_color()) for i, part in \\\n                             color_parts if part.get_color() !=1]\n                colors = [c for i,c in color_ind]\n                ind = [i for i,c in color_ind]\n\n                # Set color empty by default\n                myinter.set('color', [])\n                if not colors:\n                    # All color singlets - set empty\n                    pass\n                elif colors == [-3, 3]:\n                    # triplet-triplet-singlet coupling\n                    myinter.set('color', [color.ColorString(\\\n                        [color.T(ind[1], ind[0])])])\n                elif colors == [8, 8]:\n                    # octet-octet-singlet coupling\n                    my_cs = color.ColorString(\\\n                        [color.Tr(ind[0], ind[1])])\n                    my_cs.coeff = fractions.Fraction(2)\n                    myinter.set('color', [my_cs])\n                elif colors == [-3, 3, 8]:\n                    # triplet-triplet-octet coupling\n                    myinter.set('color', [color.ColorString(\\\n                        [color.T(ind[2], ind[1], ind[0])])])\n                elif colors == [8, 8, 8]:\n                    # Triple glue coupling\n                    my_color_string = color.ColorString(\\\n                        [color.f(ind[0], ind[1], ind[2])])\n                    my_color_string.is_imaginary = True\n                    myinter.set('color', [my_color_string])\n                elif colors == [-3, 3, 8, 8]:\n                    my_cs1 = color.ColorString(\\\n                        [color.T(ind[2], ind[3], ind[1], ind[0])])\n                    my_cs2 = color.ColorString(\\\n                        [color.T(ind[3], ind[2], ind[1], ind[0])])\n                    myinter.set('color', [my_cs1, my_cs2])\n                elif colors == [8, 8, 8, 8]:\n                    # 4-glue coupling\n                    cs1 = color.ColorString([color.f(0, 1, -1),\n                                                   color.f(2, 3, -1)])\n                    #cs1.coeff = fractions.Fraction(-1)\n                    cs2 = color.ColorString([color.f(2, 0, -1),\n                                                   color.f(1, 3, -1)])\n                    #cs2.coeff = fractions.Fraction(-1)\n                    cs3 = color.ColorString([color.f(1, 2, -1),\n                                                   color.f(0, 3, -1)])\n                    #cs3.coeff = fractions.Fraction(-1)\n                    myinter.set('color', [cs1, cs2, cs3])\n#   The following line are expected to be correct but not physical validations\n#    have been performed. So we keep it commented for the moment.                    \n#                elif colors == [3, 3, 3]:\n#                    my_color_string = color.ColorString(\\\n#                        [color.Epsilon(ind[0], ind[1], ind[2])])\n#                    myinter.set('color', [my_color_string])                    \n#                elif colors == [-3, -3, -3]:\n#                    my_color_string = color.ColorString(\\\n#                        [color.EpsilonBar(ind[0], ind[1], ind[2])])\n#                    myinter.set('color', [my_color_string])\n                else:\n                    logger.warning(\\\n                        \"Color combination %s not yet implemented.\" % \\\n                        repr(colors))\n\n                # Set the Lorentz structure. Default for 3-particle\n                # vertices is empty string, for 4-particle pair of\n                # empty strings\n                myinter.set('lorentz', [''])\n\n                pdg_codes = sorted([part.get_pdg_code() for part in part_list])\n\n                # WWWW and WWVV\n                if pdg_codes == [-24, -24, 24, 24]:\n                    myinter.set('lorentz', ['WWWW'])\n                elif spin_array == [3, 3, 3, 3] and \\\n                             24 in pdg_codes and - 24 in pdg_codes:\n                    myinter.set('lorentz', ['WWVV'])\n\n                # gggg\n                if pdg_codes == [21, 21, 21, 21]:\n                    myinter.set('lorentz', ['gggg1', 'gggg2', 'gggg3'])\n\n                # go-go-g\n                # Using the special fvigox routine provides the minus\n                # sign necessary for octet Majorana-vector interactions\n                if spin_array == [2, 2, 3] and colors == [8, 8, 8] and \\\n                   part_list[0].get('self_antipart') and \\\n                   part_list[1].get('self_antipart'):\n                    myinter.set('lorentz', ['go'])\n\n                # If extra flag, add this to Lorentz    \n                if len(values) > 3 * len(part_list) - 4:\n                    myinter.get('lorentz')[0] = \\\n                                      myinter.get('lorentz')[0]\\\n                                      + values[3 * len(part_list) - 4].upper()\n\n                # Use the other strings to fill variable names and tags\n\n                # Couplings: special treatment for 4-vertices, where MG4 used\n                # two couplings, while MG5 only uses one (with the exception\n                # of the 4g vertex, which needs special treatment)\n                # DUM0 and DUM1 are used as placeholders by FR, corresponds to 1\n                if len(part_list) == 3 or \\\n                   values[len(part_list) + 1] in ['DUM', 'DUM0', 'DUM1']:\n                    # We can just use the first coupling, since the second\n                    # is a dummy\n                    myinter.set('couplings', {(0, 0):values[len(part_list)]})\n                    if myinter.get('lorentz')[0] == 'WWWWN':\n                        # Should only use one Helas amplitude for electroweak\n                        # 4-vector vertices with FR. I choose W3W3NX.\n                        myinter.set('lorentz', ['WWVVN'])\n                elif values[len(part_list)] in ['DUM', 'DUM0', 'DUM1']:\n                    # We can just use the second coupling, since the first\n                    # is a dummy\n                    myinter.set('couplings', {(0, 0):values[len(part_list)+1]})\n                elif pdg_codes == [21, 21, 21, 21]:\n                    # gggg\n                    myinter.set('couplings', {(0, 0):values[len(part_list)],\n                                              (1, 1):values[len(part_list)],\n                                              (2, 2):values[len(part_list)]})\n                elif myinter.get('lorentz')[0] == 'WWWW':\n                    # Need special treatment of v4 SM WWWW couplings since \n                    # MG5 can only have one coupling per Lorentz structure\n                    myinter.set('couplings', {(0, 0):\\\n                                              'sqrt(' + \n                                              values[len(part_list)] + \\\n                                             '**2+' + \\\n                                              values[len(part_list) + 1] + \\\n                                              '**2)'})\n                else: #if myinter.get('lorentz')[0] == 'WWVV':\n                    # Need special treatment of v4 SM WWVV couplings since \n                    # MG5 can only have one coupling per Lorentz structure\n                    myinter.set('couplings', {(0, 0):values[len(part_list)] + \\\n                                             '*' + \\\n                                              values[len(part_list) + 1]})\n                    #raise Interaction.PhysicsObjectError, \\\n                    #    \"Only FR-style 4-vertices implemented.\"\n                \n                # SPECIAL TREATMENT OF COLOR\n                # g g sq sq (two different color structures, same Lorentz)\n                if spin_array == [3, 3, 1, 1] and colors == [-3, 3, 8, 8]:\n                    myinter.set('couplings', {(0, 0):values[len(part_list)],\n                                              (1, 0):values[len(part_list)]})\n\n                # Coupling orders - needs to be fixed\n                order_list = values[2 * len(part_list) - 2: \\\n                                    3 * len(part_list) - 4]\n\n                def count_duplicates_in_list(dupedlist):\n                    \"\"\"return a dictionary with key the element of dupeList and\n                    with value the number of times that they are in this list\"\"\"\n                    unique_set = set(item for item in dupedlist)\n                    ret_dict = {}\n                    for item in unique_set:\n                        ret_dict[item] = dupedlist.count(item)\n                    return ret_dict\n\n                myinter.set('orders', count_duplicates_in_list(order_list))\n\n                myinter.set('id', len(myinterlist) + 1)\n\n                myinterlist.append(myinter)\n\n            except Interaction.PhysicsObjectError, why:\n                logger.error(\"Interaction ignored: %s\" % why)\n\n    return myinterlist\n\n#===============================================================================\n# read_proc_card.dat (mg4 format)\n#===============================================================================\ndef read_proc_card_v4(fsock):\n    \"\"\"A simple function reading the files in fsock and returning a \n    ProcCardv4Reader object. This function authorize to have the same syntax as\n    for the other files treatment\"\"\"\n\n    reader = ProcCardv4Reader(fsock)\n    return reader\n\nclass ParticleError(InvalidCmd):\n    \"\"\" A class to carch the error\"\"\"\n    pass\n\nclass WrongFileFormat(InvalidCmd): \n    \"\"\"A specific class error for wrong V4 proc_card\"\"\"\n    pass\n\nclass ProcCardv4Reader(object):\n    \"\"\"read a proc_card.dat in the mg4 format and creates the equivalent routine\n    for mg5\"\"\"\n    \n    #tag in the proc_card.dat which split the proc_card content\n        \n    # line pattern (remove comment at the end of the line)\n    pat_line = re.compile(r\"\"\"^\\s*(?P<info>[^\\#]*?)\\s*(\\#|$)\"\"\", re.DOTALL)\n    \n    def __init__(self, fsock):\n        \"\"\"init the variable\"\"\"\n\n        self.process = [] # List of ProcessInfo\n        self.model = \"\"   # name of the model\n        self.multipart = [] # list of the mg4 definition of multiparticle\n        self.particles_name = set() # set of authorize particle name\n        self.couplings_name = set() # set of mandatory couplings\n        self.process_path = os.path.realpath(os.path.join(\n                                        os.path.dirname(fsock.name), os.pardir))\n        \n        # Reading the files and store the information in string format.\n        self.analyze_v4_proc_card(fsock)\n\n    \n    def analyze_v4_proc_card(self, fsock):\n        \"\"\"read the file and fullfill the variable with mg4 line\"\"\"\n        \n        proc_card = fsock.read()\n\n        # store process information\n        process_open = False\n        \n        process_re = re.search(\\\n            r\"^# Begin\\s+PROCESS.*?^(?P<process>.*)^# End\\s+PROCESS\",\n            proc_card, re.MULTILINE|re.DOTALL)\n\n        if not process_re:\n            raise WrongFileFormat('No valid Begin...End PROCESS tags')\n\n        model_re = re.search(\\\n            r\"^# Begin\\s+MODEL.*?^(?P<model>.+?)(\\s+|$)^# End\\s+MODEL\",\n            proc_card, re.MULTILINE|re.DOTALL)\n\n        if not model_re:\n            raise WrongFileFormat('No valid Begin...End MODEL tags')\n\n        multiparticles_re = re.search(\\\n            r\"^# Begin\\s+MULTIPARTICLES.*?^(?P<multiparticles>.*)^# End\\s+MULTIPARTICLES\",\n            proc_card, re.MULTILINE|re.DOTALL)\n\n        if not multiparticles_re:\n            raise WrongFileFormat('No valid Begin...End MULTIPARTICLES tags')\n\n        process_lines = process_re.group('process').split('\\n')\n\n        for line in process_lines:\n            # an 'end_coup' stop the current process, \n            #    'done' finish the list of process\n            analyze_line = self.pat_line.search(line)\n            if analyze_line:\n                data = analyze_line.group('info') #skip the comment\n                if not data:\n                    continue\n                if not process_open and 'done' not in data:\n                    process_open = True\n                    self.process.append(ProcessInfo(data))\n                elif 'end_coup' in data:\n                    process_open = False\n                elif 'done' not in data:\n                    self.process[-1].add_coupling(data)\n         \n        self.model = model_re.group('model')\n                \n        multiparticles_lines = multiparticles_re.group('multiparticles').split('\\n')\n\n        for line in multiparticles_lines:\n            analyze_line = self.pat_line.search(line)\n            if analyze_line:\n                line = analyze_line.group('info') #skip the comment\n                if not line:\n                    continue\n                data = line.split()\n                self.particles_name.add(data[0].lower())\n                self.multipart.append(line)\n        \n    \n    def extract_command_lines(self, model):\n        \"\"\"Return the MG5 command line corresponding to this proc_card \n        the MG5 command import model is skipped (since the model should be \n        loaded -it is one of the argument-)\"\"\"\n         \n        # extract useful information of the model\n        self.extract_info_from_model(model)\n        \n        # use the model information for the splitting in particles of the mg4\n        #process line.\n        for process in self.process:\n            process.analyze_process(self.particles_name)\n        \n        #Now we are in position to write the lines call\n        lines = []    \n        #first write the lines associate to the multiparticls definition\n        if self.multipart:\n            lines.append('# Define multiparticle labels')\n        for multipart in self.multipart:\n            data = self.separate_particle(multipart, self.particles_name)\n            lines.append('define ' + ' '.join(data))\n        \n        # secondly define the lines associate with diagram\n        if self.process:\n            lines.append('# Specify process(es) to run')\n        for i, process in enumerate(self.process):\n            if i == 0:\n                lines.append('generate %s' % \\\n                                  process.mg5_process_line(self.couplings_name))\n            else:\n                lines.append('add process %s' % \\\n                                  process.mg5_process_line(self.couplings_name))\n        \n        #finally export the madevent output\n        lines.append('# Output processes to MadEvent directory')\n        lines.append('output -f')\n        \n        return lines\n        \n        \n    def extract_info_from_model(self, model):\n        \"\"\" creates the self.particles_name (list of all valid name)\n            and self.couplings_name (list of all couplings)\"\"\"\n        \n        # add in self.particles_name (it contains normally the mulpart name \n        #already) all the valid name of particle of the model    \n        for particle in model['particles']:\n            self.particles_name.add(particle['name'])\n            self.particles_name.add(particle['antiname'])\n\n        # add in self.couplings_name the couplings name of the model\n        for interaction in model['interactions']:\n            for coupling in interaction['orders'].keys():\n                self.couplings_name.add(coupling)\n\n    \n    @staticmethod\n    def separate_particle(line, possible_str):\n        \"\"\" for a list of concatanate variable return a list of particle name\"\"\"\n\n        line = line.lower() # Particle name are not case sensitive\n        out = []            # list of the particles\n        # The procedure to find particles is the following\n        #  - check if the combination of 4 string form a valid particle name\n        #    if it is, move of 4 characters and check for the next particles.\n        #    if not try with 3, 2, 1 \n        #    if still not -> exit.\n        \n        pos = 0        # current starting position \n        old_pos = -1   # check that we don't have infinite loop    \n        line += '     '  #add 4 blank for security\n        while pos < len(line) - 4:\n            #Check for infinite loop\n            if pos == old_pos:\n                logging.error('Invalid particle name: %s' % \\\n                              line[pos:pos + 4].rstrip())\n                raise ParticleError('Invalid particle name %s' %\n                                     line[pos:pos + 4].rstrip())\n            old_pos = pos\n            # check for pointless character\n            if line[pos] in [' ', '\\n', '\\t']:\n                pos += 1\n                continue\n            \n            # try to find a match at 4(then 3\/2\/1) characters\n            for i in range(4, 0, -1):\n                if line[pos:pos + i] in possible_str:\n                    out.append(line[pos:pos + i])\n                    pos = pos + i\n                    break\n                \n        return out\n    \nclass ProcessInfo(object):\n    \"\"\"This is the basic object for storing process information\"\"\"\n    \n    def __init__(self, line):\n        \"\"\"Initialize information\"\"\"\n            \n        self.particles = [] # list tuple (level, particle)\n        self.couplings = {} # coupling -> max_order\n        self.decays = []    # ProcessInfo of the decays\n        self.tag = ''       # tag of the process\n        self.s_forbid = []  # list of particles forbids in s channel\n        self.forbid = []     # list of particles forbids\n        self.line = line    # initialization line\n        \n        self.is_mg5_valid = False\n        #some shortcut\n        self.separate_particle = ProcCardv4Reader.separate_particle\n    \n    def analyze_process(self, particles_name):\n        \"\"\"Add a line information\n            two format are possible (decay chains or not)\n            pp>h>WWj \/a $u @3\n            pp>(h>WW)j \/a $u @3\n        \"\"\"\n\n        line = self.line\n        #extract the tag\n        if '@' in line:\n            split = line.split('@')\n            line = split[0]\n            self.tag = split[1]\n            \n\n        # check if we have a MG5 format\n        if '\/mg5\/' in line:\n            self.line = line.replace('\/mg5\/','')\n            self.is_mg5_valid = True\n            return\n        if ',' in line or '=' in line:\n            self.is_mg5_valid = True\n            return\n\n        # extract (S-)forbidden particle\n        pos_forbid = line.find('\/')\n        pos_sforbid = line.find('$')\n        \n        # Select the restrictions (pos is -1 if not defined)\n        #and remove the restrictions from the line\n        if pos_forbid != -1 and pos_sforbid != -1:\n            if  pos_forbid > pos_sforbid :\n                self.forbid = self.separate_particle(line[pos_forbid + 1:], \\\n                                                                 particles_name)\n                self.s_forbid = self.separate_particle(\\\n                               line[pos_sforbid + 1:pos_forbid], particles_name)\n                line = line[:min(pos_forbid, pos_sforbid)]\n            else:\n                self.forbid = self.separate_particle(\\\n                               line[pos_forbid + 1:pos_sforbid], particles_name)\n                self.s_forbid = self.separate_particle(line[pos_sforbid + 1:], \\\n                                                           particles_name)\n                line = line[:min(pos_forbid, pos_sforbid)]\n        # Same but if they are no S-forbidden particles\n        elif pos_forbid != -1:\n            self.forbid = self.separate_particle(line[pos_forbid + 1:], \\\n                                                                 particles_name)\n            line = line[:pos_forbid]\n        # Same but if they are no forbidden particles\n        elif pos_sforbid != -1:\n            self.s_forbid = self.separate_particle(line[pos_sforbid + 1:], \\\n                                                                 particles_name)\n            line = line[:pos_sforbid]\n            \n        # Deal with decay chains, returns lines whitout the decay (and treat \n        #the different decays.\n        if '(' in line:\n            line = self.treat_decay_chain(line, particles_name)\n            \n        #define the level of each particle\n        level_content = line.split('>')\n        for level, data in enumerate(level_content):\n            particles = self.separate_particle(data, particles_name)\n            if particles:\n                [self.particles.append((level, name)) for name in particles]\n            \n            \n    def treat_decay_chain(self, line, particles_name):\n        \"\"\"Split the information of the decays into a tree of ProcessInfo.\"\"\"\n            \n        level = 0 #depth of the decay chain\n        out_line = '' # core process\n        for character in line:\n            if character == '(':\n                level += 1\n                if level == 1:\n                    decay_line = \"\" # initialize a new decay info\n                else:\n                    decay_line += '('\n                continue\n            elif character == ')':\n                level -= 1\n                if level == 0: #store the information\n                    self.decays.append(ProcessInfo(decay_line))\n                    self.decays[-1].add_restrictions(self.forbid, self.s_forbid,\n                                                                 None)\n                    self.decays[-1].analyze_process(particles_name)\n                    out_line += decay_line[:decay_line.find('>')]\n                else:\n                    decay_line += ')'\n                continue\n            elif level:\n                decay_line += character\n            else:\n                out_line += character\n        return out_line\n        \n    def add_coupling(self, line):\n        \"\"\"Add the coupling information to the process\"\"\"\n        data = line.split('=')\n        self.couplings[data[0]] = int(data[1])\n        \n    \n    def add_restrictions(self, forbid, s_forbid, couplings):\n        \"\"\"Associate some restriction to this diagram\"\"\"\n        \n        self.forbid = forbid\n        self.s_forbid = s_forbid\n        self.couplings = couplings\n\n    def mg5_process_line(self, model_coupling):\n        \"\"\"Return a valid mg5 format for this process \"\"\"\n        \n        if self.is_mg5_valid:\n            return self.line\n        \n        text = ''\n        # Write the process\n        cur_level = 0\n        for level, particle in self.particles:\n            if level > cur_level:\n                text += '> '\n                cur_level += 1\n            text += '%s ' % particle\n\n        # Write the constraints\n        if self.s_forbid:\n            text += '$ ' + ' '.join(self.s_forbid) + ' '\n        if self.forbid:\n            text += '\/ ' + ' '.join(self.forbid) + ' '\n\n        #treat decay_chains\n        for decay in self.decays:\n            decay_text = decay.mg5_process_line(model_coupling)\n            if ',' in decay_text:\n                text = text.rstrip() + ', (%s) ' % decay_text.strip()\n            else:\n                text = text.rstrip() + ', %s ' % decay_text.strip()\n        \n        # write the tag\n        if self.tag:\n            text += '@%s ' % self.tag\n\n        if self.couplings:\n            if not self.tag:\n                text += '@0 '\n            #write the rules associate to the couplings\n            text += self.mg5_couplings_line(model_coupling, len(self.particles))\n        \n        return text.rstrip()\n    \n    def mg5_couplings_line(self, model_coupling, nb_part):\n        \"\"\"Return the assignment of coupling for this process\"\"\"\n\n        out = ''\n        for coupling in model_coupling:\n            if self.couplings.has_key(coupling):\n                # Need coupling for all cases, since might be decay chain\n                out += '%s=%s ' % (coupling, self.couplings[coupling])\n            else:\n                # if not define put to zero (mg4 default)\n                out += '%s=0 ' % coupling\n        \n        return out \n    \n    \n    \n    \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_501","text":"<gh_stars>1-10\nimport sys, time\nimport multiprocessing as mp\nimport numpy as np\nimport scipy as sp\nimport visualizer as vz\nimport mock_net as mn\n\nclass NVM:\n    def __init__(self, coding, network):\n        self.coding = coding\n        self.network = network\n        self.visualizing = False\n        # Encode layer names and constants\n        for symbol in self.network.get_layer_names():\n            self.coding.encode(symbol)\n    def __str__(self):\n        pattern_list = self.network.list_patterns()\n        vmstr = ''\n        for (layer_name, pattern) in pattern_list:\n            if self.decode(pattern)=='<?>': continue\n            vmstr += '%s:%s;'%(layer_name, self.decode(pattern))\n        return vmstr\n    def encode(self,human_readable):\n        return self.coding.encode(human_readable)\n    def decode(self, machine_readable):\n        return self.coding.decode(machine_readable)\n    def tick(self):\n        # network update\n        self.network.tick()\n        # answer any visualizer request\n        if self.visualizing:\n            if self.viz_pipe.poll():\n                # flush request\n                self.viz_pipe.recv()\n                # respond with data\n                self.send_viz_data()\n    def send_viz_data(self, down_sample=2):\n        \"\"\"\n        Protocol:\n            <# layers>, <name>, <value>, <pattern>, <name>, <value>, <pattern>, ...\n        \"\"\"\n        if not self.visualizing: return\n        pattern_list = self.network.list_patterns()\n        self.viz_pipe.send(len(pattern_list))\n        for (layer_name, pattern) in pattern_list:\n            self.viz_pipe.send(layer_name)\n            self.viz_pipe.send(self.decode(pattern)) # value\n            # down sample pattern\n            pattern = np.concatenate((pattern, np.nan*np.ones(len(pattern) % down_sample)))\n            pattern = pattern.reshape((len(pattern)\/down_sample, down_sample)).mean(axis=1)\n            pattern = (128*(pattern + 1.0)).astype(np.uint8).tobytes()\n            self.viz_pipe.send_bytes(pattern) # bytes\n    def show(self):\n        self.hide() # flush any windowless viz process\n        self.viz_pipe, other_end = mp.Pipe()\n        self.viz_process = mp.Process(target=run_viz, args=(other_end,))\n        self.viz_process.start()\n        self.visualizing = True\n        # send initial data for window layout\n        self.send_viz_data()\n    def hide(self):\n        if not self.visualizing: return\n        self.viz_pipe.send('shutdown')\n        self.viz_process.join()\n        self.viz_pipe = None\n        self.viz_process = None\n        self.visualizing = False\n    def set_standard_input(self, message, from_human_readable=True):\n        if from_human_readable:\n            pattern = self.encode(message)\n        else:\n            pattern = np.fromstring(pattern,dtype=float)\n        self.network.set_pattern('STDI', pattern)\n    def get_standard_output(self, to_human_readable=True):\n        pattern = self.network.get_pattern('STDO')\n        if to_human_readable:\n            message = self.decode(pattern)\n        else:\n            message = pattern.tobytes()\n        return message\n    def set_instruction(self, opcode, *operands):\n        # clear gates\n        self.network.set_pattern('A',self.network.get_pattern('A')*0)\n        # set instruction\n        self.network.set_pattern('OPC',self.encode(opcode))\n        for op in range(len(operands)):\n            self.network.set_pattern('OP%d'%(op+1), self.encode(operands[op]))\n    def train(self, pattern_hash, new_pattern_hash):\n        # train module with module.train\n        # self.network.get_module(module_name).train(pattern_list, next_pattern_list)\n        self.network.train(pattern_hash, new_pattern_hash)\n    def quit(self):\n        self.hide()\n        sys.exit(0)\n\ndef mock_nvm(num_registers=3, layer_size=32):\n    layer_names = ['IP','OPC','OP1','OP2','OP3'] # instruction\n    layer_names += ['{%d}'%r for r in range(num_registers)] # registers\n    layer_names += ['C1','C2','CO','N1','N2','NO'] # compare+nand\n    layer_names += ['K','V'] # memory\n    layer_names += ['STDI','STDO'] # io\n    layer_sizes = [layer_size]*len(layer_names)\n    net = mn.MockNet(layer_names, layer_sizes)\n    coding = mn.MockCoding(layer_size)\n    return NVM(coding, net)\n\ndef run_viz(nvm_pipe):\n    viz = vz.Visualizer(nvm_pipe)\n    viz.launch()\n\ndef flash_nrom(vm):\n    # train vm on instruction set\n    # gate_index_map = vm.network.get_module('gating').gate_index_map\n    omega = np.tanh(1)\n    gate_pattern = vm.network.get_pattern('A')\n    # get non-gate layer names\n    layer_names = vm.network.get_layer_names(omit_gates=True)\n    # layer copies\n    zero_gate_pattern = gate_pattern.copy()\n    zero_gate_pattern[:] = 0\n    for to_layer_name in layer_names:\n        for from_layer_name in layer_names:\n            gate_pattern[:] = 0\n            gate_pattern[vm.network.get_gate_index(to_layer_name,from_layer_name)] = omega\n            vm.train(\n                {from_layer_name:'pattern', 'A':gate_pattern},\n                {to_layer_name:'pattern','A':zero_gate_pattern})\n    # set value to_layer_name\n    for to_layer_name in layer_names:\n        gate_pattern[:] = 0\n        gate_pattern[vm.network.get_gate_index(to_layer_name,'OP1')] = omega\n        vm.train({'OPC':vm.encode('set'),'OP2':vm.encode(to_layer_name)},{'A':gate_pattern})\n        vm.train({'OPC':vm.encode('set'),'OP2':vm.encode(to_layer_name),'A':gate_pattern},\n                {'A':zero_gate_pattern,'OPC':vm.encode('_')})\n    # ccp from_layer_name to_layer_name condition_layer_name (conditional copy)\n    for to_layer_name in layer_names:\n        for from_layer_name in layer_names:\n            for cond_layer_name in layer_names:\n                gate_pattern[:] = 0\n                gate_pattern[vm.network.get_gate_index(to_layer_name,from_layer_name)] = omega\n                vm.train({\n                    'OPC':vm.encode('ccp'),\n                    'OP1':vm.encode(from_layer_name),\n                    'OP2':vm.encode(to_layer_name),\n                    'OP3':vm.encode(cond_layer_name),\n                    cond_layer_name:vm.encode('TRUE')},\n                    {'A':gate_pattern})\n                vm.train({\n                    'OPC':vm.encode('ccp'),\n                    'OP1':vm.encode(from_layer_name),\n                    'OP2':vm.encode(to_layer_name),\n                    'OP3':vm.encode(cond_layer_name),\n                    cond_layer_name:vm.encode('TRUE'),\n                    'A':gate_pattern},\n                    {'A':zero_gate_pattern,\n                    'OPC':vm.encode('_')})\n    # compare circuitry\n    vm.train({}, {'CO':vm.encode('FALSE')}) # default FALSE behavior\n    vm.train({'C1':'pattern','C2':'pattern'}, {'CO':vm.encode('TRUE')}) # unless equal\n    # nand circuitry\n    vm.train({}, {'NO':vm.encode('TRUE')}) # default TRUE behavior\n    vm.train({'N1':vm.encode('TRUE'),'N2':vm.encode('TRUE')}, {'NO':vm.encode('FALSE')}) # unless both\n    # mwr value_layer_name pointer_layer_name (memory write)\n    gate_pattern[:] = 0\n    key_gate_pattern = gate_pattern.copy()\n    value_gate_pattern = gate_pattern.copy()\n    assoc_gate_pattern = gate_pattern.copy()\n    for pointer_layer_name in layer_names:\n        for value_layer_name in layer_names:\n            key_gate_pattern[:] = 0\n            key_gate_pattern[vm.network.get_gate_index('K',pointer_layer_name)] = omega\n            vm.train({\n                'OPC':vm.encode('mwr'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name)},\n                {'A':key_gate_pattern})\n            value_gate_pattern[:] = 0\n            value_gate_pattern[vm.network.get_gate_index('V',value_layer_name)] = omega\n            assoc_gate_pattern[:] = 0\n            assoc_gate_pattern[vm.network.get_gate_index('V','K')] = omega\n            vm.train({\n                'OPC':vm.encode('mwr'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'A':key_gate_pattern},\n                {'A':value_gate_pattern})\n            vm.train({\n                'OPC':vm.encode('mwr'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'A':value_gate_pattern},\n                {'W':assoc_gate_pattern})\n            vm.train({\n                'OPC':vm.encode('mwr'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'W':assoc_gate_pattern},\n                {'OPC':vm.encode('_'),\n                 'W':zero_gate_pattern})\n    # mrd value_layer_name pointer_layer_name (memory read)\n    gate_pattern[:] = 0\n    key_gate_pattern = gate_pattern.copy()\n    value_gate_pattern = gate_pattern.copy()\n    for pointer_layer_name in layer_names:\n        for value_layer_name in layer_names:\n            key_gate_pattern[:] = 0\n            key_gate_pattern[vm.network.get_gate_index('K',pointer_layer_name)] = omega\n            vm.train({\n                'OPC':vm.encode('mrd'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name)},\n                {'A':key_gate_pattern})\n            value_gate_pattern[:] = 0\n            value_gate_pattern[vm.network.get_gate_index(value_layer_name,'V')] = omega\n            vm.train({\n                'OPC':vm.encode('mrd'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'A':key_gate_pattern},\n                {'A':-key_gate_pattern}) # placeholder until hidden layer\n            vm.train({\n                'OPC':vm.encode('mrd'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'A':-key_gate_pattern},\n                {'A':value_gate_pattern})\n            vm.train({\n                'OPC':vm.encode('mrd'),\n                'OP1':vm.encode(value_layer_name),\n                'OP2':vm.encode(pointer_layer_name),\n                'A':value_gate_pattern},\n                {'OPC':vm.encode('_'),\n                 'A':zero_gate_pattern})\n\ndef show_tick(vm):\n    period = .1\n    for t in range(1):\n        print('pre : %s'%vm)\n        vm.tick()\n        print('post: %s'%vm)\n        raw_input('.')\n        # time.sleep(period)\n    \nif __name__ == '__main__':\n\n    # Should run with -i flag to allow mvm.quit()\n\n    mvm = mock_nvm()\n    # mvm.set_standard_input('NIL',from_human_readable=True)\n    # print(mvm.get_standard_output(to_human_readable=True))\n    flash_nrom(mvm)\n    # print(mvm.network.transitions['{0}'])\n    mvm.show()\n    show_tick(mvm)\n\n    # # conditional copies\n    # mvm.set_instruction('set','NIL','{0}')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # mvm.set_instruction('set','TRUE','{1}')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # mvm.set_instruction('set','FALSE','{2}')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # raw_input('...')\n    # mvm.set_instruction('ccp','{0}','{1}','{2}')\n    # show_tick(mvm)\n    # mvm.set_instruction('ccp','{0}','{2}','{1}')\n    # show_tick(mvm)\n    \n    # # compare\/logic\n    # print('set!')\n    # mvm.set_instruction('set','TRUE','N1')\n    # # mvm.set_instruction('set','TRUE','C1')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # print('set!')\n    # mvm.set_instruction('set','TRUE','N2')\n    # # mvm.set_instruction('set','TRUE','C2')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # print('set!')\n    # mvm.set_instruction('set','NIL','N2')\n    # # mvm.set_instruction('set','NIL','C2')\n    # show_tick(mvm)\n    # show_tick(mvm)\n    # show_tick(mvm)\n\n    # memory\n    print('set!')\n    mvm.set_instruction('set','TRUE','{0}')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    print('set!')\n    mvm.set_instruction('set','NIL','{1}')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    print('set!')\n    mvm.set_instruction('mwr','{0}','{1}')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    print('set!')\n    mvm.set_instruction('set','_','K')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    print('set!')\n    mvm.set_instruction('set','_','V')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    print('set!')\n    mvm.set_instruction('mrd','{2}','{1}')\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n    show_tick(mvm)\n\n    \n    \n    # mvm.hide()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_502","text":"<gh_stars>10-100\n\nfrom __future__ import division, print_function\nimport numpy as np\nimport pytest\nfrom scipy.interpolate import UnivariateSpline\n\nfrom pyunfold.unfold import iterative_unfold\nfrom pyunfold.callbacks import (Callback, CallbackList, Logger,\n                                Regularizer, SplineRegularizer,\n                                validate_callbacks, extract_regularizer,\n                                setup_callbacks_regularizer)\n\n\n@pytest.mark.parametrize('attr', ['on_unfolding_begin',\n                                  'on_unfolding_end',\n                                  'on_iteration_begin',\n                                  'on_iteration_end'])\ndef test_callback_attributes(attr):\n    assert hasattr(Callback(), attr)\n\n\n@pytest.mark.parametrize('callbacks', [[Logger()], Logger()])\ndef test_logger(capsys, callbacks, example_dataset):\n\n    # Perform iterative unfolding\n    unfolded_results = iterative_unfold(data=example_dataset.data,\n                                        data_err=example_dataset.data_err,\n                                        response=example_dataset.response,\n                                        response_err=example_dataset.response_err,\n                                        efficiencies=example_dataset.efficiencies,\n                                        efficiencies_err=example_dataset.efficiencies_err,\n                                        return_iterations=True,\n                                        callbacks=callbacks)\n\n    # Get stdout and std err from iterative_unfold\n    out, err = capsys.readouterr()\n\n    # Build expected output\n    expected_output = ''\n    for row_index, row in unfolded_results.iterrows():\n        row_output = ('Iteration {}: ts = {:0.4f}, ts_stopping ='\n                      ' {}\\n'.format(row_index + 1,\n                                     row['ts_iter'],\n                                     row['ts_stopping']))\n        expected_output += row_output\n\n    assert expected_output == out\n\n\ndef test_Logger_isinstance_Callback():\n\n    logger = Logger()\n    assert isinstance(logger, Callback)\n\n\ndef test_SplineRegularizer_isinstance_Regularizer():\n\n    spline_reg = SplineRegularizer()\n    assert isinstance(spline_reg, Regularizer)\n\n\ndef test_SplineRegularizer(example_dataset):\n    degree = 3\n    smooth = 20\n    spline_reg = SplineRegularizer(degree=degree, smooth=smooth)\n\n    unfolded_with_reg = iterative_unfold(data=example_dataset.data,\n                                         data_err=example_dataset.data_err,\n                                         response=example_dataset.response,\n                                         response_err=example_dataset.response_err,\n                                         efficiencies=example_dataset.efficiencies,\n                                         efficiencies_err=example_dataset.efficiencies_err,\n                                         return_iterations=True,\n                                         callbacks=[spline_reg])\n\n    unfolded_no_reg = iterative_unfold(data=example_dataset.data,\n                                       data_err=example_dataset.data_err,\n                                       response=example_dataset.response,\n                                       response_err=example_dataset.response_err,\n                                       efficiencies=example_dataset.efficiencies,\n                                       efficiencies_err=example_dataset.efficiencies_err,\n                                       return_iterations=True)\n\n    no_reg = unfolded_no_reg.iloc[0]['unfolded']\n    x = np.arange(len(no_reg), dtype=float)\n    spline = UnivariateSpline(x, no_reg, k=degree, s=smooth)\n    fitted_unfolded = spline(x)\n\n    np.testing.assert_allclose(unfolded_with_reg.iloc[0]['unfolded'],\n                               fitted_unfolded)\n\n\ndef test_SplineRegularizer_groups(example_dataset):\n    degree = 3\n    smooth = 20\n    groups = np.empty_like(example_dataset.data)\n    groups[:len(groups) \/\/ 2] = 0\n    groups[len(groups) \/\/ 2:] = 1\n    spline_reg = SplineRegularizer(degree=degree, smooth=smooth, groups=groups)\n    unfolded_with_reg = iterative_unfold(data=example_dataset.data,\n                                         data_err=example_dataset.data_err,\n                                         response=example_dataset.response,\n                                         response_err=example_dataset.response_err,\n                                         efficiencies=example_dataset.efficiencies,\n                                         efficiencies_err=example_dataset.efficiencies_err,\n                                         return_iterations=True,\n                                         callbacks=[spline_reg])\n\n    unfolded_no_reg = iterative_unfold(data=example_dataset.data,\n                                       data_err=example_dataset.data_err,\n                                       response=example_dataset.response,\n                                       response_err=example_dataset.response_err,\n                                       efficiencies=example_dataset.efficiencies,\n                                       efficiencies_err=example_dataset.efficiencies_err,\n                                       return_iterations=True)\n    # Manually regularize each group independently\n    y_no_reg = unfolded_no_reg.iloc[0]['unfolded']\n    x = np.arange(len(y_no_reg), dtype=float)\n    fitted_unfolded_no_reg = np.empty(len(y_no_reg))\n    group_ids = np.unique(groups)\n    for group in group_ids:\n        group_mask = groups == group\n        x_group = x[group_mask]\n        y_group = y_no_reg[group_mask]\n        spline_group = UnivariateSpline(x_group, y_group, k=degree, s=smooth)\n        fitted_unfolded_group = spline_group(x_group)\n        fitted_unfolded_no_reg[group_mask] = fitted_unfolded_group\n\n    np.testing.assert_allclose(unfolded_with_reg.iloc[0]['unfolded'],\n                               fitted_unfolded_no_reg)\n\n\ndef test_SplineRegularizer_groups_raises(example_dataset):\n    degree = 3\n    smooth = 20\n    groups = np.empty(len(example_dataset.data) - 1)\n    groups[:len(groups) \/\/ 2] = 0\n    groups[len(groups) \/\/ 2:] = 1\n    spline_reg = SplineRegularizer(degree=degree, smooth=smooth, groups=groups)\n    with pytest.raises(ValueError) as excinfo:\n        iterative_unfold(data=example_dataset.data,\n                         data_err=example_dataset.data_err,\n                         response=example_dataset.response,\n                         response_err=example_dataset.response_err,\n                         efficiencies=example_dataset.efficiencies,\n                         efficiencies_err=example_dataset.efficiencies_err,\n                         return_iterations=True,\n                         callbacks=[spline_reg])\n\n    err_msg = ('Invalid groups array. There should be an entry '\n               'for each cause bin. However, got len(groups)={} '\n               'while there are {} cause bins.'.format(len(groups),\n                                                       len(example_dataset.data)))\n    assert err_msg == str(excinfo.value)\n\n\ndef test_validate_callbacks():\n    callbacks = [Logger(), SplineRegularizer()]\n    assert validate_callbacks(callbacks) == callbacks\n\n\ndef test_validate_empty_callbacks():\n    assert validate_callbacks(None) == []\n\n\n@pytest.mark.parametrize('callback', [Logger(), SplineRegularizer()])\ndef test_validate_callbacks_single_callback(callback):\n    validate_callbacks(callback) == [callback]\n\n\ndef test_validate_callbacks_raises():\n    callbacks = [Logger(), SplineRegularizer(), 'not a callback']\n    with pytest.raises(TypeError) as excinfo:\n        validate_callbacks(callbacks)\n\n    err_msg = 'Found non-callback object in callbacks: {}'.format(['not a callback'])\n    assert err_msg == str(excinfo.value)\n\n\ndef test_extract_regularizer_mutliple_raises():\n    callbacks = [SplineRegularizer(), SplineRegularizer()]\n    with pytest.raises(NotImplementedError) as excinfo:\n        extract_regularizer(callbacks)\n\n    err_msg = 'Multiple regularizer callbacks where provided.'\n    assert err_msg == str(excinfo.value)\n\n\ndef test_extract_regularizer_no_regularizer():\n    callbacks = [Logger()]\n    assert extract_regularizer(callbacks) is None\n\n\n@pytest.mark.parametrize('callback', [SplineRegularizer()])\ndef test_extract_regularizer(callback):\n    callbacks = [Logger(), callback]\n    assert extract_regularizer(callbacks) == callback\n\n\ndef test_setup_callbacks_regularizer():\n\n    callbacks = [Logger(), SplineRegularizer()]\n    c, r = setup_callbacks_regularizer(callbacks)\n    assert isinstance(c, CallbackList)\n    assert len(c) == 1\n    assert c.callbacks[0] is callbacks[0]\n    assert r is callbacks[1]\n\n\ndef test_callbacklist_empty():\n    c = CallbackList()\n    assert c.callbacks == []\n\n\ndef test_callbacklist_callbacks():\n    logger = Logger()\n    reg = SplineRegularizer()\n    callbacks = [logger, reg]\n    c = CallbackList(callbacks=callbacks)\n    assert len(c) == len(callbacks)\n    assert all(i is j for i, j in zip(c.callbacks, callbacks))\n\n\ndef test_callbacklist_method_calls():\n    class MethodChecker(Callback):\n        def __init__(self):\n            super(Callback, self).__init__()\n            self.called_unfolding_begin = False\n            self.called_on_unfolding_end = False\n            self.called_on_iteration_begin = False\n            self.called_on_iteration_end = False\n\n        def on_unfolding_begin(self, status=None):\n            self.called_on_unfolding_begin = True\n\n        def on_unfolding_end(self, status=None):\n            self.called_on_unfolding_end = True\n\n        def on_iteration_begin(self, iteration, status=None):\n            self.called_on_iteration_begin = True\n\n        def on_iteration_end(self, iteration, status=None):\n            self.called_on_iteration_end = True\n\n    method_checker = MethodChecker()\n    c = CallbackList(method_checker)\n\n    c.on_iteration_begin(1)\n    assert method_checker.called_on_iteration_begin\n\n    c.on_iteration_end(1)\n    assert method_checker.called_on_iteration_end\n\n    c.on_unfolding_begin()\n    assert method_checker.called_on_unfolding_begin\n\n    c.on_unfolding_end()\n    assert method_checker.called_on_unfolding_end\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_503","text":"<filename>main.py\n# -*- coding: utf-8 -*-\nimport os\nimport sys\nfrom statistics.basic import Statistics\nfrom statistics.chisquare import chisquare\nfrom optparse import OptionParser, OptionValueError\n\n\nif __name__ == \"__main__\":\n    usage = \"usage: %prog [options] keyword\"\n    parser = OptionParser(usage)\n\n    parser.add_option(\n        \"-f\", \"--file\",\n        action=\"store\",\n        type=\"string\",\n        dest=\"data_file\",\n        help=\"data file\"\n    )\n    parser.add_option(\n        \"-b\", \"--bins\",\n        type=\"int\",\n        dest=\"bins\",\n        default=None,\n        help=\"bins\"\n    )\n    parser.add_option(\n        \"-w\", \"--bin_width\",\n        type=\"int\",\n        dest=\"bin_width\",\n        default=None,\n        help=\"bin width\"\n    )\n    parser.add_option(\n        \"-s\", \"--significance_level\",\n        type=\"float\",\n        dest=\"significance_level\",\n        default=0.05,\n        help=\"significance level\"\n    )\n\n    options, args = parser.parse_args()\n    if options.data_file:\n        with open(options.data_file,\"r\") as f:\n            data = map(float, f.read().split())\n    else:\n        data = map(int, args)\n    if not data:\n        raise\n    s = Statistics(\n        data,\n        bin_width=options.bin_width,\n        bins=options.bins,\n        significance_level=options.significance_level\n    )\n    print u\"階級\\t度数\\t比率\\t\\t\\tZ-Score\\t\\t\\t累積比率\\t\\t期待比率\\t\\t期待度数\"\n    for c in s.classes:\n        print \"{:<5}\\t{:<3}\\t{:<18}\\t{:<18}\\t{:<18}\\t{:<18}\\t{:<18}\".format(\n            c,\n            s.frequencies[c],\n            s.proportions[c],\n            s.zscores[c],\n            s.cumulative_ratios[c],\n            s.class_ratios[c],\n            s.expectations[c]\n        )\n    result = s.fit_test()\n    print u\"カイ二乗値: X^2 =\", s.chisquare\n    print u\"自由度:       v =\", s.freedom\n    print u\"有意水準:     a =\", s.significance_level\n    print u\"棄却域:     x^2 >\", s.critical_region\n    print(result)\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_505","text":"import scipy\nimport scipy.special\nimport scipy.integrate\nfrom numpy import exp,cos,sin\n\n# A basic 1D integral:\nscipy.integrate.quad(exp, 0, 1)\n# (1.7182818284590453, 1.9076760487502457e-14)\nscipy.integrate.quad(sin, -0.5, 0.5)\n# (0.0, 2.707864644566304e-15)\nscipy.integrate.quad(cos, -0.5, 0.5)\n# (0.9588510772084061, 1.0645385431034061e-14)\n\nf = lambda x : exp(-x**2)\nscipy.integrate.quad(f, 0, 1)\n# (0.7468241328124271, 8.291413475940725e-15)\n\nscipy.integrate.quad(lambda x : exp(-x**2), 0, 1)\n# (0.7468241328124271, 8.291413475940725e-15)\n\nscipy.integrate.quad(lambda x : exp(-x**2), 0, inf)\n# (0.8862269254527579, 7.101318390472462e-09)\n\nscipy.integrate.quad(lambda x : exp(-x**2), -inf, 1)\n# (1.6330510582651852, 3.669607414547701e-11)\n\nscipy.integrate.quad(lambda x: scipy.special.jn(1,x),0,5)\n# (1.177596771314338, 1.8083362065765924e-14)\n\n#### Integrating Polynomials\n\np = np.poly1d([2, 5, 1])\np(1), p(2), p(3.5)\n\nP = polyint(p)\nq=P(5)-P(1)\n\n\n#### Basic computations in linear algebra\nimport scipy.linalg\n\na = array([[-2, 3], [4, 5]])\nscipy.linalg.det(a)\n\nb = scipy.linalg.inv(a)\ndot(a,b)\n\n#### Solving systems of linear equations¶\nimport scipy.linalg\n\nA = array([[2, 4, 6], [1, -3, -9], [8, 5, -7]])\nb = array([4, -11, 2])\n\nsol1 = scipy.linalg.solve(A,b)\n\nAinv = scipy.linalg.inv(A)\nsol2 = dot(Ainv, b)\nsol1==sol2\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_506","text":"<reponame>yuanyuansjtu\/chaospy<filename>chaospy\/distributions\/collection\/binomial.py\n\"\"\"Binomial probability distribution.\"\"\"\nfrom functools import wraps\nimport numpy\nfrom scipy import special\n\nfrom ..baseclass import SimpleDistribution\nfrom ..operators import J\n\n\nclass binomial(SimpleDistribution):\n    \"\"\"\n    Binomial probability distribution.\n\n    Point density:\n        comb(N, x) p^x (1-p)^{N-x}      x in {0, 1, ..., N}\n\n    Examples:\n        >>> distribution = chaospy.Binomial(3, 0.5)\n        >>> distribution\n        Binomial(3, 0.5)\n        >>> xloc = numpy.arange(4)\n        >>> distribution.pdf(xloc).round(4)\n        array([0.125, 0.375, 0.375, 0.125])\n        >>> distribution.cdf(xloc).round(4)\n        array([0.125, 0.5  , 0.875, 1.   ])\n        >>> distribution.fwd([-0.5, -0.49, 0, 0.49, 0.5]).round(4)\n        array([0.    , 0.0013, 0.0625, 0.1238, 0.125 ])\n        >>> uloc = numpy.linspace(0, 1, 8)\n        >>> uloc.round(2)\n        array([0.  , 0.14, 0.29, 0.43, 0.57, 0.71, 0.86, 1.  ])\n        >>> distribution.inv(uloc).round(2)\n        array([-0.5 ,  0.55,  0.93,  1.31,  1.69,  2.07,  2.45,  3.5 ])\n        >>> distribution.sample(10)\n        array([2, 1, 0, 2, 2, 2, 2, 3, 3, 0])\n        >>> distribution.mom([1, 2, 3]).round(4)\n        array([1.5 , 3.  , 6.75])\n        >>> distribution.ttr([0, 1, 2, 3]).round(4)\n        array([[1.5 , 1.5 , 1.5 , 1.5 ],\n               [1.  , 0.75, 1.  , 0.75]])\n\n    \"\"\"\n    interpret_as_integer = True\n\n    def __init__(self, size, prob):\n        super(binomial, self).__init__(\n            parameters=dict(size=size, prob=prob),\n            repr_args=[size, prob],\n        )\n\n    def _cdf(self, x_data, size, prob):\n        size = numpy.round(size)\n        x_data = x_data-0.5\n\n        floor = numpy.zeros(x_data.shape)\n        indices = x_data >= 0\n        floor[indices] = special.bdtr(numpy.floor(x_data[indices]), size, prob)\n\n        ceil = numpy.ones(x_data.shape)\n        indices = x_data <= size\n        ceil[indices] = special.bdtr(numpy.ceil(x_data[indices]), size, prob)\n        ceil[numpy.isnan(ceil)] = 0  # left edge case\n\n        offset = x_data-numpy.floor(x_data)\n        out = floor*(1-offset) + ceil*offset\n        return out\n\n    def _pdf(self, x_data, size, prob):\n        x_data = numpy.round(x_data)\n        return special.comb(size, x_data)*prob**x_data*(1-prob)**(size-x_data)\n\n    def _lower(self, size, prob):\n        return -0.5\n\n    def _upper(self, size, prob):\n        return numpy.round(size)+0.5\n\n    def _mom(self, k_data, size, prob):\n        x_data = numpy.arange(int(size)+1, dtype=int)\n        return numpy.sum(x_data**k_data*self._pdf(\n            x_data, size=numpy.floor(size), prob=prob))\n\n    def _ttr(self, k_data, size, prob):\n        \"\"\"Krawtchouk rule.\"\"\"\n        from chaospy.quadrature import discretized_stieltjes\n        abscissas = numpy.arange(0, numpy.floor(size)+1)\n        weights = self._pdf(abscissas, size, prob)\n        (alpha, beta), _, _ = discretized_stieltjes(k_data, [abscissas], weights)\n        return alpha[0, -1], beta[0, -1]\n\n\nclass Binomial(J):\n\n    def __init__(self, size, prob):\n        dist = binomial(size, prob)\n        super(Binomial, self).__init__(dist)\n        self._repr_args = [size, prob]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_507","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Jan 26 11:12:32 2017\n\n@author: newton\n\"\"\"\n\nimport pandas as pd \nimport scipy as sp\nimport numpy as np\nfrom sklearn.metrics import classification_report\nfrom sklearn.metrics import precision_recall_curve, roc_curve, auc\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn import cross_validation\nfrom sklearn import metrics\nfrom sklearn.metrics import confusion_matrix \nimport csv \nimport matplotlib.pyplot as plt\nimport itertools\n\nlabels = [0,1,2,3,4,5,6,7,8,9]\n\n#def plot_confusion_matrix(cm, title='Confusion Matrix', cmap = plt.cm.binary):  \n#    plt.imshow(cm, interpolation='nearest', cmap=cmap)  \n#    plt.title(title)  \n#    plt.colorbar()  \n#    xlocations = np.array(range(len(labels)))  \n#    plt.xticks(xlocations, labels, rotation=90)  \n#    plt.yticks(xlocations, labels)  \n#    plt.ylabel('True label')  \n#    plt.xlabel('Predicted label')  \n\ndef plot_confusion_matrix(cm, classes,\n                          normalize=False,\n                          title='Confusion matrix',\n                          cmap=plt.cm.Blues):\n    \"\"\"\n    This function prints and plots the confusion matrix.\n    Normalization can be applied by setting `normalize=True`.\n    \"\"\"\n    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n    plt.title(title)\n    plt.colorbar()\n    tick_marks = np.arange(len(classes))\n    plt.xticks(tick_marks, classes, rotation=45)\n    plt.yticks(tick_marks, classes)\n\n    if normalize:\n        cm = cm.astype('float') \/ cm.sum(axis=1)[:, np.newaxis]\n        print(\"Normalized confusion matrix\")\n    else:\n        print('Confusion matrix, without normalization')\n\n    print(cm)\n\n    thresh = cm.max() \/ 2.\n    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n        plt.text(j, i, cm[i, j],\n                 horizontalalignment=\"center\",\n                 color=\"white\" if cm[i, j] > thresh else \"black\")\n\n    plt.tight_layout()\n    plt.ylabel('True label')\n    plt.xlabel('Predicted label')\n    \ntrains = pd.read_csv(\"train.csv\")\ntests = pd.read_csv(\"test.csv\")\n\nY = trains['label'] \n\ndel trains['label']\n\nX_datasarr = trains.as_matrix()\nX_norm = X_datasarr > 0\nX = X_norm.astype(int) \n\n\nX_train,X_test,y_train,y_test = cross_validation.train_test_split(X, Y, test_size=0.3, random_state=0)\n\nunique, counts = np.unique(y_test, return_counts=True)\nprint np.asarray((unique, counts)).T\n\nX_des_datasarr = tests.as_matrix()\nX_des_norm = X_des_datasarr > 0\nX_des = X_des_norm.astype(int) \n\nresults = []\n# 最小叶子结点的参数取值\nsample_leaf_options = list(range(1, 50, 3))\n# 决策树个数参数取值\nn_estimators_options = list(range(1, 10, 5))\nfor leaf_size in sample_leaf_options:\n    for n_estimators_size in n_estimators_options:\n        \n        rfc = RandomForestClassifier(min_samples_leaf=leaf_size, n_estimators=n_estimators_size, random_state=50)\n        rfc.fit(X_train,y_train)\n\n        y_pred_class = rfc.predict(X_test)\n        results.append((leaf_size, n_estimators_size, (y_test == y_pred_class).mean()))        \n\nprint(max(results, key=lambda x: x[2]))\n\nrfc = RandomForestClassifier(min_samples_leaf=6, n_estimators=6, random_state=50)\nrfc.fit(X_train,y_train)\ncm = confusion_matrix(y_test, y_pred_class)\nplot_confusion_matrix(cm,labels, title='Normalized confusion matrix') \n\n        \n#print metrics.accuracy_score(y_test, y_pred_class)\n#print rfc.score(X_test, y_test)\n#print rfc.classes_\n#print y_test[0]\n#print rfc.predict(X_test[0])\n#print rfc.predict_proba(X_test[0])\n\nY_des = rfc.predict(X_des)\n\n#Data is not binary and pos_label is not specified\n#precision, recall, pr_thresholds = precision_recall_curve(y_test, y_pred_class)\n#print precision,recall,pr_thresholds\n\nheaders = ['ImageId','Label']\n\nwith open('digit_submission.csv','w') as f:\n    f_csv = csv.writer(f)\n    f_csv.writerow(headers)\n    rowid = 1\n    for y in Y_des:\n        row = [rowid,y]\n        rowid += 1\n        f_csv.writerow(row)\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_508","text":"<filename>test\/algorithms\/test_bound.py\n\n# Copyright 2021 <NAME>\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     https:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nfrom nystrompca import calc_conf_bound, calculate_bound\nfrom nystrompca.base import Kernel\n\nimport numpy as np\nfrom numpy.testing import assert_array_almost_equal\nfrom scipy.stats import norm\n\n\ndef test_calc_conf_bound1():\n\n    L     = np.arange(1,11)[::-1] * 10\n    n     = 100\n    alpha = 0.5\n    B     = 1\n    \n    term1 = np.sqrt(2*np.log(4)) \/ np.sqrt(90)\n    term2 =  1 \/ np.sqrt(10)\n    D = 0.9 * (term1 + term2)\n    \n    expected_bounds = np.cumsum(L[:-1]\/10) * D**2 + D ** 3\n    expected_bounds = np.r_[expected_bounds, np.nan]\n\n    bounds = calc_conf_bound(np.diag(L), n, B, alpha)\n\n    assert_array_almost_equal(bounds, expected_bounds)\n\n\ndef test_calc_conf_bound2():\n\n    L     = np.exp(np.linspace(1,0,10))\n    n     = 20\n    alpha = 0.5\n    B     = 10\n    \n    term1 = 10 * np.sqrt(2*np.log(4)) \/ np.sqrt(10)\n    term2 =  100 \/ np.sqrt(10)\n    D = 0.5 * (term1 + term2)\n    \n    expected_bounds = np.cumsum(L[:-1]\/10) + D\n    expected_bounds = np.r_[expected_bounds, np.nan]\n\n    bounds = calc_conf_bound(np.diag(L), n, B, alpha)\n\n    assert_array_almost_equal(bounds, expected_bounds)\n\n\ndef test_calc_conf_bound3():\n\n    L     = np.arange(1,11)[::-1] * 10\n    n     = 1000\n    alpha = 0.9\n    B     = 0.5\n    \n    term1 = 0.5 * np.sqrt(2*np.log(20)) \/ np.sqrt(990)\n    term2 = 0.25 \/ np.sqrt(10)\n    D = 0.99 * (term1 + term2)\n    \n    expected_bounds = np.cumsum(L[:-1]\/10) * D**2 + D ** 3\n    expected_bounds = np.r_[expected_bounds, np.nan]\n\n    bounds = calc_conf_bound(np.diag(L), n, B, alpha)\n\n    assert_array_almost_equal(bounds, expected_bounds)\n\n\ndef test_calculate_bound():\n\n    X = np.random.randn(100,10)\n    kernel = Kernel(kernel='cauchy', sigma=5)\n    n = 2000\n    alpha = 0.75\n    K_mm = kernel.matrix(X, demean=False)\n    bounds1 = calculate_bound(X, n, 'cauchy', alpha, sigma=5)\n    bounds2 = calc_conf_bound(K_mm, n, 1, alpha)\n\n    assert_array_almost_equal(bounds1, bounds2)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_509","text":"<filename>clef20\/celebrity-profiling\/pan20_celebrity_profiling_evaluator_tests.py\nimport unittest\nfrom statistics import mean\nimport pan19_celebs_evaluator as pev\n\nclass TestRecallPrecision(unittest.TestCase):\n\n    def test_pr_gender(self):\n        truth = [\"male\", \"female\", \"binary\", \"male\", \"female\", \"binary\", \"male\", \"female\", \"binary\"]\n        predictions = [\"male\", \"female\", \"binary\", \"female\", \"binary\", \"male\", \"binary\", \"male\", \"female\"]\n        prec, rec = pev.mc_prec_rec(predictions, truth)\n        self.assertEqual(mean(prec), 1\/3)\n        self.assertEqual(mean(rec), 1\/3)\n\n    def test_pr_age(self):\n        truth = [1938, 1988, 2008, 1938, 1988, 2008, 1938, 1988, 2008]\n        predictions = [1929, 1984, 2006, 2006, 1929, 1984, 1984, 2008, 1929]\n        prec, rec = pev.mc_prec_rec(predictions, truth, hit_function=pev.age_window_hit)\n        self.assertEqual(mean(prec), 2.5\/3)\n        self.assertEqual(mean(rec), 1\/3)\n\n    def test_pr_age2(self):\n        truth = [2008, 2009, 2010, 2011, 2012]\n        predictions = [2008, 2008, 2008, 2008, 2008]\n        # after age_window_hit: predictions = [2008, 2009, 2008, 2008, 2008]\n        prec, rec = pev.mc_prec_rec(predictions, truth, hit_function=pev.age_window_hit)\n        self.assertEqual(mean([1\/3, 1, 1, 0, 0]), mean(prec))\n        self.assertEqual(mean([1, 1, 1, 0, 0]), mean(rec))\n\n    def test_pr_age3(self):\n        truth = [1978, 1979, 1980, 1981, 1982, 1983, 1984]\n        predictions = [1978, 1978, 1978, 1978, 1978, 1978, 1978]\n        # after age_window_hit: predictions = [1978, 1979, 1980, 1981, 1982, 1983, 1978]\n        prec, rec = pev.mc_prec_rec(predictions, truth, hit_function=pev.age_window_hit)\n        self.assertEqual(mean([1\/2, 1, 1, 1, 1, 1, 0]), mean(prec))\n        self.assertEqual(mean([1, 1, 1, 1, 1, 1, 0]), mean(rec))\n\n\nclass TestAgeWindowHit(unittest.TestCase):\n\n    def test_bounds(self):\n        self.assertTrue(pev.age_window_hit(2008, 2008))\n        self.assertTrue(pev.age_window_hit(2006, 2008))\n        self.assertTrue(pev.age_window_hit(2010, 2008))\n        self.assertTrue(not pev.age_window_hit(2011, 2008))\n        self.assertTrue(not pev.age_window_hit(2005, 2008))\n        self.assertTrue(pev.age_window_hit(2008, 2010))\n\n        self.assertTrue(pev.age_window_hit(1988, 1988))\n        self.assertTrue(pev.age_window_hit(1984, 1988))\n        self.assertTrue(pev.age_window_hit(1992, 1988))\n        self.assertTrue(not pev.age_window_hit(1983, 1988))\n        self.assertTrue(not pev.age_window_hit(1993, 1988))\n\n        self.assertTrue(pev.age_window_hit(1929, 1938))\n        self.assertTrue(pev.age_window_hit(1947, 1938))\n        self.assertTrue(not pev.age_window_hit(1928, 1938))\n        self.assertTrue(not pev.age_window_hit(1948, 1938))\n\n\nif __name__ == \"__main__\":\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_510","text":"from OpenPNM.Utilities import misc\nimport scipy as _sp\nimport numpy as _np\nimport os as _os\nimport pickle as _pickle\nfrom xml.etree import ElementTree as _ET\n\n\nclass VTK():\n    r\"\"\"\n    Class for writing a Vtp file to be read by ParaView\n\n    \"\"\"\n\n    _TEMPLATE = '''\n    <?xml version=\"1.0\" ?>\n    <VTKFile byte_order=\"LittleEndian\" type=\"PolyData\" version=\"0.1\">\n        <PolyData>\n            <Piece NumberOfLines=\"0\" NumberOfPoints=\"0\">\n                <Points>\n                <\/Points>\n                <Lines>\n                <\/Lines>\n                <PointData>\n                <\/PointData>\n                <CellData>\n                <\/CellData>\n            <\/Piece>\n        <\/PolyData>\n    <\/VTKFile>\n    '''.strip()\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n    @staticmethod\n    def save(network, filename='', phases=[]):\n        r\"\"\"\n        Save network and phase data to a single vtp file for visualizing in\n        Paraview\n\n        Parameters\n        ----------\n        network : OpenPNM Network Object\n            The Network containing the data to be written\n\n        filename : string, optional\n            Filename to write data.  If no name is given the file is named after\n            ther network\n\n        phases : list, optional\n            A list contain OpenPNM Phase object(s) containing data to be written\n\n        Examples\n        --------\n        >>> import OpenPNM\n        >>> pn = OpenPNM.Network.Cubic(shape=[3,3,3])\n        >>> geo = OpenPNM.Geometry.Stick_and_Ball(network=pn,\n        ...                                       pores=pn.pores(),\n        ...                                       throats=pn.throats())\n        >>> air = OpenPNM.Phases.Air(network=pn)\n        >>> phys = OpenPNM.Physics.Standard(network=pn, phase=air,\n        ...                                 pores=pn.pores(), throats=pn.throats())\n\n        >>> import OpenPNM.Utilities.IO as io\n        >>> io.VTK.save(pn,'test_pn.vtp',[air])\n\n        >>> # Delete the new file\n        >>> import os\n        >>> os.remove('test_pn.vtp')\n        \"\"\"\n\n        if filename == '':\n            filename = network.name\n        filename = filename.split('.')[0] + '.vtp'\n\n        root = _ET.fromstring(VTK._TEMPLATE)\n        objs = []\n        if type(phases) != list:\n            phases = [phases]\n        for phase in phases:\n            objs.append(phase)\n        objs.append(network)\n        am = misc.amalgamate_data(objs=objs)\n        key_list = list(sorted(am.keys()))\n        points = network['pore.coords']\n        pairs = network['throat.conns']\n\n        num_points = len(points)\n        num_throats = len(pairs)\n\n        piece_node = root.find('PolyData').find('Piece')\n        piece_node.set(\"NumberOfPoints\", str(num_points))\n        piece_node.set(\"NumberOfLines\", str(num_throats))\n\n        points_node = piece_node.find('Points')\n        coords = VTK._array_to_element(\"coords\", points.T.ravel('F'), n=3)\n        points_node.append(coords)\n\n        lines_node = piece_node.find('Lines')\n        connectivity = VTK._array_to_element(\"connectivity\", pairs)\n        lines_node.append(connectivity)\n        offsets = VTK._array_to_element(\"offsets\", 2*_np.arange(len(pairs))+2)\n        lines_node.append(offsets)\n\n        point_data_node = piece_node.find('PointData')\n        for key in key_list:\n            array = am[key]\n            if array.dtype == _np.bool:\n                array = array.astype(int)\n            if array.size != num_points:\n                continue\n            element = VTK._array_to_element(key, array)\n            point_data_node.append(element)\n\n        cell_data_node = piece_node.find('CellData')\n        for key in key_list:\n            array = am[key]\n            if array.dtype == _np.bool:\n                array = array.astype(int)\n            if array.size != num_throats:\n                continue\n            element = VTK._array_to_element(key, array)\n            cell_data_node.append(element)\n\n        tree = _ET.ElementTree(root)\n        tree.write(filename)\n\n        # Make pretty\n        with open(filename, 'r+') as f:\n            string = f.read()\n            string = string.replace('<\/DataArray>', '<\/DataArray>\\n\\t\\t\\t')\n            f.seek(0)\n            # consider adding header: '<?xml version=\"1.0\"?>\\n'+\n            f.write(string)\n\n    @staticmethod\n    def load(filename):\n        r\"\"\"\n        Read in pore and throat data from a saved VTK file.\n\n        Notes\n        -----\n        This will NOT reproduce original simulation, since all models and object\n        relationships are lost.  Use IO.Save and IO.Load for that.\n        \"\"\"\n        network = OpenPNM.Network.GenericNetwork()\n        tree = _ET.parse(filename)\n        piece_node = tree.find('PolyData').find('Piece')\n\n        # Extract connectivity\n        conn_element = piece_node.find('Lines').find('DataArray')\n        array = VTK._element_to_array(conn_element, 2)\n        network['throat.conns'] = array.T\n\n        for element in piece_node.find('PointData').iter('DataArray'):\n            key = element.get('Name')\n            array = VTK._element_to_array(element)\n            netname = key.split('.')[0]\n            propname = key.strip(netname+'.')\n            network[propname] = array\n\n        return network\n\n    @staticmethod\n    def _array_to_element(name, array, n=1):\n        dtype_map = {\n            'int8': 'Int8',\n            'int16': 'Int16',\n            'int32': 'Int32',\n            'int64': 'Int64',\n            'uint8': 'UInt8',\n            'uint16': 'UInt16',\n            'uint32': 'UInt32',\n            'uint64': 'UInt64',\n            'float32': 'Float32',\n            'float64': 'Float64',\n            'str': 'String',\n        }\n        element = _ET.Element('DataArray')\n        element.set(\"Name\", name)\n        element.set(\"NumberOfComponents\", str(n))\n        element.set(\"type\", dtype_map[str(array.dtype)])\n        element.text = '\\t'.join(map(str, array.ravel()))\n        return element\n\n    @staticmethod\n    def _element_to_array(element, n=1):\n        string = element.text\n        dtype = element.get(\"type\")\n        array = _np.fromstring(string, sep='\\t')\n        array = array.astype(dtype)\n        if n is not 1:\n            array = array.reshape(array.size\/\/n, n)\n        return array\n\n\nclass MAT():\n    r\"\"\"\n    Class for reading and writing OpenPNM data to a Matlab 'mat' file\n    \"\"\"\n\n    @staticmethod\n    def save(network, filename='', phases=[]):\n        r\"\"\"\n        Write Network to a Mat file for exporting to Matlab. This method will be\n        enhanced in a future update, and it's functionality may change!\n\n        Parameters\n        ----------\n\n        network : OpenPNM Network Object\n\n        filename : string\n            Desired file name, defaults to network name if not given\n\n        phases : list of phase objects ([])\n            Phases that have properties we want to write to file\n\n        Examples\n        --------\n        >>> import OpenPNM\n        >>> pn = OpenPNM.Network.TestNet()\n        >>> geo = OpenPNM.Geometry.TestGeometry(network=pn,\n        ...                                     pores=pn.pores(),\n        ...                                     throats=pn.throats())\n        >>> air = OpenPNM.Phases.TestPhase()\n        >>> import OpenPNM.Utilities.IO as io\n        >>> io.MAT.save(network=pn, filename='test_pn.mat', phases=air)\n\n        >>> # Remove newly created file\n        >>> import os\n        >>> os.remove('test_pn.mat')\n\n        \"\"\"\n        if filename == '':\n            filename = network.name\n        filename = filename.split('.')[0] + '.mat'\n\n        pnMatlab = {}\n        new = []\n        old = []\n        for keys in list(network.keys()):\n            old.append(keys)\n            new.append(keys.replace('.', '_'))\n\n        for i in range(len(network)):\n            pnMatlab[new[i]] = network[old[i]]\n\n        if type(phases) != list:\n            phases = [phases]\n        if len(phases) != 0:\n            for j in range(len(phases)):\n                new = []\n                old = []\n\n                for keys in list(phases[j].keys()):\n                    old.append(keys)\n                    new.append(phases[j].name+'_'+keys.replace('.', '_'))\n\n                for i in range(len(phases[j])):\n                    pnMatlab[new[i]] = phases[j][old[i]]\n\n        _sp.io.savemat(file_name=filename, mdict=pnMatlab)\n\n    @staticmethod\n    def load():\n        r\"\"\"\n        This method is not implemented yet.\n        \"\"\"\n        raise NotImplemented()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_511","text":"<gh_stars>0\nfrom scipy.optimize import curve_fit\nfrom numpy import ndarray\nfrom pyequalizer.optim import *\nfrom copy import deepcopy\n\ndef find_line(front):\n    \"\"\"\n    find_line(front): Find a rational regression line between the stress and strain values of a set of pareto fronts. \n    Parameters: \n    front: A list of pyequalizer.optim.Individuals that define the pareto front. \n    \"\"\"\n    sct_x, sct_y = get_plot_pts(front)\n    def ratline(x, c, e, h, eps):\n        ex = deepcopy(x)\n        try:\n            for a in range(len(ex)):\n                if ex[a] + h < 0:\n                    ex[a] = -h + 0.01\n        except:\n            if ex + h < 0:\n                ex = 0.01 - h\n        ret = c*(ex+h)**(-float(e))+eps\n        return ret\n    params, _ = curve_fit(ratline, sct_x, sct_y, [100., 0.1, -250., 20.], maxfev=100000000)\n    print (params)\n    return lambda x: ratline(x, *params)\n\ndef get_error(point, reg):\n    \"\"\"\n    Get the squared error between a specified 2-d point and\n    a function, typically a regression line.\n\n    Arguments: \n        * point: A 1x2 array of numbers that define a point in space. \n        * reg: A function that takes in a number and returns one other number. \n               Typically defines a regression curve. \n    \"\"\"\n    return (point[1] - reg(point[0]))**2\n\ndef get_closest(inds, reg):\n    \"\"\"\n    Get a set of the closest individuals in a population \n    to the previously generated regression line. \n\n    Arguments: \n        * inds: An array of Inds as defined in pyequalizer.optim. \n        * reg: A regression line. Function taking on numeric argument and \n               returning a numeric result. \n    \"\"\"\n    ind_c = deepcopy(inds)\n    pts = list(zip(*get_plot_pts(inds)))\n    for i in range(len(pts)): \n        cost = get_error(pts[i], reg)\n        ind_c[i].fitness.append(cost)\n    return isolate_pareto(ind_c)\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_504","text":"<reponame>geopi1\/Improved_USRNet\nfrom scipy.io import loadmat\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n\n# kernel = np.zeros((17,17))\n# kernel[6:11,6:11] = np.ones((5,5),np.float32)\/25\nx = loadmat('.\/results\/soldiers_ww2_small\/soldiers_ww2_small_kernel_x2.mat')['Kernel']\nplt.figure()\n# plt.subplot(1,2,1)\n# plt.title('original kernel')\n# plt.imshow(kernel,'gray')\n# plt.subplot(1,2,2)\nplt.title('estimated kernel')\nplt.imshow(x,'gray')\n\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_560","text":"<reponame>sequence-dev\/sequence<filename>sequence\/subsidence.py<gh_stars>1-10\n#! \/usr\/bin\/env python\nimport numpy as np\nfrom landlab import Component\nfrom scipy import interpolate\n\n\nclass SubsidenceTimeSeries(Component):\n\n    _name = \"Subsider\"\n\n    _time_units = \"y\"\n\n    _info = {\n        \"bedrock_surface__increment_of_elevation\": {\n            \"dtype\": \"float\",\n            \"intent\": \"out\",\n            \"optional\": False,\n            \"units\": \"m\",\n            \"mapping\": \"node\",\n            \"doc\": \"Increment of elevation\",\n        },\n        \"bedrock_surface__elevation\": {\n            \"dtype\": \"float\",\n            \"intent\": \"inout\",\n            \"optional\": False,\n            \"units\": \"m\",\n            \"mapping\": \"node\",\n            \"doc\": \"Surface elevation\",\n        },\n    }\n\n    def __init__(self, grid, filepath=None, kind=\"linear\"):\n        \"\"\"Generate subsidence rates.\n\n        Parameters\n        ----------\n        grid: RasterModelGrid\n            A landlab grid.\n        filepath: str\n            Name of csv-formatted subsidence file.\n        kind: str, optional\n            Kind of interpolation as a string (one of 'linear',\n            'nearest', 'zero', 'slinear', 'quadratic', 'cubic').\n            Default is 'linear'.\n        \"\"\"\n        super(SubsidenceTimeSeries, self).__init__(grid)\n\n        self._filepath = filepath\n        self._kind = kind\n\n        data = np.loadtxt(filepath, delimiter=\",\", comments=\"#\")\n        subsidence = SubsidenceTimeSeries._subsidence_interpolator(\n            data, kind=self._kind\n        )\n        inc = self.grid.add_empty(\n            \"bedrock_surface__increment_of_elevation\", at=\"node\"\n        ).reshape(self.grid.shape)\n        inc[:] = subsidence(self.grid.x_of_node[self.grid.nodes_at_bottom_edge])\n\n        self._dz = inc.copy()\n        self._time = 0.0\n\n    @staticmethod\n    def _subsidence_interpolator(data, kind=\"linear\"):\n        return interpolate.interp1d(\n            data[:, 0],\n            data[:, 1],\n            kind=kind,\n            copy=True,\n            assume_sorted=True,\n            bounds_error=True,\n        )\n\n    @property\n    def time(self):\n        return self._time\n\n    @property\n    def filepath(self):\n        return self._filepath\n\n    @filepath.setter\n    def filepath(self, new_path):\n        self._filepath = new_path\n        subsidence = SubsidenceTimeSeries._subsidence_interpolator(\n            np.loadtxt(self._filepath, delimiter=\",\", comments=\"#\"), kind=self._kind\n        )\n        inc = self.grid.at_node[\"bedrock_surface__increment_of_elevation\"].reshape(\n            self.grid.shape\n        )\n        inc[:] = subsidence(self.grid.x_of_node[self.grid.nodes_at_bottom_edge])\n        self._dz = inc.copy()\n\n    def run_one_step(self, dt):\n        dz = self.grid.at_node[\"bedrock_surface__increment_of_elevation\"]\n        z = self.grid.at_node[\"bedrock_surface__elevation\"]\n        z_top = self.grid.at_node[\"topographic__elevation\"]\n\n        dz = dz.reshape(self.grid.shape)\n        z = z.reshape(self.grid.shape)\n        z_top = z_top.reshape(self.grid.shape)\n\n        dz[:] = self._dz * dt\n        z[:] += dz\n        z_top[:] += dz\n\n        self._time += dt\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_561","text":"import h5py\nimport numpy as np\nfrom scipy.io import loadmat\nfrom operator import itemgetter\nimport math\nimport scipy as sp\nimport cv2\nimport matplotlib.pyplot as plt\nimport os, sys\nimport time\nimport multiprocessing\n\n\nimport random\n\n# Generate Observation Map\ndef func(theta, m, I, imax, L, w, N, anglemask):\n    print('*',end='')\n    rotmat = np.array([[np.cos(theta), -np.sin(theta)],[np.sin(theta), np.cos(theta)]])\n    p = 0.5*(L[:,0]+1)*(w-1) #x 0:w-1\n    q = 0.5*(L[:,1]+1)*(w-1) #y 0:w-1\n    x = [p-0.5*(w-1), q-0.5*(w-1)]\n    x_ = np.dot(rotmat, x)\n    p = x_[0,:]+0.5*(w-1);\n    q = x_[1,:]+0.5*(w-1);\n    p = np.int32(p)\n    q = np.int32(q)\n    light_idx = q*w + p # 0:w*w-1\n    x = [N[:,0], N[:,1]]\n    x_ = np.dot(rotmat, x)\n    pn = x_[0,:];\n    qn = x_[1,:];\n    normal = [np.transpose(pn), np.transpose(qn), N[:,2]]\n    normal = np.transpose(normal)\n    temp = I*anglemask\/np.transpose(imax)\n    embed = np.zeros((m, w*w), np.float32)\n    embed[:, light_idx] = temp\n    embed = np.reshape(embed, (m, w, w))\n    mask = np.zeros((m, w*w), np.bool_)\n    mask[:, light_idx] = anglemask\n    mask = np.reshape(mask, (m, w, w))\n    return embed, mask, normal, rotmat\n\ndef wrapper(args):\n    return func(*args)\n\n\n# for multi core cpu\ndef light_embedding_2d_rot_invariant_multi(I, imax, L, w, N, div, isRandomThresh):\n\n    m = I.shape[0]\n    rows = w\n    cols = w\n    embed_rot = []\n    normal_rot = []\n    mask_rot = []\n    rot = []\n\n    anglemask = np.zeros((I.shape[0],I.shape[1]),np.float32)\n    for k in range(I.shape[0]): # numpixel\n        angle1 = 180*np.arccos(L[:,2])\/np.pi\n        if isRandomThresh == True:\n            tgt = np.where(angle1<random.randint(20,90))\n            tgtrandom = np.random.permutation(tgt[0])\n            tgt = tgtrandom[:random.randint(50,np.min([1000,L.shape[0]]))]\n        else:\n            tgt = np.where(angle1<90)\n        anglemask[k,tgt] = 1\n\n    n = multiprocessing.cpu_count()\n    p = multiprocessing.Pool(n)\n\n    params = [(np.pi*(i*360.0\/div)\/180, m, I, imax, L, w, N, anglemask) for i in range(np.int32(div))]\n    result = p.map(wrapper, params)\n    p.close()\n\n    embed_list = []\n    mask_list = []\n    nml_list = []\n    rot_list = []\n    for i in range(div):\n        embed_list.append(result[i][0].copy())\n        mask_list.append(result[i][1].copy())\n        nml_list.append(result[i][2].copy())\n        rot_list.append(result[i][3].copy())\n\n    embed_list = np.array(embed_list)\n    embed_list = np.transpose(embed_list, (1,0,2,3))\n\n    mask_list = np.array(mask_list)\n    mask_list = np.transpose(mask_list, (1,0,2,3))\n\n    nml_list = np.array(nml_list)\n    nml_list = np.transpose(nml_list, (1,0,2))\n\n    del result,anglemask\n\n    return np.array(embed_list), np.array(mask_list), np.array(nml_list), np.array(rot_list), rows, cols\n\n# for single core cpu\ndef light_embedding_2d_rot_invariant(I, imax, L, w, N, div, isRandomThresh):\n\n    m = I.shape[0]\n\n    embed_rot = []\n    normal_rot = []\n    mask_rot = []\n    rot = []\n    count = 0\n\n    anglemask = np.zeros((I.shape[0],I.shape[1]),np.float32)\n    for k in range(I.shape[0]):\n\n        angle1 = 180*np.arccos(L[:,2])\/np.pi\n        if isRandomThresh == True:\n            tgt = np.where(angle1<random.randint(20,90))\n            tgtrandom = np.random.permutation(tgt[0])\n            tgt = tgtrandom[:random.randint(50,np.min([1000,L.shape[0]]))]\n        else:\n            tgt = np.where(angle1<90)\n        anglemask[k,tgt] = 1\n\n    for k in range(div):\n        theta = k*360\/div\n        if theta < 360:\n            count = count + 1\n            theta = np.pi*theta\/180\n            rotmat = np.array([[np.cos(theta), -np.sin(theta)],[np.sin(theta), np.cos(theta)]])\n            p = 0.5*(L[:,0]+1)*(w-1) #x 0:w-1\n            q = 0.5*(L[:,1]+1)*(w-1) #y 0:w-1\n            x = [p-0.5*(w-1), q-0.5*(w-1)]\n            x_ = np.dot(rotmat, x)\n            p = x_[0,:]+0.5*(w-1);\n            q = x_[1,:]+0.5*(w-1);\n            p = np.int32(p)\n            q = np.int32(q)\n            light_idx = q*w + p # 0:w*w-1\n\n            x = [N[:,0], N[:,1]]\n            x_ = np.dot(rotmat, x)\n            pn = x_[0,:];\n            qn = x_[1,:];\n            normal = [np.transpose(pn), np.transpose(qn), N[:,2]]\n            normal = np.transpose(normal)\n\n            temp = I*anglemask\/np.transpose(imax)\n            embed = np.zeros((m, w*w), np.float32)\n            embed[:, light_idx] = temp\n            embed = np.reshape(embed, (m, w, w))\n            embed_rot.append(embed.copy())\n            mask = np.zeros((m, w*w), np.bool_)\n            mask[:, light_idx] = anglemask\n            mask = np.reshape(mask, (m, w, w))\n            mask_rot.append(mask.copy())\n\n            normal_rot.append(normal.copy())\n            rot.append(rotmat.copy())\n\n            del embed, temp, normal, mask\n\n    rows = w\n    cols = w\n\n    embed_rot = np.array(embed_rot)\n    embed_rot = np.transpose(embed_rot, (1,0,2,3))\n\n    mask_rot = np.array(mask_rot)\n    mask_rot = np.transpose(mask_rot, (1,0,2,3))\n\n    normal_rot = np.array(normal_rot)\n    normal_rot = np.transpose(normal_rot, (1,0,2))\n\n    return np.array(embed_rot), np.array(mask_rot), np.array(normal_rot), np.array(rot), rows, cols\n\n\n# main function for generating the observation map\ndef light_embedding_main(Iv, Nv, L, w, rotdiv, validind, isRandomThresh):\n\n    imax = np.amax(Iv,axis=1) # for entire image\n    valid = np.intersect1d(validind, np.where(imax>0))\n    Iv = Iv[valid,:]\n    Nv = Nv[valid,:]\n    imax = imax[valid]\n    if rotdiv > 1:\n        embed, mask, nm, rot, rows, cols = light_embedding_2d_rot_invariant_multi(Iv, [imax], L, w, Nv, rotdiv, isRandomThresh)\n    else:\n        embed, mask, nm, rot, rows, cols = light_embedding_2d_rot_invariant(Iv, [imax], L, w, Nv, rotdiv, isRandomThresh)\n\n    embed = np.reshape(embed, (embed.shape[0]*embed.shape[1],w,w))\n    embed = np.reshape(embed, (embed.shape[0],1,w,w))\n    mask = np.reshape(mask, (mask.shape[0]*mask.shape[1],w,w))\n    mask = np.reshape(mask, (mask.shape[0],1,w,w))\n    nm = np.reshape(nm, (nm.shape[0]*nm.shape[1],3))\n    return embed, mask, nm\n\n# prepare observation map for cyclesPS dataset (for training)\ndef prep_data_2d_from_images_cycles(dirlist, dirname, scale, w, rotdiv_in, rotdiv_on):\n    S = []\n    M = []\n    N = []\n    for d in dirlist:\n        dirpath = d\n\n        images_dir = dirpath + '\/' + dirname\n        normal_path = dirpath + '\/' + 'gt_normal.tif'\n        inboundary_path = dirpath + '\/' + 'inboundary.png'\n        onboundary_path = dirpath + '\/' + 'onboundary.png'\n\n        # read ground truth surface normal\n        nml = np.float32(cv2.imread(normal_path,-1))\/65535.0 # [-1,1]\n        nml = nml[:,:,::-1]\n        nml = 2*nml-1\n        nml = cv2.resize(nml, None, fx = scale, fy = scale, interpolation = cv2.INTER_NEAREST)\n        nShape = np.shape(nml)\n        height = nShape[0]\n        width = nShape[1]\n\n        # read mask images_metallic\n        inboundary = cv2.imread(inboundary_path,-1)\n        inboundary = cv2.resize(inboundary, None, fx = scale, fy = scale, interpolation = cv2.INTER_NEAREST)\n        inboundary = np.where(inboundary>0)\n        inboundary_ind = inboundary[0]*height + inboundary[1]\n        onboundary = cv2.imread(onboundary_path,-1)\n        onboundary = cv2.resize(onboundary, None, fx = scale, fy = scale, interpolation = cv2.INTER_NEAREST)\n        onboundary = np.where(onboundary>0)\n        onboundary_ind = onboundary[0]*height + onboundary[1]\n\n        # read light filenames\n        f = open(dirpath + '\/' 'light.txt')\n        data = f.read()\n        f.close\n        lines = data.split('\\n')\n        numLight = len(lines)-1 # the last line is empty (how to fix it?)\n\n        L = np.zeros((numLight,3), np.float32)\n        for i,l in enumerate(lines):\n            s = l.split(' ')\n            if len(s) == 3:\n                L[i,0] = float(s[0])\n                L[i,1] = float(s[1])\n                L[i,2] = float(s[2])\n\n        # read images\n        I = np.zeros((numLight, height, width), np.float32)\n\n        for i in range(numLight):\n            if i % np.floor(numLight\/10) == 0:\n                print('.',end='')\n\n            image_path = images_dir + '\/' + '%05d.tif' % i\n\n            cv2_im = cv2.imread(image_path, -1)\/65535.0\n            cv2_im = (cv2_im[:,:,0] + cv2_im[:,:,1] + cv2_im[:,:,2])\/3\n            cv2_im = cv2.resize(cv2_im, (height,width), interpolation = cv2.INTER_NEAREST)\n            I[i,:,:] = cv2_im\n\n\n        Iv = np.reshape(I,(numLight, height*width))\n        Iv = np.transpose(Iv)\n\n        Nv = np.reshape(nml,(height*width,3))\n\n        embed_in, mask_in, nm_in = light_embedding_main(Iv, Nv, L, w, rotdiv_in, inboundary_ind, True)\n        embed_on, mask_on, nm_on = light_embedding_main(Iv, Nv, L, w, rotdiv_on, onboundary_ind, True)\n\n        embed = []\n        embed.append(embed_in.copy())\n        embed.append(embed_on.copy())\n        embed = np.concatenate(embed, axis=0 )\n\n        mask = []\n        mask.append(mask_in.copy())\n        mask.append(mask_on.copy())\n        mask = np.concatenate(mask, axis=0 )\n\n        nm = []\n        nm.append(nm_in.copy())\n        nm.append(nm_on.copy())\n        nm = np.concatenate(nm, axis=0 )\n\n\n        S.append(embed.copy())\n        M.append(mask.copy())\n        N.append(nm.copy())\n        print('')\n\n        del embed_in, mask_in, nm_in\n        del embed_on, mask_on, nm_on\n        del embed, mask, nm, I, Iv, Nv\n\n    S = np.concatenate(S, axis=0 )\n    M = np.concatenate(M, axis=0 )\n    N = np.concatenate(N, axis=0 )\n\n    S = np.reshape(S, (S.shape[0], S.shape[2], S.shape[3], 1))\n    M = np.reshape(M, (M.shape[0], M.shape[2], M.shape[3], 1))\n    return np.array(S), np.array(M), np.array(N)\n\n# prepare observation maps for test data (i.e., DiLiGenT dataset)\ndef prep_data_2d_from_images_test(dirlist, scale, w, rotdiv, index=-1):\n\n    SList = []\n    NList = []\n    RList = []\n    IDList = []\n    SizeList = []\n    for d in dirlist:\n        print('load' + '%s' % d)\n        S = []\n        N = []\n        dirpath = d\n        images_dir = dirpath\n        normal_path = dirpath + '\/' + 'normal.txt'\n        mask_path = dirpath + '\/' + 'mask.png'\n\n        # get image imgSize\n        image_path = images_dir + '\/' + '001.png'\n        cv2_im = cv2.imread(image_path, -1)\n        nShape = np.shape(cv2_im)\n        height = nShape[0]\n        width = nShape[1]\n\n        # read ground truth surface normal\n        f = open(normal_path)\n        data = f.read()\n        f.close\n        lines = np.float32(np.array(data.split('\\n')))\n        nml = np.reshape(lines, (height,width,3))\n        nml = cv2.resize(nml, None, fx = scale, fy = scale, interpolation = cv2.INTER_NEAREST)\n\n        # nml = np.flipud(nml) # Uncomment when test on Harvest, the surface noraml needs to be fliped upside down\n\n        nShape = np.shape(nml)\n        height = nShape[0]\n        width = nShape[1]\n\n        # uncomment if you want to see the ground truth normal map\n        # plt.figure(figsize=(16,16))\n        # plt.imshow(np.uint8(127*(nml+1)))\n        # plt.axis('off')\n        # plt.show()\n\n        # read mask\n        mask = cv2.imread(mask_path,-1)\n        mask = cv2.resize(mask, None, fx = scale, fy = scale, interpolation = cv2.INTER_NEAREST)\n        validsub = np.where(mask>0)\n        validind = validsub[0]*width + validsub[1]\n\n        # read light directions\n        f = open(dirpath + '\/' 'light_directions.txt')\n        data = f.read()\n        f.close\n        lines = data.split('\\n')\n        numLight = len(lines)-1 # the last line is empty (how to fix it?)\n\n        L = np.zeros((numLight,3), np.float32)\n        for i,l in enumerate(lines):\n            s = l.split(' ')\n            if len(s) == 3:\n                L[i,0] = float(s[0])\n                L[i,1] = float(s[1])\n                L[i,2] = float(s[2])\n\n        # read light intensities\n        f = open(dirpath + '\/' 'light_intensities.txt')\n        data = f.read()\n        f.close\n        lines = data.split('\\n')\n\n        Li = np.zeros((numLight,3), np.float32)\n        for i,l in enumerate(lines):\n            s = l.split(' ')\n            if len(s) == 3:\n                Li[i,0] = float(s[0])\n                Li[i,1] = float(s[1])\n                Li[i,2] = float(s[2])\n        \n        \n\n\n        if index == -1:\n            setName = os.path.basename(dirpath.rstrip('\/')) # if dirpath ends in '\/' basename returns the empty string\n            if setName == 'bearPNG':\n                # the first 20 images of bearPNG have errors, see paper\n                index = range(20, numLight)\n            else:\n                index = range(0, numLight)\n\n        L = L[index,:]\n        Li = Li[index,:]\n        numLight = len(index)\n\n        # read images\n        I = np.zeros((numLight, height, width), np.float32)\n\n        for i, idx in enumerate(index):\n            if i % np.floor(numLight\/10) == 0:\n                print('.',end='')\n            image_path = images_dir + '\/' + '%03d.png' % (idx + 1)\n            cv2_im = cv2.imread(image_path, -1)\/65535.0\n            cv2_im = (cv2_im[:,:,0]\/Li[i,0] + cv2_im[:,:,1]\/Li[i,1] + cv2_im[:,:,2]\/Li[i,2])\/3\n            cv2_im = cv2.resize(cv2_im, None, fx = scale, fy = scale,interpolation = cv2.INTER_NEAREST)\n            I[i,:,:] = cv2_im\n\n        Iv = np.reshape(I,(numLight, height*width))\n        Iv = np.transpose(Iv)\n        Nv = np.reshape(nml,(height*width,3))\n\n        imax = np.amax(Iv,axis=1) # for entire image\n        valid = np.intersect1d(validind, np.where(imax>0))\n        Iv = Iv[valid,:]\n        Nv = Nv[valid,:]\n        imax = imax[valid]\n        embed_list = []\n        embed, mask, nm, rot, rows, cols = light_embedding_2d_rot_invariant(Iv, [imax], L, w, Nv, rotdiv, False)\n        SList.append(embed)\n        RList.append(rot)\n        NList.append(nm)\n        IDList.append(valid)\n        SizeList.append((height,width))\n\n        print('')\n    return np.array(SList), np.array(NList), np.array(RList), np.array(IDList), np.array(SizeList)\n\n\n# Test and evaluate network\ndef TestNetwork(model, Sv,Nv,Rv,IDv,Szv,showFig, isTensorFlow):\n    numData = len(Sv)\n    for i in range(numData):\n        S = Sv[i]\n        N = Nv[i]\n        R = Rv[i]\n        ID = IDv[i]\n        height = Szv[i,0]\n        width  = Szv[i,1]\n        rotdiv = S.shape[1]\n        NestList = []\n        for r in range(rotdiv):\n            embed_div = S[:,r,:,:]\n            if isTensorFlow:\n                embed_div = np.reshape(embed_div, (embed_div.shape[0], embed_div.shape[1], embed_div.shape[2], 1))\n            else:\n                embed_div = np.reshape(embed_div, (embed_div.shape[0], 1, embed_div.shape[1], embed_div.shape[2]))\n            # predict\n            outputs=model.predict(embed_div)\n            Nest = np.zeros((height*width,3), np.float32)\n            error = 0\n            Err = np.zeros((height*width,3), np.float32)\n            rot = R[r,:,:]\n            # N = np.zeros()\n            for k in range(len(ID)):\n                # n = outputs[k,:];\n                n = np.zeros((2,1),np.float32)\n                n[0] = outputs[k,0]\n                n[1] = outputs[k,1]\n                n = np.dot(np.linalg.inv(rot),n)\n                n = [n[0,0],n[1,0],outputs[k,2]]\n                n = n\/np.sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2])\n                nt = N[k,0,:];\n                Nest[ID[k],:] = n\n                for l in range(3):\n                    Err[ID[k],l] = 180*math.acos(min(1,abs(n.dot(np.transpose(nt)))))\/math.pi\n                error = error + 180*math.acos(min(1,abs(n.dot(np.transpose(nt)))))\/math.pi\n            print('%d ' % i + '[Angle %d] Ave.Error = %.2f ' % (r,(error\/len(ID))))\n            NestList.append(Nest.copy())\n\n        NestMean = np.mean(NestList,axis=0)\n        Nest = np.zeros((height*width,3), np.float32)\n        error = 0\n        Err = np.zeros((height*width,3), np.float32)\n        for k in range(len(ID)):\n            # n = outputs[k,:];\n            n = NestMean[ID[k],:]\n            n = n\/np.sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2])\n            nt = N[k,0,:];\n            Nest[ID[k],:] = n\n            for l in range(3):\n                Err[ID[k],l] = 180*math.acos(min(1,abs(n.dot(np.transpose(nt)))))\/math.pi\n            error = error + 180*math.acos(min(1,abs(n.dot(np.transpose(nt)))))\/math.pi\n\n        if rotdiv >= 2:\n            print('%s ' % i + '[Mean] Ave.Error = %.2f ' % (error\/len(ID)))\n\n        Err = np.reshape(Err,(height,width,3))\n        Nest = np.reshape(Nest, (height,width,3))\n\n        if showFig == True:\n            plt.figure(figsize=(16,16))\n            plt.imshow(np.concatenate((np.uint8(127*(Nest+1)),5*np.uint8(Err)), axis=1))\n            plt.axis('off')\n            plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_562","text":"import sympy\nfrom sympy.assumptions.assume import AppliedPredicate, global_assumptions\nfrom typing import Dict, List, Union\n\na, b, c = sympy.symbols('a b c')\nd_a, d_b, d_c = sympy.symbols('Δa Δb Δc')\n\n\nclass Expression:\n    args: List[sympy.Symbol]\n    expr: sympy.Expr\n\n    def __init__(self, args: List[sympy.Symbol], expr: sympy.Expr):\n        \"\"\"Initialize an Expression instance with a sympy expression and its arguments.\n\n        :param args: the variables in the expression\n        :param expr: the mathematical expression\n\n        >>> Expression([a, b, c], a + b + c)\n        f(a, b, c) = a + b + c\n        >>> Expression([a, b, c], a * b \/ c)\n        f(a, b, c) = a*b\/c\n        >>> Expression([a, b, c], sympy.root(a ** b, c))\n        f(a, b, c) = (a**b)**(1\/c)\n        \"\"\"\n        self.args = args\n        self.expr = expr\n\n    def __repr__(self) -> str:\n        \"\"\"Show this expression as a mathematical function.\n\n        :rtype str\n\n        >>> str(Expression([a], a * sympy.pi))\n        'f(a) = pi*a'\n        >>> repr(Expression([], sympy.E))\n        'f() = E'\n        \"\"\"\n        if len(self.args) == 1:\n            return f\"f({self.args[0]}) = {self.expr}\"\n        return f\"f{tuple(self.args)} = {self.expr}\"\n\n    def evaluate(self, values: Dict[Union[str, sympy.Symbol], float], precision: int =3) -> sympy.Expr:\n        \"\"\"Evaluate the expression with the given values.\n\n        :param values: a dictionary mapping all the sympy symbols in the args to numeric values\n        :param precision: the number of digits in the results\n        :return: the result of the evaluation as an sympy expression\n\n        >>> Expression([a, b, c], a + b + c).evaluate({a: 1, b: 2, c: 3})\n        6.00\n        >>> Expression([a, b, c], a ** b + c).evaluate({'a': c, 'b': 1})\n        2.0*c\n        \"\"\"\n        return self.expr.subs(values).evalf(precision)\n\n    def calculate_absolute_uncertainty(self, *assumptions: List[AppliedPredicate],\n                                       refine: bool = False,\n                                       delta_char: str = '\\\\Delta ') -> 'Expression':\n        \"\"\"Calculate the absolute uncertainty in the expression (IB way), assuming all args given are independent.\n\n        :return: the absolute uncertainty of this expression\n        :rtype: Expression\n\n        >>> Expression([a], c * a).calculate_absolute_uncertainty(sympy.Q.positive(c), refine=True, delta_char='Δ')\n        f(Δa) = c*Δa\n        >>> Expression([a, b, c], a + b - c).calculate_absolute_uncertainty(refine=True, delta_char='Δ')\n        f(Δa, Δb, Δc) = Δa + Δb + Δc\n        \"\"\"\n        uncertainty_expr = sympy.Integer(0)  # just in case\n        uncertainty_args = []\n        global_assumptions.add(*assumptions)\n\n        for var in self.args:\n            d_var = sympy.Symbol(delta_char + sympy.latex(var))\n            uncertainty_args.append(d_var)\n            uncertainty_expr += sympy.Abs(self.expr.diff(var)) * d_var\n            global_assumptions.add(sympy.Q.positive(var))\n        if refine:\n            uncertainty_expr = sympy.refine(uncertainty_expr)\n        global_assumptions.clear()\n        return Expression(uncertainty_args, uncertainty_expr)\n\n    def calculate_fractional_uncertainty(self, *assumptions: List[AppliedPredicate],\n                                         refine: bool = False,\n                                         delta_char: str = '\\\\Delta ') -> 'Expression':\n        \"\"\"Calculate the absolute uncertainty in the expression (IB way), assuming all args given are independent.\n\n        :return: the fractional uncertainty of this expression\n        :rtype: Expression\n\n        >>> Expression([a, b, c], a * b \/ c).calculate_fractional_uncertainty(refine=True, delta_char='Δ')\n        f(Δa, Δb, Δc) = Δc\/c + Δb\/b + Δa\/a\n        >>> Expression([a], a ** b).calculate_fractional_uncertainty(sympy.Q.positive(b), refine=True, delta_char='Δ')\n        f(Δa) = b*Δa\/a\n        \"\"\"\n        absolute_uncertainty = self.calculate_absolute_uncertainty(*assumptions, refine=refine, delta_char=delta_char)\n        frac_uncertainty_expr = sympy.Integer(0)\n        if type(absolute_uncertainty.expr) == sympy.Add:\n            for addend in absolute_uncertainty.expr.args:\n                frac_uncertainty_expr += addend \/ self.expr\n        elif type(absolute_uncertainty.expr) == sympy.Mul or type(absolute_uncertainty) == sympy.Pow:\n            frac_uncertainty_expr = absolute_uncertainty.expr \/ self.expr\n        else:\n            frac_uncertainty_expr = sympy.Mul(absolute_uncertainty.expr, sympy.Pow(self.expr, -1), evaluate=False)\n        return Expression(absolute_uncertainty.args, frac_uncertainty_expr)\n\n    def to_latex(self) -> str:\n        r\"\"\"Get the latex form of this expression.\n\n        :rtype: str\n\n        >>> Expression([a, b, c], a + b + c).to_latex()\n        'a + b + c'\n        >>> Expression([a, b, c], a * b \/ c).to_latex()\n        '\\\\frac{a b}{c}'\n        >>> Expression([a, b, c], sympy.root(a ** b, c)).to_latex()\n        '\\\\left(a^{b}\\\\right)^{\\\\frac{1}{c}}'\n        \"\"\"\n        return sympy.latex(self.expr)\n\n    @classmethod\n    def from_string(cls, args_list: List[str], string: str, constants: Dict[str, float] = None) -> 'Expression':\n        \"\"\"Parse a string expression.\n\n        :param string: expression as a string of python expressions\n        :param args_list: the list of args \/ independent variables of the expression as strings\n        :param constants: a list of local variables that are considered while parsing\n        :return: an expression taking in the given args\n\n        >>> Expression.from_string(['x'], 'sqrt(x) ^ y')\n        f(x) = (sqrt(x))**y\n        >>> Expression.from_string(['m'], 'm * g', constants={'g': 9.81})\n        f(m) = 9.81*m\n        \"\"\"\n        parsed_expr = sympy.sympify(string, evaluate=False, locals=constants)  # note: uses eval\n        args = [symbol for symbol in parsed_expr.atoms(sympy.Symbol) if str(symbol) in args_list]\n        return cls(args, parsed_expr)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_563","text":"import rospy\nimport actionlib\nfrom move_base_msgs.msg import MoveBaseAction, MoveBaseGoal\nfrom moveit_msgs.msg import MoveItErrorCodes\nimport math\nfrom scipy.spatial.transform import Rotation as scipyR\nmoveit_error_dict = {}\nfor name in MoveItErrorCodes.__dict__.keys():\n    if not name[:1] == '_':\n        code = MoveItErrorCodes.__dict__[name]\n        moveit_error_dict[code] = name\n\ndef euclidean_dist(p1, p2):\n    dist = math.sqrt(sum([(a - b)** 2 for a, b in zip(p1, p2)]))\n    return dist\n\ndef yaw_diff(quat1, quat2):\n    euler1 = scipyR.from_quat(quat1).as_euler(\"xyz\")\n    euler2 = scipyR.from_quat(quat2).as_euler(\"xyz\")\n    return abs(euler1[2] - euler2[2])\n\nclass WaypointApply(object):\n    class Status:\n        NOT_RUNNING = \"not_running\"\n        RUNNING = \"running\"\n        SUCCESS = \"success\"\n        FAIL = \"fail\"\n    def __init__(self,\n                 position, orientation,\n                 action_name=\"navigate\",\n                 xy_tolerance=0.1, rot_tolerance=0.3):\n        # Get an action client\n        self.client = actionlib.SimpleActionClient('movo_move_base', MoveBaseAction)\n        rospy.loginfo(\"Waiting for movo_move_base AS...\")\n        if not self.client.wait_for_server(rospy.Duration(20)):\n            rospy.logerr(\"Could not connect to movo_move_base AS\")\n            exit()\n        rospy.loginfo(\"Connected!\")\n        rospy.sleep(1.0)\n\n        self.status = WaypointApply.Status.NOT_RUNNING\n        self.action_name = action_name\n        self._position = position\n        self._orientation = orientation\n        self._xy_tolerance = xy_tolerance\n        self._rot_tolerance = rot_tolerance\n        self._goal_reached = False\n\n        # Define the goal\n        rospy.loginfo(\"Waypoint (%.2f,%.2f) and (%.2f,%.2f,%.2f,%.2f) is sent.\", position[0], position[1], orientation[0], \\\n            orientation[1], orientation[2], orientation[3])\n        self.goal = MoveBaseGoal()\n        self.goal.target_pose.header.frame_id = 'map'\n        self.goal.target_pose.pose.position.x = position[0]\n        self.goal.target_pose.pose.position.y = position[1]\n        self.goal.target_pose.pose.position.z = 0.0\n        self.goal.target_pose.pose.orientation.x = orientation[0]\n        self.goal.target_pose.pose.orientation.y = orientation[1]\n        self.goal.target_pose.pose.orientation.z = orientation[2]\n        self.goal.target_pose.pose.orientation.w = orientation[3]\n        self.waypoint_execute()\n\n    def waypoint_execute(self):\n        self.status = WaypointApply.Status.RUNNING\n        self.client.send_goal(self.goal, self.done_cb, feedback_cb=self.feedback_cb)\n        delay = rospy.Duration(0.1)\n        while not self.client.wait_for_result(delay) and not rospy.is_shutdown():\n            if self._goal_reached:\n                rospy.loginfo(\"Goal has been reached by the robot actually. So cancel goal.\")\n                self.status = WaypointApply.Status.SUCCESS\n                self.client.cancel_goal()\n                break\n            if self.status == WaypointApply.Status.FAIL:\n                rospy.logerr(\"Could not reach goal.\")\n                self.client.cancel_goal()                \n                break\n\n    def feedback_cb(self, feedback):\n        base_position = feedback.base_position\n        curx = base_position.pose.position.x\n        cury = base_position.pose.position.y\n        curz = base_position.pose.position.z\n        curqx = base_position.pose.orientation.x\n        curqy = base_position.pose.orientation.y\n        curqz = base_position.pose.orientation.z\n        curqw = base_position.pose.orientation.w\n        # Check if already reached goal\n        dist = euclidean_dist((curx, cury, curz), self._position)\n        angle = yaw_diff((curqx, curqy, curqz, curqw), self._orientation)\n        rospy.loginfo(\"(feedback)[dist_gap: %.5f     | angle_gap: %.5f]\" % (dist, angle))\n        if dist <= self._xy_tolerance\\\n           and angle <= self._rot_tolerance:\n            self._goal_reached = True\n            rospy.loginfo(\"Goal already reached within tolerance.\")\n        \n\n    def done_cb(self, status, result):\n        # Reference for terminal status values: http:\/\/docs.ros.org\/diamondback\/api\/actionlib_msgs\/html\/msg\/GoalStatus.html\n        if status == 2:\n            rospy.loginfo(\"Navigation action \"+str(self.action_name)+\" received a cancel request after it started executing, completed execution!\")\n            self.status = WaypointApply.Status.FAIL            \n        elif status == 3:\n            rospy.loginfo(\"Navigation action \"+str(self.action_name)+\" reached\")\n            self.status = WaypointApply.Status.SUCCESS\n        elif status == 4:\n            rospy.loginfo(\"Navigation action \"+str(self.action_name)+\" was aborted by the Action Server\")\n            rospy.signal_shutdown(\"Navigation action \"+str(self.action_name)+\" aborted, shutting down!\")\n            self.status = WaypointApply.Status.FAIL\n        elif status == 5:\n            rospy.loginfo(\"Navigation action \"+str(self.action_name)+\" has been rejected by the Action Server\")\n            rospy.signal_shutdown(\"Navigation action \"+str(self.action_name)+\" rejected, shutting down!\")\n            self.status = WaypointApply.Status.FAIL\n        elif status == 8:\n            rospy.loginfo(\"Navigation action \"+str(self.action_name)+\" received a cancel request before it started executing, successfully cancelled!\")\n            self.status = WaypointApply.Status.FAIL\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_564","text":"\"\"\"This is where the cool functions go that help out stuff.\n\nThey aren't directly attached to an element. Consequently, you need to\nuse type annotations here.\n\"\"\"\n\nimport ast\nimport textwrap\nimport types\nfrom typing import Any, List, Union\n\nimport sympy\n\nfrom vyxal import context, lexer\nfrom vyxal.LazyList import *\n\nNUMBER_TYPE = \"number\"\nSCALAR_TYPE = \"scalar\"\n\n\ndef case_of(value: str) -> int:\n    \"\"\"Returns 1 for all uppercase, 0 for all lowercase, and -1 for\n    mixed case.\"\"\"\n\n    if all(map(lambda x: x.isupper(), value)):\n        return 1\n    elif all(map(lambda x: x.islower(), value)):\n        return 0\n    return -1\n\n\ndef deep_copy(value: Any) -> Any:\n    \"\"\"Because lists and lazylists use memory references. Frick them.\"\"\"\n\n    if type(value) not in (list, LazyList):\n        return value  # because primitives are all like \"ooh look at me\n        # I don't have any fancy memory references because I'm an epic\n        # chad unlike those virgin memory reference needing lists\".\n\n    # Use itertools.tee for (LazyL|l)ists\n    return LazyList(itertools.tee(value)[-1])\n\n\ndef get_input(ctx: context.Context) -> Any:\n    \"\"\"Returns the next input depending on where ctx tells to get the\n    input from.\"\"\"\n\n    if ctx.use_top_input:\n        if ctx.inputs[0][0]:\n            ret = ctx.inputs[0][ctx.inputs[0][1] % len(ctx.inputs[0])]\n            ctx.inputs[0][1] += 1\n            return ret\n        else:\n            try:\n                temp = vy_eval(input(\"> \" * ctx.repl_mode), ctx)\n                return temp\n            except:\n                return 0\n    else:\n        ret = ctx.inputs[-1][ctx.inputs[-1][1] % len(ctx.inputs[-1])]\n        ctx.inputs[-1][1] += 1\n        return ret\n\n\n@lazylist\ndef fixed_point(function: types.FunctionType, initial: Any) -> List[Any]:\n    \"\"\"Repeat function until the result is no longer unique.\n    Uses initial as the initial value\"\"\"\n\n    previous = None\n    current = simplify(initial)\n\n    while previous != current:\n        yield current\n        prevuous = deep_copy(current)\n        current = safe_apply(function, current)\n\n\ndef from_base_alphabet(value: str, alphabet: str) -> int:\n    \"\"\"Returns value in base 10 using base len(alphabet)\n    [bijective base]\"\"\"\n\n    ret = 0\n    for digit in value:\n        ret = len(alphabet) * ret + alphabet.find(digit)\n\n    return ret\n\n\ndef from_base_digits(digits: List[NUMBER_TYPE], base: int) -> int:\n    \"\"\"Returns digits in base 10 using arbitrary base 'base'\"\"\"\n    # I may have stolen this from Jelly\n    ret = 0\n    for digit in digits:\n        ret = base * ret + digit\n\n    return ret\n\n\ndef indent_str(string: str, indent: int, end=\"\\n\") -> str:\n\n    \"\"\"Indent a multiline string with 4 spaces, with a newline (or `end`) afterwards.\"\"\"\n    return textwrap.indent(string, \"    \" * indent) + end\n\n\ndef indent_code(*code, indent: int = 1) -> str:\n    \"\"\"Indent multiple lines (`*code`) by the given amount, then join on newlines.\"\"\"\n    return \"\\n\".join(indent_str(line, indent, end=\"\") for line in code) + \"\\n\"\n\n\ndef iterable(\n    item: Any, number_type: Any = None, ctx: context.Context = None\n) -> Union[LazyList, Union[list, str]]:\n    \"\"\"Makes sure that a value is an iterable\"\"\"\n\n    if (type_of_item := type(item)) in [sympy.Rational, int]:\n        if ctx.number_as_range or number_type is range:\n            return LazyList(range(ctx.range_start, int(item) + ctx.range_end))\n        else:\n            if type_of_item is sympy.Rational:\n                item = float(item)\n\n            return [int(let) if let not in \"-.\" else let for let in str(item)]\n    else:\n        return item\n\n\ndef keep(haystack: Any, needle: Any) -> Any:\n    \"\"\"Used for keeping only needle in haystack\"\"\"\n\n    ret = []\n    for item in haystack:\n        if item in needle:\n            ret.append(item)\n\n    if type(haystack) is str:\n        return \"\".join(ret)\n    else:\n        return ret\n\n\ndef mold(\n    content: Union[list, LazyList],\n    shape: Union[list, LazyList],\n) -> Union[list, LazyList]:\n    \"\"\"Mold one list to the shape of the other. Uses the mold function\n    that Jelly uses.\"\"\"\n    # https:\/\/github.com\/DennisMitchell\/jellylanguage\/blob\/70c9fd93ab009c05dc396f8cc091f72b212fb188\/jelly\/interpreter.py#L578\n    for index in range(len(shape)):\n        if type(shape[index]) == list:\n            mold(content, shape[index])\n        else:\n            item = content.pop(0)\n            shape[index] = item\n            content.append(item)\n    return shape\n\n\ndef pop(\n    iterable: Union[list, LazyList], count: int, ctx: context.Context\n) -> List[Any]:\n    \"\"\"Pops (count) items from iterable. If there isn't enough items\n    within iterable, input is used as filler.\"\"\"\n\n    popped_items = []\n    for _ in range(count):\n        if iterable:\n            popped_items.append(iterable.pop())\n        else:\n            ctx.use_top_input = True\n            popped_items.append(get_input(ctx))\n            ctx.use_top_input = False\n\n    if ctx.retain_popped:\n        for item in popped_items[::-1]:\n            iterable.append(item)\n\n    if ctx.reverse_flag:\n        popped_items = popped_items[::-1]\n\n    if count == 1:\n        return popped_items[0]\n\n    return popped_items\n\n\ndef primitive_type(item: type) -> Union[str, type]:\n    \"\"\"Turns int\/Rational\/str into 'Scalar' and everything else\n    into list\"\"\"\n\n    if type(item) in [int, sympy.Rational, str]:\n        return SCALAR_TYPE\n    else:\n        return list\n\n\ndef reverse_number(\n    item: Union[int, sympy.Rational]\n) -> Union[int, sympy.Rational]:\n    \"\"\"Reverses a number. Negative numbers are returned negative\"\"\"\n\n    temp = \"\"\n    if item < 0:\n        temp = type(item)(str(eval(item))[1:][::-1])\n    else:\n        temp = type(item)(str(eval(item))[::-1])\n\n    return sympy.Rational(item)\n\n\ndef safe_apply(function: types.FunctionType, *args, ctx) -> Any:\n    \"\"\"\n    Applies function to args that adapts to the input style of the passed function.\n    If the function is a _lambda (it's been defined within λ...;), it passes a\n      list of arguments and length of argument list.\n    Otherwise, if the function is a user-defined function (starts with FN_), it\n      simply passes the argument list.\n    Otherwise, unpack args and call as usual\n\n    *args contains ctx\n    \"\"\"\n\n    if function.__name__.startswith(\"_lambda\"):\n        ret = function(list(args), len(args), function, ctx)\n        if len(ret):\n            return ret[-1]\n        else:\n            return []\n    elif function.__name__.startswith(\"FN_\"):\n        ret = function(list(args), ctx)[-1]\n        if len(ret):\n            return ret[-1]\n        else:\n            return []\n    return function(*args, ctx)\n\n\ndef scalarify(value: Any) -> Union[Any, List[Any]]:\n    \"\"\"Returns value[0] if value is a list of length 1, else value\"\"\"\n    if type(value) in (list, LazyList):\n        if len(value) == 1:\n            return value[0]\n        else:\n            return value\n    else:\n        return value\n\n\ndef to_base_digits(value: int, base: int) -> List[int]:\n    \"\"\"Returns value in base 'base' from base 10 as a list of digits\"\"\"\n\n    ret = []\n    n = value\n\n    while n > base:\n        n, digit = divmod(n, base)\n        ret.append(digit)\n    ret.append(n)\n    return ret[::-1]\n\n\ndef transfer_capitalisation(source: str, target: str) -> str:\n    \"\"\"Returns target with the capitalisation of source\"\"\"\n    ret = \"\"\n    for i in range(min(len(source), len(target))):\n        if source[i].isupper():\n            ret += target[i].upper()\n        elif source[i].islower():\n            ret += target[i].lower()\n        else:\n            ret += target[i]\n\n    if len(target) > len(source):\n        ret += target[i + 1 :]\n\n    return ret\n\n\ndef uncompress(token: lexer.Token) -> Union[int, str]:\n    \"\"\"Uncompress the token's value based on the token type.\n\n    Handles the following token types: TokenType.STRING,\n    TokenType.COMPRESSED_NUMBER, TokenType.COMPRESSED_STRING\n    \"\"\"\n    if token.name == lexer.TokenType.COMPRESSED_STRING:\n        return uncompress_str(token.value)\n    if token.name == lexer.TokenType.COMPRESSED_NUMBER:\n        return uncompress_num(token.value)\n\n    return token.value\n\n\ndef uncompress_str(string: str) -> str:\n    # TODO (lyxal) Implement string (un)compression\n    raise NotImplementedError()\n\n\ndef uncompress_num(num: str) -> int:\n    # TODO (lyxal) Implement number (un)compression\n    raise NotImplementedError()\n\n\ndef vy_eval(item: str, ctx: context.Context) -> Any:\n    \"\"\"Evaluates an item. Does so safely if using the online\n    interpreter\"\"\"\n\n    if ctx.online:\n        try:\n            return ast.literal_eval(item)\n        except Exception as ex:\n            # TODO: eval as vyxal\n            return item\n    else:\n        try:\n            return eval(item)\n        except Exception as ex:\n            return item\n\n\ndef vy_str(item: Any, ctx: context.Context) -> str:\n    \"\"\"Convert to string, using custom vyxal formatting\"\"\"\n    if type(item) is LazyList:\n        item = list(item)\n\n    if type(item) is list:\n        return \"⟨\" + \"|\".join([vy_str(y) for y in x]) + \"⟩\"\n\n    return str(item)\n\n\ndef vy_zip(*items) -> list:\n    \"\"\"Like python's zip, but fills shorter lists with 0s\"\"\"\n\n    items = list(map(iter, items))\n    while True:\n        ret = []\n        exhausted_count = 0\n        for item in items:\n            try:\n                ret.append(next(item))\n            except:\n                ret.append(0)\n                exhausted_count += 1\n\n        if len(items) == exhausted_count:\n            break\n\n        yield ret\n\n\ndef wrap(vector: Union[str, list], width: int) -> List[Any]:\n    \"\"\"A version of textwrap.wrap that plays nice with spaces\"\"\"\n    ret = []\n    temp = []\n    for item in vector:\n        temp.append(item)\n        if len(temp) == width:\n            if all([type(x) is str for x in temp]):\n                ret.append(\"\".join(temp))\n            else:\n                ret.append(temp[::])\n            temp = []\n    if len(temp) < width and temp:\n        if all([type(x) is str for x in temp]):\n            ret.append(\"\".join(temp))\n        else:\n            ret.append(temp[::])\n\n    return ret\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_565","text":"from __future__ import print_function\n\nimport numpy as np\nfrom scipy.io import loadmat, savemat\nfrom scipy.spatial.distance import pdist, squareform\nimport networkx as nx\n\ndef get_topk_edges(distances, nodes, k=5):\n    assert k < nodes**2\n    \n    topk = np.argpartition(distances, k)[:k]\n    topk_edges = []\n    for pos in topk:\n        #print(distances[pos])\n        n1, n2 = pos\/\/nodes, pos%nodes\n        topk_edges.append((n1,n2))\n\n    print(topk_edges)\n    return topk_edges\n    \n    \ndef read_embeddings(data_dir, csv, dim=128):\n    if csv:\n        return np.loadtxt(data_dir, delimiter = ',')\n\n    f = open(data_dir, 'r')\n    f.readline()#remove meta-data in first line\n    data = f.read().split()\n    data = [float(item) for item in data]\n    embed = np.zeros((len(data)\/\/(dim+1), dim))\n    for i in range(0, len(data), dim + 1):\n        embed[int(data[i])] = data[i+1 : i+1 + dim]\n    return embed\n\ndef p_at_k(topk_edges, removed_edges):\n    k = len(topk_edges)\n    correct_edges = len(set(topk_edges) & set(removed_edges))\n    print(\"wrong: \", set(topk_edges) - set(removed_edges))\n    return correct_edges\/k\n    \n\n\n\"\"\" ====== IMP: Only for symmetric graphs without self loops ======\"\"\"\n# mat_dir = 'blogcatalog90.mat'\nmat_dir = 'karate.mat'\n# embd_dir = 'blogcatalog90_DW.embd'\nembd_dir = 'Karate_data.embd'\ncsv = True\nks = [1, 3 , 5, 10, 15, 20]#, 1000, 5000, 10000, 50000]\n\nembd = read_embeddings(embd_dir, csv=csv, dim=128)\nprint(\"Read embeddings from: \", embd_dir)\n\nmat = loadmat(mat_dir)\ngraph = nx.from_scipy_sparse_matrix(mat['network'])\nselected_edges = graph.edges(data=False)\n\nnp.random.shuffle(selected_edges)\nremoved_edges  = selected_edges[:20]#mat['removed_edges'] \nselected_edges  = selected_edges[20:]#mat['removed_edges']\nprint(removed_edges, '\\n', selected_edges)\n\nprint(\"Read graph from: \", mat_dir)\ndel graph, mat\n\ndistances = squareform(pdist(embd,'euclidean'))\nprint(\"Calculated pair-wise distances...\")\n\nnodes = embd.shape[0]\nprecisions = {}\n\n#set the distnces among nodes of existing edges \nfor n1, n2 in selected_edges:\n    distances[n1][n2] = distances[n2][n1] = 999\n\n#Make lower triangle and diagnol -inf\nfor n1 in range(nodes):\n    for n2 in range(0, n1+1):\n        distances[n1][n2] = np.inf\nprint(\"Done removing existing edges and making matrix as upper triangle...\\n\", distances)\n\n#Assert n2>n1 for removed edges and Convert to set\nfor n1, n2 in removed_edges:\n    assert n2>n1 , str(n2)+str(n1)\nremoved_edges = [(n1, n2) for n1, n2 in removed_edges]\n#print(removed_edges)\n\n\ndistances = np.ndarray.flatten(distances)\nfor k in ks:\n    topk_edges = get_topk_edges(distances, nodes, k)\n    precisions[k] = p_at_k(topk_edges, removed_edges)\n    print(\"P@\", k, \": \", precisions[k])\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_567","text":"<reponame>EkremBayar\/bayar\nimport pytest\nimport numpy as np\nfrom scipy.optimize import quadratic_assignment, OptimizeWarning\nfrom scipy.optimize._qap import _calc_score as _score\nfrom numpy.testing import assert_equal, assert_, assert_warns\n\n\n################\n# Common Tests #\n################\n\ndef chr12c():\n    A = [\n        [0, 90, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n        [90, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0],\n        [10, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0],\n        [0, 23, 0, 0, 0, 88, 0, 0, 0, 0, 0, 0],\n        [0, 0, 43, 0, 0, 0, 26, 0, 0, 0, 0, 0],\n        [0, 0, 0, 88, 0, 0, 0, 16, 0, 0, 0, 0],\n        [0, 0, 0, 0, 26, 0, 0, 0, 1, 0, 0, 0],\n        [0, 0, 0, 0, 0, 16, 0, 0, 0, 96, 0, 0],\n        [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 29, 0],\n        [0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 37],\n        [0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0],\n        [0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0],\n    ]\n    B = [\n        [0, 36, 54, 26, 59, 72, 9, 34, 79, 17, 46, 95],\n        [36, 0, 73, 35, 90, 58, 30, 78, 35, 44, 79, 36],\n        [54, 73, 0, 21, 10, 97, 58, 66, 69, 61, 54, 63],\n        [26, 35, 21, 0, 93, 12, 46, 40, 37, 48, 68, 85],\n        [59, 90, 10, 93, 0, 64, 5, 29, 76, 16, 5, 76],\n        [72, 58, 97, 12, 64, 0, 96, 55, 38, 54, 0, 34],\n        [9, 30, 58, 46, 5, 96, 0, 83, 35, 11, 56, 37],\n        [34, 78, 66, 40, 29, 55, 83, 0, 44, 12, 15, 80],\n        [79, 35, 69, 37, 76, 38, 35, 44, 0, 64, 39, 33],\n        [17, 44, 61, 48, 16, 54, 11, 12, 64, 0, 70, 86],\n        [46, 79, 54, 68, 5, 0, 56, 15, 39, 70, 0, 18],\n        [95, 36, 63, 85, 76, 34, 37, 80, 33, 86, 18, 0],\n    ]\n    A, B = np.array(A), np.array(B)\n    n = A.shape[0]\n\n    opt_perm = np.array([7, 5, 1, 3, 10, 4, 8, 6, 9, 11, 2, 12]) - [1] * n\n\n    return A, B, opt_perm\n\n\nclass QAPCommonTests(object):\n    \"\"\"\n    Base class for `quadratic_assignment` tests.\n    \"\"\"\n    def setup_method(self):\n        np.random.seed(0)\n\n    # Test global optima of problem from Umeyama IVB\n    # https:\/\/pcl.sitehost.iu.edu\/rgoldsto\/papers\/weighted%20graph%20match2.pdf\n    # Graph matching maximum is in the paper\n    # QAP minimum determined by brute force\n    def test_accuracy_1(self):\n        # besides testing accuracy, check that A and B can be lists\n        A = [[0, 3, 4, 2],\n             [0, 0, 1, 2],\n             [1, 0, 0, 1],\n             [0, 0, 1, 0]]\n\n        B = [[0, 4, 2, 4],\n             [0, 0, 1, 0],\n             [0, 2, 0, 2],\n             [0, 1, 2, 0]]\n\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, \"maximize\": False})\n        assert_equal(res.fun, 10)\n        assert_equal(res.col_ind, np.array([1, 2, 3, 0]))\n\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, \"maximize\": True})\n\n        if self.method == 'faq':\n            # Global optimum is 40, but FAQ gets 37\n            assert_equal(res.fun, 37)\n            assert_equal(res.col_ind, np.array([0, 2, 3, 1]))\n        else:\n            assert_equal(res.fun, 40)\n            assert_equal(res.col_ind, np.array([0, 3, 1, 2]))\n\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, \"maximize\": True})\n\n    # Test global optima of problem from Umeyama IIIB\n    # https:\/\/pcl.sitehost.iu.edu\/rgoldsto\/papers\/weighted%20graph%20match2.pdf\n    # Graph matching maximum is in the paper\n    # QAP minimum determined by brute force\n    def test_accuracy_2(self):\n\n        A = np.array([[0, 5, 8, 6],\n                      [5, 0, 5, 1],\n                      [8, 5, 0, 2],\n                      [6, 1, 2, 0]])\n\n        B = np.array([[0, 1, 8, 4],\n                      [1, 0, 5, 2],\n                      [8, 5, 0, 5],\n                      [4, 2, 5, 0]])\n\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, \"maximize\": False})\n        if self.method == 'faq':\n            # Global optimum is 176, but FAQ gets 178\n            assert_equal(res.fun, 178)\n            assert_equal(res.col_ind, np.array([1, 0, 3, 2]))\n        else:\n            assert_equal(res.fun, 176)\n            assert_equal(res.col_ind, np.array([1, 2, 3, 0]))\n\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, \"maximize\": True})\n        assert_equal(res.fun, 286)\n        assert_equal(res.col_ind, np.array([2, 3, 0, 1]))\n\n    def test_accuracy_3(self):\n\n        A, B, opt_perm = chr12c()\n\n        # basic minimization\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0})\n        assert_(11156 <= res.fun < 21000)\n        assert_equal(res.fun, _score(A, B, res.col_ind))\n\n        # basic maximization\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={\"rng\": 0, 'maximize': True})\n        assert_(74000 <= res.fun < 85000)\n        assert_equal(res.fun, _score(A, B, res.col_ind))\n\n        # check ofv with strictly partial match\n        seed_cost = np.array([4, 8, 10])\n        seed = np.asarray([seed_cost, opt_perm[seed_cost]]).T\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={'partial_match': seed})\n        assert_(11156 <= res.fun < 21000)\n        assert_equal(res.col_ind[seed_cost], opt_perm[seed_cost])\n\n        # check performance when partial match is the global optimum\n        seed = np.asarray([np.arange(len(A)), opt_perm]).T\n        res = quadratic_assignment(A, B, method=self.method,\n                                   options={'partial_match': seed})\n        assert_equal(res.col_ind, seed[:, 1].T)\n        assert_equal(res.fun, 11156)\n        assert_equal(res.nit, 0)\n\n        # check performance with zero sized matrix inputs\n        empty = np.empty((0, 0))\n        res = quadratic_assignment(empty, empty, method=self.method,\n                                   options={\"rng\": 0})\n        assert_equal(res.nit, 0)\n        assert_equal(res.fun, 0)\n\n    def test_unknown_options(self):\n        A, B, opt_perm = chr12c()\n\n        def f():\n            quadratic_assignment(A, B, method=self.method,\n                                 options={\"ekki-ekki\": True})\n        assert_warns(OptimizeWarning, f)\n\n\nclass TestFAQ(QAPCommonTests):\n    method = \"faq\"\n\n    def test_options(self):\n        # cost and distance matrices of QAPLIB instance chr12c\n        A, B, opt_perm = chr12c()\n        n = len(A)\n\n        # check that max_iter is obeying with low input value\n        res = quadratic_assignment(A, B,\n                                   options={'maxiter': 5})\n        assert_equal(res.nit, 5)\n\n        # test with shuffle\n        res = quadratic_assignment(A, B,\n                                   options={'shuffle_input': True})\n        assert_(11156 <= res.fun < 21000)\n\n        # test with randomized init\n        res = quadratic_assignment(A, B,\n                                   options={'rng': 1, 'P0': \"randomized\"})\n        assert_(11156 <= res.fun < 21000)\n\n        # check with specified P0\n        K = np.ones((n, n)) \/ float(n)\n        K = _doubly_stochastic(K)\n        res = quadratic_assignment(A, B,\n                                   options={'P0': K})\n        assert_(11156 <= res.fun < 21000)\n\n    def test_specific_input_validation(self):\n\n        A = np.identity(2)\n        B = A\n\n        # method is implicitly faq\n\n        # ValueError Checks: making sure single value parameters are of\n        # correct value\n        with pytest.raises(ValueError, match=\"Invalid 'P0' parameter\"):\n            quadratic_assignment(A, B, options={'P0': \"random\"})\n        with pytest.raises(\n                ValueError, match=\"'maxiter' must be a positive integer\"):\n            quadratic_assignment(A, B, options={'maxiter': -1})\n        with pytest.raises(ValueError, match=\"'tol' must be a positive float\"):\n            quadratic_assignment(A, B, options={'tol': -1})\n\n        # TypeError Checks: making sure single value parameters are of\n        # correct type\n        with pytest.raises(TypeError):\n            quadratic_assignment(A, B, options={'maxiter': 1.5})\n\n        # test P0 matrix input\n        with pytest.raises(\n                ValueError,\n                match=\"`P0` matrix must have shape m' x m', where m'=n-m\"):\n            quadratic_assignment(\n                np.identity(4), np.identity(4),\n                options={'P0': np.ones((3, 3))}\n            )\n\n        K = [[0.4, 0.2, 0.3],\n             [0.3, 0.6, 0.2],\n             [0.2, 0.2, 0.7]]\n        # matrix that isn't quite doubly stochastic\n        with pytest.raises(\n                ValueError, match=\"`P0` matrix must be doubly stochastic\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3), options={'P0': K}\n            )\n\n\nclass Test2opt(QAPCommonTests):\n    method = \"2opt\"\n\n    def test_deterministic(self):\n        # np.random.seed(0) executes before every method\n        n = 20\n\n        A = np.random.rand(n, n)\n        B = np.random.rand(n, n)\n        res1 = quadratic_assignment(A, B, method=self.method)\n\n        np.random.seed(0)\n\n        A = np.random.rand(n, n)\n        B = np.random.rand(n, n)\n        res2 = quadratic_assignment(A, B, method=self.method)\n\n        assert_equal(res1.nit, res2.nit)\n\n    def test_partial_guess(self):\n        n = 5\n        A = np.random.rand(n, n)\n        B = np.random.rand(n, n)\n\n        res1 = quadratic_assignment(A, B, method=self.method,\n                                    options={'rng': 0})\n        guess = np.array([np.arange(5), res1.col_ind]).T\n        res2 = quadratic_assignment(A, B, method=self.method,\n                                    options={'rng': 0, 'partial_guess': guess})\n        fix = [2, 4]\n        match = np.array([np.arange(5)[fix], res1.col_ind[fix]]).T\n        res3 = quadratic_assignment(A, B, method=self.method,\n                                    options={'rng': 0, 'partial_guess': guess,\n                                             'partial_match': match})\n        assert_(res1.nit != n*(n+1)\/2)\n        assert_equal(res2.nit, n*(n+1)\/2)      # tests each swap exactly once\n        assert_equal(res3.nit, (n-2)*(n-1)\/2)  # tests free swaps exactly once\n\n    def test_specific_input_validation(self):\n        # can't have more seed nodes than cost\/dist nodes\n        _rm = _range_matrix\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_guess` can have only as many entries as\"):\n            quadratic_assignment(np.identity(3), np.identity(3),\n                                 method=self.method,\n                                 options={'partial_guess': _rm(5, 2)})\n        # test for only two seed columns\n        with pytest.raises(\n                ValueError, match=\"`partial_guess` must have two columns\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3), method=self.method,\n                options={'partial_guess': _range_matrix(2, 3)}\n            )\n        # test that seed has no more than two dimensions\n        with pytest.raises(\n                ValueError, match=\"`partial_guess` must have exactly two\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3), method=self.method,\n                options={'partial_guess': np.random.rand(3, 2, 2)}\n            )\n        # seeds cannot be negative valued\n        with pytest.raises(\n                ValueError, match=\"`partial_guess` must contain only pos\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3), method=self.method,\n                options={'partial_guess': -1 * _range_matrix(2, 2)}\n            )\n        # seeds can't have values greater than number of nodes\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_guess` entries must be less than number\"):\n            quadratic_assignment(\n                np.identity(5), np.identity(5), method=self.method,\n                options={'partial_guess': 2 * _range_matrix(4, 2)}\n            )\n        # columns of seed matrix must be unique\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_guess` column entries must be unique\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3), method=self.method,\n                options={'partial_guess': np.ones((2, 2))}\n            )\n\n\nclass TestQAPOnce():\n    def setup_method(self):\n        np.random.seed(0)\n\n    # these don't need to be repeated for each method\n    def test_common_input_validation(self):\n        # test that non square matrices return error\n        with pytest.raises(ValueError, match=\"`A` must be square\"):\n            quadratic_assignment(\n                np.random.random((3, 4)),\n                np.random.random((3, 3)),\n            )\n        with pytest.raises(ValueError, match=\"`B` must be square\"):\n            quadratic_assignment(\n                np.random.random((3, 3)),\n                np.random.random((3, 4)),\n            )\n        # test that cost and dist matrices have no more than two dimensions\n        with pytest.raises(\n                ValueError, match=\"`A` and `B` must have exactly two\"):\n            quadratic_assignment(\n                np.random.random((3, 3, 3)),\n                np.random.random((3, 3, 3)),\n            )\n        # test that cost and dist matrices of different sizes return error\n        with pytest.raises(\n                ValueError,\n                match=\"`A` and `B` matrices must be of equal size\"):\n            quadratic_assignment(\n                np.random.random((3, 3)),\n                np.random.random((4, 4)),\n            )\n        # can't have more seed nodes than cost\/dist nodes\n        _rm = _range_matrix\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_match` can have only as many seeds as\"):\n            quadratic_assignment(np.identity(3), np.identity(3),\n                                 options={'partial_match': _rm(5, 2)})\n        # test for only two seed columns\n        with pytest.raises(\n                ValueError, match=\"`partial_match` must have two columns\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3),\n                options={'partial_match': _range_matrix(2, 3)}\n            )\n        # test that seed has no more than two dimensions\n        with pytest.raises(\n                ValueError, match=\"`partial_match` must have exactly two\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3),\n                options={'partial_match': np.random.rand(3, 2, 2)}\n            )\n        # seeds cannot be negative valued\n        with pytest.raises(\n                ValueError, match=\"`partial_match` must contain only pos\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3),\n                options={'partial_match': -1 * _range_matrix(2, 2)}\n            )\n        # seeds can't have values greater than number of nodes\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_match` entries must be less than number\"):\n            quadratic_assignment(\n                np.identity(5), np.identity(5),\n                options={'partial_match': 2 * _range_matrix(4, 2)}\n            )\n        # columns of seed matrix must be unique\n        with pytest.raises(\n                ValueError,\n                match=\"`partial_match` column entries must be unique\"):\n            quadratic_assignment(\n                np.identity(3), np.identity(3),\n                options={'partial_match': np.ones((2, 2))}\n            )\n\n\ndef _range_matrix(a, b):\n    mat = np.zeros((a, b))\n    for i in range(b):\n        mat[:, i] = np.arange(a)\n    return mat\n\n\ndef _doubly_stochastic(P, tol=1e-3):\n    # cleaner implementation of btaba\/sinkhorn_knopp\n\n    max_iter = 1000\n    c = 1 \/ P.sum(axis=0)\n    r = 1 \/ (P @ c)\n    P_eps = P\n\n    for it in range(max_iter):\n        if ((np.abs(P_eps.sum(axis=1) - 1) < tol).all() and\n                (np.abs(P_eps.sum(axis=0) - 1) < tol).all()):\n            # All column\/row sums ~= 1 within threshold\n            break\n\n        c = 1 \/ (r @ P)\n        r = 1 \/ (P @ c)\n        P_eps = r[:, None] * P * c\n\n    return P_eps\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_568","text":"'''\n    Compute average distances for each metric on covers80\n'''\n\n\ndef segment(y, s, rs_size, kmin, kmax, filter):\n    \"\"\"structurally segments the selected audio\n\n        ds_size: side length to which combined matrix is going to be resampled to\n        [kmin, kmax]: min and maximum approximation ranks\n        filtering: True or False, whether memory stacking, timelag and path enhance are going to be used\n\n    returns set of low rank approximations\"\"\"\n\n    #compute cqt\n    C = librosa.amplitude_to_db(np.abs(librosa.cqt(y=y, sr=sr, \n                                        hop_length=512,\n                                        bins_per_octave=12*3,\n                                        n_bins=7*12*3)),\n                                        ref=np.max)\n\n    #beat synch cqt\n    Csync = cv2.resize(C, (int(C.shape[1]\/10), C.shape[0]))\n\n    #stack memory\n    if filter:\n        Csync = librosa.feature.stack_memory(Csync, 4)\n\n    #Affinity matrix\n    R = librosa.segment.recurrence_matrix(Csync, width=3, mode='affinity', sym=True)\n\n    #Filtering\n    if filter:  \n        df = librosa.segment.timelag_filter(scipy.ndimage.median_filter)\n        R = df(R, size=(1, 7))\n        R = librosa.segment.path_enhance(R, 15)\n\n    #mfccs\n    mfcc = librosa.feature.mfcc(y=y, sr=sr)\n\n    #downsample like CQT, compress time by 10\n    Msync = cv2.resize(C, (int(mfcc.shape[1]\/10), mfcc.shape[0]))\n\n    #weighted sequence\n    path_distance = np.sum(np.diff(Msync, axis=1)**2, axis=0)\n    sigma = np.median(path_distance)\n    path_sim = np.exp(-path_distance \/ sigma)\n    R_path = np.diag(path_sim, k=1) + np.diag(path_sim, k=-1)\n\n    #weighted combination of affinity matrix and mfcc diagonal\n    deg_path = np.sum(R_path, axis=1)\n    deg_rec = np.sum(R, axis=1)\n\n    mu = deg_path.dot(deg_path + deg_rec) \/ np.sum((deg_path + deg_rec)**2)\n\n    A = mu * R + (1 - mu) * R_path\n\n    #resampling\n    A_d = cv2.resize(A, (rs_size, rs_size))\n\n    #laplacian\n    L = scipy.sparse.csgraph.laplacian(A_d, normed=True)\n\n    #eigendecomposition\n    evals, evecs = scipy.linalg.eigh(L)\n    #eigenvector filtering\n    evecs = scipy.ndimage.median_filter(evecs, size=(9, 1))\n\n    #normalization\n    Cnorm = np.cumsum(evecs**2, axis=1)**0.5\n\n    #temporary replacement for bug\n    a_min_value = 3.6934424e-08\n    Cnorm[Cnorm == 0.0] = a_min_value\n    if (np.isnan(np.sum(Cnorm))):\n        print(\"WOOOOOAH\")\n    \n    # print(\"Cnorm shape:\",Cnorm.shape)\n    # plt.matshow(Cnorm)\n    # plt.savefig(filedir[-10:-4])\n\n    #approximations\n    dist_set = []\n    for k in range(kmin, kmax):\n\n        # #debug\n        # print(np.all(Cnorm[:, k-1:k]))\n        # divisor = Cnorm[:, k-1:k]\n        # if not np.all(divisor):\n        #     print(\"0 divisor\")\n\n        Xs = evecs[:, :k] \/ Cnorm[:, k-1:k]\n        \n\n        #debug\n        if np.isnan(np.sum(Xs)):\n            print('woops')\n            # fig, axs = plt.subplots(1, approx[1]-approx[0], figsize=(20, 20))\n            # for i in range(approx[1]-approx[0]):\n            #     axs[i].matshow(struct[i])\n            # plt.savefig(filedir[-10:-1])\n\n        distance = scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(Xs, metric='euclidean'))\n        dist_set.append(distance)\n    dist_set = np.asarray(dist_set)\n    \n    \n    #return\n    return(dist_set)\n\n#Importing\nimport librosa\nimport numpy as np\nimport scipy\nfrom scipy.spatial.distance import pdist, squareform\nfrom scipy.interpolate import interp2d\nfrom scipy.sparse.csgraph import laplacian\nfrom scipy.spatial.distance import directed_hausdorff\nfrom scipy.cluster import hierarchy\nfrom scipy.linalg import eigh\nfrom scipy.ndimage import median_filter\nimport cv2\nfrom sklearn import metrics\nimport matplotlib.pyplot as plt\nimport dill\nimport sys\nimport glob\nimport os\nimport random\nimport csv\n\n#--supress warnings--#\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\n\n#--reading--#\n\nall_dirs = []\nall_names = []\nall_roots = []\nall_audio = []\nmax_files = 40000\nfor root, dirs, files in os.walk('\/home\/ismir\/Documents\/ISMIR\/Datasets\/covers80\/'):\n        for name in files:\n            if (('.wav' in name) or ('.aif' in name) or ('.mp3' in name)):\n                filepath = os.path.join(root, name)\n                all_dirs.append(filepath)\n                all_names.append(name[:-4])\n                all_roots.append(root)\n\n                if len(all_dirs)>=max_files:\n                    break\n        if len(all_dirs)>=max_files:\n            break        \nfile_no = len(all_dirs)\n\n#load audio\nfor f in range(file_no):\n    y, sr = librosa.load(all_dirs[f], sr=16000, mono=True)\n    #bug: empty mel bins\n    all_audio.append((y,sr))\n\n    #progress\n    sys.stdout.write(\"\\rLoading %i\/%s pieces.\" % ((f+1), str(file_no)))\n    sys.stdout.flush()\nprint('')\n\n\n#--cover (True) vs non-cover (False)--#\ncovers = np.zeros((file_no, file_no), dtype=np.bool_)\nfor i in range(file_no):\n    for j in range(file_no):\n        if (all_roots[i] == all_roots[j]):\n            covers[i][j] = True\n        else:\n            covers[i][j] = False\n\n#--Distance dictionary--#\n\"\"\"Terminology\ndistances: L1, fro, dtw, hau, pair, sh2, sh3\nformat: rs_size-approx[0]-approx[1]-distance e.g. 128-2-8-L1\n\"\"\"\ndistances = {}\n\n#--Score dictionary--#\n\"\"\"Terminology\ndistances: L1, fro, dtw, hau, pair, sh2, sh3\nformat: (filt-)rs_size-approx[0]-approx[1]-distance e.g. filt-128-2-8-L1\n\"\"\"\nscores = {}\n\n\n#--traverse parameters, compute segmentations, save evaluation--#\n\n#resampling parameters\n#for rs_size in [32]:\nfor rs_size in [128]:\n    #approximations\n    #for approx in [[2,6]]:\n    for approx in [[2,11]]:\n        for filtering in [True]:\n\n            #string for keys to indicate filtering\n            if filtering:\n                filt = 'filt-'\n            else:\n                filt = ''\n\n            #hold all structures and their formats\n            all_struct = [] #kmax-kmin sets each with a square matrix\n            all_flat = [] #kmax-kmin sets each with a flattened matrix\n            all_merged = [] #single concatenated vector with all flattened matrices\n            all_shingled2 = [] #shingled pairs of flat approximations\n            all_shingled3 = [] #shingled triples of flat approximations\n\n            print(\"--------------------\")\n            print(\"Resampling size:\", str(rs_size))\n            print(\"Approximation range: [\" + str(approx[0]) + ',' + str(approx[1]) + ']')\n            print(\"Filtering:\", str(filtering))\n\n            #songs\n            for f in range(file_no):\n                #structure segmentation\n                struct = segment(all_audio[f][0], all_audio[f][1],\n                                rs_size, approx[0], approx[1], filtering)\n                all_struct.append(struct)\n\n                # #debug\n                # fig, axs = plt.subplots(1, approx[1]-approx[0], figsize=(20, 20))\n                # for i in range(approx[1]-approx[0]):\n                #     axs[i].matshow(struct[i])\n                # plt.savefig(all_names[f])\n\n                #formatting\n                flat_approximations = []\n                merged_approximations = np.empty((0))\n                for j in range(approx[1]-approx[0]):\n                    flat_approximations.append(struct[j].flatten())\n                    merged_approximations = np.concatenate((merged_approximations, flat_approximations[j]))\n                all_flat.append(np.asarray(flat_approximations))\n                all_merged.append(merged_approximations)\n\n                #shingling per 2\n                shingled = []\n                for j in range(approx[1]-approx[0]-1):\n                    shingled.append(np.concatenate((all_flat[f][j],all_flat[f][j+1]),axis=None))\n                    #shingled.append(np.concatenate((struct[all_names[f]]['OG'][1][j],struct[all_names[f]]['OG'][1][j+1]),axis=None))\n                all_shingled2.append(np.asarray(shingled))\n\n                #shingling per 3\n                shingled = []\n                for j in range(approx[1]-approx[0]-2):\n                    shingled.append(np.concatenate((all_flat[f][j],all_flat[f][j+1],all_flat[f][j+2]),axis=None))\n                    #shingled.append(np.concatenate((struct[all_names[f]]['OG'][1][j],struct[all_names[f]]['OG'][1][j+1],struct[all_names[f]]['OG'][1][j+2]), axis=None))\n                all_shingled3.append(np.asarray(shingled))\n                \n                #progress\n                sys.stdout.write(\"\\rSegmented %i\/%s pieces.\" % ((f+1), str(file_no)))\n                sys.stdout.flush()\n            print('')\n\n            # #plot approximations\n            # fig, axs = plt.subplots(1, approx[1]-approx[0], figsize=(20, 20))\n            # for i in range(approx[1]-approx[0]):\n            #     axs[i].matshow(all_struct[0][i])\n            # plt.savefig('approximations'+str(rs_size))\n\n            #list to numpy array\n            all_struct = np.asarray(all_struct)\n            all_flat = np.asarray(all_flat)\n            all_merged = np.asarray(all_merged)\n\n            rows = [['', 'mean', 'max']]\n\n            #L1 norm\n            L1_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    L1_distances[i][j] = np.linalg.norm(all_merged[i]-all_merged[j], ord=1)\n\n            rows.append(['L1', np.mean(L1_distances), np.amax(L1_distances)])\n            print(\"Computed L1 distances.\")\n\n            #Frobenius norm\n            fro_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    fro_distances[i][j] = np.linalg.norm(all_merged[i]-all_merged[j])\n\n            rows.append(['Frobenius', np.mean(fro_distances), np.amax(fro_distances)])\n            print(\"Computed Frobenius distsances.\")\n\n            #Sub-sequence Dynamic Time Warping cost\n            dtw_cost = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    costs = []\n                    for k in range(approx[1]-approx[0]):           \n                        costs.append(librosa.sequence.dtw(all_struct[i][k], all_struct[j][k], subseq=False, metric='euclidean')[0][rs_size-1,rs_size-1])\n                    dtw_cost[i][j] = sum(costs)\/len(costs)\n\n            rows.append(['DTW', np.mean(dtw_cost), np.amax(dtw_cost)])\n            print(\"Computed DTW costs.\")\n            \n            #Directed Hausdorff distance\n            hausdorff_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    hausdorff_distances[i][j] = (directed_hausdorff(all_flat[i], all_flat[j]))[0]\n\n            rows.append(['Hausdorff', np.mean(hausdorff_distances), np.amax(hausdorff_distances)])\n            print(\"Computed directed Hausdorff distances.\")\n\n            #Minimum distance across all pairs\n            min_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    dists = []\n                    for n in range(approx[1]-approx[0]):\n                        for m in range(approx[1]-approx[0]):\n                            dists.append(np.linalg.norm(all_struct[i][n]-all_struct[j][m]))\n                    min_distances[i][j] = min(dists)\n            \n            rows.append(['Pair', np.mean(min_distances), np.amax(min_distances)])\n            print(\"Computed minimum paiwise distances.\")\n\n            #Directed Hausdorff distance of shingled pairs\n            shingled2_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    shingled2_distances[i][j] = (directed_hausdorff(all_shingled2[i], all_shingled2[j]))[0]\n\n            rows.append(['Shingled 2', np.mean(shingled2_distances), np.amax(shingled2_distances)])\n            print(\"Copmuter directed Hausforff distances for bi-grams\")\n\n            #Directed Hausdorff distance of shingled triples\n            shingled3_distances = np.zeros((file_no, file_no))\n            for i in range(file_no):\n                for j in range(file_no):\n                    shingled3_distances[i][j] = (directed_hausdorff(all_shingled3[i], all_shingled3[j]))[0]\n\n            rows.append(['Shingled 3', np.mean(shingled3_distances), np.amax(shingled3_distances)])\n            print(\"Computed directed Hausforff distances for tri-grams.\")\n\nwith open('\/home\/ismir\/Documents\/ISMIR\/figures\/deformations_run2\/mean_max.csv', mode='w') as f:\n    writer = csv.writer(f)\n    writer.writerows(rows)\nprint('Stats computed.')"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_569","text":"import os\nimport glob\nimport scipy.misc as misc\nimport numpy as np\nimport imageio\n\nfrom io import BytesIO\n\n\ndef normalize_image(img):\n    \"\"\"\n    Make image zero centered and in between (0, 1)\n    \"\"\"\n    normalized = img \/ 255.\n    return normalized\n\n\ndef read_split_image(img):\n    mat = misc.imread(img).astype(np.float)\n    side = int(mat.shape[1] \/ 2)\n    assert side * 2 == mat.shape[1]\n    img_A = mat[:, :side]  # target\n    img_B = mat[:, side:]  # source\n\n    return img_A, img_B\n\n\ndef bytes_to_file(bytes_img):\n    return BytesIO(bytes_img)\n\n\ndef read_split_image(img):\n    mat = misc.imread(img).astype(np.float)\n    side = int(mat.shape[1] \/ 2)\n    assert side * 2 == mat.shape[1]\n    img_A = mat[:, :side]  # target\n    img_B = mat[:, side:]  # source\n\n    return img_A, img_B\n\n\ndef shift_and_resize_image(img, shift_x, shift_y, nw, nh):\n    w, h, _ = img.shape\n    enlarged = misc.imresize(img, [nw, nh])\n    return enlarged[shift_x:shift_x + w, shift_y:shift_y + h]\n\n\ndef scale_back(images):\n    return (images + 1.) \/ 2.\n\n\ndef merge(images, size):\n    h, w = images.shape[1], images.shape[2]\n    img = np.zeros((h * size[0], w * size[1], 3))\n    for idx, image in enumerate(images):\n        i = idx % size[1]\n        j = idx \/\/ size[1]\n        img[j * h:j * h + h, i * w:i * w + w, :] = image\n\n    return img\n\n\ndef save_concat_images(imgs, img_path):\n    concated = np.concatenate(imgs, axis=1)\n    misc.imsave(img_path, concated)\n\n\ndef compile_frames_to_gif(frame_dir, gif_file):\n    frames = sorted(glob.glob(os.path.join(frame_dir, \"*.png\")))\n    print(frames)\n    images = [misc.imresize(imageio.imread(f), interp='nearest', size=0.33) for f in frames]\n    imageio.mimsave(gif_file, images, duration=0.1)\n    return gif_file\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_570","text":"<gh_stars>0\n'''\r\nFFT_testing.py\r\n\r\nBenchmark of the FFT method with CST files\r\n'''\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport time\r\nimport sys\r\nimport os\r\nfrom scipy.constants import c, mu_0, pi \r\nfrom scipy.special import iv\r\nfrom copy import copy\r\nimport pickle as pk   \r\n\r\n# UNIT=1e-3 #mm to m\r\n\r\n# # Gaussian bunch \r\n# t0=0.53e-10         #injection time [s]\r\n# WL=50*UNIT          #wakelength [m]\r\n# sigmaz=1.0*UNIT     # [m]\r\n# sigmat=sigmaz\/c     # [s]\r\n# q=1e-9              # [C]\r\n\r\n# #--- define time\r\n# N=10000\r\n# tau=np.linspace(1e-12, WL\/c, N)\r\n# dt=tau[2]-tau[1]\r\n\r\n# #--- define s\r\n# s=np.linspace(-t0*c, WL, N)\r\n# ds=s[2]-s[1]\r\n\r\n# # bunch=np.exp(-((tau-2*t0)**2)\/(2*(sigmat**2))) #*1\/(sigmat*np.sqrt(2*pi))\r\n# bunch=q*np.exp(-((s)**2)\/(2*(sigmaz**2)))*1\/(sigmaz*np.sqrt(2*pi))\r\n\r\n# # Wakefunction\r\n\r\n# F=1.0           #form factor\r\n# L=300*UNIT      #length [m]\r\n# b=1.0*UNIT      #radius [m]\r\n# Zo=376.73       #vacuum impedance [Ohm]\r\n# sigma_el=1.0e6   #electric conductivity [S\/m]\r\n# #s_wf=np.linspace(1.0e-5, WL, 1000)\r\n# WF=np.zeros_like(s)\r\n\r\n# #WF=-F*L\/(4*pi*b)*np.sqrt(Zo\/(pi*c*sigma_el))*(1\/np.power(tau,3\/2))\r\n# mask = s > 0\r\n# WF[mask]=F*L*c\/(4*pi*b)*np.sqrt(Zo\/(pi*sigma_el))*(1\/np.power(abs(s[mask]),3\/2))\r\n# #WF[np.logical_not(mask)] = 0.0\r\n\r\n# # Wakepotential\r\n\r\n# #--- with convolution\r\n\r\n# '''\r\n# WFf, f = Wsol.DFT(WF, ds\/c, fmax=fmax, Nf=1000)\r\n# bunchf, f=Wsol.DFT(bunch, ds\/c, fmax=fmax, Nf=1000)\r\n\r\n# convf = WFf*bunchf\r\n# WP = np.fft.ifft(Wf)\r\n# '''\r\n\r\n# #WP_conv=(1\/(q*1e12))*np.convolve( bunch[mask] , WF[mask] )   #convolution of Wakefunction and bunch charge distribution [V\/pC]\r\n# WP_conv=(1\/(q*1e12))*np.convolve( bunch , WF )\r\n# s_conv=np.linspace(0, WL, len(WP_conv))\r\n# WP_conv = np.interp(s, s_conv, WP_conv)\r\n\r\n\r\n# #--- from theory\r\n# x=s\/(2*sigmaz)\r\n# WPth=-c*L\/(4*pi*b*np.power(sigmaz, 3\/2))*np.sqrt(Zo\/sigma_el)*np.power(abs(x), 3\/2)*np.exp(-x**2)*(iv(-3\/4, x*x)-iv(1\/4, x*x)+np.sign(s)*(iv(3\/4, x*x)-iv(-1\/4, x*x)))\r\n# WPth=WPth*1e-12 #[V\/pC]\r\n\r\n# # Impedance\r\n\r\n# fmax=1\/(3*sigmat)\r\n\r\n# #--- with FFT\r\n# bunchf, f2=Wsol.FFT(bunch\/q, ds\/c, fmax=2*fmax, flag_zeropadding=False)\r\n# WPf, f=Wsol.FFT(WPth*1e12, ds\/c, flag_zeropadding=False)\r\n\r\n# bunchf = np.interp(f,f2,bunchf)\r\n\r\n# #--- with DFT\r\n# #WPf, f=Wsol.DFT(WPth, ds\/c, fmax=fmax, Nf=1000)\r\n# #bunchf, f=Wsol.DFT(bunch\/q, ds\/c, fmax=fmax, Nf=1000)\r\n# #WPf_conv, f=Wsol.DFT(WP_conv, ds\/c, fmax=fmax, Nf=1000)\r\n\r\n# Z = - WPf \/ bunchf \r\n# Z_abs= abs(Z)\r\n# Z_re=np.real(Z)\r\n# Z_im=np.imag(Z)\r\n\r\n# #Z_conv = - WPf_conv \/ bunchf \r\n\r\n# #--- from theory\r\n# fth=np.linspace(0, fmax, 1000)\r\n# Zth=(1-1j*np.sign(fth))*L\/(2*pi*b)*np.sqrt(Zo*2*pi*fth\/(2*c*sigma_el))\r\n\r\n# Zth_abs=abs(Zth)\r\n# Zth_re=np.real(Zth)\r\n# Zth_im=np.imag(Zth)\r\n\r\n# '''\r\n# # Plot WP \r\n# fig = plt.figure(2, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(s, WP_conv, color='red', label='Wake potential from convolution [norm]')\r\n# ax.plot(s, WPth, color='red', ls='--', label='Wake potential from theory')\r\n# ax.plot(s, bunch\/max(bunch)*max(abs(WPth)), color='orange', label='lambda(s)')\r\n# ax.set(title='Resistive wall Wake potential W\/\/(s)',\r\n#         xlabel='s [m]',\r\n#         ylabel='WP [V\/pC]',         \r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n# '''\r\n\r\n# '''\r\n# # Plot WF\r\n# fig = plt.figure(2, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(s, WF, color='blue', ls='--', label='Wake function from theory')\r\n# ax.plot(s, bunch, color='orange', label='lambda(s)')\r\n# ax.set(title='Resistive wall Wake function',\r\n#         xlabel='s [m]',\r\n#         ylabel='WF [V]',         \r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n# '''\r\n\r\n# # Plot Z vs Zth\r\n# factor=sum(Zth_abs)\/len(Zth_abs)\/(sum(Z_abs)\/len(Z_abs))\r\n# fig = plt.figure(2, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# #ax.plot(fth, Zth_abs, color='green', ls='--', label='|Z(f)| from theory')\r\n# ax.plot(f, Z_abs, color='green', label='|Z(f)| from FFT')\r\n# #ax.plot(f, abs(Z_conv), color='m', label='|Z(f)| from convolution')\r\n# ax.plot(f, Z_re, color='red', label='Zre(f) from FFT')\r\n# ax.plot(f, Z_im, color='blue', label='Zim(f) imaginary from FFT')\r\n# ax.set(title='Resistive wall impedance Z\/\/(f)', #' \\n Zth \/ Z = ' + str(round(factor,3)),\r\n#         xlabel='f [Hz]',\r\n#         ylabel='Z [Ohm]',  \r\n#         xlim=(0, 1\/(3*sigmat)),      \r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n\r\n\r\n# '''\r\n# # Plot Z vs Zth Re and Im\r\n# fig = plt.figure(2, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(f, Z_re, color='red', label='Zre(f) from FFT')\r\n# ax.plot(f, Z_im, color='blue', label='Zim(f) imaginary from FFT')\r\n# ax.plot(f, Zth_re, color='green', ls='--', label='Zre(f) from theory')\r\n# ax.plot(f, Zth_im, color='m', ls='--', label='Zim(f) from theory')\r\n# ax.set(title='Resistive wall impedance',\r\n#         xlabel='f [Hz]',\r\n#         ylabel='Z [Real \/ Imag]',         \r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n# '''\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n# #--- read the cst dictionary\r\n# with open('cst_out.txt', 'rb') as handle:\r\n#   cst_data = pk.loads(handle.read())\r\n\r\n# print(cst_data.keys())\r\n# charge_dist_time=cst_data.get('charge_dist_time')\r\n# t=cst_data.get('t_charge_dist')\r\n# t0=cst_data.get('init_time')\r\n# dt=t[2]-t[1]\r\n\r\n# charge_dist=cst_data.get('charge_dist')\r\n# s_charge_dist=cst_data.get('s_charge_dist')\r\n# ds_charge_dist=s_charge_dist[2]-s_charge_dist[1]\r\n# spectrum=cst_data.get('charge_dist_spectrum')\r\n# df=0.0094650788*1e9\r\n# f_spectrum=np.arange(0, 1001*df, df)\r\n# q=1e-9 #[C]\r\n\r\n# #'''\r\n# Wake_potential=cst_data.get('WP_cst')\r\n# s_cst=cst_data.get('s_cst')\r\n# Z_cst=cst_data.get('Z_cst')\r\n# freq_cst=cst_data.get('freq_cst')\r\n# sigmaz=cst_data.get('sigmaz')\r\n# #'''\r\n# '''\r\n# Wake_potential_cst=cst_data.get('WPx_dipolar_cst')\r\n# s_cst=cst_data.get('s_cst_dipolar')\r\n# Z_cst=cst_data.get('Zx_dipolar_cst')\r\n# freq_cst=cst_data.get('freq_cst_dipolar')\r\n# '''\r\n# '''\r\n# Wake_potential_cst=cst_data.get('WPy_quadrupolar_cst')\r\n# s_cst=cst_data.get('s_cst_quadrupolar')\r\n# Z_cst=cst_data.get('Zy_quadrupolar_cst')\r\n# freq_cst=cst_data.get('freq_cst_quadrupolar')\r\n# '''\r\n\r\n# #--- Auxiliary variables\r\n# ds=s_cst[2]-s_cst[1]\r\n# s=np.arange(np.min(s_cst),np.max(s_cst),ds) #constant ds vector\r\n\r\n# #--- Obtain impedance Z with Fourier transform numpy.fft.fft\r\n# # MAKE A SYMMETRIC SIGNAL\r\n\r\n# # Interpolate charge distribution\r\n# # INTERPOLATE TO HAVE A CONSTANT ds. PLOT CST DS DISTRIBUTION\r\n# charge_dist_interp=np.interp(s, s_charge_dist, charge_dist)\r\n# Wake_potential_interp=np.interp(s, s_cst, Wake_potential)\r\n\r\n# #lambdaf, f=Wsol.FFT(charge_dist_interp, ds\/c, fmax=np.max(freq_cst), r=10.0)\r\n# #WPf, f=Wsol.FFT(Wake_potential_interp, ds\/c, fmax=np.max(freq_cst), r=10.0)\r\n        \r\n\r\n# #lambdaf, f2=Wsol.DFT(charge_dist\/q, ds_charge_dist\/c, fmax=max(freq_cst), Nf=2001)\r\n# WPf, f=Wsol.DFT(Wake_potential*1e12, ds\/c, fmax=max(freq_cst), Nf=2001)\r\n# #WPf=WPf*sum(Wake_potential*1e12)*ds\/c\/np.sqrt(pi)\r\n\r\n# #lambdaf=np.interp(f,f2,lambdaf)\r\n# lambdaf=np.interp(f, f_spectrum, spectrum\/q)*c\r\n\r\n\r\n# # Compute the impedance\r\n# Z = abs(- WPf \/ lambdaf) # * 2\/(t_sample*ds\/np.sqrt(pi)) #normalized according to CST wakesolver manual\r\n\r\n# # Plot Impedance and maximum frequency\r\n# fig = plt.figure(1, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n\r\n# # add CST fft result\r\n# ax.plot(freq_cst*1.0e-9, Z_cst, lw=1.2, color='black', label='Z\/\/ from CST')\r\n\r\n# # add numpy.fft result (normalized)\r\n# factor=np.max(Z_cst)\/np.max(Z)\r\n# ax.plot(f*1.0e-9, Z, lw=1.2, color='red', label='Z\/\/ from numpy FFT')\r\n\r\n# ax.set(title='Longitudinal impedance Z from CST magnitude',\r\n#         xlabel='frequency [GHz]',\r\n#         ylabel='Z\/\/(s) [Ohm]',         #ylim=(-8.0e4,8.0e4)\r\n#         xlim=(0.,np.max(freq_cst)*1e-9)\r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n\r\n\r\n# # Plot charge dist and wake potential\r\n# '''\r\n# fig = plt.figure(2, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(s*1e3, charge_dist_interp, color='red', label='$\\lambda$(s)')\r\n# ax.plot(s*1e3, Wake_potential_cst, color='orange', label='W||(s)')\r\n# ax.set(title='Wake potential and charge distribution',\r\n#         xlabel='s [mm]',\r\n#         ylabel='W||(s) [V\/pC]',         #ylim=(-8.0e4,8.0e4)\r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n# '''\r\n\r\n# fig = plt.figure(1, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(f\/1e9, abs(lambdaf), color='red', label='$\\lambda$(w)')\r\n# ax.plot(f\/1e9, abs(WPf), color='orange', label='W||(w)')\r\n# ax.set(title='Wake potential and charge distribution',\r\n#         xlabel='f [GHz]',\r\n#         ylabel='W||(s) [V\/pC]',         #ylim=(-8.0e4,8.0e4)\r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n\r\n\r\n# #VALUE IN 0 SHOULD BE THE SAME AS THE INTEGRAL FOR THE CHARGE DIST\r\n\r\n\r\n# spectrum_fft,f=Wsol.DFT(charge_dist_time, dt, fmax=max(f_spectrum), Nf=2001)\r\n# spectrum_fft=spectrum_fft*sum(charge_dist_time)*dt\/np.sqrt(pi)\r\n\r\n# fig = plt.figure(1, figsize=(6,4), dpi=200, tight_layout=True)\r\n# ax=fig.gca()\r\n# ax.plot(f\/1e9, abs(spectrum_fft), color='red', label='DFT')\r\n# ax.plot(f_spectrum\/1e9, spectrum, color='blue', label='CST')\r\n# ax.set(title='Charge distribution spectrum',\r\n#         xlabel='f [GHz]',\r\n#         ylabel='Spectrum',         #ylim=(-8.0e4,8.0e4)\r\n#         )\r\n# ax.legend(loc='best')\r\n# ax.grid(True, color='gray', linewidth=0.2)\r\n# plt.show()\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n#--- read the cst dictionary\r\nwith open('cst_out.txt', 'rb') as handle:\r\n  cst_data = pk.loads(handle.read())\r\n\r\nbunch=cst_data.get('charge_dist')\r\nbunch_time=cst_data.get('charge_dist_time')\r\nspectrum=cst_data.get('charge_dist_spectrum')\r\ncurrent=cst_data.get('current')\r\ns_bunch=cst_data.get('s_charge_dist')\r\nds_bunch=s_bunch[2]-s_bunch[1]\r\ndf=0.0094650788*1e9\r\nf_spectrum=np.arange(0, 1001*df, df)\r\ndt=0.0013634439*1e-9\r\nt_current=np.arange(0,7.5371175*1e-9, dt)\r\nq=1e-9 #[C]\r\n\r\nWP=cst_data.get('WP_cst')\r\nZ_cst=cst_data.get('Z_cst')\r\nWP_dip=cst_data.get('WPx_dipolarX_cst')\r\nZ_dip_cst=cst_data.get('Zx_dipolarX_cst')\r\nWP_quad=cst_data.get('WPx_quadrupolarX_cst')\r\nZ_quad_cst=cst_data.get('Zx_quadrupolarX_cst')\r\n\r\nf_cst=cst_data.get('freq_cst_dipolar')\r\ns_cst=cst_data.get('s_cst')\r\nds = s_cst[2]-s_cst[1]\r\ndf = f_cst[2]-f_cst[1]\r\n\r\nbunch_i=np.interp(s_cst, s_bunch, bunch)\r\n\r\n'''\r\nlambdaf, f2=Wsol.DFT(bunch_i\/q, ds\/c, fmax=max(f_spectrum), Nf=2001)\r\nWPf, f=Wsol.DFT(WP*1e12, ds\/c, fmax=max(f_cst), Nf=2001)\r\nWPf_dip, f=Wsol.DFT(WP_dip*1e12, ds\/c, fmax=max(f_cst), Nf=2001)\r\nWPf_quad, f=Wsol.DFT(WP_quad*1e12, ds\/c, fmax=max(f_cst), Nf=2001)\r\n'''\r\nlambdafft = np.fft.fft(bunch_i\/q*c, n=200000)\r\nWPfft = np.fft.fft(WP*1e12, n=200000)\r\nWPfft_dip = np.fft.fft(WP_dip*1e12, n=200000)\r\nWPfft_quad = np.fft.fft(WP_quad*1e12, n=200000)\r\nffft=np.fft.fftfreq(len(WPfft), ds\/c)\r\n\r\nmask  = np.logical_and(ffft >= 0 , ffft < 5.5*1e9)\r\nWPf = WPfft[mask]*ds\r\nWPf_dip = WPfft_dip[mask]*ds\r\nWPf_quad = WPfft_quad[mask]*ds\r\nlambdaf = lambdafft[mask]*ds\r\nf = ffft[mask]            # Positive frequencies\r\n\r\n# Compute the impedance\r\nZ = abs(- WPf \/ lambdaf)\r\nZ_dip = abs(1j* WPf_dip \/ lambdaf) \r\nZ_quad = abs(1j* WPf_quad \/ lambdaf)\r\n\r\n\r\n# Plot Impedance and maximum frequency\r\nfig = plt.figure(1, figsize=(6,4), dpi=200, tight_layout=True)\r\nax=fig.gca()\r\n\r\n# add CST fft result\r\n'''\r\nax.plot(f*1.0e-9, Z, lw=1.2, color='red', label='Z\/\/ from numpy FFT')\r\nax.plot(f_cst*1.0e-9, Z_cst, lw=1.2, color='black', ls='--', label='Z\/\/ from CST')\r\n'''\r\n'''\r\n\r\nax.plot(f*1.0e-9, Z_dip, lw=1.2, color='red', label='Z dipolar from numpy FFT')\r\nax.plot(f_cst*1.0e-9, Z_dip_cst, lw=1.2, color='black', ls='--', label='Z dipolar from CST')\r\n'''\r\n\r\nax.plot(f*1.0e-9, Z_quad, lw=1.2, color='red', label='Z quadrupolar from numpy FFT')\r\nax.plot(f_cst*1.0e-9, Z_quad_cst, lw=1.2, color='black', ls='--', label='Z quadrupolar from CST')\r\n\r\n#ax.plot(f_cst*1.0e-9, Z_cst\/Z_dip_cst, lw=1.2, color='black', label='Z\/\/ from CST')\r\n#ax.plot(f*1.0e-9, Z\/Z_dip, lw=1.2, color='red', label='Z\/\/ from numpy FFT')\r\n#ax.plot(s_cst*1e3, WP_quad, lw=1.2, color='blue', label='Z\/\/ from numpy FFT')\r\n\r\n#ax.plot(f_cst*1.0e-9, abs(WPf_dip)\/Z_dip_cst, lw=1.2, color='blue', label='Z\/\/ from numpy FFT')\r\n#ax.plot(f*1.0e-9, abs(lambdaf_cst), lw=1.2, color='blue', label='Z\/\/ from numpy FFT')\r\n\r\nax.set(title='Longitudinal impedance Z from CST magnitude',\r\n        xlabel='frequency [GHz]',\r\n        ylabel='Z\/\/(s) [Ohm]',         #ylim=(-8.0e4,8.0e4)\r\n        #xlim=(0.,np.max(f_cst)*1e-9)\r\n        )\r\nax.legend(loc='best')\r\nax.grid(True, color='gray', linewidth=0.2)\r\nplt.show()\r\n\r\n\r\n\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_571","text":"# -*- coding: utf-8 -*-\n\"\"\"\nMy implementation of a linear algebra library in Python. Consists of\na Vector and Matrix class that can be compatible with one another, as\nwell as useful methods for interacting with both concepts\/classes.\n\ngithub repository: https:\/\/github.com\/ulloaluis\/linear-algebra\n\"\"\"\n\nfrom math import gcd, pow, sqrt, isclose\nfrom linear_lib.linear_tests import *\nfrom fractions import Fraction\n\n__author__ = \"<NAME>\"\n__license__ = \"MIT\"\n__version__ = \"0.0.2\"\n__maintainer__ = \"<NAME>\"\n__email__ = \"<EMAIL>\"\n\n\nclass Vector:\n    \"\"\"\n    The Vector class imitates the m x 1 vector from linear algebra and\n    contains many useful functions for dealing and interacting with Vectors.\n\n    Getting values directly from the vector should be done using the get(index)\n    function since the comp vector location in memory may change with functions\n    like mag() or zero().\n\n    class Vector\n    __init__(comp)          - takes in a list of components or a valid mx1 Matrix\n    resize(length)          - while preserving current elements or filling with 0's, changes current vector length\n    set(comp, index=-1)     - sets entire list at once or one specific index\/value\n    get(index)              - returns item at specified index of vector\n    zero()                  - turns the current vector into a zero vector and returns it\n    mag()                   - returns the magnitude of current vector\n    normalize(change=False) - returns normalized current vector, if change=True, internal vector is updated\n    same_normalized(other)  - returns True\/False depending on equality of the two vectors once normalized\n    dot(other)              - returns the dot product of th two vectors\n    cross(other)            - returns the cross product of u x v (u is current vector, v is other)\n    perp(other)             - returns True\/False if current and other are\/aren't perpendicular\n    parallel(other)         - returns True\/False if current and other are\/aren't parallel\n    indep(other)          - returns True\/False if curr vector and other vector(s) are linearly independent\n    operator +              - returns sum of two vectors, component wise addition\n    operator -              - returns difference of two vectors, component wise subtraction\n    operator *              - alternate for dot product, or can use for vector scaling\n    operator **             - returns original vector with its components raised to power\n    operator ==             - checks to see if lists are equal\n    to string method        - format: \"<elem1, elem2, ...>\"\n    len() method            - can use len() to get vector length\n    get and set []          - user can get and set values in vector with index based operations []\n\n    comp = vector composition, list of components\n    length = number of components in vector\n    rows = same as length, used with cols for backwards compatibility with Matrix\n    cols = 1 (num of columns)\n    \"\"\"\n\n    def __init__(self, comp=[]):\n        \"\"\"\n        Initializes the vector with either a list containing its components\n        or an appropriate Matrix with mx1 dimensions. Defaults to an empty\n        vector if not specified.\n\n        :param comp: a list of the elements to be included in the vector;\n                        the initial components, defaulted to an empty list.\n                        could also be an appropriately sized Matrix\n        :type comp: list, Matrix\n        :return: none\n        :raises: ValueError when Matrix is invalid size for Vector conversion\n        \"\"\"\n        if isinstance(comp, Matrix):\n            if comp.cols == 1:\n                self.comp = [row[0] for row in comp.comp]\n            else:\n                raise ValueError(\"Cannot convert Matrix with greater than 1 column to Vector.\")\n        else:\n            self.comp = comp             # user should never change comp directly; use set()\n\n        self.length = len(self.comp)     # user should never change length directly; use resize()\n        self.rows = self.length          # rows and cols included for backwards compatibility as\n        self.cols = 1                    # a Matrix and for use in matrix-vector product\n\n    def resize(self, length):\n        \"\"\"\n        Re-sizes the vector to the specified length. If length is greater than\n        current size, the new components are initialized with 0, otherwise if length\n        is less than current size, the last few components are lost.\n\n        :param length: new length of vector\n        :type length: int\n        :return: current vector, now resized\n        :rtype: Vector\n        \"\"\"\n        assert(length >= 0)                # no negative lengths\n        dist = length - self.length\n\n        if dist < 0:\n            self.comp = self.comp[:dist]  # notice how this fails when dist = 0, but else correctly handles it\n        else:\n            self.comp = self.comp + [0]*dist\n\n        self.length = length\n        return self\n\n    def set(self, comp, index=-1):\n        \"\"\"\n        Set\/change the values of the current vector. Can either pass in a new\n        list to replace the internal list, or can specify an index in vector\n        to change just that value, in which case comp can be a single value.\n        No errors are thrown if user re-sizes the list.\n\n        :param comp: list to replace whole vector or value to replace single component\n        :param index: optional parameter that specifies the index of the value to be replaced\n        :type comp: list, int, float\n        :type index: int, float (that is whole ex. 1.0)\n        :return: current vector, now updated\n        :rtype: Vector\n        :raises: index error if out of bounds index\n        \"\"\"\n        if index < 0:                   # default None and index=0 calls would conflict\n            self.comp = comp\n            self.length = self.rows = len(comp)\n        else:\n            if index >= self.length:\n                raise IndexError(\"Index out of bounds in vector.\")\n            self.comp[index] = comp\n        return self\n\n    def get(self, index):\n        \"\"\"\n        :param index: index of value\n        :type index: int\n        :return: element at specified index\n        :rtype: int, float\n        :raises: IndexError if index not in vector\n        \"\"\"\n        if 0 <= index < self.length:\n            return self.comp[index]\n        else:\n            raise IndexError(\"Specified index is not in vector.\")\n\n    def zero(self):\n        \"\"\"\n        Zeroes out the current vector by replacing each component with a 0.\n\n        :return: returns current vector, which is now a zero vector\n        :rtype: Vector\n        \"\"\"\n        self.comp = [0]*self.length\n        return self\n\n    def mag(self):\n        \"\"\"\n        Will get the magnitude of a vector.\n\n        :return: the magnitude of a vector (sqrt(sum of components squared))\n        :rtype: int, float\n        \"\"\"\n        return sqrt(sum([pow(x, 2) for x in self.comp]))\n\n    def normalize(self, change=False):\n        \"\"\"\n        Normalizes a vector (acts on internal vector, does not take in a vector)\n\n        :param change: if True, internal vector components are changed in addition\n                          to returning vector\n                 if False, vector says the same but normalized vector is returned;\n                           default is false\n        :type change: bool\n        :return: another Vector but with the normalized components (False)\n                 current Vector but with normalized components (True)\n        :rtype: Vector\n        \"\"\"\n        magnitude = self.mag()\n        if magnitude == 0:      # already zero vector\n            return self\n\n        if change:\n            self.comp = [elem \/ magnitude for elem in self.comp]\n            return self\n        else:\n            return Vector([x \/ magnitude for x in self.comp])\n\n    def same_normalized(self, other):\n        \"\"\"\n        This function states whether the current vector is the same as other\n        vector when normalized.\n\n        :param other: other vector to be compared\n        :type other: Vector\n        :return: True if they have same normalized version, False otherwise\n        :rtype: bool\n        \"\"\"\n        return self.normalize() == other.normalize()\n\n    def dot(self, other):\n        \"\"\"\n        This function returns a scalar (number) value representing the dot\n        product of the current vector and the other vector.\n\n        :param other: the b vector in a dot b\n        :type other: Vector\n        :return: The dot product of the current vector and other vector.\n        :rtype: int, float\n        :raises: ValueError when vectors are not the same length\n        \"\"\"\n        if len(self.comp) == len(other.comp):\n            return sum([x * y for x, y in zip(self.comp, other.comp)])\n        else:\n            raise ValueError(\"Invalid vectors - must be of same length.\")\n\n    def cross(self, other):\n        \"\"\"\n        For 3-dimensional vectors (3x1), this function allows you to take\n        the cross product, which produces a vector i.e. orthogonal to both.\n\n        :param other: 3D Vector (b in a X b)\n        :return: Vector representing cross product of current and other\n        :rtype: Vector\n        :raises: Value error if vectors are not 3 dimensional\n        \"\"\"\n\n        # Simplified version, after determinants: u is current vector v is other\n        # u x v = (u2v3 - u3v2)i - (u1v3-u3v1)j + (u1v2-u2v1)k\n        if self.length == 3 and other.length == 3:\n            i_hat = self.comp[1]*other.comp[2] - self.comp[2]*other.comp[1]\n            j_hat = -1 * (self.comp[0]*other.comp[2] - self.comp[2]*other.comp[0])\n            k_hat = self.comp[0]*other.comp[1] - self.comp[1]*other.comp[0]\n            return Vector([i_hat, j_hat, k_hat])\n        else:\n            raise ValueError(\"Invalid vectors - Can only take the cross product of 3D vectors.\")\n\n    def perp(self, other):\n        \"\"\"\n        Boolean function for whether two vectors are perpendicular\/orthogonal to each other.\n\n        :param other: the other vector\n        :type other: Vector\n        :return: Will return True if current vector and other vector are perpendicular, false otherwise.\n        :rtype: bool\n        \"\"\"\n\n        return self.dot(other) == 0\n\n    def parallel(self, other):\n        \"\"\"\n        Boolean function for whether two vectors are parallel to each other.\n\n        :param other: the other vector\n        :type other: Vector\n        :return: Will return True if current vector and other vector are parallel, false otherwise.\n        :rtype: bool\n        \"\"\"\n\n        return self.cross(other).mag() == 0   # could also check dot prod = |A*B|\n\n    def indep(self, other):\n        \"\"\"\n        Determines whether current vector and one or more vectors are linearly independent.\n\n        Note: User should make sure to pass in vectors of correct dimension.\n\n        :param other: list of vectors or a vector to be compared to current\n        :type other: List, Vector\n        :return: boolean true\/false if given vectors are linearly independent\n        :rtype: bool\n        :raises: ValueError if other is not a valid type\n        \"\"\"\n\n        if isinstance(other, Vector):   # make 'other' a list if it's a vector\n            other = [other]\n\n        if isinstance(other, list) and len(other) > 0:\n            other.append(self)\n            m, n = len(other), len(other[0])    # m is num vectors, n is vector dimension\n\n            if m == n:              # Place list into matrix and check if determinant is 0\n                return Matrix([vec.comp for vec in other]).det() != 0\n            elif m < n:\n                row_reduced = Matrix([vec.comp for vec in other]).row_reduce()\n                return Vector(row_reduced[-1]).mag() != 0   # see if last row is all 0s\n            else:\n                return False    # if num vectors > dimension, can't be independent\n\n        else:\n            raise ValueError(\"Invalid input - Must be a vector or list of vectors.\")\n\n    def __add__(self, other):\n        \"\"\"\n        Adding two vectors returns a vector with the respective components\n        added together as expected. (does not affect this or other vector's\n        components)\n\n        :param other: the other vector to be added to current instance vector\n        :type other: Vector\n        :return: a vector with the resulting added components\n        :rtype: Vector\n        :raises: ValueError when vectors are not the same length\n        \"\"\"\n        if len(self.comp) == len(other.comp):\n            return Vector([x+y for x, y in zip(self.comp, other.comp)])\n        else:\n            raise ValueError(\"Invalid vectors - must be of same length.\")\n\n    def __sub__(self, other):\n        \"\"\"\n       Subtracting two vectors returns a vector with the respective components\n       subtracted. \"current - other\" is formatting. (this does not affect this\n       or other vector's components)\n\n       :param other: the other vector which is subtracting from the current vector\n       :type other: Vector\n       :return: a vector with the resulting subtracted components\n       :rtype: Vector\n       :raises: ValueError when vectors are not the same length\n       \"\"\"\n        if len(self.comp) == len(other.comp):\n            return Vector([x-y for x, y in zip(self.comp, other.comp)])\n        else:\n            raise ValueError(\"Invalid vectors - must be of same length.\")\n\n    def __mul__(self, other):\n        \"\"\"\n        Multiplies the two vectors together; same functionality as calling the\n        dot() function for dot product of current and other. Could also scale\n        each component by a number\n\n        :param other: the other vector\n        :type other: Vector, integer, float\n        :return: number value representing dot product of both vectors\n        :rtype: int, float\n        :raises: ValueError when vectors are not the same length\n        \"\"\"\n        if isinstance(other, int) or isinstance(other, float):\n            return Vector([x * other for x in self.comp])\n        elif len(self.comp) == len(other.comp):\n            return self.dot(other)\n        else:\n            raise ValueError(\"Invalid vectors - must be of same length.\")\n\n    def __eq__(self, other):\n        \"\"\"\n        If two vectors have the same components, then they are equal. If the\n        lists are not the same length, will always be False with no error thrown.\n\n        :param other: other vector being tested for equality\n        :type other: Vector\n        :return: True or False based on equality\n        :rtype: bool\n        \"\"\"\n        return self.comp == other.comp  # compares lists\n\n    def __pow__(self, power, modulo=None):\n        \"\"\"\n        Allows you to raise each of the components of the current vector to a power.\n\n        :param power: value to raise each component to\n        :param modulo: optional parameter that applies the modulus operator to each result\n        :type power: int, float\n        :type modulo: int, float\n        :return: a vector containing the appropriately scaled components\n        :rtype: Vector\n        \"\"\"\n\n        return Vector([pow(x, power) % modulo if modulo else pow(x, power) for x in self.comp])\n\n    def __str__(self):\n        \"\"\"\n        Converts vector to string by placing the components a, b , c, ... into arrow\n        brackets, as such <a, b, c, ...>.  Empty arrays return <empty> for clarity.\n\n        :return: a string detailing contents of vector with the format <a, b, c, ...> or <empty>\n        :rtype: str\n        \"\"\"\n        if self.length == 0:\n            return \"<empty>\"\n        vec = \"<\"\n        for elem in self.comp:\n            vec += str(elem) + \", \"\n        return vec[:-2] + \">\"  # remove additional \", \" and close\n\n    def __len__(self):\n        \"\"\"\n        :return: length of vector\n        :rtype: int\n        \"\"\"\n        return self.length\n\n    def __getitem__(self, i):\n        \"\"\"\n        Alternate for get(), allows you to reliably access components of vector.\n        v = Vector([1,2]) v[0] -> 1\n\n        :param i: index\n        :type i: int\n        :return: value at specified index in self.comp\/vector\n        :rtype: int, float\n        \"\"\"\n        return self.get(i)\n\n    def __setitem__(self, key, value):\n        \"\"\"\n        Allows user to set value using index-based accessing.\n\n        :param key:\n        :param value:\n        :return: item just inserted\n        \"\"\"\n        return self.set(value, key)\n\n\nclass Matrix:\n    \"\"\"\n    The Matrix class imitates the matrix concept from linear algebra and allows\n    for different ways of dealing and interacting with matrices and vectors.\n\n    class Matrix\n    __init__(comp)          - takes in a list of components or a valid Vector\n    resize(rows, cols)      - while preserving current elements or filling with 0's, changes current vector length\n    set(comp, index=None)   - sets entire list at once or one specific index\/value (tuple or array as (row, col))\n    get(row=None,col=None)  - can get a specific row, column, or entire matrix composition (no args for matrix)\n    zero()                  - replaces values in current matrix with all zeroes and returns it\n    det()                   - takes the determinant of the current NxN matrix\n    transpose()             - transposes the current mxn matrix to an nxm matrix (1st row becomes 1st col, etc.)\n    row_echelon()           - returns the current matrix in row echelon form\n    row_reduce()            - returns the current matrix to reduced row echelon form\n    identity(n)             - static method that returns the nxn identity matrix\n    combine(first, second)  - static method that combines two matrices by concatenation\n    inverse()               - returns the inverse of current nxn matrix, or None if singular\n    operator +              - returns sum of two matrices, component wise addition\n    operator -              - returns difference of two matrices, component wise subtraction\n    operator *              - matrix multiplication, matrix-vector product, scalar multiplication\n    operator **             - returns original matrix with its components raised to power\n    operator ==             - checks to see if internal lists are equal\n    to string method        - format: \"[row1\\n row2\\n row3\\n ...]\" and floats are shown as fractions\n    len() method            - returns tuple formatted as (row, col)\n    get and set [][]        - can get rows and specific values with [] or [][], and set specific values with [][]\n\n    comp = matrix composition, list of lists where each list is a row\n    rows = number of rows in matrix\n    cols = number of columns in matrix\n    \"\"\"\n    def __init__(self, comp=[]):\n        \"\"\"\n        Initializes the matrix to the specified format. Default is an empty 0x0 matrix\n\n        Note: It is up to the user to pass well-formed matrices, that is, two different\n                rows cannot be different lengths, etc.\n\n        :param comp: list of lists where each individual list represents a row,\n                     similar to how numpy implements arrays; could also be a vector\n        :type comp: list, Vector\n        :return: none\n        \"\"\"\n\n        if isinstance(comp, Vector):\n            self.comp = [[row] for row in comp.comp]  # m x 1 Vector --> m rows\n        else:\n            self.comp = comp                          # list\n\n        self.rows = len(self.comp)          # User should never be able to change instance\n        if self.rows != 0:                  # variables directly, use an appropriate method\n            self.cols = len(self.comp[0])\n        else:\n            self.cols = 0                   # if rows = 0, then no columns by default\n\n    def resize(self, rows, cols):\n        \"\"\"\n        Re-sizes the current matrix to the specified dimensions, rows x cols.\n        Previous elements are left in place, if size is increased then new\n        locations are filled with values of 0.\n\n        :param rows: new row size\n        :param cols: new column size\n        :type rows: int, float\n        :type cols: int, float\n        :return: current matrix after resizing\n        :rtype: Matrix\n        \"\"\"\n        assert(rows >= 0 and cols >= 0)     # no negative dimensions allowed\n\n        dist_rows = rows - self.rows\n        dist_cols = cols - self.cols\n\n        if dist_rows < 0:\n            self.comp = self.comp[:dist_rows]\n        else:\n            for i in range(dist_rows):\n                self.comp.append([0]*self.cols)  # update rows but don't have varying number of columns for each row\n\n        if dist_cols < 0:                        # go through and shape columns now\n            for i in range(rows):\n                self.comp[i] = self.comp[i][:dist_cols]\n        else:\n            for i in range(rows):\n                self.comp[i] += [0]*dist_cols\n\n        self.rows = rows\n        self.cols = cols\n        return self\n\n    def set(self, comp, index=None):\n        \"\"\"\n        Set\/change the current matrix. If index is not specified, then comp should\n        be a list of lists detailing a new matrix. Otherwise, comp should be the\n        integer value that goes in the specified index (row, column) tuple.\n\n        :param comp: list of lists to replace matrix entirely, or single value\n                     to replace a specific location in matrix\n        :param index: optional tuple\/list with (row, column) of value to be replaced\n        :type comp: list of lists, int\n        :type index: tuple, list\n        :return: self, after edits are made\n        :rtype: Matrix\n        \"\"\"\n\n        if not index:\n            assert(isinstance(comp, list))\n            self.comp = comp\n            self.rows = len(comp)\n            if self.rows != 0:\n                self.cols = len(comp[0])\n            else:\n                self.cols = 0\n        else:\n            assert(isinstance(comp, int))\n            self.comp[index[0]][index[1]] = comp\n        return self\n\n    def get(self, row=None, col=None):\n        \"\"\"\n        User can get rows, columns, the matrix comp list, or specific values\n        in Matrix using this function and its optional parameters\n\n        :param row: index of target row\n        :param col: index of target col\n        :type row: int\n        :type col: int\n        :return: element at specified row\/col, or a row, or a col, or entire Matrix\n        :rtype: int, list (row\/col), List\n        :raises: IndexError if row index or col index invalid\n        \"\"\"\n        if row is not None and col is not None:  # value\n            if 0 > row >= self.rows and 0 > col >= self.cols:\n                raise IndexError(\"Row or column out of index bounds.\")\n            return self.comp[row][col]\n        elif col is None and row is not None:    # row\n            if 0 > row >= self.rows:\n                raise IndexError(\"Row out of index bounds.\")\n            return self.comp[row]\n        elif col is not None:                    # just col\n            if 0 > col >= self.cols:\n                raise IndexError(\"Col out of index bounds.\")\n            return [r[col] for r in self.comp]\n        else:                                    # entire matrix\n            return self.comp\n\n    def zero(self):\n        \"\"\"\n        Zeroes out the current matrix by replacing every element with a zero.\n\n        :return: The current matrix, but updated to be the zero matrix.\n        \"\"\"\n        self.comp = [[0]*self.cols for _ in range(self.rows)]\n        return self\n\n    def det(self):\n        \"\"\"\n        Returns the determinant of an nxn matrix that is at least a 2x2. (recursive)\n\n        :return: the determinant of the current matrix\n        :rtype: int, float\n        \"\"\"\n\n        if self.rows != self.cols:\n            raise ValueError(\"Invalid matrix - only N x N matrices supported.\")\n\n        # base case -> 2 by 2\n        if self.rows == 2 and self.cols == 2:  # ad - bc\n            return self.comp[0][0] * self.comp[1][1] - self.comp[0][1] * self.comp[1][0]\n\n        # going along top, along first row (not optimized to find best path)\n        top_row = self.comp[0]\n        determinant = 0\n        for col_i in range(len(top_row)):\n            # don't include in same row or column\n            new_matrix = self.comp[1:]            # remove top row\n            for r in range(len(new_matrix)):      # remove this column from each row\n                new_matrix[r] = new_matrix[r][:col_i] + new_matrix[r][col_i + 1:]\n\n            constant = top_row[col_i]\n            if col_i % 2 == 1:\n                constant *= -1  # every other constant is negative\n\n            determinant += constant * Matrix(new_matrix).det()\n        return determinant\n\n    def transpose(self):\n        \"\"\"\n        This function will return the transpose of the current matrix. (A -> A^T)\n        \"First row becomes first column, second row becomes second column, etc.\"\n\n        :return: Transposed matrix\n        :rtype: Matrix\n        \"\"\"\n        return Matrix([[self.comp[r][c] for r in range(self.rows)] for c in range(self.cols)])\n\n    @staticmethod\n    def identity(n):\n        \"\"\"\n        Static method for creating an identity matrix of dimension nxn.\n\n        :param n: dimension of identity matrix\n        :type n: int\n        :return: identity matrix of size nxn\n        :rtype: Matrix\n        \"\"\"\n        return Matrix([[1 if i == j else 0 for j in range(n)] for i in range(n)])\n\n    @staticmethod\n    def combine(first, second):\n        \"\"\"\n        Static method for concatenating two matrices, side by side.\n        1 1   *combined  1  0    =      1 1 1 0\n        2 2     with*    0  1    =      2 2 0 1\n\n        Warning\/Note: Matrices should have the same number of rows, otherwise\n                        the minimum amount of rows will be present. (If first\n                        has 3 rows and second has 5 rows, combined matrix has 3)\n\n        :param first: first matrix\n        :param second: second matrix\n        :return: combined matrix, [[row1 + row2], ...]\n        :rtype: Matrix\n        \"\"\"\n        return Matrix([one + two for one, two in zip(first.comp, second.comp)])\n\n    @staticmethod\n    def _clean_matrix(new_matrix):\n        \"\"\"\n        Not intended for client use. This method goes through matrix contents\n        and reduces each row by the greatest common divisor of that row,\n        multiplies row by -1 if leading pivot is negative, and turns floats\n        into ints if no reduction occurs. self._clean_matrix or Matrix._clean_matrix\n\n        :param new_matrix: matrix.comp, composition of matrix\n        :type new_matrix: list\n        :return: \"cleaned\" matrix comp\n        :rtype: list\n        \"\"\"\n        cols = len(new_matrix[0])\n        for r, row in enumerate(new_matrix):\n            gcf = row[0]\n            for col in row[1:]:\n                gcf = gcd(gcf, col)\n\n            if gcf != 0:\n                new_matrix[r] = row = [elem \/\/ gcf for elem in row]  # update row for next list comp\n\n            c = 0\n            while c < cols and row[c] == 0:\n                c += 1\n            if c < cols and row[c] < 0:\n                new_matrix[r] = row = [-1*elem for elem in row]\n\n            new_matrix[r] = [int(col) if int(col) == col else col for col in row]\n\n        return new_matrix\n\n    @staticmethod\n    def _clear_pos(new_matrix, r, c, other_row):\n        \"\"\"\n        Helper method for both row echelon functions.\n\n        :param new_matrix: the matrix that will be updated by algorithmically\n                            clearing one position in matrix\n        :param r:  index of row to be changed\n        :param c:   index of col to be changed\n        :param other_row: index of other row being using in row operation\n        :type r: int\n        :type c: int\n        :type other_row: list\n        :return: matrix composition\n        :rtype: list\n        \"\"\"\n        above = new_matrix[r][c]\n        const = new_matrix[other_row][c]  # row we will use\n\n        # prioritize keeping numbers small \/ int division\n        if const > above != 0 and const % above == 0:\n            scale = const \/\/ above\n            new_matrix[r] = [elem * scale for elem in new_matrix[r]]\n        elif above >= const != 0 and const != 0 and above % const == 0:\n            scale = above \/\/ const\n            new_matrix[other_row] = [elem * scale for elem in new_matrix[other_row]]\n        else:  # scale both\n            new_matrix[r] = [elem * const for elem in new_matrix[r]]\n            new_matrix[other_row] = [elem * above for elem in new_matrix[other_row]]\n        new_matrix[r] = [other - curr for curr, other in\n                         zip(new_matrix[r], new_matrix[other_row])]\n        return new_matrix\n\n    def row_echelon(self):\n        \"\"\"\n        This function will row reduce the current matrix until it is in row echelon form.\n        That is, until there is an upper triangular matrix. I've made a decent amount of\n        optimizations in this function, but there definitely many others that could  be made.\n\n        Note: This doesn't change the matrix internally, you will have to assign the\n                return value to the your matrix variable if you want to change it.\n              There is no guarantee that the matrix returned will contain only integers, may\n                have floats.\n\n        :return: row echelon form of current matrix\n        :rtype: Matrix\n        :return:\n        \"\"\"\n\n        # adjust matrix so rows are in proper descending order \/ putting any pre-made pivots in place\n        new_matrix = sorted(self.comp, reverse=True)\n        pivot_row = 0\n\n        for c in range(self.cols):\n            new_matrix = sorted(new_matrix, reverse=True)   # swap any out of place rows\n            if pivot_row < self.rows and new_matrix[pivot_row][c] != 0:\n                for r in range(pivot_row+1, self.rows):     # use pivot row to clear other rows\n                    while new_matrix[r][c] != 0:\n\n                        new_matrix = self._clear_pos(new_matrix, r, c, pivot_row)\n\n                pivot_row += 1\n        new_matrix = self._clean_matrix(new_matrix)\n        return Matrix(sorted(new_matrix, reverse=True))     # swap any out of place rows\n\n    def row_reduce(self):\n        \"\"\"\n        This function will row reduce the current matrix until it is in reduced row\n        echelon form (RREF). The transpose of a matrix has the same RREF as original.\n\n        Note: This doesn't change the matrix internally, you will have to assign the\n                return value to the your matrix variable if you want to change it.\n\n        :return: reduced row echelon form of current matrix\n        :rtype: Matrix\n        \"\"\"\n\n        new_matrix = self.row_echelon().comp     # get in row echelon form first\n\n        pivots = {}     # store pivot indexes key-value for use later\n\n        # store pivots as col : row pairs\n        for r, row in enumerate(new_matrix):\n            # identify pivot\n            i = 0\n            while i < self.cols and row[i] == 0:\n                i += 1\n            if i < self.cols:\n                pivots[i] = r\n\n        # apply only 0s above pivot (bottom part is done since already in row echelon form)\n        offset = 0     # how far ahead the first pivot is (ex. may be zero cols before first pivot)\n        for c in range(self.cols):\n            if c in pivots:\n                pivot_row = pivots[c]       # row the pivot is in\n                for r in range(pivot_row):  # top part, don't loop past location of pivot\n                    while new_matrix[r][c] != 0:    # stay in same column and fix parts above pivot\n                        other_row = c-offset  # when no offset, col c can be cleared using row c since there are c zeros\n\n                        new_matrix = self._clear_pos(new_matrix, r, c, other_row)\n            else:\n                offset += 1\n\n        new_matrix = self._clean_matrix(new_matrix)  # this function also changes floats to perfect ints based on gcd\n\n        # now, apply \"each pivot is 1\" rule, floats inevitable, but preserve as much ints as possible\n        for r, row in enumerate(new_matrix):\n            # identify pivot\n            i = 0\n            while i < self.cols and row[i] == 0:\n                i += 1\n            # divide row by proper amount to get a 1 on pivot\n            if i < self.cols:\n                pivot = row[i]\n                new_matrix[r] = [elem \/\/ pivot if elem % pivot == 0 else elem \/ pivot for elem in row]\n        return Matrix(sorted(new_matrix, reverse=True))  # ensure ordering is still valid\n\n    def inverse(self):\n        \"\"\"\n        Gets the inverse A^-1 of the current matrix A.\n\n        :return: inverse matrix of current matrix, or None if not invertible (singular)\n        :rtype: Matrix\n        :raises: value error if current matrix is not nxn\n        \"\"\"\n        n = self.cols\n        identity = Matrix.identity(n)\n        if self.rows != n:\n            raise ValueError(\"Need an nxn matrix to calculate inverse.\")\n        # create combined matrix\n        with_identity = Matrix.combine(self, identity).row_reduce()\n        # if left side is identity, then right side is inverse\n        if Matrix([row[:n] for row in with_identity.comp]) != identity:\n            return None     # no inverse, singular\n        else:\n            return Matrix([row[-n:] for row in with_identity.comp])\n\n    def __add__(self, other):\n        \"\"\"\n        Adds two matrices and returns a matrix with the respective components\n        added together as expected.\n\n        :param other: the other matrix to be added to current instance matrix\n        :type other: Matrix\n        :return: a matrix with the resulting added components\n        :rtype: Matrix\n        :raises: ValueError when matrices do not have same dimensions\n        \"\"\"\n        new_comp = []\n        if self.rows == other.rows and self.cols == other.cols:\n            for x, y in zip(self.comp, other.comp):\n                new_comp.append([a + b for a, b in zip(x, y)])  # adding done in list comprehension\n            return Matrix(new_comp)\n        else:\n            raise ValueError(\"Size mismatch, both matrices must have the same number of rows and columns.\")\n\n    def __sub__(self, other):\n        \"\"\"\n       Subtracting two matrices returns a matrix with the respective components\n       subtracted. \"current - other\" is formatting.\n\n       :param other: the other matrix which is subtracting from the current matrix\n       :type other: Matrix\n       :return: a matrix with the resulting subtracted components\n       :rtype: Matrix\n       :raises: ValueError when matrices do not have same dimensions\n       \"\"\"\n        new_comp = []\n        if self.rows == other.rows and self.cols == other.cols:\n            for x, y in zip(self.comp, other.comp):\n                new_comp.append([a - b for a, b in zip(x, y)])  # subtracting done in list comprehension\n            return Matrix(new_comp)\n        else:\n            raise ValueError(\"Size mismatch, both matrices must have the same number of rows and columns.\")\n\n    def __mul__(self, other):\n        \"\"\"\n        Multiplies the two matrices together; aka Matrix Multiplication.\n        Matrix-Vector product is also possible using the Vector class, though\n        this method works for a mx1 matrix as well. Also configured to work with\n        normal application of multiplying a scalar to a matrix.\n\n        Notes: Approach is to take the dot product of each row of current matrix\n                with each column of other matrix\/vector. Since you typically write\n                \"Ax\" where A is the matrix and x is the vector, this syntax should\n                be adhered to when attempting matrix multiplication with these classes.\n\n        :param other: the other matrix or vector, could also be an int or float for scaling\n        :type other: Matrix, int, float\n        :return: the resulting matrix\n        :rtype: Matrix\n        :raises: ValueError when there's a matrix multiplication size mismatch ([mxn]*[nxp]=[mxp])\n        \"\"\"\n        new_matrix = []\n        if isinstance(other, int) or isinstance(other, float):\n            for row in self.comp:\n                new_matrix.append([elem * other for elem in row])\n            return Matrix(new_matrix)\n        elif self.cols == other.rows:    # [m x n] * [n x p] = [m x p] i.e. [self.rows x other.cols] matrix\n            other_cols = []\n            for i in range(other.cols):  # extract columns from rows\n                other_cols.append([row[i] if isinstance(other, Matrix) else row for row in other.comp])\n            for row_me in self.comp:\n                new_row = []\n                for col_other in other_cols:\n                    new_row.append(Vector(row_me) * Vector(col_other))   # Dot product of vectors\n                new_matrix.append(new_row)\n            return Vector([row[0] for row in new_matrix]) if other.cols == 1 else Matrix(new_matrix)\n        else:\n            raise ValueError(\"Size mismatch; [m x n] * [n x p] = [m x p] matrix\")\n\n    def __eq__(self, other):\n        \"\"\"\n        If two matrices have the same components, then they are equal. If the\n        lists are not the same length, will always be False with no error thrown.\n        Have to compare each component due to necessity of using math.isclose()\n        on floats in order to deal with floating point errors.\n\n        :param other: other matrix being tested for equality\n        :type other: Matrix\n        :return: True or False based on equality\n        :rtype: bool\n        \"\"\"\n        if self.rows != other.rows or self.cols != other.cols:\n            return False\n        for my_row, other_row in zip(self, other):\n            for my_val, other_val in zip(my_row, other_row):\n                if not isclose(my_val, other_val):\n                    return False\n\n        return self.comp == other.comp  # compares lists\n\n    def __pow__(self, power, modulo=None):\n        \"\"\"\n        Allows you to raise a matrix to a power, that is, each of the\n        components of the current matrix is raised to a power. Can use\n        power 0 to fill the current matrix with all 1s.\n\n        :param power: value to raise each component to\n        :param modulo: optional parameter that applies the modulus operator to each result\n        :type power: int, float\n        :type modulo: int, float\n        :return: a matrix containing the appropriately scaled components\n        :rtype: Matrix\n        \"\"\"\n        new_comp = []\n        for row in self.comp:\n            new_row = []\n            for elem in row:\n                if modulo:\n                    elem = elem % modulo\n                new_row.append(pow(elem, power))\n            new_comp.append(new_row)\n        return Matrix(new_comp)\n\n    def __str__(self):\n        \"\"\"\n        String representation of matrix is each row separated by new line\n        characters. This is done so that when printed it resembles a normal\n        matrix as closely as possible.\n\n        :return: string representation of current matrix\n        :rtype: str\n        \"\"\"\n\n        # joins each row of matrix with a new line character and a space,\n        # floats are converted to visual fractions, need to get rid of quotes around them\n        return \"[\" + '\\n '\\\n            .join([str([str(Fraction(elem).limit_denominator()) if isinstance(elem, float) else elem for elem in row])\n                  .replace('\\'', '') for row in self.comp])\\\n            + \"]\"\n\n    def __len__(self):\n        \"\"\"\n        :return: returns tuple formatted as (row, col)\n        :rtype: tuple\n        \"\"\"\n        return self.rows, self.cols\n\n    def __getitem__(self, index):\n        \"\"\"\n        Allows user to access internal self.comp without doing\n        my_matrix.comp[i][j] and instead doing my_matrix[i][j]\n\n        Note: the first [] calls this function, which returns row,\n                that row is a list, which supports [] in the same way\n                that this function does.\n\n        :param index: index of row\n        :type index: int\n        :return: list or value for row or row+col value\n        :rtype: list, value\n        \"\"\"\n        return self.comp[index]\n\n    def __setitem__(self, key, value):\n        \"\"\"\n        Allows the user to set a value using brackets.\n\n        Note: behavior undefined if user attempts to set a row.\n\n        :param key: index of row to be changed\n        :param value: value to be set\n        :type key: int\n        :type value: int\n        :return: no return\n        \"\"\"\n\n        self.set(value, key)\n\n\nif __name__ == \"__main__\":\n    test()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_572","text":"#=====================================================#\n#\n#    File:   zeta_zeroes_plot.py\n#    Author: <NAME>\n#    Date:   May 2021\n#    Description:\n#        Shows the position of the zeta zeroes along the critical strip\n#\n#=============================================================================#\n\n\nfrom time import time\nimport numpy as np\nfrom cmath import pi, sin\nfrom scipy.special import gamma\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n\n\n# returns the value of \\frac{\\zeta(s)}{\\eta(s)}\n# = \\frac{ 2^{iy}}{2^{iy}-2^{1-x}}\ndef zeta_over_eta(x, y):\n    A = -2**(1 - x)\n    B = 2**(y * 1j)\n    zeta_over_eta = B \/ (A + B)\n    return zeta_over_eta\n\n\n# approximates the eta function where\n# r is the real part of the input (r\\equiv\\Re(s))\n# and t is the imaginary part of the input (t\\equiv\\Im(s))\n# \\eta(r+it)=\\sum_{n=1}^\\infty\\frac{(-1)^{n-1}}{n^r}[cos(y\\phi_n)-isin(y\\phi_n)]\ndef eta(x, y, limit=5*10**3):\n    n = np.arange(1, limit)\n    coefficient = (-1)**(n-1) \/ n**x\n    phi_y = np.log(n) * y\n    real_parts = coefficient * np.cos(phi_y)\n    imaginary_parts = coefficient * np.sin(phi_y)\n\n    real_summation = real_parts.sum()\n    imaginary_summation = imaginary_parts.sum()\n    eta = real_summation - imaginary_summation * 1j\n\n    return eta\n\n\n# returns value of \\zeta(s)\n# where s \\equiv r + it ,r,t \\in \\mathbb{C}\n# by computing \\frac{\\zeta(s)\\eta(s)}\n# for x = 1\/2\ndef zeta(x, y=0):\n    result = zeta_over_eta(x, y) * eta(x, y)\n    return result\n\n\ndef is_sign_change(previous, number):\n    # print(f'prev: {previous}, number {number}')\n    if previous == 0:\n        return False\n    previous_sign = previous \/ abs(previous)\n    number_sign = number \/ abs(number)\n    return previous_sign != number_sign\n\n\ndef animate(i, x_vals, y_vals):\n    PRECISION = 100\n    previous_y_input = (i-1)\/PRECISION\n    current_y_input = i\/PRECISION\n    previous_zeta = zeta(1\/2, previous_y_input)\n    current_zeta = zeta(1\/2, current_y_input)\n    # print(current_zeta.real, current_zeta.imag)\n    # print(y_vals)\n    if is_sign_change(previous_zeta.real, current_zeta.real) and is_sign_change(previous_zeta.imag, current_zeta.imag):\n        x_vals.append(1\/2)\n        y_vals.append(current_y_input)\n        print(current_y_input)\n\n    plt.cla()\n\n    plt.scatter(x_vals, y_vals)\n\n    plt.xlabel('Re')\n    plt.ylabel('Im')\n    plt.tight_layout()\n\n\ndef plot():\n    plt.style.use('dark_background')\n\n    x_vals = []\n    y_vals = []\n\n    animation = FuncAnimation(plt.gcf(), animate, fargs=(x_vals, y_vals,), interval=0)\n    plt.xlabel('Re')\n    plt.ylabel('Im')\n    plt.tight_layout()\n    plt.show()\n\n\nif __name__=='__main__':\n    start = time()\n    plot()\n    print(f'--- {time()-start} seconds ---')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_573","text":"import numpy as np\nfrom scipy.ndimage import uniform_filter, gaussian_filter\nfrom numpy.lib.arraypad import _as_pairs\n\n_integer_types = (np.byte, np.ubyte,  # 8 bits\n                      np.short, np.ushort,  # 16 bits\n                      np.intc, np.uintc,  # 16 or 32 or 64 bits\n                      np.int_, np.uint,  # 32 or 64 bits\n                      np.longlong, np.ulonglong)  # 64 bits\n\n_integer_ranges = {t: (np.iinfo(t).min, np.iinfo(t).max)\n                   for t in _integer_types}\n\ndtype_range = {np.bool_: (False, True),\n               np.bool8: (False, True),\n               np.float16: (-1, 1),\n               np.float32: (-1, 1),\n               np.float64: (-1, 1)}\n\ndtype_range.update(_integer_ranges)\n\ndef _assert_compatible(im1, im2):\n    \"\"\"Raise an error if the shape and dtype do not match.\"\"\"\n    if not im1.shape == im2.shape:\n        raise ValueError('Input images must have the same dimensions.')\n    return\n\ndef _as_floats(im1, im2):\n    \"\"\"Promote im1, im2 to nearest appropriate floating point precision.\"\"\"\n    float_type = np.result_type(im1.dtype, im2.dtype, np.float32)\n    im1 = np.asarray(im1, dtype=float_type)\n    im2 = np.asarray(im2, dtype=float_type)\n    return im1, im2\n\ndef crop(ar, crop_width, copy=False, order='K'):\n    \"\"\"Crop array `ar` by `crop_width` along each dimension.\n    Parameters\n    ----------\n    ar : array-like of rank N\n        Input array.\n    crop_width : {sequence, int}\n        Number of values to remove from the edges of each axis.\n        ``((before_1, after_1),`` ... ``(before_N, after_N))`` specifies\n        unique crop widths at the start and end of each axis.\n        ``((before, after),)`` specifies a fixed start and end crop\n        for every axis.\n        ``(n,)`` or ``n`` for integer ``n`` is a shortcut for\n        before = after = ``n`` for all axes.\n    copy : bool, optional\n        If `True`, ensure the returned array is a contiguous copy. Normally,\n        a crop operation will return a discontiguous view of the underlying\n        input array.\n    order : {'C', 'F', 'A', 'K'}, optional\n        If ``copy==True``, control the memory layout of the copy. See\n        ``np.copy``.\n    Returns\n    -------\n    cropped : array\n        The cropped array. If ``copy=False`` (default), this is a sliced\n        view of the input array.\n    \"\"\"\n    ar = np.array(ar, copy=False)\n    crops = _as_pairs(crop_width, ar.ndim, as_index=True)\n    slices = tuple(slice(a, ar.shape[i] - b)\n                   for i, (a, b) in enumerate(crops))\n    if copy:\n        cropped = np.array(ar[slices], order=order, copy=True)\n    else:\n        cropped = ar[slices]\n    return cropped\n\ndef MSE(im1, im2):\n    \"\"\"Compute the mean-squared error between two images.\n    Parameters\n    ----------\n    im1, im2 : ndarray\n        Image.  Any dimensionality.\n    Returns\n    -------\n    mse : float\n        The mean-squared error (MSE) metric.\n    \"\"\"\n    _assert_compatible(im1, im2)\n    im1, im2 = _as_floats(im1, im2)\n    return np.mean(np.square(im1 - im2), dtype=np.float64)\n\n\ndef PSNR(ref_img, pred_img):\n    \"\"\"\n    Compute average PSNR score for a batch of pairs of images\n\n    :param ref_img: ndarray of shape (batch_size, width, height, channels) with target noise-free image\n    :param pred_img: ndarray of shape (batch_size, width, height, channels) with predicted denoised image\n    :return: float, averaged over batch PSNR score\n    \"\"\"\n\n    _assert_compatible(ref_img, pred_img)\n\n    dmin, dmax = dtype_range[ref_img.dtype.type]\n    true_min, true_max = np.min(ref_img), np.max(ref_img)\n    if true_max > dmax or true_min < dmin:\n        raise ValueError(\n            \"im_true has intensity values outside the range expected for \"\n            \"its data type.  Please manually specify the data_range\")\n    if true_min >= 0:\n        # most common case (255 for uint8, 1 for float)\n        data_range = dmax\n    else:\n        data_range = dmax - dmin\n\n    ref_img, pred_img = _as_floats(ref_img, pred_img)\n\n    err = MSE(ref_img, pred_img)\n    return 10 * np.log10((data_range ** 2) \/ err)\n\n\ndef SSIM(X, Y, win_size=None, gradient=False,\n                 data_range=None, multichannel=False, gaussian_weights=False,\n                 full=False, **kwargs):\n    \"\"\"Compute the mean structural similarity index between two images.\n    Parameters\n    ----------\n    X, Y : ndarray\n        Image. Any dimensionality.\n    win_size : int or None\n        The side-length of the sliding window used in comparison. Must be an\n        odd value. If `gaussian_weights` is True, this is ignored and the\n        window size will depend on `sigma`.\n    gradient : bool, optional\n        If True, also return the gradient with respect to Y.\n    data_range : float, optional\n        The data range of the input image (distance between minimum and\n        maximum possible values). By default, this is estimated from the image\n        data-type.\n    multichannel : bool, optional\n        If True, treat the last dimension of the array as channels. Similarity\n        calculations are done independently for each channel then averaged.\n    gaussian_weights : bool, optional\n        If True, each patch has its mean and variance spatially weighted by a\n        normalized Gaussian kernel of width sigma=1.5.\n    full : bool, optional\n        If True, also return the full structural similarity image.\n    Other Parameters\n    ----------------\n    use_sample_covariance : bool\n        If True, normalize covariances by N-1 rather than, N where N is the\n        number of pixels within the sliding window.\n    K1 : float\n        Algorithm parameter, K1 (small constant, see [1]_).\n    K2 : float\n        Algorithm parameter, K2 (small constant, see [1]_).\n    sigma : float\n        Standard deviation for the Gaussian when `gaussian_weights` is True.\n    Returns\n    -------\n    mssim : float\n        The mean structural similarity over the image.\n    grad : ndarray\n        The gradient of the structural similarity index between X and Y [2]_.\n        This is only returned if `gradient` is set to True.\n    S : ndarray\n        The full SSIM image.  This is only returned if `full` is set to True.\n    Notes\n    -----\n    To match the implementation of Wang et. al. [1]_, set `gaussian_weights`\n    to True, `sigma` to 1.5, and `use_sample_covariance` to False.\n    References\n    ----------\n    .. [1] <NAME>., <NAME>., <NAME>., & <NAME>.\n       (2004). Image quality assessment: From error visibility to\n       structural similarity. IEEE Transactions on Image Processing,\n       13, 600-612.\n       https:\/\/ece.uwaterloo.ca\/~z70wang\/publications\/ssim.pdf,\n       :DOI:`10.1109\/TIP.2003.819861`\n    .. [2] <NAME>. (2009). Exact global histogram specification\n       optimized for structural similarity. Optical Review, 16, 613-621.\n       :arXiv:`0901.0065`\n       :DOI:`10.1007\/s10043-009-0119-z`\n    \"\"\"\n    if not X.shape == Y.shape:\n        raise ValueError('Input images must have the same dimensions.')\n\n    if multichannel:\n        # loop over channels\n        args = dict(win_size=win_size,\n                    gradient=gradient,\n                    data_range=data_range,\n                    multichannel=False,\n                    gaussian_weights=gaussian_weights,\n                    full=full)\n        args.update(kwargs)\n        nch = X.shape[-1]\n        mssim = np.empty(nch)\n        if gradient:\n            G = np.empty(X.shape)\n        if full:\n            S = np.empty(X.shape)\n        for ch in range(nch):\n            ch_result = SSIM(X[..., ch], Y[..., ch], **args)\n            if gradient and full:\n                mssim[..., ch], G[..., ch], S[..., ch] = ch_result\n            elif gradient:\n                mssim[..., ch], G[..., ch] = ch_result\n            elif full:\n                mssim[..., ch], S[..., ch] = ch_result\n            else:\n                mssim[..., ch] = ch_result\n        mssim = mssim.mean()\n        if gradient and full:\n            return mssim, G, S\n        elif gradient:\n            return mssim, G\n        elif full:\n            return mssim, S\n        else:\n            return mssim\n\n    K1 = kwargs.pop('K1', 0.01)\n    K2 = kwargs.pop('K2', 0.03)\n    sigma = kwargs.pop('sigma', 1.5)\n    if K1 < 0:\n        raise ValueError(\"K1 must be positive\")\n    if K2 < 0:\n        raise ValueError(\"K2 must be positive\")\n    if sigma < 0:\n        raise ValueError(\"sigma must be positive\")\n    use_sample_covariance = kwargs.pop('use_sample_covariance', True)\n\n    if gaussian_weights:\n        # Set to give an 11-tap filter with the default sigma of 1.5 to match\n        # Wang et. al. 2004.\n        truncate = 3.5\n\n    if win_size is None:\n        if gaussian_weights:\n            # set win_size used by crop to match the filter size\n            r = int(truncate * sigma + 0.5)  # radius as in ndimage\n            win_size = 2 * r + 1\n        else:\n            win_size = 7   # backwards compatibility\n\n    if np.any((np.asarray(X.shape) - win_size) < 0):\n        raise ValueError(\n            \"win_size exceeds image extent.  If the input is a multichannel \"\n            \"(color) image, set multichannel=True.\")\n\n    if not (win_size % 2 == 1):\n        raise ValueError('Window size must be odd.')\n\n    if data_range is None:\n        assert X.dtype == Y.dtype, \\\n            \"Inputs have mismatched dtype. Setting data_range based on X.dtype.\"\n        dmin, dmax = dtype_range[X.dtype.type]\n        data_range = dmax - dmin\n\n    ndim = X.ndim\n\n    if gaussian_weights:\n        filter_func = gaussian_filter\n        filter_args = {'sigma': sigma, 'truncate': truncate}\n    else:\n        filter_func = uniform_filter\n        filter_args = {'size': win_size}\n\n    # ndimage filters need floating point data\n    X = X.astype(np.float64)\n    Y = Y.astype(np.float64)\n\n    NP = win_size ** ndim\n\n    # filter has already normalized by NP\n    if use_sample_covariance:\n        cov_norm = NP \/ (NP - 1)  # sample covariance\n    else:\n        cov_norm = 1.0  # population covariance to match Wang et. al. 2004\n\n    # compute (weighted) means\n    ux = filter_func(X, **filter_args)\n    uy = filter_func(Y, **filter_args)\n\n    # compute (weighted) variances and covariances\n    uxx = filter_func(X * X, **filter_args)\n    uyy = filter_func(Y * Y, **filter_args)\n    uxy = filter_func(X * Y, **filter_args)\n    vx = cov_norm * (uxx - ux * ux)\n    vy = cov_norm * (uyy - uy * uy)\n    vxy = cov_norm * (uxy - ux * uy)\n\n    R = data_range\n    C1 = (K1 * R) ** 2\n    C2 = (K2 * R) ** 2\n\n    A1, A2, B1, B2 = ((2 * ux * uy + C1,\n                       2 * vxy + C2,\n                       ux ** 2 + uy ** 2 + C1,\n                       vx + vy + C2))\n    D = B1 * B2\n    S = (A1 * A2) \/ D\n\n    # to avoid edge effects will ignore filter radius strip around edges\n    pad = (win_size - 1) \/\/ 2\n\n    # compute (weighted) mean of ssim\n    mssim = crop(S, pad).mean()\n\n    if gradient:\n        # The following is Eqs. 7-8 of Avanaki 2009.\n        grad = filter_func(A1 \/ D, **filter_args) * X\n        grad += filter_func(-S \/ B2, **filter_args) * Y\n        grad += filter_func((ux * (A2 - A1) - uy * (B2 - B1) * S) \/ D,\n                            **filter_args)\n        grad *= (2 \/ X.size)\n\n        if full:\n            return mssim, grad, S\n        else:\n            return mssim, grad\n    else:\n        if full:\n            return mssim, S\n        else:\n            return mssim"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_574","text":"import matplotlib\nfrom hydroDL import kPath, utils\nfrom hydroDL.app import waterQuality\nfrom hydroDL.master import basins\nfrom hydroDL.data import usgs, gageII, gridMET, ntn\nfrom hydroDL.master import slurm\nfrom hydroDL.post import axplot, figplot\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport scipy\nimport os\nimport json\n\ndataName = 'rbWN5'\nwqData = waterQuality.DataModelWQ(dataName)\nsiteNoLst = wqData.siteNoLst\nlabel = 'QFP_C'\nep = 500\nreTest = False\ncodeLst = sorted(usgs.newC)\nnSite = len(siteNoLst)\n\nhsLst = [16, 32, 64, 128, 256, 512]\ncorrMat = np.full([nSite, len(codeLst), len(hsLst)], np.nan)\nrmseMat = np.full([nSite, len(codeLst), len(hsLst)], np.nan)\n\nfor k, hs in enumerate(hsLst):\n    code = 'comb'\n    trainSet = '{}-B10'.format('comb')\n    testSet = '{}-A10'.format('comb')\n    outName = '{}-{}-{}-{}-hs{}'.format(dataName, code, label, trainSet, hs)\n    master = basins.loadMaster(outName)\n    yP, ycP = basins.testModel(\n        outName, testSet, wqData=wqData, ep=ep, reTest=reTest)\n    ind = wqData.subset[testSet]\n    info = wqData.info.iloc[ind].reset_index()\n    siteNoTemp = info['siteNo'].unique()\n    for iCode, code in enumerate(codeLst):\n        ic = wqData.varC.index(code)\n        if len(wqData.c.shape) == 3:\n            p = yP[-1, :, master['varY'].index(code)]\n            o = wqData.c[-1, ind, ic]\n        elif len(wqData.c.shape) == 2:\n            p = ycP[:, master['varYC'].index(code)]\n            o = wqData.c[ind, ic]\n        for siteNo in siteNoTemp:\n            iS = siteNoLst.index(siteNo)\n            indS = info[info['siteNo'] == siteNo].index.values\n            rmse, corr = utils.stat.calErr(p[indS], o[indS])\n            corrMat[iS, iCode, k] = corr\n            rmseMat[iS, iCode, k] = rmse\n\n\n# plot box\ndirSel = os.path.join(kPath.dirData, 'USGS', 'inventory', 'siteSel')\nwith open(os.path.join(dirSel, 'dictRB_Y30N5.json')) as f:\n    dictSite = json.load(f)\nlabLst1 = [usgs.codePdf.loc[code]['shortName'] +\n           '\\n'+code for code in codeLst]\nlabLst2 = hsLst\ndataBox = list()\nfor k, code in enumerate(codeLst):\n    siteNoCode = dictSite[code]\n    indS = [siteNoLst.index(siteNo) for siteNo in siteNoCode]\n    temp = list()\n    for i in range(len(hsLst)):\n        temp.append(corrMat[indS, k, i])\n    dataBox.append(temp)\nfig = figplot.boxPlot(dataBox, label1=labLst1, widths=0.5,\n                      label2=labLst2, figsize=(12, 4), yRange=[0, 1])\nfig.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_575","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Jun 26 14:46:56 2017\n@author: luohao\n\"\"\"\n\n\"\"\"\nCVPR2017 paper:<NAME>, <NAME>, <NAME>, et al. Re-ranking Person Re-identification with k-reciprocal Encoding[J]. 2017.\nurl:http:\/\/openaccess.thecvf.com\/content_cvpr_2017\/papers\/Zhong_Re-Ranking_Person_Re-Identification_CVPR_2017_paper.pdf\nMatlab version: https:\/\/github.com\/zhunzhong07\/person-re-ranking\n\"\"\"\n\n\"\"\"\nAPI\nprobFea: all feature vectors of the query set, shape = (image_size, feature_dim)\ngalFea: all feature vectors of the gallery set, shape = (image_size, feature_dim)\nk1,k2,lambda: parameters, the original paper is (k1=20,k2=6,lambda=0.3)\nMemorySave: set to 'True' when using MemorySave mode\nMinibatch: avaliable when 'MemorySave' is 'True'\n\"\"\"\n\nimport numpy as np\nfrom scipy.spatial.distance import cdist\nfrom scipy.stats import entropy # for KL divergence\nfrom math import log\n\ndef compute_metadata_distance_hard(q_metadatas, g_metadatas, metadata_prob_ranges):\n    q_num = q_metadatas.shape[0]\n    g_num = g_metadatas.shape[0]\n    dist = np.zeros((q_num, g_num), dtype=np.float32)\n    for iq in range(q_num):\n        for ig in range(g_num):\n            for p_begin, p_end in metadata_prob_ranges:\n                cq = np.argmax(q_metadatas[iq][p_begin:p_end])\n                cg = np.argmax(g_metadatas[ig][p_begin:p_end])\n                if cq != cg:\n                    dist[iq, ig] += 1\n                    break\n    return dist\n\ndef compute_metadata_distance_semihard(q_metadatas, g_metadatas, metadata_prob_ranges):\n    q_num = q_metadatas.shape[0]\n    g_num = g_metadatas.shape[0]\n    dist = np.zeros((q_num, g_num), dtype=np.float32)\n    for iq in range(q_num):\n        for ig in range(g_num):\n            for p_begin, p_end in metadata_prob_ranges:\n                cq = np.argmax(q_metadatas[iq][p_begin:p_end])\n                cg = np.argmax(g_metadatas[ig][p_begin:p_end])\n                if cq != cg and cq != (p_end - p_begin - 1) and cg != (p_end - p_begin - 1): # the last class is \"other\"\n                    dist[iq, ig] += 1\n                    break\n    return dist\n\ndef compute_metadata_distance_easy(q_metadatas, g_metadatas, metadata_prob_ranges):\n    q_num = q_metadatas.shape[0]\n    g_num = g_metadatas.shape[0]\n    dist = np.ones((q_num, g_num), dtype=np.float32)\n    for iq in range(q_num):\n        for ig in range(g_num):\n            for p_begin, p_end in metadata_prob_ranges:\n                cq = np.argmax(q_metadatas[iq][p_begin:p_end])\n                cg = np.argmax(g_metadatas[ig][p_begin:p_end])\n                if cq == cg:\n                    dist[iq, ig] = 0\n                    break\n    return dist\n\ndef compute_KL_divergence(q_metadatas, g_metadatas, metadata_prob_ranges = [(0,6), (6,18), (18,26)]):\n    q_num = q_metadatas.shape[0]\n    g_num = g_metadatas.shape[0]\n    m_num = len(metadata_prob_ranges)\n    KL_div = np.zeros((q_num, g_num, m_num), dtype=np.float32)\n    epsilon = 1e-4\n    for iq in range(q_num):\n        for ig in range(g_num):\n            for im, (p_begin, p_end) in enumerate(metadata_prob_ranges):\n                KL_div[iq, ig, im] = entropy(q_metadatas[iq][p_begin:p_end]+epsilon, g_metadatas[ig][p_begin:p_end]+epsilon)\n    return KL_div\n\ndef compute_pred(metadatas, metadata_prob_ranges):\n    all_num = metadatas.shape[0]\n    m_num = len(metadata_prob_ranges)\n    pred = np.zeros((all_num, m_num), dtype=np.int32)\n    for im, (p_begin, p_end) in enumerate(metadata_prob_ranges):\n        pred[:,im] = np.argmax(metadatas[:,p_begin:p_end], axis=1)\n    return pred\n\n\ndef compute_confusion_weight_old(q_pred, g_pred, confusion_mat):\n    q_num = q_pred.shape[0]\n    g_num = g_pred.shape[0]\n    c_num = confusion_mat.shape[0]\n\n    confusion_mat = confusion_mat + 1e-4*np.ones((c_num, c_num), dtype=np.float32)\n\n    c_weight = np.transpose(confusion_mat)*np.diag(confusion_mat)\n    c_weight += np.transpose(c_weight)\n    c_sum = np.sum(confusion_mat, axis=0).reshape(1,-1)\n    c_sum = np.matmul(np.transpose(c_sum), c_sum)\n    c_weight = c_weight * np.reciprocal(c_sum)\n    #c_weight[range(c_num),range(c_num)]\/=2\n    np.fill_diagonal(c_weight, 1) # no penalty for the same class\n    #print('c_weight = ')\n    #print(c_weight)\n    \n    confusion_weight = np.ones((q_num, g_num), dtype=np.float32)\n    for iq in range(q_num):\n        for ig in range(g_num):\n            confusion_weight[iq, ig] = c_weight[q_pred[iq], g_pred[ig]]\n    return confusion_weight\n\n    \ndef compute_confusion_weight(q_pred, g_pred, confusion_mat):\n    q_num = q_pred.shape[0]\n    g_num = g_pred.shape[0]\n    c_num = confusion_mat.shape[0]\n\n    #print('confusion_mat = ')\n    #print(confusion_mat)\n    confusion_mat = confusion_mat + 1e-4*np.ones((c_num, c_num), dtype=np.float32)\n    c_sum = np.sum(confusion_mat, axis=0)\n    confusion_mat_norm = confusion_mat * np.reciprocal(c_sum)\n    #print('confusion_mat_norm = ')\n    #print(confusion_mat_norm)\n    c_weight = np.matmul(np.transpose(confusion_mat_norm), confusion_mat_norm)\n    np.fill_diagonal(c_weight, 1) # no penalty for the same class\n    #print('c_weight = ')\n    #print(c_weight)\n    \n    confusion_weight = np.ones((q_num, g_num), dtype=np.float32)\n    for iq in range(q_num):\n        for ig in range(g_num):\n            confusion_weight[iq, ig] = c_weight[q_pred[iq], g_pred[ig]]\n    return confusion_weight\n    \n\ndef cluster_gallery_soft(gf, g_metadatas, metadata_prob_ranges = [(0,6), (6,18), (18,26)], k=20, learning_rate=0.5, num_iter=20, MemorySave=False, Minibatch=2000):\n    '''\n    return new gallery feature gf_new\n    '''\n    gf = gf.copy() # make a copy since it will be updated in each iteration\n    g_num = gf.shape[0]\n    # meta data penalty\n    '''dist_meta = np.zeros((g_num, g_num), dtype=np.float16)\n    epsilon = 1e-4\n    for i in range(g_num):\n        metaI = g_metadatas[i]\n        for j in range(g_num):\n            metaJ = g_metadatas[j]\n            for prob_range_begin, prob_ranges_end in metadata_prob_ranges:\n                if entropy (metaI[prob_range_begin:prob_ranges_end] + epsilon, metaJ[prob_range_begin:prob_ranges_end] + epsilon) > 0.5:\n                    dist_meta[i][j] = 1\n                    break'''\n    dist_meta = compute_metadata_distance_hard(g_metadatas, g_metadatas, metadata_prob_ranges)\n    for iter in range(num_iter):\n        #print('iter: %d' % iter)\n        #print('computing original distance')\n        if MemorySave:\n            g_g_dist = np.zeros(shape=[g_num, g_num], dtype=np.float16)\n            i = 0\n            while True:\n                it = i + Minibatch\n                if it < np.shape(gf)[0]:\n                    g_g_dist[i:it, ] = np.power(cdist(gf[i:it, ], gf), 2).astype(np.float16)\n                else:\n                    g_g_dist[i:, :] = np.power(cdist(gf[i:, ], gf), 2).astype(np.float16)\n                    break\n                i = it\n        else:\n            g_g_dist = cdist(gf, gf).astype(np.float16)\n            g_g_dist = np.power(g_g_dist, 2).astype(np.float16)\n        dist_min = np.min(g_g_dist[np.triu_indices(g_num,1)])\n        dist_max = np.max(g_g_dist[np.triu_indices(g_num,1)])\n        #print('dist_min = %f, dist_max = %f' % (dist_min, dist_max))\n        #g_g_dist = np.transpose(g_g_dist \/ np.max(g_g_dist, axis=0))\n        # apply meta data\n        g_g_dist += np.transpose(dist_meta * np.max(g_g_dist, axis=1))\n        initial_rank = np.argsort(g_g_dist).astype(np.int32)\n        # apply mean field\n        gf_new = gf.copy()\n        sigma = dist_min \/ 2 + 1\n        for i in range(g_num):\n            k_neigh_index = initial_rank[i, :k + 1]\n            sigma = np.min(g_g_dist[i, k_neigh_index[1:]]) + 1\n            weight = np.exp(-g_g_dist[i, k_neigh_index] \/ sigma)\n            weight \/= np.sum(weight)\n            if i % 100 == 0 and False:\n                print(i)\n                print(k_neigh_index)\n                print(g_g_dist[i, k_neigh_index])\n                print(weight)\n            gf_new[i] = np.dot(np.transpose(gf[k_neigh_index]), weight)\n        gf = gf * (1 - learning_rate) +  gf_new * (learning_rate)\n    return gf\n\n\ndef re_ranking_metadata_soft_v3(original_dist, metadata_dist, query_num, all_num, r_metadata, k1, k2, lambda_value):\n    '''\n    input:\n        original_dist: pre-compute distmat\n        metadata_dist: metadata distance\n        r_metadata: weight for metadata distance\n    return:\n        final_dist\n    '''\n    \n    # The following naming, e.g. gallery_num, is different from outer scope.\n    # Don't care about it.\n    gallery_num = all_num\n    original_dist = np.transpose(original_dist \/ np.max(original_dist, axis=0))\n    ### additional scaling\n    scaling = False\n    if scaling:\n        tmp_rank = np.argsort(original_dist).astype(np.int32)\n        min_dist = original_dist[range(all_num), tmp_rank[:,1]]\n        metadata_dist = np.transpose(metadata_dist * min_dist)\n        #print('min_dist = ')\n        #print(min_dist)\n    ###\n    original_dist += r_metadata * metadata_dist\n\n    \n    print('starting re_ranking')\n    initial_rank = np.argsort(original_dist).astype(np.int32)\n    V = np.zeros_like(original_dist).astype(np.float16)\n    for i in range(all_num):\n        # k-reciprocal neighbors\n        forward_k_neigh_index = initial_rank[i, :k1 + 1]\n        backward_k_neigh_index = initial_rank[forward_k_neigh_index, :k1 + 1]\n        fi = np.where(backward_k_neigh_index == i)[0]\n        k_reciprocal_index = forward_k_neigh_index[fi]\n        k_reciprocal_expansion_index = k_reciprocal_index\n        for j in range(len(k_reciprocal_index)):\n            candidate = k_reciprocal_index[j]\n            candidate_forward_k_neigh_index = initial_rank[candidate, :int(np.around(k1 \/ 2)) + 1]\n            candidate_backward_k_neigh_index = initial_rank[candidate_forward_k_neigh_index,\n                                               :int(np.around(k1 \/ 2)) + 1]\n            fi_candidate = np.where(candidate_backward_k_neigh_index == candidate)[0]\n            candidate_k_reciprocal_index = candidate_forward_k_neigh_index[fi_candidate]\n            if len(np.intersect1d(candidate_k_reciprocal_index, k_reciprocal_index)) > 2 \/ 3 * len(\n                    candidate_k_reciprocal_index):\n                k_reciprocal_expansion_index = np.append(k_reciprocal_expansion_index, candidate_k_reciprocal_index)\n\n        k_reciprocal_expansion_index = np.unique(k_reciprocal_expansion_index)\n        weight = np.exp(-original_dist[i, k_reciprocal_expansion_index])\n        V[i, k_reciprocal_expansion_index] = weight \/ np.sum(weight)\n    original_dist = original_dist[:query_num, ]\n    if k2 != 1:\n        V_qe = np.zeros_like(V, dtype=np.float16)\n        for i in range(all_num):\n            V_qe[i, :] = np.mean(V[initial_rank[i, :k2], :], axis=0)\n        V = V_qe\n        del V_qe\n    del initial_rank\n    invIndex = []\n    for i in range(gallery_num):\n        invIndex.append(np.where(V[:, i] != 0)[0])\n\n    jaccard_dist = np.zeros_like(original_dist, dtype=np.float16)\n\n    for i in range(query_num):\n        temp_min = np.zeros(shape=[1, gallery_num], dtype=np.float16)\n        indNonZero = np.where(V[i, :] != 0)[0]\n        indImages = []\n        indImages = [invIndex[ind] for ind in indNonZero]\n        for j in range(len(indNonZero)):\n            temp_min[0, indImages[j]] = temp_min[0, indImages[j]] + np.minimum(V[i, indNonZero[j]], V[indImages[j], indNonZero[j]])\n        jaccard_dist[i] = 1 - temp_min \/ (2 - temp_min)\n\n    final_dist = jaccard_dist * (1 - lambda_value) + original_dist * lambda_value\n    del original_dist\n    del V\n    del jaccard_dist\n    final_dist = final_dist[:query_num, query_num:]\n\n    # np.save('final_dist.npy', final_dist)\n\n    return final_dist\n\n\n\n\ndef re_ranking_metadata_soft_v2(qf, gf, q_metadatas, g_metadatas, confusion_mats, metadata_prob_ranges, k1=4, k2=4, lambda_value=0.5, MemorySave=False, Minibatch=2000):\n\n    m_num = len(metadata_prob_ranges)\n    for p_begin, p_end in metadata_prob_ranges:\n        assert (p_begin, p_end) in confusion_mats\n\n    query_num = qf.shape[0]\n    all_num = query_num + gf.shape[0]\n    feat = np.append(qf, gf, axis=0)\n    all_metadatas = np.append(q_metadatas, g_metadatas, axis=0)\n    ###feat = np.concatenate((feat, all_metadatas*20), axis=1)\n    # feat = np.append(probFea, galFea)\n    # feat = np.vstack((probFea, galFea))\n    feat = feat.astype(np.float16)\n    print('computing original distance')\n    if MemorySave:\n        original_dist = np.zeros(shape=[all_num, all_num], dtype=np.float16)\n        i = 0\n        while True:\n            it = i + Minibatch\n            if it < np.shape(feat)[0]:\n                original_dist[i:it, ] = np.power(cdist(feat[i:it, ], feat), 2).astype(np.float16)\n            else:\n                original_dist[i:, :] = np.power(cdist(feat[i:, ], feat), 2).astype(np.float16)\n                break\n            i = it\n    else:\n        original_dist = cdist(feat, feat).astype(np.float16)\n        original_dist = np.power(original_dist, 2).astype(np.float16)\n    del feat\n    gallery_num = original_dist.shape[0]\n    original_dist = np.transpose(original_dist \/ np.max(original_dist, axis=0))\n    V = np.zeros_like(original_dist).astype(np.float16)\n\n    # apply meta data\n    print('computing KL divergence')\n    \n    KL_div = compute_KL_divergence(all_metadatas, all_metadatas, metadata_prob_ranges)\n    KL_div_U = compute_KL_divergence(all_metadatas, np.ones(all_metadatas.shape, dtype=np.float32), metadata_prob_ranges)\n    conf_pred = np.zeros((all_num, all_num, m_num), dtype=np.float32)\n    for im, (p_begin, p_end) in enumerate(metadata_prob_ranges):\n        conf_pred[:,:,im] = KL_div_U[:,:,im] * np.transpose(KL_div_U[:,:,im]) \/ (np.log(p_end - p_begin)*np.log(p_end - p_begin))\n    pred = compute_pred(all_metadatas, metadata_prob_ranges)\n    confusion_dist = np.zeros((all_num, all_num, m_num), dtype=np.float32)\n    for im, (p_begin, p_end) in enumerate(metadata_prob_ranges):\n        confusion_weight = compute_confusion_weight(pred[:,im], pred[:,im], confusion_mats[(p_begin, p_end)])\n        confusion_dist[:,:,im] = -np.log(confusion_weight + 1e-4) \/ np.log(p_end-p_begin)\n\n    pred_weight = conf_pred * confusion_dist# * KL_div\n    pred_weight = np.sum(pred_weight, axis=2)\n    #print('confusion_dist = ')\n    #print(confusion_dist)\n\n    tmp_rank = np.argsort(original_dist).astype(np.int32)\n    min_dist = original_dist[range(all_num), tmp_rank[:,1]]\n    #print('min_dist = ')\n    #print(min_dist)\n    pred_dist = np.transpose(pred_weight * min_dist)\n    #print('pred_dist = ')\n    #print(pred_dist)\n\n    r_KL = 10#0.5#20.0\n    #print('original_dist = ')\n    #print(original_dist)\n    #original_dist_no_meta = original_dist.copy()\n    original_dist += pred_dist*r_KL\n    #original_dist = np.clip(original_dist, 0, 1) # not meaningful\n    #print('original_dist = ')\n    #print(original_dist)\n\n    initial_rank = np.argsort(original_dist).astype(np.int32)\n    #original_dist_no_query = original_dist.copy()\n    #original_dist_no_query[:,:query_num] = 1000.0\n    #initial_rank = np.argsort(original_dist_no_query).astype(np.int32)\n\n    print('starting re_ranking')\n    for i in range(all_num):\n        # k-reciprocal neighbors\n        forward_k_neigh_index = initial_rank[i, :k1 + 1]\n        backward_k_neigh_index = initial_rank[forward_k_neigh_index, :k1 + 1]\n        fi = np.where(backward_k_neigh_index == i)[0]\n        k_reciprocal_index = forward_k_neigh_index[fi]\n        k_reciprocal_expansion_index = k_reciprocal_index\n        for j in range(len(k_reciprocal_index)):\n            candidate = k_reciprocal_index[j]\n            candidate_forward_k_neigh_index = initial_rank[candidate, :int(np.around(k1 \/ 2)) + 1]\n            candidate_backward_k_neigh_index = initial_rank[candidate_forward_k_neigh_index,\n                                               :int(np.around(k1 \/ 2)) + 1]\n            fi_candidate = np.where(candidate_backward_k_neigh_index == candidate)[0]\n            candidate_k_reciprocal_index = candidate_forward_k_neigh_index[fi_candidate]\n            if len(np.intersect1d(candidate_k_reciprocal_index, k_reciprocal_index)) > 2 \/ 3 * len(\n                    candidate_k_reciprocal_index):\n                k_reciprocal_expansion_index = np.append(k_reciprocal_expansion_index, candidate_k_reciprocal_index)\n\n        k_reciprocal_expansion_index = np.unique(k_reciprocal_expansion_index)\n        weight = np.exp(-original_dist[i, k_reciprocal_expansion_index])\n        V[i, k_reciprocal_expansion_index] = weight \/ np.sum(weight)\n    original_dist = original_dist[:query_num, ]\n    if k2 != 1:\n        V_qe = np.zeros_like(V, dtype=np.float16)\n        for i in range(all_num):\n            V_qe[i, :] = np.mean(V[initial_rank[i, :k2], :], axis=0)\n        V = V_qe\n        del V_qe\n    del initial_rank\n    invIndex = []\n    for i in range(gallery_num):\n        invIndex.append(np.where(V[:, i] != 0)[0])\n\n    jaccard_dist = np.zeros_like(original_dist, dtype=np.float16)\n\n    for i in range(query_num):\n        temp_min = np.zeros(shape=[1, gallery_num], dtype=np.float16)\n        indNonZero = np.where(V[i, :] != 0)[0]\n        indImages = []\n        indImages = [invIndex[ind] for ind in indNonZero]\n        for j in range(len(indNonZero)):\n            temp_min[0, indImages[j]] = temp_min[0, indImages[j]] + np.minimum(V[i, indNonZero[j]], V[indImages[j], indNonZero[j]])\n        jaccard_dist[i] = 1 - temp_min \/ (2 - temp_min)\n\n\n\n    final_dist = jaccard_dist * (1 - lambda_value) + original_dist * lambda_value\n\n    #original_dist_easy_meta = original_dist_no_meta + 100*compute_metadata_distance_easy(all_metadatas, all_metadatas, metadata_prob_ranges)\n    #original_dist_easy_meta = original_dist_easy_meta[:query_num, ]\n    #final_dist = jaccard_dist * (1 - lambda_value) + original_dist_easy_meta * lambda_value\n\n    #original_dist_no_meta = original_dist_no_meta[:query_num, ]\n    #final_dist = jaccard_dist * (1 - lambda_value) + original_dist_no_meta * lambda_value\n\n\n    del original_dist\n    del V\n    del jaccard_dist\n    final_dist = final_dist[:query_num, query_num:]\n\n    # np.save('final_dist.npy', final_dist)\n\n    return final_dist\n\n\ndef re_ranking_metadata_soft(qf, gf, q_metadatas, g_metadatas, metadata_prob_ranges, k1=4, k2=4, lambda_value=0.5, MemorySave=False, Minibatch=2000):\n    query_num = qf.shape[0]\n    all_num = query_num + gf.shape[0]\n    feat = np.append(qf, gf, axis=0)\n    #meta = np.append(q_metadatas, g_metadatas, axis=0)\n    ###feat = np.concatenate((feat, meta*20), axis=1)\n    # feat = np.append(probFea, galFea)\n    # feat = np.vstack((probFea, galFea))\n    feat = feat.astype(np.float16)\n    print('computing original distance')\n    if MemorySave:\n        original_dist = np.zeros(shape=[all_num, all_num], dtype=np.float16)\n        i = 0\n        while True:\n            it = i + Minibatch\n            if it < np.shape(feat)[0]:\n                original_dist[i:it, ] = np.power(cdist(feat[i:it, ], feat), 2).astype(np.float16)\n            else:\n                original_dist[i:, :] = np.power(cdist(feat[i:, ], feat), 2).astype(np.float16)\n                break\n            i = it\n    else:\n        original_dist = cdist(feat, feat).astype(np.float16)\n        original_dist = np.power(original_dist, 2).astype(np.float16)\n    del feat\n    gallery_num = original_dist.shape[0]\n    original_dist = np.transpose(original_dist \/ np.max(original_dist, axis=0))\n    V = np.zeros_like(original_dist).astype(np.float16)\n    # apply meta data\n    print('computing KL divergence')\n    KL_div = np.zeros((all_num, all_num), dtype=np.float16)\n    tmp_rank = np.argsort(original_dist).astype(np.int32)\n    for i in range(all_num):\n        if i < query_num:\n            metaI = q_metadatas[i]\n        else:\n            metaI = g_metadatas[i - query_num]\n        d_min = original_dist[i][tmp_rank[i,1]]\n        #print('d_min: %f' % d_min)\n        for j in range(all_num):\n            if j < query_num:\n                metaJ = q_metadatas[j]\n            else:\n                metaJ = g_metadatas[j - query_num]\n            for prob_range_begin, prob_range_end in metadata_prob_ranges:\n                hard_threshold = True\n                epsilon = 1e-4\n                pk = metaI[prob_range_begin:prob_range_end] + epsilon\n                qk = metaJ[prob_range_begin:prob_range_end] + epsilon\n                if hard_threshold:\n                    if np.argmax(pk) != np.argmax(qk):\n                        KL_div[i][j] += 100\n                        break\n                    else:\n                        continue\n                #s = entropy(pk, qk)*0.5 + entropy(qk, pk)*0.5\n                s = min(entropy(pk, qk), entropy(qk, pk))\n                #print('%d: %f' % (num_classes, s))\n                #KL_div[i][j] += max(s\/log(num_classes) - 1, 0) * d_min\n                KL_div[i][j] += s * d_min\n    print('KL_div min: %f' % np.min(KL_div[np.triu_indices(all_num,1)]))\n    print('KL_div max: %f' % np.max(KL_div[np.triu_indices(all_num,1)]))\n    r_KL = 1.0\n    original_dist = np.clip(original_dist+KL_div*r_KL, 0, 1)\n                    \n\n\n    initial_rank = np.argsort(original_dist).astype(np.int32)\n    #original_dist_no_query = original_dist.copy()\n    #original_dist_no_query[:,:query_num] = 1000.0\n    #initial_rank = np.argsort(original_dist_no_query).astype(np.int32)\n\n    print('starting re_ranking')\n    for i in range(all_num):\n        # k-reciprocal neighbors\n        forward_k_neigh_index = initial_rank[i, :k1 + 1]\n        backward_k_neigh_index = initial_rank[forward_k_neigh_index, :k1 + 1]\n        fi = np.where(backward_k_neigh_index == i)[0]\n        k_reciprocal_index = forward_k_neigh_index[fi]\n        k_reciprocal_expansion_index = k_reciprocal_index\n        for j in range(len(k_reciprocal_index)):\n            candidate = k_reciprocal_index[j]\n            candidate_forward_k_neigh_index = initial_rank[candidate, :int(np.around(k1 \/ 2)) + 1]\n            candidate_backward_k_neigh_index = initial_rank[candidate_forward_k_neigh_index,\n                                               :int(np.around(k1 \/ 2)) + 1]\n            fi_candidate = np.where(candidate_backward_k_neigh_index == candidate)[0]\n            candidate_k_reciprocal_index = candidate_forward_k_neigh_index[fi_candidate]\n            if len(np.intersect1d(candidate_k_reciprocal_index, k_reciprocal_index)) > 2 \/ 3 * len(\n                    candidate_k_reciprocal_index):\n                k_reciprocal_expansion_index = np.append(k_reciprocal_expansion_index, candidate_k_reciprocal_index)\n\n        k_reciprocal_expansion_index = np.unique(k_reciprocal_expansion_index)\n        weight = np.exp(-original_dist[i, k_reciprocal_expansion_index])\n        V[i, k_reciprocal_expansion_index] = weight \/ np.sum(weight)\n    original_dist = original_dist[:query_num, ]\n    if k2 != 1:\n        V_qe = np.zeros_like(V, dtype=np.float16)\n        for i in range(all_num):\n            V_qe[i, :] = np.mean(V[initial_rank[i, :k2], :], axis=0)\n        V = V_qe\n        del V_qe\n    del initial_rank\n    invIndex = []\n    for i in range(gallery_num):\n        invIndex.append(np.where(V[:, i] != 0)[0])\n\n    jaccard_dist = np.zeros_like(original_dist, dtype=np.float16)\n\n    for i in range(query_num):\n        temp_min = np.zeros(shape=[1, gallery_num], dtype=np.float16)\n        indNonZero = np.where(V[i, :] != 0)[0]\n        indImages = []\n        indImages = [invIndex[ind] for ind in indNonZero]\n        for j in range(len(indNonZero)):\n            temp_min[0, indImages[j]] = temp_min[0, indImages[j]] + np.minimum(V[i, indNonZero[j]], V[indImages[j], indNonZero[j]])\n        jaccard_dist[i] = 1 - temp_min \/ (2 - temp_min)\n\n    final_dist = jaccard_dist * (1 - lambda_value) + original_dist * lambda_value\n    del original_dist\n    del V\n    del jaccard_dist\n    final_dist = final_dist[:query_num, query_num:]\n\n    # np.save('final_dist.npy', final_dist)\n\n    return final_dist\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_566","text":"import matplotlib as mpl\nimport numpy as np\nimport os\nimport matplotlib.pyplot as plt\nimport tkinter \n\nimport datetime\nimport struct\nimport ftplib\nimport glob\nimport tempfile\nimport pymongo\nimport requests\nimport sys\n\nimport scipy.signal as signal\nimport scipy.io.wavfile\nimport pywt\n\nfrom unophysics import ladc, wavefuncs\nfrom pathlib import Path\nfrom scipy.io import savemat\nfrom sshtunnel import SSHTunnelForwarder\n\nroot = tkinter.Tk()\nroot.title('LADC-GEMM Interactive')\nroot.geometry('540x260')\nroot.grid_columnconfigure(1, minsize=135)\n\n# SET UP INFORMATION PAGE FOR EACH LOCATION\nlocalcalls = []\ndef info_location_change():\n    currentlocation.set(ladc.Stuff.brydes_calls[info_location.get()]['Location'])\n    locationlabel.grid(column=1, row=0, sticky=tkinter.N+tkinter.W)\n\n    global localcalls\n    localcalls = ladc.Stuff.brydes_calls[info_location.get()]['Call(s) recorded']\n    numcallsstring = ', '.join(localcalls)\n    current_numcalls.set(numcallsstring)\n    numcalls_label.grid(column=1, row=0, sticky=tkinter.N+tkinter.W, pady=5)\n    callmenu.delete(0, tkinter.END)\n    for x in localcalls:\n        callmenu.insert(tkinter.END, x)\n    current_date.set(ladc.Stuff.brydes_calls[info_location.get()]['Date'])\n    date_label.grid(column=1, row=0, sticky=tkinter.N+tkinter.W, pady=5)\n    current_minmax.set('')\n\n# LOCATION BUTTONS\ninfobutton_box = tkinter.LabelFrame(root)\ninfo_location = tkinter.StringVar()\ninfo_location.set('ETP')\n\ncurrentlocation=tkinter.StringVar()\nlocationlabel = tkinter.Label(root, textvariable=currentlocation, font=('bold', 13))\n\netp = tkinter.Radiobutton(infobutton_box, text='Eastern Tropical Pacific', variable=info_location, value='ETP', command=info_location_change)\nscarib = tkinter.Radiobutton(infobutton_box, text='Southern Caribbean', variable=info_location, value='SCaribbean', command=info_location_change)\nnwpac = tkinter.Radiobutton(infobutton_box, text='Northwest Pacific', variable=info_location, value='NWPacific', command=info_location_change)\ngoc = tkinter.Radiobutton(infobutton_box, text='Gulf of California', variable=info_location, value='GoC', command=info_location_change)\ncabo = tkinter.Radiobutton(infobutton_box, text='Cabo Frio, Brazil', variable=info_location, value='CaboFrio', command=info_location_change)\ngom = tkinter.Radiobutton(infobutton_box, text='Gulf of Mexico', variable=info_location, value='GoM', command=info_location_change)\n\n# REGIONAL CALL INFORMATION WIDGETS\nnumcallsbox = tkinter.LabelFrame(root)\nnumcalls = tkinter.Label(numcallsbox, text='Call(s) recorded: ')\ncurrent_numcalls = tkinter.StringVar()\nnumcalls_label = tkinter.Label(numcallsbox, textvariable=current_numcalls, wraplength=200, justify='left')\n\ndatebox = tkinter.LabelFrame(root)\ndate = tkinter.Label(datebox, text='Date: ')\ncurrent_date = tkinter.StringVar()\ndate_label = tkinter.Label(datebox, textvariable=current_date, wraplength=200, justify='left')\n\n# FREQUENCY INFORMATION WIDGETS\nfreqbox = tkinter.LabelFrame(root)\nfreq = tkinter.Label(freqbox, text='Frequency information: ')\n\ndef change_facts(event):\n    selecttuple = event.widget.curselection()\n    selectindex = selecttuple[0]\n    callname = localcalls[selectindex]\n    minmaxrange = ladc.Stuff.frequency_info[info_location.get()][callname]\n    minbookmark = minmaxrange[0]\n    maxbookmark = minmaxrange[1]\n    minmax_string = f'{minbookmark} - {maxbookmark} Hz'\n    current_minmax.set(minmax_string) \n\ncallbox = tkinter.Frame(freqbox)\ncall = tkinter.Label(callbox, text='Call: ')\ncallmenu = tkinter.Listbox(callbox, selectmode='SINGLE', height=6) \ncallmenu.bind('<<ListboxSelect>>', change_facts)\n\nminmaxbox = tkinter.Frame(freqbox)\nminmax = tkinter.Label(minmaxbox, text='Min\/max frequencies: ')\ncurrent_minmax = tkinter.StringVar()\nminmax_label = tkinter.Label(minmaxbox, textvariable=current_minmax) \n\n# MENU WIDGET CHANGES\ndef datapage():\n    reset_inputs()\n\n    root.grid_columnconfigure(index=1, minsize=135)\n    root.grid_rowconfigure(index=0, minsize=10)\n    root.grid_rowconfigure(index=2, minsize=10)\n    \n    widgetlist = [minmax_label, callbox, minmaxbox, freqbox, freq, call, callmenu, minmax, infobutton_box, etp, scarib, nwpac, goc, cabo, gom, datebox, date, numcallsbox, numcalls, locationlabel, numcalls_label, date_label]\n    for widget in widgetlist:\n        widget.grid_remove()\n\n    onefilename_box.grid(column=1, row=0, sticky=tkinter.W+tkinter.E, padx=10, pady=10)\n    enter_onefile.grid(column=1, row=0, pady=5, padx=3)\n\n    skipval_box.grid(column=2, row=0, sticky=tkinter.W+tkinter.E, padx=10, pady=10)\n    enter_skipval.grid(column=2, row=0, pady=5, padx=3)\n\n    cmap_box.grid(column=1, row=1, padx=10, pady=10, sticky=tkinter.E+tkinter.W)\n    colorschemes.grid(column=1, row=1, sticky=tkinter.E+tkinter.W)\n\n    fileamount_box.grid(column=2, row=1, padx=10, pady=10, sticky=tkinter.E+tkinter.W)\n    fileamounts.grid(column=2, row=1, sticky=tkinter.E+tkinter.W)\n\n    reset.grid(column=1, row=2, sticky=tkinter.E+tkinter.W, pady=10, padx=10)\n\n    show_button.grid(column=2, row=2, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n\n    databutton_box.grid(column=0, row=0, rowspan=4, padx=10, pady=10, sticky=tkinter.N+tkinter.S)\n    spec_plot.grid(row=0, sticky=tkinter.W, pady=15, padx=5)\n    amp_plot.grid(row=1, sticky=tkinter.W, pady=15, padx=5)\n    search_interesting.grid(row=2, sticky=tkinter.W, pady=15, padx=5)\n\ndef infopage():\n    info_location.set(None)\n\n    root.grid_columnconfigure(index=1, minsize=330)\n    root.grid_rowconfigure(index=0, minsize=30)\n    root.grid_rowconfigure(index=2, minsize=20)\n\n    widgetlist = [onefilename_box, enter_onefile, skipval_box, enter_skipval, cmap_box, colorschemes, fileamount_box, fileamounts, reset, show_button, databutton_box, spec_plot, amp_plot, search_interesting]\n    for widget in widgetlist:\n        widget.grid_remove()\n\n    infobutton_box.grid(column=0, row=0, padx=10, pady=10, rowspan=6, sticky=tkinter.N+tkinter.S)\n\n    etp.grid(column=0, row=0, sticky=tkinter.W, padx=10, pady=5)\n    scarib.grid(column=0, row=1, sticky=tkinter.W, padx=10, pady=5)\n    nwpac.grid(column=0, row=2, sticky=tkinter.W, padx=10, pady=5)\n    goc.grid(column=0, row=3, sticky=tkinter.W, padx=10, pady=5)\n    cabo.grid(column=0, row=4, sticky=tkinter.W, padx=10, pady=5)\n    gom.grid(column=0, row=5, sticky=tkinter.W, padx=10, pady=5)\n\n    numcallsbox.grid(column=1, row=1, columnspan=2, sticky=tkinter.W+tkinter.E+tkinter.N+tkinter.S)\n    numcalls.grid(column=0, row=0, sticky=tkinter.W+tkinter.N, padx=10, pady=5)\n    datebox.grid(column=1, row=2, columnspan=2, sticky=tkinter.W+tkinter.E+tkinter.N+tkinter.S)\n    date.grid(column=0, row=0, sticky=tkinter.W+tkinter.N, padx=10, pady=5)\n\n    freqbox.grid(column=1, row=3, columnspan=2, sticky=tkinter.W+tkinter.E+tkinter.N+tkinter.S)\n    freq.grid(column=0, row=0)\n\n    callbox.grid(column=0, row=1)\n    call.grid(column=0, row=0)\n    callmenu.grid(column=1, row=0)\n\n    minmaxbox.grid(column=1, row=1)\n    minmax.grid(column=0, row=0)\n    minmax_label.grid(column=1, row=0)\n    callmenu.delete(0, tkinter.END)\n    current_minmax.set('')\n\n# CREATING MENU\nmenu = tkinter.Menu(root)\nroot.config(menu=menu)\ndatamenu = tkinter.Menu(menu)\nmenu.add_cascade(label='Data', menu=datamenu)\ndatamenu.add_command(label='Data', command=datapage)\ninfomenu = tkinter.Menu(menu)\nmenu.add_cascade(label='Information', menu=infomenu)\ninfomenu.add_command(label='Information', command=infopage)\n\n# TYPE IN FILE NAME\nonefilename_box = tkinter.LabelFrame(root, text='Filename')\nonefilename_box.grid(column=1, row=0, sticky=tkinter.W+tkinter.E, padx=10, pady=10)\nonefilename = tkinter.StringVar()\nonefilename.set('')\nenter_onefile = tkinter.Entry(onefilename_box, textvariable=onefilename, width=16)\nenter_onefile.grid(column=1, row=0, pady=5, padx=3)\n\n# TYPE IN SKIP VALUE\ndef skip_error_check(number):\n    valid = False\n    if number.isdigit():\n        if (int(number) <= 10000) and (int(number) >= 0):\n            valid = True\n    elif number == '':\n        valid = True\n    return valid\nvalidate_skip = (root.register(skip_error_check), '%P')\nskipval_box = tkinter.LabelFrame(root, text='Skip Value')\nskipval_box.grid(column=2, row=0, sticky=tkinter.W+tkinter.E, padx=10, pady=10)\nskipval = tkinter.StringVar()\nskipval.set(0)\nenter_skipval = tkinter.Spinbox(skipval_box, from_=0, to=10000, textvariable=skipval, width=16, validate='all', validatecommand=validate_skip)\nenter_skipval.grid(column=2, row=0, pady=5, padx=3)\n\n# OPTION MENUS\ndef show_options():\n    global cmap_box, colorschemes, fileamount_box, fileamounts, fileamount_str, enter_onefile\n    if current_page.get() == 'spec':\n        enter_onefile.configure(state='normal')\n        fileamounts.configure(state='disabled')\n        colorschemes.configure(state='normal')\n        colorscheme_str.set(cmaps[2])\n        skipval.set(0)\n        fileamount_str.set(number_of_files[0])\n        onefilename.set('')\n    else: \n        colorschemes.configure(state='disabled')\n    \n    if current_page.get() == 'amp':\n        enter_onefile.configure(state='normal')\n        fileamounts.configure(state='disabled')\n        colorschemes.configure(state='disabled')\n        skipval.set(0)\n        fileamount_str.set(number_of_files[0])\n        onefilename.set('')\n    \n    if current_page.get() == 'interesting':\n        enter_onefile.configure(state='disabled')\n        fileamounts.configure(state='normal')\n        colorschemes.configure(state='disabled')\n        skipval.set(0)\n        fileamount_str.set(number_of_files[0])\n    else:\n        fileamounts.configure(state='disabled')\n\n    if current_page.get() != 'spec' and current_page.get() != 'amp' and current_page.get() != 'interesting':\n        enter_onefile.configure(state='disabled')\n        fileamounts.configure(state='disabled')\n        colorschemes.configure(state='disabled')\n        enter_skipval.configure(state='disabled')\n        reset.configure(state='disabled')\n        show_button.configure(state='disabled')\n\ncmaps = ['hsv', 'Greys', 'nipy_spectral']\ncmap_box = tkinter.LabelFrame(root, text='Color Scheme')\ncolorscheme_str = tkinter.StringVar()\ncolorscheme_str.set(cmaps[2])\ncolorschemes = tkinter.OptionMenu(cmap_box, colorscheme_str, *cmaps)\ncmap_box.grid(column=1, row=1, padx=10, pady=10, sticky=tkinter.E+tkinter.W)\ncolorschemes.grid(column=1, row=1, sticky=tkinter.E+tkinter.W)\n\nnumber_of_files = ['4','9','16']\nfileamount_box = tkinter.LabelFrame(root, text='Number of Files')\nfileamount_str = tkinter.StringVar()\nfileamount_str.set(number_of_files[0])\nfileamounts = tkinter.OptionMenu(fileamount_box, fileamount_str, *number_of_files)\nfileamount_box.grid(column=2, row=1, padx=10, pady=10, sticky=tkinter.E+tkinter.W)\nfileamounts.grid(column=2, row=1, sticky=tkinter.E+tkinter.W)\n\n# PLOT TYPE RADIOBUTTONS\n# RADIOBUTTON LABELFRAME\ndatabutton_box = tkinter.LabelFrame(root)\ndatabutton_box.grid(column=0, row=0, rowspan=4, padx=10, pady=10, sticky=tkinter.N+tkinter.S)\n\ncurrent_page = tkinter.StringVar()\ncurrent_page.set(None)\nspec_plot = tkinter.Radiobutton(databutton_box, text='Create Spectrogram', command=show_options, variable=current_page, value='spec')\nspec_plot.grid(row=0, sticky=tkinter.W, pady=15, padx=5)\n\namp_plot = tkinter.Radiobutton(databutton_box, text='Create Time Series', command=show_options, variable=current_page, value='amp')\namp_plot.grid(row=1, sticky=tkinter.W, pady=15, padx=5)\n\nsearch_interesting = tkinter.Radiobutton(databutton_box, text= 'Find Interesting', command=show_options, variable=current_page, value='interesting')\nsearch_interesting.grid(row=2, sticky=tkinter.W, pady=15, padx=5)\n\n# RESET BUTTON\ndef reset_inputs():\n    global onefilename, skipval, current_page, cmap_box, colorschemes, fileamount_box, fileamounts, fileamount_str, colorscheme_str\n    onefilename.set('')\n    skipval.set(0)\n    current_page.set(None)\n    fileamount_str.set(number_of_files[0])\n    colorscheme_str.set(cmaps[2])\n    enter_onefile.configure(state='normal')\n    fileamounts.configure(state='normal')\n    colorschemes.configure(state='normal')\n\nreset = tkinter.Button(root, text='Reset All', command=reset_inputs)\nreset.grid(column=1, row=2, sticky=tkinter.E+tkinter.W, pady=10, padx=10)\n\n# FORMAT USER INPUT FOR _ladc FUNCTIONS\ntrueskip = 0\ntruefilename = ''\nfileamount_int = 0\n\ndef recordswindow(recordfn=None, recordskip=None, recordnumber=None):\n    global trueskip, truefilename, fileamount_int\n\n    recordswindow = tkinter.Toplevel(root)\n    recordswindow.title('Records')\n    recordswindow.geometry('630x300')\n\n    truerecords = tkinter.StringVar()\n    truerecords.set('')\n\n    trueheader = tkinter.StringVar()\n    trueheader.set('')\n\n    recordlabel = tkinter.Label(recordswindow, textvariable=truerecords, wraplength=600, font=('bold', 12), justify='left')\n    headerlabel = tkinter.Label(recordswindow, textvariable=trueheader, font=(6))\n    \n    if current_page.get() == 'spec' or current_page.get() == 'amp':\n        if recordfn is None:\n            if recordskip is None:\n                detect = ladc.find()\n            elif recordskip is not None:\n                detect = ladc.find(skip=recordskip)\n        elif recordfn is not None:\n            detect = ladc.find(filename=recordfn)\n\n        detectbookmark = str(detect)\n        truerecords.set(detectbookmark)\n        \n        filenamebookmark = detect['filename']\n        headerbookmark = (f'File {filenamebookmark} Records')\n        trueheader.set(headerbookmark)\n\n    if current_page.get() == 'interesting':\n        if recordnumber is not None:\n            truerecords.set(ladc.find_interesting(skip_start=recordskip, number_of_files=recordnumber, Type=6, Buoy='13', Disk='0'))\n            trueheader.set('File Records')\n\n    recordlabel.grid(column=0, row=1, sticky=tkinter.E+tkinter.W, padx=5, pady=5)\n    headerlabel.grid(column=0, row=0, sticky=tkinter.N+tkinter.W, padx=5, pady=5)\n    print('window')\n\n# POPUP WINDOW\ndef build_plot(): \n    global trueskip, truefilename, fileamount_int\n    print('built plot')\n\n    truefilename = onefilename.get()\n    if truefilename == '':\n        truefilename = None\n    \n    fileamount_int = int(fileamount_str.get())\n\n    trueskip = int(skipval.get())\n    if trueskip == 0:\n        trueskip = None\n\n    if current_page.get() == 'spec' or current_page.get() == 'amp':\n        if (trueskip is not None) and (truefilename is not None):\n            errorwindow = tkinter.Toplevel(root)\n            errorwindow.title('Error')\n            errormessage = tkinter.Label(errorwindow, text='Please enter only a filename OR a skip value.')\n            errormessage.grid(column=0, row=0, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n            okbutton = tkinter.Button(errorwindow, text='Okay', command=errorwindow.destroy)\n            okbutton.grid(column=0, row=1, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n        else:\n            try:\n                recordswindow(recordfn=truefilename, recordskip=trueskip, recordnumber=None)\n                if current_page.get() == 'spec': # use the output from the window building function instead of getting it from the widget\n                    ladc.create_spec(skip=trueskip, cmap=(colorscheme_str.get()), figsize=(6,4), save_fig=None, show_plt=True, filename=truefilename)\n                if current_page.get() == 'amp':\n                    ladc.create_timeseries(filename=truefilename, skip=trueskip, show_plt=True)\n            except FileNotFoundError:\n                errorwindow = tkinter.Toplevel(root)\n                errorwindow.title('Error')\n                errormessage = tkinter.Label(errorwindow,text='Sorry, that file does not exist.')\n                errormessage.grid(column=0, row=0, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n                okbutton = tkinter.Button(errorwindow, text='Okay', command=errorwindow.destroy)\n                okbutton.grid(column=0, row=1, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n\n    if current_page.get() == 'interesting':\n        recordswindow(recordfn=None, recordskip=trueskip, recordnumber=fileamount_int)\n        ladc.find_interesting(skip_start=trueskip, number_of_files=fileamount_int, Type=6, Buoy='13', Disk='0')\n        ladc.MATLAB_format(plot=True, show_plt=True, save_plt=False, clip_length=577, number_of_files=fileamount_int, directory='data', records=None, Type=6, Buoy='13', Disk='0', skip_start=trueskip)\n\nshow_button = tkinter.Button(root, text='Create Figure(s)', command=build_plot)\nshow_button.grid(column=2, row=2, sticky=tkinter.E+tkinter.W, padx=10, pady=10)\n\nroot.mainloop()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_256","text":"<reponame>syys96\/digital_rf<filename>python\/tools\/drf_sti.py\n#!python\n# ----------------------------------------------------------------------------\n# Copyright (c) 2017 Massachusetts Institute of Technology (MIT)\n# All rights reserved.\n#\n# Distributed under the terms of the BSD 3-clause license.\n#\n# The full license is in the LICENSE file, distributed with this software.\n# ----------------------------------------------------------------------------\n\"\"\"Create a spectral time intensity summary plot for a data set.\"\"\"\n\n\nimport datetime\nimport optparse\nimport os\nimport sys\nimport time\nimport traceback\n\nimport dateutil\nimport digital_rf as drf\nimport matplotlib.gridspec\nimport matplotlib.mlab\nimport matplotlib.pyplot\nimport numpy as np\nimport pytz\nimport scipy\nimport scipy.signal\n\n\nclass DataPlotter(object):\n    def __init__(self, control):\n        \"\"\"Initialize a data plotter for STI plotting.\"\"\"\n        self.control = control\n        ch = self.control.channel.split(\":\")\n        self.channel = ch[0]\n        self.sub_channel = int(ch[1])\n\n        # open digital RF path\n        self.dio = drf.DigitalRFReader(self.control.path)\n\n        if self.control.verbose:\n            print(\"channel bounds:\", self.dio.get_bounds(self.channel))\n\n        self.bounds = self.dio.get_bounds(self.channel)\n\n        print(\"bounds \", self.bounds)\n\n        # Figure setup\n\n        self.f = matplotlib.pyplot.figure(\n            figsize=(7, np.min([np.max([4, self.control.frames]), 7])), dpi=128\n        )\n\n        self.gridspec = matplotlib.gridspec.GridSpec(self.control.frames, 1)\n\n        self.subplots = []\n\n        \"\"\" Setup the subplots for this display \"\"\"\n        for n in np.arange(self.control.frames):\n            ax = self.f.add_subplot(self.gridspec[n])\n            self.subplots.append(ax)\n\n    def plot(self):\n        \"\"\"Iterate over the data set and plot the STI into the subplot panels.\n\n        Each panel is divided into a provided number of bins of a given\n        integration length. Strides between the panels are made between\n        integrations.\n\n        \"\"\"\n        # initialize outside the loop to avoid memory leak\n\n        # initial plotting scales\n        vmin = 0\n        vmax = 0\n\n        sr = self.dio.get_properties(self.channel)[\"samples_per_second\"]\n\n        if self.control.verbose:\n            print(\"sample rate: \", sr)\n\n        # initial time info\n        b = self.dio.get_bounds(self.channel)\n\n        if self.control.verbose:\n            print(\"data bounds: \", b)\n\n        if self.control.start:\n            dtst0 = dateutil.parser.parse(self.control.start)\n            st0 = (\n                dtst0 - datetime.datetime(1970, 1, 1, tzinfo=pytz.utc)\n            ).total_seconds()\n            st0 = int(st0 * sr)\n        else:\n            st0 = int(b[0])\n\n        if self.control.end:\n            dtst0 = dateutil.parser.parse(self.control.end)\n            et0 = (\n                dtst0 - datetime.datetime(1970, 1, 1, tzinfo=pytz.utc)\n            ).total_seconds()\n            et0 = int(et0 * sr)\n        else:\n            et0 = int(b[1])\n\n        if self.control.verbose:\n\n            print(\"start sample st0: \", st0)\n            print(\"end sample et0: \", et0)\n\n        blocks = self.control.bins * self.control.frames\n\n        samples_per_stripe = (\n            self.control.num_fft * self.control.integration * self.control.decimation\n        )\n        total_samples = blocks * samples_per_stripe\n\n        if total_samples > (et0 - st0):\n            print(\n                \"Insufficient samples for %d samples per stripe and %d blocks between %ld and %ld\"\n                % (samples_per_stripe, blocks, st0, et0)\n            )\n            return\n\n        stripe_stride = (et0 - st0) \/ blocks\n\n        bin_stride = stripe_stride \/ self.control.bins\n\n        start_sample = st0\n\n        print(\"first \", start_sample)\n\n        # get metadata\n        # this could be done better to ensure we catch frequency or sample rate\n        # changes\n        mdt = self.dio.read_metadata(st0, et0, self.channel)\n        try:\n            md = mdt[list(mdt.keys())[0]]\n            cfreq = md[\"center_frequencies\"].ravel()[self.sub_channel]\n        except (IndexError, KeyError):\n            cfreq = 0.0\n\n        if self.control.verbose:\n            print(\n                \"processing info : \",\n                self.control.frames,\n                self.control.bins,\n                samples_per_stripe,\n                bin_stride,\n            )\n\n        for p in np.arange(self.control.frames):\n            sti_psd_data = np.zeros([self.control.num_fft, self.control.bins], np.float)\n            sti_times = np.zeros([self.control.bins], np.complex128)\n\n            for b in np.arange(self.control.bins, dtype=np.int_):\n\n                if self.control.verbose:\n                    print(\n                        \"read vector :\", self.channel, start_sample, samples_per_stripe\n                    )\n\n                data = self.dio.read_vector(\n                    start_sample, samples_per_stripe, self.channel, self.sub_channel\n                )\n                if self.control.decimation > 1:\n                    data = scipy.signal.decimate(data, self.control.decimation)\n                    sample_freq = sr \/ self.control.decimation\n                else:\n                    sample_freq = sr\n\n                if self.control.mean:\n                    detrend_fn = matplotlib.mlab.detrend_mean\n                else:\n                    detrend_fn = matplotlib.mlab.detrend_none\n\n                try:\n                    psd_data, freq_axis = matplotlib.mlab.psd(\n                        data,\n                        NFFT=self.control.num_fft,\n                        Fs=float(sample_freq),\n                        detrend=detrend_fn,\n                        scale_by_freq=False,\n                    )\n                except:\n                    traceback.print_exc(file=sys.stdout)\n\n                sti_psd_data[:, b] = np.real(10.0 * np.log10(np.abs(psd_data) + 1e-12))\n\n                sti_times[b] = start_sample \/ sr\n\n                start_sample += stripe_stride\n\n            # Now Plot the Data\n            ax = self.subplots[p]\n\n            # determine image x-y extent\n            extent = (\n                0,\n                self.control.bins,\n                np.min(freq_axis) \/ 1e3,\n                np.max(freq_axis) \/ 1e3,\n            )\n\n            # determine image color extent in log scale units\n            Pss = sti_psd_data\n\n            if self.control.zaxis:\n                vmin = int(self.control.zaxis.split(\":\")[0])\n                vmax = int(self.control.zaxis.split(\":\")[1])\n            else:\n                med_Pss = np.nanmedian(Pss)\n                max_Pss = np.nanmax(Pss)\n                vmin = np.real(med_Pss - 6.0)\n                vmax = np.real(med_Pss + (max_Pss - med_Pss) * 0.61803398875 + 50.0)\n\n            im = ax.imshow(\n                sti_psd_data,\n                cmap=\"jet\",\n                origin=\"lower\",\n                extent=extent,\n                interpolation=\"nearest\",\n                vmin=vmin,\n                vmax=vmax,\n                aspect=\"auto\",\n            )\n\n            ax.set_ylabel(\"f (kHz)\", fontsize=8)\n\n            # plot dates\n\n            tick_spacing = np.arange(\n                self.control.bins \/ 8,\n                self.control.bins,\n                self.control.bins \/ 8,\n                dtype=np.int_,\n            )\n            ax.set_xticks(tick_spacing)\n            tick_labels = []\n\n            for s in tick_spacing:\n                tick_time = sti_times[s]\n\n                if tick_time == 0:\n                    tick_string = \"\"\n                else:\n                    gm_tick_time = time.gmtime(np.real(tick_time))\n                    tick_string = \"%02d:%02d:%02d\" % (\n                        gm_tick_time[3],\n                        gm_tick_time[4],\n                        gm_tick_time[5],\n                    )\n                    tick_labels.append(tick_string)\n\n            ax.set_xticklabels(tick_labels)\n\n            # set the font sizes\n            tl = ax.get_xticklabels()\n\n            for tk in tl:\n                tk.set_size(8)\n            del tl\n\n            tl = ax.get_yticklabels()\n\n            for tk in tl:\n                tk.set_size(8)\n            del tl\n\n        print(\"last \", start_sample)\n\n        # create a time stamp\n        start_time = st0 \/ sr\n        srt_time = time.gmtime(start_time)\n        sub_second = int(round((start_time - int(start_time)) * 100))\n\n        timestamp = \"%d-%02d-%02d %02d:%02d:%02d.%02d UT\" % (\n            srt_time[0],\n            srt_time[1],\n            srt_time[2],\n            srt_time[3],\n            srt_time[4],\n            srt_time[5],\n            sub_second,\n        )\n\n        self.f.suptitle(\n            \"%s %s %4.2f MHz (%s)\"\n            % (self.control.title, timestamp, cfreq \/ 1e6, self.control.path),\n            fontsize=10,\n        )\n\n        # ax.legend(fontsize=8)\n        ax.set_xlabel(\"time (UTC)\", fontsize=8)\n\n        # fixup ticks\n\n        tl = ax.get_xticklabels()\n        for tk in tl:\n            tk.set_size(8)\n        del tl\n        tl = ax.get_yticklabels()\n        for tk in tl:\n            tk.set_size(8)\n        del tl\n\n        self.gridspec.update()\n\n        self.f.tight_layout()\n\n        self.f.subplots_adjust(top=0.95, right=0.88)\n        cax = self.f.add_axes([0.9, 0.12, 0.02, 0.80])\n        self.f.colorbar(im, cax=cax)\n        if self.control.outname:\n            fname, ext = os.path.splitext(self.control.outname)\n            if ext == \"\":\n                ext = \".png\"\n            print(\"Save plot as {}\".format(fname + ext))\n            matplotlib.pyplot.savefig(fname + ext)\n        if self.control.appear or not self.control.outname:\n            print(\"Show plot\")\n            matplotlib.pyplot.show()\n\n\ndef parse_command_line(str_input=None):\n    # if str_input is None:\n    #     parser = optparse.OptionParser()\n    # else:\n    #     parser = optparse.OptionParser(str_input)\n    parser = optparse.OptionParser()\n\n    parser.add_option(\n        \"-t\",\n        \"--title\",\n        dest=\"title\",\n        default=\"Digital RF Data\",\n        help=\"Use title provided for the data.\",\n    )\n    parser.add_option(\n        \"-s\",\n        \"--start\",\n        dest=\"start\",\n        default=None,\n        help=\"Use the provided start time instead of the first time in the data. format is ISO8601: 2015-11-01T15:24:00Z\",\n    )\n    parser.add_option(\n        \"-e\",\n        \"--end\",\n        dest=\"end\",\n        default=None,\n        help=\"Use the provided end time for the plot. format is ISO8601: 2015-11-01T15:24:00Z\",\n    )\n\n    parser.add_option(\n        \"-p\",\n        \"--path\",\n        dest=\"path\",\n        help=\"Use data from the provided digital RF data <path>.\",\n    )\n    parser.add_option(\n        \"-c\",\n        \"--channel\",\n        dest=\"channel\",\n        default=\"ch0:0\",\n        help=\"Use data from the provided digital RF channel <channel>:<subchannel>.\",\n    )\n    parser.add_option(\n        \"-l\",\n        \"--length\",\n        dest=\"length\",\n        default=0.04,\n        type=\"float\",\n        help=\"The default data length in seconds for unframed data.\",\n    )\n    parser.add_option(\n        \"-b\",\n        \"--bins\",\n        dest=\"bins\",\n        default=128,\n        type=\"int\",\n        help=\"The number of time bins for the STI.\",\n    )\n    parser.add_option(\n        \"-f\",\n        \"--frames\",\n        dest=\"frames\",\n        default=4,\n        type=\"int\",\n        help=\"The number of sub-panel frames in the plot.\",\n    )\n    parser.add_option(\n        \"-n\",\n        \"--num_fft\",\n        dest=\"num_fft\",\n        default=128,\n        type=\"int\",\n        help=\"The number of FFT bints for the STI.\",\n    )\n    parser.add_option(\n        \"-i\",\n        \"--integration\",\n        dest=\"integration\",\n        default=1,\n        type=\"int\",\n        help=\"The number of rasters to integrate for each plot.\",\n    )\n    parser.add_option(\n        \"-d\",\n        \"--decimation\",\n        dest=\"decimation\",\n        default=1,\n        type=\"int\",\n        help=\"The decimation factor for the data (integer).\",\n    )\n    parser.add_option(\n        \"-m\",\n        \"--mean\",\n        dest=\"mean\",\n        action=\"store_true\",\n        default=False,\n        help=\"Remove the mean from the data at the PSD processing step.\",\n    )\n    parser.add_option(\n        \"-z\",\n        \"--zaxis\",\n        dest=\"zaxis\",\n        default=None,\n        type=\"string\",\n        help=\"zaxis colorbar setting e.g. -50:50\",\n    )\n    parser.add_option(\n        \"-v\",\n        \"--verbose\",\n        action=\"store_true\",\n        dest=\"verbose\",\n        default=False,\n        help=\"Print status messages to stdout.\",\n    )\n    parser.add_option(\n        \"-o\",\n        \"--outname\",\n        dest=\"outname\",\n        default=None,\n        type=str,\n        help=\"Name of file that figure will be saved under.\",\n    )\n    parser.add_option(\n        \"-a\",\n        \"--appear\",\n        action=\"store_true\",\n        dest=\"appear\",\n        default=False,\n        help=\"Makes the plot appear through pyplot show.\",\n    )\n    if str_input is None:\n        (options, args) = parser.parse_args()\n    else:\n        (options, args) = parser.parse_args(str_input)\n\n    return (options, args)\n\n\n#\n# MAIN PROGRAM\n#\n\n# Setup Defaults\nif __name__ == \"__main__\":\n    \"\"\"\n    Needed to add main function to use outside functions outside of module.\n    \"\"\"\n\n    # Parse the Command Line for configuration\n    (options, args) = parse_command_line()\n\n    if options.path is None:\n        print(\"Please provide an input source with the -p option!\")\n        sys.exit(1)\n\n    # Activate the DataPlotter\n    dpc = DataPlotter(options)\n\n    dpc.plot()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_257","text":"<reponame>JohnStarich\/python-pool-performance<filename>pools\/pool.py\nfrom requests.adapters import HTTPAdapter\nfrom collections.abc import Mapping, Sequence\nfrom types import FunctionType\nfrom tqdm import tqdm\nimport time\nimport sys\nimport gc\n\n\nclass PoolTest(object):\n    def __init__(self, worker_count: int):\n        self.worker_count = worker_count\n        self.pool = self.init_pool(worker_count)\n        self.compute_resource = self.init_compute_resource()\n        self.network_resource = self.init_network_resource()\n\n    def init_pool(self, worker_count: int) -> object:\n        raise NotImplementedError(\"{} does not implement init_pool\"\n                                  .format(self.__class__.__name__))\n\n    def destroy_pool(self):\n        pass\n\n    def map(self, work_func: FunctionType, inputs: Sequence) -> Sequence:\n        raise NotImplementedError(\"{} does not implement map\"\n                                  .format(self.__class__.__name__))\n\n    def init_compute_resource(self) -> object:\n        from cmath import sqrt\n        return sqrt\n\n    def init_network_resource(self) -> object:\n        import requests\n        return requests.Session\n\n    @staticmethod\n    def do_compute_work(args) -> None:\n        compute_resource, num, *_ = args\n        sqrt = compute_resource\n        sqrt(sqrt(sqrt(num)))\n\n    @staticmethod\n    def do_network_work(args) -> None:\n        network_resource, *_ = args\n        Session = network_resource\n        with Session() as s:\n            adapter = HTTPAdapter(max_retries=3)\n            s.mount('http:\/\/', adapter)\n            s.get('http:\/\/localhost:8080\/')\n\n    def run_compute_test(self, jobs: int, trials: int,\n                         show_progress: bool=False) -> Mapping:\n        return self._run_test(self.do_compute_work, self.compute_resource,\n                              jobs, trials, show_progress=show_progress)\n\n    def run_network_test(self, jobs: int, trials: int,\n                         show_progress: bool=False) -> Mapping:\n        return self._run_test(self.do_network_work, self.network_resource,\n                              jobs, trials, show_progress=show_progress)\n\n    def _run_test(self, work_func: FunctionType, work_resource: object,\n                  jobs: int, trials: int,\n                  show_progress: bool=False) -> Mapping:\n        results = {\n            'jobs': jobs,\n            'trials': trials,\n            'time': [],\n            'blocks': [],\n        }\n        # Forcibly evaluate the inputs to prevent time\/resources taken up later\n        inputs = list(zip(\n            [work_resource] * jobs,\n            range(jobs)\n        ))\n        trial_iter = range(trials)\n        if show_progress is True and trials > 2:\n            trial_iter = tqdm(trial_iter, desc='trials')\n        gc.collect()\n        for _ in trial_iter:\n            # Run trial of pool map function and measure it\n            gc.collect()\n            blocks_start = sys.getallocatedblocks()\n            time_start = time.time()\n            list(self.map(work_func, inputs))\n            time_end = time.time()\n            results['time'].append(time_end - time_start)\n            # Get allocated blocks before garbage collection to show peak usage\n            blocks_end = sys.getallocatedblocks()\n            results['blocks'].append(blocks_end - blocks_start)\n        return results\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_258","text":"import numpy as np\nimport math\nfrom ..utils import Monitor\nfrom scipy.optimize import basinhopping, minimize, Bounds\n\nclass OverbudgetException(Exception):\n    def __init__(self):\n        super(Exception, self).__init__()\n\ndef get_variable_bounds(problem):\n    lbs = problem.lbs()\n    ubs = problem.ubs()\n\n    return Bounds(lbs, ubs)\n\ndef optimize_basinhopping(problem, max_evals, T=1.0, stepsize=0.5, localmethod=\"L-BFGS-B\", log=None, verbose=True):\n    vt = problem.vartype()\n    lbs = problem.lbs()\n    ubs = problem.ubs()\n    mon = Monitor(f\"scipy.basinhopping\/{localmethod}\", problem, log=log)\n    def f(x):\n        # This approach does not stay within its evaluation budget (it has little to no way to enforce this!)\n        # As such. raise an exception if we are over the limit\n        if mon.num_iters > max_evals:\n            raise OverbudgetException()\n        # scipy.optimize\n        xvec = x.copy()\n        # Round non-continuous variables\n        xvec[vt != 'cont'] = np.round(xvec[vt != 'cont'])\n        # Clamp variable values to bounds\n        np.clip(xvec, lbs, ubs, out=xvec)\n        mon.commit_start_eval()\n        r = problem.evaluate(xvec)\n        mon.commit_end_eval(xvec, r)\n        return r\n    \n    def budget_check_global(x, f, accept):\n        # Callback used to stop basin hopping when evaluation limit is reached.\n        # x -- local minimum solution\n        # f -- corresponding fitness\n        # accept -- whether this local optima was accepted as the new reference solution\n        return mon.num_iters >= max_evals\n\n    def budget_check_local(x):\n        # Callback used to stop local optimization when evaluation limit is reached.\n        # x -- local minimum solution\n        return mon.num_iters >= max_evals\n    \n    minimizer_kwargs = {\n        'method': localmethod,\n        'bounds': get_variable_bounds(problem),\n        'callback': budget_check_local\n    }\n\n    # Generate initial point\n    lb = problem.lbs()\n    ub = problem.ubs()\n    d = len(lb)\n    x0 = np.random.rand(d)*(ub-lb) + lb\n    x0[vt != 'cont'] = np.round(x0[vt != 'cont'])\n\n    mon.start()\n    try:\n        optim_result = basinhopping(func=f, x0=x0, niter=max_evals, T=T, stepsize=stepsize, minimizer_kwargs=minimizer_kwargs, callback=budget_check_global)\n    except OverbudgetException as e:\n        pass\n    mon.end()\n\n    solX = mon.best_x #optim_result['x']\n    solY = mon.best_fitness #optim_result['fun']\n\n    return solX, solY, mon\n\n\ndef optimize_scipy_local(problem, max_evals, method=\"BFGS\", log=None, verbose=False):\n\n    vt = problem.vartype()\n    mon = Monitor(f\"scipy.{method}\", problem, log=log)\n    def f(x):\n        # This approach does not stay within its evaluation budget (it has little to no way to enforce this!)\n        # As such. raise an exception if we are over the limit\n        if mon.num_iters > max_evals:\n            raise OverbudgetException()\n        # scipy.optimize\n        xvec = x.copy()\n        # Round non-continuous variables\n        xvec[vt != 'cont'] = np.round(xvec[vt != 'cont'])\n        mon.commit_start_eval()\n        r = problem.evaluate(xvec)\n        mon.commit_end_eval(xvec, r)\n        return r\n    \n    def budget_check_local(x):\n        # Callback used to stop local optimization when evaluation limit is reached.\n        # x -- local minimum solution\n        return mon.num_iters >= max_evals\n\n    # Generate initial point, round the integers.\n    lb = problem.lbs()\n    ub = problem.ubs()\n    d = len(lb)\n    x0 = np.random.rand(d)*(ub-lb) + lb\n    x0[vt != 'cont'] = np.round(x0[vt != 'cont'])\n\n    mon.start()\n    try:\n        optim_result = minimize(fun=f, x0=x0, method=method, bounds=get_variable_bounds(problem), options={'maxiter': max_evals}, callback=budget_check_local)\n    except OverbudgetException as e:\n        pass\n    mon.end()\n\n    solX = mon.best_x #optim_result['x']\n    solY = mon.best_fitness #optim_result['fun']\n\n    return solX, solY, mon"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_259","text":"<reponame>prise-3d\/IPFML\n\"\"\"\nFunctions which can be used to extract information from image or reduce it\n\"\"\"\n\n# main imports\nimport os\nimport random\nimport numpy as np\n\n# image processing imports\nfrom numpy.linalg import svd\nfrom scipy import misc\nfrom sklearn import preprocessing\nfrom skimage import io, color\nimport cv2\nfrom PIL import Image\n\n# ipfml imports\nfrom ipfml.processing import compression\n\n\ndef get_LAB(image):\n    \"\"\"Transforms RGB  Image into Lab\n\n    Args:\n        image: image to convert\n\n    Returns:\n        Lab information\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> Lab = transform.get_LAB(img)\n    >>> Lab.shape\n    (200, 200, 3)\n    \"\"\"\n\n    return color.rgb2lab(image)\n\n\ndef get_LAB_L(image):\n    \"\"\"Transforms RGB Image into Lab and returns L\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The L chanel from Lab information\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> L = transform.get_LAB_L(img)\n    >>> L.shape\n    (200, 200)\n    \"\"\"\n\n    lab = get_LAB(image)\n    return lab[:, :, 0]\n\n\ndef get_LAB_a(image):\n    \"\"\"Transforms RGB Image into LAB and returns a\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The a chanel from Lab information\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> a = transform.get_LAB_a(img)\n    >>> a.shape\n    (200, 200)\n    \"\"\"\n\n    lab = get_LAB(image)\n    return lab[:, :, 1]\n\n\ndef get_LAB_b(image):\n    \"\"\"Transforms RGB Image into LAB and returns b\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The b chanel from Lab information\n\n    Usage :\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> b = transform.get_LAB_b(img)\n    >>> b.shape\n    (200, 200)\n    \"\"\"\n\n    lab = get_LAB(image)\n    return lab[:, :, 2]\n\n\ndef get_XYZ(image):\n    \"\"\"Transforms RGB Image into XYZ\n\n    Args:\n        image: image to convert\n\n    Returns:\n        XYZ information obtained from transformation\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> transform.get_XYZ(img).shape\n    (200, 200, 3)\n    \"\"\"\n\n    return color.rgb2xyz(image)\n\n\ndef get_XYZ_X(image):\n    \"\"\"Transforms RGB Image into XYZ and returns X\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The X chanel from XYZ information\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> x = transform.get_XYZ_X(img)\n    >>> x.shape\n    (200, 200)\n    \"\"\"\n\n    xyz = color.rgb2xyz(image)\n    return xyz[:, :, 0]\n\n\ndef get_XYZ_Y(image):\n    \"\"\"Transforms RGB Image into XYZ and returns Y\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The Y chanel from XYZ information\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> y = transform.get_XYZ_Y(img)\n    >>> y.shape\n    (200, 200)\n    \"\"\"\n\n    xyz = color.rgb2xyz(image)\n    return xyz[:, :, 1]\n\n\ndef get_XYZ_Z(image):\n    \"\"\"Transforms RGB Image into XYZ and returns Z\n\n    Args:\n        image: image to convert\n\n    Returns:\n        The Z chanel from XYZ information\n\n    Raises:\n        ValueError: If `nb_bits` has unexpected value. `nb_bits` needs to be in interval [1, 8].\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> z = transform.get_XYZ_Z(img)\n    >>> z.shape\n    (200, 200)\n    \"\"\"\n\n    xyz = color.rgb2xyz(image)\n    return xyz[:, :, 2]\n\n\ndef get_low_bits_img(image, nb_bits=4):\n    \"\"\"Returns Image or Numpy array with data information reduced using only low bits\n\n    Args:\n        image: image to convert\n        nb_bits: optional parameter which indicates the number of bits to keep\n\n    Returns:\n        Numpy array with reduced values\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> low_bits_img = transform.get_low_bits_img(img, 5)\n    >>> low_bits_img.shape\n    (200, 200, 3)\n    \"\"\"\n\n    if nb_bits <= 0:\n        raise ValueError(\n            \"unexpected value of number of bits to keep. @nb_bits needs to be positive and greater than 0.\"\n        )\n\n    if nb_bits > 8:\n        raise ValueError(\n            \"Unexpected value of number of bits to keep. @nb_bits needs to be in interval [1, 8].\"\n        )\n\n    img_arr = np.array(image)\n\n    bits_values = sum([pow(2, i - 1) for i in range(1, nb_bits + 1)])\n\n    return img_arr & bits_values\n\n\ndef get_bits_img(image, interval):\n    \"\"\"Returns only bits specified into the interval\n\n    Args:\n        image: image to convert using this interval of bits value to keep\n        interval: (begin, end) of bits values\n\n    Returns:\n        Numpy array with reduced values\n\n    Raises:\n        ValueError: If min value from interval is not >= 1.\n        ValueError: If max value from interval is not <= 8.\n        ValueError: If min value from interval >= max value.\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> bits_img = transform.get_bits_img(img, (2, 5))\n    >>> bits_img.shape\n    (200, 200, 3)\n    \"\"\"\n\n    img_arr = np.array(image)\n    begin, end = interval\n\n    if begin < 1:\n        raise ValueError(\n            \"Unexpected value of interval. Interval min value needs to be >= 1.\"\n        )\n\n    if end > 8:\n        raise ValueError(\n            \"Unexpected value of interval. Interval min value needs to be <= 8.\"\n        )\n\n    if begin >= end:\n        raise ValueError(\"Unexpected interval values order.\")\n\n    bits_values = sum([pow(2, i - 1) for i in range(begin, end + 1)])\n\n    return img_arr & bits_values\n\n\ndef gray_to_mscn(image):\n    \"\"\"Convert Grayscale Image into Mean Subtracted Contrast Normalized (MSCN)\n\n    Args:\n        image: grayscale image\n\n    Returns:\n        MSCN matrix obtained from transformation\n\n    Usage:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> img = transform.get_LAB_L(img)\n    >>> img_mscn = transform.gray_to_mscn(img)\n    >>> img_mscn.shape\n    (200, 200)\n    \"\"\"\n\n    s = 7 \/ 6\n    blurred = cv2.GaussianBlur(image, (7, 7),\n                               s)  # apply gaussian blur to the image\n    blurred_sq = blurred * blurred\n    sigma = cv2.GaussianBlur(image * image, (7, 7), s)\n    sigma = abs(sigma - blurred_sq)**0.5\n    sigma = sigma + 1.0 \/ 255  # avoid DivideByZero Exception\n    mscn = (image - blurred) \/ sigma  # MSCN(i, j) image\n\n    return mscn\n\n\ndef rgb_to_mscn(image):\n    \"\"\"Convert RGB Image into Mean Subtracted Contrast Normalized (MSCN)\n\n    Args:\n        image: 3D RGB image Numpy array or PIL RGB image\n\n    Returns:\n        2D Numpy array with MSCN information\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> img_mscn = transform.rgb_to_mscn(img)\n    >>> img_mscn.shape\n    (200, 200)\n    \"\"\"\n\n    # check if PIL image or not\n    img_arr = np.array(image)\n\n    # convert rgb image to gray\n    im = np.array(color.rgb2gray(img_arr) * 255, 'uint8')\n\n    return gray_to_mscn(im)\n\n\ndef get_mscn_coefficients(image):\n    \"\"\"Compute the Mean Substracted Constrast Normalized coefficients of an image\n\n    Args:\n        image: PIL Image, Numpy array or path of image\n\n    Returns:\n        MSCN coefficients\n\n    Raises:\n        FileNotFoundError: If `image` is set as str path and image was not found\n        ValueError: If `image` numpy shape are not correct\n\n    Example:\n\n    >>> from PIL import Image\n    >>> import numpy as np\n    >>> from ipfml.processing import transform\n    >>> image_values = Image.open('.\/images\/test_img.png')\n    >>> mscn_coefficients = transform.get_mscn_coefficients(image_values)\n    >>> mscn_coefficients.shape\n    (200, 200)\n    \"\"\"\n\n    if isinstance(image, str):\n        if os.path.exists(image):\n            # open image directly as grey level image\n            imdist = cv2.imread(image, 0)\n        else:\n            raise FileNotFoundError('Image not found in your system')\n\n    elif isinstance(image, np.ndarray):\n        # convert if necessary to grey level numpy array\n        if image.ndim == 2:\n            imdist = image\n        if image.ndim == 3:\n            imdist = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n        else:\n            raise ValueError('Incorrect image shape')\n    else:\n        # if PIL Image\n        image = np.asarray(image)\n\n        if image.ndim == 2:\n            imdist = image\n        if image.ndim == 3:\n            imdist = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n        else:\n            raise ValueError('Incorrect image shape')\n\n    imdist = imdist.astype(np.float64)\n    imdist = imdist \/ 255.0\n\n    # calculating MSCN coefficients\n    mu = cv2.GaussianBlur(imdist, (7, 7),\n                          7 \/ 6,\n                          borderType=cv2.BORDER_CONSTANT)\n    mu_sq = mu * mu\n    sigma = cv2.GaussianBlur(imdist * imdist, (7, 7),\n                             7 \/ 6,\n                             borderType=cv2.BORDER_CONSTANT)\n    sigma = np.sqrt(abs((sigma - mu_sq)))\n    structdis = (imdist - mu) \/ (sigma + 1)\n    return structdis\n\n\ndef get_LAB_L_SVD(image):\n    \"\"\"Returns Singular values from LAB L Image information\n\n    Args:\n        image: PIL Image or Numpy array\n\n    Returns:\n        U, s, V information obtained from SVD compression using Lab\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> U, s, V = transform.get_LAB_L_SVD(img)\n    >>> U.shape\n    (200, 200)\n    >>> len(s)\n    200\n    >>> V.shape\n    (200, 200)\n    \"\"\"\n    L = get_LAB_L(image)\n    return compression.get_SVD(L)\n\n\ndef get_LAB_L_SVD_s(image):\n    \"\"\"Returns s (Singular values) SVD from L of LAB Image information\n\n    Args:\n        image: PIL Image or Numpy array\n\n    Returns:\n        vector of singular values\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> s = transform.get_LAB_L_SVD_s(img)\n    >>> len(s)\n    200\n    \"\"\"\n    L = get_LAB_L(image)\n    return compression.get_SVD_s(L)\n\n\ndef get_LAB_L_SVD_U(image):\n    \"\"\"Returns U SVD from L of LAB Image information\n\n    Args:\n        image: PIL Image or Numpy array\n\n    Returns:\n        U matrix of SVD compression\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> U = transform.get_LAB_L_SVD_U(img)\n    >>> U.shape\n    (200, 200)\n    \"\"\"\n    L = get_LAB_L(image)\n    return compression.get_SVD_U(L)\n\n\ndef get_LAB_L_SVD_V(image):\n    \"\"\"Returns V SVD from L of LAB Image information\n\n    Args:\n        image: PIL Image or Numpy array\n\n    Returns:\n        V matrix of SVD compression\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> V = transform.get_LAB_L_SVD_V(img)\n    >>> V.shape\n    (200, 200)\n    \"\"\"\n\n    L = get_LAB_L(image)\n    return compression.get_SVD_V(L)\n\n\ndef rgb_to_grey_low_bits(image, nb_bits=4):\n    \"\"\"Convert RGB Image into grey image using only 4 low bits values\n\n    Args:\n        image: 3D RGB image Numpy array or PIL RGB image\n        nb_bits: optional parameter which indicates the number of bits to keep (default 4)\n\n    Returns:\n        2D Numpy array with low bits information kept\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> low_bits_grey_img = transform.rgb_to_grey_low_bits(img, 5)\n    >>> low_bits_grey_img.shape\n    (200, 200)\n    \"\"\"\n\n    img_arr = np.array(image)\n    grey_block = np.array(color.rgb2gray(img_arr) * 255, 'uint8')\n\n    return get_low_bits_img(grey_block, nb_bits)\n\n\ndef rgb_to_LAB_L_low_bits(image, nb_bits=4):\n    \"\"\"Convert RGB Image into Lab L channel image using only 4 low bits values\n\n    Args:\n        image: 3D RGB image Numpy array or PIL RGB image\n        nb_bits: optional parameter which indicates the number of bits to keep (default 4)\n\n    Returns:\n        2D Numpy array with low bits information kept\n\n    Example:\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> low_bits_Lab_l_img = transform.rgb_to_LAB_L_low_bits(img, 5)\n    >>> low_bits_Lab_l_img.shape\n    (200, 200)\n    \"\"\"\n\n    L_block = np.asarray(get_LAB_L(image), 'uint8')\n\n    return get_low_bits_img(L_block, nb_bits)\n\n\ndef rgb_to_LAB_L_bits(image, interval):\n    \"\"\"Returns only bits from LAB L canal specified into the interval\n\n    Args:\n        image: image to convert using this interval of bits value to keep\n        interval: (begin, end) of bits values\n\n    Returns:\n        2D Numpy array with reduced values\n\n    >>> from PIL import Image\n    >>> from ipfml.processing import transform\n    >>> img = Image.open('.\/images\/test_img.png')\n    >>> bits_Lab_l_img = transform.rgb_to_LAB_L_bits(img, (2, 6))\n    >>> bits_Lab_l_img.shape\n    (200, 200)\n    \"\"\"\n\n    L_block = np.asarray(get_LAB_L(image), 'uint8')\n\n    return get_bits_img(L_block, interval)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_260","text":"import numpy as np\nfrom scipy.stats import multivariate_normal\nfrom to.probabilistic_model import ProbabilisticModel\nfrom evolution import chromosome as evolution\nfrom copy import deepcopy\n\n\n\nclass MixtureModel(object):\n\n    def __init__(self, allModels, alpha=False):\n        self.model_list = allModels.copy()\n        self.nModels = len(allModels)\n        if alpha is False:\n            self.alpha = (1\/self.nModels)*np.ones(self.nModels)\n        else:\n            self.alpha = alpha\n\n        self.probTable = None\n        self.nSol = None\n        self.__target_model_added = False\n\n    def add_target_solutions(self, solutions, modelType):\n        if not self.__target_model_added:\n            self.nModels = self.nModels + 1\n            self.model_list.append(ProbabilisticModel(modelType=modelType))\n            self.model_list[-1].buildModel(solutions)\n            self.__target_model_added = True\n        else:\n            raise Exception('Target model is already added.')\n\n    def add_target_model(self, target_model):\n        if not self.__target_model_added:\n            self.nModels = self.nModels + 1\n            self.model_list.append(target_model)\n            self.target_model_added = True\n        else:\n            raise Exception('Target model is already added.')\n\n    def createTable(self, solutions, CV, modelType, probs_RL=None):\n        if CV:\n            self.add_target_solutions(solutions, modelType)\n            self.alpha = (1\/self.nModels) * np.ones(self.nModels)\n            nSol = solutions.shape[0]\n            self.nSol = nSol\n            self.probTable = np.ones([nSol, self.nModels])\n \n            if probs_RL is None:\n                for j in range(self.nModels-1):\n                    self.probTable[:, j] = self.model_list[j].pdfEval(solutions) \n            else:\n                for j in range(0, self.nModels-1):\n                    self.probTable[:, j] = self.model_list[j].pdfEval(solutions) # Time complexity: O(pd)\n\n            for i in range(nSol):  # Leave-one-out cross validation\n                x = np.concatenate((solutions[:i, :], solutions[i+1:, :]))\n                tModel = ProbabilisticModel(modelType=modelType)\n                tModel.buildModel(x)\n                self.probTable[i, -1] = tModel.pdfEval(solutions[[i], :])\n        else:\n            nSol = solutions.shape[0]\n            self.probTable = np.ones([nSol, self.nModels])\n            for j in range(self.nModels):\n                self.probTable[:, j] = self.model_list[j].pdfEval(solutions)\n            self.nSol = nSol\n\n    def EMstacking(self, iterations=1):\n        for t in range(iterations):\n            print(t)\n            talpha = self.alpha\n            probVector = np.matmul(self.probTable, talpha.T)\n            if any(probVector == 0):\n                print('probVector: ', probVector)\n                print('self.probTable: ', self.probTable)\n                print('talpha: ', talpha)\n            for i in range(self.nModels):\n                talpha[i] = np.sum((1\/self.nSol)*talpha[i]*self.probTable[:, i]\/probVector)\n            self.alpha = talpha\n\n        if np.sum(np.isnan(self.alpha)) > 0:\n            print('sanity check mutate')\n            self.alpha = np.zeros(self.nModels)\n            self.alpha[-1] = 1\n\n\n    def mutate(self, version='normal'):\n        modif_alpha = None\n        \n        modif_alpha = self.alpha + np.random.rand(self.nModels)*0.01\n\n        total_alpha = np.sum(modif_alpha)\n        if total_alpha == 0:\n            self.alpha = np.zeros(self.nModels)\n            self.alpha[-1] = 1\n        else:\n            self.alpha = modif_alpha\/total_alpha\n\n        # Sanity check\n        if np.sum(np.isnan(self.alpha)) > 0:\n            print('sanity check mutate')\n            self.alpha = np.zeros(self.nModels)\n            self.alpha[-1] = 1\n\n\n    def sample(self, nSol, samplesRL=None, preprocess=False):\n        \n        if preprocess:\n            i = 0\n            while any(self.alpha[self.alpha!=0]<(1\/nSol - np.finfo(np.float32).eps)):\n                self.alpha[self.alpha<(1\/nSol - np.finfo(np.float32).eps)] = 0\n                self.alpha = self.alpha\/np.sum(self.alpha)\n                i += 1\n\n        indSamples = np.ceil(nSol*self.alpha).astype(int)\n        solutions = np.array([])\n        for i in range(self.nModels):\n            if indSamples[i] == 0:\n                pass\n            elif i == self.nModels - 2 and samplesRL is not None:\n                solutions = np.vstack([solutions, samplesRL]) if solutions.size else samplesRL\n            else:\n                sols = self.model_list[i].sample(indSamples[i])\n                solutions = np.vstack([solutions, sols]) if solutions.size else sols\n        solutions = solutions[np.random.permutation(solutions.shape[0]), :]\n        solutions = solutions[:nSol, :]\n        return solutions\n\n\n    def sample_enhanced(self, nSol, problem, mutation_strength, \n                        samples_count, max_sampling_num=None, solution_found=None,\n                        problem_type='knapsack', net=None, s_len=None, mutation=True):\n        \"\"\"\n        This sampling function only works for sTrEvo algorithm\n        \"\"\"\n\n        if max_sampling_num is None:\n            max_sampling_num = nSol\n        indSamples = np.ceil(nSol*self.alpha).astype(int)\n\n        solutions = []\n        added_solutions = []\n        solutions_idx = []\n        for i in range(self.nModels):\n            if indSamples[i] == 0:\n                pass\n            else:\n                \n                sampling_size = min(max_sampling_num, indSamples[i])\n                sols_idx = np.ones(sampling_size) * i\n                sols = self.model_list[i].sample(sampling_size)\n\n                solutions = np.append(solutions, sols, axis=0) if len(solutions) else deepcopy(sols)\n                solutions_idx = np.append(solutions_idx, sols_idx, axis=0) if len(sols_idx) else deepcopy(sols_idx)\n\n        \n        perm_indexes = np.random.permutation(len(solutions))\n        solutions_num = min(nSol, len(solutions))\n        solutions = solutions[perm_indexes][:solutions_num]\n        solutions_idx = solutions_idx[perm_indexes][:solutions_num].astype(np.int)\n        \n\n        # Fitness Evaluation + Mutation_strength Update\n        offsprings = []\n        fitness_mean = 0\n        \n        func_eval_num = 0\n        for solution, src_idx in zip(solutions, solutions_idx):\n            \n            if problem_type == 'knapsack':\n                offsprings.append(evolution.Chromosome(solution))\n                fitness = offsprings[-1].fitness_calc(problem)\n            elif problem_type == 'pole':\n                offsprings.append(evolution.ChromosomePole(solution))\n                fitness = offsprings[-1].fitness_calc(net, problem, s_len)\n                if not solution_found.value:\n                    func_eval_num += 1\n                if fitness - 2000 > -0.0001:\n                    solution_found.value = True\n            elif problem_type == 'arm':\n                offsprings.append(evolution.ChromosomeKA(solution))\n                fitness = offsprings[-1].fitness_calc(*problem)\n            else:\n                raise ValueError('Problem_type is wrong')\n            \n            fitness_mean += fitness\n            if src_idx != self.nModels-1:\n                samples_count[src_idx] += 1\n                mutation_strength[src_idx] += (1\/samples_count[src_idx])*(fitness - mutation_strength[src_idx])\n        \n        fitness_mean = fitness_mean\/solutions_num\n\n\n        # Sanity check\n        if len(offsprings) != solutions_num:\n            raise ValueError('offsprings length does not match the number of solutions')\n        \n        if solution_found is not None:     \n            return offsprings, mutation_strength, samples_count, fitness_mean, func_eval_num\n        else:\n            return offsprings, mutation_strength, samples_count, fitness_mean\n\n    def n_samples(self, ind, nSol):\n        return np.ceil(nSol * self.alpha[ind]).astype(int)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_261","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n# ---\n# jupyter:\n#   jupytext:\n#     text_representation:\n#       extension: .py\n#       format_name: light\n#       format_version: '1.4'\n#       jupytext_version: 1.1.4\n#   kernelspec:\n#     display_name: Python 3\n#     language: python\n#     name: python3\n# ---\n\n# # S_BackForwEwmaSD [<img src=\"https:\/\/www.arpm.co\/lab\/icons\/icon_permalink.png\" width=30 height=30 style=\"display: inline;\">](https:\/\/www.arpm.co\/lab\/redirect.php?code=S_BackForwEwmaSD&codeLang=Python)\n# For details, see [here](https:\/\/www.arpm.co\/lab\/redirect.php?permalink=eb-estimation-fwd-bwd-exp-smooth).\n\n# ## Prepare the environment\n\n# +\nimport os\nimport os.path as path\nimport sys\n\nsys.path.append(path.abspath('..\/..\/functions-legacy'))\n\nfrom numpy import arange, array, zeros, diff, abs, log, exp, sqrt, linspace\nfrom numpy import sum as npsum\n\nfrom scipy.io import loadmat\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.pyplot import subplots, title\nimport matplotlib.dates as mdates\n\nplt.style.use('seaborn')\n\nfrom CONFIG import GLOBAL_DB, TEMPORARY_DB\nfrom ARPM_utils import save_plot, struct_to_dict, date_mtop\n\n# Parameters\ntau_HL = 30\nlam = log(2) \/ tau_HL\ni_ = 252\n# -\n\n# ## Upload database db_Stock SPX\n\n# +\ntry:\n    db = loadmat(os.path.join(GLOBAL_DB, 'db_Stocks'), squeeze_me=True)\nexcept FileNotFoundError:\n    db = loadmat(os.path.join(TEMPORARY_DB, 'db_Stocks'), squeeze_me=True)\n\nSPX = struct_to_dict(db['SPX'])\n# -\n\n# ## Compute the realized compounded returns\n\n# +\nv = SPX.Price_close\n\nx = log(v)\nepsi = diff(x, 1).reshape(1,-1)\ndate = SPX.Date[1:]\n\nt_ = epsi.shape[1]\n# -\n\n# ## Compute the backward-forward exponential decay probabilities\n\nedecayprobs = exp(-lam*(abs(arange(-i_, i_ + 1)))).reshape(1,-1)\ngamma = npsum(edecayprobs)  # normalization coefficient\nedecayprobs = edecayprobs \/ gamma  # decay factors\n\n# ## Compute the backward\/forward exponentially weighted moving standard deviations\n\ny = zeros(t_ - 2 * i_)  # start from time= i_+1 and estimate up to time= t_end -i_  (so that i_ observations are always availabe both backward and forward)\nfor t in arange(i_,t_-i_):\n    ret = epsi[[0],t - i_:t + i_+1]\n    y[t - i_] = sqrt(edecayprobs@ret.T ** 2)\n\n# ## Display the compounded returns and the backward\/forward exponentially weighted moving standard deviations\n\n# +\ndate_dt = array([date_mtop(i) for i in date])\nmyFmt = mdates.DateFormatter('%d-%b-%Y')\n\nf, ax = subplots(2, 1)\ndate_est = date_dt[i_:t_- i_]\nax[0].plot(date_est, epsi[0,i_:t_ - i_], color='b',lw=1)\nax[0].set_xlim([date_est[0], date_est[-1]])\nax[0].xaxis.set_major_formatter(myFmt)\ntitle('Compounded returns')\n\ndate_est = date_dt[i_ :t_- i_]\nax[1].plot(date_est, y, color=[.9, .4, 0], lw = 1.5)\nax[1].set_xlim([date_est[0], date_est[-1]])\nax[1].xaxis.set_major_formatter(myFmt)\ntitle('Estimated Exponentially Weighted Moving St. Deviation')\nplt.tight_layout();\n# save_plot(ax=plt.gca(), extension='png', scriptname=os.path.basename('.')[:-3], count=plt.get_fignums()[-1])\n# -\n\n# ## Display the backward\/forward exponential decay probabilities\n\nf, ax = subplots(1, 1)\nax.bar(arange(edecayprobs.shape[1]),edecayprobs[0], facecolor=[.7, .7, .7], edgecolor=[.7, .7, .7])\nax.set_xlim([1, 2 * i_ + 1])\nplt.xticks(linspace(1,2*i_+1,3),[-252,0,252])\ntitle('Exponential decay factors profile');\n# save_plot(ax=plt.gca(), extension='png', scriptname=os.path.basename('.')[:-3], count=plt.get_fignums()[-1])\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_263","text":"<reponame>ADBI-george2\/AnomalyDetection\nfrom __future__ import print_function, division\nfrom igraph import *\nimport numpy as np\nimport numpy.linalg as la\nfrom scipy.stats import pearsonr\nimport matplotlib.pyplot as plt\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\n__author__ = 'panzer'\n\nFEATURES = [\"degree\", \"clustering_coefficient\", \"ego_net_edges\"]\n\ndef say(*lst):\n  print(*lst, end=\"\")\n  sys.stdout.flush()\n\ndef list_files(folder):\n  \"\"\"\n  List all files in a folder\n  :param folder: Name of the folder\n  :return: list of complete file names in folder\n  \"\"\"\n  return [\"%s\/%s\"%(folder, f) for f in os.listdir(folder) if f.endswith(\".txt\")]\n\ndef make_graph(file_name):\n  \"\"\"\n  Make graph from a file\n  :param file_name:\n  :return:\n  \"\"\"\n  with open(file_name, 'r') as f:\n    lines = f.readlines()\n    node_count, edge_count = map(int, lines[0].strip().split())\n    edges = [map(int, line.strip().split()) for line in lines[1:]]\n    graph = Graph()\n    graph.add_vertices(node_count)\n    graph.add_edges(edges)\n  for vertex in graph.vs:\n    assign_attributes(vertex, graph)\n  return graph\n\n\ndef assign_attributes(vertex, graph):\n  \"\"\"\n  Assign Attributes for the vertex\n  :param vertex: Vertex to be assigned attributes\n  :param graph: Instance of graph to which the vertex belongs\n  \"\"\"\n  neighbors = graph.neighbors(vertex.index)\n  ego_net = graph.subgraph([vertex.index]+neighbors)\n  vertex[\"degree\"] = vertex.degree()\n  cc = graph.transitivity_local_undirected([vertex.index])[0]\n  vertex[\"clustering_coefficient\"] = 0 if np.isnan(cc) else cc\n  vertex[\"ego_net_edges\"] = len(ego_net.es)\n\n\ndef get_feature_vector(graphs, vertex_id, feature):\n  return [graph.vs[vertex_id][feature] for graph in graphs]\n\ndef pearson_rho(x_vector, y_vector):\n  val, _ = pearsonr(x_vector, y_vector)\n  return 0 if np.isnan(val) else val\n\ndef get_principal_eigen_vector(matrix):\n  _, v = la.eig(matrix)\n  return v[0]\n\ndef construct_correlation_matrix(all_graphs, feature, start, window=7):\n  graphs = all_graphs[start:start+window]\n  vertices = range(len(graphs[0].vs))\n  matrix = []\n  for x in vertices:\n    x_vector = get_feature_vector(graphs, x, feature)\n    covariance_vector = []\n    for y in vertices:\n      y_vector = get_feature_vector(graphs, y, feature)\n      covariance_vector.append(pearson_rho(x_vector, y_vector))\n    matrix.append(covariance_vector)\n  return matrix\n\ndef vector_average(vectors):\n  total = vectors[0]\n  count = 1\n  for vector in vectors[1:]:\n    total = total + vector\n    count += 1\n  return total \/ count\n\ndef construct_correlation_matrices(all_graphs, window=7):\n  feature_info = {}\n  for feature in FEATURES:\n    matrices = []\n    eigens = []\n    for start in range(len(all_graphs)-window):\n      say(\".\")\n      matrix = construct_correlation_matrix(all_graphs, feature, start, window)\n      matrices.append(matrix)\n      eigens.append(get_principal_eigen_vector(matrix))\n    feature_info[feature] = {\n      \"matrices\" : matrices,\n      \"eigens\" : eigens\n    }\n    print(\"%s completed\"%feature)\n  return feature_info\n\ndef compute_eigen_behaviour(feature_info, window=7):\n  eigen_behaviours = {}\n  for feature in FEATURES:\n    eigens =  feature_info[feature][\"eigens\"]\n    eigen_behaviour = []\n    for start in range(len(eigens)-window):\n      u_t = eigens[start+window]\n      r_t1 = vector_average(eigens[start:start+window])\n      eigen_behaviour.append(round(np.dot(u_t, r_t1).real, 2))\n    eigen_behaviours[feature] = eigen_behaviour\n  return eigen_behaviours\n\ndef save_eigen_behaviours(eigen_behaviours, file_name):\n  lines = [\" \".join(FEATURES)+\"\\n\"]\n  vals = []\n  for feature in FEATURES:\n    vals.append(eigen_behaviours[feature])\n  vals = zip(*vals)\n  for line in vals:\n    lines.append(\" \".join(map(str, line))+\"\\n\")\n  with open(file_name, 'w') as f:\n    f.writelines(lines)\n\ndef plot_eigen_behaviours(eigen_behaviours, file_name, window = 7):\n  xs = range(window,len(eigen_behaviours.values()[0])+window)\n  colors = [\"r\", \"g\", \"b\"]\n  f, axis_arr = plt.subplots(3, sharex=True)\n  for i, feature in enumerate(FEATURES):\n    ys = eigen_behaviours[feature]\n    axis_arr[i].plot(xs, ys, \"%s-\"%colors[i])\n    axis_arr[i].set_ylabel(\"Z Score\")\n  plt.xlabel(\"Time\")\n  plt.xlim(0, xs[-1]+2)\n  plt.savefig(file_name)\n  plt.clf()\n\n\n\ndef _main(folder):\n  graphs = []\n  for f in list_files(folder):\n    graphs.append(make_graph(f))\n  print(\"Graphs Processed\")\n  feature_info = construct_correlation_matrices(graphs)\n  eigen_behaviours = compute_eigen_behaviour(feature_info)\n  dataset = folder.split(\"\/\")[-1]\n  ts_file_name = \"%s_time_series.txt\"%dataset\n  ts_png_name = \"%s_time_series.png\"%dataset\n  save_eigen_behaviours(eigen_behaviours, ts_file_name)\n  plot_eigen_behaviours(eigen_behaviours, ts_png_name)\n\n\nif __name__ == \"__main__\":\n  args = sys.argv\n  if len(args) != 2:\n    print(\"USE THE COMMAND : python anomaly.py <data folder>\")\n    exit()\n  folder_name = args[1]\n  _main(folder_name)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_264","text":"<reponame>AndreasMadsen\/bachelor-code\n\nimport urllib.parse as url\nimport http.server\nimport os.path as path\nimport ujson as json\nimport numpy as np\nimport scipy.sparse\n\nimport time\n\nthisdir = path.dirname(path.realpath(__file__))\n\nclass npzToObj:\n    def __init__(self, npz):\n        \"\"\"\n        npz are lazyloaded, this preloads it loads\n        \"\"\"\n        for name in npz.files:\n            setattr(self, name, npz[name])\n\n\nclass GraphServer:\n    def __init__(self, clusters, distance, connectivity, nodes, verbose=False):\n        self._verbose = verbose\n        if (self._verbose): print(\"Initializing graph server\")\n\n        self._clusters = npzToObj(clusters)\n        self._distance = scipy.sparse.csr_matrix(distance)\n        self._connectivity = scipy.sparse.csr_matrix(connectivity)\n        self._raw_nodes = nodes\n        self._nodes = [[node['title'], node['website'], node['id']] for node in nodes]\n\n        # Create a http server\n        if (self._verbose): print(\"\\tCreating http server\")\n        self._server = http.server.HTTPServer(('127.0.0.1', 8000), GraphServer.Responder)\n        self._server._owner = self\n\n    def listen(self):\n        if (self._verbose): print(\"Server listening on http:\/\/127.0.0.1:8000\")\n        self._server.serve_forever()\n\n    def fetch_article(self, id):\n        return self._raw_nodes[id]\n\n    def fetch_compare(self, a, b):\n        return {\n            \"connecitivity\": bool(self._connectivity[min(a, b), max(a, b)]),\n            \"distance\": float(self._distance[min(a, b), max(a, b)])\n        }\n\n    def _groups_from_title(self, search):\n        if (self._verbose): print(\"\\tSearching for \\\"%s\\\"\" % (search))\n        words = search.split()\n\n        # Construct and execute SQL search query\n        match = np.fromiter([\n            np.all([(word in node[0]) for word in words])\n            for node in self._nodes\n        ], dtype='bool')\n\n        # Fetch groups\n        groups = set(int(group) for group in self._clusters.node_to_group[match])\n        if (self._verbose): print(\"\\tSearch complete, found %d groups\" % len(groups))\n\n        return groups\n\n    def _fetch_single_group(self, group_id):\n        if (self._verbose): print(\"\\tFetching group %d\" % group_id)\n\n        # Create node info object\n        nodes = self._clusters.group[group_id, 0:self._clusters.group_size[group_id]]\n        node_info = [self._nodes[id] for id in nodes]\n\n        # Create link info object\n        if (self._verbose): print(\"\\tBuilding link object\")\n        mask = np.any(self._clusters.connects_row[:, np.newaxis] == nodes, axis=1)\n        if (np.sum(mask) == 0):\n            link_info = []\n        else:\n            info = (\n                self._clusters.connects_row[mask],\n                self._clusters.connects_col[mask]\n            )\n\n            link_info = [\n                [int(row), int(col), float(data)]\n                for (row, col, data)\n                in zip(info[0], info[1], self._distance[info].A1)\n            ]\n\n        # Send group info\n        return (node_info, link_info)\n\n    def fetch_graph(self, groups):\n        if (self._verbose): print(\"Fetching groups\")\n\n        # Validate groups\n        max_group_size = int(self._clusters.group.shape[0])\n        for group in groups:\n            if (group >= max_group_size):\n                if (self._verbose): print(\"\\tGroup with id %d do not exists\" % group)\n                return None\n\n        # Initialize info array\n        info = []\n\n        # Fetch group info\n        for group in groups:\n            (node_info, link_info) = self._fetch_single_group(group)\n            info.append({\n                \"group\": group,\n                \"nodes\": node_info,\n                \"links\": link_info\n            })\n\n        # Done return result\n        return info\n\n    class Responder(http.server.BaseHTTPRequestHandler):\n        def __init__(self, *args, **kwargs):\n            self._owner = args[2]._owner\n            self._verbose = self._owner._verbose\n            http.server.BaseHTTPRequestHandler.__init__(self, *args, **kwargs)\n\n        def do_GET(self):\n            if self.path         == '\/'             : self.index_page()\n            elif self.path       == '\/details'      : self.details_page()\n            elif self.path       == '\/d3.js'        : self.d3_script()\n            elif self.path       == '\/view.js'      : self.view_script()\n            elif self.path       == '\/style.css'    : self.style_script()\n            elif self.path[0:11] == '\/graph.json'   : self.graph_data()\n            elif self.path[0:13] == '\/article.json' : self.article_data()\n            elif self.path[0:13] == '\/compare.json' : self.compare_data()\n            else                                    : self.otherwise()\n\n        def index_page(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'text\/html; charset=UTF-8')\n            self.end_headers()\n\n            f = open(path.join(thisdir, 'public', 'index.html'), 'rb')\n            self.wfile.write(f.read())\n            f.close()\n\n        def details_page(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'text\/html; charset=UTF-8')\n            self.end_headers()\n\n            f = open(path.join(thisdir, 'public', 'details.html'), 'rb')\n            self.wfile.write(f.read())\n            f.close()\n\n        def d3_script(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'application\/javascript; charset=UTF-8')\n            self.end_headers()\n\n            f = open(path.join(thisdir, 'public', 'd3.js'), 'rb')\n            self.wfile.write(f.read())\n            f.close()\n\n        def view_script(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'application\/javascript; charset=UTF-8')\n            self.end_headers()\n\n            f = open(path.join(thisdir, 'public', 'view.js'), 'rb')\n            self.wfile.write(f.read())\n            f.close()\n\n        def style_script(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'text\/css; charset=UTF-8')\n            self.end_headers()\n\n            f = open(path.join(thisdir, 'public', 'style.css'), 'rb')\n            self.wfile.write(f.read())\n            f.close()\n\n        def article_data(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'application\/json; charset=UTF-8')\n            self.end_headers()\n\n            query = url.parse_qs(url.urlparse(self.path).query)\n            data = self._owner.fetch_article(int(query['id'][0]))\n            self.wfile.write(bytes(json.dumps(data), 'ASCII'))\n\n        def compare_data(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'application\/json; charset=UTF-8')\n            self.end_headers()\n\n            query = url.parse_qs(url.urlparse(self.path).query)\n            data = self._owner.fetch_compare(int(query['a'][0]), int(query['b'][0]))\n            self.wfile.write(bytes(json.dumps(data), 'ASCII'))\n\n        def graph_data(self):\n            self.send_response(200)\n            self.send_header('Content-Type', 'application\/json; charset=UTF-8')\n            self.end_headers()\n\n            query = url.parse_qs(url.urlparse(self.path).query)\n\n            # Convert input to group list\n            if ('title' in query):\n                groups = self._owner._groups_from_title(query['title'][0])\n            elif ('groups' in query):\n                groups = set(int(group) for group in query['groups'][0].split(\",\"))\n            else:\n                groups = None\n\n            # Fetch nodes and links\n            if (groups is None):\n                data = None\n            else:\n                data = self._owner.fetch_graph(groups)\n\n            # Send data\n            if (data is None):\n                if (self._verbose): print(\"\\tBad query input\")\n                self.wfile.write(bytes('null', 'ASCII'))\n            else:\n                if (self._verbose): print(\"\\tSending result\")\n\n                self.wfile.write(bytes('[', 'ASCII'))\n                for index, group in enumerate(data):\n                    self.wfile.write(bytes('{\"group\":', 'ASCII'))\n                    self.wfile.write(bytes(json.dumps(group['group']), 'ASCII'))\n\n                    self.wfile.write(bytes(', \"nodes\":', 'ASCII'))\n                    self.wfile.write(bytes(json.dumps(group['nodes']), 'ASCII'))\n\n                    self.wfile.write(bytes(', \"links\":', 'ASCII'))\n                    self.wfile.write(bytes(json.dumps(group['links']), 'ASCII'))\n\n                    # Write } if last item otherwise write },\\n\n                    if (index == (len(data) - 1)):\n                        self.wfile.write(bytes('}', 'ASCII'))\n                    else:\n                        self.wfile.write(bytes('},\\n', 'ASCII'))\n                self.wfile.write(bytes(']', 'ASCII'))\n\n                if (self._verbose): print(\"\\tResult send\")\n\n        def otherwise(self):\n            self.send_response(404)\n            self.send_header('Content-Type', 'text\/html; charset=UTF-8')\n            self.end_headers()\n\n            self.wfile.write(bytes('<pre>Sorry invalid path (404)<\/pre>', 'UTF-8'))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_265","text":"<reponame>ACTCollaboration\/mnms\n#!\/usr\/bin\/env python3\nfrom pixell import enmap, utils\nfrom mnms import utils as tnu, mpi\n\nimport numpy as np\nfrom scipy.interpolate import RectBivariateSpline as rectinterp\n\n# Some utilities for calculating effective mode coupling matrices in 2D Fourier space\n# Currently, only supports matrices which are formed as outerproducts of two vectors\n# If want general mode coupling matrices, would need to write a C extension because things\n# won't separate nicely and you'll have to do a full sum\n\ndef get_outer_mask(arr1, arr2=None):\n    arr1 = np.atleast_1d(arr1)\n    if arr2 is None:\n        arr2 = arr1\n    else:\n        arr2 = np.atleast_1d(arr2)\n    assert arr1.ndim == 1 and arr2.ndim == 1 \n    \n    return np.einsum('y,x->yx',arr1,arr2)\n\ndef get_vecs_from_outer_mask(mask):\n    Ny, Nx = mask.shape\n    arr1 = mask[Ny\/\/2]\n    arr2 = mask[:, Nx\/\/2]\n    return arr1, arr2\n\ndef get_1d_kernel(arr1):\n    arr1 = np.atleast_1d(arr1)\n    assert arr1.ndim == 1\n    \n    fnorm = np.abs(np.fft.fft(arr1) \/ arr1.size)**2\n    kernel = np.zeros((fnorm.size, fnorm.size))\n    for i in range(fnorm.size):\n        for j in range(fnorm.size):\n            kernel[i, j] = fnorm[i - j]\n    return kernel\n\ndef get_binned_1d_kernel(kernel, bin_slices):\n    assert kernel.ndim == 2\n    assert kernel.shape[0] == kernel.shape[1]\n\n    nbins = len(bin_slices)\n    nperbin = kernel.shape[0] \/\/ nbins\n    binned_kernel = np.zeros((nbins, nbins))\n    for i in range(nbins):\n        for j in range(nbins):\n            binned_kernel[i, j] = kernel[bin_slices[i], bin_slices[j]].sum() \/ nperbin\n    return binned_kernel\n\ndef get_mcm(arr1, arr2=None, bin_slices1=None, bin_slices2=None):\n    arr1 = np.atleast_1d(arr1)\n    if arr2 is None:\n        square = True\n        assert arr1.ndim == 1\n    else:\n        arr2 = np.atleast_1d(arr2)\n        assert arr1.ndim == 1 and arr2.ndim == 1\n        if np.allclose(arr1, arr2, rtol=0):\n            square = True\n        else:\n            square = False\n    \n    kernel1 = get_1d_kernel(arr1)\n    if bin_slices1 is not None:\n        kernel1 = get_binned_1d_kernel(kernel1, bin_slices1)\n    if square:\n        kernel2 = kernel1\n    else:\n        kernel2 = get_1d_kernel(arr2)\n        if bin_slices2 is not None:\n            kernel2 = get_binned_1d_kernel(kernel2, bin_slices2)\n\n    # kernel1 is M_yy' and kernel2 is M_xx', we want M_yxy'x'\n    return np.einsum('Yy,Xx->YXyx', kernel1, kernel2)\n\ndef get_inv_mcm(arr1, arr2=None, bin_slices1=None, bin_slices2=None, verbose=False):\n    M = get_mcm(arr1, arr2=arr2, bin_slices1=bin_slices1, bin_slices2=bin_slices2)\n    assert M.ndim == 4\n    assert M.shape[0] == M.shape[2] and M.shape[1] == M.shape[3]\n    Ny = M.shape[0]\n    Nx = M.shape[1]\n    M = M.reshape(Ny*Nx, Ny*Nx)\n    if verbose:\n        print(f'Condition number of MCM is {np.round(np.linalg.cond(M), 3)}')\n    M = np.linalg.inv(M)\n    return M.reshape(Ny, Nx, Ny, Nx)\n\ndef get_uniform_bin_slices(arr1, nbins):\n    arr1 = np.atleast_1d(arr1)\n    assert arr1.ndim == 1\n\n    npix = arr1.size\n    counts, displs = mpi.mpi_distribute(npix, nbins)\n    slices = tuple(slice(d, d + counts[i]) for i, d in enumerate(displs))\n    return slices\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_266","text":"<filename>1400OS_09_Codes\/ceps.py\nimport os\nimport glob\n\nimport numpy as np\nimport scipy\nimport scipy.io.wavfile\nfrom librosa.feature import mfcc\n\nfrom utils import GENRE_DIR, CHART_DIR\n\n\ndef write_ceps(ceps, fn):\n    \"\"\"\n    Write the MFCC to separate files to speed up processing.\n    \"\"\"\n    base_fn, ext = os.path.splitext(fn)\n    data_fn = CHART_DIR + \"\/\" + base_fn + \".ceps\"\n    np.save(data_fn, ceps)\n    print(\"Written\", data_fn)\n\n\ndef create_ceps(fn):\n    sample_rate, X = scipy.io.wavfile.read(fn)\n\n    Y = X * 1.0\n\n    # ceps, mspec, spec = mfcc(Y)\n    ceps = mfcc(Y)\n    write_ceps(ceps, fn)\n\n\ndef read_ceps(genre_list, base_dir=GENRE_DIR):\n    X = []\n    y = []\n    for label, genre in enumerate(genre_list):\n        for fn in glob.glob(os.path.join(base_dir, genre, \"*.ceps.npy\")):\n            ceps = np.load(fn)\n            num_ceps = len(ceps)\n            X.append(np.mean(ceps[int(num_ceps \/ 10):int(num_ceps * 9 \/ 10)], axis=0))\n            y.append(label)\n\n    return np.array(X), np.array(y)\n\n\nif __name__ == \"__main__\":\n    # os.chdir(GENRE_DIR)\n    glob_wav = os.path.join(\".\", \"*.wav\")\n    print(glob_wav)\n    for fn in glob.glob(glob_wav):\n        create_ceps(fn)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_267","text":"<reponame>msc-acse\/acse-9-independent-research-project-Wade003\nfrom scipy import *\nfrom pylab import *\nnum_detectors = 100\nx = 0.5+0.25*arange(0,float(num_detectors))\/float(num_detectors)\ny = zeros(num_detectors) + 0.5\n\nt = 0.\nn_cycles = 1\ndt = 0.1\/n_cycles\ntmax = 8\n\ndef vel(x,y):\n    return [-(y-0.5),x-0.5]\n\nwhile(t<tmax):\n    t = t + dt\n    [k1_x,k1_y] = vel(x,y)\n    [k2_x,k2_y] = vel(x+0.5*dt*k1_x,y+0.5*dt*k1_y)\n    [k3_x,k3_y] = vel(x+0.5*dt*k2_x,y+0.5*dt*k2_y)\n    [k4_x,k4_y] = vel(x+dt*k3_x,y+dt*k3_y)\n    x = x + dt*(k1_x\/6.+k2_x\/3. + k3_x\/3. + k4_x\/6.)\n    y = y + dt*(k1_y\/6.+k2_y\/3. + k3_y\/3. + k4_y\/6.)\n\nplot(x,y,'.')\n#show()\n\nx.tofile('Xvals.txt',sep=' ')\ny.tofile('Yvals.txt',sep=' ')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_268","text":"\"\"\"Class for generating pronunciations from G2P models\"\"\"\nfrom __future__ import annotations\n\nimport csv\nimport functools\nimport multiprocessing as mp\nimport os\nimport queue\nimport statistics\nimport time\nfrom typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union\n\nimport tqdm\n\nfrom montreal_forced_aligner.abc import TopLevelMfaWorker\nfrom montreal_forced_aligner.corpus.text_corpus import TextCorpusMixin\nfrom montreal_forced_aligner.exceptions import PyniniGenerationError\nfrom montreal_forced_aligner.g2p.mixins import G2PTopLevelMixin\nfrom montreal_forced_aligner.helper import comma_join, score_g2p\nfrom montreal_forced_aligner.models import G2PModel\nfrom montreal_forced_aligner.utils import Stopped\n\ntry:\n    import pynini\n    from pynini import Fst, SymbolTable, TokenType\n    from pynini.lib import rewrite\n\n    G2P_DISABLED = False\nexcept ImportError:\n    pynini = None\n    TokenType = str\n    Fst = None\n    SymbolTable = None\n    rewrite = None\n    G2P_DISABLED = True\n\nif TYPE_CHECKING:\n    SpeakerCharacterType = Union[str, int]\n\n\n__all__ = [\n    \"Rewriter\",\n    \"RewriterWorker\",\n    \"PyniniGenerator\",\n    \"PyniniCorpusGenerator\",\n    \"PyniniWordListGenerator\",\n]\n\n\ndef threshold_lattice_to_dfa(\n    lattice: pynini.Fst, threshold: float = 1.0, state_multiplier: int = 2\n) -> pynini.Fst:\n    \"\"\"Constructs a (possibly pruned) weighted DFA of output strings.\n    Given an epsilon-free lattice of output strings (such as produced by\n    rewrite_lattice), attempts to determinize it, pruning non-optimal paths if\n    optimal_only is true. This is valid only in a semiring with the path property.\n    To prevent unexpected blowup during determinization, a state threshold is\n    also used and a warning is logged if this exact threshold is reached. The\n    threshold is a multiplier of the size of input lattice (by default, 4), plus\n    a small constant factor. This is intended by a sensible default and is not an\n    inherently meaningful value in and of itself.\n\n    Parameters\n    ----------\n    lattice: :class:`~pynini.Fst`\n        Epsilon-free non-deterministic finite acceptor.\n    threshold: float\n        Threshold for weights, 1.0 is optimal only, 0 is for all paths, greater than 1\n        prunes the lattice to include paths with costs less than the optimal path's score times the threshold\n    state_multiplier: int\n        Max ratio for the number of states in the DFA lattice to the NFA lattice; if exceeded, a warning is logged.\n\n    Returns\n    -------\n    :class:`~pynini.Fst`\n        Epsilon-free deterministic finite acceptor.\n    \"\"\"\n    weight_type = lattice.weight_type()\n    weight_threshold = pynini.Weight(weight_type, threshold)\n    state_threshold = 256 + state_multiplier * lattice.num_states()\n    lattice = pynini.determinize(lattice, nstate=state_threshold, weight=weight_threshold)\n    return lattice\n\n\ndef optimal_rewrites(\n    string: pynini.FstLike,\n    rule: pynini.Fst,\n    input_token_type: Optional[TokenType] = None,\n    output_token_type: Optional[TokenType] = None,\n    threshold: float = 1,\n) -> List[str]:\n    \"\"\"Returns all optimal rewrites.\n    Args:\n    string: Input string or FST.\n    rule: Input rule WFST.\n    input_token_type: Optional input token type, or symbol table.\n    output_token_type: Optional output token type, or symbol table.\n    threshold: Threshold for weights (1 is optimal only, 0 is for all paths)\n    Returns:\n    A tuple of output strings.\n    \"\"\"\n    lattice = rewrite.rewrite_lattice(string, rule, input_token_type)\n    lattice = threshold_lattice_to_dfa(lattice, threshold, 4)\n    return rewrite.lattice_to_strings(lattice, output_token_type)\n\n\nclass Rewriter:\n    \"\"\"\n    Helper object for rewriting\n\n    Parameters\n    ----------\n    fst: pynini.Fst\n        G2P FST model\n    input_token_type: pynini.TokenType\n        Grapheme symbol table or \"utf8\"\n    output_token_type: pynini.SymbolTable\n        Phone symbol table\n    num_pronunciations: int\n        Number of pronunciations, default to 0.  If this is 0, thresholding is used\n    threshold: float\n        Threshold to use for pruning rewrite lattice, defaults to 1.5, only used if num_pronunciations is 0\n    \"\"\"\n\n    def __init__(\n        self,\n        fst: Fst,\n        input_token_type: TokenType,\n        output_token_type: SymbolTable,\n        num_pronunciations: int = 0,\n        threshold: float = 1,\n    ):\n        if num_pronunciations > 0:\n            self.rewrite = functools.partial(\n                rewrite.top_rewrites,\n                nshortest=num_pronunciations,\n                rule=fst,\n                input_token_type=input_token_type,\n                output_token_type=output_token_type,\n            )\n        else:\n            self.rewrite = functools.partial(\n                optimal_rewrites,\n                threshold=threshold,\n                rule=fst,\n                input_token_type=input_token_type,\n                output_token_type=output_token_type,\n            )\n\n    def __call__(self, i: str) -> List[Tuple[str, ...]]:  # pragma: no cover\n        \"\"\"Call the rewrite function\"\"\"\n        hypotheses = self.rewrite(i)\n        return [x for x in hypotheses if x]\n\n\nclass PhonetisaurusRewriter:\n    \"\"\"\n    Helper function for rewriting\n\n    Parameters\n    ----------\n    fst: pynini.Fst\n        G2P FST model\n    input_token_type: pynini.SymbolTable\n        Grapheme symbol table\n    output_token_type: pynini.SymbolTable\n    num_pronunciations: int\n        Number of pronunciations, default to 0.  If this is 0, thresholding is used\n    threshold: float\n        Threshold to use for pruning rewrite lattice, defaults to 1.5, only used if num_pronunciations is 0\n    grapheme_order: int\n        Maximum number of graphemes to consider single segment\n    seq_sep: str\n        Separator to use between grapheme symbols\n    \"\"\"\n\n    def __init__(\n        self,\n        fst: Fst,\n        input_token_type: SymbolTable,\n        output_token_type: SymbolTable,\n        num_pronunciations: int = 0,\n        threshold: float = 1.5,\n        grapheme_order: int = 2,\n        seq_sep: str = \"|\",\n    ):\n        self.fst = fst\n        self.seq_sep = seq_sep\n        self.input_token_type = input_token_type\n        self.output_token_type = output_token_type\n        self.grapheme_order = grapheme_order\n        if num_pronunciations > 0:\n            self.rewrite = functools.partial(\n                rewrite.top_rewrites,\n                nshortest=num_pronunciations,\n                rule=fst,\n                input_token_type=None,\n                output_token_type=output_token_type,\n            )\n        else:\n            self.rewrite = functools.partial(\n                optimal_rewrites,\n                threshold=threshold,\n                rule=fst,\n                input_token_type=None,\n                output_token_type=output_token_type,\n            )\n\n    def __call__(self, graphemes: str) -> List[Tuple[str, ...]]:  # pragma: no cover\n        \"\"\"Call the rewrite function\"\"\"\n        fst = pynini.Fst()\n        one = pynini.Weight.one(fst.weight_type())\n        max_state = 0\n        for i in range(len(graphemes)):\n            start_state = fst.add_state()\n            for j in range(1, self.grapheme_order + 1):\n                if i + j <= len(graphemes):\n                    substring = self.seq_sep.join(graphemes[i : i + j])\n                    state = self.input_token_type.find(substring)\n                    if state != pynini.NO_SYMBOL:\n                        fst.add_arc(start_state, pynini.Arc(state, state, one, i + j))\n                    if i + j >= max_state:\n                        max_state = i + j\n        for _ in range(fst.num_states(), max_state + 1):\n            fst.add_state()\n        fst.set_start(0)\n        fst.set_final(len(graphemes), one)\n        fst.set_input_symbols(self.input_token_type)\n        fst.set_output_symbols(self.input_token_type)\n        hypotheses = self.rewrite(fst)\n        hypotheses = [x.replace(self.seq_sep, \" \") for x in hypotheses if x]\n        return hypotheses\n\n\nclass RewriterWorker(mp.Process):\n    \"\"\"\n    Rewriter process\n\n    Parameters\n    ----------\n    job_queue: :class:`~multiprocessing.Queue`\n        Queue to pull words from\n    return_queue: :class:`~multiprocessing.Queue`\n        Queue to put pronunciations\n    rewriter: :class:`~montreal_forced_aligner.g2p.generator.Rewriter`\n        Function to generate pronunciations of words\n    stopped: :class:`~montreal_forced_aligner.utils.Stopped`\n        Stop check\n    \"\"\"\n\n    def __init__(\n        self,\n        job_queue: mp.Queue,\n        return_queue: mp.Queue,\n        rewriter: Rewriter,\n        stopped: Stopped,\n    ):\n        mp.Process.__init__(self)\n        self.job_queue = job_queue\n        self.return_queue = return_queue\n        self.rewriter = rewriter\n        self.stopped = stopped\n        self.finished = Stopped()\n\n    def run(self) -> None:\n        \"\"\"Run the rewriting function\"\"\"\n        while True:\n            try:\n                word = self.job_queue.get(timeout=1)\n            except queue.Empty:\n                break\n            if self.stopped.stop_check():\n                continue\n            try:\n                rep = self.rewriter(word)\n                self.return_queue.put((word, rep))\n            except rewrite.Error:\n                pass\n            except Exception as e:  # noqa\n                self.stopped.stop()\n                self.return_queue.put(e)\n                raise\n        self.finished.stop()\n        return\n\n\ndef clean_up_word(word: str, graphemes: Set[str]) -> Tuple[str, Set[str]]:\n    \"\"\"\n    Clean up word by removing graphemes not in a specified set\n\n    Parameters\n    ----------\n    word : str\n        Input string\n    graphemes: set[str]\n        Set of allowable graphemes\n\n    Returns\n    -------\n    str\n        Cleaned up word\n    Set[str]\n        Graphemes excluded\n    \"\"\"\n    new_word = []\n    missing_graphemes = set()\n    for c in word:\n        if c not in graphemes:\n            missing_graphemes.add(c)\n        else:\n            new_word.append(c)\n    return \"\".join(new_word), missing_graphemes\n\n\nclass OrthographyGenerator(G2PTopLevelMixin):\n    \"\"\"\n    Abstract mixin class for generating \"pronunciations\" based off the orthographic word\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.mixins.G2PTopLevelMixin`\n        For top level G2P generation parameters\n    \"\"\"\n\n    def generate_pronunciations(self) -> Dict[str, List[str]]:\n        \"\"\"\n        Generate pronunciations for the word set\n\n        Returns\n        -------\n        dict[str, Word]\n            Mapping of words to their \"pronunciation\"\n        \"\"\"\n        pronunciations = {}\n        for word in self.words_to_g2p:\n            pronunciations[word] = [\" \".join(word)]\n        return pronunciations\n\n\nclass PyniniGenerator(G2PTopLevelMixin):\n    \"\"\"\n    Class for generating pronunciations from a Pynini G2P model\n\n    Parameters\n    ----------\n    g2p_model_path: str\n        Path to G2P model\n    strict_graphemes: bool\n        Flag for whether to be strict with missing graphemes and skip words containing new graphemes\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.mixins.G2PTopLevelMixin`\n        For top level G2P generation parameters\n\n    Attributes\n    ----------\n    g2p_model: G2PModel\n        G2P model\n    \"\"\"\n\n    def __init__(self, g2p_model_path: str, strict_graphemes: bool = False, **kwargs):\n        self.strict_graphemes = strict_graphemes\n        super().__init__(**kwargs)\n        self.g2p_model = G2PModel(\n            g2p_model_path, root_directory=getattr(self, \"workflow_directory\", None)\n        )\n\n    def generate_pronunciations(self) -> Dict[str, List[str]]:\n        \"\"\"\n        Generate pronunciations\n\n        Returns\n        -------\n        dict[str, list[str]]\n            Mappings of keys to their generated pronunciations\n        \"\"\"\n\n        fst = pynini.Fst.read(self.g2p_model.fst_path)\n        if self.g2p_model.meta[\"architecture\"] == \"phonetisaurus\":\n            output_token_type = pynini.SymbolTable.read_text(self.g2p_model.sym_path)\n            input_token_type = pynini.SymbolTable.read_text(self.g2p_model.grapheme_sym_path)\n            fst.set_input_symbols(input_token_type)\n            fst.set_output_symbols(output_token_type)\n            rewriter = PhonetisaurusRewriter(\n                fst,\n                input_token_type,\n                output_token_type,\n                num_pronunciations=self.num_pronunciations,\n                threshold=self.g2p_threshold,\n            )\n        else:\n            output_token_type = \"utf8\"\n            input_token_type = \"utf8\"\n            if self.g2p_model.sym_path is not None and os.path.exists(self.g2p_model.sym_path):\n                output_token_type = pynini.SymbolTable.read_text(self.g2p_model.sym_path)\n            rewriter = Rewriter(\n                fst,\n                input_token_type,\n                output_token_type,\n                num_pronunciations=self.num_pronunciations,\n                threshold=self.g2p_threshold,\n            )\n\n        num_words = len(self.words_to_g2p)\n        begin = time.time()\n        missing_graphemes = set()\n        self.log_info(\"Generating pronunciations...\")\n        to_return = {}\n        skipped_words = 0\n        if num_words < 30 or self.num_jobs == 1:\n            with tqdm.tqdm(total=num_words, disable=getattr(self, \"quiet\", False)) as pbar:\n                for word in self.words_to_g2p:\n                    w, m = clean_up_word(word, self.g2p_model.meta[\"graphemes\"])\n                    pbar.update(1)\n                    missing_graphemes = missing_graphemes | m\n                    if self.strict_graphemes and m:\n                        skipped_words += 1\n                        continue\n                    if not w:\n                        skipped_words += 1\n                        continue\n                    try:\n                        prons = rewriter(w)\n                    except rewrite.Error:\n                        continue\n                    to_return[word] = prons\n                self.log_debug(\n                    f\"Skipping {skipped_words} words for containing the following graphemes: \"\n                    f\"{comma_join(sorted(missing_graphemes))}\"\n                )\n        else:\n            stopped = Stopped()\n            job_queue = mp.Queue()\n            for word in self.words_to_g2p:\n                w, m = clean_up_word(word, self.g2p_model.meta[\"graphemes\"])\n                missing_graphemes = missing_graphemes | m\n                if self.strict_graphemes and m:\n                    skipped_words += 1\n                    continue\n                if not w:\n                    skipped_words += 1\n                    continue\n                job_queue.put(w)\n            self.log_debug(\n                f\"Skipping {skipped_words} words for containing the following graphemes: \"\n                f\"{comma_join(sorted(missing_graphemes))}\"\n            )\n            error_dict = {}\n            return_queue = mp.Queue()\n            procs = []\n            for _ in range(self.num_jobs):\n                p = RewriterWorker(\n                    job_queue,\n                    return_queue,\n                    rewriter,\n                    stopped,\n                )\n                procs.append(p)\n                p.start()\n            num_words -= skipped_words\n            with tqdm.tqdm(total=num_words, disable=getattr(self, \"quiet\", False)) as pbar:\n                while True:\n                    try:\n                        word, result = return_queue.get(timeout=1)\n                        if stopped.stop_check():\n                            continue\n                    except queue.Empty:\n                        for proc in procs:\n                            if not proc.finished.stop_check():\n                                break\n                        else:\n                            break\n                        continue\n                    pbar.update(1)\n                    if isinstance(result, Exception):\n                        error_dict[word] = result\n                        continue\n                    to_return[word] = result\n\n            for p in procs:\n                p.join()\n            if error_dict:\n                raise PyniniGenerationError(error_dict)\n        self.log_debug(f\"Processed {num_words} in {time.time() - begin} seconds\")\n        return to_return\n\n\nclass PyniniValidator(PyniniGenerator, TopLevelMfaWorker):\n    \"\"\"\n    Class for running validation for G2P model training\n\n    Parameters\n    ----------\n    word_list: list[str]\n        List of words to generate pronunciations\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.generator.PyniniGenerator`\n        For parameters to generate pronunciations\n    \"\"\"\n\n    def __init__(self, word_list: List[str] = None, **kwargs):\n        super().__init__(**kwargs)\n        if word_list is None:\n            word_list = []\n        self.word_list = word_list\n\n    @property\n    def words_to_g2p(self) -> List[str]:\n        \"\"\"Words to produce pronunciations\"\"\"\n        return self.word_list\n\n    @property\n    def data_source_identifier(self) -> str:\n        \"\"\"Dummy \"validation\" data source\"\"\"\n        return \"validation\"\n\n    @property\n    def data_directory(self) -> str:\n        \"\"\"Data directory\"\"\"\n        return self.working_directory\n\n    @property\n    def evaluation_csv_path(self) -> str:\n        \"\"\"Path to working directory's CSV file\"\"\"\n        return os.path.join(self.working_directory, \"pronunciation_evaluation.csv\")\n\n    def setup(self) -> None:\n        \"\"\"Set up the G2P validator\"\"\"\n        if self.initialized:\n            return\n        self.g2p_model.validate(self.words_to_g2p)\n        self.initialized = True\n        self.wer = None\n        self.ler = None\n\n    def compute_validation_errors(\n        self,\n        gold_values: Dict[str, Set[str]],\n        hypothesis_values: Dict[str, List[str]],\n    ):\n        \"\"\"\n        Computes validation errors\n\n        Parameters\n        ----------\n        gold_values: dict[str, set[str]]\n            Gold pronunciations\n        hypothesis_values: dict[str, list[str]]\n            Hypothesis pronunciations\n        \"\"\"\n        begin = time.time()\n        # Word-level measures.\n        correct = 0\n        incorrect = 0\n        # Label-level measures.\n        total_edits = 0\n        total_length = 0\n        # Since the edit distance algorithm is quadratic, let's do this with\n        # multiprocessing.\n        self.log_debug(f\"Processing results for {len(hypothesis_values)} hypotheses\")\n        to_comp = []\n        indices = []\n        hyp_pron_count = 0\n        gold_pron_count = 0\n        output = []\n        for word, gold_pronunciations in gold_values.items():\n            if word not in hypothesis_values:\n                incorrect += 1\n                gold_length = statistics.mean(len(x.split()) for x in gold_pronunciations)\n                total_edits += gold_length\n                total_length += gold_length\n                output.append(\n                    {\n                        \"Word\": word,\n                        \"Gold pronunciations\": \", \".join(gold_pronunciations),\n                        \"Hypothesis pronunciations\": \"\",\n                        \"Accuracy\": 0,\n                        \"Error rate\": 1.0,\n                        \"Length\": gold_length,\n                    }\n                )\n                continue\n            hyp = hypothesis_values[word]\n            for h in hyp:\n                if h in gold_pronunciations:\n                    correct += 1\n                    total_length += len(h)\n                    output.append(\n                        {\n                            \"Word\": word,\n                            \"Gold pronunciations\": \", \".join(gold_pronunciations),\n                            \"Hypothesis pronunciations\": \", \".join(hyp),\n                            \"Accuracy\": 1,\n                            \"Error rate\": 0.0,\n                            \"Length\": len(h),\n                        }\n                    )\n                    break\n            else:\n                incorrect += 1\n                indices.append(word)\n                to_comp.append((gold_pronunciations, hyp))  # Multiple hypotheses to compare\n            self.log_debug(\n                f\"For the word {word}: gold is {gold_pronunciations}, hypothesized are: {hyp}\"\n            )\n            hyp_pron_count += len(hyp)\n            gold_pron_count += len(gold_pronunciations)\n        self.log_debug(\n            f\"Generated an average of {hyp_pron_count \/len(hypothesis_values)} variants \"\n            f\"The gold set had an average of {gold_pron_count\/len(hypothesis_values)} variants.\"\n        )\n        with mp.Pool(self.num_jobs) as pool:\n            gen = pool.starmap(score_g2p, to_comp)\n            for i, (edits, length) in enumerate(gen):\n                word = indices[i]\n                gold_pronunciations = gold_values[word]\n                hyp = hypothesis_values[word]\n                output.append(\n                    {\n                        \"Word\": word,\n                        \"Gold pronunciations\": \", \".join(gold_pronunciations),\n                        \"Hypothesis pronunciations\": \", \".join(hyp),\n                        \"Accuracy\": 1,\n                        \"Error rate\": edits \/ length,\n                        \"Length\": length,\n                    }\n                )\n                total_edits += edits\n                total_length += length\n        with open(self.evaluation_csv_path, \"w\", encoding=\"utf8\", newline=\"\") as f:\n            writer = csv.DictWriter(\n                f,\n                fieldnames=[\n                    \"Word\",\n                    \"Gold pronunciations\",\n                    \"Hypothesis pronunciations\",\n                    \"Accuracy\",\n                    \"Error rate\",\n                    \"Length\",\n                ],\n            )\n            writer.writeheader()\n            for line in output:\n                writer.writerow(line)\n        self.wer = 100 * incorrect \/ (correct + incorrect)\n        self.ler = 100 * total_edits \/ total_length\n        self.log_info(f\"WER:\\t{self.wer:.2f}\")\n        self.log_info(f\"LER:\\t{self.ler:.2f}\")\n        self.log_debug(\n            f\"Computation of errors for {len(gold_values)} words took {time.time() - begin} seconds\"\n        )\n\n    def evaluate_g2p_model(self, gold_pronunciations: Dict[str, Set[str]]) -> None:\n        \"\"\"\n        Evaluate a G2P model on the word list\n\n        Parameters\n        ----------\n        gold_pronunciations: dict[str, set[str]]\n            Gold pronunciations\n        \"\"\"\n        output = self.generate_pronunciations()\n        self.compute_validation_errors(gold_pronunciations, output)\n\n\nclass PyniniWordListGenerator(PyniniValidator):\n    \"\"\"\n    Top-level worker for generating pronunciations from a word list and a Pynini G2P model\n\n    Parameters\n    ----------\n    word_list_path: str\n        Path to word list file\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.generator.PyniniGenerator`\n        For Pynini G2P generation parameters\n    :class:`~montreal_forced_aligner.abc.TopLevelMfaWorker`\n        For top-level parameters\n\n    Attributes\n    ----------\n    word_list: list[str]\n        Word list to generate pronunciations\n    \"\"\"\n\n    def __init__(self, word_list_path: str, **kwargs):\n        self.word_list_path = word_list_path\n        super().__init__(**kwargs)\n\n    @property\n    def data_directory(self) -> str:\n        \"\"\"Data directory\"\"\"\n        return self.working_directory\n\n    @property\n    def data_source_identifier(self) -> str:\n        \"\"\"Name of the word list file\"\"\"\n        return os.path.splitext(os.path.basename(self.word_list_path))[0]\n\n    def setup(self) -> None:\n        \"\"\"Set up the G2P generator\"\"\"\n        if self.initialized:\n            return\n        with open(self.word_list_path, \"r\", encoding=\"utf8\") as f:\n            for line in f:\n                self.word_list.extend(line.strip().split())\n        if not self.include_bracketed:\n            self.word_list = [x for x in self.word_list if not self.check_bracketed(x)]\n        self.g2p_model.validate(self.words_to_g2p)\n        self.initialized = True\n\n\nclass PyniniCorpusGenerator(PyniniGenerator, TextCorpusMixin, TopLevelMfaWorker):\n    \"\"\"\n    Top-level worker for generating pronunciations from a corpus and a Pynini G2P model\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.generator.PyniniGenerator`\n        For Pynini G2P generation parameters\n    :class:`~montreal_forced_aligner.corpus.text_corpus.TextCorpusMixin`\n        For corpus parsing parameters\n    :class:`~montreal_forced_aligner.abc.TopLevelMfaWorker`\n        For top-level parameters\n    \"\"\"\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n    def setup(self) -> None:\n        \"\"\"Set up the pronunciation generator\"\"\"\n        if self.initialized:\n            return\n        self._load_corpus()\n        self.calculate_word_counts()\n        self.g2p_model.validate(self.words_to_g2p)\n        self.initialized = True\n\n    @property\n    def words_to_g2p(self) -> List[str]:\n        \"\"\"Words to produce pronunciations\"\"\"\n        word_list = self.corpus_word_set\n        if not self.include_bracketed:\n            word_list = [x for x in word_list if not self.check_bracketed(x)]\n        return word_list\n\n\nclass OrthographicCorpusGenerator(OrthographyGenerator, TextCorpusMixin, TopLevelMfaWorker):\n    \"\"\"\n    Top-level class for generating \"pronunciations\" from the orthography of a corpus\n\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.generator.OrthographyGenerator`\n        For orthography-based G2P generation parameters\n    :class:`~montreal_forced_aligner.corpus.text_corpus.TextCorpusMixin`\n        For corpus parsing parameters\n    :class:`~montreal_forced_aligner.abc.TopLevelMfaWorker`\n        For top-level parameters\n    \"\"\"\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n    def setup(self) -> None:\n        \"\"\"Set up the pronunciation generator\"\"\"\n        if self.initialized:\n            return\n        self._load_corpus()\n        self.calculate_word_counts()\n        self.initialized = True\n\n    @property\n    def words_to_g2p(self) -> List[str]:\n        \"\"\"Words to produce pronunciations\"\"\"\n        word_list = self.corpus_word_set\n        if not self.include_bracketed:\n            word_list = [x for x in word_list if not self.check_bracketed(x)]\n        return word_list\n\n\nclass OrthographicWordListGenerator(OrthographyGenerator, TopLevelMfaWorker):\n    \"\"\"\n    Top-level class for generating \"pronunciations\" from the orthography of a corpus\n\n    Parameters\n    ----------\n    word_list_path: str\n        Path to word list file\n    See Also\n    --------\n    :class:`~montreal_forced_aligner.g2p.generator.OrthographyGenerator`\n        For orthography-based G2P generation parameters\n    :class:`~montreal_forced_aligner.abc.TopLevelMfaWorker`\n        For top-level parameters\n\n    Attributes\n    ----------\n    word_list: list[str]\n        Word list to generate pronunciations\n    \"\"\"\n\n    def __init__(self, word_list_path: str, **kwargs):\n        super().__init__(**kwargs)\n        self.word_list_path = word_list_path\n        self.word_list = []\n\n    def setup(self) -> None:\n        \"\"\"Set up the pronunciation generator\"\"\"\n        if self.initialized:\n            return\n        with open(self.word_list_path, \"r\", encoding=\"utf8\") as f:\n            for line in f:\n                self.word_list.extend(line.strip().split())\n        if not self.include_bracketed:\n            self.word_list = [x for x in self.word_list if not self.check_bracketed(x)]\n        self.initialized = True\n\n    @property\n    def words_to_g2p(self) -> List[str]:\n        \"\"\"Words to produce pronunciations\"\"\"\n        return self.word_list\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_269","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\nimport re\n\nfrom Commands.Keys import Button, Direction, Hat\nfrom Commands.PythonCommandBase import PythonCommand\n# import numpy as np\nfrom scipy.sparse.csgraph import shortest_path  # , floyd_warshall, dijkstra, bellman_ford, johnson\nfrom scipy.sparse import csr_matrix\n\nserial = {0: '-1',\n          1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '0', 11: '@', 12: 'BS',\n          13: 'Q', 14: 'W', 15: 'E', 16: 'R', 17: 'T', 18: 'Y', 19: 'U', 20: 'I', 21: 'O', 22: 'P', 23: '=',\n          24: 'A', 25: 'S', 26: 'D', 27: 'F', 28: 'G', 29: 'H', 30: 'J', 31: 'K', 32: 'L', 33: '&', 34: ';',\n          35: 'Z', 36: 'X', 37: 'C', 38: 'V', 39: 'B', 40: 'N', 41: 'M', 42: '*', 43: '#', 44: '!', 45: '?',\n          46: 'SelectKeyboard', 47: 'Shift', 48: '#+=', 49: 'nl_1', 50: 'nl_2', 51: 'nl_3',\n          52: 'ok_1', 53: 'ok_2', 54: 'ok_3', 55: 'blank_1', 56: 'blank_2', 57: 'blank_3', 58: 'blank_4',\n          59: 'blank_5', 60: 'blank_6', 61: 'blank_7', 62: 'blank_8', }\nserial_inv = {v: k for k, v in serial.items()}\nserial_graph_list = [[],\n                     # 1-5\n                     [2, 13, 12], [1, 3, 14], [2, 4, 15], [3, 5, 16], [4, 6, 17],\n                     # 6-10\n                     [5, 7, 18], [6, 8, 19], [7, 9, 20], [8, 10, 21], [9, 11, 22],\n                     # 11-15 @ ~ E\n                     [10, 12, 23], [11, 49, 1], [1, 24, 14, 49], [2, 13, 15, 25], [3, 14, 16, 26],\n                     # 16-20 R ~ I\n                     [4, 15, 17, 27], [5, 16, 18, 28], [6, 17, 19, 29], [7, 18, 20, 30], [8, 19, 21, 31],\n                     # 21-25 O ~ S\n                     [9, 20, 22, 32], [10, 21, 23, 33], [11, 22, 34, 49], [13, 25, 35, 50], [14, 24, 26, 36],\n                     # 26-30 D ~ J\n                     [15, 25, 27, 37], [16, 26, 28, 38], [17, 27, 29, 39], [18, 28, 30, 40], [19, 29, 31, 41],\n                     # 31-35 J ~ Z\n                     [20, 30, 32, 42], [21, 31, 33, 43], [22, 32, 34, 44], [23, 33, 45, 50], [24, 46, 36, 53],\n                     # 36-40 X ~ N\n                     [25, 35, 37, 47], [26, 36, 38, 48], [27, 37, 39, 55], [28, 38, 40, 56], [29, 39, 41, 57],\n                     # 41-45 M ~ ?\n                     [30, 40, 42, 58], [31, 41, 43, 59], [32, 42, 44, 60], [33, 43, 45, 61], [34, 44, 62, 53],\n                     # 46-50\n                     [35, 47, 54], [36, 46, 48], [37, 47, 55], [12, 23, 13, 52], [12, 34, 24, 53],\n                     # 51-56\n                     [12, 34, 24, 54], [49, 45, 35], [45, 35, 50], [55, 46, 51], [38, 48, 54], [39, 48, 54],\n                     # 57-62\n                     [40, 48, 54], [41, 48, 54], [42, 48, 54], [43, 48, 54], [44, 48, 54], [45, 48, 54]]\n\n\nclass InputKeyboard(PythonCommand):\n    NAME = 'シリアル入力'\n\n    def __init__(self):\n        super().__init__()\n        self.s = 'F105LP98GMFCB3RA'  # 入力したい文字列\n        self.now_dict = serial_graph_list\n        self.now_dict_ = serial\n        self.now_dict_inv = serial_inv\n        self.graph = None\n        self.d = None\n        self.p = None\n        self.n = None\n        self.MakeGraph()\n        self.pos = 1  # 初期位置\n\n    def MakeGraph(self):\n        self.n = len(self.now_dict)\n        self.graph = [[0] * self.n for _ in range(self.n)]  # 隣接行列\n        for i, g_i in enumerate(self.now_dict):\n            for j in g_i:\n                self.graph[i][j] = 1\n        # for i in self.graph:\n        # print(\" \".join(list(map(str, i))))\n\n        a = csr_matrix(self.graph)\n        self.d, self.p = shortest_path(a, return_predecessors=True)\n\n    def do(self):\n        input_char = 0\n        for i in self.s:\n            print(self.now_dict_[self.now_dict_inv[i]])\n            t = GetPath(self.pos, self.now_dict_inv[i], self.p)\n            print(t)\n            stick = False\n            stick = self.Move(t, stick)\n            if not stick:\n                self.press(Button.A, wait=0.03, duration=0.05)\n            input_char += 1\n\n    def Move(self, t, stick):  # 移動のための関数\n        for j in range(len(t) - 1):\n            if t[j + 1] == 1 and t[j] == 12:\n                self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n            if t[j + 1] == 12:\n                if t[j] in [49, 50, 51]:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n                elif t[j] == 1:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 11:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n            elif t[j + 1] == 13:  # Q\n                if t[j] == 49:\n                    self.press(Direction.RIGHT, wait=0.1, duration=0.05)\n                elif t[j] == 1:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] == 14:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 24:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 23:  # =\n                if t[j] == 22:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 11:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] == 49:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 34:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 24:  # A\n                if t[j] in [50, 51]:\n                    self.press(Direction.RIGHT, wait=0.1, duration=0.05)\n                elif t[j] == 13:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] == 25:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 35:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 34:  # ;\n                if t[j] == 33:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 23:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] in [50, 51]:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 45:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 35:  # Z\n                if t[j] in [52, 53]:\n                    self.press(Direction.RIGHT, wait=0.1, duration=0.05)\n                elif t[j] == 24:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] == 36:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 46:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] in [38, 39, 40, 41, 42, 43, 44] and t[j + 1] - t[j] == -17:  # Z\n                self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 45:  # ?\n                if t[j] == 44:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 34:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] in [52, 53]:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 62:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 48 and t[j] in [55, 56, 57, 58, 59, 60, 61, 62]:\n                self.press(Direction.LEFT, wait=0.03, duration=0.05)\n\n            elif t[j + 1] == 49:\n                if t[j] == 12:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n                elif t[j] == 23:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 13:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 52:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 50:\n                if t[j] == 34:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 24:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 53:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 51:\n                if t[j] == 54:\n                    self.press(Direction.UP, wait=0.03, duration=0.05)\n            elif t[j + 1] == 52:\n                if t[j] == 49:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] == 53:\n                if t[j] == 45:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 35:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 50:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] == 54:\n                if t[j] in [55, 56, 57, 58, 59, 60, 61, 62]:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 46:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 51:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] == 55:\n                if t[j] == 48:\n                    self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n                elif t[j] == 54:\n                    self.press(Direction.LEFT, wait=0.03, duration=0.05)\n                elif t[j] == 38:\n                    self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] in [56, 57, 58, 59, 60, 61, 62] and t[j + 1] - t[j] == 17:\n                self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] - t[j] == 1:\n                self.press(Direction.RIGHT, wait=0.03, duration=0.05)\n            elif t[j + 1] - t[j] == -1:\n                self.press(Direction.LEFT, wait=0.03, duration=0.05)\n            elif t[j + 1] - t[j] in [11, 12]:\n                self.press(Direction.DOWN, wait=0.03, duration=0.05)\n            elif t[j + 1] - t[j] in [-11, -12]:\n                self.press(Direction.UP, wait=0.03, duration=0.05)\n            if t[j + 1] not in list(range(67, self.n)):\n                self.pos = self.now_dict_inv[self.now_dict_[t[j + 1]]]\n        return stick\n\n\ndef GetPath(start, goal, pred):\n    return GetPathRow(start, goal, pred[start])\n\n\ndef GetPathRow(start, goal, pred_row):\n    path = []\n    i = goal\n    while i != start and i >= 0:\n        path.append(i)\n        i = pred_row[i]\n    if i < 0:\n        return []\n    path.append(i)\n    return path[::-1]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_270","text":"<filename>filter_and_merge_reads.py\nimport pysam\nimport sys\nimport os\nimport re\nimport argparse\nimport statistics\n\nparser=argparse.ArgumentParser()\nparser.add_argument(\"-f\",\"--file_in\",help=\"Input bam file name\", required=True)\nparser.add_argument(\"-o\",\"--file_out\",help=\"Output sam file name\", required=True)\nparser.add_argument(\"-c\",\"--overcovered_regions\",help=\"File with overcovered regions\")\n\nargs=parser.parse_args()\n\nraw_bam_file_name=args.file_in\ncollapsed_sam_file_name=args.file_out\n\novercovered_starts_dict={}\novercovered_ends_dict={}\nif args.overcovered_regions:\n    overcovered_file=open(args.overcovered_regions,'rt')\n    for line in overcovered_file:\n        overcovered_chr,overcovered_start,overcovered_end=line.split()\n        if overcovered_chr in overcovered_starts_dict:\n            overcovered_starts_dict[overcovered_chr].append(int(overcovered_start))\n            overcovered_ends_dict[overcovered_chr].append(int(overcovered_end))\n        else:\n            overcovered_starts_dict[overcovered_chr]=[int(overcovered_start),]\n            overcovered_ends_dict[overcovered_chr]=[int(overcovered_end),]\n\nsamfile=pysam.AlignmentFile(raw_bam_file_name, \"rb\")\ncollapsed_samfile=pysam.AlignmentFile(collapsed_sam_file_name, \"wb\", template=samfile)\ncurrent_read_name=\"\"\nreads_with_same_name=list()\n\ntlen_vect = []\ndef process_reads_with_same_name(reads_with_same_name, overcovered_starts_dict, overcovered_ends_dict):\n    read1=\"\"\n    read2=\"\"\n    global tlen_vect\n    \n    for same_read in reads_with_same_name:\n        #check if this is a primary read\n        if not same_read.is_secondary:\n            if same_read.is_read1:\n                if not read1:\n                    read1=same_read\n                else:\n                    #this read is probably split aligned\n                    return(\"Split-aligned R1 or R2\")\n            elif same_read.is_read2:\n                if not read2:\n                    read2=same_read\n                else:\n                    return(\"Split-aligned R1 or R2\")\n            else:\n                print(\"Strange: this is not read1 or read2\\n\")\n                print(same_read.tostring())\n\n    if not(read1 and read2):\n        return(\"No R1 or R2\")\n    elif (read1.mapping_quality<60 or read2.mapping_quality<60):\n        if (abs(read1.template_length)==abs(read2.template_length)):\n            tlen_vect.append(abs(read1.template_length))\n        return(\"R1 or R2 mapping quality lower than 60\")\n    elif (re.search('S',read1.cigarstring) or re.search('S',read2.cigarstring)):\n        return(\"Soft-clipped bases in R1 or R2\")\n    elif (read1.is_reverse and read2.is_reverse):\n        return(\"Both reads have reverse orientation\")\n    elif ((not read1.is_reverse) and (not read2.is_reverse)):\n        return(\"Both reads have forward orientation\")\n    elif (read1.template_length>1000 or read1.template_length<-1000):\n        return(\"Template length longer than 1000 bp\")\n    elif (read1.template_length==0 or read2.template_length==0):\n        return(\"Template length 0\")\n    elif (not read1.is_proper_pair or not read2.is_proper_pair):\n        return(\"R1 and R2 are not a proper pair\")\n    else:\n        if str(read1.reference_name)==str(read2.reference_name):\n            chrom=str(read1.reference_name)\n            if (abs(read1.template_length)==abs(read2.template_length)):\n                tlen_vect.append(abs(read1.template_length))\n        else:\n            return(\"R1 and R2 are not a proper pair\")\n        if read1.reference_start and read1.reference_end and read2.reference_start and read2.reference_end:\n            positions_list=[read1.reference_start,read1.reference_end,read2.reference_start,read2.reference_end]\n        else:\n            return(\"R1 and R2 are not a proper pair\")\n        pos_start=min(positions_list)\n        pos_end=max(positions_list)\n        in_overcovered=0\n        if chrom in overcovered_starts_dict:\n            for i in range(0,len(overcovered_starts_dict[chrom])):\n                if pos_start>overcovered_ends_dict[chrom][i]:\n                    i+=1\n                    continue\n                elif pos_end<overcovered_starts_dict[chrom][i]:\n                    break\n                elif pos_start<overcovered_starts_dict[chrom][i] and \\\n                    pos_end>=overcovered_starts_dict[chrom][i]:\n                    in_overcovered=1\n                    break\n                elif pos_start>=overcovered_starts_dict[chrom][i] and \\\n                    pos_start<=overcovered_ends_dict[chrom][i]:\n                    in_overcovered=1\n                    break\n        if in_overcovered:\n            return(\"Within overcovered region\")\n        elif not read1.is_reverse:\n            read1.tags += [('rr', '\"'+read2.tostring()+'\"')]\n            read1.tags += [('re', read2.reference_end)]\n            collapsed_samfile.write(read1)\n            return(\"Reads passed\")\n        else:\n            read2.tags += [('rr', '\"'+read1.tostring()+'\"')]\n            read2.tags += [('re', read1.reference_end)]\n            collapsed_samfile.write(read2)\n            return(\"Reads passed\")\n\nnumber_of_reads=0\n\nread_dict={\"Split-aligned R1 or R2\":0,\n           \"No R1 or R2\":0,\n           \"R1 or R2 mapping quality lower than 60\":0,\n           \"Soft-clipped bases in R1 or R2\":0,\n           \"Both reads have reverse orientation\":0,\n           \"Both reads have forward orientation\":0,\n           \"Template length longer than 1000 bp\":0,\n           \"Template length 0\":0,\n           \"R1 and R2 are not a proper pair\":0,\n           \"Within overcovered region\":0,\n           \"Reads passed\":0}\n\nfor read in samfile.fetch(until_eof=True):\n    if not current_read_name:\n        current_read_name=read.query_name\n        continue\n    else:\n        if read.query_name==current_read_name:\n            reads_with_same_name.append(read)\n            continue\n        else:\n            number_of_reads+=1\n            res=process_reads_with_same_name(reads_with_same_name, overcovered_starts_dict, overcovered_ends_dict)\n            read_dict[res]+=1\n            current_read_name=read.query_name\n            reads_with_same_name=[read,]\nelse:\n    number_of_reads+=1\n    res=process_reads_with_same_name(reads_with_same_name, overcovered_starts_dict, overcovered_ends_dict)\n    read_dict[res]+=1\n            \nprint(\"Overall number of reads or clusters in bam file\")\nprint(number_of_reads)\n\nfor each_reason in read_dict.keys():\n    print(each_reason,\": \",read_dict[each_reason])\n\nprint(\"Median template length: \",statistics.median(tlen_vect))\nsamfile.close()\ncollapsed_samfile.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_271","text":"from typing import Optional\n\nimport numpy\nfrom scipy.sparse import csr_matrix\nfrom scipy.special import expit\nfrom tqdm.auto import trange, tqdm\n\nfrom .matrix_factorization_base import MatrixFactorizationBase\n\n\nclass BPR(MatrixFactorizationBase):\n    def __init__(\n        self,\n        factors: int,\n        lr: float,\n        steps: int,\n        reg_lambda: float = 0.0,\n        random_state: Optional[int] = None,\n    ):\n        super().__init__(factors, random_state)\n        self.__lr = lr\n        self.__steps = steps\n        self.__lambda = reg_lambda\n\n    @staticmethod\n    def _sample_negative(user_id: int, user_item_csr: csr_matrix) -> int:\n        neg_sample = numpy.random.choice(user_item_csr.shape[1])\n        while user_item_csr[user_id, neg_sample] != 0:\n            neg_sample = numpy.random.choice(user_item_csr.shape[1])\n        return neg_sample\n\n    def _gradient_step(self, loss: float, user_id: int, pos_sample: int, neg_sample: int):\n        # [ d ]\n        du = loss * (self._V[pos_sample] - self._V[neg_sample]) + self.__lambda * self._U[user_id]\n        dpi = loss * self._U[user_id] + self.__lambda * self._V[pos_sample]\n        dni = loss * -self._U[user_id] + self.__lambda * self._V[neg_sample]\n\n        self._U[user_id] -= self.__lr * du\n        self._V[pos_sample] -= self.__lr * dpi\n        self._V[neg_sample] -= self.__lr * dni\n\n    def _step(self, user_id: int, pos_sample: int, user_item_csr: csr_matrix) -> float:\n        neg_sample = self._sample_negative(user_id, user_item_csr)\n\n        # [ 1 ]\n        r_uij = numpy.dot(self._U[user_id], self._V[pos_sample] - self._V[neg_sample])\n        sigmoid = expit(r_uij)\n\n        self._gradient_step(sigmoid, user_id, pos_sample, neg_sample)\n\n        return numpy.log(sigmoid)\n\n    def fit(self, user_item_csr: csr_matrix):\n        n_users, n_items = user_item_csr.shape\n        self._init_matrices(n_users, n_items)\n\n        user_item_coo = user_item_csr.tocoo()\n        n_samples = user_item_csr.count_nonzero()\n        assert len(user_item_coo.row) == len(user_item_coo.col) == n_samples\n\n        epoch_range = trange(self.__steps, desc=\"Epoch\")\n        for _ in epoch_range:\n            order = numpy.random.permutation(n_samples)\n            log_loss = 0\n            for user_id, pos_sample in tqdm(zip(user_item_coo.row[order], user_item_coo.col[order]), total=n_samples):\n                log_loss += self._step(user_id, pos_sample, user_item_csr)\n\n            epoch_range.set_postfix({\"log loss\": round(log_loss \/ n_samples, 3)})\n        epoch_range.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_262","text":"#!\/usr\/bin\/env python3\n# ------------------------------------------------------------------------\n# Copyright (c) 2021 megvii-model. All Rights Reserved.\n# ------------------------------------------------------------------------\nimport os, sys\nfrom scipy.optimize import linear_sum_assignment\nimport numpy as np\n\ndef mask_minimumWeightMatching(costSet, mask) -> list:\n\n    m, n = costSet.shape\n    nMax = max(m, n)\n\n    costSet_ = np.full((nMax, nMax), np.inf)\n\n    mask = mask > 0\n    costSet_[:m, :n][mask] = costSet[mask]\n    assert costSet_.shape[0] == costSet_.shape[1]\n\n    if mask.sum():\n        practicalInfinity = 2 * costSet[costSet < np.inf].max() + 10\n    # except ValueError:\n    else:\n        practicalInfinity = 1\n\n    # Replace infinitites with our representation.\n    costSet_[costSet_ == np.inf] = practicalInfinity\n\n    # Find a pairing of minimum total cost between matching second-level contours.\n    iSet, jSet = linear_sum_assignment(costSet_)\n    assert len(iSet) == len(jSet)\n\n    # Return only pairs with finite cost.\n    indices = [(iSet[k], jSet[k]) for k in range(len(iSet)) \n                if costSet_[iSet[k], jSet[k]] != practicalInfinity]\n        \n    rows = np.array([i for i, _ in indices])\n    cols = np.array([j for _, j in indices])\n    return rows, cols\n\ndef minimumWeightMatching(costSet : np.ndarray) -> list:\n    '''\n    Computes a minimum-weight matching in a bipartite graph\n    (A union B, E).\n\n    costSet:\n    An (m x n)-matrix of real values, where costSet[i, j]\n    is the cost of matching the i:th vertex in A to the j:th \n    vertex of B. A value of numpy.inf is allowed, and is \n    interpreted as missing the (i, j)-edge.\n\n    returns:\n    A minimum-weight matching given as a list of pairs (i, j), \n    denoting that the i:th vertex of A be paired with the j:th \n    vertex of B.\n    '''\n\n    m, n = costSet.shape\n    nMax = max(m, n)\n\n    # Since the choice of infinity blocks later choices for that index, \n    # it is important that the cost matrix is square, so there\n    # is enough space to shift the choices for infinity to the unused \n    # part of the cost-matrix.\n    costSet_ = np.full((nMax, nMax), np.inf)\n\n    mask = costSet < 0\n    costSet_[:m, :n][mask] = costSet[mask]\n    assert costSet_.shape[0] == costSet_.shape[1]\n    \n    # We allow a cost to be infinity. Since scipy does not\n    # support this, we use a workaround. We represent infinity \n    # by M = 2 * maximum cost + 1. The point is to choose a distinct \n    # value, greater than any other cost, so that choosing an \n    # infinity-pair is the last resort. The 2 times is for large\n    # values for which x + 1 == x in floating point. The plus 1\n    # is for zero, for which 2 x == x.\n    try:\n        practicalInfinity = 2 * costSet[costSet < np.inf].max() + 10\n    except ValueError:\n        # This is thrown when the indexing set is empty;\n        # then all elements are infinities.\n        practicalInfinity = 1\n\n    # Replace infinitites with our representation.\n    costSet_[costSet_ == np.inf] = practicalInfinity\n\n    # Find a pairing of minimum total cost between matching second-level contours.\n    iSet, jSet = linear_sum_assignment(costSet_)\n    assert len(iSet) == len(jSet)\n\n    # Return only pairs with finite cost.\n    indices = [(iSet[k], jSet[k]) \n        for k in range(len(iSet)) \n        if costSet_[iSet[k], jSet[k]] != practicalInfinity]\n\n    return indices\n\ndef compute_lap(dtboxes, gtboxes, thr):\n\n    eps = 1e-7\n    n, k = dtboxes.shape[0], gtboxes.shape[0]\n    if k + n < 2:\n        m, n = np.array([]), np.array([])\n        return m, n\n        \n    overlaps = compute_iou_matrix(dtboxes, gtboxes)\n\n    if n < 2:\n        cols = np.argmax(overlaps, axis = 1)\n        rows = np.array([0])\n        m, n = (rows, cols) if thr - overlaps[rows, cols] < eps else (np.array([]), np.array([]))\n        return m, n\n\n    if k < 2:\n        \n        rows = np.argmax(overlaps, axis = 0)\n        cols = np.array([0])\n        m,n = (rows, cols) if thr - overlaps[rows, cols] < eps else (np.array([]), np.array([]))\n        return m, n\n            \n    ious = overlaps * (overlaps >= thr)\n        \n    matches = minimumWeightMatching(-ious)\n    m, n = np.array([i for i, _ in matches]).astype(np.int32), np.array([i for _, i in matches]).astype(np.int32)\n    indice = np.where(overlaps[m, n] < thr)[0]\n\n    if indice.size >= m.size:\n        m, n = np.array([]), np.array([])\n    else:\n        index = np.array(list(set(np.arange(m.size)) - set(indice))).astype(np.int)\n        m, n = m[index], n[index]\n    \n    return m, n\n\ndef compute_Jaccard(dtboxes, gtboxes, bm_thr):\n\n    rows, cols = compute_lap(dtboxes, gtboxes, bm_thr)\n    return [(i, j) for i, j in (rows, cols)]\n\ndef compute_JC(dtboxes, gtboxes, bm_thr):\n\n    rows, cols = compute_lap(dtboxes, gtboxes, bm_thr)\n    return [(i, j) for i, j in zip(rows, cols)]\n\ndef compute_ioa_matrix(dboxes: np.ndarray, gboxes: np.ndarray):\n\n    assert dboxes.shape[-1] >= 4 and gboxes.shape[-1] >= 4\n    N, K = dboxes.shape[0], gboxes.shape[0]\n    eps = 1e-6\n    dtboxes = np.tile(np.expand_dims(dboxes, axis = 1), (1, K, 1))\n    gtboxes = np.tile(np.expand_dims(gboxes, axis = 0), (N, 1, 1))\n\n    iw = np.minimum(dtboxes[:,:,2], gtboxes[:,:,2]) - np.maximum(dtboxes[:,:,0], gtboxes[:,:,0])\n    ih = np.minimum(dtboxes[:,:,3], gtboxes[:,:,3]) - np.maximum(dtboxes[:,:,1], gtboxes[:,:,1])\n    inter = np.maximum(0, iw) * np.maximum(0, ih)\n\n    dtarea = np.maximum(dtboxes[:,:,2] - dtboxes[:,:,0], 0) * np.maximum(dtboxes[:,:,3] - dtboxes[:,:,1], 0)   \n    ioas = inter \/ (dtarea + eps)\n    return ioas\n\ndef compute_iou_matrix(dboxes:np.ndarray, gboxes:np.ndarray):\n    \n    assert dboxes.shape[-1] >= 4 and gboxes.shape[-1] >= 4\n    eps = 1e-6\n    N, K = dboxes.shape[0], gboxes.shape[0]\n    dtboxes = np.tile(np.expand_dims(dboxes, axis = 1), (1, K, 1))\n    gtboxes = np.tile(np.expand_dims(gboxes, axis = 0), (N, 1, 1))\n\n    iw = np.minimum(dtboxes[:,:,2], gtboxes[:,:,2]) - np.maximum(dtboxes[:,:,0], gtboxes[:,:,0])\n    ih = np.minimum(dtboxes[:,:,3], gtboxes[:,:,3]) - np.maximum(dtboxes[:,:,1], gtboxes[:,:,1])\n    inter = np.maximum(0, iw) * np.maximum(0, ih)\n\n    dtarea = (dtboxes[:,:,2] - dtboxes[:,:,0]) * (dtboxes[:,:,3] - dtboxes[:,:,1])\n    gtarea = (gtboxes[:,:,2] - gtboxes[:,:,0]) * (gtboxes[:,:,3] - gtboxes[:,:,1])\n    ious = inter \/ (dtarea + gtarea - inter + eps)\n    return ious\n\ndef compute_maximal_iou(proposals:np.ndarray,gt:np.ndarray):\n    \n    ious = compute_iou_matrix(proposals, gt)\n    return np.max(ious, axis = 1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_273","text":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.stats import linregress\n\n# Set style\nplt.rcParams[\"font.family\"] = \"sans-serif\"\nplt.rcParams[\"figure.figsize\"] = (10, 4)\n\n# Data\nx = np.array([0.25, 0.286, 0.333, 0.4, 0.5])\ny = np.array([0.15, 0.3, 0.39, 0.54, 0.69])\n\nx_error = np.array([0.006, 0.008, 0.011, 0.016, 0.025])\ny_error = np.array([0.03, 0.01, 0.04, 0.02, 0.02])\n\n# Linear regression\nresult = linregress(x, y)\nx_conti = np.linspace(0.23, 0.57)\ny_conti = result.intercept + result.slope * x_conti\n\n# Plot\nfigure, axs = plt.subplots(1, 2)\naxs[0].errorbar(x, y, yerr=y_error, xerr=x_error, fmt=\"o\")\naxs[0].plot(x_conti, y_conti)\n\naxs[0].set_xlabel(\"1\/a (cm^-1)\")\naxs[0].set_ylabel(\"sin(theta)\")\naxs[0].set_ylim(0, None)\n\naxs[1].scatter(x, y - result.intercept - x * result.slope)\naxs[1].set_xlabel(\"1\/a (cm^-1)\")\naxs[1].set_ylabel(\"Residuals\")\n\n# Show\nplt.savefig(\"4a.png\")\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_274","text":"<filename>code\/preprocess\/consumption\/sector\/tn\/tn_nm.py\n#! usr\/bin\/python3\n\nimport pandas as pd\nimport re\nimport numpy as np\nimport os\nimport sys\nfrom collections import OrderedDict, defaultdict\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n# import seaborn as sns\nfrom scipy import stats, integrate\n\n# sns.set() # switch to seaborn default\n# sns.set_style(\"whitegrid\")\n\n#load sector msncodes\ntn_msncodes = pd.read_csv(\"data\/csv\/consumption\/sector\/tn_sector.csv\", engine='c', low_memory=True)[\"MSN\"]\n#load state data\nnm_data = pd.read_csv(\"data\/csv\/state_data\/nm_data.csv\", engine='c', low_memory=True)\n\nnm_msn = []\nnm_year = []\nnm_value = []\n\nfor i in range(len(nm_data[\"MSN\"])):\n    for j in range(len(tn_msncodes)):\n        if nm_data[\"MSN\"][i] == tn_msncodes[j]:\n            nm_msn.append(nm_data[\"MSN\"][i])\n            nm_year.append(nm_data[\"Year\"][i])\n            nm_value.append(nm_data[\"Data\"][i])\n        else:\n            pass\n\nnm_tn = OrderedDict()\nnm_tn[\"MSN\"] = nm_msn\nnm_tn[\"Year\"] = nm_year\nnm_tn[\"Data\"] = nm_value\nnm_tn_data = pd.DataFrame(nm_tn)\n\nnm_tn_data.to_csv(\"data\/csv\/consumption\/sector\/nm\/nm_tn_data.csv\",\n                  index=False, index_label=False, sep=',')\n# print(nm_tn_data)\n\nsectors = [\"TNACB\", \"TNCCB\", \"TNICB\", \"TNRCB\"]\ntnacb = OrderedDict()\ntnacb[\"Year\"] = []\ntnacb[\"Data\"] = []\ntnccb = OrderedDict()\ntnccb[\"Year\"] = []\ntnccb[\"Data\"] = []\ntnicb = OrderedDict()\ntnicb[\"Year\"] = []\ntnicb[\"Data\"] = []\ntnrcb = OrderedDict()\ntnrcb[\"Year\"] = []\ntnrcb[\"Data\"] = []\n\n\nfor i in range(len(nm_tn_data[\"MSN\"])):\n    if nm_tn_data[\"MSN\"][i] == \"TNACB\":\n        tnacb[\"Year\"].append(nm_tn_data[\"Year\"][i])\n        tnacb[\"Data\"].append(nm_tn_data[\"Data\"][i])\n    elif nm_tn_data[\"MSN\"][i] == \"TNCCB\":\n        tnccb[\"Year\"].append(nm_tn_data[\"Year\"][i])\n        tnccb[\"Data\"].append(nm_tn_data[\"Data\"][i])\n    elif nm_tn_data[\"MSN\"][i] == \"TNICB\":\n        tnicb[\"Year\"].append(nm_tn_data[\"Year\"][i])\n        tnicb[\"Data\"].append(nm_tn_data[\"Data\"][i])\n    elif nm_tn_data[\"MSN\"][i] == \"TNRCB\":\n        tnrcb[\"Year\"].append(nm_tn_data[\"Year\"][i])\n        tnrcb[\"Data\"].append(nm_tn_data[\"Data\"][i])\n    else:\n        pass\n\ntnacb_data = pd.DataFrame(tnacb)\ntnacb_data.to_csv(\"data\/csv\/consumption\/sector\/nm\/tn\/tnacb.csv\",\n                  index=False, index_label=False, sep=',')\ntnccb_data = pd.DataFrame(tnccb)\ntnccb_data.to_csv(\"data\/csv\/consumption\/sector\/nm\/tn\/tnccb.csv\",\n                  index=False, index_label=False, sep=',')\ntnicb_data = pd.DataFrame(tnicb)\ntnicb_data.to_csv(\"data\/csv\/consumption\/sector\/nm\/tn\/tnicb.csv\",\n                  index=False, index_label=False, sep=',')\ntnrcb_data = pd.DataFrame(tnrcb)\ntnrcb_data.to_csv(\"data\/csv\/consumption\/sector\/nm\/tn\/tnrcb.csv\",\n                  index=False, index_label=False, sep=',')\n# print(tnacb_data)\n# print(tnccb_data)\n# print(tnicb_data)\n# print(tnrcb_data)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_275","text":"r\"\"\"Solve Navier-Stokes equations for the lid driven cavity using a coupled\nformulation\n\nThe equations are in strong form\n\n.. math::\n\n    \\nu\\nabla^2 u - \\nabla p &= (u \\cdot \\nabla) u) \\\\\n    \\nabla \\cdot u &= 0 \\\\\n    i\\bs{u}(x, y=1) = (1, 0) \\, &\\text{ or }\\, \\bs{u}(x, y=1) = ((1-x)^2(1+x)^2, 0) \\\\\n    u(x, y=-1) &= 0 \\\\\n    u(x=\\pm 1, y) &= 0\n\nIn addition we require :math:`\\int p d\\ = 0`, which is achieved by\nfixing the coefficient :math:`\\hat{p}_{0, 0} = 0`.\n\nWe use a tensorproductspace with a composite Legendre for the Dirichlet space\nand a regular Legendre for the pressure space.\n\nTo remove all nullspaces we use a P_{N} x P_{N-2} basis, with P_{N-2} for the\npressure.\n\n\"\"\"\nimport os\nimport sys\nimport time\nimport numpy as np\nfrom scipy.sparse.linalg import splu\nimport sympy\nfrom shenfun import *\n\nassert comm.Get_size() == 1, \"Two non-periodic directions only have solver implemented for serial\"\n\nRe = 250.\nnu = 2.\/Re\nalfa = 0.1 # underrelaxation factor\nN = 64\nfamily = 'Chebyshev'\n#family = 'Legendre'\nx = sympy.symbols('x', real='True')\nD0 = FunctionSpace(N, family, bc=(0, 0))\n#D1 = FunctionSpace(N, family, bc=(0, 1))\nD1 = FunctionSpace(N, family, bc=(0, (1-x)**2*(1+x)**2))\n\n# Create tensor product spaces with different combination of bases\nV1 = TensorProductSpace(comm, (D0, D1))\nV0 = V1.get_homogeneous()\nP = V1.get_orthogonal()\n\n# To satisfy inf-sup for the Stokes problem, just pick the first N-2 items of the pressure basis\n# Note that this effectively sets P_{N-1} and P_{N-2} to zero, but still the basis uses\n# the same quadrature points as the Dirichlet basis, which is required for the inner products.\nP.bases[0].slice = lambda: slice(0, N-2)\nP.bases[1].slice = lambda: slice(0, N-2)\n\n# Create vector space for velocity and a mixed velocity-pressure space\nW1 = VectorSpace([V1, V0])\nVQ = CompositeSpace([W1, P])\n\n# Create space for nonlinearity\nS1 = TensorSpace(P)\n\nup = TrialFunction(VQ)\nvq = TestFunction(VQ)\n\nu, p = up\nv, q = vq\n\n# Assemble blocks of the complete block matrix\nif family.lower() == 'legendre':\n    A00 = inner(grad(v), -nu*grad(u))\n    A01 = inner(div(v), p)\nelse:\n    A00 = inner(v, nu*div(grad(u)))\n    A01 = inner(v, -grad(p))\n\nA10 = inner(q, div(u))\n\n# Create Block matrix solver. This also takes care of boundary conditions.\nsol = la.BlockMatrixSolver(A00+A01+A10)\n\n# Create Function to hold solution\nuh_hat = Function(VQ).set_boundary_dofs()\nui_hat = uh_hat[0]\n\n# New solution (iterative)\nuh_new = Function(VQ).set_boundary_dofs()\nui_new = uh_new[0]\n\n# Create regular work arrays for right hand side.\nbh_hat = Function(VQ)\n\n# Create arrays to hold velocity vector solution\nui = Array(W1)\n\n# Create work arrays for nonlinear part\nuiuj = Array(S1.get_dealiased())\nuiuj_hat = Function(S1)\nBS = BlockMatrix(inner(TestFunction(W1), div(TrialFunction(S1))))\n\ndef compute_rhs(ui_hat, bh_hat):\n    global uip, uiuj, uiuj_hat\n    bh_hat.fill(0)\n    bi_hat = bh_hat[0]\n    # Get convection\n    uip = ui_hat.backward(padding_factor=1.5)\n    uiuj = outer(uip, uip, uiuj)\n    uiuj_hat = uiuj.forward(uiuj_hat)\n    #bi_hat = inner(v, div(uiuj_hat), output_array=bi_hat)\n    bi_hat = BS.matvec(uiuj_hat, bi_hat) # fastest method\n    #bi_hat = inner(grad(v), -uiuj_hat, output_array=bi_hat) # only Legendre\n    #gradu = project(grad(ui_hat), S1)\n    #bi_hat = inner(v, dot(gradu, ui_hat), output_array=bi_hat)\n    return bh_hat\n\nconverged = False\ncount = 0\nmax_count = 1000\nif 'pytest' in os.environ:\n    max_count = 1\nt0 = time.time()\nwhile not converged:\n    count += 1\n    bh_hat = compute_rhs(ui_hat, bh_hat)\n    uh_new = sol(bh_hat, u=uh_new, constraints=((2, 0, 0),)) # Constraint for component 2 of mixed space\n    error = np.linalg.norm(ui_hat-ui_new)\n    uh_hat[:] = alfa*uh_new + (1-alfa)*uh_hat\n    converged = abs(error) < 1e-11 or count >= max_count\n    if count % 1 == 0:\n        print('Iteration %d Error %2.4e' %(count, error))\n\nprint('Time ', time.time()-t0)\n\n# Move solution to regular Function\nup = Array(VQ)\nup = uh_hat.backward(up)\nu_, p_ = up\n\nif 'pytest' in os.environ: sys.exit(0)\n\n# Postprocessing\n# Solve streamfunction\nr = TestFunction(V0)\ns = TrialFunction(V0)\nS = inner(r, div(grad(s)))\nh = inner(r, -curl(ui_hat))\nH = la.SolverGeneric2ND(S)\nphi_h = H(h)\nphi = phi_h.backward()\n# Compute vorticity\nP = V1.get_orthogonal()\nw_h = Function(P)\nw_h = project(curl(ui_hat), P, output_array=w_h)\n#p0 = np.array([[0.], [0.]])\n#print(w_h.eval(p0)*2)\n\n# Find minimal streamfunction value and position\n# by gradually zooming in on mesh\nW = 101\nconverged = False\nxmid, ymid = 0, 0\ndx = 1\npsi_old = 0\ncount = 0\ny, x = np.meshgrid(np.linspace(ymid-dx, ymid+dx, W), np.linspace(xmid-dx, xmid+dx, W))\npoints = np.vstack((x.flatten(), y.flatten()))\npp = phi_h.eval(points).reshape((W, W))\nwhile not converged:\n    yr, xr = np.meshgrid(np.linspace(ymid-dx, ymid+dx, W), np.linspace(xmid-dx, xmid+dx, W))\n    points = np.vstack((xr.flatten(), yr.flatten()))\n    pr = phi_h.eval(points).reshape((W, W))\n    xi, yi = pr.argmin()\/\/W, pr.argmin()%W\n    psi_min, xmid, ymid = pr.min()\/2, xr[xi, yi], yr[xi, yi]\n    err = abs(psi_min-psi_old)\n    converged = err < 1e-15 or count > 10\n    psi_old = psi_min\n    dx = dx\/4.\n    print(\"%d %d \" %(xi, yi) +(\"%+2.7e \"*4) %(xmid, ymid, psi_min, err))\n    count += 1\n\nimport matplotlib.pyplot as plt\n#f = open('plot_u_y_Ghia{}.csv'.format(int(Re)))\n#g = np.loadtxt(f, skiprows=1, delimiter=',')\n#plt.figure()\n#y = 2*(g[:, 0]-0.5)\n#plt.plot(y, g[:, 1], 'r+')\nX = V0.local_mesh(True)\n#x = np.vstack([np.zeros(N[0]), X[1][0]])\n#res = ui_hat[0].eval(x)\n#plt.plot(x[1], res)\n#res2 = ui_hat[0].eval(np.vstack([np.zeros(len(y)), y]))\n#plt.plot(y, res2, 'bs', mfc='None')\nplt.figure()\nplt.contourf(X[0], X[1], p_, 100)\nplt.figure()\nplt.quiver(X[0], X[1], u_[0], u_[1])\nplt.figure()\nplt.spy(sol.mat.diags())\nplt.figure()\nplt.contourf(X[0], X[1], u_[0], 100)\nplt.figure()\nplt.contourf(X[0], X[1], u_[1], 100)\nplt.figure()\nplt.contourf(X[0], X[1], phi, 100)\n#plt.title('Streamfunction')\n#plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_276","text":"<gh_stars>0\nimport numpy as np\r\nnp.set_printoptions(precision=4)\r\n\r\nimport time\r\nfrom scipy import spatial\r\n\r\ndef xy2theta(x, y):\r\n    if (x >= 0 and y >= 0): \r\n        theta = 180\/np.pi * np.arctan(y\/x);\r\n    if (x < 0 and y >= 0): \r\n        theta = 180 - ((180\/np.pi) * np.arctan(y\/(-x)));\r\n    if (x < 0 and y < 0): \r\n        theta = 180 + ((180\/np.pi) * np.arctan(y\/x));\r\n    if ( x >= 0 and y < 0):\r\n        theta = 360 - ((180\/np.pi) * np.arctan((-y)\/x));\r\n\r\n    return theta\r\n\r\n\r\ndef pt2rs(point, gap_ring, gap_sector, num_ring, num_sector):\r\n    x = point[0]\r\n    y = point[1]\r\n    # z = point[2]\r\n    \r\n    if(x == 0.0):\r\n        x = 0.001\r\n    if(y == 0.0):\r\n        y = 0.001\r\n    \r\n    theta = xy2theta(x, y)\r\n    faraway = np.sqrt(x*x + y*y)\r\n    \r\n    idx_ring = np.divmod(faraway, gap_ring)[0]       \r\n    idx_sector = np.divmod(theta, gap_sector)[0]\r\n\r\n    if(idx_ring >= num_ring):\r\n        idx_ring = num_ring-1 # python starts with 0 and ends with N-1\r\n    \r\n    return int(idx_ring), int(idx_sector)\r\n\r\n\r\ndef ptcloud2sc(ptcloud, sc_shape, max_length):\r\n    num_ring = sc_shape[0]\r\n    num_sector = sc_shape[1]\r\n\r\n    gap_ring = max_length\/num_ring\r\n    gap_sector = 360\/num_sector\r\n    \r\n    enough_large = 500\r\n    sc_storage = np.zeros([enough_large, num_ring, num_sector])\r\n    sc_counter = np.zeros([num_ring, num_sector])\r\n    \r\n    num_points = ptcloud.shape[0]\r\n    for pt_idx in range(num_points):\r\n        point = ptcloud[pt_idx, :]\r\n        point_height = point[2] + 2.0 # for setting ground is roughly zero \r\n        \r\n        idx_ring, idx_sector = pt2rs(point, gap_ring, gap_sector, num_ring, num_sector)\r\n        \r\n        if sc_counter[idx_ring, idx_sector] >= enough_large:\r\n            continue\r\n        sc_storage[int(sc_counter[idx_ring, idx_sector]), idx_ring, idx_sector] = point_height\r\n        sc_counter[idx_ring, idx_sector] = sc_counter[idx_ring, idx_sector] + 1\r\n\r\n    sc = np.amax(sc_storage, axis=0)\r\n        \r\n    return sc\r\n\r\n\r\ndef sc2rk(sc):\r\n    return np.mean(sc, axis=1)\r\n\r\ndef distance_sc(sc1, sc2):\r\n    num_sectors = sc1.shape[1]\r\n\r\n    # repeate to move 1 columns\r\n    _one_step = 1 # const\r\n    sim_for_each_cols = np.zeros(num_sectors)\r\n    for i in range(num_sectors):\r\n        # Shift\r\n        sc1 = np.roll(sc1, _one_step, axis=1) #  columne shift\r\n\r\n        #compare\r\n        sum_of_cossim = 0\r\n        num_col_engaged = 0\r\n        for j in range(num_sectors):\r\n            col_j_1 = sc1[:, j]\r\n            col_j_2 = sc2[:, j]\r\n            if (~np.any(col_j_1) or ~np.any(col_j_2)): \r\n                # to avoid being divided by zero when calculating cosine similarity\r\n                # - but this part is quite slow in python, you can omit it.\r\n                continue \r\n\r\n            cossim = np.dot(col_j_1, col_j_2) \/ (np.linalg.norm(col_j_1) * np.linalg.norm(col_j_2))\r\n            sum_of_cossim = sum_of_cossim + cossim\r\n\r\n            num_col_engaged = num_col_engaged + 1\r\n\r\n        # save \r\n        sim_for_each_cols[i] = sum_of_cossim \/ num_col_engaged\r\n\r\n    yaw_diff = np.argmax(sim_for_each_cols) + 1 # because python starts with 0 \r\n    sim = np.max(sim_for_each_cols)\r\n    dist = 1 - sim\r\n\r\n    return dist, yaw_diff\r\n\r\n    \r\nclass ScanContextManager:\r\n    def __init__(self, shape=[20,60], num_candidates=10, threshold=0.15): # defualt configs are same as the original paper \r\n        self.shape = shape\r\n        self.num_candidates = num_candidates\r\n        self.threshold = threshold\r\n\r\n        self.max_length = 80 # recommended but other (e.g., 100m) is also ok.\r\n\r\n        self.ENOUGH_LARGE = 15000 # capable of up to ENOUGH_LARGE number of nodes \r\n        self.ptclouds = [None] * self.ENOUGH_LARGE\r\n        self.scancontexts = [None] * self.ENOUGH_LARGE\r\n        self.ringkeys = [None] * self.ENOUGH_LARGE\r\n\r\n        self.curr_node_idx = 0\r\n       \r\n\r\n    def addNode(self, node_idx, ptcloud):\r\n        sc = ptcloud2sc(ptcloud, self.shape, self.max_length)\r\n        rk = sc2rk(sc)\r\n\r\n        self.curr_node_idx = node_idx\r\n        self.ptclouds[node_idx] = ptcloud\r\n        self.scancontexts[node_idx] = sc\r\n        self.ringkeys[node_idx] = rk\r\n        \r\n\r\n    def getPtcloud(self, node_idx):\r\n        return self.ptclouds[node_idx]\r\n\r\n\r\n    def detectLoop(self):        \r\n        exclude_recent_nodes = 30\r\n        valid_recent_node_idx = self.curr_node_idx - exclude_recent_nodes\r\n\r\n        if(valid_recent_node_idx < 1):\r\n            return None, None, None\r\n        else:\r\n            # step 1\r\n            ringkey_history = np.array(self.ringkeys[:valid_recent_node_idx])\r\n            ringkey_tree = spatial.KDTree(ringkey_history)\r\n\r\n            ringkey_query = self.ringkeys[self.curr_node_idx]\r\n            _, nncandidates_idx = ringkey_tree.query(ringkey_query, k=self.num_candidates)\r\n\r\n            # step 2\r\n            query_sc = self.scancontexts[self.curr_node_idx]\r\n            \r\n            nn_dist = 1.0 # initialize with the largest value of distance\r\n            nn_idx = None\r\n            nn_yawdiff = None\r\n            for ith in range(self.num_candidates):\r\n                candidate_idx = nncandidates_idx[ith]\r\n                candidate_sc = self.scancontexts[candidate_idx]\r\n                dist, yaw_diff = distance_sc(candidate_sc, query_sc)\r\n                if(dist < nn_dist):\r\n                    nn_dist = dist\r\n                    nn_yawdiff = yaw_diff\r\n                    nn_idx = candidate_idx\r\n\r\n            if(nn_dist < self.threshold):\r\n                nn_yawdiff_deg = nn_yawdiff * (360\/self.shape[1])\r\n                return nn_idx, nn_dist, nn_yawdiff_deg # loop detected!\r\n            else:\r\n                return None, None, None\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_277","text":"\"\"\"\nCCT 建模优化代码\n束线\n\n作者：赵润晓\n日期：2021年5月1日\n\"\"\"\n\nimport multiprocessing  # since v0.1.1 多线程计算\nimport time  # since v0.1.1 统计计算时长\nfrom typing import Callable, Dict, Generic, Iterable, List, NoReturn, Optional, Tuple, TypeVar, Union\nimport matplotlib.pyplot as plt\nimport math\nimport random  # since v0.1.1 随机数\nimport sys\nimport os  # since v0.1.1 查看CPU核心数\nimport numpy\nfrom scipy.integrate import solve_ivp  # since v0.1.1 ODE45\nimport warnings  # since v0.1.1 提醒方法过时\nfrom packages.point import *\nfrom packages.constants import *\nfrom packages.base_utils import BaseUtils\nfrom packages.local_coordinate_system import LocalCoordinateSystem\nfrom packages.line2s import *\nfrom packages.trajectory import Trajectory\nfrom packages.particles import *\nfrom packages.magnets import *\nfrom packages.cct import CCT\n\n\nclass Beamline(Line2, Magnet, ApertureObject):\n    def __init__(self, trajectory: Trajectory) -> None:\n        \"\"\"\n        不要直接调用构造器\n        请使用 set_start_point\n        \"\"\"\n        self.magnets: List[Magnet] = []\n        self.trajectory: Trajectory = trajectory\n\n        # 2021年3月18日 新增，表示元件。List 中每个元素表示一个元件\n        # 元件由三部分组成，位置、元件自身、长度\n        # 其中位置表示沿着 Beamline 的长度\n        # 元件自身，使用 None 表示漂移段。\n        self.elements: List[Tuple[float, Magnet, float]] = []\n\n    def magnetic_field_at(self, point: P3) -> P3:\n        \"\"\"\n        返回 Beamline 在全局坐标系点 P3 处产生的磁场\n        \"\"\"\n        b: P3 = P3.zeros()\n        for m in self.magnets:\n            b += m.magnetic_field_at(point)\n        return b\n\n    # from Magnet\n    def magnetic_field_along(\n            self,\n            line2: Optional[Line2] = None,\n            p2_t0_p3: Callable[[P2], P3] = lambda p2: P3(p2.x, p2.y, 0.0),\n            step: float = 1 * MM,\n    ) -> List[ValueWithDistance[P3]]:\n        \"\"\"\n        计算本对象在二维曲线 line2 上的磁场分布(line2 为 None 时，默认为 self.trajectory)\n        p2_t0_p3 是一个函数，用于把 line2 上的二维点转为三维，默认转为 z=0 的三维点\n        step 表示 line2 分段长度\n        -------\n        \"\"\"\n        if line2 is None:\n            line2 = self.trajectory\n\n        return super(Beamline, self).magnetic_field_along(\n            line2=line2, p2_t0_p3=p2_t0_p3, step=step\n        )\n\n    def magnetic_field_bz_along(\n            self,\n            line2: Optional[Line2] = None,\n            p2_t0_p3: Callable[[P2], P3] = lambda p2: P3(p2.x, p2.y, 0.0),\n            step: float = 1 * MM,\n    ) -> List[P2]:\n        \"\"\"\n        计算本对象在二维曲线 line (line2 为 None 时，默认为 self.trajectory)上的磁场 Z 方向分量的分布\n        因为磁铁一般放置在 XY 平面，所以 Bz 一般可以看作自然坐标系下 By，也就是二级场大小\n        p2_t0_p3 是一个函数，用于把 line2 上的二维点转为三维，默认转为 z=0 的三维点\n        step 表示 line2 分段长度\n\n        返回 P2 的数组，P2 中 x 表示曲线 line2 上距离 s，y 表示前述距离对应的点的磁场 bz\n        \"\"\"\n        if line2 is None:\n            line2 = self.trajectory\n\n        return super(Beamline, self).magnetic_field_bz_along(\n            line2=line2, p2_t0_p3=p2_t0_p3, step=step\n        )\n\n    def graident_field_along(\n            self,\n            line2: Optional[Line2] = None,\n            good_field_area_width: float = 10 * MM,\n            step: float = 1 * MM,\n            point_number: int = 4,\n    ) -> List[P2]:\n        \"\"\"\n        计算本对象在二维曲线 line2 (line2 为 None 时，默认为 self.trajectory)上的磁场梯度的分布\n        每一点的梯度，采用这点水平垂线上 Bz 的多项式拟合得到\n        good_field_area_width：水平垂线的长度，注意应小于等于好场区范围\n        step：line2 上取点间距\n        point_number：水平垂线上取点数目，越多则拟合越精确\n        \"\"\"\n        if line2 is None:\n            line2 = self.trajectory\n\n        return super(Beamline, self).graident_field_along(\n            line2=line2, good_field_area_width=good_field_area_width, step=step, point_number=point_number\n        )\n\n    def second_graident_field_along(\n            self,\n            line2: Optional[Line2] = None,\n            good_field_area_width: float = 10 * MM,\n            step: float = 1 * MM,\n            point_number: int = 4,\n    ) -> List[P2]:\n        \"\"\"\n        计算本对象在二维曲线 line2 (line2 为 None 时，默认为 self.trajectory)上的磁场二阶梯度的分布（六极场）\n        每一点的梯度，采用这点水���垂线上 Bz 的多项式拟合得到\n        good_field_area_width：水平垂线的长度，注意应小于等于好场区范围\n        step：line2 上取点间距\n        point_number：水平垂线上取点数目，越多则拟合越精确\n        \"\"\"\n        if line2 is None:\n            line2 = self.trajectory\n\n        return super(Beamline, self).second_graident_field_along(\n            line2=line2, good_field_area_width=good_field_area_width, step=step, point_number=point_number\n        )\n\n    def track_ideal_particle(\n            self,\n            kinetic_MeV: float,\n            s: float = 0.0,\n            length: Optional[float] = None,\n            footstep: float = 5 * MM,\n    ) -> List[P3]:\n        \"\"\"\n        束流跟踪，运行一个理想粒子，返回轨迹\n        kinetic_MeV 粒子动能，单位 MeV\n        s 起点位置\n        length 粒子运行长度，默认运动到束线尾部\n        footstep 粒子运动步长\n        \"\"\"\n        if length is None:\n            length = self.trajectory.get_length() - s\n        ip = ParticleFactory.create_proton_along(\n            self.trajectory, s, kinetic_MeV)\n        return ParticleRunner.run_get_trajectory(ip, self, length, footstep)\n\n    def track_phase_space_particle(\n        self,\n        x_mm: float,\n        xp_mrad: float,\n        y_mm: float,\n        yp_mrad,\n        delta: float,\n        kinetic_MeV: float,\n        s: float = 0.0,\n        length: Optional[float] = None,\n        footstep: float = 10 * MM,\n    ) -> List[ValueWithDistance[PhaseSpaceParticle]]:\n        \"\"\"\n        运行一个相空间粒子\n        x_mm 相空间坐标 x，单位 mm\n        xp_mrad 相空间坐标 xp，单位 mrad\n        y_mm 相空间坐标 y，单位 mm\n        yp_mrad 相空间坐标 yp，单位 mrad\n        delta 动量分散\n        kinetic_MeV 正则动能，单位 MeV\n        s 在束线上的起点，默认 0.0\n        length 运动长度，如果为空则运行到束线尾\n        footstep 运动步长，默认 10*MM\n\n        返回值是一个 List[ValueWithDistance[PhaseSpaceParticle]]\n        即一个数组，数组元素是 ValueWithDistance\n        即对应运动位置的粒子的相空间坐标信息\n        \"\"\"\n        if length is None:\n            length = self.trajectory.get_length() - s\n        pp = PhaseSpaceParticle(\n            x=x_mm * MM,\n            xp=xp_mrad * MM,\n            y=y_mm * MM,\n            yp=yp_mrad * MM,\n            z=0.0,\n            delta=delta\n        )\n        # ip, distence = 0.0\n        ip = ParticleFactory.create_proton_along(\n            self.trajectory, s, kinetic_MeV)\n        # to rp, distence = 0.0\n        rp = ParticleFactory.create_from_phase_space_particle(\n            ideal_particle=ip,\n            coordinate_system=ip.get_natural_coordinate_system(),\n            phase_space_particle=pp\n        )\n        # run all info, distence from 0.0\n        all_info = ParticleRunner.run_get_all_info(\n            p=rp,\n            m=self,\n            length=length,\n            footstep=footstep\n        )\n        # for cp\n        ret: List[ValueWithDistance[PhaseSpaceParticle]] = []\n        for cp in all_info:\n            d = cp.distance  # , distence from 0.0\n            cip = ParticleFactory.create_proton_along(\n                self.trajectory, d + s, kinetic_MeV)  # 所以这里是 d + s\n            cpp = PhaseSpaceParticle.create_from_running_particle(\n                ideal_particle=cip,\n                coordinate_system=cip.get_natural_coordinate_system(),\n                running_particle=cp\n            )\n            ret.append(ValueWithDistance(\n                value=cpp, distance=d\n            ))\n\n        return ret\n\n    def track_phase_ellipse(\n            self,\n            x_sigma_mm: float,\n            xp_sigma_mrad: float,\n            y_sigma_mm: float,\n            yp_sigma_mrad,\n            delta: float,\n            particle_number: int,\n            kinetic_MeV: float,\n            s: float = 0.0,\n            length: Optional[float] = None,\n            footstep: float = 10 * MM,\n            concurrency_level: int = 1,\n            report: bool = True\n    ) -> Tuple[List[P2], List[P2]]:\n        \"\"\"\n        束流跟踪，运行两个相椭圆边界上的粒子，\n        返回一个长度 2 的元组，表示相空间 x-xp 平面和 y-yp 平面上粒子投影（单位 mm \/ mrad）\n        两个相椭圆，一个位于 xxp 平面，参数为 σx 和 σxp ，动量分散为 delta\n        另一个位于 xxp 平面，参数为 σx 和 σxp ，动量分散为 delta\n        x_sigma_mm σx 单位 mm\n        xp_sigma_mrad σxp 单位 mrad\n        y_sigma_mm σy 单位 mm\n        yp_sigma_mrad σyp 单位 mrad\n        delta 动量分散 单位 1\n        particle_number 粒子数目\n        kinetic_MeV 动能 单位 MeV\n        s 起点位置\n        length 粒子运行长度，默认运行到束线尾部\n        footstep 粒子运动步长\n        concurrency_level 并���等级（使用多少个核心进行粒子跟踪）\n        report 是否打印并行任务计划\n        \"\"\"\n        if length is None:\n            length = self.trajectory.get_length() - s\n        ip_start = ParticleFactory.create_proton_along(\n            self.trajectory, s, kinetic_MeV)\n        ip_end = ParticleFactory.create_proton_along(\n            self.trajectory, s + length, kinetic_MeV\n        )\n\n        pp_x = PhaseSpaceParticle.phase_space_particles_along_positive_ellipse_in_xxp_plane(\n            xMax=x_sigma_mm * MM,\n            xpMax=xp_sigma_mrad * MRAD,\n            delta=delta,\n            number=particle_number,\n        )\n\n        pp_y = PhaseSpaceParticle.phase_space_particles_along_positive_ellipse_in_yyp_plane(\n            yMax=y_sigma_mm * MM,\n            ypMax=yp_sigma_mrad * MRAD,\n            delta=delta,\n            number=particle_number,\n        )\n\n        rp_x = ParticleFactory.create_from_phase_space_particles(\n            ideal_particle=ip_start,\n            coordinate_system=ip_start.get_natural_coordinate_system(),\n            phase_space_particles=pp_x,\n        )\n\n        rp_y = ParticleFactory.create_from_phase_space_particles(\n            ideal_particle=ip_start,\n            coordinate_system=ip_start.get_natural_coordinate_system(),\n            phase_space_particles=pp_y,\n        )\n\n        # run\n        # refactor v0.1.1 合并计算\n        ParticleRunner.run_only(\n            p=rp_x + rp_y, m=self, length=length, footstep=footstep, concurrency_level=concurrency_level,\n            report=report\n        )\n\n        pp_x_end = PhaseSpaceParticle.create_from_running_particles(\n            ideal_particle=ip_end,\n            coordinate_system=ip_end.get_natural_coordinate_system(),\n            running_particles=rp_x,\n        )\n\n        pp_y_end = PhaseSpaceParticle.create_from_running_particles(\n            ideal_particle=ip_end,\n            coordinate_system=ip_end.get_natural_coordinate_system(),\n            running_particles=rp_y,\n        )\n\n        xs = [pp.project_to_xxp_plane() \/ MM for pp in pp_x_end]\n        ys = [pp.project_to_yyp_plane() \/ MM for pp in pp_y_end]\n\n        s: BaseUtils.Statistic = BaseUtils.Statistic()\n\n        print(\n            f\"delta={delta},\" +\n            f\"avg_size_x={s.clear().add_all(P2.extract(xs)[0]).half_width()}mm,\" +\n            f\"avg_size_y={s.clear().add_all(P2.extract(ys)[0]).half_width()}mm\"\n        )\n\n        return (xs, ys)\n\n    # from ApertureObject\n    def is_out_of_aperture(self, point: P3) -> bool:\n        \"\"\"\n        判断点 point 是否超出 Beamline 的任意一个元件的孔径\n        只有当粒子轴向投影在元件内部时，才会进行判断，\n        否则即时粒子距离轴线很远，也认为粒子没有超出孔径，\n        这是因为粒子不在元件内时，很可能处于另一个大孔径元件中，这样会造成误判。\n\n        注意：这个函数的效率极低！\n        \"\"\"\n        for m in self.magnets:\n            if isinstance(m, ApertureObject) and m.is_out_of_aperture(point):\n                print(f\"beamline在{m}位置超出孔径\")\n                return True\n\n        return False\n\n    def trace_is_out_of_aperture(\n            self, trace_with_distance: List[ValueWithDistance[P3]]\n    ) -> bool:\n        \"\"\"\n        判断一条粒子轨迹是否超出孔径\n\n        注意：这个函数的效率极低！\n        \"\"\"\n        for pd in trace_with_distance:\n            if self.is_out_of_aperture(pd.value):\n                return True\n\n        return False\n\n    def get_length(self) -> float:\n        \"\"\"\n        获得 Beamline 的长度\n        \"\"\"\n        return self.trajectory.get_length()\n\n    def point_at(self, s: float) -> P2:\n        \"\"\"\n        获得 Beamline s 位置处的点 (x,y)\n        -------\n\n        \"\"\"\n        return self.trajectory.point_at(s)\n\n    def direct_at(self, s: float) -> P2:\n        \"\"\"\n        获得 Beamline s 位置处的方向\n        \"\"\"\n        return self.trajectory.direct_at(s)\n\n    class __BeamlineBuilder:\n        \"\"\"\n        构建 Beamline 的中间产物\n        \"\"\"\n\n        def __init__(self, start_point: P2) -> None:\n            self.start_point = start_point\n\n        def first_drift(self, direct: P2 = P2.x_direct(), length: float = 1.0) -> \"Beamline\":\n            \"\"\"\n            为 Beamline 添加第一个 drift\n            正如 Trajectory 的第一个曲线段必须是是直线一样\n            Beamline 中第一个元件必须是 drift\n            \"\"\"\n            bl = Beamline(\n                Trajectory.set_start_point(self.start_point).first_line(\n                    direct=direct, length=length\n                )\n            )\n            bl.elements.append((0, None, length))\n            return bl\n\n    @staticmethod\n    # -> \"Beamline.__BeamlineBuilder\"\n    def set_start_point(start_point: P2 = P2.origin()):\n        \"\"\"\n        设置束线起点\n        \"\"\"\n        return Beamline.__BeamlineBuilder(start_point)\n\n    def append_drift(self, length: float) -> \"Beamline\":\n        \"\"\"\n        尾加漂移段\n        length 漂移段长度\n        \"\"\"\n        old_len = self.trajectory.get_length()\n        self.trajectory.add_strait_line(length=length)\n        self.elements.append((old_len, None, length))\n\n        return self\n\n    def append_straight_dipole_magnet(\n            self,\n            magnetic_field: float,\n            length: float,\n            aperture_radius: float,\n            # field_direct: P2 = P2.y_direct()\n    ) -> \"Beamline\":\n        \"\"\"\n        尾加直线二极铁\n        \"\"\"\n        old_length = self.trajectory.get_length()\n        self.trajectory.add_strait_line(length=length)\n\n        lum = LocalUniformMagnet.create_local_uniform_magnet_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            length=length,\n            magnetic_field=magnetic_field,\n            aperture_radius=aperture_radius,\n        )\n\n        self.magnets.append(lum)\n        self.elements.append((old_length, lum, length))\n\n        return self\n\n    def append_qs(\n            self,\n            length: float,\n            gradient: float,\n            second_gradient: float,\n            aperture_radius: float,\n    ) -> \"Beamline\":\n        \"\"\"\n        尾加 QS 磁铁\n\n        length: float QS 磁铁长度\n        gradient: float 梯度 T\/m\n        second_gradient: float 二阶梯度（六极场） T\/m^2\n        aperture_radius: float 半孔径 单位 m\n        \"\"\"\n        old_length = self.trajectory.get_length()\n        self.trajectory.add_strait_line(length=length)\n\n        qs = QS.create_qs_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            length=length,\n            gradient=gradient,\n            second_gradient=second_gradient,\n            aperture_radius=aperture_radius,\n        )\n\n        self.magnets.append(qs)\n        self.elements.append((old_length, qs, length))\n\n        return self\n\n    def append_q(\n            self,\n            length: float,\n            gradient: float,\n            aperture_radius: float,\n    ) -> \"Beamline\":\n        \"\"\"\n        尾加 Q 磁铁\n\n        length: float QS 磁铁长度\n        gradient: float 梯度 T\/m\n        aperture_radius: float 半孔径 单位 m\n        \"\"\"\n        old_length = self.trajectory.get_length()\n        self.trajectory.add_strait_line(length=length)\n\n        q = Q.create_q_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            length=length,\n            gradient=gradient,\n            aperture_radius=aperture_radius,\n        )\n\n        self.magnets.append(q)\n        self.elements.append((old_length, q, length))\n\n        return self\n\n    def append_dipole_cct(\n            self,\n            big_r: float,\n            small_r_inner: float,\n            small_r_outer: float,\n            bending_angle: float,\n            tilt_angles: List[float],\n            winding_number: int,\n            current: float,\n            disperse_number_per_winding: int = 120,\n    ) -> \"Beamline\":\n        \"\"\"\n        尾加二极CCT\n\n        big_r: float 偏转半径\n        small_r_inner: float 内层半孔径\n        small_r_outer: float 外层半孔径\n        bending_angle: float 偏转角度（正数表示逆时针、负数表示顺时针）\n        tilt_angles: List[float] 各极倾斜角\n        winding_number: int 匝数\n        current: float 电流\n        disperse_number_per_winding: int 每匝分段数目，越大计算越精确\n        \"\"\"\n        old_length = self.trajectory.get_length()\n        cct_length = big_r * abs(BaseUtils.angle_to_radian(bending_angle))\n        self.trajectory.add_arc_line(\n            radius=big_r, clockwise=bending_angle < 0, angle_deg=abs(bending_angle)\n        )\n\n        cct_inner = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=small_r_inner,\n            bending_angle=abs(bending_angle),\n            tilt_angles=tilt_angles,\n            winding_number=winding_number,\n            current=current,\n            starting_point_in_ksi_phi_coordinate=P2.origin(),\n            end_point_in_ksi_phi_coordinate=P2(\n                2 * math.pi * winding_number,\n                BaseUtils.angle_to_radian(bending_angle),\n            ),\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        self.magnets.append(cct_inner)\n        self.elements.append((old_length, cct_inner, cct_length))\n\n        cct_outer = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=small_r_outer,\n            bending_angle=abs(bending_angle),\n            tilt_angles=BaseUtils.list_multiply(tilt_angles, -1),\n            winding_number=winding_number,\n            current=current,\n            starting_point_in_ksi_phi_coordinate=P2.origin(),\n            end_point_in_ksi_phi_coordinate=P2(\n                -2 * math.pi * winding_number,\n                BaseUtils.angle_to_radian(bending_angle),\n            ),\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        self.magnets.append(cct_outer)\n        self.elements.append((old_length, cct_outer, cct_length))\n\n        return self\n\n    def append_agcct(\n            self,\n            big_r: float,\n            small_rs: List[float],\n            bending_angles: List[float],\n            tilt_angles: List[List[float]],\n            winding_numbers: List[List[int]],\n            currents: List[float],\n            disperse_number_per_winding: int = 120,\n    ) -> \"Beamline\":\n        \"\"\"\n        尾加 agcct\n        本质是两层二极 CCT 和两层交变四极 CCT\n\n        big_r: float 偏转半径，单位 m\n        small_rs: List[float] 各层 CCT 的孔径，一共四层，从大到小排列。分别是二极CCT外层、内层，四极CCT外层、内层\n        bending_angles: List[float] 交变四极 CCT 每个 part 的偏转半径（正数表示逆时针、负数表示顺时针），要么全正数，要么全负数。不需要传入二极 CCT 偏转半径，因为它就是 sum(bending_angles)\n        tilt_angles: List[List[float]] 二极 CCT 和四极 CCT 的倾斜角，典型值 [[30],[90,30]]，只有两个元素的二维数组\n        winding_numbers: List[List[int]], 二极 CCT 和四极 CCT 的匝数，典型值 [[128],[21,50,50]] 表示二极 CCT 128匝，四极交变 CCT 为 21、50、50 匝\n        currents: List[float] 二极 CCT 和四极 CCT 的电流，典型值 [8000,9000]\n        disperse_number_per_winding: int 每匝分段数目，越大计算越精确\n\n        添加 CCT 的顺序为：\n        外层二极 CCT\n        内层二极 CCT\n        part1 四极 CCT 内层\n        part1 四极 CCT 外层\n        part2 四极 CCT 内层\n        part2 四极 CCT 外层\n        ... ... \n        \"\"\"\n        if len(small_rs) != 4:\n            raise ValueError(\n                f\"small_rs({small_rs})，长度应为4，分别是二极CCT外层、内层，四极CCT外层、内层\")\n        if not BaseUtils.is_sorted(small_rs[::-1]):\n            raise ValueError(\n                f\"small_rs({small_rs})，应从大到小排列，分别是二极CCT外层、内层，四极CCT外层、内层\")\n\n        total_bending_angle = sum(bending_angles)\n        old_length = self.trajectory.get_length()\n        cct_length = big_r * \\\n            abs(BaseUtils.angle_to_radian(total_bending_angle))\n        self.trajectory.add_arc_line(\n            radius=big_r,\n            clockwise=total_bending_angle < 0,\n            angle_deg=abs(total_bending_angle),\n        )\n\n        # 构建二极 CCT 外层\n        cct2_outer = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=small_rs[0],\n            bending_angle=abs(total_bending_angle),\n            tilt_angles=BaseUtils.list_multiply(tilt_angles[0], -1),\n            winding_number=winding_numbers[0][0],\n            current=currents[0],\n            starting_point_in_ksi_phi_coordinate=P2.origin(),\n            end_point_in_ksi_phi_coordinate=P2(\n                -2 * math.pi * winding_numbers[0][0],\n                BaseUtils.angle_to_radian(total_bending_angle),\n            ),\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        self.magnets.append(cct2_outer)\n        self.elements.append((old_length, cct2_outer, cct_length))\n\n        # 构建二极 CCT 内层\n        cct2_innter = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=small_rs[1],\n            bending_angle=abs(total_bending_angle),\n            tilt_angles=tilt_angles[0],\n            winding_number=winding_numbers[0][0],\n            current=currents[0],\n            starting_point_in_ksi_phi_coordinate=P2.origin(),\n            end_point_in_ksi_phi_coordinate=P2(\n                2 * math.pi * winding_numbers[0][0],\n                BaseUtils.angle_to_radian(total_bending_angle),\n            ),\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        self.magnets.append(cct2_innter)\n        self.elements.append((old_length, cct2_innter, cct_length))\n\n        # 构建内外侧四极交变 CCT\n        # 提取参数\n        agcct_small_r_out = small_rs[2]\n        agcct_small_r_in = small_rs[3]\n        agcct_winding_nums: List[int] = winding_numbers[1]\n        agcct_bending_angles: List[float] = bending_angles\n        agcct_bending_angles_rad: List[float] = BaseUtils.angle_to_radian(\n            agcct_bending_angles\n        )\n        agcct_tilt_angles: List[float] = tilt_angles[1]\n        agcct_current: float = currents[1]\n\n        # 构建 part1\n        agcct_index = 0\n        agcct_start_in = P2.origin()\n        agcct_start_out = P2.origin()\n        agcct_end_in = P2(\n            ((-1.0) ** agcct_index) * 2 * math.pi *\n            agcct_winding_nums[agcct_index],\n            agcct_bending_angles_rad[agcct_index],\n        )\n        agcct_end_out = P2(\n            ((-1.0) ** (agcct_index + 1))\n            * 2\n            * math.pi\n            * agcct_winding_nums[agcct_index],\n            agcct_bending_angles_rad[agcct_index],\n        )\n        agcct_part1_inner = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=agcct_small_r_in,\n            bending_angle=abs(agcct_bending_angles[agcct_index]),\n            tilt_angles=BaseUtils.list_multiply(agcct_tilt_angles, -1),\n            winding_number=agcct_winding_nums[agcct_index],\n            current=agcct_current,\n            starting_point_in_ksi_phi_coordinate=agcct_start_in,\n            end_point_in_ksi_phi_coordinate=agcct_end_in,\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        agcct_part1_length = big_r * \\\n            BaseUtils.angle_to_radian(abs(agcct_bending_angles[agcct_index]))\n        self.magnets.append(agcct_part1_inner)\n        self.elements.append(\n            (old_length, agcct_part1_inner, agcct_part1_length))\n\n        agcct_part1_outer = CCT.create_cct_along(\n            trajectory=self.trajectory,\n            s=old_length,\n            big_r=big_r,\n            small_r=agcct_small_r_out,\n            bending_angle=abs(agcct_bending_angles[agcct_index]),\n            tilt_angles=agcct_tilt_angles,\n            winding_number=agcct_winding_nums[agcct_index],\n            current=agcct_current,\n            starting_point_in_ksi_phi_coordinate=agcct_start_out,\n            end_point_in_ksi_phi_coordinate=agcct_end_out,\n            disperse_number_per_winding=disperse_number_per_winding,\n        )\n        self.magnets.append(agcct_part1_outer)\n        self.elements.append(\n            (old_length, agcct_part1_outer, agcct_part1_length))\n\n        old_length_i = old_length + agcct_part1_length\n        # 构建 part2 和之后的 part\n        for ignore in range(len(agcct_bending_angles) - 1):\n            agcct_index += 1\n            agcct_start_in = agcct_end_in + P2(\n                0,\n                agcct_bending_angles_rad[agcct_index - 1]\n                \/ agcct_winding_nums[agcct_index - 1],\n            )\n            agcct_start_out = agcct_end_out + P2(\n                0,\n                agcct_bending_angles_rad[agcct_index - 1]\n                \/ agcct_winding_nums[agcct_index - 1],\n            )\n            agcct_end_in = agcct_start_in + P2(\n                ((-1) ** agcct_index) * 2 * math.pi *\n                agcct_winding_nums[agcct_index],\n                agcct_bending_angles_rad[agcct_index],\n            )\n            agcct_end_out = agcct_start_out + P2(\n                ((-1) ** (agcct_index + 1))\n                * 2\n                * math.pi\n                * agcct_winding_nums[agcct_index],\n                agcct_bending_angles_rad[agcct_index],\n            )\n            agcct_parti_inner = CCT.create_cct_along(\n                trajectory=self.trajectory,\n                s=old_length,\n                big_r=big_r,\n                small_r=agcct_small_r_in,\n                bending_angle=abs(agcct_bending_angles[agcct_index]),\n                tilt_angles=BaseUtils.list_multiply(agcct_tilt_angles, -1),\n                winding_number=agcct_winding_nums[agcct_index],\n                current=agcct_current,\n                starting_point_in_ksi_phi_coordinate=agcct_start_in,\n                end_point_in_ksi_phi_coordinate=agcct_end_in,\n                disperse_number_per_winding=disperse_number_per_winding,\n            )\n            agcct_parti_length = big_r * \\\n                BaseUtils.angle_to_radian(\n                    abs(agcct_bending_angles[agcct_index]))\n            self.magnets.append(agcct_parti_inner)\n            self.elements.append(\n                (old_length_i, agcct_parti_inner, agcct_parti_length))\n\n            agcct_parti_outer = CCT.create_cct_along(\n                trajectory=self.trajectory,\n                s=old_length,\n                big_r=big_r,\n                small_r=agcct_small_r_out,\n                bending_angle=abs(agcct_bending_angles[agcct_index]),\n                tilt_angles=agcct_tilt_angles,\n                winding_number=agcct_winding_nums[agcct_index],\n                current=agcct_current,\n                starting_point_in_ksi_phi_coordinate=agcct_start_out,\n                end_point_in_ksi_phi_coordinate=agcct_end_out,\n                disperse_number_per_winding=disperse_number_per_winding,\n            )\n            self.magnets.append(agcct_parti_outer)\n            self.elements.append(\n                (old_length_i, agcct_parti_outer, agcct_parti_length))\n\n            old_length_i += agcct_parti_length\n\n        return self\n\n    def get_magnets(self) -> List[Magnet]:\n        return self.magnets\n\n    def get_trajectory(self) -> Trajectory:\n        return self.trajectory\n\n    def __str__(self) -> str:\n        return f\"beamline(magnet_size={len(self.magnets)}, traj_len={self.trajectory.get_length()})\"\n\n    def __repr__(self) -> str:\n        return self.__str__()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_278","text":"# -*- coding: UTF-8 -*-\n\nfrom mpi4py import MPI\nfrom sympy import pi, cos, sin\nimport pytest\nimport os\n\nfrom sympde.calculus import grad, dot\nfrom sympde.topology import ScalarFunctionSpace, VectorFunctionSpace\nfrom sympde.topology import ProductSpace\nfrom sympde.topology import element_of\nfrom sympde.topology import NormalVector\nfrom sympde.topology import Union\nfrom sympde.topology import Domain\nfrom sympde.expr     import BilinearForm, LinearForm, integral\nfrom sympde.expr     import Norm\nfrom sympde.expr     import find, EssentialBC\n\nfrom psydac.fem.basic          import FemField\nfrom psydac.api.discretization import discretize\n\n# ... get the mesh directory\ntry:\n    mesh_dir = os.environ['PSYDAC_MESH_DIR']\n\nexcept:\n    base_dir = os.path.dirname(os.path.realpath(__file__))\n    base_dir = os.path.join(base_dir, '..', '..', '..')\n    mesh_dir = os.path.join(base_dir, 'mesh')\n# ...\n\n#==============================================================================\ndef run_poisson_3d_dir(filename, solution, f, comm=None):\n\n    # ... abstract model\n    domain = Domain.from_file(filename)\n\n    V = ScalarFunctionSpace('V', domain)\n\n    x,y,z = domain.coordinates\n\n    F = element_of(V, name='F')\n\n    v = element_of(V, name='v')\n    u = element_of(V, name='u')\n\n    int_0 = lambda expr: integral(domain , expr)\n\n    expr = dot(grad(v), grad(u))\n    a = BilinearForm((v,u), int_0(expr))\n\n    expr = f*v\n    l = LinearForm(v, int_0(expr))\n\n    error = F - solution\n    l2norm = Norm(error, domain, kind='l2')\n    h1norm = Norm(error, domain, kind='h1')\n\n    bc = EssentialBC(u, 0, domain.boundary)\n    equation = find(u, forall=v, lhs=a(u,v), rhs=l(v), bc=bc)\n    # ...\n\n    # ... create the computational domain from a topological domain\n    domain_h = discretize(domain, filename=filename, comm=comm)\n    # ...\n\n    # ... discrete spaces\n    Vh = discretize(V, domain_h)\n    # ...\n\n    # ... dsicretize the equation using Dirichlet bc\n    equation_h = discretize(equation, domain_h, [Vh, Vh])\n    # ...\n\n    # ... discretize norms\n    l2norm_h = discretize(l2norm, domain_h, Vh)\n    h1norm_h = discretize(h1norm, domain_h, Vh)\n    # ...\n\n    # ... solve the discrete equation\n    x = equation_h.solve()\n    # ...\n\n    # ...\n    phi = FemField( Vh, x )\n    # ...\n\n    # ... compute norms\n    l2_error = l2norm_h.assemble(F=phi)\n    h1_error = h1norm_h.assemble(F=phi)\n    # ...\n\n    return l2_error, h1_error\n\n#==============================================================================\ndef run_poisson_3d_dirneu(filename, solution, f, boundary, comm=None):\n\n    assert( isinstance(boundary, (list, tuple)) )\n\n    # ... abstract model\n    domain = Domain.from_file(filename)\n\n    V = ScalarFunctionSpace('V', domain)\n\n    B_neumann = [domain.get_boundary(**kw) for kw in boundary]\n    if len(B_neumann) == 1:\n        B_neumann = B_neumann[0]\n\n    else:\n        B_neumann = Union(*B_neumann)\n\n    x,y,z = domain.coordinates\n\n    F = element_of(V, name='F')\n\n    v = element_of(V, name='v')\n    u = element_of(V, name='u')\n\n    nn = NormalVector('nn')\n\n    int_0 = lambda expr: integral(domain , expr)\n    int_1 = lambda expr: integral(B_neumann , expr)\n\n    expr = dot(grad(v), grad(u))\n    a = BilinearForm((v,u), int_0(expr))\n\n    expr = f*v\n    l0 = LinearForm(v, int_0(expr))\n\n    expr = v*dot(grad(solution), nn)\n    l_B_neumann = LinearForm(v, int_1(expr))\n\n    expr = l0(v) + l_B_neumann(v)\n    l = LinearForm(v, expr)\n\n    error = F-solution\n    l2norm = Norm(error, domain, kind='l2')\n    h1norm = Norm(error, domain, kind='h1')\n\n    B_dirichlet = domain.boundary.complement(B_neumann)\n    bc = EssentialBC(u, 0, B_dirichlet)\n\n    equation = find(u, forall=v, lhs=a(u,v), rhs=l(v), bc=bc)\n    # ...\n\n    # ... create the computational domain from a topological domain\n    domain_h = discretize(domain, filename=filename, comm=comm)\n    # ...\n\n    # ... discrete spaces\n    Vh = discretize(V, domain_h)\n    # ...\n\n    # ... dsicretize the equation using Dirichlet bc\n    equation_h = discretize(equation, domain_h, [Vh, Vh])\n    # ...\n\n    # ... discretize norms\n    l2norm_h = discretize(l2norm, domain_h, Vh)\n    h1norm_h = discretize(h1norm, domain_h, Vh)\n    # ...\n\n    # ... solve the discrete equation\n    x = equation_h.solve()\n    # ...\n\n    # ...\n    phi = FemField( Vh, x )\n    # ...\n\n    # ... compute norms\n    l2_error = l2norm_h.assemble(F=phi)\n    h1_error = h1norm_h.assemble(F=phi)\n    # ...\n\n    return l2_error, h1_error\n\n#==============================================================================\ndef run_laplace_3d_neu(filename, solution, f, comm=None):\n\n    # ... abstract model\n    domain = Domain.from_file(filename)\n\n    V = ScalarFunctionSpace('V', domain)\n\n    B_neumann = domain.boundary\n\n    x,y,z = domain.coordinates\n\n    F = element_of(V, name='F')\n\n    v = element_of(V, name='v')\n    u = element_of(V, name='u')\n\n    nn = NormalVector('nn')\n\n    int_0 = lambda expr: integral(domain , expr)\n    int_1 = lambda expr: integral(B_neumann , expr)\n\n    expr = dot(grad(v), grad(u)) + v*u\n    a = BilinearForm((v,u), int_0(expr))\n\n    expr = f*v\n    l0 = LinearForm(v, int_0(expr))\n\n    expr = v*dot(grad(solution), nn)\n    l_B_neumann = LinearForm(v, int_1(expr))\n\n    expr = l0(v) + l_B_neumann(v)\n    l = LinearForm(v, expr)\n\n    error = F-solution\n    l2norm = Norm(error, domain, kind='l2')\n    h1norm = Norm(error, domain, kind='h1')\n\n    equation = find(u, forall=v, lhs=a(u,v), rhs=l(v))\n    # ...\n\n    # ... create the computational domain from a topological domain\n    domain_h = discretize(domain, filename=filename, comm=comm)\n    # ...\n\n    # ... discrete spaces\n    Vh = discretize(V, domain_h)\n    # ...\n\n    # ... dsicretize the equation using Dirichlet bc\n    equation_h = discretize(equation, domain_h, [Vh, Vh])\n    # ...\n\n    # ... discretize norms\n    l2norm_h = discretize(l2norm, domain_h, Vh)\n    h1norm_h = discretize(h1norm, domain_h, Vh)\n    # ...\n\n    # ... solve the discrete equation\n    x = equation_h.solve()\n    # ...\n\n    # ...\n    phi = FemField( Vh, x )\n    # ...\n\n    # ... compute norms\n    l2_error = l2norm_h.assemble(F=phi)\n    h1_error = h1norm_h.assemble(F=phi)\n    # ...\n\n    return l2_error, h1_error\n\n\n###############################################################################\n#            SERIAL TESTS\n###############################################################################\n\n#==============================================================================\ndef test_api_poisson_3d_dir_collela():\n\n    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(pi*x)*sin(pi*y)*sin(pi*z)\n    f        = 3*pi**2*sin(pi*x)*sin(pi*y)*sin(pi*z)\n\n    l2_error, h1_error = run_poisson_3d_dir(filename, solution, f)\n\n    expected_l2_error =  0.15687494944868827\n    expected_h1_error =  1.518006054794389\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n\n#==============================================================================\ndef test_api_poisson_3d_dirneu_identity_2():\n    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(0.5*pi*x)*sin(pi*y)*sin(pi*z)\n    f        = (9.\/4.)*pi**2*solution\n\n    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f, [{'axis': 0, 'ext': 1}])\n\n    expected_l2_error =  0.001438835012218704\n    expected_h1_error =  0.03929404299152016\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n\n#==============================================================================\ndef test_api_poisson_3d_dirneu_identity_13():\n    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = cos(0.5*pi*x)*cos(0.5*pi*y)*sin(pi*z)\n    f        = (3.\/2.)*pi**2*solution\n\n    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n                                               [{'axis': 0, 'ext': -1},\n                                                {'axis': 1, 'ext': -1}])\n\n    expected_l2_error =  0.0010275451113313282\n    expected_h1_error =  0.027938446826372126\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n#==============================================================================\ndef test_api_poisson_3d_dirneu_identity_24():\n    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(0.5*pi*x)*sin(0.5*pi*y)*sin(pi*z)\n    f        = (3.\/2.)*pi**2*solution\n\n    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n                                               [{'axis': 0, 'ext': 1},\n                                                {'axis': 1, 'ext': 1}])\n\n    expected_l2_error =  0.001027545111330973\n    expected_h1_error =  0.027938446826371813\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_poisson_3d_dirneu_identity_123():\n#    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = cos(0.25*pi*x)*cos(0.5*pi*y)*sin(pi*z)\n#    f        = (21.\/16.)*pi**2*solution\n#\n#    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n#                                               [{'axis': 0, 'ext': -1},\n#                                                {'axis': 0, 'ext': 1},\n#                                                {'axis': 1, 'ext': -1}])\n#\n#    expected_l2_error =  0.0013124098938804697\n#    expected_h1_error =  0.035441679549890456\n#\n#    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n#    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_poisson_3d_dirneu_identity_1235():\n#    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = cos(0.25*pi*x)*cos(0.5*pi*y)*cos(0.5*pi*z)\n#    f        = (9.\/16.)*pi**2*solution\n#\n#    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n#                                               [{'axis': 0, 'ext': -1},\n#                                                {'axis': 0, 'ext': 1},\n#                                                {'axis': 1, 'ext': -1},\n#                                                {'axis': 2, 'ext': -1}])\n#\n#    expected_l2_error =  0.00019677816039781896\n#    expected_h1_error =  0.0058786142515790405\n#\n#    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n#    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n\n#==============================================================================\ndef test_api_poisson_3d_dirneu_collela_2():\n    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(0.25*pi*(x+1.))*sin(pi*y)*sin(pi*z)\n    f        = (33.\/16.)*pi**2*solution\n\n    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n                                               [{'axis': 0, 'ext': 1}])\n\n    expected_l2_error =  0.06091240085930318\n    expected_h1_error =  0.6380043932563333\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_poisson_3d_dirneu_collela_13():\n#    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = sin(0.25*pi*(1.-x))*sin(0.25*pi*(1.-y))*sin(pi*z)\n#    f        = (9.\/8.)*pi**2*solution\n#\n#    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n#                                               [{'axis': 0, 'ext': -1},\n#                                                {'axis': 1, 'ext': -1}])\n#\n#    expected_l2_error =  0.03786854933218588\n#    expected_h1_error =  0.38437667047918933\n#\n#    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n#    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n#==============================================================================\ndef test_api_poisson_3d_dirneu_collela_24():\n    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(0.25*pi*(x+1.))*sin(0.25*pi*(y+1.))*sin(pi*z)\n    f        = (9.\/8.)*pi**2*solution\n\n    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n                                               [{'axis': 0, 'ext': 1},\n                                                {'axis': 1, 'ext': 1}])\n\n    expected_l2_error =  0.03793880183960465\n    expected_h1_error =  0.38439642303250143\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_poisson_3d_dirneu_collela_123():\n#    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = cos(pi*x)*sin(0.25*pi*(1.-y))*sin(pi*z)\n#    f        = (33.\/16.)*pi**2*solution\n#\n#    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n#                                               [{'axis': 0, 'ext': -1},\n#                                                {'axis': 0, 'ext': 1},\n#                                                {'axis': 1, 'ext': -1}])\n#\n#    expected_l2_error =  0.11963989196330076\n#    expected_h1_error =  1.1267766354124575\n#\n#    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n#    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n#\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_poisson_3d_dirneu_collela_1235():\n#    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = cos(pi*x)*sin(0.25*pi*(1.-y))*sin(0.25*pi*(1.-z))\n#    f        = (9.\/8.)*pi**2*solution\n#\n#    l2_error, h1_error = run_poisson_3d_dirneu(filename, solution, f,\n#                                               [{'axis': 0, 'ext': -1},\n#                                                {'axis': 0, 'ext': 1},\n#                                                {'axis': 1, 'ext': -1},\n#                                                {'axis': 2, 'ext': -1}])\n#\n#    expected_l2_error =  0.13208728319093133\n#    expected_h1_error =  0.9964934429086868\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n#==============================================================================\ndef test_api_laplace_3d_neu_identity():\n    filename = os.path.join(mesh_dir, 'identity_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = cos(pi*x)*cos(pi*y)*cos(pi*z)\n    f        = (3.*pi**2 + 1.)*solution\n\n    l2_error, h1_error = run_laplace_3d_neu(filename, solution, f)\n\n    expected_l2_error =  0.0016975430150953524\n    expected_h1_error =  0.047009063231215\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n##==============================================================================\n## TODO DEBUG, not working since merge with devel\n#def test_api_laplace_3d_neu_collela():\n#    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n#\n#    from sympy.abc import x,y,z\n#\n#    solution = cos(pi*x)*cos(pi*y)*cos(pi*z)\n#    f        = (3.*pi**2 + 1.)*solution\n#\n#    l2_error, h1_error = run_laplace_3d_neu(filename, solution, f)\n#\n#    expected_l2_error =  0.1768000505351402\n#    expected_h1_error =  1.7036022067226382\n#\n#    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n#    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n###############################################################################\n#            PARALLEL TESTS\n###############################################################################\n\n#==============================================================================\n@pytest.mark.parallel\ndef test_api_poisson_3d_dir_collela():\n\n    filename = os.path.join(mesh_dir, 'collela_3d.h5')\n\n    from sympy.abc import x,y,z\n\n    solution = sin(pi*x)*sin(pi*y)*sin(pi*z)\n    f        = 3*pi**2*sin(pi*x)*sin(pi*y)*sin(pi*z)\n\n    l2_error, h1_error = run_poisson_3d_dir(filename, solution, f,\n                                            comm=MPI.COMM_WORLD)\n\n    expected_l2_error =  0.15687494944868827\n    expected_h1_error =  1.518006054794389\n\n    assert( abs(l2_error - expected_l2_error) < 1.e-7)\n    assert( abs(h1_error - expected_h1_error) < 1.e-7)\n\n\n#==============================================================================\n# CLEAN UP SYMPY NAMESPACE\n#==============================================================================\n\ndef teardown_module():\n    from sympy import cache\n    cache.clear_cache()\n\ndef teardown_function():\n    from sympy import cache\n    cache.clear_cache()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_279","text":"<filename>modules\/math-codes\/modules\/statistics-and-probability\/src\/skew_kurt-v1.py\n########################################################\n# <NAME> - drigols                              #\n# Last update: 17\/12\/2021                              #\n########################################################\n\nimport pandas as pd\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport scipy.stats as stats\n\ndf = pd.DataFrame({\n  'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n  'Salary':[50000, 54000, 50000, 189000, 55000, 40000, 59000],\n  'Hours':[41, 40, 36, 30, 35, 39, 40],\n  'Grade':[50, 50, 46, 95, 50, 5, 57]\n})\n\n# Cria uma lista que vai representar os labels do nosso DataFrame:\n# - Salary;\n# - Hours;\n# - Grade.\nnumcols = ['Salary', 'Hours', 'Grade'] \n\n# O laço for vai passar por cada item na nosssa lista de labels(numcols) fazendo o seguinte:\n# - Imprimindo a assimétria (skewness);\n# - Imprimindo a curtose (kurtosis);\n# - Pegando a densidade da label;\n# - Criando um Histograma para a label;\n# - Adicionando a densidade\/linha de densidade no plot\/histograma.\nfor col in numcols:\n  print(df[col].name + ' skewness: ' + str(df[col].skew())) # Imprime a Assimetria do label\/coluna no laço for.\n  print(df[col].name + ' kurtosis: ' + str(df[col].kurt())) # Imprime a Curtose do label\/coluna no laço for.\n  density = stats.gaussian_kde(df[col]) # Pega a densidade do label\/coluna no laço for.\n  n, x, _ = plt.hist(df[col], histtype='step', density=True, bins=25) # Cria o plot do label\/coluna no laço for.\n  plt.plot(x, density(x)*6) # Cria a linha de densidade do label no laço for.\n  plt.show()\n  print('\\n')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_280","text":"<reponame>samcom12\/anuga_core\n\"\"\"\n\nFunction which can be useful when setting quantities\n\n\"\"\"\n\nimport copy\nimport os\nimport anuga.utilities.spatialInputUtil as su\n\n\ndef make_nearestNeighbour_quantity_function(\n    quantity_xyValueIn,\n    domain,\n    threshold_distance=9.0e+100,\n    background_value=9.0e+100,\n    k_nearest_neighbours=1,\n    method='average'\n):\n    \"\"\"\n    Function which makes another function, which can be used in set_quantity\n    Idea: For every point x,y in the domain, we want to set a quantity based on\n          the 'nearest-neighbours' from quantity_xyValue (a 3 column array with\n          x,y,quantity-value),\n          UNLESS the distance from x,y to the nearest-neighbour is >\n            threshold_distance.\n          In the latter case, we want to set the quantity value to\n            'background_value'\n\n          We need a function f(x,y) to do that. This routine makes the\n          function, with the desired quantity_xyValue points,\n          threshold_distance, and background_value\n    INPUTS:\n        @param quantity_xyValueIn -- A 3 column array with 'x,y, Value'\n            defining the points used to set the new quantity values in\n            georeferenced coordinates\n        @param domain -- The ANUGA domain\n        @param k_nearest_neighbors --- Number of nearest neighbours used in calculation\n        @param threshold_distance -- Points greater than this distance from\n            their nearest quantity_xyValue point are set to background_value\n        @param background_value -- see 'threshold_distance'\n        @param method -- Three methods; 'average' uses an inverse-distance-weighted average\n               of the k nearest neighbours is used:\n               'min' the minimum of the k nearest neighbours is used:\n               'max' the maximum of the k nearest neighbours is used.\n    OUTPUTS:\n        A function f which can be passed to domain.set_quantity('myQuantity', f)\n    \"\"\"\n\n    import scipy\n    import scipy.interpolate\n    import scipy.spatial\n\n    if(len(quantity_xyValueIn.shape) > 1):\n        quantity_xyValue = quantity_xyValueIn\n    else:\n        # Treat the single-point case\n        quantity_xyValue = quantity_xyValueIn.reshape((1, 3))\n\n    # Make a function which gives us the ROW-INDEX of the nearest xy point in\n    # quantity_xyValue\n    # quantity_xy_interpolator = scipy.interpolate.NearestNDInterpolator(\n    #    quantity_xyValue[:,0:2],\n    #    scipy.arange(len(quantity_xyValue[:,2])))\n\n    # Make a function which returns k-nearest-neighbour indices + distances\n    quantity_xy_interpolator = scipy.spatial.cKDTree(quantity_xyValue[:, 0:2])\n\n    # Make a function of x,y which we can pass to domain.set_quantity\n    def quant_NN_fun(x, y):\n        \"\"\"\n        Function to assign quantity from the nearest point in quantity_xyValue,\n        UNLESS the point is more than 'threshold_distance' away from the\n        nearest point, in which case the background value is used\n        \"\"\"\n\n        import scipy\n        import scipy.interpolate\n        import scipy.spatial\n        import numpy as np\n\n        x = np.asarray(x).reshape(1, -1)[0, :]\n        y = np.asarray(y).reshape(1, -1)[0, :]\n\n        # Since ANUGA stores x,y internally in non-georeferenced coordinates,\n        # we adjust them here\n        xll = domain.geo_reference.xllcorner\n        yll = domain.geo_reference.yllcorner\n        z = np.zeros(shape=(len(x), 2))\n        z[:, 0] = x+xll\n        z[:, 1] = y+yll\n\n        # This will hold the quantity values\n        quantity_output = x*0. + background_value\n        # Compute the index of the nearest-neighbour in quantity_xyValue\n        neighbour_data = quantity_xy_interpolator.query(z,\n                                                        k=k_nearest_neighbours)\n\n        # Next find indices with distance < threshold_distance\n        if(k_nearest_neighbours == 1):\n            dist_lt_thresh = neighbour_data[0] < threshold_distance\n        else:\n            dist_lt_thresh = neighbour_data[0][:, 0] < threshold_distance\n\n        dist_lt_thresh = dist_lt_thresh.nonzero()[0]\n\n        # Initialise output\n        quantity_output = x*0 + background_value\n\n        # Interpolate\n        if len(dist_lt_thresh) > 0:\n            if method == 'min':\n                numerator = 9.0e+100\n                for i in range(k_nearest_neighbours):\n                    if(k_nearest_neighbours == 1):\n                        distances = neighbour_data[0][dist_lt_thresh]\n                        indices = neighbour_data[1][dist_lt_thresh]\n                        values = quantity_xyValue[indices, 2]\n                        numerator = np.minimum(numerator, values)\n                    else:\n                        distances = neighbour_data[0][dist_lt_thresh, i]\n                        indices = neighbour_data[1][dist_lt_thresh, i]\n                        values = quantity_xyValue[indices, 2]\n                        numerator = np.minimum(numerator, values)\n                quantity_output[dist_lt_thresh] = numerator\n            elif method == 'max':\n                numerator = -9.0e+100\n                for i in range(k_nearest_neighbours):\n                    if(k_nearest_neighbours == 1):\n                        distances = neighbour_data[0][dist_lt_thresh]\n                        indices = neighbour_data[1][dist_lt_thresh]\n                        values = quantity_xyValue[indices, 2]\n                        numerator = np.maximum(numerator, values)\n                    else:\n                        distances = neighbour_data[0][dist_lt_thresh, i]\n                        indices = neighbour_data[1][dist_lt_thresh, i]\n                        values = quantity_xyValue[indices, 2]\n                        numerator = np.maximum(numerator, values)\n                quantity_output[dist_lt_thresh] = numerator\n            else:\n                numerator = 0\n                denominator = 0\n                for i in range(k_nearest_neighbours):\n                    if(k_nearest_neighbours == 1):\n                        distances = neighbour_data[0][dist_lt_thresh]\n                        indices = neighbour_data[1][dist_lt_thresh]\n                    else:\n                        distances = neighbour_data[0][dist_lt_thresh, i]\n                        indices = neighbour_data[1][dist_lt_thresh, i]\n\n                    inverse_distance = 1.0\/(distances+1.0e-100)\n                    values = quantity_xyValue[indices, 2]\n                    numerator += values*inverse_distance\n                    denominator += inverse_distance\n\n                quantity_output[dist_lt_thresh] = numerator \/ denominator\n\n        return quantity_output\n\n    # Return the quantity function\n    return quant_NN_fun\n\n\n###############################################################################\n\ndef composite_quantity_setting_function(poly_fun_pairs,\n                                        domain,\n                                        clip_range=None,\n                                        nan_treatment='exception',\n                                        nan_interpolation_region_polygon=None,\n                                        default_k_nearest_neighbours=1,\n                                        default_raster_interpolation='pixel',\n                                        verbose=True):\n    \"\"\" Make a 'composite function' to set quantities -- applies different\n        functions inside different polygon regions.\n\n        poly_fun_pairs = [ [p0, f0], [p1, f1], ...]\n\n        Where:\n\n          fi is a function,\n             or a constant,\n             or a '.txt' or '.csv' file with comma separated xyz data\n                and an optional header row which contains letters,\n             or the name of a gdal-compatible rasterFile\n                (not ending in .txt or .csv),\n             or a numpy array with 3 columns\n\n          pi is a polygon (anuga polygon format),\n            or a polygon filename (shapefile or a csv format that\n                                    anuga.read_polygon will read),\n            or None ( equivalent to a polygon with zero area),\n            or 'All' (equivalent to a polygon covering everything)\n            or 'Extent' in the case that fi is a rasterFile name\n                (equivalent to a polygon with the same extent as the raster)\n\n        IMPORTANT: When polygons overlap, the first elements of the list are\n                   given priority. The approach is:\n                   First f0 is applied to all points in p0, and we record\n                     that these points have been 'set'\n                   Next f1 is applied to all points in p1 which have not\n                     been 'set', and then we record those points as being 'set'\n                   Next f2 is applied to all points in p2 which have not\n                     been 'set', and then we record those points as being 'set'\n                   ... etc\n\n        INPUT:\n          @param poly_fun_pairs = [ [p0, f0], [p1, f1], ...]\n\n              where fi(x,y) is a function returning quantity values at points,\n                or any of the special cases below\n\n              SPECIAL fi CASES:\n              fi = a constant in which case points in the polygon are\n                   set to that value,\n              fi = a .txt or .csv file name containing x, y, z data,\n                     with comma separators and an optional header row\n                     containing letters (nearest neighbour interpolation is used)\n              fi = a string rasterFile name (not ending in .txt or .csv)\n                    which can be passed to quantityRasterFun to make a function\n              fi = a numpy array with 3 columns (x,y,Value) in which case\n                   nearest-neighbour interpolation is used on the points\n\n              pi are polygons where we want to use fi inside\n              (anuga polygon format) or any of the special cases below\n              SPECIAL pi CASES:\n              If pi is a filename ending in .shp or a csv format that\n                anuga.read_polygon can read, we assume it contains a polygon\n                we have to read\n              If any pi = 'All', then we assume that ALL unset points are set\n                 using the function. This CAN ONLY happen in the last [fi,pi]\n                 pair where pi is not None (since fi will be applied to\n                 all remaining points -- so anything else is probably an\n                 input mistake)\n              If any pi = None, then that [fi,pi] pair is skipped\n              If pi = 'Extent' and fi is the name of a raster file, then the\n                extent of the raster file is used to define the polygon\n\n          @param domain = ANUGA domain object\n\n          @param clip_range = List with the same length as poly_fun_pairs,\n                 of the form:\n                 [ [min0, max0], [min1, max1], ...]\n                 After f0 is applied in p0, its values will be 'clipped' to the\n                 range\n                    [min0, max0]\n                 , and similarly for the other fi\n\n          @param nan_treatment = 'exception' or 'fall_through' -- string determining\n                what to do if F(x,y) is nan. The default 'exception' raises an exception.\n                The value 'fall_through' allows the function to try lower-priority\n                poly,fun pairs (in sequence) to set the value.\n\n          @param nan_interpolation_region_polygon = None, or 'All', or a list\n                of csv or shp filenames containing polygons, or a list of\n                anuga polygon objects.\n\n                If it is not None, then all x,y points which evaluate to nan\n                on their **first preference** dataset are recorded, and as a\n                final step, the values at these x,y points\n                **which are inside the nan_interpolation_region_polygon**\n                are interpolated from the other x,y,F(x,y) values.\n\n                Nearest neighbour interpolation is used, with\n                k_nearest_neighbours taken from default_k_nearest_neighbours.\n\n                Note that if nan_treatment = 'exception', then nan's will cause\n                exceptions earlier on in this routine, so you will need\n                nan_treatment = 'fall_through' to use this option.\n\n                Example of why you might want this:\n                    Say you have 2 elevation datasets (one defining the\n                    topography above MSL, and the other defining the topography\n                    below MSL). There might be small nan gaps between them,\n                    which you would like to fill with interpolation. That\n                    can be done with this option, by including the nan regions\n                    in one of the elevation-dataset-polygons pi.\n\n          @param default_k_nearest_neighbours = integer >=1 . The value of\n                k_nearest_neighbours passed to\n                make_nearestNeighbour_quantity_function when a 'special_case'\n                value of fi is passed in (either a point array or a .txt or\n                .csv point file), or when nan_interpolation_region_polygon is\n                not None\n\n          @param default_raster_interpolation = 'pixel' or 'bilinear'. The value of\n                'interpolation' passed to quantityRasterFun if a raster filename\n                is passed as one of the fi.\n\n          @param verbose TRUE\/FALSE Print more information\n\n        OUTPUT: A function F(x,y) which can be used e.g. to set the quantity\n                domain.set_quantity('elevation', F)\n\n    \"\"\"\n    import os\n    import numpy\n    from anuga.geometry.polygon import inside_polygon\n\n    # Check that clip_range has the right form\n    if clip_range is not None:\n        if len(clip_range) != len(poly_fun_pairs):\n            msg = ' clip_range must be the same ' +\\\n                  'length as poly_fun_pairs, or None'\n            raise ValueError(msg)\n        # Check that min < = max\n        for i in range(len(clip_range)):\n            if clip_range[i][0] > clip_range[i][1]:\n                raise Exception('clip_range minima must be less than maxima')\n\n    def F(x, y):\n        \"\"\"This is the function returned by composite_quantity_setting_function\n           It can be passed to set_quantity\n        \"\"\"\n        isSet = numpy.zeros(len(x))  # 0\/1 - record if each point has been set\n        quantityVal = x*0 + numpy.nan  # Function return value\n\n        # Record points which evaluated to nan on their first preference\n        # dataset.\n        was_ever_nan = (x*0).astype(int)\n\n        lpf = len(poly_fun_pairs)\n        if(lpf <= 0):\n            raise Exception('Must have at least 1 fun-poly-pair')\n\n        # Make an array of 'transformed' spatial coordinates, for checking\n        # polygon inclusion\n        xll = domain.geo_reference.xllcorner\n        yll = domain.geo_reference.yllcorner\n        xy_array_trans = numpy.vstack([x+xll, y+yll]).transpose()\n\n        # Check that none of the pi polygons [except perhaps the last] is 'All'\n        for i in range(lpf-1):\n            if(poly_fun_pairs[i][0] == 'All'):\n                # This is only ok if all the othe poly_fun_pairs are None\n                remaining_poly_fun_pairs_are_None = \\\n                    [poly_fun_pairs[j][0] is None for j in range(i+1, lpf)]\n                if(not all(remaining_poly_fun_pairs_are_None)):\n                    raise Exception('Can only have the last polygon = All')\n\n        # Main Loop\n        # Apply the fi inside the pi\n        for i in range(lpf):\n            fi = poly_fun_pairs[i][1]  # The function\n            pi = poly_fun_pairs[i][0]  # The polygon\n\n            # Quick exit\n            if(pi is None):\n                continue\n\n            ###################################################################\n            # Get indices fInds of points in polygon pi which are not already\n            # set\n            ###################################################################\n            if(pi == 'All'):\n                # Get all unset points\n                fInside = (1 - isSet)\n                fInds = (fInside == 1).nonzero()[0]\n\n            else:\n                if pi == 'Extent':\n                    # Here fi MUST be a gdal-compatible raster\n                    if not isinstance(fi, str):\n                        msg = ' pi = \"Extent\" can only be used when fi is a' +\\\n                              ' raster file name'\n                        raise Exception(msg)\n\n                    if not os.path.exists(fi):\n                        msg = 'fi ' + str(fi) + ' is supposed to be a ' +\\\n                              ' raster filename, but it could not be found'\n                        raise Exception(msg)\n\n                    # Then we get the extent from the raster itself\n                    pi_path = su.getRasterExtent(fi, asPolygon=True)\n\n                    if verbose:\n                        print('Extracting extent from raster: ', fi)\n                        print('Extent: ', pi_path)\n\n                elif (type(pi) == str) and os.path.isfile(pi):\n                    # pi is a file\n                    pi_path = su.read_polygon(pi)\n\n                else:\n                    # pi is the actual polygon data\n                    pi_path = pi\n\n                # Get the insides of unset points inside pi_path\n                notSet = (isSet == 0.).nonzero()[0]\n                fInds = inside_polygon(xy_array_trans[notSet, :], pi_path)\n                fInds = notSet[fInds]\n\n            if len(fInds) == 0:\n                # No points found, move on\n                continue\n\n            ###################################################################\n            # Evaluate fi at the points inside pi\n            ###################################################################\n\n            # We use various tricks to infer whether fi is a function,\n            # a constant, a file (raster or csv), or an array\n            if hasattr(fi, '__call__'):\n                # fi is a function or a callable object\n                quantityVal[fInds] = fi(x[fInds], y[fInds])\n\n            elif isinstance(fi, (int, int, float)):\n                # fi is a numerical constant\n                quantityVal[fInds] = fi*1.0\n\n            elif type(fi) is str and os.path.exists(fi):\n                # fi is a file which is assumed to be\n                # a gdal-compatible raster OR an x,y,z elevation file\n                if os.path.splitext(fi)[1] in ['.txt', '.csv']:\n                    fi_array = su.read_csv_optional_header(fi)\n                    # Check the results\n                    if fi_array.shape[1] != 3:\n                        print('Treated input file ' + fi +\n                              ' as xyz array with an optional header')\n                        msg = 'Array should have 3 columns -- x,y,value'\n                        raise Exception(msg)\n\n                    newfi = make_nearestNeighbour_quantity_function(\n                        fi_array, domain,\n                        k_nearest_neighbours=default_k_nearest_neighbours)\n                    quantityVal[fInds] = newfi(x[fInds], y[fInds])\n\n                else:\n                    # Treating input file as a raster\n                    newfi = quantityRasterFun(domain, fi,\n                                              interpolation=default_raster_interpolation)\n                    quantityVal[fInds] = newfi(x[fInds], y[fInds])\n\n            elif type(fi) is numpy.ndarray:\n                if fi.shape[1] != 3:\n                    msg = 'Array should have 3 columns -- x,y,value'\n                    raise Exception(msg)\n                newfi = make_nearestNeighbour_quantity_function(fi, domain,\n                                                                k_nearest_neighbours=default_k_nearest_neighbours)\n                quantityVal[fInds] = newfi(x[fInds], y[fInds])\n\n            else:\n                print('ERROR: with function from ' + fi)\n                msg = 'Cannot make function from type ' + str(type(fi))\n                raise Exception(msg)\n\n            ###################################################################\n            # Check for nan values\n            ###################################################################\n            #nan_flag = (quantityVal[fInds] != quantityVal[fInds])\n            nan_flag = 1*numpy.isnan(quantityVal[fInds])\n            nan_inds = nan_flag.nonzero()[0]\n            was_ever_nan[fInds[nan_inds]] = 1\n\n            if len(nan_inds) > 0:\n                if nan_treatment == 'exception':\n                    msg = 'nan values generated by the poly_fun_pair at '\\\n                          'index ' + str(i) + ' '\\\n                          'in composite_quantity_setting_function. ' + \\\n                          'To allow these values to be set by later ' + \\\n                          'poly_fun pairs, pass the argument ' + \\\n                          'nan_treatment=\"fall_through\" ' + \\\n                          'to composite_quantity_setting_function'\n                    raise Exception(msg)\n\n                elif nan_treatment == 'fall_through':\n                    msg = 'WARNING: nan values generated by the ' + \\\n                          'poly_fun_pair at index ' + str(i) + ' '\\\n                          'in composite_quantity_setting_function. ' + \\\n                          'They will be passed to later poly_fun_pairs'\n                    if verbose:\n                        print(msg)\n                    not_nan_inds = (1-nan_flag).nonzero()[0]\n\n                    if len(not_nan_inds) > 0:\n                        fInds = fInds[not_nan_inds]\n                    else:\n                        # All values are nan\n                        msg = '( Actually all the values were nan - ' + \\\n                              'Are you sure they should be? Possible error?)'\n                        if verbose:\n                            print(msg)\n                        continue\n\n                else:\n                    msg = 'Found nan values in ' + \\\n                          'composite_quantity_setting_function but ' + \\\n                          'nan_treatment is not a recognized value'\n                    raise Exception(msg)\n\n            # Record that the points have been set\n            isSet[fInds] = 1\n\n            # Enforce clip_range\n            if clip_range is not None:\n                lower_bound = clip_range[i][0]\n                upper_bound = clip_range[i][1]\n                quantityVal[fInds] = numpy.maximum(\n                    quantityVal[fInds], lower_bound)\n                quantityVal[fInds] = numpy.minimum(\n                    quantityVal[fInds], upper_bound)\n\n        # End of loop\n\n        # Find points which were nan on their first preference dataset + are\n        # inside nan_interpolation_region_polygon. Then reinterpolate their\n        # values from the other x,y, quantityVal points.\n        if (nan_interpolation_region_polygon is not None) &\\\n           (was_ever_nan.sum() > 0):\n            if nan_interpolation_region_polygon == 'All':\n                points_to_reinterpolate = was_ever_nan.nonzero()[0]\n            else:\n                # nan_interpolation_region_polygon contains information on 1 or\n                # more polygons\n                # Inside those polygons, we need to re-interpolate points which\n                # first evaluted to na\n                possible_points_to_reint = was_ever_nan.nonzero()[0]\n                points_to_reinterpolate = numpy.array([]).astype(int)\n\n                for i in range(len(nan_interpolation_region_polygon)):\n                    nan_pi = nan_interpolation_region_polygon[i]\n\n                    # Ensure nan_pi = list of x,y points making a polygon\n                    if(type(nan_pi) == str):\n                        nan_pi = su.read_polygon(nan_pi)\n\n                    points_in_nan_pi = inside_polygon(\n                        xy_array_trans[possible_points_to_reint, :],\n                        nan_pi)\n\n                    if len(points_in_nan_pi) > 0:\n                        points_to_reinterpolate = numpy.hstack(\n                            [points_to_reinterpolate,\n                             possible_points_to_reint[points_in_nan_pi]])\n\n            if verbose:\n                print('Re-interpolating ', len(points_to_reinterpolate),\n                      ' points which were nan under their',\n                      ' first-preference and are inside the',\n                      ' nan_interpolation_region_polygon')\n\n            if len(points_to_reinterpolate) > 0:\n                msg = 'WARNING: nan interpolation is being applied. This ',\\\n                      'should be done in serial prior to distributing the ',\\\n                      'domain, as there is no parallel communication ',\\\n                      'implemented yet [so parallel results might depend on ',\\\n                      'the number of processes]'\n                if verbose:\n                    print(msg)\n\n            # Find the interpolation points = points not needing reinterpolation\n            ip = x*0 + 1\n            ip[points_to_reinterpolate] = 0\n            number_of_ip = ip.sum()\n            ip = ip.nonzero()[0]\n\n            # Check that none of the ip points has an nan value\n            nan_ip = (quantityVal[ip] != quantityVal[ip]).nonzero()[0]\n\n            if len(nan_ip) > 0:\n                print('There are ', len(nan_ip), ' points outside the ',\n                      'nan_interpolation_region_polygon have nan values.')\n                print('The user should ensure this does not happen.')\n                print('The points have the following coordinates:')\n                print(xy_array_trans[ip[nan_ip], :])\n                msg = \"There are nan points outside of \" +\\\n                      \"nan_interpolation_region_polygon, even after all \" +\\\n                      \"fall-through's\"\n                raise Exception(msg)\n\n            if(number_of_ip < default_k_nearest_neighbours):\n                raise Exception('Too few non-nan points to interpolate from')\n\n            # Make function for re-interpolation. Note this requires\n            # x,y,z in georeferenced coordinates, whereas x,y are ANUGA\n            # coordinates\n            reinterp_F = make_nearestNeighbour_quantity_function(\n                numpy.vstack([xy_array_trans[ip, 0], xy_array_trans[ip, 1],\n                              quantityVal[ip]]).transpose(),\n                domain,\n                k_nearest_neighbours=default_k_nearest_neighbours)\n\n            # re-interpolate\n            quantityVal[points_to_reinterpolate] = reinterp_F(\n                x[points_to_reinterpolate], y[points_to_reinterpolate])\n\n            isSet[points_to_reinterpolate] = 1\n\n        # Check there are no remaining nan values\n        if(min(isSet) != 1):\n            print('Some points remain as nan, which is not allowed')\n            unset_inds = (isSet != 1).nonzero()[0]\n            lui = min(5, len(unset_inds))\n            print('There are ', len(unset_inds), ' such points')\n            print('Here are a few:')\n            for i in range(lui):\n                print(x[unset_inds[i]] + xll, y[unset_inds[i]] + yll)\n            raise Exception('It seems the input data needs to be fixed')\n\n        return quantityVal\n        # END OF FUNCTION F(x,y)\n\n    return F\n\n##############################################################################\n\n\ndef quantityRasterFun(domain, rasterFile, interpolation='pixel'):\n    \"\"\"\n    Make a function whick takes x,y in ANUGA coordinates, and returns the values\n    on a raster rasterFile\n\n    This can be used to set a quantity, and takes care of the manual conversion\n    from ANUGA coordinates to spatial coordinates.\n\n    INPUTS: @param domain = ANUGA domain\n            @param rasterFile = Filename of the raster to extract point values\n                    from\n            @param interpolation = 'pixel' (in which case the point value is\n                    set from the pixel it is on) or 'bilinear' in which case\n                    the point value is set from bilinear interpolation of\n                    pixels.\n\n    OUTPUT: Function which takes x,y in ANUGA coordinates, and outputs their\n            corresponding raster values\n    \"\"\"\n    import scipy\n    # import numpy as NearestNDInterpolator  # FIXME (Ole): What?\n    import numpy as np\n\n    from anuga.utilities.spatialInputUtil import rasterValuesAtPoints\n\n    def QFun(x, y):\n        xll = domain.geo_reference.xllcorner\n        yll = domain.geo_reference.yllcorner\n        inDat = np.vstack([x+xll, y+yll]).transpose()\n        return rasterValuesAtPoints(xy=inDat, rasterFile=rasterFile,\n                                    interpolation=interpolation)\n\n    return QFun\n\n#################################################################################\n\n\ndef quantity_from_Pt_Pol_Data_and_Raster(Pt_Pol_Data, quantity_raster, domain):\n    \"\"\"\n        Function to make a function F(x,y) which returns the corresponding\n        values on quantity_raster, except if x,y is inside the polygon associated with\n        any element of Pt_Pol_Data, in which case a Pt_Pol_-specific nearest neighbour\n        interpolator is used.\n\n        This has been superceeded by composite_quantity_setting_function\n\n        INPUT:\n            @param Pt_Pol_Data = a list with [ [ Polygon_0, Pt_XYZ_0],\n                                               [ Polygon_1, Pt_XYZ_1],\n                                               ...\n                                             ]\n                    Here Polygon_i is a polygon in ANUGA format,\n                    and Pt_XYZ_i is a 3 column array of x,y,Value points\n            @param quantity_raster = A GDAL-compatible quantity raster\n            @param domain = ANUGA domain\n    \"\"\"\n\n    # Function to set quantity from raster\n    qFun1 = quantityRasterFun(domain, rasterFile=quantity_raster)\n\n    # List of function\/polygon pairs defining the Pt_Pol_ quantity data\n    qFunChanList = []\n    for i in range(len(Pt_Pol_Data)):\n        qFunChanList.append([\n            Pt_Pol_Data[i][0],\n            make_nearestNeighbour_quantity_function(Pt_Pol_Data[i][1], domain)\n        ])\n\n    #\n    qFun = composite_quantity_setting_function(\n        qFunChanList+[['All', qFun1]], domain)\n\n    return qFun\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_281","text":"<reponame>nkran\/malariagen-data-python\nimport os\nimport random\nimport shutil\n\nimport dask.array as da\nimport numpy as np\nimport pandas as pd\nimport pytest\nimport scipy.stats\nimport xarray as xr\nimport zarr\nfrom numpy.testing import assert_allclose, assert_array_equal\nfrom pandas.testing import assert_frame_equal\n\nfrom malariagen_data import Ag3, Region\nfrom malariagen_data.ag3 import _cn_mode\nfrom malariagen_data.util import locate_region, resolve_region\n\nexpected_species_legacy = {\n    \"gambiae\",\n    \"coluzzii\",\n    \"arabiensis\",\n    \"intermediate_arabiensis_gambiae\",\n    \"intermediate_gambiae_coluzzii\",\n}\n\nexpected_species = {\n    \"gambiae\",\n    \"coluzzii\",\n    \"arabiensis\",\n    \"intermediate_gambcolu_arabiensis\",\n    \"intermediate_gambiae_coluzzii\",\n}\n\ncontigs = \"2R\", \"2L\", \"3R\", \"3L\", \"X\"\n\ncohort_cols = (\n    \"country_iso\",\n    \"admin1_name\",\n    \"admin1_iso\",\n    \"admin2_name\",\n    \"taxon\",\n    \"cohort_admin1_year\",\n    \"cohort_admin1_month\",\n    \"cohort_admin2_year\",\n    \"cohort_admin2_month\",\n)\n\n\ndef setup_ag3(url=\"simplecache::gs:\/\/vo_agam_release\/\", **kwargs):\n    kwargs.setdefault(\"check_location\", False)\n    kwargs.setdefault(\"show_progress\", False)\n    if url is None:\n        # test default URL\n        return Ag3(**kwargs)\n    if url.startswith(\"simplecache::\"):\n        # configure the directory on the local file system to cache data\n        kwargs[\"simplecache\"] = dict(cache_storage=\"gcs_cache\")\n    return Ag3(url, **kwargs)\n\n\n@pytest.mark.parametrize(\n    \"url\",\n    [\n        None,\n        \"gs:\/\/vo_agam_release\/\",\n        \"gcs:\/\/vo_agam_release\/\",\n        \"gs:\/\/vo_agam_release\",\n        \"gcs:\/\/vo_agam_release\",\n        \"simplecache::gs:\/\/vo_agam_release\/\",\n        \"simplecache::gcs:\/\/vo_agam_release\/\",\n    ],\n)\ndef test_sample_sets(url):\n\n    ag3 = setup_ag3(url)\n    df_sample_sets_v3 = ag3.sample_sets(release=\"3.0\")\n    assert isinstance(df_sample_sets_v3, pd.DataFrame)\n    assert len(df_sample_sets_v3) == 28\n    assert tuple(df_sample_sets_v3.columns) == (\"sample_set\", \"sample_count\", \"release\")\n\n    # test duplicates not allowed\n    with pytest.raises(ValueError):\n        ag3.sample_sets(release=[\"3.0\", \"3.0\"])\n\n    # test default is all public releases\n    df_default = ag3.sample_sets()\n    df_all = ag3.sample_sets(release=ag3.releases)\n    assert_frame_equal(df_default, df_all)\n\n\ndef test_releases():\n\n    ag3 = setup_ag3()\n    assert isinstance(ag3.releases, tuple)\n    assert ag3.releases == (\"3.0\",)\n\n    ag3 = setup_ag3(pre=True)\n    assert isinstance(ag3.releases, tuple)\n    assert len(ag3.releases) > 1\n    assert all([r.startswith(\"3.\") for r in ag3.releases])\n\n\ndef test_sample_metadata():\n\n    ag3 = setup_ag3()\n    df_sample_sets_v3 = ag3.sample_sets(release=\"3.0\")\n\n    expected_cols = (\n        \"sample_id\",\n        \"partner_sample_id\",\n        \"contributor\",\n        \"country\",\n        \"location\",\n        \"year\",\n        \"month\",\n        \"latitude\",\n        \"longitude\",\n        \"sex_call\",\n        \"sample_set\",\n        \"release\",\n    )\n\n    # all v3\n    df_samples_v3 = ag3.sample_metadata(sample_sets=\"3.0\")\n    assert tuple(df_samples_v3.columns[: len(expected_cols)]) == expected_cols\n    expected_len = df_sample_sets_v3[\"sample_count\"].sum()\n    assert len(df_samples_v3) == expected_len\n\n    # single sample set\n    df_samples_x = ag3.sample_metadata(sample_sets=\"AG1000G-X\")\n    assert tuple(df_samples_x.columns[: len(expected_cols)]) == expected_cols\n    expected_len = df_sample_sets_v3.query(\"sample_set == 'AG1000G-X'\")[\n        \"sample_count\"\n    ].sum()\n    assert len(df_samples_x) == expected_len\n\n    # multiple sample sets\n    sample_sets = [\"AG1000G-BF-A\", \"AG1000G-BF-B\", \"AG1000G-BF-C\"]\n    df_samples_bf = ag3.sample_metadata(sample_sets=sample_sets)\n    assert tuple(df_samples_bf.columns[: len(expected_cols)]) == expected_cols\n    loc_sample_sets = df_sample_sets_v3[\"sample_set\"].isin(sample_sets)\n    expected_len = df_sample_sets_v3.loc[loc_sample_sets][\"sample_count\"].sum()\n    assert len(df_samples_bf) == expected_len\n\n    # duplicate sample sets\n    with pytest.raises(ValueError):\n        ag3.sample_metadata(sample_sets=[\"3.0\", \"3.0\"])\n    with pytest.raises(ValueError):\n        ag3.sample_metadata(sample_sets=[\"AG1000G-UG\", \"AG1000G-UG\"])\n    with pytest.raises(ValueError):\n        ag3.sample_metadata(sample_sets=[\"AG1000G-UG\", \"3.0\"])\n\n    # default is all public releases\n    df_default = ag3.sample_metadata()\n    df_all = ag3.sample_metadata(sample_sets=ag3.releases)\n    assert_frame_equal(df_default, df_all)\n\n\ndef test_sample_metadata_with_aim_species():\n    ag3 = setup_ag3(species_analysis=\"aim_20220528\")\n\n    expected_cols = (\n        \"sample_id\",\n        \"partner_sample_id\",\n        \"contributor\",\n        \"country\",\n        \"location\",\n        \"year\",\n        \"month\",\n        \"latitude\",\n        \"longitude\",\n        \"sex_call\",\n        \"sample_set\",\n        \"release\",\n        \"aim_species_fraction_arab\",\n        \"aim_species_fraction_colu\",\n        \"aim_species_fraction_colu_no2l\",\n        \"aim_species_gambcolu_arabiensis\",\n        \"aim_species_gambiae_coluzzii\",\n        \"aim_species\",\n    )\n\n    # AIM species calls, included by default\n    df_samples_aim = ag3.sample_metadata(sample_sets=\"3.0\")\n    assert tuple(df_samples_aim.columns[: len(expected_cols)]) == expected_cols\n    assert set(df_samples_aim[\"aim_species\"].dropna()) == expected_species\n\n\ndef test_sample_metadata_with_aim_species_legacy():\n    # TODO this is legacy, deprecate at some point\n    ag3 = setup_ag3(species_analysis=\"aim_20200422\")\n\n    expected_cols = (\n        \"sample_id\",\n        \"partner_sample_id\",\n        \"contributor\",\n        \"country\",\n        \"location\",\n        \"year\",\n        \"month\",\n        \"latitude\",\n        \"longitude\",\n        \"sex_call\",\n        \"sample_set\",\n        \"release\",\n        \"aim_species_fraction_colu\",\n        \"aim_species_fraction_arab\",\n        \"aim_species_gambcolu_arabiensis\",\n        \"aim_species_gambiae_coluzzii\",\n        \"aim_species\",\n    )\n\n    # AIM species calls, included by default\n    df_samples_aim = ag3.sample_metadata(sample_sets=\"3.0\")\n    assert tuple(df_samples_aim.columns[: len(expected_cols)]) == expected_cols\n    assert set(df_samples_aim[\"aim_species\"].dropna()) == expected_species_legacy\n\n\ndef test_sample_metadata_with_pca_species():\n    # TODO this is legacy, deprecate at some point\n    ag3 = setup_ag3(species_analysis=\"pca_20200422\")\n\n    expected_cols = (\n        \"sample_id\",\n        \"partner_sample_id\",\n        \"contributor\",\n        \"country\",\n        \"location\",\n        \"year\",\n        \"month\",\n        \"latitude\",\n        \"longitude\",\n        \"sex_call\",\n        \"sample_set\",\n        \"release\",\n        \"pca_species_pc1\",\n        \"pca_species_pc2\",\n        \"pca_species_gambcolu_arabiensis\",\n        \"pca_species_gambiae_coluzzii\",\n        \"pca_species\",\n    )\n\n    # PCA species calls\n    df_samples_pca = ag3.sample_metadata(sample_sets=\"3.0\")\n    assert tuple(df_samples_pca.columns[: len(expected_cols)]) == expected_cols\n    assert (\n        set(df_samples_pca[\"pca_species\"].dropna()).difference(expected_species_legacy)\n        == set()\n    )\n\n\ndef test_sample_metadata_with_cohorts():\n    ag3 = setup_ag3()\n    df_samples_coh = ag3.sample_metadata(sample_sets=\"3.0\")\n    for c in cohort_cols:\n        assert c in df_samples_coh\n\n\ndef test_sample_metadata_without_cohorts():\n    working_dir = os.path.dirname(os.path.abspath(__file__))\n    test_data_path = os.path.join(working_dir, \"anopheles_test_data\")\n    ag3 = Ag3(test_data_path)\n    df_samples_coh = ag3.sample_metadata(sample_sets=\"3.0\")\n    for c in cohort_cols:\n        assert c in df_samples_coh\n        assert df_samples_coh[c].isnull().all()\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\n        \"AG1000G-AO\",\n        \"AG1000G-X\",\n        [\"AG1000G-BF-A\", \"AG1000G-BF-B\"],\n        \"3.0\",\n        None,\n    ],\n)\n@pytest.mark.parametrize(\"analysis\", [\"aim_20220528\", \"aim_20200422\", \"pca_20200422\"])\ndef test_species_calls(sample_sets, analysis):\n    ag3 = setup_ag3(species_analysis=analysis)\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    df_species = ag3.species_calls(sample_sets=sample_sets)\n    assert len(df_species) == len(df_samples)\n    assert_array_equal(df_samples[\"sample_id\"], df_species[\"sample_id\"])\n    if analysis == \"aim_20220528\":\n        assert (\n            set(df_species[\"aim_species\"].dropna()).difference(expected_species)\n            == set()\n        )\n    if analysis == \"aim_20200422\":\n        assert (\n            set(df_species[\"aim_species\"].dropna()).difference(expected_species_legacy)\n            == set()\n        )\n    if analysis == \"pca_20200422\":\n        assert (\n            set(df_species[\"pca_species\"].dropna()).difference(expected_species_legacy)\n            == set()\n        )\n\n\n@pytest.mark.parametrize(\"mask\", [\"gamb_colu_arab\", \"gamb_colu\", \"arab\"])\ndef test_open_site_filters(mask):\n    # check can open the zarr directly\n    ag3 = setup_ag3()\n    root = ag3.open_site_filters(mask=mask)\n    assert isinstance(root, zarr.hierarchy.Group)\n    for contig in ag3.contigs:\n        assert contig in root\n\n\n@pytest.mark.parametrize(\"mask\", [\"gamb_colu_arab\", \"gamb_colu\", \"arab\"])\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"3L\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\ndef test_site_filters(mask, region):\n    ag3 = setup_ag3()\n    filter_pass = ag3.site_filters(region=region, mask=mask)\n    assert isinstance(filter_pass, da.Array)\n    assert filter_pass.ndim == 1\n    assert filter_pass.dtype == bool\n\n\ndef test_open_snp_sites():\n    ag3 = setup_ag3()\n    root = ag3.open_snp_sites()\n    assert isinstance(root, zarr.hierarchy.Group)\n    for contig in ag3.contigs:\n        assert contig in root\n\n\n@pytest.mark.parametrize(\"chunks\", [\"auto\", \"native\"])\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\ndef test_snp_sites(chunks, region):\n\n    ag3 = setup_ag3()\n\n    pos = ag3.snp_sites(region=region, field=\"POS\", chunks=chunks)\n    ref = ag3.snp_sites(region=region, field=\"REF\", chunks=chunks)\n    alt = ag3.snp_sites(region=region, field=\"ALT\", chunks=chunks)\n    assert isinstance(pos, da.Array)\n    assert pos.ndim == 1\n    assert pos.dtype == \"i4\"\n    assert isinstance(ref, da.Array)\n    assert ref.ndim == 1\n    assert ref.dtype == \"S1\"\n    assert isinstance(alt, da.Array)\n    assert alt.ndim == 2\n    assert alt.dtype == \"S1\"\n    assert pos.shape[0] == ref.shape[0] == alt.shape[0]\n\n    # apply site mask\n    filter_pass = ag3.site_filters(region=region, mask=\"gamb_colu_arab\").compute()\n    n_pass = np.count_nonzero(filter_pass)\n    pos_pass = ag3.snp_sites(\n        region=region, field=\"POS\", site_mask=\"gamb_colu_arab\", chunks=chunks\n    )\n    assert isinstance(pos_pass, da.Array)\n    assert pos_pass.ndim == 1\n    assert pos_pass.dtype == \"i4\"\n    assert pos_pass.shape[0] == n_pass\n    assert pos_pass.compute().shape == pos_pass.shape\n    for f in \"POS\", \"REF\", \"ALT\":\n        d = ag3.snp_sites(\n            region=region, site_mask=\"gamb_colu_arab\", field=f, chunks=chunks\n        )\n        assert isinstance(d, da.Array)\n        assert d.shape[0] == n_pass\n        assert d.shape == d.compute().shape\n\n\ndef test_open_snp_genotypes():\n    # check can open the zarr directly\n    ag3 = setup_ag3()\n    root = ag3.open_snp_genotypes(sample_set=\"AG1000G-AO\")\n    assert isinstance(root, zarr.hierarchy.Group)\n    for contig in ag3.contigs:\n        assert contig in root\n\n\n@pytest.mark.parametrize(\"chunks\", [\"auto\", \"native\"])\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [None, \"AG1000G-X\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"], \"3.0\"],\n)\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\ndef test_snp_genotypes(chunks, sample_sets, region):\n\n    ag3 = setup_ag3()\n\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    gt = ag3.snp_genotypes(region=region, sample_sets=sample_sets, chunks=chunks)\n    assert isinstance(gt, da.Array)\n    assert gt.ndim == 3\n    assert gt.dtype == \"i1\"\n    assert gt.shape[1] == len(df_samples)\n\n    # specific fields\n    x = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, field=\"GT\", chunks=chunks\n    )\n    assert isinstance(x, da.Array)\n    assert x.ndim == 3\n    assert x.dtype == \"i1\"\n    x = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, field=\"GQ\", chunks=chunks\n    )\n    assert isinstance(x, da.Array)\n    assert x.ndim == 2\n    assert x.dtype == \"i2\"\n    x = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, field=\"MQ\", chunks=chunks\n    )\n    assert isinstance(x, da.Array)\n    assert x.ndim == 2\n    assert x.dtype == \"i2\"\n    x = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, field=\"AD\", chunks=chunks\n    )\n    assert isinstance(x, da.Array)\n    assert x.ndim == 3\n    assert x.dtype == \"i2\"\n\n    # site mask\n    filter_pass = ag3.site_filters(region=region, mask=\"gamb_colu_arab\").compute()\n    gt_pass = ag3.snp_genotypes(\n        region=region,\n        sample_sets=sample_sets,\n        site_mask=\"gamb_colu_arab\",\n        chunks=chunks,\n    )\n    assert isinstance(gt_pass, da.Array)\n    assert gt_pass.ndim == 3\n    assert gt_pass.dtype == \"i1\"\n    assert gt_pass.shape[0] == np.count_nonzero(filter_pass)\n    assert gt_pass.shape[1] == len(df_samples)\n    assert gt_pass.shape[2] == 2\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [None, \"AG1000G-X\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"], \"3.0\"],\n)\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\ndef test_snp_genotypes_chunks(sample_sets, region):\n\n    ag3 = setup_ag3()\n    gt_native = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, chunks=\"native\"\n    )\n    gt_auto = ag3.snp_genotypes(region=region, sample_sets=sample_sets, chunks=\"auto\")\n    gt_manual = ag3.snp_genotypes(\n        region=region, sample_sets=sample_sets, chunks=(100_000, 10, 2)\n    )\n\n    assert gt_native.chunks != gt_auto.chunks\n    assert gt_auto.chunks != gt_manual.chunks\n    assert gt_manual.chunks != gt_native.chunks\n    assert gt_manual.chunks[0][0] == 100_000\n    assert gt_manual.chunks[1][0] == 10\n    assert gt_manual.chunks[2][0] == 2\n\n\ndef test_genome():\n\n    ag3 = setup_ag3()\n\n    # test the open_genome() method to access as zarr\n    genome = ag3.open_genome()\n    assert isinstance(genome, zarr.hierarchy.Group)\n    for contig in ag3.contigs:\n        assert contig in genome\n        assert genome[contig].dtype == \"S1\"\n\n    # test the genome_sequence() method to access sequences\n    for contig in ag3.contigs:\n        seq = ag3.genome_sequence(contig)\n        assert isinstance(seq, da.Array)\n        assert seq.dtype == \"S1\"\n\n\ndef test_geneset():\n\n    ag3 = setup_ag3()\n\n    # default\n    df = ag3.geneset()\n    assert isinstance(df, pd.DataFrame)\n    gff3_cols = [\n        \"contig\",\n        \"source\",\n        \"type\",\n        \"start\",\n        \"end\",\n        \"score\",\n        \"strand\",\n        \"phase\",\n    ]\n    expected_cols = gff3_cols + [\"ID\", \"Parent\", \"Name\", \"description\"]\n    assert df.columns.tolist() == expected_cols\n\n    # don't unpack attributes\n    df = ag3.geneset(attributes=None)\n    assert isinstance(df, pd.DataFrame)\n    expected_cols = gff3_cols + [\"attributes\"]\n    assert df.columns.tolist() == expected_cols\n\n\n@pytest.mark.parametrize(\n    \"region\",\n    [\"AGAP007280\", \"3R:28,000,000-29,000,000\", \"2R\", \"X\", [\"3R\", \"3L\"]],\n)\ndef test_geneset_region(region):\n\n    ag3 = setup_ag3()\n\n    df = ag3.geneset(region=region)\n    assert isinstance(df, pd.DataFrame)\n    gff3_cols = [\n        \"contig\",\n        \"source\",\n        \"type\",\n        \"start\",\n        \"end\",\n        \"score\",\n        \"strand\",\n        \"phase\",\n    ]\n    expected_cols = gff3_cols + [\"ID\", \"Parent\", \"Name\", \"description\"]\n    assert df.columns.tolist() == expected_cols\n    assert len(df) > 0\n\n    # check region\n    region = ag3.resolve_region(region)\n    if isinstance(region, Region):\n        assert np.all(df[\"contig\"].values == region.contig)\n        if region.start and region.end:\n            assert np.all(df.eval(f\"start <= {region.end} and end >= {region.start}\"))\n\n\n@pytest.mark.parametrize(\n    \"region\",\n    [\"AGAP007280\", \"2R:48714463-48715355\", \"2R\", \"X\"],\n)\n@pytest.mark.parametrize(\"mask\", [\"gamb_colu_arab\", \"gamb_colu\", \"arab\"])\ndef test_is_accessible(region, mask):\n\n    ag3 = setup_ag3()\n    # run a couple of tests\n    is_accessible = ag3.is_accessible(region=region, site_mask=mask)\n    assert isinstance(is_accessible, np.ndarray)\n    assert is_accessible.ndim == 1\n    assert is_accessible.shape[0] == ag3.genome_sequence(region).shape[0]\n\n\ndef test_cross_metadata():\n\n    ag3 = setup_ag3()\n    df_crosses = ag3.cross_metadata()\n    assert isinstance(df_crosses, pd.DataFrame)\n    expected_cols = [\"cross\", \"sample_id\", \"father_id\", \"mother_id\", \"sex\", \"role\"]\n    assert df_crosses.columns.tolist() == expected_cols\n\n    # check samples are in AG1000G-X\n    df_samples = ag3.sample_metadata(sample_sets=\"AG1000G-X\")\n    assert set(df_crosses[\"sample_id\"]) == set(df_samples[\"sample_id\"])\n\n    # check values\n    expected_role_values = [\"parent\", \"progeny\"]\n    assert df_crosses[\"role\"].unique().tolist() == expected_role_values\n    expected_sex_values = [\"F\", \"M\"]\n    assert df_crosses[\"sex\"].unique().tolist() == expected_sex_values\n\n\ndef test_site_annotations():\n\n    ag3 = setup_ag3()\n\n    # test access as zarr\n    root = ag3.open_site_annotations()\n    assert isinstance(root, zarr.hierarchy.Group)\n    for f in (\n        \"codon_degeneracy\",\n        \"codon_nonsyn\",\n        \"codon_position\",\n        \"seq_cls\",\n        \"seq_flen\",\n        \"seq_relpos_start\",\n        \"seq_relpos_stop\",\n    ):\n        assert f in root\n        for contig in contigs:\n            assert contig in root[f]\n\n    # test access as dask arrays\n    for region in \"2R\", \"X\", \"AGAP007280\", \"2R:48714463-48715355\":\n        for site_mask in None, \"gamb_colu_arab\":\n            pos = ag3.snp_sites(region=region, field=\"POS\", site_mask=site_mask)\n            for field in \"codon_degeneracy\", \"seq_cls\":\n                d = ag3.site_annotations(\n                    region=region, field=field, site_mask=site_mask\n                )\n                assert isinstance(d, da.Array)\n                assert d.ndim == 1\n                assert d.shape == pos.shape\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [None, \"AG1000G-X\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"], \"3.0\"],\n)\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\n@pytest.mark.parametrize(\"site_mask\", [None, \"gamb_colu_arab\"])\ndef test_snp_calls(sample_sets, region, site_mask):\n\n    ag3 = setup_ag3()\n\n    ds = ag3.snp_calls(region=region, sample_sets=sample_sets, site_mask=site_mask)\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"variant_allele\",\n        \"variant_filter_pass_gamb_colu_arab\",\n        \"variant_filter_pass_gamb_colu\",\n        \"variant_filter_pass_arab\",\n        \"call_genotype\",\n        \"call_genotype_mask\",\n        \"call_GQ\",\n        \"call_AD\",\n        \"call_MQ\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"alleles\", \"ploidy\", \"samples\", \"variants\"}\n\n    # check dim lengths\n    pos = ag3.snp_sites(region=region, field=\"POS\", site_mask=site_mask)\n    n_variants = len(pos)\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    n_samples = len(df_samples)\n    assert ds.dims[\"variants\"] == n_variants\n    assert ds.dims[\"samples\"] == n_samples\n    assert ds.dims[\"ploidy\"] == 2\n    assert ds.dims[\"alleles\"] == 4\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f == \"variant_allele\":\n            assert x.ndim == 2\n            assert x.shape == (n_variants, 4)\n            assert x.dims == (\"variants\", \"alleles\")\n        elif f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.shape == (n_variants,)\n            assert x.dims == (\"variants\",)\n        elif f in {\"call_genotype\", \"call_genotype_mask\"}:\n            assert x.ndim == 3\n            assert x.dims == (\"variants\", \"samples\", \"ploidy\")\n            assert x.shape == (n_variants, n_samples, 2)\n        elif f == \"call_AD\":\n            assert x.ndim == 3\n            assert x.dims == (\"variants\", \"samples\", \"alleles\")\n            assert x.shape == (n_variants, n_samples, 4)\n        elif f.startswith(\"call_\"):\n            assert x.ndim == 2\n            assert x.dims == (\"variants\", \"samples\")\n            assert x.shape == (n_variants, n_samples)\n        elif f.startswith(\"sample_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"samples\",)\n            assert x.shape == (n_samples,)\n\n    # check samples\n    expected_samples = df_samples[\"sample_id\"].tolist()\n    assert ds[\"sample_id\"].values.tolist() == expected_samples\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n    # check can set up computations\n    d1 = ds[\"variant_position\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"call_AD\"].sum(axis=(1, 2))\n    assert isinstance(d2, xr.DataArray)\n\n    # check compress bug\n    pos = ds[\"variant_position\"].data\n    assert pos.shape == pos.compute().shape\n\n\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [None, \"taxon == 'coluzzii'\", \"taxon == 'robot'\"],\n)\ndef test_snp_calls__sample_query(sample_query):\n    ag3 = setup_ag3()\n\n    sample_sets = \"AG1000G-BF-A\"\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    if sample_query is not None:\n        df_samples = df_samples.query(sample_query)\n\n    if len(df_samples) == 0:\n        with pytest.raises(ValueError):\n            ag3.snp_calls(\n                region=\"3L\", sample_sets=sample_sets, sample_query=sample_query\n            )\n\n    else:\n        ds = ag3.snp_calls(\n            region=\"3L\", sample_sets=sample_sets, sample_query=sample_query\n        )\n        assert ds.dims[\"samples\"] == len(df_samples)\n        assert_array_equal(ds[\"sample_id\"].values, df_samples[\"sample_id\"].values)\n\n\ndef test_snp_effects():\n    ag3 = setup_ag3()\n    gste2 = \"AGAP009194-RA\"\n    site_mask = \"gamb_colu\"\n    expected_fields = [\n        \"contig\",\n        \"position\",\n        \"ref_allele\",\n        \"alt_allele\",\n        \"pass_gamb_colu_arab\",\n        \"pass_gamb_colu\",\n        \"pass_arab\",\n        \"transcript\",\n        \"effect\",\n        \"impact\",\n        \"ref_codon\",\n        \"alt_codon\",\n        \"aa_pos\",\n        \"ref_aa\",\n        \"alt_aa\",\n        \"aa_change\",\n    ]\n\n    df = ag3.snp_effects(transcript=gste2, site_mask=site_mask)\n    assert isinstance(df, pd.DataFrame)\n    assert df.columns.tolist() == expected_fields\n\n    # reverse strand gene\n    assert df.shape == (2838, len(expected_fields))\n    # check first, second, third codon position non-syn\n    assert df.iloc[1454].aa_change == \"I114L\"\n    assert df.iloc[1446].aa_change == \"I114M\"\n    # while we are here, check all columns for a position\n    assert df.iloc[1451].position == 28598166\n    assert df.iloc[1451].ref_allele == \"A\"\n    assert df.iloc[1451].alt_allele == \"G\"\n    assert df.iloc[1451].effect == \"NON_SYNONYMOUS_CODING\"\n    assert df.iloc[1451].impact == \"MODERATE\"\n    assert df.iloc[1451].ref_codon == \"aTt\"\n    assert df.iloc[1451].alt_codon == \"aCt\"\n    assert df.iloc[1451].aa_pos == 114\n    assert df.iloc[1451].ref_aa == \"I\"\n    assert df.iloc[1451].alt_aa == \"T\"\n    assert df.iloc[1451].aa_change == \"I114T\"\n    # check syn\n    assert df.iloc[1447].aa_change == \"I114I\"\n    # check intronic\n    assert df.iloc[1197].effect == \"INTRONIC\"\n    # check 5' utr\n    assert df.iloc[2661].effect == \"FIVE_PRIME_UTR\"\n    # check 3' utr\n    assert df.iloc[0].effect == \"THREE_PRIME_UTR\"\n\n    # test forward strand gene gste6\n    gste6 = \"AGAP009196-RA\"\n    df = ag3.snp_effects(transcript=gste6, site_mask=site_mask)\n    assert isinstance(df, pd.DataFrame)\n    assert df.columns.tolist() == expected_fields\n    assert df.shape == (2829, len(expected_fields))\n\n    # check first, second, third codon position non-syn\n    assert df.iloc[701].aa_change == \"E35*\"\n    assert df.iloc[703].aa_change == \"E35V\"\n    # while we are here, check all columns for a position\n    assert df.iloc[706].position == 28600605\n    assert df.iloc[706].ref_allele == \"G\"\n    assert df.iloc[706].alt_allele == \"C\"\n    assert df.iloc[706].effect == \"NON_SYNONYMOUS_CODING\"\n    assert df.iloc[706].impact == \"MODERATE\"\n    assert df.iloc[706].ref_codon == \"gaG\"\n    assert df.iloc[706].alt_codon == \"gaC\"\n    assert df.iloc[706].aa_pos == 35\n    assert df.iloc[706].ref_aa == \"E\"\n    assert df.iloc[706].alt_aa == \"D\"\n    assert df.iloc[706].aa_change == \"E35D\"\n    # check syn\n    assert df.iloc[705].aa_change == \"E35E\"\n    # check intronic\n    assert df.iloc[900].effect == \"INTRONIC\"\n    # check 5' utr\n    assert df.iloc[0].effect == \"FIVE_PRIME_UTR\"\n    # check 3' utr\n    assert df.iloc[2828].effect == \"THREE_PRIME_UTR\"\n\n    # check 5' utr intron and the different intron effects\n    utr_intron5 = \"AGAP004679-RB\"\n    df = ag3.snp_effects(transcript=utr_intron5, site_mask=site_mask)\n    assert isinstance(df, pd.DataFrame)\n    assert df.columns.tolist() == expected_fields\n    assert df.shape == (7686, len(expected_fields))\n    assert df.iloc[180].effect == \"SPLICE_CORE\"\n    assert df.iloc[198].effect == \"SPLICE_REGION\"\n    assert df.iloc[202].effect == \"INTRONIC\"\n\n    # check 3' utr intron\n    utr_intron3 = \"AGAP000689-RA\"\n    df = ag3.snp_effects(transcript=utr_intron3, site_mask=site_mask)\n    assert isinstance(df, pd.DataFrame)\n    assert df.columns.tolist() == expected_fields\n    assert df.shape == (5397, len(expected_fields))\n    assert df.iloc[646].effect == \"SPLICE_CORE\"\n    assert df.iloc[652].effect == \"SPLICE_REGION\"\n    assert df.iloc[674].effect == \"INTRONIC\"\n\n\ndef test_snp_allele_frequencies__str_cohorts():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    cohorts = \"admin1_month\"\n    min_cohort_size = 10\n    universal_fields = [\n        \"pass_gamb_colu_arab\",\n        \"pass_gamb_colu\",\n        \"pass_arab\",\n        \"label\",\n    ]\n    df = ag3.snp_allele_frequencies(\n        transcript=\"AGAP004707-RD\",\n        cohorts=cohorts,\n        min_cohort_size=min_cohort_size,\n        site_mask=\"gamb_colu\",\n        sample_sets=\"3.0\",\n        drop_invariant=True,\n        effects=False,\n    )\n    df_coh = ag3.sample_cohorts(sample_sets=\"3.0\")\n    coh_nm = \"cohort_\" + cohorts\n    coh_counts = df_coh[coh_nm].dropna().value_counts().to_frame()\n    cohort_labels = coh_counts[coh_counts[coh_nm] >= min_cohort_size].index.to_list()\n    frq_cohort_labels = [\"frq_\" + s for s in cohort_labels]\n    expected_fields = universal_fields + frq_cohort_labels + [\"max_af\"]\n\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns.tolist()) == sorted(expected_fields)\n    assert df.index.names == [\"contig\", \"position\", \"ref_allele\", \"alt_allele\"]\n    assert len(df) == 16526\n\n\ndef test_snp_allele_frequencies__dict_cohorts():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    cohorts = {\n        \"ke\": \"country == 'Kenya'\",\n        \"bf_2012_col\": \"country == 'Burkina Faso' and year == 2012 and aim_species == 'coluzzii'\",\n    }\n    universal_fields = [\n        \"pass_gamb_colu_arab\",\n        \"pass_gamb_colu\",\n        \"pass_arab\",\n        \"label\",\n    ]\n\n    # test drop invariants\n    df = ag3.snp_allele_frequencies(\n        transcript=\"AGAP009194-RA\",\n        cohorts=cohorts,\n        site_mask=\"gamb_colu\",\n        sample_sets=\"3.0\",\n        drop_invariant=True,\n        effects=False,\n    )\n\n    assert isinstance(df, pd.DataFrame)\n    frq_columns = [\"frq_\" + s for s in list(cohorts.keys())]\n    expected_fields = universal_fields + frq_columns + [\"max_af\"]\n    assert sorted(df.columns.tolist()) == sorted(expected_fields)\n    assert df.shape == (133, len(expected_fields))\n    assert df.iloc[3].frq_ke == 0\n    assert df.iloc[4].frq_bf_2012_col == pytest.approx(0.006097, abs=1e-6)\n    assert df.iloc[4].max_af == pytest.approx(0.006097, abs=1e-6)\n    # check invariant have been dropped\n    assert df.max_af.min() > 0\n\n    # test keep invariants\n    df = ag3.snp_allele_frequencies(\n        transcript=\"AGAP004707-RD\",\n        cohorts=cohorts,\n        site_mask=\"gamb_colu\",\n        sample_sets=\"3.0\",\n        drop_invariant=False,\n        effects=False,\n    )\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns.tolist()) == sorted(expected_fields)\n    assert df.shape == (132306, len(expected_fields))\n    # check invariant positions are still present\n    assert np.any(df.max_af == 0)\n\n\ndef test_snp_allele_frequencies__str_cohorts__effects():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    cohorts = \"admin1_month\"\n    min_cohort_size = 10\n    universal_fields = [\n        \"pass_gamb_colu_arab\",\n        \"pass_gamb_colu\",\n        \"pass_arab\",\n        \"label\",\n    ]\n    effects_fields = [\n        \"transcript\",\n        \"effect\",\n        \"impact\",\n        \"ref_codon\",\n        \"alt_codon\",\n        \"aa_pos\",\n        \"ref_aa\",\n        \"alt_aa\",\n    ]\n    df = ag3.snp_allele_frequencies(\n        transcript=\"AGAP004707-RD\",\n        cohorts=cohorts,\n        min_cohort_size=min_cohort_size,\n        site_mask=\"gamb_colu\",\n        sample_sets=\"3.0\",\n        drop_invariant=True,\n        effects=True,\n    )\n    df_coh = ag3.sample_cohorts(sample_sets=\"3.0\")\n    coh_nm = \"cohort_\" + cohorts\n    coh_counts = df_coh[coh_nm].dropna().value_counts().to_frame()\n    cohort_labels = coh_counts[coh_counts[coh_nm] >= min_cohort_size].index.to_list()\n    frq_cohort_labels = [\"frq_\" + s for s in cohort_labels]\n    expected_fields = universal_fields + frq_cohort_labels + [\"max_af\"] + effects_fields\n\n    assert isinstance(df, pd.DataFrame)\n    assert len(df) == 16526\n    assert sorted(df.columns.tolist()) == sorted(expected_fields)\n    assert df.index.names == [\n        \"contig\",\n        \"position\",\n        \"ref_allele\",\n        \"alt_allele\",\n        \"aa_change\",\n    ]\n\n\ndef test_snp_allele_frequencies__query():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    cohorts = \"admin1_year\"\n    min_cohort_size = 10\n    expected_columns = [\n        \"pass_gamb_colu_arab\",\n        \"pass_gamb_colu\",\n        \"pass_arab\",\n        \"frq_AO-LUA_colu_2009\",\n        \"max_af\",\n        \"label\",\n    ]\n\n    df = ag3.snp_allele_frequencies(\n        transcript=\"AGAP004707-RD\",\n        cohorts=cohorts,\n        sample_query=\"country == 'Angola'\",\n        min_cohort_size=min_cohort_size,\n        site_mask=\"gamb_colu\",\n        sample_sets=\"3.0\",\n        drop_invariant=True,\n        effects=False,\n    )\n\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns) == sorted(expected_columns)\n    assert len(df) == 695\n\n\ndef test_snp_allele_frequencies__dup_samples():\n    ag3 = setup_ag3()\n    with pytest.raises(ValueError):\n        ag3.snp_allele_frequencies(\n            transcript=\"AGAP004707-RD\",\n            cohorts=\"admin1_year\",\n            sample_sets=[\"AG1000G-FR\", \"AG1000G-FR\"],\n        )\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"AG1000G-AO\", [\"AG1000G-AO\", \"AG1000G-UG\"], \"3.0\", None],\n)\n@pytest.mark.parametrize(\"region\", [\"2R\", [\"3L\", \"X\"], \"3R:28,000,000-29,000,000\"])\ndef test_cnv_hmm(sample_sets, region):\n    ag3 = setup_ag3()\n    ds = ag3.cnv_hmm(region=region, sample_sets=sample_sets, max_coverage_variance=None)\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"call_CN\",\n        \"call_NormCov\",\n        \"call_RawCov\",\n        \"sample_coverage_variance\",\n        \"sample_is_high_variance\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_end\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"variants\"}\n\n    # check dim lengths\n    if region in ag3.contigs:\n        n_variants_expected = 1 + len(ag3.genome_sequence(region=region)) \/\/ 300\n    elif isinstance(region, (tuple, list)) and all([r in ag3.contigs for r in region]):\n        n_variants_expected = sum(\n            [1 + len(ag3.genome_sequence(region=c)) \/\/ 300 for c in region]\n        )\n    else:\n        # test part of a contig region\n        region = ag3.resolve_region(region)\n        variant_contig = ds[\"variant_contig\"].values\n        contig_index = ds.attrs[\"contigs\"].index(region.contig)\n        assert np.all(variant_contig == contig_index)\n        variant_position = ds[\"variant_position\"].values\n        variant_end = ds[\"variant_end\"].values\n        assert variant_position[0] <= region.start\n        assert variant_end[0] >= region.start\n        assert variant_position[-1] <= region.end\n        assert variant_end[-1] >= region.end\n        assert np.all(variant_position <= region.end)\n        assert np.all(variant_end >= region.start)\n        n_variants_expected = 1 + (region.end - region.start) \/\/ 300\n\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    n_samples_expected = len(df_samples)\n    assert ds.dims[\"variants\"] == n_variants_expected\n    assert ds.dims[\"samples\"] == n_samples_expected\n\n    # check sample IDs\n    assert ds[\"sample_id\"].values.tolist() == df_samples[\"sample_id\"].tolist()\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.shape == (n_variants_expected,)\n            assert x.dims == (\"variants\",)\n        elif f.startswith(\"call_\"):\n            assert x.ndim == 2\n            assert x.dims == (\"variants\", \"samples\")\n            assert x.shape == (n_variants_expected, n_samples_expected)\n        elif f.startswith(\"sample_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"samples\",)\n            assert x.shape == (n_samples_expected,)\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n    # check can set up computations\n    d1 = ds[\"variant_position\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"call_CN\"].sum(axis=1)\n    assert isinstance(d2, xr.DataArray)\n\n\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [\n        \"taxon == 'coluzzii' and location == 'Bana Village'\",\n        \"taxon == 'gambiae' and location == 'Pala'\",\n    ],\n)\ndef test_cnv_hmm__sample_query(sample_query):\n\n    sample_sets = \"AG1000G-BF-B\"\n    region = \"3L\"\n    ag3 = setup_ag3()\n    ds = ag3.cnv_hmm(\n        region=region,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        max_coverage_variance=None,\n    )\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"call_CN\",\n        \"call_NormCov\",\n        \"call_RawCov\",\n        \"sample_coverage_variance\",\n        \"sample_is_high_variance\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_end\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"variants\"}\n\n    # check expected samples\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets).query(sample_query)\n    expected_samples = df_samples[\"sample_id\"].tolist()\n    n_samples_expected = len(expected_samples)\n    assert ds.dims[\"samples\"] == n_samples_expected\n\n    # check sample IDs\n    assert ds[\"sample_id\"].values.tolist() == df_samples[\"sample_id\"].tolist()\n\n\n@pytest.mark.parametrize(\n    \"max_coverage_variance\",\n    [0, 0.1, 0.2, 1],\n)\ndef test_cnv_hmm__max_coverage_variance(max_coverage_variance):\n\n    sample_sets = \"AG1000G-CI\"\n    region = \"3L\"\n    ag3 = setup_ag3()\n    ds = ag3.cnv_hmm(\n        region=region,\n        sample_sets=sample_sets,\n        max_coverage_variance=max_coverage_variance,\n    )\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"call_CN\",\n        \"call_NormCov\",\n        \"call_RawCov\",\n        \"sample_coverage_variance\",\n        \"sample_is_high_variance\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_end\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"variants\"}\n\n    # check expected samples\n    cov_var = ds[\"sample_coverage_variance\"].values\n    assert np.all(cov_var <= max_coverage_variance)\n\n\n@pytest.mark.parametrize(\"sample_set\", [\"AG1000G-AO\", \"AG1000G-UG\", \"AG1000G-X\"])\n@pytest.mark.parametrize(\"analysis\", [\"gamb_colu\", \"arab\", \"crosses\"])\n@pytest.mark.parametrize(\n    \"region\", [\"3L\", \"X\", [\"2R\", \"2L\"], \"3R:28,000,000-29,000,000\"]\n)\ndef test_cnv_coverage_calls(sample_set, analysis, region):\n\n    ag3 = setup_ag3()\n\n    expected_analyses = {\n        \"AG1000G-AO\": {\"gamb_colu\"},\n        \"AG1000G-UG\": {\"gamb_colu\", \"arab\"},\n        \"AG1000G-X\": {\"crosses\"},\n    }\n    if analysis not in expected_analyses[sample_set]:\n        with pytest.raises(ValueError):\n            ag3.cnv_coverage_calls(\n                region=region, analysis=analysis, sample_set=sample_set\n            )\n        return\n\n    ds = ag3.cnv_coverage_calls(region=region, analysis=analysis, sample_set=sample_set)\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"variant_CIPOS\",\n        \"variant_CIEND\",\n        \"variant_filter_pass\",\n        \"call_genotype\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_end\",\n        \"variant_id\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"variants\"}\n\n    # check sample IDs\n    df_samples = ag3.sample_metadata(sample_sets=sample_set)\n    sample_id = pd.Series(ds[\"sample_id\"].values)\n    assert sample_id.isin(df_samples[\"sample_id\"]).all()\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"variants\",)\n        elif f.startswith(\"call_\"):\n            assert x.ndim == 2\n            assert x.dims == (\"variants\", \"samples\")\n        elif f.startswith(\"sample_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"samples\",)\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n    # check region\n    region = ag3.resolve_region(region)\n    if (\n        isinstance(region, Region)\n        and region.start is not None\n        and region.end is not None\n    ):\n        variant_position = ds[\"variant_position\"].values\n        variant_end = ds[\"variant_end\"].values\n        assert np.all(variant_position <= region.end)\n        assert np.all(variant_end >= region.start)\n\n    # check can set up computations\n    d1 = ds[\"variant_position\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"call_genotype\"].sum(axis=1)\n    assert isinstance(d2, xr.DataArray)\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\n        \"AG1000G-AO\",\n        \"AG1000G-UG\",\n        [\"AG1000G-AO\", \"AG1000G-UG\"],\n        \"3.0\",\n        None,\n    ],\n)\n@pytest.mark.parametrize(\"contig\", [\"2R\", \"3R\", \"X\", [\"2R\", \"3R\"]])\ndef test_cnv_discordant_read_calls(sample_sets, contig):\n\n    ag3 = setup_ag3()\n\n    if contig == \"3L\":\n        with pytest.raises(ValueError):\n            ag3.cnv_discordant_read_calls(contig=contig, sample_sets=sample_sets)\n        return\n\n    ds = ag3.cnv_discordant_read_calls(contig=contig, sample_sets=sample_sets)\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"variant_Region\",\n        \"variant_StartBreakpointMethod\",\n        \"variant_EndBreakpointMethod\",\n        \"call_genotype\",\n        \"sample_coverage_variance\",\n        \"sample_is_high_variance\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_end\",\n        \"variant_id\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"variants\"}\n\n    # check dim lengths\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    n_samples = len(df_samples)\n    assert ds.dims[\"samples\"] == n_samples\n\n    expected_variants = {\"2R\": 40, \"3R\": 29, \"X\": 29}\n    if isinstance(contig, str):\n        n_variants = expected_variants[contig]\n    elif isinstance(contig, (list, tuple)):\n        n_variants = sum([expected_variants[c] for c in contig])\n    else:\n        raise NotImplementedError\n\n    assert ds.dims[\"variants\"] == n_variants\n\n    # check sample IDs\n    assert ds[\"sample_id\"].values.tolist() == df_samples[\"sample_id\"].tolist()\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"variants\",)\n        elif f.startswith(\"call_\"):\n            assert x.ndim == 2\n            assert x.dims == (\"variants\", \"samples\")\n        elif f.startswith(\"sample_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"samples\",)\n            assert x.shape == (n_samples,)\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n    # check can set up computations\n    d1 = ds[\"variant_position\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"call_genotype\"].sum(axis=1)\n    assert isinstance(d2, xr.DataArray)\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"AG1000G-AO\", [\"AG1000G-AO\", \"AG1000G-UG\"], \"3.0\", None],\n)\n@pytest.mark.parametrize(\"contig\", [\"2L\", \"3L\"])\ndef test_cnv_discordant_read_calls__no_calls(sample_sets, contig):\n\n    ag3 = setup_ag3()\n\n    with pytest.raises(ValueError):\n        ag3.cnv_discordant_read_calls(contig=contig, sample_sets=sample_sets)\n    return\n\n\n@pytest.mark.parametrize(\"rows\", [10, 100, 1000])\n@pytest.mark.parametrize(\"cols\", [10, 100, 1000])\n@pytest.mark.parametrize(\"vmax\", [2, 12, 100])\ndef test_cn_mode(rows, cols, vmax):\n    \"\"\"Test the numba-optimised function for computing modal copy number.\"\"\"\n\n    a = np.random.randint(0, vmax, size=(rows * cols), dtype=\"i1\").reshape(rows, cols)\n    expect = scipy.stats.mode(a, axis=0)\n    modes, counts = _cn_mode(a, vmax)\n    assert_array_equal(expect.mode.squeeze(), modes)\n    assert_array_equal(expect.count.squeeze(), counts)\n\n\n# noinspection PyArgumentList\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"AG1000G-AO\", (\"AG1000G-TZ\", \"AG1000G-UG\"), \"3.0\", None],\n)\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", \"X\", [\"2R\", \"3R\"], \"3R:28,000,000-29,000,000\"]\n)\ndef test_gene_cnv(region, sample_sets):\n    ag3 = setup_ag3()\n\n    ds = ag3.gene_cnv(\n        region=region, sample_sets=sample_sets, max_coverage_variance=None\n    )\n\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"CN_mode\",\n        \"CN_mode_count\",\n        \"gene_windows\",\n        \"gene_contig\",\n        \"gene_start\",\n        \"gene_end\",\n        \"gene_name\",\n        \"gene_description\",\n        \"gene_strand\",\n        \"sample_coverage_variance\",\n        \"sample_is_high_variance\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"gene_id\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"samples\", \"genes\"}\n\n    # check dim lengths\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    n_samples = len(df_samples)\n    assert ds.dims[\"samples\"] == n_samples\n    df_geneset = ag3.geneset(region=region)\n    df_genes = df_geneset.query(\"type == 'gene'\")\n    n_genes = len(df_genes)\n    assert ds.dims[\"genes\"] == n_genes\n\n    # check IDs\n    assert ds[\"sample_id\"].values.tolist() == df_samples[\"sample_id\"].tolist()\n    assert ds[\"gene_id\"].values.tolist() == df_genes[\"ID\"].tolist()\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, np.ndarray)\n\n        if f.startswith(\"gene_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"genes\",)\n        elif f.startswith(\"CN\"):\n            assert x.ndim == 2\n            assert x.dims == (\"genes\", \"samples\")\n        elif f.startswith(\"sample_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"samples\",)\n            assert x.shape == (n_samples,)\n\n    # check can set up computations\n    d1 = ds[\"gene_start\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"CN_mode\"].max(axis=1)\n    assert isinstance(d2, xr.DataArray)\n\n    # sanity checks\n    x = ds[\"gene_windows\"].values\n    y = ds[\"CN_mode_count\"].values.max(axis=1)\n    assert np.all(x >= y)\n    z = ds[\"CN_mode\"].values\n    assert np.max(z) <= 12\n    assert np.min(z) >= -1\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"AG1000G-AO\", (\"AG1000G-TZ\", \"AG1000G-UG\"), \"3.0\", None],\n)\n@pytest.mark.parametrize(\"region\", [\"2R\", \"X\", \"3R:28,000,000-29,000,000\"])\ndef test_gene_cnv_xarray_indexing(region, sample_sets):\n    ag3 = setup_ag3()\n\n    ds = ag3.gene_cnv(\n        region=region, sample_sets=sample_sets, max_coverage_variance=None\n    )\n\n    # check label-based indexing\n    # pick a random gene and sample ID\n\n    # check dim lengths\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    df_geneset = ag3.geneset(region=region)\n    df_genes = df_geneset.query(\"type == 'gene'\")\n    gene = random.choice(df_genes[\"ID\"].tolist())\n    sample = random.choice(df_samples[\"sample_id\"].tolist())\n    ds = ds.set_index(genes=\"gene_id\", samples=\"sample_id\")\n    o = ds.sel(genes=gene)\n    assert isinstance(o, xr.Dataset)\n    assert set(o.dims) == {\"samples\"}\n    assert o.dims[\"samples\"] == ds.dims[\"samples\"]\n    o = ds.sel(samples=sample)\n    assert isinstance(o, xr.Dataset)\n    assert set(o.dims) == {\"genes\"}\n    assert o.dims[\"genes\"] == ds.dims[\"genes\"]\n    o = ds.sel(genes=gene, samples=sample)\n    assert isinstance(o, xr.Dataset)\n    assert set(o.dims) == set()\n\n\ndef _check_frequency(x):\n    loc_nan = np.isnan(x)\n    assert np.all(x[~loc_nan] >= 0)\n    assert np.all(x[~loc_nan] <= 1)\n\n\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", \"X\", [\"2R\", \"3R\"], \"3R:28,000,000-29,000,000\"]\n)\n@pytest.mark.parametrize(\n    \"cohorts\",\n    [\n        {\n            \"ke\": \"country == 'Kenya'\",\n            \"bf_2012_col\": \"country == 'Burkina Faso' and year == 2012 and aim_species == 'coluzzii'\",\n        },\n        \"admin1_month\",\n    ],\n)\ndef test_gene_cnv_frequencies(region, cohorts):\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    universal_fields = [\n        \"contig\",\n        \"start\",\n        \"end\",\n        \"windows\",\n        \"max_af\",\n        \"gene_strand\",\n        \"gene_description\",\n        \"label\",\n    ]\n    df_genes = ag3.geneset(region=region).query(\"type == 'gene'\")\n\n    df_cnv_frq = ag3.gene_cnv_frequencies(\n        region=region,\n        sample_sets=\"3.0\",\n        cohorts=cohorts,\n        min_cohort_size=1,\n        drop_invariant=False,\n        max_coverage_variance=None,\n    )\n\n    assert isinstance(df_cnv_frq, pd.DataFrame)\n    assert len(df_cnv_frq) == len(df_genes) * 2\n    assert df_cnv_frq.index.names == [\"gene_id\", \"gene_name\", \"cnv_type\"]\n\n    # sanity checks\n    frq_cols = None\n    if isinstance(cohorts, dict):\n        frq_cols = [\"frq_\" + s for s in cohorts.keys()]\n    if isinstance(cohorts, str):\n        df_coh = ag3.sample_cohorts(sample_sets=\"3.0\")\n        coh_nm = \"cohort_\" + cohorts\n        frq_cols = [\"frq_\" + s for s in list(df_coh[coh_nm].dropna().unique())]\n\n    # check frequencies are within sensible range\n    for f in frq_cols:\n        _check_frequency(df_cnv_frq[f].values)\n\n    # check amp and del frequencies are within sensible range\n    df_frq_amp = df_cnv_frq[frq_cols].xs(\"amp\", level=\"cnv_type\")\n    df_frq_del = df_cnv_frq[frq_cols].xs(\"del\", level=\"cnv_type\")\n    df_frq_sum = df_frq_amp + df_frq_del\n    for f in frq_cols:\n        _check_frequency(df_frq_sum[f].values)\n    expected_fields = universal_fields + frq_cols\n    assert sorted(df_cnv_frq.columns.tolist()) == sorted(expected_fields)\n\n\ndef test_gene_cnv_frequencies__query():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    region = \"3L\"\n\n    expected_columns = [\n        \"contig\",\n        \"start\",\n        \"end\",\n        \"windows\",\n        \"max_af\",\n        \"gene_strand\",\n        \"gene_description\",\n        \"label\",\n        \"frq_AO-LUA_colu_2009\",\n    ]\n\n    df = ag3.gene_cnv_frequencies(\n        region=region,\n        sample_sets=\"3.0\",\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        sample_query=\"country == 'Angola'\",\n        drop_invariant=False,\n    )\n\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns) == sorted(expected_columns)\n    df_genes = ag3.geneset(region=region).query(\"type == 'gene'\")\n    assert len(df) == len(df_genes) * 2\n\n\ndef test_gene_cnv_frequencies__max_coverage_variance():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    region = \"3L\"\n    df_genes = ag3.geneset(region=region).query(\"type == 'gene'\")\n\n    base_columns = [\n        \"contig\",\n        \"start\",\n        \"end\",\n        \"windows\",\n        \"max_af\",\n        \"gene_strand\",\n        \"gene_description\",\n        \"label\",\n    ]\n\n    # run without a threshold on coverage variance\n    df = ag3.gene_cnv_frequencies(\n        region=region,\n        sample_sets=[\"AG1000G-GM-A\", \"AG1000G-GM-B\", \"AG1000G-GM-C\"],\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        max_coverage_variance=None,\n        drop_invariant=False,\n    )\n    expected_frq_columns = [\n        \"frq_GM-L_gcx2_2012\",\n        \"frq_GM-M_gcx2_2012\",\n        \"frq_GM-N_gcx1_2011\",\n    ]\n    expected_columns = base_columns + expected_frq_columns\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns) == sorted(expected_columns)\n    assert len(df) == len(df_genes) * 2\n\n    # Run with a threshold on coverage variance - this will remove samples,\n    # which in turn will drop one of the cohorts below the min_cohort_size,\n    # and so we can check that we have lost a cohort.\n    df = ag3.gene_cnv_frequencies(\n        region=region,\n        sample_sets=[\"AG1000G-GM-A\", \"AG1000G-GM-B\", \"AG1000G-GM-C\"],\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        max_coverage_variance=0.2,\n        drop_invariant=False,\n    )\n    expected_frq_columns = [\n        \"frq_GM-M_gcx2_2012\",\n        \"frq_GM-N_gcx1_2011\",\n    ]\n    expected_columns = base_columns + expected_frq_columns\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns) == sorted(expected_columns)\n    assert len(df) == len(df_genes) * 2\n\n\ndef test_gene_cnv_frequencies__drop_invariant():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    region = \"3L\"\n\n    expected_columns = [\n        \"contig\",\n        \"start\",\n        \"end\",\n        \"windows\",\n        \"max_af\",\n        \"gene_strand\",\n        \"gene_description\",\n        \"label\",\n        \"frq_AO-LUA_colu_2009\",\n    ]\n\n    df = ag3.gene_cnv_frequencies(\n        region=region,\n        sample_sets=\"3.0\",\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        sample_query=\"country == 'Angola'\",\n        drop_invariant=True,\n    )\n\n    assert isinstance(df, pd.DataFrame)\n    assert sorted(df.columns) == sorted(expected_columns)\n    assert np.all(df[\"max_af\"] > 0)\n    df_genes = ag3.geneset(region=region).query(\"type == 'gene'\")\n    assert len(df) < len(df_genes) * 2\n\n\ndef test_gene_cnv_frequencies__dup_samples():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    with pytest.raises(ValueError):\n        ag3.gene_cnv_frequencies(\n            region=\"3L\",\n            cohorts=\"admin1_year\",\n            sample_sets=[\"AG1000G-FR\", \"AG1000G-FR\"],\n        )\n\n\ndef test_gene_cnv_frequencies__multi_contig_x():\n    # https:\/\/github.com\/malariagen\/malariagen-data-python\/issues\/166\n\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    df1 = ag3.gene_cnv_frequencies(\n        region=\"X\",\n        sample_sets=\"AG1000G-BF-B\",\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        drop_invariant=False,\n        max_coverage_variance=None,\n    )\n\n    df2 = ag3.gene_cnv_frequencies(\n        region=[\"2R\", \"X\"],\n        sample_sets=\"AG1000G-BF-B\",\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        drop_invariant=False,\n        max_coverage_variance=None,\n    ).query(\"contig == 'X'\")\n\n    assert_frame_equal(df1, df2)\n\n\ndef test_gene_cnv_frequencies__missing_samples():\n    # https:\/\/github.com\/malariagen\/malariagen-data-python\/issues\/183\n\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\", pre=True)\n\n    df = ag3.gene_cnv_frequencies(\n        region=\"3L\",\n        sample_sets=\"1190-VO-GH-AMENGA-ETEGO-VMF00013\",\n        cohorts=\"admin1_year\",\n    )\n    assert isinstance(df, pd.DataFrame)\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"AG1000G-BF-A\", (\"AG1000G-TZ\", \"AG1000G-UG\"), \"3.0\", None],\n)\n@pytest.mark.parametrize(\n    \"region\", [\"2R\", [\"3R\", \"2R:48,714,463-48,715,355\", \"AGAP007280\"]]\n)\n@pytest.mark.parametrize(\"analysis\", [\"arab\", \"gamb_colu\", \"gamb_colu_arab\"])\ndef test_haplotypes(sample_sets, region, analysis):\n\n    ag3 = setup_ag3()\n\n    # check expected samples\n    phased_samples_query = None\n    if analysis == \"arab\":\n        phased_samples_query = (\n            \"aim_species == 'arabiensis' and sample_set != 'AG1000G-X'\"\n        )\n    elif analysis == \"gamb_colu\":\n        phased_samples_query = (\n            \"aim_species in ['gambiae', 'coluzzii', 'intermediate_gambiae_coluzzii'] and \"\n            \"sample_set != 'AG1000G-X'\"\n        )\n    elif analysis == \"gamb_colu_arab\":\n        phased_samples_query = \"sample_set != 'AG1000G-X'\"\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    expected_samples = df_samples.query(phased_samples_query)[\"sample_id\"].tolist()\n    n_samples = len(expected_samples)\n\n    # check if any samples\n    if n_samples == 0:\n        ds = ag3.haplotypes(region=region, sample_sets=sample_sets, analysis=analysis)\n        assert ds is None\n        return\n\n    ds = ag3.haplotypes(region=region, sample_sets=sample_sets, analysis=analysis)\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"variant_allele\",\n        \"call_genotype\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"alleles\", \"ploidy\", \"samples\", \"variants\"}\n\n    # check samples\n    samples = ds[\"sample_id\"].values\n    assert set(samples) == set(expected_samples)\n\n    # check dim lengths\n    assert ds.dims[\"samples\"] == n_samples\n    assert ds.dims[\"ploidy\"] == 2\n    assert ds.dims[\"alleles\"] == 2\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f == \"variant_allele\":\n            assert x.ndim == 2\n            assert x.shape[1] == 2\n            assert x.dims == (\"variants\", \"alleles\")\n        elif f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"variants\",)\n        elif f == \"call_genotype\":\n            assert x.ndim == 3\n            assert x.dims == (\"variants\", \"samples\", \"ploidy\")\n            assert x.shape[1] == n_samples\n            assert x.shape[2] == 2\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n    # check can set up computations\n    d1 = ds[\"variant_position\"] > 10_000\n    assert isinstance(d1, xr.DataArray)\n    d2 = ds[\"call_genotype\"].sum(axis=(1, 2))\n    assert isinstance(d2, xr.DataArray)\n\n\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [\n        \"taxon == 'coluzzii' and location == 'Bana Village'\",\n        \"taxon == 'gambiae' and location == 'Pala'\",\n    ],\n)\ndef test_haplotypes__sample_query(sample_query):\n\n    sample_sets = \"AG1000G-BF-B\"\n    region = \"3L\"\n    analysis = \"gamb_colu_arab\"\n\n    ag3 = setup_ag3()\n\n    # check expected samples\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    expected_samples = df_samples.query(sample_query)[\"sample_id\"].tolist()\n    n_samples = len(expected_samples)\n\n    ds = ag3.haplotypes(\n        region=region,\n        sample_sets=sample_sets,\n        analysis=analysis,\n        sample_query=sample_query,\n    )\n    assert isinstance(ds, xr.Dataset)\n\n    # check fields\n    expected_data_vars = {\n        \"variant_allele\",\n        \"call_genotype\",\n    }\n    assert set(ds.data_vars) == expected_data_vars\n\n    expected_coords = {\n        \"variant_contig\",\n        \"variant_position\",\n        \"sample_id\",\n    }\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    assert set(ds.dims) == {\"alleles\", \"ploidy\", \"samples\", \"variants\"}\n\n    # check samples\n    samples = ds[\"sample_id\"].values\n    assert set(samples) == set(expected_samples)\n\n    # check dim lengths\n    assert ds.dims[\"samples\"] == n_samples\n    assert ds.dims[\"ploidy\"] == 2\n    assert ds.dims[\"alleles\"] == 2\n\n    # check shapes\n    for f in expected_coords | expected_data_vars:\n        x = ds[f]\n        assert isinstance(x, xr.DataArray)\n        assert isinstance(x.data, da.Array)\n\n        if f == \"variant_allele\":\n            assert x.ndim == 2\n            assert x.shape[1] == 2\n            assert x.dims == (\"variants\", \"alleles\")\n        elif f.startswith(\"variant_\"):\n            assert x.ndim == 1\n            assert x.dims == (\"variants\",)\n        elif f == \"call_genotype\":\n            assert x.ndim == 3\n            assert x.dims == (\"variants\", \"samples\", \"ploidy\")\n            assert x.shape[1] == n_samples\n            assert x.shape[2] == 2\n\n    # check attributes\n    assert \"contigs\" in ds.attrs\n    assert ds.attrs[\"contigs\"] == (\"2R\", \"2L\", \"3R\", \"3L\", \"X\")\n\n\n# test v3 sample sets\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [\"3.0\", \"AG1000G-UG\", [\"AG1000G-AO\", \"AG1000G-FR\"]],\n)\ndef test_sample_cohorts(sample_sets):\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    expected_cols = (\n        \"sample_id\",\n        \"country_iso\",\n        \"admin1_name\",\n        \"admin1_iso\",\n        \"admin2_name\",\n        \"taxon\",\n        \"cohort_admin1_year\",\n        \"cohort_admin1_month\",\n        \"cohort_admin2_year\",\n        \"cohort_admin2_month\",\n    )\n\n    df_coh = ag3.sample_cohorts(sample_sets=sample_sets)\n    df_meta = ag3.sample_metadata(sample_sets=sample_sets)\n\n    assert tuple(df_coh.columns) == expected_cols\n    assert len(df_coh) == len(df_meta)\n    assert df_coh.sample_id.tolist() == df_meta.sample_id.tolist()\n    if sample_sets == \"AG1000G-UG\":\n        assert df_coh.sample_id[0] == \"AC0007-C\"\n        assert df_coh.cohort_admin1_year[23] == \"UG-E_arab_2012\"\n        assert df_coh.cohort_admin1_month[37] == \"UG-E_arab_2012_10\"\n        assert df_coh.cohort_admin2_year[42] == \"UG-E_Tororo_arab_2012\"\n        assert df_coh.cohort_admin2_month[49] == \"UG-E_Tororo_arab_2012_10\"\n    if sample_sets == [\"AG1000G-AO\", \"AG1000G-FR\"]:\n        assert df_coh.sample_id[0] == \"AR0047-C\"\n        assert df_coh.sample_id[103] == \"AP0017-Cx\"\n\n\n@pytest.mark.parametrize(\n    \"region_raw\",\n    [\n        \"AGAP007280\",\n        \"3L\",\n        \"2R:48714463-48715355\",\n        \"2L:24,630,355-24,633,221\",\n        Region(\"2R\", 48714463, 48715355),\n    ],\n)\ndef test_locate_region(region_raw):\n\n    ag3 = setup_ag3()\n    gene_annotation = ag3.geneset(attributes=[\"ID\"])\n    region = resolve_region(ag3, region_raw)\n    pos = ag3.snp_sites(region=region.contig, field=\"POS\")\n    ref = ag3.snp_sites(region=region.contig, field=\"REF\")\n    loc_region = locate_region(region, pos)\n\n    # check types\n    assert isinstance(loc_region, slice)\n    assert isinstance(region, Region)\n\n    # check Region with contig\n    if region_raw == \"3L\":\n        assert region.contig == \"3L\"\n        assert region.start is None\n        assert region.end is None\n\n    # check that Region goes through unchanged\n    if isinstance(region_raw, Region):\n        assert region == region_raw\n\n    # check that gene name matches coordinates from the geneset and matches gene sequence\n    if region_raw == \"AGAP007280\":\n        gene = gene_annotation.query(\"ID == 'AGAP007280'\").squeeze()\n        assert region == Region(gene.contig, gene.start, gene.end)\n        assert pos[loc_region][0] == gene.start\n        assert pos[loc_region][-1] == gene.end\n        assert (\n            ref[loc_region][:5].compute()\n            == np.array([\"A\", \"T\", \"G\", \"G\", \"C\"], dtype=\"S1\")\n        ).all()\n\n    # check string parsing\n    if region_raw == \"2R:48714463-48715355\":\n        assert region == Region(\"2R\", 48714463, 48715355)\n    if region_raw == \"2L:24,630,355-24,633,221\":\n        assert region == Region(\"2L\", 24630355, 24633221)\n\n\ndef test_aa_allele_frequencies():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    expected_fields = [\n        \"transcript\",\n        \"aa_pos\",\n        \"ref_allele\",\n        \"alt_allele\",\n        \"ref_aa\",\n        \"alt_aa\",\n        \"effect\",\n        \"impact\",\n        \"frq_BF-09_gamb_2012\",\n        \"frq_BF-09_colu_2012\",\n        \"frq_BF-09_colu_2014\",\n        \"frq_BF-09_gamb_2014\",\n        \"frq_BF-07_gamb_2004\",\n        \"max_af\",\n        \"label\",\n    ]\n\n    df = ag3.aa_allele_frequencies(\n        transcript=\"AGAP004707-RD\",\n        cohorts=\"admin1_year\",\n        min_cohort_size=10,\n        site_mask=\"gamb_colu\",\n        sample_sets=(\"AG1000G-BF-A\", \"AG1000G-BF-B\", \"AG1000G-BF-C\"),\n        drop_invariant=True,\n    )\n\n    assert sorted(df.columns.tolist()) == sorted(expected_fields)\n    assert isinstance(df, pd.DataFrame)\n    assert df.index.names == [\"aa_change\", \"contig\", \"position\"]\n    assert df.shape == (61, len(expected_fields))\n    assert df.loc[\"V402L\"].max_af[0] == pytest.approx(0.121951, abs=1e-6)\n\n\ndef test_aa_allele_frequencies__dup_samples():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    with pytest.raises(ValueError):\n        ag3.aa_allele_frequencies(\n            transcript=\"AGAP004707-RD\",\n            cohorts=\"admin1_year\",\n            sample_sets=[\"AG1000G-FR\", \"AG1000G-FR\"],\n        )\n\n\n# noinspection PyDefaultArgument\ndef _check_snp_allele_frequencies_advanced(\n    transcript=\"AGAP004707-RD\",\n    area_by=\"admin1_iso\",\n    period_by=\"year\",\n    sample_sets=[\"AG1000G-BF-A\", \"AG1000G-ML-A\", \"AG1000G-UG\"],\n    sample_query=None,\n    min_cohort_size=10,\n    nobs_mode=\"called\",\n    variant_query=\"max_af > 0.02\",\n):\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    ds = ag3.snp_allele_frequencies_advanced(\n        transcript=transcript,\n        area_by=area_by,\n        period_by=period_by,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        min_cohort_size=min_cohort_size,\n        nobs_mode=nobs_mode,\n        variant_query=variant_query,\n    )\n\n    assert isinstance(ds, xr.Dataset)\n\n    # noinspection PyTypeChecker\n    assert sorted(ds.dims) == [\"cohorts\", \"variants\"]\n\n    expected_variant_vars = (\n        \"variant_label\",\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_ref_allele\",\n        \"variant_alt_allele\",\n        \"variant_max_af\",\n        \"variant_pass_gamb_colu_arab\",\n        \"variant_pass_gamb_colu\",\n        \"variant_pass_arab\",\n        \"variant_transcript\",\n        \"variant_effect\",\n        \"variant_impact\",\n        \"variant_ref_codon\",\n        \"variant_alt_codon\",\n        \"variant_ref_aa\",\n        \"variant_alt_aa\",\n        \"variant_aa_pos\",\n        \"variant_aa_change\",\n    )\n    for v in expected_variant_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\",)\n\n    expected_cohort_vars = (\n        \"cohort_label\",\n        \"cohort_size\",\n        \"cohort_taxon\",\n        \"cohort_area\",\n        \"cohort_period\",\n        \"cohort_period_start\",\n        \"cohort_period_end\",\n        \"cohort_lat_mean\",\n        \"cohort_lat_min\",\n        \"cohort_lat_max\",\n        \"cohort_lon_mean\",\n        \"cohort_lon_min\",\n        \"cohort_lon_max\",\n    )\n    for v in expected_cohort_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"cohorts\",)\n\n    expected_event_vars = (\n        \"event_count\",\n        \"event_nobs\",\n        \"event_frequency\",\n        \"event_frequency_ci_low\",\n        \"event_frequency_ci_upp\",\n    )\n    for v in expected_event_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\", \"cohorts\")\n\n    # sanity checks for area values\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    if sample_query is not None:\n        df_samples = df_samples.query(sample_query)\n    expected_area = np.unique(df_samples[area_by].dropna().values)\n    area = ds[\"cohort_area\"].values\n    # N.B., some areas may not end up in final dataset if cohort\n    # size is too small, so do a set membership test\n    for a in area:\n        assert a in expected_area\n\n    # sanity checks for period values\n    period = ds[\"cohort_period\"].values\n    if period_by == \"year\":\n        expected_freqstr = \"A-DEC\"\n    elif period_by == \"month\":\n        expected_freqstr = \"M\"\n    elif period_by == \"quarter\":\n        expected_freqstr = \"Q-DEC\"\n    else:\n        assert False, \"not implemented\"\n    for p in period:\n        assert isinstance(p, pd.Period)\n        assert p.freqstr == expected_freqstr\n\n    # sanity check cohort size\n    size = ds[\"cohort_size\"].values\n    for s in size:\n        assert s >= min_cohort_size\n\n    if area_by == \"admin1_iso\" and period_by == \"year\" and nobs_mode == \"called\":\n\n        # Here we test the behaviour of the function when grouping by admin level\n        # 1 and year. We can do some more in-depth testing in this case because\n        # we can compare results directly against the simpler snp_allele_frequencies()\n        # function with the admin1_year cohorts.\n\n        # check consistency with the basic snp allele frequencies method\n        df_af = ag3.snp_allele_frequencies(\n            transcript=transcript,\n            cohorts=\"admin1_year\",\n            sample_sets=sample_sets,\n            sample_query=sample_query,\n            min_cohort_size=min_cohort_size,\n        )\n        df_af = df_af.reset_index()  # make sure all variables available to check\n        if variant_query is not None:\n            df_af = df_af.query(variant_query)\n\n        # check cohorts are consistent\n        expect_cohort_labels = sorted(\n            [c.split(\"frq_\")[1] for c in df_af.columns if c.startswith(\"frq_\")]\n        )\n        cohort_labels = sorted(ds[\"cohort_label\"].values)\n        assert cohort_labels == expect_cohort_labels\n\n        # check variants are consistent\n        assert ds.dims[\"variants\"] == len(df_af)\n        for v in expected_variant_vars:\n            c = v.split(\"variant_\")[1]\n            actual = ds[v]\n            expect = df_af[c]\n            _compare_series_like(actual, expect)\n\n        # check frequencies are consistent\n        for cohort_index, cohort_label in enumerate(ds[\"cohort_label\"].values):\n            actual_frq = ds[\"event_frequency\"].values[:, cohort_index]\n            expect_frq = df_af[f\"frq_{cohort_label}\"].values\n            assert_allclose(actual_frq, expect_frq)\n\n\n# noinspection PyDefaultArgument\ndef _check_aa_allele_frequencies_advanced(\n    transcript=\"AGAP004707-RD\",\n    area_by=\"admin1_iso\",\n    period_by=\"year\",\n    sample_sets=[\"AG1000G-BF-A\", \"AG1000G-ML-A\", \"AG1000G-UG\"],\n    sample_query=None,\n    min_cohort_size=10,\n    nobs_mode=\"called\",\n    variant_query=\"max_af > 0.02\",\n):\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    ds = ag3.aa_allele_frequencies_advanced(\n        transcript=transcript,\n        area_by=area_by,\n        period_by=period_by,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        min_cohort_size=min_cohort_size,\n        nobs_mode=nobs_mode,\n        variant_query=variant_query,\n    )\n\n    assert isinstance(ds, xr.Dataset)\n\n    # noinspection PyTypeChecker\n    assert sorted(ds.dims) == [\"cohorts\", \"variants\"]\n\n    expected_variant_vars = (\n        \"variant_label\",\n        \"variant_contig\",\n        \"variant_position\",\n        \"variant_max_af\",\n        \"variant_transcript\",\n        \"variant_effect\",\n        \"variant_impact\",\n        \"variant_ref_aa\",\n        \"variant_alt_aa\",\n        \"variant_aa_pos\",\n        \"variant_aa_change\",\n    )\n    for v in expected_variant_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\",)\n\n    expected_cohort_vars = (\n        \"cohort_label\",\n        \"cohort_size\",\n        \"cohort_taxon\",\n        \"cohort_area\",\n        \"cohort_period\",\n        \"cohort_period_start\",\n        \"cohort_period_end\",\n        \"cohort_lat_mean\",\n        \"cohort_lat_min\",\n        \"cohort_lat_max\",\n        \"cohort_lon_mean\",\n        \"cohort_lon_min\",\n        \"cohort_lon_max\",\n    )\n    for v in expected_cohort_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"cohorts\",)\n\n    expected_event_vars = (\n        \"event_count\",\n        \"event_nobs\",\n        \"event_frequency\",\n        \"event_frequency_ci_low\",\n        \"event_frequency_ci_upp\",\n    )\n    for v in expected_event_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\", \"cohorts\")\n\n    # sanity checks for area values\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    if sample_query is not None:\n        df_samples = df_samples.query(sample_query)\n    expected_area = np.unique(df_samples[area_by].dropna().values)\n    area = ds[\"cohort_area\"].values\n    # N.B., some areas may not end up in final dataset if cohort\n    # size is too small, so do a set membership test\n    for a in area:\n        assert a in expected_area\n\n    # sanity checks for period values\n    period = ds[\"cohort_period\"].values\n    if period_by == \"year\":\n        expected_freqstr = \"A-DEC\"\n    elif period_by == \"month\":\n        expected_freqstr = \"M\"\n    elif period_by == \"quarter\":\n        expected_freqstr = \"Q-DEC\"\n    else:\n        assert False, \"not implemented\"\n    for p in period:\n        assert isinstance(p, pd.Period)\n        assert p.freqstr == expected_freqstr\n\n    # sanity check cohort size\n    size = ds[\"cohort_size\"].values\n    for s in size:\n        assert s >= min_cohort_size\n\n    if area_by == \"admin1_iso\" and period_by == \"year\" and nobs_mode == \"called\":\n\n        # Here we test the behaviour of the function when grouping by admin level\n        # 1 and year. We can do some more in-depth testing in this case because\n        # we can compare results directly against the simpler aa_allele_frequencies()\n        # function with the admin1_year cohorts.\n\n        # check consistency with the basic snp allele frequencies method\n        df_af = ag3.aa_allele_frequencies(\n            transcript=transcript,\n            cohorts=\"admin1_year\",\n            sample_sets=sample_sets,\n            sample_query=sample_query,\n            min_cohort_size=min_cohort_size,\n        )\n        df_af = df_af.reset_index()  # make sure all variables available to check\n        if variant_query is not None:\n            df_af = df_af.query(variant_query)\n\n        # check cohorts are consistent\n        expect_cohort_labels = sorted(\n            [c.split(\"frq_\")[1] for c in df_af.columns if c.startswith(\"frq_\")]\n        )\n        cohort_labels = sorted(ds[\"cohort_label\"].values)\n        assert cohort_labels == expect_cohort_labels\n\n        # check variants are consistent\n        assert ds.dims[\"variants\"] == len(df_af)\n        for v in expected_variant_vars:\n            c = v.split(\"variant_\")[1]\n            actual = ds[v]\n            expect = df_af[c]\n            _compare_series_like(actual, expect)\n\n        # check frequencies are consistent\n        for cohort_index, cohort_label in enumerate(ds[\"cohort_label\"].values):\n            print(cohort_label)\n            actual_frq = ds[\"event_frequency\"].values[:, cohort_index]\n            expect_frq = df_af[f\"frq_{cohort_label}\"].values\n            assert_allclose(actual_frq, expect_frq)\n\n\n# Here we don't explore the full matrix, but vary one parameter at a time, otherwise\n# the test suite would take too long to run.\n\n\n@pytest.mark.parametrize(\"transcript\", [\"AGAP004707-RD\", \"AGAP006028-RA\"])\ndef test_allele_frequencies_advanced__transcript(transcript):\n    _check_snp_allele_frequencies_advanced(\n        transcript=transcript,\n    )\n    _check_aa_allele_frequencies_advanced(\n        transcript=transcript,\n    )\n\n\n@pytest.mark.parametrize(\"area_by\", [\"country\", \"admin1_iso\", \"admin2_name\"])\ndef test_allele_frequencies_advanced__area_by(area_by):\n    _check_snp_allele_frequencies_advanced(\n        area_by=area_by,\n    )\n    _check_aa_allele_frequencies_advanced(\n        area_by=area_by,\n    )\n\n\n@pytest.mark.parametrize(\"period_by\", [\"year\", \"quarter\", \"month\"])\ndef test_allele_frequencies_advanced__period_by(period_by):\n    _check_snp_allele_frequencies_advanced(\n        period_by=period_by,\n    )\n    _check_aa_allele_frequencies_advanced(\n        period_by=period_by,\n    )\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\", [\"AG1000G-BF-A\", [\"AG1000G-BF-A\", \"AG1000G-ML-A\"], \"3.0\"]\n)\ndef test_allele_frequencies_advanced__sample_sets(sample_sets):\n    _check_snp_allele_frequencies_advanced(\n        sample_sets=sample_sets,\n    )\n    _check_aa_allele_frequencies_advanced(\n        sample_sets=sample_sets,\n    )\n\n\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [\n        \"taxon in ['gambiae', 'coluzzii'] and country == 'Mali'\",\n        \"taxon == 'arabiensis' and country in ['Uganda', 'Tanzania']\",\n    ],\n)\ndef test_allele_frequencies_advanced__sample_query(sample_query):\n    _check_snp_allele_frequencies_advanced(\n        sample_query=sample_query,\n    )\n    # noinspection PyTypeChecker\n    _check_aa_allele_frequencies_advanced(\n        sample_query=sample_query,\n        variant_query=None,\n    )\n\n\n@pytest.mark.parametrize(\"min_cohort_size\", [10, 100])\ndef test_allele_frequencies_advanced__min_cohort_size(min_cohort_size):\n    _check_snp_allele_frequencies_advanced(\n        min_cohort_size=min_cohort_size,\n    )\n    _check_aa_allele_frequencies_advanced(\n        min_cohort_size=min_cohort_size,\n    )\n\n\n@pytest.mark.parametrize(\n    \"variant_query\",\n    [\n        None,\n        \"effect == 'NON_SYNONYMOUS_CODING' and max_af > 0.05\",\n        \"effect == 'foobar'\",  # no variants\n    ],\n)\ndef test_allele_frequencies_advanced__variant_query(variant_query):\n    _check_snp_allele_frequencies_advanced(\n        variant_query=variant_query,\n    )\n    _check_aa_allele_frequencies_advanced(\n        variant_query=variant_query,\n    )\n\n\n@pytest.mark.parametrize(\"nobs_mode\", [\"called\", \"fixed\"])\ndef test_allele_frequencies_advanced__nobs_mode(nobs_mode):\n    _check_snp_allele_frequencies_advanced(\n        nobs_mode=nobs_mode,\n    )\n    _check_aa_allele_frequencies_advanced(\n        nobs_mode=nobs_mode,\n    )\n\n\n# noinspection PyDefaultArgument\ndef _check_gene_cnv_frequencies_advanced(\n    region=\"2L\",\n    area_by=\"admin1_iso\",\n    period_by=\"year\",\n    sample_sets=[\"AG1000G-BF-A\", \"AG1000G-ML-A\", \"AG1000G-UG\"],\n    sample_query=None,\n    min_cohort_size=10,\n    variant_query=\"max_af > 0.02\",\n    drop_invariant=True,\n    max_coverage_variance=0.2,\n):\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    ds = ag3.gene_cnv_frequencies_advanced(\n        region=region,\n        area_by=area_by,\n        period_by=period_by,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        min_cohort_size=min_cohort_size,\n        variant_query=variant_query,\n        drop_invariant=drop_invariant,\n        max_coverage_variance=max_coverage_variance,\n    )\n\n    assert isinstance(ds, xr.Dataset)\n\n    # noinspection PyTypeChecker\n    assert sorted(ds.dims) == [\"cohorts\", \"variants\"]\n\n    expected_variant_vars = (\n        \"variant_label\",\n        \"variant_contig\",\n        \"variant_start\",\n        \"variant_end\",\n        \"variant_windows\",\n        \"variant_cnv_type\",\n        \"variant_gene_id\",\n        \"variant_gene_name\",\n        \"variant_gene_strand\",\n        \"variant_max_af\",\n    )\n    for v in expected_variant_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\",)\n\n    expected_cohort_vars = (\n        \"cohort_label\",\n        \"cohort_size\",\n        \"cohort_taxon\",\n        \"cohort_area\",\n        \"cohort_period\",\n        \"cohort_period_start\",\n        \"cohort_period_end\",\n        \"cohort_lat_mean\",\n        \"cohort_lat_min\",\n        \"cohort_lat_max\",\n        \"cohort_lon_mean\",\n        \"cohort_lon_min\",\n        \"cohort_lon_max\",\n    )\n    for v in expected_cohort_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"cohorts\",)\n\n    expected_event_vars = (\n        \"event_count\",\n        \"event_nobs\",\n        \"event_frequency\",\n        \"event_frequency_ci_low\",\n        \"event_frequency_ci_upp\",\n    )\n    for v in expected_event_vars:\n        a = ds[v]\n        assert isinstance(a, xr.DataArray)\n        assert a.dims == (\"variants\", \"cohorts\")\n\n    # sanity checks for area values\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets)\n    if sample_query is not None:\n        df_samples = df_samples.query(sample_query)\n    expected_area = np.unique(df_samples[area_by].dropna().values)\n    area = ds[\"cohort_area\"].values\n    # N.B., some areas may not end up in final dataset if cohort\n    # size is too small, so do a set membership test\n    for a in area:\n        assert a in expected_area\n\n    # sanity checks for period values\n    period = ds[\"cohort_period\"].values\n    if period_by == \"year\":\n        expected_freqstr = \"A-DEC\"\n    elif period_by == \"month\":\n        expected_freqstr = \"M\"\n    elif period_by == \"quarter\":\n        expected_freqstr = \"Q-DEC\"\n    else:\n        assert False, \"not implemented\"\n    for p in period:\n        assert isinstance(p, pd.Period)\n        assert p.freqstr == expected_freqstr\n\n    # sanity check cohort size\n    size = ds[\"cohort_size\"].values\n    for s in size:\n        assert s >= min_cohort_size\n\n    if area_by == \"admin1_iso\" and period_by == \"year\":\n\n        # Here we test the behaviour of the function when grouping by admin level\n        # 1 and year. We can do some more in-depth testing in this case because\n        # we can compare results directly against the simpler gene_cnv_frequencies()\n        # function with the admin1_year cohorts.\n\n        # check consistency with the basic gene CNV frequencies method\n        df_af = ag3.gene_cnv_frequencies(\n            region=region,\n            cohorts=\"admin1_year\",\n            sample_sets=sample_sets,\n            sample_query=sample_query,\n            min_cohort_size=min_cohort_size,\n            drop_invariant=drop_invariant,\n            max_coverage_variance=max_coverage_variance,\n        )\n        df_af = df_af.reset_index()  # make sure all variables available to check\n        if variant_query is not None:\n            df_af = df_af.query(variant_query)\n\n        # check cohorts are consistent\n        expect_cohort_labels = sorted(\n            [c.split(\"frq_\")[1] for c in df_af.columns if c.startswith(\"frq_\")]\n        )\n        cohort_labels = sorted(ds[\"cohort_label\"].values)\n        assert cohort_labels == expect_cohort_labels\n\n        # check variants are consistent\n        assert ds.dims[\"variants\"] == len(df_af)\n        for v in expected_variant_vars:\n            c = v.split(\"variant_\")[1]\n            actual = ds[v]\n            expect = df_af[c]\n            _compare_series_like(actual, expect)\n\n        # check frequencies are consistent\n        for cohort_index, cohort_label in enumerate(ds[\"cohort_label\"].values):\n            actual_frq = ds[\"event_frequency\"].values[:, cohort_index]\n            expect_frq = df_af[f\"frq_{cohort_label}\"].values\n            assert_allclose(actual_frq, expect_frq)\n\n\n@pytest.mark.parametrize(\"region\", [\"2R\", \"X\", [\"3R\", \"X\"], \"3R:28,000,000-29,000,000\"])\ndef test_gene_cnv_frequencies_advanced__region(region):\n    _check_gene_cnv_frequencies_advanced(\n        region=region,\n    )\n\n\n@pytest.mark.parametrize(\"area_by\", [\"country\", \"admin1_iso\", \"admin2_name\"])\ndef test_gene_cnv_frequencies_advanced__area_by(area_by):\n    _check_gene_cnv_frequencies_advanced(\n        area_by=area_by,\n    )\n\n\n@pytest.mark.parametrize(\"period_by\", [\"year\", \"quarter\", \"month\"])\ndef test_gene_cnv_frequencies_advanced__period_by(period_by):\n    _check_gene_cnv_frequencies_advanced(\n        period_by=period_by,\n    )\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\", [\"AG1000G-BF-A\", [\"AG1000G-BF-A\", \"AG1000G-ML-A\"], \"3.0\"]\n)\ndef test_gene_cnv_frequencies_advanced__sample_sets(sample_sets):\n    _check_gene_cnv_frequencies_advanced(\n        sample_sets=sample_sets,\n    )\n\n\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [\n        \"taxon in ['gambiae', 'coluzzii'] and country == 'Mali'\",\n        \"taxon == 'arabiensis' and country in ['Uganda', 'Tanzania']\",\n    ],\n)\ndef test_gene_cnv_frequencies_advanced__sample_query(sample_query):\n    _check_gene_cnv_frequencies_advanced(\n        sample_query=sample_query,\n    )\n\n\n@pytest.mark.parametrize(\"min_cohort_size\", [10, 100])\ndef test_gene_cnv_frequencies_advanced__min_cohort_size(min_cohort_size):\n    _check_gene_cnv_frequencies_advanced(\n        min_cohort_size=min_cohort_size,\n    )\n\n\n@pytest.mark.parametrize(\n    \"variant_query\",\n    [\n        None,\n        \"cnv_type == 'amp' and max_af > 0.05\",\n    ],\n)\ndef test_gene_cnv_frequencies_advanced__variant_query(variant_query):\n    _check_gene_cnv_frequencies_advanced(\n        variant_query=variant_query,\n    )\n\n\n@pytest.mark.parametrize(\n    \"drop_invariant\",\n    [\n        False,\n        True,\n    ],\n)\ndef test_gene_cnv_frequencies_advanced__drop_invariant(drop_invariant):\n    # noinspection PyTypeChecker\n    _check_gene_cnv_frequencies_advanced(\n        variant_query=None,\n        drop_invariant=drop_invariant,\n    )\n\n\n@pytest.mark.parametrize(\n    \"max_coverage_variance\",\n    [None, 0.2],\n)\ndef test_gene_cnv_frequencies_advanced__max_coverage_variance(max_coverage_variance):\n    _check_gene_cnv_frequencies_advanced(\n        max_coverage_variance=max_coverage_variance,\n        sample_sets=[\"AG1000G-GM-A\", \"AG1000G-GM-B\", \"AG1000G-GM-C\"],\n    )\n\n\ndef test_gene_cnv_frequencies_advanced__multi_contig_x():\n    # https:\/\/github.com\/malariagen\/malariagen-data-python\/issues\/166\n\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n\n    ds1 = ag3.gene_cnv_frequencies_advanced(\n        region=\"X\",\n        area_by=\"admin1_iso\",\n        period_by=\"year\",\n        sample_sets=\"AG1000G-BF-B\",\n        sample_query=None,\n        min_cohort_size=10,\n        variant_query=None,\n        drop_invariant=False,\n        max_coverage_variance=None,\n    )\n\n    ds2 = ag3.gene_cnv_frequencies_advanced(\n        region=[\"2R\", \"X\"],\n        area_by=\"admin1_iso\",\n        period_by=\"year\",\n        sample_sets=\"AG1000G-BF-B\",\n        sample_query=None,\n        min_cohort_size=10,\n        variant_query=None,\n        drop_invariant=False,\n        max_coverage_variance=None,\n    )\n    loc_x = ds2[\"variant_contig\"].values == \"X\"\n    ds2 = ds2.isel(variants=loc_x)\n\n    for v in ds1:\n        a = ds1[v]\n        b = ds2[v]\n        _compare_series_like(a, b)\n\n\ndef test_gene_cnv_frequencies_advanced__missing_samples():\n    # https:\/\/github.com\/malariagen\/malariagen-data-python\/issues\/183\n\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\", pre=True)\n\n    ds = ag3.gene_cnv_frequencies_advanced(\n        region=\"3L\",\n        sample_sets=\"1190-VO-GH-AMENGA-ETEGO-VMF00013\",\n        area_by=\"admin1_iso\",\n        period_by=\"year\",\n    )\n    assert isinstance(ds, xr.Dataset)\n\n\ndef test_snp_allele_frequencies_advanced__dup_samples():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    with pytest.raises(ValueError):\n        ag3.snp_allele_frequencies_advanced(\n            transcript=\"AGAP004707-RD\",\n            area_by=\"admin1_iso\",\n            period_by=\"year\",\n            sample_sets=[\"AG1000G-BF-A\", \"AG1000G-BF-A\"],\n        )\n\n\ndef test_aa_allele_frequencies_advanced__dup_samples():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    with pytest.raises(ValueError):\n        ag3.aa_allele_frequencies_advanced(\n            transcript=\"AGAP004707-RD\",\n            area_by=\"admin1_iso\",\n            period_by=\"year\",\n            sample_sets=[\"AG1000G-BF-A\", \"AG1000G-BF-A\"],\n        )\n\n\ndef test_gene_cnv_frequencies_advanced__dup_samples():\n    ag3 = setup_ag3(cohorts_analysis=\"20211101\")\n    with pytest.raises(ValueError):\n        ag3.gene_cnv_frequencies_advanced(\n            region=\"3L\",\n            area_by=\"admin1_iso\",\n            period_by=\"year\",\n            sample_sets=[\"AG1000G-BF-A\", \"AG1000G-BF-A\"],\n        )\n\n\n@pytest.mark.parametrize(\"region\", [\"2R:1,000,000-2,000,000\", \"AGAP004707\"])\n@pytest.mark.parametrize(\n    \"sample_sets\", [\"AG1000G-AO\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"]]\n)\n@pytest.mark.parametrize(\"sample_query\", [None, \"taxon == 'coluzzii'\"])\n@pytest.mark.parametrize(\"site_mask\", [None, \"gamb_colu_arab\"])\ndef test_snp_allele_counts(region, sample_sets, sample_query, site_mask):\n\n    results_cache = \"..\/results_cache\"\n    shutil.rmtree(results_cache, ignore_errors=True)\n    ag3 = setup_ag3(results_cache=results_cache)\n\n    ac = ag3.snp_allele_counts(\n        region=region,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        site_mask=site_mask,\n    )\n    assert isinstance(ac, np.ndarray)\n    pos = ag3.snp_sites(region=region, field=\"POS\", site_mask=site_mask)\n    assert ac.shape == (pos.shape[0], 4)\n\n    ac2 = ag3.snp_allele_counts(\n        region=region,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        site_mask=site_mask,\n    )\n    assert_array_equal(ac, ac2)\n\n\n@pytest.mark.parametrize(\"region\", [\"2R:1,000,000-2,000,000\", \"AGAP004707\"])\n@pytest.mark.parametrize(\n    \"sample_sets\", [\"AG1000G-AO\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"]]\n)\n@pytest.mark.parametrize(\"sample_query\", [None, \"taxon == 'coluzzii'\"])\n@pytest.mark.parametrize(\"site_mask\", [None, \"gamb_colu_arab\"])\ndef test_pca(region, sample_sets, sample_query, site_mask):\n\n    results_cache = \"..\/results_cache\"\n    shutil.rmtree(results_cache, ignore_errors=True)\n    ag3 = setup_ag3(results_cache=results_cache)\n\n    n_components = 8\n    df_pca, evr = ag3.pca(\n        region=region,\n        n_snps=100,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        site_mask=site_mask,\n        n_components=n_components,\n    )\n\n    df_samples = ag3.sample_metadata(\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n    )\n\n    assert isinstance(df_pca, pd.DataFrame)\n    assert len(df_pca) == len(df_samples)\n    expected_columns = df_samples.columns.tolist() + [\n        f\"PC{n+1}\" for n in range(n_components)\n    ]\n    assert df_pca.columns.tolist() == expected_columns\n    assert_frame_equal(df_samples, df_pca[df_samples.columns.tolist()])\n    assert isinstance(evr, np.ndarray)\n    assert evr.shape == (n_components,)\n\n    df_pca2, evr2 = ag3.pca(\n        region=region,\n        n_snps=100,\n        sample_sets=sample_sets,\n        sample_query=sample_query,\n        site_mask=site_mask,\n        n_components=n_components,\n    )\n    assert_frame_equal(df_pca, df_pca2)\n    assert_array_equal(evr, evr2)\n\n\ndef _compare_series_like(actual, expect):\n\n    # compare pandas series-like objects for equality or floating point\n    # similarity, handling missing values appropriately\n\n    # handle object arrays, these don't get nans compared properly\n    t = actual.dtype\n    if t == object:\n        expect = expect.fillna(\"NA\")\n        actual = actual.fillna(\"NA\")\n\n    if t.kind == \"f\":\n        assert_allclose(actual.values, expect.values)\n    else:\n        assert_array_equal(actual.values, expect.values)\n\n\n@pytest.mark.parametrize(\"aims\", [\"gamb_vs_colu\", \"gambcolu_vs_arab\"])\ndef test_aim_variants(aims):\n    ag3 = setup_ag3()\n    ds = ag3.aim_variants(aims=aims)\n\n    # check dataset\n    assert isinstance(ds, xr.Dataset)\n\n    # check variables\n    expected_data_vars = {\"variant_allele\"}\n    assert set(ds.data_vars) == expected_data_vars\n\n    # check coordinates\n    expected_coords = {\"variant_contig\", \"variant_position\"}\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    expected_dims = {\"variants\", \"alleles\"}\n    assert set(ds.dims) == expected_dims\n\n    # check variant_contig\n    x = ds[\"variant_contig\"]\n    assert x.dims == (\"variants\",)\n    assert x.dtype == \"uint8\"\n\n    # check variant_position\n    x = ds[\"variant_position\"]\n    assert x.dims == (\"variants\",)\n    assert x.dtype == \"int64\" or \"int32\"\n\n    # check variant_allele\n    x = ds[\"variant_allele\"]\n    assert x.dims == (\"variants\", \"alleles\")\n    assert x.dtype == \"S1\"\n\n    # check attributes\n    assert ds.attrs[\"contigs\"] == [\"2R\", \"2L\", \"3R\", \"3L\", \"X\"]\n\n    # check dimension lengths\n    assert ds.dims[\"alleles\"] == 2\n    if aims == \"gamb_vs_colu\":\n        assert ds.dims[\"variants\"] == 700\n    elif aims == \"gambcolu_vs_arab\":\n        assert ds.dims[\"variants\"] == 2612\n\n\n@pytest.mark.parametrize(\n    \"sample_sets\",\n    [None, \"AG1000G-UG\", [\"AG1000G-BF-A\", \"AG1000G-BF-B\"], \"3.0\"],\n)\n@pytest.mark.parametrize(\n    \"sample_query\",\n    [None, \"aim_species != 'arabiensis'\"],\n)\n@pytest.mark.parametrize(\"aims\", [\"gamb_vs_colu\", \"gambcolu_vs_arab\"])\ndef test_aim_calls(sample_sets, sample_query, aims):\n    ag3 = setup_ag3()\n    ds = ag3.aim_calls(aims=aims, sample_sets=sample_sets, sample_query=sample_query)\n\n    # check dataset\n    assert isinstance(ds, xr.Dataset)\n\n    # check variables\n    expected_data_vars = {\"variant_allele\", \"call_genotype\"}\n    assert set(ds.data_vars) == expected_data_vars\n\n    # check coordinates\n    expected_coords = {\"variant_contig\", \"variant_position\", \"sample_id\"}\n    assert set(ds.coords) == expected_coords\n\n    # check dimensions\n    expected_dims = {\"variants\", \"alleles\", \"samples\", \"ploidy\"}\n    assert set(ds.dims) == expected_dims\n\n    # check variant_contig\n    x = ds[\"variant_contig\"]\n    assert x.dims == (\"variants\",)\n    assert x.dtype == \"uint8\"\n\n    # check variant_position\n    x = ds[\"variant_position\"]\n    assert x.dims == (\"variants\",)\n    assert (x.dtype == \"int32\") or (x.dtype == \"int64\")\n\n    # check variant_allele\n    x = ds[\"variant_allele\"]\n    assert x.dims == (\"variants\", \"alleles\")\n    assert x.dtype == \"S1\"\n\n    # check variant_allele\n    x = ds[\"call_genotype\"]\n    assert x.dims == (\"variants\", \"samples\", \"ploidy\")\n    assert x.dtype == \"int8\"\n\n    # check attributes\n    assert ds.attrs[\"contigs\"] == [\"2R\", \"2L\", \"3R\", \"3L\", \"X\"]\n\n    # check dimension lengths\n    df_samples = ag3.sample_metadata(sample_sets=sample_sets, sample_query=sample_query)\n    assert_array_equal(df_samples[\"sample_id\"].values, ds[\"sample_id\"].values)\n    assert ds.dims[\"samples\"] == len(df_samples)\n    assert ds.dims[\"alleles\"] == 2\n    assert ds.dims[\"ploidy\"] == 2\n    if aims == \"gamb_vs_colu\":\n        assert ds.dims[\"variants\"] == 700\n    elif aims == \"gambcolu_vs_arab\":\n        assert ds.dims[\"variants\"] == 2612\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_282","text":"<reponame>Melanee-Melanee\/X-Caps\n'''\nEncoding Visual Attributes in Capsules for Explainable Medical Diagnoses (X-Caps)\nOriginal Paper by <NAME>, <NAME>, and <NAME> (https:\/\/arxiv.org\/abs\/1909.05926)\nCode written by: <NAME>\nIf you use significant portions of this code or the ideas from our paper, please cite it :)\nIf you have any questions, please email me at <EMAIL>.\n\nThis file contains the functions needed to convert the LIDC-IDRI dataset to the expected format.\n'''\n\nimport os\nfrom fnmatch import filter as fnf\nfrom glob import glob\nimport xml.etree.ElementTree as ET\n\nfrom tqdm import tqdm\ntry:\n    import pydicom as pydcm\nexcept:\n    import dicom as pydcm\nimport numpy as np\nfrom scipy.ndimage.morphology import binary_fill_holes\nfrom PIL import Image\n\nfrom utils import safe_mkdir\n\n\ndef create_cropped_nodules(IMG_ROOT, OUT_ROOT):\n    safe_mkdir(OUT_ROOT)\n\n    DEFAULT_PIXEL_SPACING = 0.787109\n    DEFAULT_SLICE_THICKNESS = 2.5\n    CROP_EXTRA_AMT = (np.sqrt(2)-1)\/2\n\n    print('Finding all xml files in LIDC-IDRI')\n    matches = []\n    for d1 in tqdm(sorted(os.listdir(IMG_ROOT))):\n        for d2 in sorted(os.listdir(os.path.join(IMG_ROOT, d1))):\n            if d2 == 'AdamsMasks':\n                continue\n            for d3 in sorted(os.listdir(os.path.join(IMG_ROOT, d1, d2))):\n                for f in fnf(os.listdir(os.path.join(IMG_ROOT, d1, d2, d3)), '*.xml'):\n                    matches.append(os.path.join(IMG_ROOT, d1, d2, d3, f))\n\n    print('\\nCreating cropped images of all nodules in LIDC-IDRI')\n    for xml_file in tqdm(matches):\n        # Load dicom image\n        img_path = os.path.dirname(xml_file)\n        dcm_imgs = []\n        for dir, _, files in os.walk(img_path):\n            for file in fnf(files, '*.dcm'):\n                dcm_imgs.append(os.path.join(dir, file))\n\n        # Get ref file\n        RefDs = pydcm.read_file(dcm_imgs[0])\n\n        # Load dimensions based on the number of rows, columns, and slices (along the Z axis)\n        ConstPixelDims = (int(RefDs.Rows), int(RefDs.Columns), len(dcm_imgs))\n        if int(RefDs.Rows) > 512 or int(RefDs.Columns) > 512:\n            continue\n\n        # Load spacing values (in mm)\n        try:\n            pixel_space = [float(RefDs.PixelSpacing[0]), float(RefDs.PixelSpacing[1])]\n        except AttributeError as e:\n            if str(e) == \"'FileDataset' object has no attribute 'PixelSpacing'\":\n                pixel_space = [DEFAULT_PIXEL_SPACING, DEFAULT_PIXEL_SPACING]\n            else:\n                raise NotImplementedError('Unhandled exception in pixel spacing.')\n\n        # Load slice thickness (in mm)\n        try:\n            slice_thick = float(RefDs.SliceThickness)\n        except AttributeError as e:\n            if str(e) == \"'FileDataset' object has no attribute 'SliceThickness'\":\n                if os.path.basename(xml_file)[:-4] == '243' or os.path.basename(xml_file)[:-4] == '244' or \\\n                                os.path.basename(xml_file)[:-4] == '070':\n                    slice_thick = 2.5\n                elif os.path.basename(xml_file)[:-4] == '135':\n                    slice_thick = 2.0\n                elif os.path.basename(xml_file)[:-4] == '043':\n                    slice_thick = 1.8\n                else:\n                    slice_thick = DEFAULT_SLICE_THICKNESS\n            else:\n                raise NotImplementedError('Unhandled exception in slice thickness.')\n\n        ConstPixelSpacing = (pixel_space[0], pixel_space[1], slice_thick)\n\n        x = np.arange(0.0, (ConstPixelDims[0] + 1) * ConstPixelSpacing[0], ConstPixelSpacing[0])\n        y = np.arange(0.0, (ConstPixelDims[1] + 1) * ConstPixelSpacing[1], ConstPixelSpacing[1])\n        z = np.arange(0.0, (ConstPixelDims[2] + 1) * ConstPixelSpacing[2], ConstPixelSpacing[2])\n\n        # The array is sized based on 'ConstPixelDims'\n        ArrayDicom = np.zeros(ConstPixelDims, dtype=RefDs.pixel_array.dtype)\n\n        # loop through all the DICOM files\n        sop_ids = dict()\n        for filenameDCM in dcm_imgs:\n            # read the file\n            ds = pydcm.read_file(filenameDCM)\n            # store the raw image data\n            ArrayDicom[:, :, dcm_imgs.index(filenameDCM)] = ds.pixel_array\n            sop_ids[ds.SOPInstanceUID] = filenameDCM\n\n        # Load attributes\n        tree = ET.parse(xml_file)\n        root = tree.getroot()\n\n        unique_nodule_list = []\n        curr_nodule = -1\n        for s in root.findall('{http:\/\/www.nih.gov}ResponseHeader'):\n            try:\n                study_id = s.find('{http:\/\/www.nih.gov}StudyInstanceUID').text\n            except:\n                study_id = -1\n        for r_num, rad in enumerate(root.findall('{http:\/\/www.nih.gov}readingSession')):\n            try:\n                rad_id = rad.find('{http:\/\/www.nih.gov}servicingRadiologistID').text\n                if rad_id == 'anon':\n                    rad_id = 'anon-{:02d}'.format(r_num)\n            except:\n                rad_id = -1\n            for nodule in rad.findall('{http:\/\/www.nih.gov}unblindedReadNodule'):\n                nodule_id = nodule.find('{http:\/\/www.nih.gov}noduleID').text\n                sub = -1; ist = -1; cal = -1; sph = -1; mar = -1; lob = -1; spi = -1; tex = -1; mal = -1\n                for charac in nodule.findall('{http:\/\/www.nih.gov}characteristics'):\n                    try:\n                        sub = int(charac.find('{http:\/\/www.nih.gov}subtlety').text)\n                    except:\n                        pass\n                    try:\n                        ist = int(charac.find('{http:\/\/www.nih.gov}internalStructure').text)\n                    except:\n                        pass\n                    try:\n                        cal = int(charac.find('{http:\/\/www.nih.gov}calcification').text)\n                    except:\n                        pass\n                    try:\n                        sph = int(charac.find('{http:\/\/www.nih.gov}sphericity').text)\n                    except:\n                        pass\n                    try:\n                        mar = int(charac.find('{http:\/\/www.nih.gov}margin').text)\n                    except:\n                        pass\n                    try:\n                        lob = int(charac.find('{http:\/\/www.nih.gov}lobulation').text)\n                    except:\n                        pass\n                    try:\n                        spi = int(charac.find('{http:\/\/www.nih.gov}spiculation').text)\n                    except:\n                        pass\n                    try:\n                        tex = int(charac.find('{http:\/\/www.nih.gov}texture').text)\n                    except:\n                        pass\n                    try:\n                        mal = int(charac.find('{http:\/\/www.nih.gov}malignancy').text)\n                    except:\n                        pass\n                slices = []\n                x_min = 999999; x_max = -9999999; y_min = 999999; y_max = -9999999\n                slice_list = nodule.findall('{http:\/\/www.nih.gov}roi')\n                GT = np.zeros((ConstPixelDims[0], ConstPixelDims[1], len(slice_list)), dtype=np.uint8)\n                for i, roi in enumerate(slice_list):\n                    z_pos = -1*float(roi.find('{http:\/\/www.nih.gov}imageZposition').text)\n                    sop_id = roi.find('{http:\/\/www.nih.gov}imageSOP_UID').text\n                    for edges in roi.findall('{http:\/\/www.nih.gov}edgeMap'):\n                        x_pos = int(edges.find('{http:\/\/www.nih.gov}xCoord').text)\n                        y_pos = int(edges.find('{http:\/\/www.nih.gov}yCoord').text)\n                        GT[y_pos,x_pos, i] = 1\n                        if x_pos < x_min:\n                            x_min = x_pos\n                        if x_pos > x_max:\n                            x_max = x_pos\n                        if y_pos < y_min:\n                            y_min = y_pos\n                        if y_pos > y_max:\n                            y_max = y_pos\n                    slices.append([sop_id, z_pos])\n                    GT[:,:,i] = binary_fill_holes(GT[:,:,i])\n\n                np_slices = np.asarray(slices)\n                sorted_slices = np_slices[np_slices[:, 1].argsort()]\n                sorted_GT = GT[:,:,np_slices[:, 1].argsort()]\n\n                mean_x = np.mean((x_min, x_max))\n                mean_y = np.mean((y_min, y_max))\n                mean_z = np.mean((float(sorted_slices[0][1]), float(sorted_slices[-1][1])))\n                width = abs(x_max - x_min)\n                height = abs(y_max - y_min)\n                depth = abs(float(sorted_slices[-1][1]) - float(sorted_slices[0][1]))\n                this_nodule = -1\n                matched_list = []\n                for i, nod_coords in enumerate(unique_nodule_list):\n                    if (abs(nod_coords[0] - mean_x) < (nod_coords[3]+width)\/4 or abs(nod_coords[0] - mean_x) <= 3) and \\\n                       (abs(nod_coords[1] - mean_y) < (nod_coords[4]+height)\/4 or abs(nod_coords[1] - mean_y) <= 3) and \\\n                       (abs(nod_coords[2] - mean_z) < (nod_coords[5]+depth)\/4 or abs(nod_coords[2] - mean_z) <= 3*slice_thick):\n                        # Check for multiple matches\n                        matched_list.append([i, np.sqrt((nod_coords[0] - mean_x)**2 + (nod_coords[1] - mean_y)**2 +\n                                                        (nod_coords[2] - mean_z)**2)])\n                if matched_list:\n                    matched_list = np.asarray(matched_list)\n                    for match in matched_list[matched_list[:, 1].argsort()]:\n                        if not glob(os.path.join(OUT_ROOT, '{}_{}'.format(os.path.basename(os.path.dirname(os.path.dirname(os.path.dirname(xml_file)))), study_id),\n                                   'nodule_{:03d}'.format(int(match[0])), 'rad-{}_*'.format(rad_id))):\n                            this_nodule = int(match[0])\n                            break\n                if this_nodule == -1:\n                    unique_nodule_list.append([mean_x, mean_y, mean_z, width, height, depth])\n                    curr_nodule += 1\n                    this_nodule = curr_nodule\n\n                out_dir = os.path.join(OUT_ROOT, '{}_{}'.format(os.path.basename(os.path.dirname(os.path.dirname(os.path.dirname(xml_file)))), study_id),\n                               'nodule_{:03d}'.format(this_nodule), 'rad-{}_sub-{}_ist-{}_cal-{}_sph-{}_mar-{}_lob-{}_'\n                               'spi-{}_tex-{}_mal-{}'.format(rad_id, sub, ist, cal, sph, mar, lob, spi, tex, mal))\n                safe_mkdir(out_dir)\n\n                for i, box in enumerate(sorted_slices):\n                    try:\n                        dcm_slice = int(dcm_imgs.index(sop_ids[box[0]]))\n                    except Exception as e:\n                        box[0] = correct_images(box[0])\n                        if box[0] != '-1' and box[0] != '-2':\n                            dcm_slice = int(dcm_imgs.index(sop_ids[box[0]]))\n                        elif box[0] == '-2':\n                            continue # This option is for images which cannot be corrected but are unimportant\n                        else:\n                            print('Unable to locate correct .dcm slice for {}: {}. Please correct by hand.'.format(out_dir, box[0]))\n                            print(e)\n                            continue\n\n                    h_extra = int(height * CROP_EXTRA_AMT)\n                    w_extra = int(width * CROP_EXTRA_AMT)\n                    # These are to handle single pixel annotations\n                    if h_extra < 2:\n                        h_extra = 2\n                    if w_extra < 2:\n                        w_extra = 2\n                    crop = ArrayDicom[y_min-h_extra:y_max+h_extra, x_min-w_extra:x_max+w_extra, dcm_slice]\n                    crop_GT = sorted_GT[y_min-h_extra:y_max+h_extra, x_min-w_extra:x_max+w_extra, i]\n\n                    try:\n                        # NOTE: Make sure to change values back to int16 from uint16 when reading the images in!!!\n                        im = Image.fromarray(crop.astype('<i2'))\n                        im.save(os.path.join(out_dir, '{:03d}.tif').format(i))\n                        gt_im = Image.fromarray(crop_GT)\n                        gt_im.save(os.path.join(out_dir, 'gt_{:03d}.tif').format(i))\n                    except Exception as e:\n                        print('Unable to create image for: {}.'.format(out_dir))\n                        print(e)\n\n    print('\\n\\nCompleted creating all nodule cropped images for LIDC-IDRI dataset!')\n\n\ndef create_master_list(IMG_ROOT, OUT_ROOT):\n    MIN_RADS = 3\n    safe_mkdir(OUT_ROOT)\n\n    num_chars_data = np.zeros((9,6))\n\n    print('Finding all nodule files in LIDC-IDRI with >= {} radiologists\\' characteristics data'.format(MIN_RADS))\n    matches = []\n    nodules_total = 0\n    nodules_to_use = 0\n    non_mal_count = 0\n    mal_count = 0\n\n    for study_dir in tqdm(sorted(os.listdir(IMG_ROOT))):\n        nodule_list = sorted(os.listdir(os.path.join(IMG_ROOT, study_dir)))\n        nodules_total += len(nodule_list)\n        for nodule_dir in nodule_list:\n            rad_dirs = sorted(os.listdir(os.path.join(IMG_ROOT, study_dir, nodule_dir)))\n            rads = len(rad_dirs)\n            if rads < MIN_RADS:\n                continue\n            temp_list = []\n            temp_char_data = np.zeros((9,6))\n            for rad_dir in rad_dirs:\n                if not os.listdir(os.path.join(IMG_ROOT, study_dir, nodule_dir, rad_dir)):\n                    rads -= 1 # Make sure there is actually image(s) for this rad\n                else:\n                    split_names = rad_dir.split('_')\n                    all_chars = True\n                    for i in range(1,10):\n                        if split_names[i][-3:] == '--1':\n                            all_chars = False\n                        else:\n                            temp_char_data[i-1][int(split_names[i][-1])-1] += 1\n                    if not all_chars:\n                        rads -= 1\n                    else:\n                        temp_list.append(os.path.join(IMG_ROOT, study_dir, nodule_dir, rad_dir))\n\n            if rads >= MIN_RADS:\n                # Compute mean mal score\n                char_data_totals = np.zeros((9,rads))\n                char_data_stats = np.zeros((9,2))\n\n                for i in range(temp_char_data.shape[0]):\n                    c = 0\n                    for j in range(temp_char_data.shape[1]):\n                        for k in range(int(temp_char_data[i,j])):\n                            char_data_totals[i,c] = (j + 1)\n                            c += 1\n                char_data_stats[:,0] = np.mean(char_data_totals, axis=1)\n                char_data_stats[:, 1] = np.std(char_data_totals, axis=1)\n                mean_mal = char_data_stats[8,0]\n\n                if mean_mal != 3.:\n                    if rads > 4:\n                        print('Encountered rads > 4: {}'.format(os.path.join(IMG_ROOT, study_dir, nodule_dir))) # Sanity check for nodule matching\n                    if mean_mal > 3.:\n                        mal_count += 1\n                    else:\n                        non_mal_count += 1\n                    num_chars_data += temp_char_data\n                    nodules_to_use += 1\n                    for file_path in temp_list:\n                        matches.append([file_path] + list(np.ndarray.flatten(char_data_stats)))\n\n    print('Found {} total nodules.'.format(nodules_total))\n    print('Found {} nodules with characteristics and determinable (not score 3) avg malignancy scores.'.format(nodules_to_use))\n    print('{} nodules average score below 3.0, {} nodules above 3.0.'.format(non_mal_count, mal_count))\n\n    np.savetxt(os.path.join(OUT_ROOT, 'nodule_characteristics_counts.csv'),\n               np.concatenate((np.expand_dims(np.asarray(['sub', 'ist', 'cal', 'sph', 'mar', 'lob', 'spi',\n               'tex', 'mal', 'Totals:']), axis=1), np.vstack((num_chars_data.astype(np.int64),\n               np.asarray(['Nodules', nodules_to_use, 'Benign', non_mal_count, 'Malig', mal_count])))), axis=1),\n               fmt='%s,%s,%s,%s,%s,%s,%s', delimiter=',', header=\"Characteristics,1,2,3,4,5,6\")\n\n    np.savetxt(os.path.join(OUT_ROOT, 'master_nodule_list.csv'), np.asarray(matches),\n               fmt='%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s')\n\n\ndef correct_images(sname):\n    # This function contains a list of images which previously required manual correction within the LIDC-IDRI Dataset.\n\n    # Manually correct for image 0017\n    if sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.305973183883758685859912046949':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.139636132253744151113715840194'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.975363198401611311891539311888':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.225900589792147134785051710110'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.153194632177600377201998652445':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.222098252047357192090439228841'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.329142402178255247031380957411':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.276070543618203204841799986172'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.109012962923033337571132618784':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.201369290021439277502674762620'\n    # Manually correct for image 0365\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.112512486762301518180007539984':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.249086187399161659167414756279'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.448378396789516014605561762604':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.216758182207805904911618558070'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.303256875597167746646589593562':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.180833422259316497536094826188'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.261962165647171557143883123825':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.680655051010882131364380217685'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.428441304577336024295581627835':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.282568083479753958511921318301'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.329221218419947342986803210392':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.130147884776737463511106208477'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.162079731049618854270820976684':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.317603920309971419052997711476'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.785736194417664146622972784664':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.180833422259316497536094826188'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.652444697985639935050732394135':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.247436296095192529771061686046'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.126539353916279887972936951408':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.119827225411893011639439591713'\n    # Manually correct for image 0566\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.514074599988412913277488312051':\n        sname = '-2'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.292826962115570345472638642623':\n        sname = '-2'\n    # Manually correct for image 0659\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.294658615382614203741435957661':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.248517083496561594434577071132'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.883951945165118277793500546792':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.218208995904859324781331654067'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.227260896757583835259462034815':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.183101167412396355129144409796'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.739565975013005403715405771404':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.276779570196705787348278946110'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.244522908325555679363936146772':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.576955311322527292170312066972'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.125776849447531170933991444187':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.944721105102210115761068591710'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.156959022761131412720241221222':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.685786061228252640465903515314'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.157441085111648851876365968475':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.218208995904859324781331654067'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.137224073243631437732289379681':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.327828856516446064398338817575'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.196786590005502760794118627532':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.205919555392658132555723231924'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.271749899549008749493412118500':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.467531607505823612652093494995'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.132283326090716626749170288137':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.715346929996135559455398127585'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.292014563425807316410737237443':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.251646556878192917000905983161'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.281350813740489812658551562167':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.188830155395223944149966050821'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.316094521169588935447289217773':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.318926701435673382024116339995'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.400249926333575297612413406645':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.247894320876850135016381965868'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.381007938661788498734279329156':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.263902120137234774391883090194'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.158922411981395099005780254611':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.266102462639631998797024975317'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.153968349496782778041856013116':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.313130758239406881022967921981'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.199135326994407563129497784698':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.137821430143892810553323149499'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.328454607276840155088910752459':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.277464141419855638903368659937'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.105901452377957975094355467039':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.270022323575518362032565947858'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.230181645068532680519497368825':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.101175636735586811268012081787'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.173090595736867429956574661962':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.311147794796034131535570099457'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.426419361480558838333009902353':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.283215380710563114133061955920'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.149783315493297937843600113966':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.211773626788832944113459632641'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.333349896902589057387703875126':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.324942356299228484760469569592'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.259329619426001073359049716159':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.218894908479906137103265765511'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.204211053191501804382709873157':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.219041363289039597488091781264'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.365700870941618176907116849738':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.269625131313796127254468189745'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.174649660921460497526396207837':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.499186182774918820678569631767'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.628619440608225619886544814747':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.288908400826505634061200144991'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.165071066866482679435986323504':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.138555834428706707378735123427'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.932783428097248153076463331304':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.403741639352083297611557443868'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.232252382783080336041314614357':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.242386520761336203399531222995'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.304249587531812156369799852687':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.233668843426769210066014174740'\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.547584917033319141420515123587':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.502898181085822091725452394574'\n    # Manually correct for image 0931\n    elif sname == '1.3.6.1.4.1.14519.5.2.1.6279.6001.265313295605480688537936547605':\n        sname = '1.3.6.1.4.1.14519.5.2.1.6279.6001.290994721708875046196354781651'\n    else:\n        sname = '-1'\n    return sname"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_283","text":"import math\nimport numpy as np\nimport pylab as py\nfrom astropy.table import Table\nfrom astropy.io import fits\nimport pickle, glob\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\nimport os\nfrom scipy import interpolate\nimport kai\n\ndef setup_phot(imageRoot, silent=False,\n               apertures=[25,50,75,100,125,150,175,200],\n               sky_annulus=200, sky_dannulus=50, zmag=0):\n\n    from pyraf import iraf as ir\n    \n    # Load image header\n    hdr = fits.getheader(imageRoot + '.fits')\n\n    ir.digiphot()\n    ir.daophot()\n    ir.unlearn('phot')\n    ir.unlearn('datapars')\n    ir.unlearn('centerpars')\n    ir.unlearn('fitskypars')\n    ir.unlearn('photpars')\n\n    ##########\n    # Set up datapars\n    ##########\n    ir.datapars.fwhmpsf = 5.0 # shouldn't really matter\n    ir.datapars.sigma = 'INDEF'\n    ir.datapars.datamin = 'INDEF'\n\n    if os.path.exists(imageRoot + '.max'):\n        max_file = open(imageRoot + '.max', 'r')\n        max_line = max_file.readline()\n        max = float(max_line)\n        ir.datapars.datamax = max\n\n        if not silent:\n            print( 'Set ir.datapars.datamax = %d' % max)\n\n    # Pull gain from the header\n    ir.datapars.gain = 'GAIN'\n    ir.datapars.epadu = 'INDEF'\n\n    # Assumes 43.1 electrons per read of noise\n    nreads = 1.0\n    if int(hdr['SAMPMODE']) == 3:\n        nreads = int(hdr['MULTISAM'])\n    \n    ir.datapars.ccdread = ''\n    ir.datapars.readnoise = 43.1 * math.sqrt(2.0) \/ math.sqrt(nreads)\n\n    # Get exposure times from header\n    ir.datapars.exposure = ''\n    ir.datapars.itime = float(hdr['ITIME']) * int(hdr['COADDS'])\n\n    # Other Header keywords\n    ir.datapars.airmass = 'AIRMASS'\n    ir.datapars.filter = 'FWINAME'\n    ir.datapars.obstime = 'EXPSTART'\n\n    \n    ##########\n    # Setup centerpars. We will use *.coo file for initial guess.\n    ##########\n    ir.centerpars.calgorithm = 'centroid'\n\n    ##########\n    # Setup fitskypars\n    ##########\n    ir.fitskypars.salgorithm = 'centroid'\n    ir.fitskypars.annulus = sky_annulus\n    ir.fitskypars.dannulus = sky_dannulus\n\n    ##########\n    # Setup photpars\n    ##########\n    # Setup a zeropoint... this assumes Strehl = 1, but good enough for now.\n    ir.photpars.zmag = zmag\n    ir.photpars.apertures = ','.join([str(aa) for aa in apertures])\n    \n    ##########\n    # Setup phot\n    ##########\n    ir.phot.interactive = 'no'\n    ir.phot.radplots = 'no'\n    ir.phot.verify = 'No'\n\n    if silent:\n        ir.phot.verbose = 'no'\n    else:\n        ir.phot.verbose = 'yes'\n\ndef run_phot(imageRoot, silent=False,\n             apertures=[25,50,75,100,125,150,175,200],\n             sky_annulus=200, sky_dannulus=50, zmag=0):\n\n    from pyraf import iraf as ir\n    \n    setup_phot(imageRoot, apertures=apertures, zmag=zmag, silent=silent,\n               sky_annulus=sky_annulus, sky_dannulus=sky_dannulus)\n\n    image = imageRoot + '.fits'\n    coords = imageRoot + '.coo'\n\n    # Output into current directory, not data directory\n    rootSplit = imageRoot.split('\/')\n    output = rootSplit[-1] + '.phot.mag'\n\n    ir.phot(image, coords, output)\n\n    (radius, flux, mag, merr) = get_phot_output(output, silent=silent)\n\n    return (radius, flux, mag, merr)\n\ndef get_phot_output(output, silent=False):\n    from pyraf import iraf as ir\n    \n    # Now get the results using txdump\n    radStr = ir.txdump(output, 'RAPERT', 'yes', Stdout=1)\n    fluxStr = ir.txdump(output, 'FLUX', 'yes', Stdout=1)\n    magStr = ir.txdump(output, 'MAG', 'yes', Stdout=1)\n    merrStr = ir.txdump(output, 'MERR', 'yes', Stdout=1)\n    pierStr = ir.txdump(output, 'PIER', 'yes', Stdout=1)\n\n    radFields = radStr[0].split()\n    fluxFields = fluxStr[0].split()\n    magFields = magStr[0].split()\n    merrFields = merrStr[0].split()\n    pierFields = pierStr[0].split()\n\n    count = len(radFields)\n\n    radius = np.zeros(count, dtype=float)\n    flux = np.zeros(count, dtype=float)\n    mag = np.zeros(count, dtype=float)\n    merr = np.zeros(count, dtype=float)\n\n    for rr in range(count):\n        radius[rr] = float(radFields[rr])\n\n        if (int(pierFields[rr]) != 0 or magFields[rr] == 'INDEF' or\n            merrFields[rr] == 'INDEF'):\n            print( 'Problem in image: ' + output)\n\n            # Error\n            flux[rr] = 0\n            mag[rr] = 0\n            merr[rr] = 0\n        else:\n            flux[rr] = float(fluxFields[rr])\n            mag[rr] = float(magFields[rr])\n            merr[rr] = float(merrFields[rr])\n\n    if not silent:\n        print( '%6s  %10s  %6s  %6s' % ('Radius', 'Flux', 'Mag', 'MagErr'))\n        for ii in range(count):\n            print( '%8.1f  %10d  %6.3f  %6.3f' % \\\n                (radius[ii], flux[ii], mag[ii], merr[ii]))\n    \n    return (radius, flux, mag, merr)\n\ndef get_filter_profile(filter):\n    \"\"\"\n    Returns the wavelength (in microns) and the transmission for \n    the specified NIRC2 filter.\n\n    Example: \n    (wave, trans) = kai.photometry.get_filter_profile('Kp')\n    py.clf()\n    py.plot(wave, trans)\n    py.xlabel('Wavelength (microns)')\n    py.ylabel('Transmission')\n    \"\"\"\n    base_path = os.path.dirname(kai.__file__)\n    rootDir = base_path + '\/filters\/'\n\n    filters = ['J', 'H', 'K', 'Kcont', 'Kp', 'Ks', 'Lp', 'Ms',\n               'Hcont', 'Brgamma', 'FeII']\n\n    if filter not in filters:\n        print( 'Could not find profile for filter %s.' % filter)\n        print( 'Choices are: ', filters)\n        return\n\n    table = Table.read(rootDir + filter + '.dat', format='ascii')\n\n    wavelength = table[table.colnames[0]]\n    transmission = table[table.colnames[1]]\n\n    # Lets fix wavelength array for duplicate values\n    diff = np.diff(wavelength)\n    idx = np.where(diff <= 0)[0]\n    wavelength[idx+1] += 1.0e-7\n\n    # Get rid of all entries with negative transmission\n    idx = np.where(transmission > 1)[0]\n    wavelength = wavelength[idx]\n    transmission = transmission[idx] \/ 100.0 # convert from % to ratio\n\n    return (wavelength, transmission)\n\ndef test_filter_profile_interp():\n    \"\"\"\n    Plot up the filter transmission curves and their interpolations\n    for the three K-band filters (K, Kp, Ks).\n    \"\"\"\n    # Get the transmission curve for NIRC2 filters and atmosphere.\n    K_wave, K_trans = get_filter_profile('K')\n    Kp_wave, Kp_trans = get_filter_profile('Kp')\n    Ks_wave, Ks_trans = get_filter_profile('Ks')\n    J_wave, J_trans = get_filter_profile('J')\n    H_wave, H_trans = get_filter_profile('H')\n    Lp_wave, Lp_trans = get_filter_profile('Lp')\n\n    # We will need to resample these transmission curves.\n    print( 'Creating interp object')\n    K_interp = interpolate.splrep(K_wave, K_trans, k=1, s=0)\n    Kp_interp = interpolate.splrep(Kp_wave, Kp_trans, k=1, s=0)\n    Ks_interp = interpolate.splrep(Ks_wave, Ks_trans, k=1, s=0)\n    J_interp = interpolate.splrep(J_wave, J_trans, k=1, s=0)\n    H_interp = interpolate.splrep(H_wave, H_trans, k=1, s=0)\n    Lp_interp = interpolate.splrep(Lp_wave, Lp_trans, k=1, s=0)\n\n    K_wave_new = np.arange(K_wave.min(), K_wave.max(), 0.0005)\n    Kp_wave_new = np.arange(Kp_wave.min(), Kp_wave.max(), 0.0005)\n    Ks_wave_new = np.arange(Ks_wave.min(), Ks_wave.max(), 0.0005)\n    J_wave_new = np.arange(J_wave.min(), J_wave.max(), 0.0005)\n    H_wave_new = np.arange(H_wave.min(), H_wave.max(), 0.0005)\n    Lp_wave_new = np.arange(Lp_wave.min(), Lp_wave.max(), 0.0005)\n\n    print( 'Interpolating')\n    K_trans_new = interpolate.splev(K_wave_new, K_interp)\n    Kp_trans_new = interpolate.splev(Kp_wave_new, Kp_interp)\n    Ks_trans_new = interpolate.splev(Ks_wave_new, Ks_interp)\n    J_trans_new = interpolate.splev(J_wave_new, J_interp)\n    H_trans_new = interpolate.splev(H_wave_new, H_interp)\n    Lp_trans_new = interpolate.splev(Lp_wave_new, Lp_interp)\n\n    print( 'Plotting')\n#     py.figure(2, figsize=(4,4))\n#     py.subplots_adjust(left=0.2, bottom=0.14, top=0.95, right=0.94)\n    py.clf()\n    py.plot(K_wave, K_trans, 'bo', ms=4, label='_nolegend_', mec='blue')\n    py.plot(K_wave_new, K_trans_new, 'b-', label='K', linewidth=2)\n\n    py.plot(Kp_wave, Kp_trans, 'ro', ms=4, label='_nolegend_', mec='red')\n    py.plot(Kp_wave_new, Kp_trans_new, 'r-', label='Kp', linewidth=2)\n\n    py.plot(Ks_wave, Ks_trans, 'go', ms=4, label='_nolegend_', mec='green')\n    py.plot(Ks_wave_new, Ks_trans_new, 'g-', label='Ks', linewidth=2)\n\n    py.plot(J_wave, J_trans, 'go', ms=4, label='_nolegend_', mec='green')\n    py.plot(J_wave_new, J_trans_new, 'g-', label='J', linewidth=2)\n\n    py.plot(H_wave, H_trans, 'go', ms=4, label='_nolegend_', mec='green')\n    py.plot(H_wave_new, H_trans_new, 'g-', label='H', linewidth=2)\n\n    py.plot(Lp_wave, Lp_trans, 'go', ms=4, label='_nolegend_', mec='green')\n    py.plot(Lp_wave_new, Lp_trans_new, 'g-', label='Lp', linewidth=2)\n    \n    py.legend(loc='lower right', numpoints=1, markerscale=0.1)\n    py.xlabel('Wavelength (microns)')\n    py.ylabel('Transmission (%)')\n\n#     py.axis([2.110, 2.120, 0.928, 0.945])\n\ndef test_atmosphere_profile_interp():\n    atmDir = '\/u\/jlu\/data\/w51\/09jun26\/weather\/atmosphere_transmission.dat'\n    atmData = Table.read(atmDir, format='ascii')\n    atm_wave = atmData[atmData.colnames[0]]\n    atm_trans = atmData[atmData.colnames[1]]\n\n    atm_interp = interpolate.splrep(atm_wave, atm_trans, k=1, s=1)\n\n    atm_wave_new = np.arange(2.0, 2.4, 0.0005)\n    atm_trans_new = interpolate.splev(atm_wave_new, atm_interp)\n\n    py.clf()\n    py.plot(atm_wave, atm_trans, 'r.', ms=2)\n    py.plot(atm_wave_new, atm_trans_new, 'b-')\n    py.xlabel('Wavelength (microns)')\n    py.ylabel('Transmission (%)')\n    py.xlim(2, 2.4)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_284","text":"from pathlib import Path\nfrom random import choice\nfrom statistics import mean\nfrom typing import Any, Counter\n\nimport typer\nfrom click import Choice as click_Choice\nfrom tqdm import tqdm  # type: ignore\nfrom typer import echo as typer_echo\nfrom typer import prompt as typer_prompt\nfrom typer import secho as typer_secho\nfrom typer import style as typer_style\n\nfrom wordle_solver.solver import (\n    calculate_entropies,\n    get_initial_hints_dict,\n    map_all_hints,\n)\nfrom wordle_solver.utils import DEFAULT_WORDLIST_PATH, calculate_hints, load_word_list\n\napp = typer.Typer(add_completion=False)  # pragma: no cover\nstate: dict[Any, Any] = {}  # pragma: no cover\n\n\ndef get_hint_feedback(chosen_word: str) -> tuple[int, ...]:  # pragma: no cover\n    while True:\n        typer_echo(\"b = black (grey) \/ y = yellow \/ g = green\")\n\n        hint_input = typer_prompt(\n            \"Please provide the result for '\"\n            + typer_style(chosen_word, fg=\"bright_magenta\")\n            + \"'\"\n        )\n\n        if not all(char in set(\"byg\") for char in hint_input):\n            typer_secho(\n                \"Invalid input. Please only use the characters 'b', 'y', or 'g'\",\n                fg=\"red\",\n            )\n            typer_echo(\"Try again...\")\n            continue\n\n        if len(hint_input) != 5:\n            typer_secho(\"Invalid input. Input must be 5 characters long.\", fg=\"red\")\n            typer_echo(\"Try again...\")\n            continue\n\n        break\n\n    input_to_output: dict[str, int] = {\"g\": 2, \"y\": 1, \"b\": 0}\n\n    return tuple(input_to_output[input_char] for input_char in hint_input)\n\n\n@app.command()  # pragma: no cover\ndef stats(\n    word_list: Path = typer.Option(\n        DEFAULT_WORDLIST_PATH,\n        \"--word-list\",\n        \"-w\",\n        help=\"The directory location containing the word list files.\",\n    ),\n) -> None:\n    _, all_guesses, all_solutions = load_word_list(word_list)\n    initial_hint_dict = get_initial_hints_dict(all_guesses, all_solutions)\n\n    temp_entropies = calculate_entropies(all_guesses, all_solutions, initial_hint_dict)\n    top_initial_guesses: list[str] = list(temp_entropies.keys())[0:10]\n\n    for initial_guess in top_initial_guesses:\n        guesses_to_solved: list[int] = []\n\n        for secret in tqdm(all_solutions):\n            solved = False\n            iteration_count = 1\n\n            # The first guess is the most computational, so try to keep it fast\n            hint = calculate_hints(initial_guess, secret)\n            local_solutions = list(initial_hint_dict[initial_guess][hint])\n            local_hint_dict = map_all_hints(all_guesses, local_solutions)\n\n            while not solved:\n                iteration_count += 1\n                total_remaining_solutions = len(local_solutions)\n\n                if total_remaining_solutions == 1:\n                    chosen_guess = local_solutions[0]\n                elif total_remaining_solutions == 2:\n                    chosen_guess = choice(local_solutions)\n                else:\n                    entropies = calculate_entropies(\n                        all_guesses, local_solutions, local_hint_dict\n                    )\n                    chosen_guess = list(entropies.keys())[0]\n\n                # typer_echo(f\"{chosen_guess=}\")\n                hint = calculate_hints(chosen_guess, secret)\n                if hint == (2, 2, 2, 2, 2):\n                    solved = True\n                    guesses_to_solved.append(iteration_count)\n                    break\n\n                local_solutions = list(local_hint_dict[chosen_guess][hint])\n                local_hint_dict = map_all_hints(all_guesses, local_solutions)\n\n        typer_echo(f\"Using guess: {initial_guess}\")\n        typer_echo(f\"Total words solved: {len(guesses_to_solved)}\")\n        typer_echo(f\"Average guess: {round(mean(guesses_to_solved), 3)}\")\n        typer_echo(f\"Total counts: {Counter(guesses_to_solved)}\")\n\n\n@app.command()  # pragma: no cover\ndef solver(\n    word_list: Path = typer.Option(\n        DEFAULT_WORDLIST_PATH,\n        \"--word-list\",\n        \"-w\",\n        help=\"The directory location containing the word list files.\",\n    ),\n) -> None:\n    \"\"\"Solve a word on Wordle.\"\"\"\n    _, guesses, solutions = load_word_list(word_list)\n    hint_dict = get_initial_hints_dict(guesses, solutions)\n\n    for _ in range(6):\n        total_remaining_solutions = len(solutions)\n        if total_remaining_solutions == 0:\n            # TODO: Error out?\n            pass\n        elif total_remaining_solutions == 1:\n            typer_echo(\"There is only 1 reamining possible answer:\")\n            typer_echo(typer_style(solutions, bg=\"magenta\"))\n\n            chosen_guess = solutions[0]\n        elif total_remaining_solutions == 2:\n            typer_echo(\"There are 2 remaining possible answers:\")\n            typer_echo(typer_style(solutions, bg=\"magenta\"))\n\n            chosen_guess = typer_prompt(\n                \"Please select a guess word:\",\n                type=click_Choice(solutions),\n            )\n        else:\n            entropies = calculate_entropies(guesses, solutions, hint_dict)\n            top_8_entropies = dict(list(entropies.items())[0:8])\n\n            typer_echo(\n                f\"There are {total_remaining_solutions} remaining possible answers.\"\n            )\n            if total_remaining_solutions < 8:\n                typer_echo(typer_style(solutions, bg=\"magenta\"))\n\n            typer_echo(\"The top 8 guesses are:\")\n            typer_echo(typer_style(top_8_entropies, bg=\"blue\"))\n\n            chosen_guess = typer_prompt(\n                \"Please select a guess word:\",\n                type=click_Choice(list(top_8_entropies.keys())),\n            )\n\n        hint_feedback = get_hint_feedback(chosen_guess)\n        if hint_feedback == (2, 2, 2, 2, 2):\n            typer_secho(\"Victory!\", fg=\"bright_green\")\n            return\n\n        solutions = list(hint_dict[chosen_guess][hint_feedback])\n        hint_dict = map_all_hints(guesses, solutions)\n\n\n@app.callback()  # pragma: no cover\ndef main() -> None:\n    # \"\"\"\n    # Manage users in the awesome CLI app.\n    # \"\"\"\n    pass\n\n\nif __name__ == \"__main__\":\n    app()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_285","text":"<gh_stars>0\n# -*- coding: utf-8 -*-\n\"\"\"Approval-based committee (ABC) voting rules\"\"\"\n\n\nfrom __future__ import print_function\nimport sys\nimport functools\nfrom itertools import combinations\ntry:\n    from gmpy2 import mpq as Fraction\nexcept ImportError:\n    print(\"Warning: module gmpy2 not found, \"\n          + \"resorting to Python's fractions.Fraction\")\n    from fractions import Fraction\nfrom abcvoting import abcrules_gurobi\nfrom abcvoting.misc import sort_committees\nfrom abcvoting.misc import hamming\nfrom abcvoting.misc import enough_approved_candidates\nfrom abcvoting.misc import str_committees_header\nfrom abcvoting.misc import str_candset, str_candsets\nfrom abcvoting.misc import header\nfrom abcvoting import scores\n\n\n########################################################################\n\n\nclass UnknownRuleIDError(ValueError):\n    \"\"\"Exception raised if unknown rule id is used\"\"\"\n\n    def __init__(self, expression, message):\n        self.expression = expression\n        self.message = \"Rule ID \\\"\" + str(message) + \"\\\" is not known.\"\n\n\nclass ABCRule():\n    \"\"\"Class for ABC rules containing basic information and function call\"\"\"\n    def __init__(self, rule_id, shortname, longname, fct,\n                 algorithms=[\"standard\"], resolute=[True, False]):\n        self.rule_id = rule_id\n        self.shortname = shortname\n        self.longname = longname\n        self.fct = fct\n        self.algorithms = algorithms\n        # algorithms should be sorted by speed (fastest first)\n        self.resolute = resolute\n\n        assert len(resolute) > 0\n        assert len(algorithms) > 0\n\n    def compute(self, profile, committeesize, **kwargs):\n        return self.fct(profile, committeesize, **kwargs)\n\n    def fastest_algo(self):\n        for algo in self.algorithms:\n            if algo == \"gurobi\" and not abcrules_gurobi.available:\n                continue\n            return algo\n\n\n########################################################################\n\n\ndef compute(rule_id, profile, committeesize, **kwargs):\n    try:\n        return rules[rule_id].compute(profile, committeesize, **kwargs)\n    except KeyError:\n        raise NotImplementedError(\"ABC rule \" + str(rule_id) + \" not known.\")\n\n\n# computes arbitrary Thiele methods via branch-and-bound\ndef compute_thiele_method(scorefct_str, profile, committeesize,\n                          algorithm=\"branch-and-bound\",\n                          resolute=False, verbose=0):\n    \"\"\"Thiele methods\n\n    Compute winning committees of the Thiele method specified\n    by the score function (scorefct_str)\n    \"\"\"\n    enough_approved_candidates(profile, committeesize)\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    # optional output\n    if verbose:\n        print(header(rules[scorefct_str].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    if verbose >= 3:\n        if algorithm == \"gurobi\":\n            print(\"Using the Gurobi ILP solver\\n\")\n        if algorithm == \"branch-and-bound\":\n            print(\"Using a branch-and-bound algorithm\\n\")\n    # end of optional output\n\n    if algorithm == \"gurobi\":\n        committees = abcrules_gurobi.__gurobi_thiele_methods(\n            profile, committeesize, scorefct, resolute)\n\n        committees = sort_committees(committees)\n    elif algorithm == \"branch-and-bound\":\n        committees = __thiele_methods_branchandbound(\n            profile, committeesize, scorefct_str, resolute)\n    else:\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_thiele_method\")\n\n    # optional output\n    if verbose >= 2:\n        print(\"Optimal \" + scorefct_str.upper() + \"-score: \"\n              + str(scores.thiele_score(scorefct_str, profile, committees[0])))\n        print()\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\n# computes arbitrary Thiele methods via branch-and-bound\ndef __thiele_methods_branchandbound(profile, committeesize,\n                                    scorefct_str, resolute):\n    \"\"\"Branch-and-bound algorithm to compute winning committees\n    for Thiele methods\"\"\"\n    enough_approved_candidates(profile, committeesize)\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    best_committees = []\n    init_com = compute_seq_thiele_method(\n        profile, committeesize, scorefct_str, resolute=True)[0]\n    best_score = scores.thiele_score(scorefct_str, profile, init_com)\n    part_coms = [[]]\n    while part_coms:\n        part_com = part_coms.pop(0)\n        # potential committee, check if at least as good\n        # as previous best committee\n        if len(part_com) == committeesize:\n            score = scores.thiele_score(scorefct_str, profile, part_com)\n            if score == best_score:\n                best_committees.append(part_com)\n            elif score > best_score:\n                best_committees = [part_com]\n                best_score = score\n        else:\n            if len(part_com) > 0:\n                largest_cand = part_com[-1]\n            else:\n                largest_cand = -1\n            missing = committeesize - len(part_com)\n            marg_util_cand = scores.marginal_thiele_scores_add(\n                scorefct, profile, part_com)\n            upper_bound = (\n                sum(sorted(marg_util_cand[largest_cand + 1:])[-missing:])\n                + scores.thiele_score(scorefct_str, profile, part_com))\n            if upper_bound >= best_score:\n                for c in range(largest_cand + 1,\n                               profile.num_cand - missing + 1):\n                    part_coms.insert(0, part_com + [c])\n\n    committees = sort_committees(best_committees)\n    if resolute:\n        committees = [committees[0]]\n\n    return committees\n\n\n# Sequential PAV\ndef compute_seqpav(profile, committeesize, algorithm=\"standard\",\n                   resolute=True, verbose=0):\n    \"\"\"Sequential PAV (seq-PAV)\"\"\"\n    return compute_seq_thiele_method(\n        profile, committeesize, 'pav', algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\ndef compute_seqslav(profile, committeesize, algorithm=\"standard\",\n                    resolute=True, verbose=0):\n    \"\"\"Sequential Sainte-Lague Approval Voting (SLAV)\"\"\"\n    return compute_seq_thiele_method(\n        profile, committeesize, \"slav\", algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\n# Reverse Sequential PAV\ndef compute_revseqpav(profile, committeesize, algorithm=\"standard\",\n                      resolute=True, verbose=0):\n    \"\"\"Reverse sequential PAV (revseq-PAV)\"\"\"\n    return compute_revseq_thiele_method(\n        profile, committeesize, 'pav', algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\ndef compute_seqcc(profile, committeesize, algorithm=\"standard\",\n                  resolute=True, verbose=0):\n    \"\"\"Sequential Chamberlin-Courant (seq-CC)\"\"\"\n    return compute_seq_thiele_method(\n        profile, committeesize, 'cc', algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\ndef compute_sav(profile, committeesize, algorithm=\"standard\",\n                resolute=False, verbose=0):\n    \"\"\"Satisfaction Approval Voting (SAV)\"\"\"\n    if algorithm == \"standard\":\n        return __separable(\"sav\", profile, committeesize, resolute, verbose)\n    else:\n            raise NotImplementedError(\n                \"Algorithm \" + str(algorithm)\n                + \" not specified for compute_sav\")\n\n\n# Approval Voting (AV)\ndef compute_av(profile, committeesize, algorithm=\"standard\",\n               resolute=False, verbose=0):\n    \"\"\"Approval Voting\"\"\"\n    if algorithm == \"standard\":\n        return __separable(\"av\", profile, committeesize, resolute, verbose)\n    else:\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_av\")\n\n\ndef __separable(rule_id, profile, committeesize, resolute, verbose):\n    enough_approved_candidates(profile, committeesize)\n\n    appr_scores = [0] * profile.num_cand\n    for pref in profile:\n        for cand in pref:\n            if rule_id == \"sav\":\n                # Satisfaction Approval Voting\n                appr_scores[cand] += Fraction(pref.weight, len(pref))\n            elif rule_id == \"av\":\n                # (Classic) Approval Voting\n                appr_scores[cand] += pref.weight\n            else:\n                raise UnknownRuleIDError(rule_id)\n\n    # smallest score to be in the committee\n    cutoff = sorted(appr_scores)[-committeesize]\n\n    certain_cands = [c for c in range(profile.num_cand)\n                     if appr_scores[c] > cutoff]\n    possible_cands = [c for c in range(profile.num_cand)\n                      if appr_scores[c] == cutoff]\n    missing = committeesize - len(certain_cands)\n    if len(possible_cands) == missing:\n        # candidates with appr_scores[c] == cutoff\n        # are also certain candidates because all these candidates\n        # are required to fill the committee\n        certain_cands = sorted(certain_cands + possible_cands)\n        possible_cands = []\n        missing = 0\n\n    if resolute:\n        committees = sort_committees(\n            [(certain_cands + possible_cands[:missing])])\n    else:\n        committees = sort_committees(\n            [(certain_cands + list(selection))\n             for selection\n             in combinations(possible_cands, missing)])\n\n    # optional output\n    if verbose:\n        print(header(rules[rule_id].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    if verbose >= 2:\n        print(\"Scores of candidates:\")\n        for c in range(profile.num_cand):\n            print(profile.names[c] + \": \" + str(appr_scores[c]))\n\n        print(\"\\nCandidates are contained in winning committees\")\n        print(\"if their score is >= \" + str(cutoff) + \".\")\n\n        if len(certain_cands) > 0:\n            print(\"\\nThe following candidates are contained in\")\n            print(\"every winning committee:\")\n            namedset = [profile.names[c] for c in certain_cands]\n            print(\" \" + \", \".join(map(str, namedset)))\n            print()\n\n        if len(possible_cands) > 0:\n            print(\"The following candidates are contained in\")\n            print(\"some of the winning committees:\")\n            namedset = [profile.names[c] for c in possible_cands]\n            print(\" \" + \", \".join(map(str, namedset)))\n            print(\"(\" + str(missing) + \" of those candidates is contained\\n\"\n                  + \" in every winning committee.)\\n\")\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\ndef __seq_thiele_resolute(profile, committeesize, scorefct_str, verbose):\n    \"\"\"Compute a *resolute* reverse sequential Thiele method\n\n    Tiebreaking between candidates in favor of candidate with smaller\n    number\/index (candidates with larger numbers get deleted first).\n    \"\"\"\n    committee = []\n\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    # optional output\n    if verbose >= 2:\n        output = \"starting with the empty committee (score = \"\n        output += str(scores.thiele_score(\n            scorefct_str, profile, committee)) + \")\"\n        print(output + \"\\n\")\n    # end of optional output\n\n    # build a committee starting with the empty set\n    for _ in range(committeesize):\n        additional_score_cand = scores.marginal_thiele_scores_add(\n            scorefct, profile, committee)\n        next_cand = additional_score_cand.index(max(additional_score_cand))\n        committee.append(next_cand)\n        # optional output\n        if verbose >= 2:\n            output = \"adding candidate number \"\n            output += str(len(committee)) + \": \"\n            output += profile.names[next_cand] + \"\\n\"\n            output += \" score increases by \"\n            output += str(max(additional_score_cand))\n            output += \" to a total of \"\n            output += str(scores.thiele_score(\n                scorefct_str, profile, committee))\n            tied_cands = [c for c in range(len(additional_score_cand))\n                          if (c > next_cand and\n                              (additional_score_cand[c]\n                               == max(additional_score_cand)))]\n            if len(tied_cands) > 0:\n                output += \" tie broken in favor of \" + str(next_cand)\n                output += \" candidates \" + str_candset(tied_cands)\n                output += \" would increase the score by the same amount (\"\n                output += str(max(additional_score_cand)) + \")\"\n            print(output + \"\\n\")\n        # end of optional output\n    return [sorted(committee)]\n\n\ndef __seq_thiele_irresolute(profile, committeesize, scorefct_str):\n    \"\"\"Compute an *irresolute* reverse sequential Thiele method\n\n    Consider all possible ways to break ties between candidates\n    (aka parallel universe tiebreaking)\n    \"\"\"\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    comm_scores = {(): 0}\n    # build committees starting with the empty set\n    for _ in range(committeesize):\n        comm_scores_next = {}\n        for committee, score in comm_scores.items():\n            # marginal utility gained by adding candidate to the committee\n            additional_score_cand = scores.marginal_thiele_scores_add(\n                scorefct, profile, committee)\n            for c in range(profile.num_cand):\n                if additional_score_cand[c] >= max(additional_score_cand):\n                    next_comm = tuple(sorted(committee + (c,)))\n                    comm_scores_next[next_comm] = (\n                        score + additional_score_cand[c])\n        comm_scores = comm_scores_next\n    return sort_committees(list(comm_scores.keys()))\n\n\ndef compute_seq_thiele_method(profile, committeesize, scorefct_str,\n                              algorithm=\"standard\", resolute=True, verbose=0):\n    \"\"\"Sequential Thiele methods\"\"\"\n\n    enough_approved_candidates(profile, committeesize)\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_seq_thiele_method\")\n\n    # optional output\n    if verbose:\n        print(header(rules[\"seq\" + scorefct_str].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    # end of optional output\n\n    if resolute:\n        committees = __seq_thiele_resolute(\n            profile, committeesize, scorefct_str, verbose=verbose)\n    else:\n        committees = __seq_thiele_irresolute(\n            profile, committeesize, scorefct_str)\n\n    # optional output\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n        if resolute or len(committees) == 1:\n            print(scorefct_str.upper() + \"-score of winning committee:\",\n                  end=\"\")\n        else:\n            print(scorefct_str.upper() + \"-score of winning committees:\")\n        for comm in committees:\n            print(\" \" + str(scores.thiele_score(scorefct_str, profile, comm)))\n        print()\n    # end of optional output\n\n    return committees\n\n\ndef __revseq_thiele_irresolute(profile, committeesize, scorefct_str):\n    \"\"\"Compute an *irresolute* sequential Thiele method\n\n    Consider all possible ways to break ties between candidates\n    (aka parallel universe tiebreaking)\n    \"\"\"\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    allcandcomm = tuple(range(profile.num_cand))\n    comm_scores = {allcandcomm: scores.thiele_score(\n        scorefct_str, profile, allcandcomm)}\n\n    for _ in range(profile.num_cand - committeesize):\n        comm_scores_next = {}\n        for committee, score in comm_scores.items():\n            marg_util_cand = scores.marginal_thiele_scores_remove(\n                scorefct, profile, committee)\n            score_reduction = min(marg_util_cand)\n            # find smallest elements in marg_util_cand and return indices\n            cands_to_remove = [cand for cand in range(profile.num_cand)\n                               if marg_util_cand[cand] == min(marg_util_cand)]\n            for c in cands_to_remove:\n                next_comm = tuple(set(committee) - set([c]))\n                comm_scores_next[next_comm] = score - score_reduction\n            comm_scores = comm_scores_next\n    return sort_committees(list(comm_scores.keys()))\n\n\ndef __revseq_thiele_resolute(profile, committeesize, scorefct_str, verbose):\n    \"\"\"Compute a *resolute* reverse sequential Thiele method\n\n    Tiebreaking between candidates in favor of candidate with smaller\n    number\/index (candidates with smaller numbers are added first).\n    \"\"\"\n    scorefct = scores.get_scorefct(scorefct_str, committeesize)\n\n    committee = set(range(profile.num_cand))\n\n    # optional output\n    if verbose >= 2:\n        output = \"full committee (\" + str(len(committee))\n        output += \" candidates) has a total score of \"\n        output += str(scores.thiele_score(\n            scorefct_str, profile, committee))\n        print(output + \"\\n\")\n    # end of optional output\n\n    for _ in range(profile.num_cand - committeesize):\n        marg_util_cand = scores.marginal_thiele_scores_remove(\n            scorefct, profile, committee)\n        score_reduction = min(marg_util_cand)\n        # find smallest elements in marg_util_cand and return indices\n        cands_to_remove = [cand for cand in range(profile.num_cand)\n                           if marg_util_cand[cand] == min(marg_util_cand)]\n        committee.remove(cands_to_remove[-1])\n\n        # optional output\n        if verbose >= 2:\n            rem_cand = cands_to_remove[-1]\n            output = \"removing candidate number \"\n            output += str(profile.num_cand - len(committee)) + \": \"\n            output += profile.names[rem_cand] + \"\\n\"\n            output += \" score decreases by \"\n            output += str(score_reduction)\n            output += \" to a total of \"\n            output += str(scores.thiele_score(\n                scorefct_str, profile, committee))\n            if len(cands_to_remove) > 1:\n                output += \" (tie between candidates \"\n                output += str_candset(cands_to_remove) + \")\\n\"\n            print(output + \"\\n\")\n        # end of optional output\n\n    return [sorted(list(committee))]\n\n\ndef compute_revseq_thiele_method(profile, committeesize,\n                                 scorefct_str, algorithm=\"standard\",\n                                 resolute=True, verbose=0):\n    \"\"\"Reverse sequential Thiele methods\"\"\"\n    enough_approved_candidates(profile, committeesize)\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_revseq_thiele_method\")\n\n    # optional output\n    if verbose:\n        print(header(rules[\"revseq\" + scorefct_str].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    # end of optional output\n\n    if resolute:\n        committees = __revseq_thiele_resolute(\n            profile, committeesize, scorefct_str, verbose=verbose)\n    else:\n        committees = __revseq_thiele_irresolute(\n            profile, committeesize, scorefct_str)\n\n    # optional output\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    if verbose >= 2:\n        if resolute or len(committees) == 1:\n            print(\"PAV-score of winning committee:\", end=\"\")\n        else:\n            print(\"PAV-score of winning committees:\")\n        for comm in committees:\n            print(\" \" + str(scores.thiele_score(scorefct_str, profile, comm)))\n        print()\n    # end of optional output\n\n    return committees\n\n\ndef __minimaxav_bruteforce(profile, committeesize):\n    \"\"\"Brute-force algorithm for computing Minimax AV (MAV)\"\"\"\n    opt_committees = []\n    opt_mavscore = profile.num_cand + 1\n    for comm in combinations(list(range(profile.num_cand)), committeesize):\n        score = scores.mavscore(profile, comm)\n        if score < opt_mavscore:\n            opt_committees = [comm]\n            opt_mavscore = score\n        elif scores.mavscore(profile, comm) == opt_mavscore:\n            opt_committees.append(comm)\n\n    committees = sort_committees(opt_committees)\n\n    return committees\n\n\n# Minimax Approval Voting\ndef compute_mav(profile, committeesize, algorithm=\"brute-force\",\n                resolute=False, verbose=0):\n    \"\"\"Minimax AV (MAV)\"\"\"\n    enough_approved_candidates(profile, committeesize)\n\n    # optional output\n    if verbose:\n        print(header(rules[\"mav\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    if verbose >= 3:\n        if algorithm == \"gurobi\":\n            print(\"Using the Gurobi ILP solver\\n\")\n        if algorithm == \"brute-force\":\n            print(\"Using a brute-force algorithm\\n\")\n    # end of optional output\n\n    if algorithm == \"gurobi\":\n        committees = abcrules_gurobi.__gurobi_minimaxav(\n            profile, committeesize, resolute)\n        committees = sort_committees(committees)\n    elif algorithm == \"brute-force\":\n        committees = __minimaxav_bruteforce(profile, committeesize)\n        if resolute:\n            committees = [committees[0]]\n    else:\n        raise NotImplementedError(\"Algorithm \" + str(algorithm)\n                                  + \" not specified for compute_mav\")\n\n    opt_mavscore = scores.mavscore(profile, committees[0])\n\n    # optional output\n    if verbose:\n        print(\"Minimum maximal distance: \" + str(opt_mavscore))\n\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n\n        print(\"Corresponding distances to voters:\")\n        for comm in committees:\n            print([hamming(pref, comm) for pref in profile])\n        print()\n    # end of optional output\n\n    return committees\n\n\n# Lexicographic Minimax Approval Voting\ndef compute_lexmav(profile, committeesize, algorithm=\"brute-force\",\n                   resolute=False, verbose=0):\n    \"\"\"Lexicographic Minimax AV\"\"\"\n    enough_approved_candidates(profile, committeesize)\n\n    if not profile.has_unit_weights():\n        raise ValueError(rules[\"lexmav\"].shortname +\n                         \" is only defined for unit weights (weight=1)\")\n\n    if algorithm != \"brute-force\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_lexmav\")\n\n    opt_committees = []\n    opt_distances = [profile.num_cand + 1] * len(profile)\n    for comm in combinations(list(range(profile.num_cand)), committeesize):\n        distances = sorted([hamming(pref, comm)\n                            for pref in profile],\n                           reverse=True)\n        for i in range(len(distances)):\n            if opt_distances[i] < distances[i]:\n                break\n            if opt_distances[i] > distances[i]:\n                opt_distances = distances\n                opt_committees = [comm]\n                break\n        else:\n            opt_committees.append(comm)\n\n    committees = sort_committees(opt_committees)\n    if resolute:\n        committees = [committees[0]]\n\n    # optional output\n    if verbose:\n        print(header(rules[\"lexmav\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n\n        print(\"Minimum maximal distance: \" + str(max(opt_distances)))\n\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n\n        print(\"Corresponding distances to voters:\")\n        for comm in committees:\n            print([hamming(pref, comm) for pref in profile])\n        print()\n    # end of optional output\n\n    return committees\n\n\n# Proportional Approval Voting\ndef compute_pav(profile, committeesize, algorithm=\"branch-and-bound\",\n                resolute=False, verbose=0):\n    \"\"\"Proportional Approval Voting (PAV)\"\"\"\n    return compute_thiele_method(\n        'pav', profile, committeesize, algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\n# Sainte-Lague Approval Voting\ndef compute_slav(profile, committeesize, algorithm=\"branch-and-bound\",\n                 resolute=False, verbose=0):\n    \"\"\"Sainte-Lague Approval Voting (SLAV)\"\"\"\n    return compute_thiele_method(\n        'slav', profile, committeesize, algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\n# Chamberlin-Courant\ndef compute_cc(profile, committeesize, algorithm=\"branch-and-bound\",\n               resolute=False, verbose=0):\n    \"\"\"Approval Chamberlin-Courant (CC)\"\"\"\n    return compute_thiele_method(\n        'cc', profile, committeesize, algorithm=algorithm,\n        resolute=resolute, verbose=verbose)\n\n\ndef compute_monroe(profile, committeesize, algorithm=\"brute-force\",\n                   resolute=False, verbose=0):\n    \"\"\"Monroe's rule\"\"\"\n    enough_approved_candidates(profile, committeesize)\n\n    # optional output\n    if verbose:\n        print(header(rules[\"monroe\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    if verbose >= 3:\n        if algorithm == \"gurobi\":\n            print(\"Using the Gurobi ILP solver\\n\")\n        if algorithm == \"brute-force\":\n            print(\"Using a brute-force algorithm\\n\")\n    # end of optional output\n\n    if not profile.has_unit_weights():\n        raise ValueError(rules[\"monroe\"].shortname +\n                         \" is only defined for unit weights (weight=1)\")\n\n    if algorithm == \"gurobi\":\n        committees = abcrules_gurobi.__gurobi_monroe(\n            profile, committeesize, resolute)\n        committees = sort_committees(committees)\n    elif algorithm == \"brute-force\":\n        committees = __monroe_bruteforce(\n            profile, committeesize, resolute)\n    else:\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_monroe\")\n\n    # optional output\n    if verbose:\n        print(\"Optimal Monroe score: \"\n              + str(scores.monroescore(profile, committees[0])) + \"\\n\")\n\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\n# Monroe's rule, computed via (brute-force) matching\ndef __monroe_bruteforce(profile, committeesize, resolute):\n    \"\"\"Brute-force computation of Monroe's rule\"\"\"\n    opt_committees = []\n    opt_monroescore = -1\n    for comm in combinations(list(range(profile.num_cand)), committeesize):\n        score = scores.monroescore(profile, comm)\n        if score > opt_monroescore:\n            opt_committees = [comm]\n            opt_monroescore = score\n        elif scores.monroescore(profile, comm) == opt_monroescore:\n            opt_committees.append(comm)\n\n    committees = sort_committees(opt_committees)\n    if resolute:\n        committees = [committees[0]]\n\n    return committees\n\n\ndef compute_greedy_monroe(profile, committeesize,\n                          algorithm=\"standard\", resolute=True, verbose=0):\n    \"\"\"\"Greedy Monroe\"\"\"\n    enough_approved_candidates(profile, committeesize)\n    if not profile.has_unit_weights():\n        raise ValueError(rules[\"greedy-monroe\"].shortname +\n                         \" is only defined for unit weights (weight=1)\")\n\n    if not resolute:\n        raise NotImplementedError(\n            \"compute_greedy_monroe does not support resolute=False.\")\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_greedy_monroe\")\n\n    num_voters = len(profile)\n    committee = []\n\n    # remaining voters\n    remaining_voters = list(range(num_voters))\n    remaining_cands = set(range(profile.num_cand))\n\n    assignment = []\n    for t in range(committeesize):\n        maxapprovals = -1\n        selected = None\n        for c in remaining_cands:\n            approvals = len([i for i in remaining_voters\n                             if c in profile[i]])\n            if approvals > maxapprovals:\n                maxapprovals = approvals\n                selected = c\n\n        # determine how many voters are removed (at most)\n        if t < num_voters - committeesize * (num_voters \/\/ committeesize):\n            num_remove = num_voters \/\/ committeesize + 1\n        else:\n            num_remove = num_voters \/\/ committeesize\n\n        # only voters that approve the chosen candidate\n        # are removed\n        to_remove = [i for i in remaining_voters\n                     if selected in profile[i]]\n        if len(to_remove) > num_remove:\n            to_remove = to_remove[:num_remove]\n        assignment.append((selected, to_remove))\n        remaining_voters = [i for i in remaining_voters\n                            if i not in to_remove]\n        committee.append(selected)\n        remaining_cands.remove(selected)\n\n    committees = sort_committees([committee])\n\n    # optional output\n    if verbose:\n        print(header(rules[\"greedy-monroe\"].longname))\n\n    if verbose >= 2:\n        score1 = scores.monroescore(profile, committees[0])\n\n        score2 = len(profile) - len(remaining_voters)\n        print(\"The Monroe assignment computed by <NAME>\")\n        print(\"has a Monroe score of \" + str(score2) + \".\")\n\n        if score1 > score2:\n            print(\"Monroe assignment found by Greedy Monroe is not \"\n                  + \"optimal for the winning committee,\")\n            print(\"i.e., by redistributing voters to candidates a higher \"\n                  + \"satisfaction is possible \"\n                  + \"(without changing the committee).\")\n            print(\"Optimal Monroe score of the winning committee is \"\n                  + str(score1) + \".\")\n\n        # build actual Monroe assignment for winning committee\n        for t, district in enumerate(assignment):\n            cand, voters = district\n            if t < num_voters - committeesize * (num_voters \/\/ committeesize):\n                missing = num_voters \/\/ committeesize + 1 - len(voters)\n            else:\n                missing = num_voters \/\/ committeesize - len(voters)\n            for _ in range(missing):\n                v = remaining_voters.pop()\n                voters.append(v)\n\n        print(\"Assignment (unsatisfatied voters marked with *):\\n\")\n        for cand, voters in assignment:\n            print(\" candidate \" + profile.names[cand]\n                  + \" assigned to: \", end=\"\")\n            output = \"\"\n            for v in sorted(voters):\n                output += str(v)\n                if cand not in profile[v].approved:\n                    output += \"*\"\n                output += \", \"\n            print(output[:-2])\n        print()\n\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\ndef __seqphragmen_resolute(profile, committeesize, verbose,\n                           start_load=None, partial_committee=None):\n    \"\"\"Algorithm for computing resolute seq-Phragmen  (1 winning committee)\"\"\"\n    approvers_weight = {}\n    for c in range(profile.num_cand):\n        approvers_weight[c] = sum(pref.weight for pref in profile if c in pref)\n\n    load = start_load\n    if load is None:\n        load = {v: 0 for v, _ in enumerate(profile)}\n\n    committee = partial_committee\n    if partial_committee is None:\n        committee = []  # build committees starting with the empty set\n\n    for _ in range(len(committee), committeesize):\n        approvers_load = {}\n        for c in range(profile.num_cand):\n            approvers_load[c] = sum(pref.weight * load[v]\n                                    for v, pref in enumerate(profile)\n                                    if c in pref)\n        new_maxload = [Fraction(approvers_load[c] + 1, approvers_weight[c])\n                       if approvers_weight[c] > 0 else committeesize + 1\n                       for c in range(profile.num_cand)]\n        # exclude committees already in the committee\n        large = max(new_maxload) + 1\n        for c in range(profile.num_cand):\n            if c in committee:\n                new_maxload[c] = large\n        # find smallest maxload\n        opt = min(new_maxload)\n        next_cand = new_maxload.index(opt)\n        # compute new loads and add new candidate\n        for v, pref in enumerate(profile):\n            if next_cand in pref:\n                load[v] = new_maxload[next_cand]\n            else:\n                load[v] = load[v]\n        committee = sorted(committee + [next_cand])\n\n        # optional output\n        if verbose >= 2:\n            output = \"adding candidate number \"\n            output += str(len(committee)) + \": \"\n            output += profile.names[next_cand] + \"\\n\"\n            output += \" maximum load increased to \"\n            output += str(opt)\n            print(output)\n            print(\" load distribution:\")\n            output = \"  (\"\n            for v, _ in enumerate(profile):\n                output += str(load[v]) + \", \"\n            print(output[:-2] + \")\")\n            tied_cands = [c for c in range(profile.num_cand)\n                          if (c > next_cand and\n                              (new_maxload[c] == new_maxload))]\n            if len(tied_cands) > 0:\n                output = \" tie broken in favor of \" + profile.names[next_cand]\n                output += \",\\n candidates \" + str_candset(tied_cands)\n                output += \" would increase the load to the same amount (\"\n                output += str(new_maxload) + \")\"\n                print(output)\n            print()\n        # end of optional output\n\n    comm_loads = {tuple(committee): load}\n    return [committee], comm_loads\n\n\ndef __seqphragmen_irresolute(profile, committeesize,\n                             start_load=None, partial_committee=None):\n    \"\"\"Algorithm for computing irresolute seq-Phragmen (>=1 winning committees)\n    \"\"\"\n    approvers_weight = {}\n    for c in range(profile.num_cand):\n        approvers_weight[c] = sum(pref.weight for pref in profile if c in pref)\n\n    load = start_load\n    if load is None:\n        load = {v: 0 for v, _ in enumerate(profile)}\n\n    if partial_committee is None:\n        partial_committee = []  # build committees starting with the empty set\n    comm_loads = {tuple(partial_committee): load}\n\n    for _ in range(len(partial_committee), committeesize):\n        comm_loads_next = {}\n        for committee, load in comm_loads.items():\n            approvers_load = {}\n            for c in range(profile.num_cand):\n                approvers_load[c] = sum(pref.weight * load[v]\n                                        for v, pref in enumerate(profile)\n                                        if c in pref)\n            new_maxload = [\n                Fraction(approvers_load[c] + 1, approvers_weight[c])\n                if approvers_weight[c] > 0 else committeesize + 1\n                for c in range(profile.num_cand)]\n            # exclude committees already in the committee\n            for c in range(profile.num_cand):\n                if c in committee:\n                    new_maxload[c] = sys.maxsize\n            # compute new loads\n            # and add new committees\n            for c in range(profile.num_cand):\n                if new_maxload[c] <= min(new_maxload):\n                    new_load = {}\n                    for v, pref in enumerate(profile):\n                        if c in pref:\n                            new_load[v] = new_maxload[c]\n                        else:\n                            new_load[v] = load[v]\n                    new_comm = tuple(sorted(committee + (c,)))\n                    comm_loads_next[new_comm] = new_load\n        comm_loads = comm_loads_next\n\n    committees = sort_committees(list(comm_loads.keys()))\n    return committees, comm_loads\n\n\ndef compute_seqphragmen(profile, committeesize, algorithm=\"standard\",\n                        resolute=True, verbose=False):\n    \"\"\"Phragmen's sequential rule (seq-Phragmen)\"\"\"\n    enough_approved_candidates(profile, committeesize)\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_seqphragmen\")\n\n    # optional output\n    if verbose:\n        print(header(rules[\"seqphrag\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    # end of optional output\n\n    if resolute:\n        committees, comm_loads = __seqphragmen_resolute(\n            profile, committeesize, verbose)\n    else:\n        committees, comm_loads = __seqphragmen_irresolute(\n            profile, committeesize)\n\n    # optional output\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    if verbose >= 2:\n        if resolute or len(committees) == 1:\n            print(\"corresponding load distribution:\")\n        else:\n            print(\"corresponding load distributions:\")\n        for comm in committees:\n            output = \"(\"\n            for v, _ in enumerate(profile):\n                output += str(comm_loads[tuple(comm)][v]) + \", \"\n            print(output[:-2] + \")\")\n    # end of optional output\n\n    return committees\n\n\ndef __rule_x_get_min_q(profile, budget, cand):\n    rich = set([v for v, pref in enumerate(profile)\n                if cand in pref])\n    poor = set()\n\n    while len(rich) > 0:\n        poor_budget = sum(budget[v] for v in poor)\n        q = Fraction(1 - poor_budget, len(rich))\n        new_poor = set([v for v in rich\n                        if budget[v] < q])\n        if len(new_poor) == 0:\n            return q\n        rich -= new_poor\n        poor.update(new_poor)\n\n    return None  # not sufficient budget available\n\n\ndef compute_rule_x(profile, committeesize, algorithm=\"standard\",\n                   resolute=True, verbose=0):\n    \"\"\"Rule X\n\n    See https:\/\/arxiv.org\/pdf\/1911.11747.pdf, page 7\n    \"\"\"\n    enough_approved_candidates(profile, committeesize)\n    if not profile.has_unit_weights():\n        raise ValueError(rules[\"rule-x\"].shortname +\n                         \" is only defined for unit weights (weight=1)\")\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_rule_x\")\n\n    # optional output\n    if verbose:\n        print(header(rules[\"rule-x\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    # end of optional output\n\n    start_budget = {v: Fraction(committeesize, len(profile))\n                    for v, _ in enumerate(profile)}\n    cands = range(profile.num_cand)\n    commbugdets = [(set(), start_budget)]\n    final_committees = set()\n\n    # optional output\n    if resolute and verbose >= 2:\n        print(\"Phase 1:\\n\")\n        print(\"starting budget:\")\n        output = \"  (\"\n        for v, _ in enumerate(profile):\n            output += str(start_budget[v]) + \", \"\n        print(output[:-2] + \")\\n\")\n    # end of optional output\n\n    for _ in range(committeesize):\n        next_commbudgets = []\n        for committee, budget in commbugdets:\n\n            curr_cands = set(cands) - committee\n            min_q = {}\n            for c in curr_cands:\n                q = __rule_x_get_min_q(profile, budget, c)\n                if q is not None:\n                    min_q[c] = q\n\n            if len(min_q) > 0:  # one or more candidates are affordable\n                next_cands = [c for c in min_q.keys()\n                              if min_q[c] == min(min_q.values())]\n                for next_cand in next_cands:\n                    new_budget = dict(budget)\n                    for v, pref in enumerate(profile):\n                        if next_cand in pref:\n                            new_budget[v] -= min(budget[v], min_q[next_cand])\n                    new_comm = set(committee)\n                    new_comm.add(next_cand)\n                    next_commbudgets.append((new_comm, new_budget))\n\n                    # optional output\n                    if resolute and verbose >= 2:\n                        output = \"adding candidate number \"\n                        output += str(len(committee)) + \": \"\n                        output += profile.names[next_cand] + \"\\n\"\n                        output += \" with maxmimum cost per voter q = \"\n                        output += str(min(min_q.values()))\n                        print(output)\n                        print(\" remaining budget:\")\n                        output = \"  (\"\n                        for v, _ in enumerate(profile):\n                            output += str(new_budget[v]) + \", \"\n                        print(output[:-2] + \")\")\n                        if len(next_cands) > 1:\n                            output = \" tie broken in favor of \"\n                            output += profile.names[next_cand] + \",\"\n                            output += \"\\n candidates \"\n                            output += str_candset(next_cands[1:])\n                            output += \" are tied\"\n                            print(output)\n                        print()\n                    # end of optional output\n\n                    if resolute:\n                        break\n\n            else:  # no affordable candidates remain\n                # fill committee via seq-Phragmen\n\n                # optional output\n                if resolute and verbose >= 2:\n                    print(\"Phase 2 (seq-Phragmén):\\n\")\n                # end of optional output\n\n                start_load = {}\n                # translate budget to loads\n                for v in range(len(profile)):\n                    start_load[v] = (Fraction(committeesize, len(profile))\n                                     - budget[v])\n\n                # optional output\n                if resolute and verbose >= 2:\n                    print(\"starting loads (= budget spent):\")\n                    output = \"  (\"\n                    for v, _ in enumerate(profile):\n                        output += str(start_load[v]) + \", \"\n                    print(output[:-2] + \")\\n\")\n                # end of optional output\n\n                if resolute:\n                    committees, _ = __seqphragmen_resolute(\n                        profile, committeesize, verbose=verbose,\n                        partial_committee=list(committee),\n                        start_load=start_load)\n                else:\n                    committees, _ = __seqphragmen_irresolute(\n                        profile, committeesize,\n                        partial_committee=list(committee),\n                        start_load=start_load)\n                final_committees.update([tuple(comm) for comm in committees])\n                # after filling the remaining spots these committees\n                # have size committeesize\n\n            commbugdets = next_commbudgets\n\n    final_committees.update([tuple(comm) for comm, _ in commbugdets])\n\n    committees = sort_committees(final_committees)\n    if resolute:\n        committees = committees[:1]\n\n    # optional output\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\ndef compute_optphragmen(profile, committeesize,\n                        algorithm=\"gurobi\", resolute=False, verbose=0):\n    enough_approved_candidates(profile, committeesize)\n\n    # optional output\n    if verbose:\n        print(header(rules[\"optphrag\"].longname))\n        if resolute:\n            print(\"Computing only one winning committee (resolute=True)\\n\")\n    if verbose >= 3:\n        if algorithm == \"gurobi\":\n            print(\"Using the Gurobi ILP solver\")\n    # end of optional output\n\n    if algorithm != \"gurobi\":\n        raise NotImplementedError(\"Algorithm \" + str(algorithm)\n                                  + \" not specified for compute_optphragmen\")\n\n    committees = abcrules_gurobi.__gurobi_optphragmen(\n        profile, committeesize, resolute=resolute, verbose=verbose)\n    committees = sort_committees(committees)\n\n    # optional output\n    if verbose:\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\ndef compute_phragmen_enestroem(profile, committeesize, algorithm=\"standard\",\n                               resolute=True, verbose=0):\n    \"\"\"\"Phragmen-Enestroem (aka Phragmen's first method, Enestroem's method)\n\n    In every round the candidate with the highest combined budget of\n    their supporters is put in the committee.\n    Method described in:\n    https:\/\/arxiv.org\/pdf\/1611.08826.pdf (Section 18.5, Page 59)\n    \"\"\"\n    enough_approved_candidates(profile, committeesize)\n    if not profile.has_unit_weights():\n        raise ValueError(rules[\"phrag-enestr\"].shortname +\n                         \" is only defined for unit weights (weight=1)\")\n\n    if algorithm != \"standard\":\n        raise NotImplementedError(\n            \"Algorithm \" + str(algorithm)\n            + \" not specified for compute_phragmen_enestroem\")\n\n    num_voters = len(profile)\n\n    start_budget = {i: Fraction(profile[i].weight)\n                    for i in range(num_voters)}\n    price = Fraction(sum(start_budget.values()), committeesize)\n\n    cands = range(profile.num_cand)\n\n    committees = [(start_budget, set())]\n    for _ in range(committeesize):\n        # here the committees with i+1 candidates are\n        # stored (together with budget)\n        next_committees = []\n        # loop in case multiple possible committees\n        # with i filled candidates\n        for committee in committees:\n            budget, comm = committee\n            curr_cands = set(cands) - comm\n            support = {c: 0 for c in curr_cands}\n            for nr, pref in enumerate(profile):\n                voting_power = budget[nr]\n                if voting_power <= 0:\n                    continue\n                for cand in pref:\n                    if cand in curr_cands:\n                        support[cand] += voting_power\n            max_support = max(support.values())\n            winners = [c for c, s in support.items()\n                       if s == max_support]\n            for cand in winners:\n                b = dict(budget)  # copy of budget\n                if max_support > price:  # supporters can afford it\n                    # (voting_power - price) \/ voting_power\n                    multiplier = Fraction(max_support - price,\n                                          max_support)\n                else:  # set supporters to 0\n                    multiplier = 0\n                for nr, pref in enumerate(profile):\n                    if cand in pref:\n                        b[nr] *= multiplier\n                c = comm.union([cand])  # new committee with candidate\n                next_committees.append((b, c))\n\n        if resolute:\n            committees = [next_committees[0]]\n        else:\n            committees = next_committees\n    committees = [comm for b, comm in committees]\n    committees = sort_committees(committees)\n    if resolute:\n        committees = [committees[0]]\n\n    # optional output\n    if verbose:\n        print(header(rules[\"phrag-enestr\"].longname))\n\n        print(str_committees_header(committees, winning=True))\n        print(str_candsets(committees, names=profile.names))\n    # end of optional output\n\n    return committees\n\n\n__RULESINFO = [\n    (\"av\", \"AV\", \"Approval Voting (AV)\", compute_av,\n     [\"standard\"], [True, False]),\n    (\"sav\", \"SAV\", \"Satisfaction Approval Voting (SAV)\", compute_sav,\n     [\"standard\"], [True, False]),\n    (\"pav\", \"PAV\", \"Proportional Approval Voting (PAV)\", compute_pav,\n     [\"gurobi\", \"branch-and-bound\"], [True, False]),\n    (\"slav\", \"SLAV\", \"Sainte-Laguë Approval Voting (SLAV)\", compute_slav,\n     [\"gurobi\", \"branch-and-bound\"], [True, False]),\n    (\"cc\", \"CC\", \"Approval Chamberlin-Courant (CC)\", compute_cc,\n     [\"gurobi\", \"branch-and-bound\"], [True, False]),\n    (\"geom2\", \"2-Geometric\", \"2-Geometric Rule\",\n     functools.partial(compute_thiele_method, \"geom2\"),\n     [\"gurobi\", \"branch-and-bound\"], [True, False]),\n    (\"seqpav\", \"seq-PAV\", \"Sequential Proportional Approval Voting (seq-PAV)\",\n     compute_seqpav, [\"standard\"], [True, False]),\n    (\"revseqpav\", \"revseq-PAV\",\n     \"Reverse Sequential Proportional Approval Voting (revseq-PAV)\",\n     compute_revseqpav, [\"standard\"], [True, False]),\n    (\"seqslav\", \"seq-SLAV\",\n     \"Sequential Sainte-Laguë Approval Voting (seq-SLAV)\",\n     compute_seqslav, [\"standard\"], [True, False]),\n    (\"seqcc\", \"seq-CC\", \"Sequential Approval Chamberlin-Courant (seq-CC)\",\n     compute_seqcc, [\"standard\"], [True, False]),\n    (\"seqphrag\", \"seq-Phragmén\", \"Phragmén's Sequential Rule (seq-Phragmén)\",\n     compute_seqphragmen, [\"standard\"], [True, False]),\n    (\"optphrag\", \"opt-Phragmén\", \"Phragmén's Optimization Rule (opt-Phragmén)\",\n     compute_optphragmen, [\"gurobi\"], [True, False]),\n    (\"monroe\", \"Monroe\", \"Monroe's Approval Rule (Monroe)\",\n     compute_monroe, [\"gurobi\", \"brute-force\"], [True, False]),\n    (\"greedy-monroe\", \"Greedy Monroe\", \"Greedy Monroe\",\n     compute_greedy_monroe, [\"standard\"], [True]),\n    (\"mav\", \"MAV\", \"Minimax Approval Voting (MAV)\",\n     compute_mav, [\"gurobi\", \"brute-force\"], [True, False]),\n    (\"lexmav\", \"lex-MAV\", \"Lexicographic Minimax Approval Voting (lex-MAV)\",\n     compute_lexmav, [\"brute-force\"], [True, False]),\n    (\"rule-x\", \"Rule X\", \"Rule X\",\n     compute_rule_x, [\"standard\"], [True, False]),\n    (\"phrag-enestr\", \"Phragmén-Eneström\", \"Method of Phragmén-Eneström\",\n     compute_phragmen_enestroem, [\"standard\"], [True, False])]\nrules = {}\nfor ruleinfo in __RULESINFO:\n    rules[ruleinfo[0]] = ABCRule(*ruleinfo)\n# TODO: add other thiele methods\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_286","text":"<reponame>drtaiga\/Thermistor_Notebook\n#Import the schemdraw modules for drawing circuit schematics\nimport schemdraw.elements as elm\nimport schemdraw\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nimport ipywidgets as widgets\n\n#import scipy.optimize as fsolve\nfrom scipy.optimize import fsolve \nimport scipy.optimize as opt\n\n#---------------------------------\n#-- Voltage divider schematics\ndef draw_dividers():\n\n    v_divider = schemdraw.Drawing(inches_per_unit=.5, unit=2)   \n    v_divider.add(elm.DOT,open='true',label='$V_o$')\n    vdr1 = v_divider.add(elm.RES, d='down', label='$R_0$')\n    v_divider.add(elm.DOT)\n    vdr2 = v_divider.add(elm.RES, d='down', label='$R_1$')\n    v_divider.add(elm.GND, botlabel='Fig. 1A',lblofst=1)\n    v_divider.add(elm.LINE, d='right', xy=vdr1.end, l=v_divider.unit)\n    v_divider.add(elm.DOT, open='true', label='$V^{(A)}$')\n    v_divider.here = [v_divider.here[0]+2*v_divider.unit, v_divider.here[1]]\n    vdr3=v_divider.add(elm.DOT)\n    v_divider.add(elm.RES, d='up', label='$R_1$')\n    v_divider.add(elm.DOT, open='true', label='$V_o$')\n    v_divider.add(elm.RES,d='down',xy=vdr3.start, label='$R_0$')\n    v_divider.add(elm.GND, botlabel='Fig. 1B',lblofst=1)\n    v_divider.add(elm.LINE, d='right', xy=vdr3.end, l=v_divider.unit)\n    v_divider.add(elm.DOT, open='true', label='$V^{(B)}$')\n    return v_divider.draw()\n\ndef draw_dividers2():\n    \n    #SchemDraw schematic of a generic voltage divider circuit\n    v2_divider = schemdraw.Drawing(inches_per_unit=.5, unit=2)\n    v2_divider.add(elm.DOT,open='true',label='$V_o$')\n    v2dr1 = v2_divider.add(elm.RES, d='down', label='$R_0$')\n    v2_divider.add(elm.DOT)\n    v2dr2 = v2_divider.add(elm.RES_VAR, reverse='true',d='down', label='$R(T)$')\n    v2_divider.add(elm.GND, botlabel='Fig. 2A',lblofst=1)\n    v2_divider.add(elm.LINE, d='right', xy=v2dr1.end, l=v2_divider.unit)\n    v2_divider.add(elm.DOT, open='true', label='$V^{(2A)}$')\n    v2_divider.here = [v2_divider.here[0]+2*v2_divider.unit, v2_divider.here[1]]\n    v2dr3=v2_divider.add(elm.DOT)\n    v2_divider.add(elm.RES_VAR, d='up', flip='true',label='$R(T)$')\n    v2_divider.add(elm.DOT, open='true', label='$V_o$')\n    v2_divider.add(elm.RES,d='down',xy=v2dr3.start, label='$R_0$')\n    v2_divider.add(elm.GND, botlabel='Fig. 2B',lblofst=1)\n    v2_divider.add(elm.LINE, d='right', xy=v2dr3.end, l=v2_divider.unit)\n    v2_divider.add(elm.DOT, open='true', label='$V^{(2B)}$')\n    return v2_divider.draw()\n\ndef draw_divamp():\n    \n    div_amp = schemdraw.Drawing(inches_per_unit=.5, unit=2)\n    \n    op = div_amp.add(elm.Opamp,flip='true')\n    div_amp.add(elm.LINE, d='left', xy=op.in2, l=div_amp.unit*.75)\n    p1=div_amp.add(elm.DOT)\n    div_amp.add(elm.LINE,l=1.0, d='left')\n    div_amp.add(elm.RES_VAR,d='left',label=\"$R(T)$\",reverse='true',flip='true')\n    div_amp.add(elm.LINE,d='left',l=0.5)\n    div_amp.add(elm.DOT,open='true',label='$V_o$')\n    div_amp.add(elm.LINE,d='down', l=div_amp.unit*1, xy=p1.start)\n    div_amp.add(elm.GND)   \n    p3=div_amp.add(elm.LINE,d='left', xy=op.in1, l=div_amp.unit\/4)\n    div_amp.add(elm.LINE,d='right', xy=op.out,l=1)\n    div_amp.add(elm.DOT,open='true',label='$V$')\n    div_amp.add(elm.LINE,xy=p3.end,d='down',l=.75)\n    div_amp.add(elm.GND)\n    div_amp.add(elm.LINE,d='down', xy=op.vd, l=.5)\n    div_amp.add(elm.GND)\n    div_amp.add(elm.LINE,d='up', xy=op.vs, l=.5)\n    div_amp.add(elm.VDD,label='$V_0$')\n    div_amp.add(elm.LINE,d='down', xy=op.n2, l=.5)\n    div_amp.add(elm.LINE,d='right',l=.25)\n    div_amp.add(elm.DOT,rgtlabel='$V_{ref}$')\n    return div_amp.draw()    \n#--- Voltage divider schematics    \n#---------------------------------\n\n\n#---------------------------------\n#--- Wheatstone bridge schematics\ndef draw_bridge():\n    \n    wbridge = schemdraw.Drawing(inches_per_unit=.5, unit=3)\n    br1 = wbridge.add(elm.RES,theta=45, toplabel='$R_1$')\n    br_top=wbridge.add(elm.DOT)\n    br2 = wbridge.add(elm.RES,theta=-45, toplabel='$R_3$')\n    br_right=wbridge.add(elm.DOT)\n    br3 = wbridge.add(elm.RES_VAR, theta=-135, botlabel='$R(T)$', flip='true',reverse='true')\n    br_bot=wbridge.add(elm.DOT,botlabel='Fig. 3A',lblofst=1)\n    br4 = wbridge.add(elm.RES,theta=135, botlabel='$R_2$')\n    br_left=wbridge.add(elm.DOT)\n    wbridge.add(elm.LINE,d='right',xy=br_top.start,l=wbridge.unit*1.25)\n    wbridge.add(elm.DOT, open=True, label='$V_T^{(3A)}$')\n    wbridge.add(elm.LINE,d='right',xy=br_bot.start,l=wbridge.unit*1.25)\n    wbridge.add(elm.DOT,open=True, label='$V_B^{(3A)}$')\n    wbridge.add(elm.LINE,d='left',xy=br_left.start,l=wbridge.unit\/4)\n    wbridge.add(elm.VDD,label='$V_0$')\n    wbridge.add(elm.LINE,d='right',xy=br_right.start,l=wbridge.unit\/4)\n    wbridge.add(elm.GND)\n\n    wbridge.here = [wbridge.here[0]+1.5*wbridge.unit, wbridge.here[1]]\n    br2_left=wbridge.add(elm.DOT)\n    br5=wbridge.add(elm.RES,theta=45, toplabel='$R_1$')\n    br2_top=wbridge.add(elm.DOT)\n    br6 = wbridge.add(elm.Resistor(theta=-45, toplabel='$R_3$'))\n    br2_right=wbridge.add(elm.Dot())\n    br7 = wbridge.add(elm.RES, theta=-135, botlabel='$R_2$', flip='true',reverse='true')\n    br2_bot=wbridge.add(elm.DOT,botlabel='Fig. 3B',lblofst=1)\n    br8 = wbridge.add(elm.RES_VAR,theta=135, flip='true',botlabel='$R(T)$')\n\n    wbridge.add(elm.LINE,d='left',xy=br2_left.start,l=wbridge.unit\/4)\n    wbridge.add(elm.VDD,label='$V_0$')\n    wbridge.add(elm.LINE,d='right',xy=br2_right.start,l=wbridge.unit\/4)\n    wbridge.add(elm.GND)\n    wbridge.add(elm.LINE,d='right',xy=br2_top.start,l=wbridge.unit*1.25)\n    wbridge.add(elm.DOT, open=True, label='$V_T^{(3B)}$')\n    wbridge.add(elm.LINE,d='right',xy=br2_bot.start,l=wbridge.unit*1.25)\n    wbridge.add(elm.DOT, open=True, label='$V_B^{(3B)}$')\n\n    return wbridge.draw()\n\n\ndef draw_bridgeamp():\n    \n    wwbridge = schemdraw.Drawing(inches_per_unit=.5, unit=3)\n    wbr1 = wwbridge.add(elm.RES,theta=45, toplabel='$R_1$')\n    wbr_top=wwbridge.add(elm.DOT)\n    #wbridge.add(elm.Vdd(label='$V_0$'))\n    wbr2 = wwbridge.add(elm.RES,theta=-45, toplabel='$R_3$')\n    wbr_right=wwbridge.add(elm.DOT)\n    wbr3 = wwbridge.add(elm.RES_VAR,theta=-135,flip='true', botlabel='$R(T)$')\n    wbr_bot=wwbridge.add(elm.DOT)\n    #wbridge.add(elm.Ground())\n    wbr4 = wwbridge.add(elm.RES,theta=135, botlabel='$R_2$')\n    wbr_left=wwbridge.add(elm.DOT)\n    wwbridge.add(elm.LINE,d='right',xy=wbr_top.start,l=wwbridge.unit*1.25)\n    rn1=wwbridge.add(elm.DOT,open=True, label='$V_T$')\n    wwbridge.add(elm.LINE,d='right',xy=wbr_bot.start,l=wwbridge.unit*1.25)\n    rn2=wwbridge.add(elm.DOT, open=True, botlabel='$V_B$')\n    wwbridge.add(elm.LINE,d='left',xy=wbr_left.start,l=wwbridge.unit\/4)\n    wwbridge.add(elm.VDD,label='$V_0$')\n    wwbridge.add(elm.LINE,d='right',xy=wbr_right.start,l=wwbridge.unit\/4)\n    wwbridge.add(elm.GND)\n    wwbridge.add(elm.LINE,d='down',xy=rn1.start,l=wwbridge.unit*0.5)\n    wwbridge.add(elm.LINE,d='right',l=wwbridge.unit*0.5)\n    O1=wwbridge.add(elm.OPAMP,anchor='in2',flip='true')\n    wwbridge.add(elm.LINE,d='up',xy=rn2.start,l=wwbridge.unit*0.5)\n    wwbridge.add(elm.LINE,d='left', l=wwbridge.unit*0.5, xy=O1.in1)\n    wwbridge.add(elm.LINE,d='up', xy=O1.vs, l=1\/2)\n    wwbridge.add(elm.VDD,label='$V_0$')\n    wwbridge.add(elm.LINE,d='down', xy=O1.vd, l=1\/2)\n    wwbridge.add(elm.GND)\n    wwbridge.add(elm.LINE,d='right', xy=O1.out,l=1)\n    wwbridge.add(elm.DOT,open='true',label='$V$')\n    wwbridge.add(elm.LINE,d='down', xy=O1.n2, l=.5)\n    wwbridge.add(elm.LINE,d='right',l=.25)\n    wwbridge.add(elm.DOT,rgtlabel='$V_{ref}$')\n    \n    return wwbridge.draw()    \n    \n#--- Wheatstone bridge schematics\n#---------------------------------\n\n\n#---------------------------------\n# Voltage divider: thermistor-to-ground configuration (Configuration 'A')\ndef div_tg(T, Vin, res0, B, R25, T25):\n    #R25 = 1.0e4\n    #B = 3977.0\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f=res\/(res0+res) * Vin\n    return f\n\ndef ddt_div_tp(T, Vin, res0, B, R25, T25):\n    \n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f=Vin*B*res0\/T**2.0\/(res0+res)**2.0 * res\n\n    return f\n\ndef ddt_div_tg(T, Vin, res0, B, R25, T25):\n    \n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f= Vin*(B*res**2.0 \/(T**2.0 * (res0+res)**2.0) - \\\n        B*res\/(T**2.0 * (res0+res)))\n\n    return f\n\n# Voltage divider: thermistor-to-power configuration (Configuration 'B')\ndef div_tp(T, Vin, res0, B, R25, T25):\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f = res0\/(res0+res) * Vin\n    return f\n\n# Bridge: thermistor-to-ground configuration\ndef b_tg(T, Vin, res0, B, R25, T25, rho):\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f = -(1\/(1.0 + rho)-res\/(res0+res)) * Vin\n    return  f\n\n# Bridge: thermistor-to-power configuration\ndef b_tp(T, Vin, res0, B, R25, T25, rho):\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f = -(rho\/(1.0+rho) - res0\/(res0+res)) * Vin\n    return f\n\ndef div_plot(R0):\n    R25 = 1.0e4\n    B = 3977.0\n    T25 = 273.15 + 25.0\n    V_in=3.3\n    # Input temperatures in Kelvin\n    T25 = 273.15 + 25.0\n    temp_K = np.arange(250.0, 310.0, 0.2)\n    fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n    out_tg=np.clip(div_tg(temp_K, V_in, R0, B, R25, T25),0,V_in)\n    out_tp=np.clip(div_tp(temp_K, V_in, R0, B, R25, T25),0,V_in)\n    \n    t_infl = opt.fsolve(f_inflection, 280., args=R0)\n    \n    slope_tg=ddt_div_tg(t_infl, V_in, R0, B, R25, T25)\n    slope_tp=ddt_div_tp(t_infl, V_in, R0, B, R25, T25)\n    \n    lin_tg = div_tg(t_infl, V_in, R0, B, R25, T25) + \\\n        slope_tg*(temp_K - t_infl)\n    lin_tp = div_tp(t_infl, V_in, R0, B, R25, T25) + \\\n        slope_tp*(temp_K - t_infl)\n    \n    \n    ax.plot(temp_K,out_tg,label='$V^{(2A)}$')\n    ax.plot(temp_K,out_tp,label='$V^{(2B)}$')\n    plt.plot(t_infl, np.clip(div_tg(t_infl, V_in, R0, B, R25, T25),0,V_in), \\\n             marker='o',color=\"gray\" )\n    plt.plot(t_infl, np.clip(div_tp(t_infl, V_in, R0, B, R25, T25),0,V_in), \\\n             marker='o', color=\"gray\" )\n    plt.plot(temp_K,lin_tg,':', color=\"gray\")\n    plt.plot(temp_K,lin_tp,':', color=\"gray\")\n    plt.ylim(0.,4.0)\n    plt.legend()\n    plt.title('Outputs from the Thermistor Voltage Divider Configurations \\n (10K Thermistor: Vishay Model Booo )')\n    plt.ylabel('Divider Circuit Output (Volts)')\n    plt.xlabel('Temperature (Kelvin)')\n    return plt.show()\n\ndef divider_plot():\n\n    return widgets.interact(div_plot, \\\n        R0=widgets.IntSlider(min=5000, max=100000, step=500, value=17900.,description=r'\\(R_0 (\\Omega) \\)'))\n\n\n# Bridge: thermistor-to-ground configuration\ndef bridge_tg(T, Vin, res0, B, R25, T25,rho):\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f=(1.0\/(rho+1.0)-res\/(res0+res)) * Vin\n    return  f\n\n# Bridge: thermistor-to-power configuration\ndef bridge_tp(T, Vin, res0, B, R25, T25,rho):\n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    f=(1.0\/(rho+1.0) - res0\/(res0+res)) * Vin\n    return f\n\n\n\ndef br_plot(R0, RHO):\n    \n    R25 = 1.0e4\n    B = 3977.0\n    T25 = 273.15 + 25.0\n    V_in=3.3\n    \n    temp_K = np.arange(250.0, 310.0, 0.2)\n    \n    fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n    \n    out_tg=np.clip(bridge_tg(temp_K, V_in, R0, \\\n                                 B, R25, T25,RHO), 0,V_in)\n    out_tp=np.clip(bridge_tp(temp_K, V_in, R0, \\\n                                 B, R25, T25,RHO),0,V_in)\n\n\n    \n    t_infl = opt.fsolve(f_inflection, 280., args=R0)\n    \n    slope_tg=-ddt_div_tg(t_infl, V_in, R0, B, R25, T25)\n    slope_tp=-ddt_div_tp(t_infl, V_in, R0, B, R25, T25)\n    \n    lin_tg = bridge_tg(t_infl, V_in, R0, B, R25, T25, RHO) + \\\n        slope_tg*(temp_K - t_infl)\n    lin_tp = bridge_tp(t_infl, V_in, R0, B, R25, T25, RHO) + \\\n        slope_tp*(temp_K - t_infl)\n\n    ax.plot(temp_K,out_tg,label='$V^{(3A)}$')\n    ax.plot(temp_K,out_tp,label='$V^{(3B)}$')\n    \n    plt.plot(t_infl, np.clip(bridge_tg(t_infl, V_in, R0, B, R25, T25,RHO),0,V_in), \\\n             marker='o',color=\"gray\" )\n    plt.plot(t_infl, np.clip(bridge_tp(t_infl, V_in, R0, B, R25, T25, RHO),0,V_in), \\\n             marker='o', color=\"gray\" )\n    plt.plot(temp_K,lin_tg,':', color=\"gray\")\n    plt.plot(temp_K,lin_tp,':', color=\"gray\")\n    #ax.plot(temp_K,out_div_tp,label='$V_{div}$')\n    plt.ylim(0.,3.5)\n    plt.legend()\n    plt.title('Outputs from the Amplified Voltage Divider Configurations')\n    plt.ylabel('Divider Circuit Output (Volts)')\n    plt.xlabel('Temperature (Kelvin)')\n    \n    return plt.show()\n\ndef bridge_plot2():\n\n    return widgets.interact(br_plot, \\\n        R0=widgets.IntSlider(min=5000, max=100000, step=100, value=17500.,description=r'\\(R_0 (\\Omega) \\)'), \\\n        RHO=widgets.FloatSlider(min=0, max=0.5, step=.005, value=0,description=r'\\(\\rho\\)'))\n\n\ndef amp_plot(R0,V_ref,RHO,A_G):\n    R25 = 1.0e4\n    B = 3977.0\n    T25 = 273.15 + 25.0\n    V_in=3.3\n    temp_K = np.arange(250.0, 310.0, 0.2)\n    #temp_K = np.arange(250.0, 310.0, 0.2)\n    fig, ax = plt.subplots(1, 1, figsize=(6,4))\n    out_tg=np.clip(A_G*b_tg(temp_K, V_in, R0, \\\n                                 B, R25, T25,RHO)+V_ref,0.0,V_in)\n    out_tp=np.clip(A_G*b_tp(temp_K, V_in, R0, \\\n                                 B, R25, T25,RHO)+V_ref,0.0,V_in)\n    out_div_tp=np.clip(A_G*div_tp(temp_K, V_in, R0, B, R25, T25)+V_ref,0,V_in)\n    \n    #ax.plot(temp_K,out_tg,label='$V_{TG}$')\n    ax.plot(temp_K,out_tp,label='$V_{br}$')\n    ax.plot(temp_K,out_div_tp,label='$V_{div}$')\n    plt.ylim(0.,3.5)\n    plt.legend()\n    plt.title('Outputs from the Amplified Voltage Divider Configurations')\n    plt.ylabel('Divider Circuit Output (Volts)')\n    plt.xlabel('Temperature (Kelvin)')\n    \n    return plt.show()\n\ndef ampcircuits_plot():\n    \n    return widgets.interact(amp_plot, \\\n        R0=widgets.IntSlider(min=5000, max=100000, step=100,value=17500.,description=r'\\(R_0 (\\Omega) \\)'), \\\n        V_ref=widgets.FloatSlider(min=0, max=3.3, step=.01,value=0,description=r'\\(V_{\\it ref} (V)\\)'), \\\n        RHO=widgets.FloatSlider(min=0, max=1, step=.01,value=0,description=r'\\(\\rho\\)'), \\\n        A_G=widgets.FloatSlider(min=1, max=2, step=.01,value=0,description=r'\\(A_{G}\\)'))\n\n\n#---------------------------------\n\ndef therm_res(T, B, R25, T25):\n    \n    #B-Parameter equation for thermistor resistance\n    \n    res = R25 * np.exp(B*(1.0\/T-1.0\/T25))\n    \n    return res\n\ndef d_therm_res(T, B, R25, T25):\n    \n    f= - B\/T**2.0 * therm_res(T,B,R25,T25)\n    \n    return f\n\ndef thermres_plot():\n    \n    #Define the temperature range in Kelvin\n    temp_K = np.arange(250.0, 310.0, 0.2)\n\n    #Define thermistor parameters\n\n    R25 = 1.0e4\n    T25 = 273.15 + 25.0\n    B = 3977.0\n    \n    r_t = therm_res(temp_K, B, R25, T25)\n    \n    fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n    ax.plot(temp_K,r_t\/1000.)\n    plt.title('Temperature Dependence of Thermistor Resistance \\n (10K Thermistor: Vishay Model )');\n    plt.ylabel('Thermistor Resistance ($k\\Omega$)');\n    plt.xlabel('Temperature (Kelvin)');   \n    \n    return plt.show()\n\ndef inflection():\n    \n    R25 = 1.0e4\n    T25 = 273.15 + 25.0\n    B = 3977.0\n    \n    #Define the temperature range in Kelvin\n    temp_K = np.arange(250.0, 310.0, 0.2)\n\n    \n    res0= (B-2.0*temp_K)\/(B+2.0*temp_K)*therm_res(temp_K,B,R25,T25)\n    \n    fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n    ax.plot(temp_K,res0\/1000.,temp_K,therm_res(temp_K,B,R25,T25)\/1000.)\n    plt.title('Temperature Dependence of Thermistor Resistance \\n (10K Thermistor: Vishay Model )');\n    plt.ylabel('Thermistor Resistance ($k\\Omega$)');\n    plt.xlabel('Temperature (Kelvin)');   \n    \n    return plt.show()\n\ndef f_inflection(tkel, *data):\n    \n    R0=data\n    \n    R25 = 1.0e4\n    T25 = 273.15 + 25.0\n    B = 3977.0\n    \n    f = (B-2.0*tkel)\/(B+2.0*tkel)*therm_res(tkel,B,R25,T25)-R0\n    \n    return f\n\ndef f_prime(tkel):\n\n    R25 = 1.0e4\n    T25 = 273.15 + 25.0\n    B = 3977.0\n    \n    fp = - (2.0 + 2.0*(B-2.0*tkel)\/(B+2.0*tkel) + B*(B-2.0*tkel)\/tkel**2.0) \\\n        * therm_res(tkel,B,R25,T25) \/ (B+2.0*tkel)\n    \n    return fp\n    \n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_287","text":"#!\/usr\/bin\/env python\r\n\r\n\"\"\" Assemble the specified FEM matrix.\r\n\"\"\"\r\n\r\nimport argparse\r\nimport pymesh\r\nimport scipy.sparse\r\n\r\ndef parse_args():\r\n    parser = argparse.ArgumentParser(__doc__);\r\n    parser.add_argument(\"--type\", \"-t\", help=\"The type of matrix\",\r\n            choices=[\"stiffness\", \"mass\", \"lumped_mass\", \"laplacian\",\r\n                \"displacement_strain\", \"elasticity_tensor\",\r\n                \"engineer_strain_stress\", \"rigid_motion\", \"gradient\"]);\r\n    parser.add_argument(\"input_mesh\");\r\n    parser.add_argument(\"output_matrix\");\r\n    return parser.parse_args();\r\n\r\ndef main():\r\n    args = parse_args();\r\n    mesh = pymesh.load_mesh(args.input_mesh);\r\n    assembler = pymesh.Assembler(mesh);\r\n    M = assembler.assemble(args.type);\r\n    scipy.sparse.save_npz(args.output_matrix, M);\r\n\r\nif __name__ == \"__main__\":\r\n    main();\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_272","text":"<filename>pypower\/qps_pips.py\n# Copyright (c) 1996-2015 PSERC. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n\"\"\"Uses the Python Interior Point Solver (PIPS) to solve QP (quadratic\nprogramming) problems.\n\"\"\"\n\nfrom numpy import Inf, ones, zeros, dot\n\nfrom scipy.sparse import csr_matrix as sparse\n\nfrom pypower.pips import pips\n\n\ndef qps_pips(H, c, A, l, u, xmin=None, xmax=None, x0=None, opt=None):\n    \"\"\"Uses the Python Interior Point Solver (PIPS) to solve the following\n    QP (quadratic programming) problem::\n\n            min 1\/2 x'*H*x + C'*x\n             x\n\n    subject to::\n\n            l <= A*x <= u       (linear constraints)\n            xmin <= x <= xmax   (variable bounds)\n\n    Note the calling syntax is almost identical to that of QUADPROG from\n    MathWorks' Optimization Toolbox. The main difference is that the linear\n    constraints are specified with C{A}, C{L}, C{U} instead of C{A}, C{B},\n    C{Aeq}, C{Beq}.\n\n    Example from U{http:\/\/www.uc.edu\/sashtml\/iml\/chap8\/sect12.htm}:\n\n        >>> from numpy import array, zeros, Inf\n        >>> from scipy.sparse import csr_matrix\n        >>> H = csr_matrix(array([[1003.1,  4.3,     6.3,     5.9],\n        ...                       [4.3,     2.2,     2.1,     3.9],\n        ...                       [6.3,     2.1,     3.5,     4.8],\n        ...                       [5.9,     3.9,     4.8,     10 ]]))\n        >>> c = zeros(4)\n        >>> A = csr_matrix(array([[1,       1,       1,       1   ],\n        ...                       [0.17,    0.11,    0.10,    0.18]]))\n        >>> l = array([1, 0.10])\n        >>> u = array([1, Inf])\n        >>> xmin = zeros(4)\n        >>> xmax = None\n        >>> x0 = array([1, 0, 0, 1])\n        >>> solution = qps_pips(H, c, A, l, u, xmin, xmax, x0)\n        >>> round(solution[\"f\"], 11) == 1.09666678128\n        True\n        >>> solution[\"converged\"]\n        True\n        >>> solution[\"output\"][\"iterations\"]\n        10\n\n    All parameters are optional except C{H}, C{c}, C{A} and C{l} or C{u}.\n    @param H: Quadratic cost coefficients.\n    @type H: csr_matrix\n    @param c: vector of linear cost coefficients\n    @type c: array\n    @param A: Optional linear constraints.\n    @type A: csr_matrix\n    @param l: Optional linear constraints. Default values are M{-Inf}.\n    @type l: array\n    @param u: Optional linear constraints. Default values are M{Inf}.\n    @type u: array\n    @param xmin: Optional lower bounds on the M{x} variables, defaults are\n                 M{-Inf}.\n    @type xmin: array\n    @param xmax: Optional upper bounds on the M{x} variables, defaults are\n                 M{Inf}.\n    @type xmax: array\n    @param x0: Starting value of optimization vector M{x}.\n    @type x0: array\n    @param opt: optional options dictionary with the following keys, all of\n                which are also optional (default values shown in parentheses)\n                  - C{verbose} (False) - Controls level of progress output\n                    displayed\n                  - C{feastol} (1e-6) - termination tolerance for feasibility\n                    condition\n                  - C{gradtol} (1e-6) - termination tolerance for gradient\n                    condition\n                  - C{comptol} (1e-6) - termination tolerance for\n                    complementarity condition\n                  - C{costtol} (1e-6) - termination tolerance for cost\n                    condition\n                  - C{max_it} (150) - maximum number of iterations\n                  - C{step_control} (False) - set to True to enable step-size\n                    control\n                  - C{max_red} (20) - maximum number of step-size reductions if\n                    step-control is on\n                  - C{cost_mult} (1.0) - cost multiplier used to scale the\n                    objective function for improved conditioning. Note: The\n                    same value must also be passed to the Hessian evaluation\n                    function so that it can appropriately scale the objective\n                    function term in the Hessian of the Lagrangian.\n    @type opt: dict\n\n    @rtype: dict\n    @return: The solution dictionary has the following keys:\n               - C{x} - solution vector\n               - C{f} - final objective function value\n               - C{converged} - exit status\n                   - True = first order optimality conditions satisfied\n                   - False = maximum number of iterations reached\n                   - None = numerically failed\n               - C{output} - output dictionary with keys:\n                   - C{iterations} - number of iterations performed\n                   - C{hist} - dictionary of arrays with trajectories of the\n                     following: feascond, gradcond, coppcond, costcond, gamma,\n                     stepsize, obj, alphap, alphad\n                   - C{message} - exit message\n               - C{lmbda} - dictionary containing the Langrange and Kuhn-Tucker\n                 multipliers on the constraints, with keys:\n                   - C{eqnonlin} - nonlinear equality constraints\n                   - C{ineqnonlin} - nonlinear inequality constraints\n                   - C{mu_l} - lower (left-hand) limit on linear constraints\n                   - C{mu_u} - upper (right-hand) limit on linear constraints\n                   - C{lower} - lower bound on optimization variables\n                   - C{upper} - upper bound on optimization variables\n\n    @see: L{pips}\n\n    @author: <NAME> (PSERC Cornell)\n    \"\"\"\n    if isinstance(H, dict):\n        p = H\n    else:\n        p = {'H': H, 'c': c, 'A': A, 'l': l, 'u': u}\n        if xmin is not None: p['xmin'] = xmin\n        if xmax is not None: p['xmax'] = xmax\n        if x0 is not None: p['x0'] = x0\n        if opt is not None: p['opt'] = opt\n\n    if 'H' not in p or p['H'] == None:#p['H'].nnz == 0:\n        if p['A'] is None or p['A'].nnz == 0 and \\\n           'xmin' not in p and \\\n           'xmax' not in p:\n#           'xmin' not in p or len(p['xmin']) == 0 and \\\n#           'xmax' not in p or len(p['xmax']) == 0:\n            print('qps_pips: LP problem must include constraints or variable bounds')\n            return\n        else:\n            if p['A'] is not None and p['A'].nnz >= 0:\n                nx = p['A'].shape[1]\n            elif 'xmin' in p and len(p['xmin']) > 0:\n                nx = p['xmin'].shape[0]\n            elif 'xmax' in p and len(p['xmax']) > 0:\n                nx = p['xmax'].shape[0]\n        p['H'] = sparse((nx, nx))\n    else:\n        nx = p['H'].shape[0]\n\n    p['xmin'] = -Inf * ones(nx) if 'xmin' not in p else p['xmin']\n    p['xmax'] =  Inf * ones(nx) if 'xmax' not in p else p['xmax']\n\n    p['c'] = zeros(nx) if p['c'] is None else p['c']\n\n    p['x0'] = zeros(nx) if 'x0' not in p else p['x0']\n\n    def qp_f(x, return_hessian=False):\n        f = 0.5 * dot(x * p['H'], x) + dot(p['c'], x)\n        df = p['H'] * x + p['c']\n        if not return_hessian:\n            return f, df\n        d2f = p['H']\n        return f, df, d2f\n\n    p['f_fcn'] = qp_f\n\n    sol = pips(p)\n\n    return sol[\"x\"], sol[\"f\"], sol[\"eflag\"], sol[\"output\"], sol[\"lmbda\"]\n\n\nif __name__ == \"__main__\":\n    import doctest\n    doctest.testmod()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_160","text":"import torch\nfrom torch import nn, Tensor\nfrom scipy.spatial.distance import cosine\nfrom typing import Optional\ndef mean(x : Tensor, dim : int = 1, weights: Optional[ None, Tensor ] = None) -> Tensor:\n    '''\n        Apply the mean to the index that represents the number of words\n    '''\n    return x.mean(dim=dim) if weights is not None else x.mean(dim=dim) * weights\n\ndef centroid(x : Tensor, index: int = 1) -> Tensor: \n    '''\n        Calculate the mean vector and return the one closest to the center\n    '''\n    from utils.funcs import normedChebyshev\n    mu = mean( x , index )\n    best = torch.argmin([ normedChebyshev( mu, x_i ) for x_i in x[ :, index ] ])\n    return x[:, [best], :]\n\ndef diff(x : Tensor) -> Tensor:\n    '''\n        Take the difference between the min and max of each dimension.\n        This will produce only positive values.\n\n        NOTE: This kind of seems dumb, but I'm leaving it for now.\n    '''\n    pass\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_161","text":"<filename>gemelli\/rpca.py\n# ----------------------------------------------------------------------------\n# Copyright (c) 2019--, gemelli development team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n# ----------------------------------------------------------------------------\n\nimport biom\nimport skbio\nimport numpy as np\nimport pandas as pd\nfrom typing import Union\nfrom gemelli.matrix_completion import MatrixCompletion\nfrom gemelli.preprocessing import matrix_rclr\nfrom gemelli._defaults import (DEFAULT_COMP,\n                               DEFAULT_MSC, DEFAULT_MFC,\n                               DEFAULT_OPTSPACE_ITERATIONS,\n                               DEFAULT_MFF)\nfrom scipy.linalg import svd\n\n\ndef rpca(table: biom.Table,\n         n_components: Union[int, str] = DEFAULT_COMP,\n         min_sample_count: int = DEFAULT_MSC,\n         min_feature_count: int = DEFAULT_MFC,\n         min_feature_frequency: float = DEFAULT_MFF,\n         max_iterations: int = DEFAULT_OPTSPACE_ITERATIONS) -> (\n        skbio.OrdinationResults,\n        skbio.DistanceMatrix):\n    \"\"\"Runs RPCA with an matrix_rclr preprocessing step.\n\n       This code will be run by both the standalone and QIIME 2 versions of\n       gemelli.\n    \"\"\"\n    # get shape of table\n    n_features, n_samples = table.shape\n\n    # filter sample to min seq. depth\n    def sample_filter(val, id_, md):\n        return sum(val) > min_sample_count\n\n    # filter features to min total counts\n    def observation_filter(val, id_, md):\n        return sum(val) > min_feature_count\n\n    # filter features by N samples presence\n    def frequency_filter(val, id_, md):\n        return (np.sum(val > 0) \/ n_samples) > (min_feature_frequency \/ 100)\n\n    # filter and import table for each filter above\n    table = table.filter(observation_filter, axis='observation')\n    table = table.filter(frequency_filter, axis='observation')\n    table = table.filter(sample_filter, axis='sample')\n    # table to dataframe\n    table = pd.DataFrame(table.matrix_data.toarray(),\n                         table.ids('observation'),\n                         table.ids('sample')).T\n    # check the table after filtering\n    if len(table.index) != len(set(table.index)):\n        raise ValueError('Data-table contains duplicate indices')\n    if len(table.columns) != len(set(table.columns)):\n        raise ValueError('Data-table contains duplicate columns')\n    # Robust-clt (matrix_rclr) preprocessing and OptSpace (RPCA)\n    opt = MatrixCompletion(n_components=n_components,\n                           max_iterations=max_iterations).fit(\n                               matrix_rclr(table))\n    # get new n-comp when applicable\n    n_components = opt.s.shape[0]\n    # get PC column labels for the skbio OrdinationResults\n    rename_cols = ['PC' + str(i + 1) for i in range(n_components)]\n    # get completed matrix for centering\n    X = opt.sample_weights @ opt.s @ opt.feature_weights.T\n    # center again around zero after completion\n    X = X - X.mean(axis=0)\n    X = X - X.mean(axis=1).reshape(-1, 1)\n    # re-factor the data\n    u, s, v = svd(X)\n    # only take n-components\n    u = u[:, :n_components]\n    v = v.T[:, :n_components]\n    # calc. the new variance using projection\n    p = s**2 \/ np.sum(s**2)\n    p = p[:n_components]\n    s = s[:n_components]\n    # save the loadings\n    feature_loading = pd.DataFrame(v, index=table.columns,\n                                   columns=rename_cols)\n    sample_loading = pd.DataFrame(u, index=table.index,\n                                  columns=rename_cols)\n    # % var explained\n    proportion_explained = pd.Series(p, index=rename_cols)\n    # get eigenvalues\n    eigvals = pd.Series(s, index=rename_cols)\n\n    # if the n_components is two add PC3 of zeros\n    # this is referenced as in issue in\n    # <https:\/\/github.com\/biocore\/emperor\/commit\n    # \/a93f029548c421cb0ba365b4294f7a5a6b0209ce>\n    # discussed in gemelli -- PR#29\n    if n_components == 2:\n        feature_loading['PC3'] = [0] * len(feature_loading.index)\n        sample_loading['PC3'] = [0] * len(sample_loading.index)\n        eigvals.loc['PC3'] = 0\n        proportion_explained.loc['PC3'] = 0\n\n    # save ordination results\n    short_method_name = 'rpca_biplot'\n    long_method_name = '(Robust Aitchison) RPCA Biplot'\n    ord_res = skbio.OrdinationResults(\n        short_method_name,\n        long_method_name,\n        eigvals.copy(),\n        samples=sample_loading.copy(),\n        features=feature_loading.copy(),\n        proportion_explained=proportion_explained.copy())\n    # save distance matrix\n    dist_res = skbio.stats.distance.DistanceMatrix(\n        opt.distance, ids=sample_loading.index)\n\n    return ord_res, dist_res\n\n\ndef auto_rpca(table: biom.Table,\n              min_sample_count: int = DEFAULT_MSC,\n              min_feature_count: int = DEFAULT_MFC,\n              min_feature_frequency: float = DEFAULT_MFF,\n              max_iterations: int = DEFAULT_OPTSPACE_ITERATIONS) -> (\n        skbio.OrdinationResults,\n        skbio.DistanceMatrix):\n    \"\"\"Runs RPCA but with auto estimation of the\n       rank peramater.\n    \"\"\"\n    ord_res, dist_res = rpca(table,\n                             n_components='auto',\n                             min_sample_count=min_sample_count,\n                             min_feature_count=min_feature_count,\n                             min_feature_frequency=min_feature_frequency,\n                             max_iterations=max_iterations)\n    return ord_res, dist_res\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_162","text":"import matplotlib\nmatplotlib.rcParams['pdf.fonttype'] = 42\nmatplotlib.rcParams['ps.fonttype'] = 42\n# matplotlib.rcParams['ps.useafm'] = True\n# matplotlib.rcParams['pdf.use14corefonts'] = True\n# matplotlib.rcParams['text.usetex'] = True\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plot\nimport matplotlib.cm as cm # cm.rainbow\nfrom random import expovariate\nimport sys, pprint, math, numpy, simpy, getopt, itertools\n\nfrom simplex_sim import *\nfrom simplex_models import *\nfrom mds_models import mds_exactbound_on_ar\n# from mds_exp import sim_mds_nk\n\nfrom scipy.interpolate import UnivariateSpline\n\ndef plot_reptoall_steadystate_probhist():\n  t, r, k = 1, 2, 2\n  def get_state_prob_m(ar):\n    log(WARNING, \"ar= {}, t= {}, r= {}, k= {}\".format(ar, t, r, k) )\n    env = simpy.Environment()\n    pg = PG(env, \"pg\", ar)\n    avq = AVQ(\"avq\", env, t, r, k, serv=\"Exp\", servdist_m={'mu': 1} )\n    # monitor = AVQMonitor(env, avq, poll_dist=lambda: 0.1)\n    # avq.join_q.out_m = monitor\n    pg.out = avq\n    env.run(until=50000)\n    \n    # print(\"monitor.polled_state__counter_map= {}\".format(pprint.pformat(monitor.polled_state__counter_map) ) )\n    total_counter = sum([c for rs, c in monitor.polled_state__counter_map.items() ] )\n    state_prob_m = {rs:float(c)\/total_counter for rs, c in monitor.polled_state__counter_map.items() }\n    # print(\"polled_state__counter_map= {}\".format(pprint.pformat(polled_state__counter_map) ) )\n    return state_prob_m # ['0,(0,0)']\n  # for ar in numpy.arange(0.05, 1.2, 0.1):\n  color = iter(cm.rainbow(numpy.linspace(0, 1, 20) ) )\n  plot.figure(figsize=(20,10) )\n  for ar in numpy.arange(0.05, 1.3, 0.1):\n  # for ar in numpy.arange(0.05, 0.1, 0.1):\n    state_prob_m = get_state_prob_m(ar)\n    \n    def state(kp, i, j):\n      return \"{},({},{})\".format(kp, i, j)\n    i__tau_l_map = {}\n    for i in range(10):\n      if i not in i__tau_l_map:\n        i__tau_l_map[i] = []\n      for kp in range(i, 10):\n        s_u, s_l = state(kp, i, 0), state(kp+1, i, 0)\n        if s_u in state_prob_m and s_l in state_prob_m:\n          i__tau_l_map[i].append(state_prob_m[s_l]\/state_prob_m[s_u] )\n        # if state(k+1, 0, i) in state_prob_m:\n        #   i__tau_l_map[i].append(state_prob_m[state(k+1, 0, i) ] \/state_prob_m[state(k, 0, i) ] )\n    log(WARNING, \"i__tau_l_map=\\n {}\".format(pprint.pformat(i__tau_l_map) ) )\n    #\n    wing_cutoff_i = 2\n    wing_cutoff_sum = 0\n    for s, p in state_prob_m.items():\n      split_l = s.split(\",\")\n      if int(split_l[1].split(\"(\")[1] ) > wing_cutoff_i or int(split_l[2].split(\")\")[0] ) > wing_cutoff_i:\n        wing_cutoff_sum += p\n      \n    s_l, p_l = [], []\n    for s, p in state_prob_m.items():\n      if p > 0.01:\n        s_l.append(s)\n        p_l.append(p)\n    plot.bar(range(len(p_l) ), p_l, color=next(color) )\n    plot.xticks([i+0.5 for i in range(len(s_l) ) ], s_l, size='small')\n    plot.xlabel(\"State\")\n    plot.ylabel(\"Steady-state probability\")\n    plot.title(r't= {}, $\\lambda$= {}, sum_on_plot= {}, wing_cutoff_sum= {}'. \\\n      format(t, \"{0:.2f}\".format(ar), \"{0:.2f}\".format(sum(p_l)), \"{0:.2f}\".format(wing_cutoff_sum) ) )\n    plot.savefig(\"plot_reptoall_steadystate_probhist_ar_{0:.2f}.png\".format(ar) )\n    plot.clf()\n\ndef test_avq(nf, ar, t, r, k, serv=\"Exp\", servdist_m=None,\n             w_sys=True, mixed_traff=False, sching=\"rep-to-all\", p_i_l= [] ):\n  E_T_f_sum = 0\n  for f in range(nf):\n    log(WARNING, \"ar= {}, t= {}, r= {}, k= {}, servdist_m= {}, w_sys= {}, mixed_traff= {}, sching= {}\". \\\n        format(ar, t, r, k, servdist_m, w_sys, mixed_traff, sching) )\n    \n    env = simpy.Environment()\n    if mixed_traff:\n      sym_l, sym__rgroup_l_m = simplex_sym_l__sym__rgroup_l_m(t)\n      log(WARNING, \"sym__rgroup_l_m=\\n {}\".format(pprint.pformat(sym__rgroup_l_m) ) )\n      pg = MT_PG(env, \"pg\", ar, sym_l)\n      avq = MT_AVQ(\"mt_avq\", env, t, sym__rgroup_l_m, serv, servdist_m)\n      # monitor = AVQMonitor(env, aq=avq, poll_dist=lambda: 0.1)\n      # avq.join_q.out_m = monitor\n    else:\n      psize = None\n      if serv == \"Bern*Pareto\":\n        psize = \"Pareto\"\n        serv = \"Bern\"\n      pg = PG(env, \"pg\", ar, psize=psize, psize_dist_m=servdist_m)\n      avq = AVQ(\"avq\", env, t, r, k, servdist_m, sching, w_sys=w_sys)\n      # monitor = AVQMonitor(env, aq=avq, poll_dist=lambda: 0.1)\n      # avq.join_q.out_m = monitor\n    pg.out = avq\n    pg.init()\n    c = 3 if serv == \"Pareto\" or serv == \"Bern\" else 1\n    env.run(until=c*50000) # 20\n    \n    if mixed_traff:\n      print(\"pg.sym__n_sent= {}\".format(pprint.pformat(pg.sym__n_sent) ) )\n    st_l = avq.jsink.st_l\n    if len(st_l) > 0:\n      E_T_f_sum += float(sum(st_l) )\/len(st_l)\n      # continue\n    # print(\"avq.jsink.qid__num_win_map= {}\".format(pprint.pformat(avq.jsink.qid__num_win_map) ) )\n    total_n_wins = sum([n for i, n in avq.jsink.qid__num_win_map.items() ] )\n    print(\"pg.n_sent= {}, total_n_wins= {}\".format(pg.n_sent, total_n_wins) )\n    qid_winfreq_map = {i:float(n)\/total_n_wins for i, n in avq.jsink.qid__num_win_map.items() }\n    print(\"qid_winfreq_map= {}\".format(pprint.pformat(qid_winfreq_map) ) )\n    # if not mixed_traff:\n    #   total_n_types = sum(avq.servtype__num_m)\n    #   p_i_l[:] = [n\/total_n_types for t, n in enumerate(avq.servtype__num_m) ]\n    #   print(\"p_i_l= {}\".format(p_i_l) )\n    \"\"\"\n    print(\"\\n\")\n    # print(\"avq.join_q.state__num_found_map= {}\".format(pprint.pformat(avq.join_q.state__num_found_map) ) )\n    # total_num_founds = sum([n for s, n in avq.join_q.state__num_found_map.items() ] )\n    # state__found_freq_map = {s:float(n)\/total_num_founds for s, n in avq.join_q.state__num_found_map.items() }\n    # print(\"state__found_freq_map= {}\".format(pprint.pformat(state__found_freq_map) ) )\n    \n    print(\"\\n\")\n    # print(\"monitor.polled_state__counter_map= {}\".format(pprint.pformat(monitor.polled_state__counter_map) ) )\n    total_counter = sum([c for rs, c in monitor.polled_state__counter_map.items() ] )\n    polled_state__counter_map = {rs:float(c)\/total_counter for rs, c in monitor.polled_state__counter_map.items() }\n    print(\"polled_state__counter_map= {}\".format(pprint.pformat(polled_state__counter_map) ) )\n    \n    print(\"\\n\")\n    # print(\"monitor.state__num_found_by_job_departed_map= {}\".format(pprint.pformat(monitor.state__num_found_by_job_departed_map) ) )\n    total_counter = sum([c for rs, c in monitor.state__num_found_by_job_departed_map.items() ] )\n    state__freq_found_by_job_departed_map = {rs:float(c)\/total_counter for rs, c in monitor.state__num_found_by_job_departed_map.items() }\n    print(\"state__freq_found_by_job_departed_map= {}\".format(pprint.pformat(state__freq_found_by_job_departed_map) ) )\n    \n    print(\"\\n\")\n    # print(\"monitor.start_setup__num_found_by_job_departed_map= {}\".format(pprint.pformat(monitor.start_setup__num_found_by_job_departed_map) ) )\n    total_counter = sum([c for rs, c in monitor.start_setup__num_found_by_job_departed_map.items() ] )\n    start_setup__freq_found_by_job_departed_map = {rs:float(c)\/total_counter for rs, c in monitor.start_setup__num_found_by_job_departed_map.items() }\n    print(\"start_setup__freq_found_by_job_departed_map= {}\".format(pprint.pformat(start_setup__freq_found_by_job_departed_map) ) )\n    \"\"\"\n  E_T = E_T_f_sum\/nf\n  print(\">> E_T= {}\".format(E_T) )\n  if E_T > 100: return None\n  return E_T\n  \ndef plot_winning_freqs():\n  t, r, k = 1, 2, 2\n  mu = 1\n  servdist_m = {'dist': 'Exp', 'mu': mu}\n  ar_ub = reptoall_innerbound_on_ar(t, servdist_m)\n  log(WARNING, \"t= {}, servdist_m= {}, ar_ub={}\".format(t, servdist_m, ar_ub) )\n  ar_l = []\n  qid__winfreq_l_map = {}\n  for ar in numpy.linspace(0.05, ar_ub*1.1, 20):\n    env = simpy.Environment()\n    pg = PG(env, \"pg\", ar)\n    avq = AVQ(\"avq\", env, t, r, k, servdist_m, \"rep-to-all\")\n    pg.out = avq\n    pg.init()\n    # monitor = AVQMonitor(env, aq=avq, poll_dist=lambda: 1)\n    env.run(until=50000)\n    \n    total_n_wins = sum([n for i, n in avq.jsink.qid__num_win_map.items() ] )\n    qid_winfreq_map = {i:float(n)\/total_n_wins for i, n in avq.jsink.qid__num_win_map.items() }\n    print(\"ar= {}, qid_winfreq_map= {}\".format(ar, pprint.pformat(qid_winfreq_map) ) )\n    \n    ar_l.append(ar)\n    for qid, win_freq in qid_winfreq_map.items():\n      if qid not in qid__winfreq_l_map:\n        qid__winfreq_l_map[qid] = []\n      qid__winfreq_l_map[qid].append(win_freq)\n  \n  plot.axhline(y=0.6, label=r'Lower-bound, $w_s$', c=next(dark_color), lw=2, ls='--')\n  plot.axhline(y=0.4, label=r'Upper-bound, $w_r$', c=next(dark_color), lw=2, ls='--')\n  counter = 0\n  for qid, win_freq_l in qid__winfreq_l_map.items():\n    if counter == 0:\n      plot.plot(ar_l, win_freq_l, label=r'Simulation, $w_s$', color=next(dark_color), marker=next(marker), ms=8, mew=2, ls=':')\n    else:\n      plot.plot(ar_l, win_freq_l, label=r'Simulation, $w_r$', color=next(dark_color), marker=next(marker), ms=8, mew=2, ls=':')\n    counter += 1\n\n  fontsize = 16\n  plot.legend(fontsize=13)\n  plot.xlabel(r'Arrival rate $\\lambda$', fontsize=fontsize)\n  plot.ylabel(\"Fraction of request completions\", fontsize=fontsize)\n  plot.title(r'Replicate-to-all $t=1$, $\\gamma=\\alpha=\\beta= {}$'.format(mu), fontsize=fontsize)\n  fig = plot.gcf()\n  # def_size = fig.get_size_inches()\n  # fig.set_size_inches(def_size[0]\/1.4, def_size[1]\/1.4)\n  fig.set_size_inches(6, 4)\n  fig.tight_layout()\n  # plot.savefig(\"plot_winning_freqs.png\", bbox_inches='tight')\n  plot.savefig(\"plot_winning_freqs.pdf\", dpi=fig.dpi)\n  plot.gcf().clear()\n  log(WARNING, \"done.\")\n\ndef plot_simplex_vs_rep():\n  t, r, k = 3, 2, 2\n  serv = \"Exp\"\n  mu = 1\n  servdist_m['mu'] = mu\n  if t == 1: ar_ub = 1.6\n  elif t == 3: ar_ub = 2.4\n  elif t == 7:\n    ar_ub = float(1.1*reptoall_innerbound_on_ar(mu, t, r, w_sys=True) )\n  mixed_traff = False\n  if mixed_traff: ar_ub = 1.1*ar_ub\n  log(WARNING, \"t= {}, ar_ub= {}, serv= {}, servdist_m= {}, mixed_traff= {}\".format(t, ar_ub, serv, servdist_m, mixed_traff) )\n  \n  n = 2*t + 1\n  n_sym = int(numpy.log2(n+1) )\n  # # Same distance\n  # n_rep = t + 1\n  # n_total_rep = n_sym*n_rep\n  # mu_rep = n*mu\/n_total_rep\n  \n  # n_mds = n_sym + t\n  # k_mds = n_sym\n  # mu_mds = (2*t+1)*mu\/n_mds\n  # ar_ub_mds = None\n  # if t == 3 and not mixed_traff: ar_ub_mds = ar_ub + 0.15 # mds_exactbound_on_ar(mu_mds, n_mds, k_mds)\n  \n  # Preserving hot-cold data mix\n  # n_rep = t + 1\n  # n_total_rep = n_rep\n  # ar_ub_mds = None\n  \n  # Same repair bandwidth\n  n_rep = t + 1\n  n_total_rep = int(n_sym*(t+1)\/2)\n  mu_rep = n*mu\/n_total_rep if not mixed_traff else n*mu\/n_total_rep\/n_sym\n  ar_ub_mds = None\n  \n  ar_ub_rep = n_rep*mu_rep\n  \n  sim_simplex_reqed = False\n  ET_sim_l = []\n  if not mixed_traff and t == 1:\n    ET_sim_l= [\n      0.6775872854372559,\n      0.7909557937247363,\n      0.9486987202221493,\n      1.166209238915134,\n      1.5685720588787688,\n      2.478342315521276,\n      2.6376081306859107,\n      2.906788473547391,\n      3.263700392764921,\n      3.5974807041868426,\n      4.289127887822366,\n      4.794525358984301,\n      5.896928018871929,\n      8.099664758903687,\n      12.74155958739236]\n  elif mixed_traff and t == 1:\n    ET_sim_mixedtraff_l= [\n      0.6795142458623882,\n      0.7748927520953908,\n      0.9120551663968248,\n      1.1017354073281063,\n      1.4008309793905753,\n      2.0319166972531395,\n      2.3461415096416802,\n      2.617752845887241,\n      2.931842457820586,\n      3.3957906721917803,\n      4.275140545352988,\n      5.384652265631004,\n      8.289396804081276,\n      None, # 21.85423973012918,\n      None]\n  elif not mixed_traff and t == 3:\n    ET_sim_l= [\n      0.4676519075931255,\n      0.5247256264186801,\n      0.6230081386991332,\n      0.775814486873029,\n      1.0207917160021767,\n      1.6244613243247372,\n      1.7481208563178903,\n      1.9667165686859327,\n      2.163968348080258,\n      2.5923594863306776,\n      3.0700378671376627,\n      3.796384731111067,\n      4.841880170965622,\n      6.610367379250164,\n      13.559429107437742]\n  elif mixed_traff and t == 3:\n    ET_sim_mixedtraff_l= [\n      0.46628732795742817,\n      0.5184094604634668,\n      0.5975473670434864,\n      0.7272615729604553,\n      0.9228862984361961,\n      1.3432430706439402,\n      1.5297012938889547,\n      1.7382202900329649,\n      2.006828591863818,\n      2.409746021676913,\n      2.9987862815607667,\n      4.1494167022302415,\n      6.7589082110731376,\n      None,\n      None]\n  elif not mixed_traff and t == 7:\n    ET_sim_l= [\n      0.31868938934489865,\n      0.3650196292881234,\n      0.4281058344507201,\n      0.5206469367259021,\n      0.6957249200007437,\n      1.1325417176453465,\n      1.2307386079673424,\n      1.3867025010207843,\n      1.5768489395874896,\n      1.865829597118924,\n      2.1844400783734677,\n      2.89287730113055,\n      4.276904798075734,\n      6.184072327220002,\n      None]\n  else:\n    sim_simplex_reqed = True\n  \n  sim_mds_reqed = False\n  E_T_sim_mds_l = []\n  if t == 3:\n    E_T_sim_mds_l= [\n      0.4291382378049635,\n      0.4859752967032978,\n      0.5573834220518918,\n      0.6504572423217563,\n      0.7912534680581111,\n      1.0617796194912665,\n      1.1173955998468372,\n      1.1864819039768486,\n      1.3132561853089193,\n      1.4183354786680833,\n      1.5441924947724337,\n      1.6800188501504796,\n      1.97388257061194,\n      2.365205967704707,\n      2.552714259149294]\n  else:\n    sim_mds_reqed = True\n  \n  sim_mds_split_to_one_reqed = False\n  E_T_sim_split_to_one_mds_l = []\n  if t == 3:\n    E_T_sim_split_to_one_mds_l= [\n      0.77365082603341717,\n      0.82440222647912942,\n      0.88499585518811741,\n      0.95059809100622572,\n      1.026735997953014,\n      1.1276811830357545,\n      1.2540326440649683,\n      1.4212608769595043,\n      1.6517287453133336,\n      1.9954850953566452,\n      2.5853499093220909,\n      3.8254183518878659,\n      8.5337611351281506,\n      None,\n      None]\n  else:\n    sim_mds_split_to_one_reqed = True\n  \n  mew, ms = 3, 8\n  nf = 2\n  def plot_reptoall():\n    # Simplex\n    ar_simplex_l = []\n    for ar in [*numpy.linspace(0.05, 0.8*ar_ub, 5, endpoint=False), *numpy.linspace(0.8*ar_ub, ar_ub, 10) ]:\n      ar_simplex_l.append(ar)\n      if sim_simplex_reqed:\n        ET_sim_l.append(test_avq(nf, ar, t, r, k, serv, servdist_m, w_sys=True, mixed_traff=mixed_traff) )\n    c = next(dark_color)\n    label = 'Simplex' # if t != 1 else 'Simplex or MDS'\n    print(\"ET_sim_l= {}\".format(pprint.pformat(ET_sim_l) ) )\n    plot.plot(ar_simplex_l, ET_sim_l, label=label, color=c, marker=next(marker), mew=mew, ms=ms, linestyle=':')\n    # stab_lim = ET_simplex_approx(t, ar, servdist_m, incremental=True, ar_ub=True)\n    # plot.axvline(stab_lim, label=\"Simplex stability\", color=c, linestyle='--')\n    # Rep\n    ar_rep_l, E_T_rep_n_1_l = [], []\n    for ar in numpy.linspace(0.05, ar_ub_rep-0.05, 20):\n      ar_rep_l.append(ar)\n      E_T_rep_n_1_l.append(E_T_rep_n_1(ar, mu_rep, n_rep) )\n    # E_T_rep_n_1_l = [e*n_rep for e in E_T_rep_n_1_l]\n    c = next(dark_color)\n    plot.plot(ar_rep_l, E_T_rep_n_1_l, label=r'Replication', color=c, marker=next(marker), mew=mew, ms=ms, linestyle=':')\n    # plot.axvline(ar_ub_rep, label=\"Rep stability\", color=c, linestyle='--')\n    # # MDS\n    # if ar_ub_mds is not None:\n    #   ar_mds_l = []\n    #   for ar in [*numpy.linspace(0.05, 0.7*ar_ub_mds, 5, endpoint=False), *numpy.linspace(0.7*ar_ub_mds, ar_ub, 10, endpoint=False) ]:\n    #   # for ar in numpy.linspace(ar_ub_mds, ar_ub_mds, 1):\n    #     ar_mds_l.append(ar)\n    #     if sim_mds_reqed:\n    #       E_T_sim_mds_l.append(test_avq(nf, ar, t=1, r, k, serv, {'mu': mu_mds}, w_sys=True) )\n    #   print(\"E_T_sim_mds_l= {}\".format(pprint.pformat(E_T_sim_mds_l) ) )\n    #   plot.plot(ar_mds_l, E_T_sim_mds_l, label=r'MDS', color=next(dark_color), marker=next(marker), mew=mew, ms=ms, linestyle=':')\n  def plot_selectone():\n    # Simplex\n    ar_ub = arub_simplex_selectone(t, mu) + 0.1\n    log(WARNING, \"ar_ub= {}\".format(ar_ub) )\n    ar_l, ET_l = [], []\n    for ar in numpy.linspace(0.05, ar_ub, 20):\n      ar_l.append(ar)\n      ET_l.append(ET_selectone(t, ar, mu) )\n    label = 'Simplex' # if t != 1 else 'Simplex or MDS'\n    plot.plot(ar_l, ET_l, label=label, color=next(dark_color), marker=next(marker), mew=mew, ms=ms, linestyle=':')\n    # Rep\n    ar_ub_rep = n_rep*mu_rep\n    ar_l, E_T_rep_l = [], []\n    for ar in numpy.linspace(0.05, ar_ub_rep-0.2, 20):\n      ar_l.append(ar)\n      E_T_rep_l.append(E_T_rep_n_1_split_to_one(ar, mu_rep, n_rep) )\n    plot.plot(ar_l, E_T_rep_l, label=r'Replication', color=next(dark_color), marker=next(marker), mew=mew, ms=ms, linestyle=':')\n  plot_reptoall()\n  scheduling = \"Replicate-to-all\"\n  # plot_selectone()\n  # scheduling = \"Split-to-one\"\n  plot.legend(prop={'size':12})\n  plot.xlabel(r'Arrival rate $\\lambda$ (Request\/s)', fontsize=12)\n  plot.ylabel(r'Average download time (s)', fontsize=12)\n  # plot.title(r'$t={}, \\mu={}$'.format(t, mu) )\n  plot.title(r'{} scheduling, $t= {}$'.format(scheduling, t) )\n  fig = plot.gcf()\n  def_size = fig.get_size_inches()\n  fig.set_size_inches(def_size[0]\/1.4, def_size[1]\/1.4)\n  fig.tight_layout()\n  plot.savefig(\"plot_simplex_vs_rep_t_{}_{}.pdf\".format(t, scheduling) )\n  fig.clear()\n  # Energy\n  # ar_simplex_l, Energy_simplex_l = [], []\n  # for ar in numpy.linspace(0.1, ar_ub, 20):\n  #   ar_simplex_l.append(ar)\n  #   Energy_simplex_l.append(n\/ar)\n  # ar_rep_l, Energy_rep_l = [], []\n  # for ar in numpy.linspace(0.1, ar_ub_rep, 20):\n  #   ar_rep_l.append(ar)\n  #   Energy_rep_l.append(n_total_rep\/ar)\n  # plot.plot(ar_simplex_l, Energy_simplex_l, label='Simplex', color=next(dark_color), marker=next(marker), mew=mew, ms=ms, linestyle=':')\n  # plot.plot(ar_rep_l, Energy_rep_l, label='Rep', color=next(dark_color), marker=next(marker), mew=mew, ms=ms, linestyle=':')\n  # plot.legend()\n  # plot.xlabel(r'Arrival rate $\\lambda$', fontsize=12)\n  # plot.ylabel(r'Unit of energy per request', fontsize=12)\n  # plot.title(r'$t={}, \\mu={}$'.format(t, mu) )\n  # fig = plot.gcf()\n  # def_size = fig.get_size_inches()\n  # fig.set_size_inches(def_size[0]\/1., def_size[1]\/1.)\n  # fig.tight_layout()\n  # plot.savefig(\"plot_simplex_vs_rep_t_{}_energy.pdf\".format(t) )\n  # fig.clear()\n  log(WARNING, \"done; scheduling= {}, t= {}\".format(scheduling, t) )\n\ndef plot_reptoall():\n  mixed_traff, w_sys = False, True\n  t, r, k = 1, 2, 2\n  serv = \"Exp\" # \"Bern\" # \"Bern*Pareto\" # \"Pareto\" # \"Dolly\"\n  mu = 1\n  # loc, a = 1, 2\n  # U, L, p, loc, a = 1, 8, 0.2, 0.1, 1.5 # 1, 8, 0.2, 1, 3\n  U, L, p, loc, a = 1, 10, 0.3, 0.1, 1.5 # 1, 8, 0.2, 1, 3\n  # For rep-to-all\n  if serv == \"Exp\":\n    servdist_m = {'dist': serv, 'mu': mu}\n    if t == 1: ar_ub = 1.6\n    elif t == 3: ar_ub = 2.4\n    elif t == 7: ar_ub = float(1.1*reptoall_innerbound_on_ar(t, servdist_m) )\n    else: ar_ub = reptoall_innerbound_on_ar(t, servdist_m)\n  elif serv == \"Pareto\":\n    servdist_m = {'dist': serv, 'loc': loc, 'a': a}\n    ar_ub = reptoall_innerbound_on_ar(t, servdist_m)\n  elif serv == \"TPareto\":\n    servdist_m = {'dist': serv, 'l': l, 'u': u, 'a': a}\n    ar_ub = reptoall_innerbound_on_ar(t, servdist_m)\n  elif serv == \"Bern\" or serv == \"Bern*Pareto\":\n    servdist_m = {'dist': serv, 'U': U, 'L': L, 'p': p, 'loc': loc, 'a': a}\n    ar_ub = reptoall_innerbound_on_ar(t, servdist_m)\n  elif serv == \"Dolly\":\n    servdist_m = None\n    if t == 1: ar_ub = 0.28\n    elif t == 3: ar_ub = 0.4\n  log(WARNING, \"w_sys= {}, t= {}, r= {}, k= {}, servdist_m= {}, ar_ub= {}, mixed_traff= {}\".format(w_sys, t, r, k, servdist_m, ar_ub, mixed_traff) )\n  \n  ET_sm_l, ET_sim_l, ET_l, ET_lb_l = [], [], [], []\n  ET_alt_l, ET_matrixanalytic_l = [], []\n  ET_bestapprox_l, ET_betterapprox_l, ET_naiveapprox_l, ET_varkigauri_lb_l = [], [], [], []\n  ET_simbasedapprox_l = []\n  ET_sim_mixedtraff_l = []\n  \n  # All below w_sys=True\n  nf = 3\n  sim_simplex = False\n  if serv == \"Exp\":\n    if t == 1:\n      ET_sim_l= [\n        0.6775872854372559,\n        0.7909557937247363,\n        0.9486987202221493,\n        1.166209238915134,\n        1.5685720588787688,\n        2.478342315521276,\n        2.6376081306859107,\n        2.906788473547391,\n        3.263700392764921,\n        3.5974807041868426,\n        4.289127887822366,\n        4.794525358984301,\n        5.896928018871929,\n        8.099664758903687,\n        12.74155958739236]\n    elif t == 3:\n      ET_sim_l= [\n        0.4676519075931255,\n        0.5247256264186801,\n        0.6230081386991332,\n        0.775814486873029,\n        1.0207917160021767,\n        1.6244613243247372,\n        1.7481208563178903,\n        1.9667165686859327,\n        2.163968348080258,\n        2.5923594863306776,\n        3.0700378671376627,\n        3.796384731111067,\n        4.841880170965622,\n        6.610367379250164,\n        13.559429107437742]\n    else: sim_simplex = True\n  elif serv == \"Pareto\":\n    if loc == 1 and a == 2:\n      if t == 1:\n        ET_sim_l= [\n          1.5299993522735693,\n          1.7233577876041122,\n          1.8952577131712123,\n          2.2418712080584897,\n          2.853623528849504,\n          4.2208097489868,\n          4.586420599121132,\n          5.191481636572133,\n          5.6340499086639815,\n          5.9712033727746,\n          7.94309766204549,\n          9.599736059102067,\n          13.280357368839619,\n          17.20104661693977,\n          25.449711725024084]\n      elif t == 3:\n        ET_sim_l= [\n          1.3221090353539466,\n          1.4459274633541828,\n          1.6229349092564267,\n          1.9043964678064051,\n          2.4154300633936936,\n          3.6666730405584844,\n          3.9217550909479577,\n          4.256167164955279,\n          4.717366068731679,\n          5.891743883842969,\n          6.04468767433355,\n          8.073514650754076,\n          9.880581947509592,\n          15.816118977624845,\n          28.433468299774272]\n      else: sim_simplex = True\n    elif loc == 1 and a == 5:\n      if t == 3:\n        ET_sim_l= [\n          1.1276007604818075,\n          1.240550592912947,\n          1.3862061325608057,\n          1.645653757532261,\n          2.0688083303883276,\n          3.2115831386711813,\n          3.2986018954384835,\n          3.8148027478966227,\n          4.033705086448495,\n          5.448028336643181,\n          5.697392211154507,\n          9.053323168666376,\n          10.17868048265699,\n          23.644561610837382,\n          None] # 93.02644300031747\n      else: sim_simplex = True\n    else: sim_simplex = True\n  elif serv == \"Bern\":\n    if U == 1 and L == 8 and p == 0.2:\n      if t == 1:\n        # nf = 3\n        ET_sim_l= [\n          1.6376474738985423,\n          1.9851446427827089,\n          2.4840795375267626,\n          3.1829054073054217,\n          4.39332366216294,\n          7.063110373762194,\n          7.4445330550351665,\n          8.208129233744382,\n          9.309321611480481,\n          10.747520637423975,\n          12.460023568734707,\n          15.038255521201348,\n          18.778687793661728,\n          23.582209372296532,\n          36.21619587757658]\n      elif t == 3:\n        # nf = 1\n        ET_sim_l= [\n          1.1072895175117927,\n          1.2582695204803385,\n          1.4572200912301614,\n          1.8340775367273732,\n          2.4430722742069184,\n          4.053853819806121,\n          4.4494192069988605,\n          5.061922101782603,\n          5.883304533639656,\n          6.705043861319703,\n          8.307668993372534,\n          11.041651319984396,\n          17.564101468045756,\n          33.184482866801716,\n          None]\n      else: sim_simplex = True\n    else: sim_simplex = True\n  elif serv == \"Bern*Pareto\":\n    if U == 1 and L == 8 and p == 0.2 and loc == 1 and a == 3:\n      if t == 11:\n        # nf = 3\n        ET_sim_l= [\n          2.142631836594827,\n          2.5302711620514966,\n          2.941315337537391,\n          3.8773353598252345,\n          4.550420407107853,\n          6.649089020276313,\n          7.000687768519389,\n          7.681497353358071,\n          8.058275694322152,\n          9.541434770613856,\n          10.136837383356713,\n          11.027889242435874,\n          14.072462480848941,\n          18.721889173565945,\n          29.85022801496356]\n      elif t == 33:\n        pass\n      else: sim_simplex = True\n    else: sim_simplex = True\n  else: sim_simplex = True\n  \n  # Mixed traff\n  sim_simplex_mixed_traff = False\n  if mixed_traff:\n    if serv == \"Exp\":\n      if t == 1:\n        ET_sim_mixedtraff_l= [\n          0.678978501641253,\n          0.7748022818617738,\n          0.9072886738372506,\n          1.0928902616368403,\n          1.43754904360929,\n          2.0810587767368154,\n          2.266461910378062,\n          2.5977047234601125,\n          3.2441553951140985,\n          3.585616438620215,\n          4.415600179701042,\n          6.099149242270735,\n          9.786138444920114,\n          None, # 21.631079441147904\n          None]\n      elif t == 3:\n        ET_sim_mixedtraff_l= [\n          0.46217641274184773,\n          0.5249541076176077,\n          0.6065798815902482,\n          0.7193352388312126,\n          0.9238674360581351,\n          1.363955390788439,\n          1.4654931553890183,\n          1.733811055160431,\n          2.0493965738680795,\n          2.479767271681704,\n          3.065826086322138,\n          4.300842192226751,\n          8.05986376865404,\n          None, # 35.70730644518723,\n          None]\n      else:\n        sim_simplex_mixed_traff = True\n  \n  ar_l = []\n  for ar in [*numpy.linspace(0.05, 0.8*ar_ub, 5, endpoint=False), *numpy.linspace(0.8*ar_ub, ar_ub, 10) ]:\n  # for ar in numpy.linspace(0.05, ar_ub, 2):\n    ar_l.append(ar)\n    \n    p_i_l = []\n    if sim_simplex:\n      ET_sim = test_avq(nf, ar, t, r, k, serv, servdist_m, w_sys=w_sys, p_i_l=p_i_l)\n      print(\"*** ET_sim= {}\".format(ET_sim) )\n      ET_sim_l.append(ET_sim)\n      # ET_sim_l.append(None)\n    \n    # ET_simbasedapprox_l.append(ET_simplex_approx(t, ar, servdist_m, p_i_l=p_i_l)[0] )\n    # if sim_simplex_mixed_traff:\n    #   ET_sim_mixedtraff_l.append(test_avq(nf, ar, t, r, k, serv, servdist_m, w_sys=w_sys, p_i_l=p_i_l, mixed_traff=True) )\n    \n    ET_sm_l.append(ET_simplex_sm(t, ar, servdist_m) )\n    ET_lb_l.append(ET_simplex_lb(t, ar, servdist_m) )\n    if serv == \"Exp\":\n      if t == 1:\n        ET_l.append(ET_reptoall_t1(ar, mu) )\n        ET_matrixanalytic_l.append(ET_reptoall_t1_matrixanalytic(t, ar, mu) )\n      elif t == 2:\n        if w_sys:\n          ET_alt_l.append(simplex_w_two_repair__E_T(ar, mu, M=2) )\n          ET_l.append(simplex_w_two_repair__E_T(ar, mu, M=5) )\n        else:\n          ET_l.append(simplex_wo_sys_w_two_repair__E_T(ar, mu) )\n    ET_naiveapprox_l.append(ET_simplex_approx(t, ar, servdist_m, naive=True)[0] )\n    ET_betterapprox_l.append(ET_simplex_approx(t, ar, servdist_m)[0] )\n    ET_bestapprox_l.append(ET_simplex_approx(t, ar, servdist_m, incremental=True)[0] )\n    # ET_varkigauri_lb_l.append(E_T_simplex_varki_gauri_lb(t, ar, gamma, mu)[0] )\n  \n  ar_mixed_traff_l = []\n  # for ar in numpy.linspace(0.2, 0.2, 1):\n  for ar in [*numpy.linspace(0.05, 0.8*ar_ub, 5, endpoint=False), *numpy.linspace(0.8*ar_ub, 1.1*ar_ub, 10) ]:\n    ar_mixed_traff_l.append(ar)\n    if sim_simplex_mixed_traff:\n      ET_sim_mixedtraff_l.append(test_avq(nf, ar, t, r, k, serv, servdist_m, w_sys=w_sys, mixed_traff=True) )\n  \n  # mew, ms = 0.1, 10\n  mew, ms = 2, 5\n  def plot_poster():\n    # for better looking plot\n    ar_approx_l = list(ar_l)\n    \n    ar = ar_ub + 0.03\n    ar_approx_l.append(ar)\n    ET_bestapprox_l.append(ET_simplex_approx(t, ar, servdist_m, incremental=True) )\n    \n    plot.plot(ar_l, ET_sim_l, label=\"FJ-FA, simulation\", marker=next(marker), zorder=1, color=next(dark_color), linestyle=':', mew=mew, ms=ms)\n    plot.plot(ar_approx_l, ET_bestapprox_l, label=\"FJ-FA, M\/G\/1 approximation\", zorder=2, marker=next(marker), color='black', linestyle=':', mew=mew, ms=ms)\n\n  def get_xs_l_ys_l(_x_l, _y_l):\n    x_l, y_l = [], []\n    for i, y in enumerate(_y_l):\n      if y is not None:\n        x_l.append(_x_l[i])\n        y_l.append(y)\n    \n    s = UnivariateSpline(x_l, y_l, s=0.001)\n    xs_l = np.linspace(min(x_l), max(x_l), 20)\n    ys_l = s(xs_l)\n    return xs_l, ys_l\n    \n  def plot_():\n    log(WARNING, \"ET_sim_l= {}\".format(pprint.pformat(ET_sim_l) ) )\n    # plot.plot(ar_l, ET_simbasedapprox_l, label=r'Sim-based approximation', marker=next(marker), zorder=1, color=next(dark_color), linestyle=':', mew=mew, ms=ms)\n    label = 'Simulation, fixed-arrivals' if mixed_traff else 'Simulation'\n\n    xs_l, ys_l = get_xs_l_ys_l(ar_l, ET_sim_l)\n    # plot.plot(ar_l, ET_sim_l, label=label, marker=next(marker), zorder=1, color=next(dark_color), linestyle=':', mew=mew, ms=ms)\n    plot.plot(xs_l, ys_l, label=label, marker=next(marker), zorder=1, color=next(dark_color), linestyle=':', mew=mew, ms=ms)\n    \n    if mixed_traff:\n      log(WARNING, \"ET_sim_mixedtraff_l= {}\".format(pprint.pformat(ET_sim_mixedtraff_l) ) )\n      plot.plot(ar_mixed_traff_l, ET_sim_mixedtraff_l, label=r'Simulation, mixed-arrivals', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n    else:\n      xs_l, ys_l = get_xs_l_ys_l(ar_l, ET_sm_l)\n      # plot.plot(ar_l, ET_sm_l, label=r'Split-Merge upper bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      plot.plot(xs_l, ys_l, label=r'Split-Merge upper bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      \n      # plot.plot(ar_l, ET_bestapprox_l, label=r'$M\/G\/1$ approximation', zorder=2, marker=next(marker), color='black', linestyle=':', mew=mew, ms=ms)\n      xs_l, ys_l = get_xs_l_ys_l(ar_l, ET_lb_l)\n      # plot.plot(ar_l, ET_lb_l, label=r'Fast-Split-Merge lower bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      plot.plot(xs_l, ys_l, label=r'Fast-Split-Merge lower bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      if t == 1:\n        xs_l, ys_l = get_xs_l_ys_l(ar_l, ET_matrixanalytic_l)\n        # plot.plot(ar_l, ET_matrixanalytic_l, label=r'Matrix-analytic upper-bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n        plot.plot(xs_l, ys_l, label=r'Matrix-analytic upper-bound', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n\n        xs_l, ys_l = get_xs_l_ys_l(ar_l, ET_l)\n        # plot.plot(ar_l, ET_l, label=r'High-traffic approximation', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n        plot.plot(xs_l, ys_l, label=r'High-traffic approximation', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      # plot.plot(ar_l, ET_naiveapprox_l, label=r'Straightforward approximation', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      # plot.plot(ar_l, ET_betterapprox_l, label=r'Better approximation', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew, ms=ms)\n      # plot.plot(ar_l, ET_bestapprox_l, label=r'Fine-grained approximation', zorder=2, marker=next(marker), color='black', linestyle=':', mew=mew, ms=ms)\n      # plot.plot(ar_l, ET_varkigauri_lb_l, label=r'$E[\\hat{T}_{fast-serial}]$', color=next(dark_color), marker=next(marker), linestyle=':', mew=mew)\n    # stab_lim = ET_simplex_approx(t, ar, servdist_m, incremental=True, ar_ub=True)\n    # plot.axvline(stab_lim, label=\"Stability limit\", color='black', linestyle='--')\n    # plot.gca().set_xlim([0, stab_lim+0.1] )\n  \n  def plot_selectone():\n    ar_ub = 0.9*arub_simplex_selectone(t, serv, servdist_m)\n    log(WARNING, \"ar_ub={}\".format(ar_ub) )\n    ar_l, ET_l = [], []\n    for ar in numpy.linspace(0.05, ar_ub, 50):\n    # for ar in numpy.linspace(0.05, ar_ub, 2):\n      ar_l.append(ar)\n      # if sim:\n      #   ET_l.append(test_avq(nf, ar, t, r, k, serv, servdist_m, w_sys=w_sys, sching=\"select-one\") )\n      ET_l.append(ET_selectone(t, ar, mu) )\n    # log(WARNING, \"ET_l= {}\".format(pprint.pformat(ET_l) ) )\n    plot.plot(ar_l, ET_l, 'b', label=r'Select-one', linestyle='--', lw=3, mew=mew, ms=ms)\n  # plot_poster()\n  plot_()\n  \n  # plot.plot(ar_l, ET_sim_l, 'k', label=r'Replicate-to-all', linestyle='-', lw=3)\n  # plot_selectone()\n  fontsize = 16\n  plot.yscale('log')\n  plot.legend(loc='upper left', fontsize=13, framealpha=0.25)\n  plot.xlabel(r'Arrival rate $\\lambda$', fontsize=fontsize)\n  plot.ylabel(r'Average download time', fontsize=fontsize)\n  serv_in_latex = None\n  if serv == \"Exp\":\n    serv_in_latex = '\\mathrm{Exp}' + r'(\\mu={})'.format(mu)\n  elif serv == \"Pareto\":\n    serv_in_latex = r'Pareto(s={}, \\alpha={})'.format(loc, a)\n  elif serv == \"Bern\":\n    serv_in_latex = r'Bernoulli(U={}, L={}, p={})'.format(U, L, p)\n  elif serv == \"Dolly\":\n    serv_in_latex = r'Dolly'\n  plot.title(r'FJ-FA with $r= {}$, $t= {}$, $\\mu= {}$'.format(r, t, mu), fontsize=fontsize)\n  # plot.title(r'$t={}$, Servers $\\sim {}$'.format(t, serv_in_latex) )\n  fig = plot.gcf()\n  fig.set_size_inches(6, 4)\n  fig.tight_layout()\n  plot.savefig(\"plot_FJFA_r{}_t{}.pdf\".format(r, t) )\n  log(WARNING, \"done; t= {}, r= {}, k= {}\".format(t, r, k) )\n\ndef get_opts(argv):\n  opt_map = {}\n  try:\n    opts, args = getopt.getopt(argv, '', ['num_q='] )\n  except getopt.GetoptError:\n    log(ERROR, \"Unexpected command line arg, expecting: exp.py --num_q=<>\")\n    sys.exit(1)\n  \n  for opt, arg in opts:\n    opt_map[opt] = arg\n  return opt_map\n\nif __name__ == \"__main__\":\n  # opt_map = get_opts(sys.argv[1:] )\n  # log(WARNING, \"opt_map= {}\".format(pprint.pformat(opt_map) ) )\n  # num_q = int(opt_map[\"--num_q\"] )\n  \n  # plot_winning_freqs()\n  plot_reptoall()\n  # plot_simplex_vs_rep()\n  \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_163","text":"<reponame>Fuligor\/Uczenie-sie-rekonstrukcji-rozdzielczosci-obrazow-za-pomoca-sieci-glebokich<gh_stars>0\nimport numpy as np\nfrom scipy import signal\nfrom PIL import Image\n\ndef resample(hr_image):\n    return hr_image[range(0, hr_image.shape[0], 2)][:, range(0, hr_image.shape[1], 2)]\n\ndef downsample(hr_image, kernel):\n    temp = np.zeros_like(hr_image)\n\n    for i in range(temp.shape[2]):\n        temp[:, :, i] = signal.convolve2d(hr_image[:, :, i], kernel, mode=\"same\", boundary=\"symm\")\n        \n    if temp.dtype != np.uint8:\n        temp = (temp * 255).astype(np.uint8)\n        \n    temp = Image.fromarray(temp, mode='RGB')\n\n    size = (hr_image.shape[1]\/\/2, hr_image.shape[0]\/\/2)\n    lr_image = temp.resize(size=size, resample=Image.BOX)\n    lr_image = lr_image.resize(size=(hr_image.shape[1], hr_image.shape[0]), resample=Image.NEAREST)\n\n    return (np.array(lr_image) \/ 255).astype(np.float32)\n\n\ndef create_image_patches(image, patch_size, step):\n    patches = []\n\n    for i in range(0, image.shape[0] - patch_size[0], step):\n        for j in range(0, image.shape[1] - patch_size[1], step):\n            patch = image[i:i+patch_size[0], j:j+patch_size[1]]\n\n            patches.append(patch)\n\n    return patches\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_164","text":"<reponame>guanyilun\/cosmo-codes<filename>cosmoslib\/aps\/ps.py\n\"\"\"Reusable functions related to camb and power spectrum calculation\n\nThis module collects some reusable functions that I used when working\nwith camb, power spectrum and covariance matrix\n\"\"\"\n\nimport numpy as np\nfrom scipy import interpolate\nimport healpy as hp\nimport pickle\nfrom functools import reduce\nimport operator\n\n\nclass PS:\n    \"\"\"A container for CMB power spectrum.\"\"\"\n    def __init__(self, arg=None, order=('ell','TT','EE','BB','TE'), prefactor=False, verbose=False):\n        \"\"\"Simple power spectrum data wrapper\n\n        Args:\n            arg (str or ndarray): input data, can be a string to a file to load or\n                an np.ndarray that contains the power spectrum. The array has to have\n                a shape like [n_ell, n_spec].\n            order (tuple(str)): order of columns in the input ps. Follow the naming\n                convention like ell,TT,EE,BB,TE which is default\n            prefactor (bool): whether input array has l(l+1)\/2\\pi prefactor included\n        \"\"\"\n        self.ps = {}\n        self.order=order\n        self.prefactor=prefactor\n        self.verbose=False\n        # populate ps depending on the inputs\n        if type(arg) == str:\n            self.load_file(arg, order, prefactor)\n        elif type(arg) == np.ndarray:\n            self.load_arr(arg, order, prefactor)\n\n    def __getattr__(self, key):\n        if key in self.ps:\n            return self.ps[key]\n        return self.__dict__[key]\n\n    def load_arr(self, arr, order=('ell','TT','EE','BB','TE'), prefactor=True):\n        \"\"\"Load data from a given array\"\"\"\n        if arr.shape[-1] != len(order):\n            # see if we are missing ells\n            if arr.shape[-1] == len(order)-1:\n                print(\"Didn't find ell, generating based on the shape now...\")\n                ell = np.arange(arr.shape[0])\n                arr = np.pad(arr, ((0,0),(1,0)))\n                arr[:,0] = ell\n            else:\n                raise ValueError(\"provided order doesn't match the input array!\")\n        # now populate fields\n        self.order = order\n        for i,c in enumerate(order):\n            self.ps[c] = arr[:,i]\n        # by default keep the unprefactored version\n        self.prefactor = prefactor\n        if prefactor:\n            return self.remove_prefactor()\n        else:\n            return self\n\n    def load_file(self, infile, order=('ell','TT','EE','BB','TE'), prefactor=True):\n        \"\"\"load ps from a given file, will be read using np.readtxt\"\"\"\n        data = np.loadtxt(infile)\n        return self.load_arr(data, order, prefactor)\n\n    def __repr__(self):\n        order = str(self.order).replace(' ','')\n        return f\"PS(lmin={int(self.lmin)},lmax={int(self.lmax)},prefactor={self.prefactor},order={order})\"\n\n    def __add__(self, other):\n        if not issubclass(type(other), PS):\n            raise NotImplementedError(\"Currently only support PS type ops!\")\n        # check for ell mismatch\n        if np.any(self.ell != other.ell):\n            if self.verbose:\n                print(\"Warning: ells mismatch, interpolating...\")\n            return self.resample(other.ell) + other.resample(self.ell)\n        # find common specs\n        new_order = ['ell'] + [s for s in self.specs if s in other.specs]\n        if len(new_order) < 2: raise ValueError(\"No common specs!\")\n        if self.prefactor != other.prefactor:\n            # if prefactor mismatch, add prefactor to both of them\n            self.remove_prefactor()\n            other.remove_prefactor()\n        new_ps = PS(order=new_order, prefactor=self.prefactor)\n        assert np.all(self.ell == other.ell)\n        new_ps.ps['ell'] = self.ell\n        for s in new_ps.specs:\n            new_ps.ps[s] = self.ps[s] + other.ps[s]\n        return new_ps\n\n    def __sub__(self, other):\n        if not issubclass(type(other), PS):\n            raise NotImplementedError(\"Currently only support PS type ops!\")\n        # check for ell mismatch\n        if np.any(self.ell != other.ell):\n            if self.verbose:\n                print(\"Warning: ells mismatch, interpolating...\")\n            return self.resample(other.ell) - other.resample(self.ell)\n        # find common specs\n        new_order = ['ell'] + [s for s in self.specs if s in other.specs]\n        if len(new_order) < 2: raise ValueError(\"No common specs!\")\n        if self.prefactor != other.prefactor:\n            # if prefactor mismatch, add prefactor to both of them\n            self.remove_prefactor()\n            other.remove_prefactor()\n        new_ps = PS(order=new_order, prefactor=self.prefactor)\n        new_ps.ps['ell'] = self.ell\n        for s in new_ps.specs:\n            new_ps.ps[s] = self.ps[s] - other.ps[s]\n        return new_ps\n\n    def __mul__(self, other):\n        if issubclass(type(other), PS):\n            raise NotImplementedError(\"Currently only support number ops!\")\n        new_ps = PS(order=self.order, prefactor=self.prefactor)\n        new_ps.ps['ell'] = self.ell\n        for s in self.specs:\n            new_ps.ps[s] = self.ps[s] * other\n        return new_ps\n\n    def __rmul__(self, other):\n        return self.__mul__(other)\n\n    def __truediv__(self, other):\n        if issubclass(type(other), PS):\n            raise NotImplementedError(\"Currently only support number ops!\")\n        new_ps = PS(order=self.order, prefactor=self.prefactor)\n        new_ps.ps['ell'] = self.ell\n        for s in self.specs:\n            new_ps.ps[s] = self.ps[s] \/ other\n        return new_ps\n\n    def __getitem__(self, field):\n        if field not in self.order:\n            raise ValueError(f\"{field} not found!\")\n        return self.ps[field]\n\n    @classmethod\n    def from_arr(cls, arr, order=('ell','TT','EE','BB','TE'), prefactor=True):\n        return cls(arr, order, prefactor)\n\n    @property\n    def lmin(self):\n        return self.ps['ell'].min()\n\n    @property\n    def lmax(self):\n        return self.ps['ell'].max()\n\n    @property\n    def ell(self):\n        return self.ps['ell']\n\n    @property\n    def specs(self):\n        return [o for o in self.order if o != 'ell']\n\n    @property\n    def values(self):\n        # made sure ell starts from index 0\n        return np.vstack([self.ps[s] for s in self.order]).T\n\n    @property\n    def shape(self):\n        return self.values.shape\n\n    def add_prefactor(self, inplace=True):\n        if self.prefactor: return self\n        if inplace:\n            ell = self.ell\n            for c in self.specs:\n                self.ps[c] *= (ell+1)*ell\/(2*np.pi)\n            self.prefactor = True\n            return self\n        else:\n            return PS(self.values,self.order,prefactor=False).add_prefactor()\n\n    def remove_prefactor(self, inplace=True):\n        if not self.prefactor: return self\n        if inplace:\n            ell = self.ell\n            for c in self.specs:\n                self.ps[c] *= 2*np.pi\/(ell*(ell+1))\n            self.prefactor = False\n            return self\n        else:\n            return PS(self.values,self.order,prefactor=True).remove_refactor()\n\n    def resample(self, new_ell, **kwargs):\n        ell = self.ell\n        # make sure we are within interpolation range\n        m = np.logical_and(new_ell<=self.lmax,new_ell>=self.lmin)\n        # create a new ps object\n        new_ps = PS(order=self.order,prefactor=self.prefactor)\n        new_ps.ps['ell'] = new_ell[m]\n        for s in self.specs:\n            new_ps.ps[s] = interpolate.interp1d(ell,self.ps[s],**kwargs)(new_ell[m])\n        return new_ps\n\n    def plot(self, fmt=\"-\", name='C_\\ell', axes=None, ncol=2, figsize=(12,9),\n             legend=False, legend_below=True, anchor=(0.6,-0.2), filename=None, \n             prefactor=True, logx=True, logy=True, show_cov=False, loc='best',\n             cov=None, xlim=[], ylim=[], show_abs=True, tight=True, **kwargs):\n        \"\"\"Plot the power spectra\"\"\"\n        import matplotlib.pyplot as plt\n        ell = self.ell\n        nrow = int(np.ceil(len(self.specs)\/ncol))\n        if not np.any(axes):\n            fig, axes = plt.subplots(nrow, ncol,figsize=figsize)\n        for i,s in enumerate(self.specs):\n            spec = self.ps[s]\n            ax = axes[i\/\/ncol,i%ncol]\n            if prefactor:\n                spec_name = r'$\\ell(\\ell+1)%s^{\\rm %s}\/2\\pi$' % (name, s)\n            else:\n                spec_name = r'$%s^{\\rm %s}$' % (name, s)\n            if show_abs:\n                spec = np.abs(spec)\n            if prefactor and not self.prefactor:\n                spec = spec*ell*(ell+1)\/2\/np.pi\n            elif not prefactor and self.prefactor:\n                spec = spec*2*np.pi\/ell\/(ell+1)\n            if show_cov:\n                assert isinstance(cov, Covmat), \"covmat not provided or invalid\"\n                assert np.allclose(cov.ell, ell), 'ell mismatch in cov'\n                yerr = np.sqrt(cov[f'{s}{s}'])\n                if prefactor and not self.prefactor:\n                    yerr *= ell*(ell+1)\/2\/np.pi\n                ax.errorbar(ell, spec, yerr=yerr, fmt=fmt, **kwargs)\n            else:\n                ax.plot(ell, spec, fmt, **kwargs)\n            ax.set_xlabel(r'$\\ell$')\n            ax.set_ylabel(spec_name)\n            if logx:\n                ax.set_xscale('log')\n            if logy:\n                ax.set_yscale('log')\n            if len(xlim) == 2:\n                ax.set_xlim(xlim)\n            if len(ylim) == 2:\n                ax.set_ylim(ylim)\n            if legend and not legend_below:\n                ax.legend(loc=loc)\n        if tight: plt.tight_layout()\n        if legend and legend_below:\n            ax.legend(ncol=4, bbox_to_anchor=anchor, frameon=False)\n        if filename:\n            plt.savefig(filename, bbox_inches='tight')\n        return axes\n\n    def gen_sim(self):\n        \"\"\"Generate a sim realization of the power spectra, use internal version\"\"\"\n        # make sure we have everything we want\n        target = ['ell','TT','EE','BB','TE']\n        ok = [s for s in target if s in self.order] == target\n        if not ok:\n            raise ValueError(\"PS does not contain all of ell,TT,EE,BB,TE required\")\n        data = np.hstack([self.ps[s].reshape(-1,1) for s in target])\n        rdata = gen_ps_realization(data, self.prefactor)\n        new_ps = PS(order=target, prefactor=self.prefactor)\n        for i,s in enumerate(target): new_ps.ps[s] = rdata[:,i]\n        return new_ps\n\n    def gen_sim_hp(self):\n        \"\"\"Generate a sim realization of the power spectra, wrapped around healpy,\n        this is often 30% faster\"\"\"\n        alm = self.gen_alm_hp()\n        cl = hp.sphtfunc.alm2cl(alm)\n        ell = np.arange(cl.shape[1])\n        ps = PS(cl.T, order=('TT', 'EE', 'BB', 'TE', 'EB', 'TB'), prefactor=False)\n        ps.ps['ell'] = ell\n        ps.order += ('ell',)\n        return ps\n\n    def gen_alm_hp(self):\n        if self.prefactor:\n            self.remove_prefactor()\n        # healpy requires array starts from zero, fill will 0\n        ps = np.zeros((4,self.lmax+1))\n        ps[:,self.lmin:] = self.values[:,1:].T\n        alm = hp.synalm((ps[0],ps[1],ps[2],ps[3],np.zeros_like(ps[0]),np.zeros_like(ps[0])),\n                        lmax=self.lmax, verbose=False, new=True)\n        return alm\n\n    def gen_map(self, nside, n=1):\n        if n > 1:\n            return [self.gen_map(nside) for i in range(n)]\n        else:\n            alm = self.gen_alm_hp(nside)\n            return hp.alm2map(alm, nside)\n\n    def covmat(self, noise, f_sky=1):\n        \"\"\"get covariance matrix given a noise model\n        Args:\n            noise: noise model of PS class\n            f_sky: sky coverage fraction, 1 means full-sky coverage\n        Returns:\n            cov: a tensor of size [n_ell, n_ps, n_ps], for example with\n                 a lmax of 5000, the tensor size will be [5000, 4, 4]\n        \"\"\"\n        # assuming the beam is a gaussian beam with an ell dependent\n        # beam size\n        # ps_w_noise = self + noise\n        ps = self.resample(noise.ell)\n        ell, ClTT, ClEE, ClBB, ClTE = [ps.ps[spec]\n                                       for spec in ['ell', 'TT','EE','BB','TE']]\n        new_noise = noise.resample(ell)\n        NlTT, NlEE, NlBB, NlTE = [new_noise.ps[spec] for spec in ['TT','EE','BB','TE']]\n        # initialize empty covariance tensor. Since the covariance matrix\n        # depends on ell, we will make a higher dimensional array [n_ell,\n        # n_ps, n_ps] where the first index represents different ells, the\n        # second and third parameters represents different power spectra\n        n_ells = len(ell)\n        cov = np.zeros([n_ells, 4, 4])\n        cov[:,0,0] = 2\/(2*ell+1)*(ClTT+NlTT)**2\n        cov[:,1,1] = 2\/(2*ell+1)*(ClEE+NlEE)**2\n        cov[:,2,2] = 2\/(2*ell+1)*(ClBB+NlBB)**2\n        cov[:,3,3] = 1\/(2*ell+1)*(ClTE**2+(ClTT+NlTT)*(ClEE+NlEE))\n        cov[:,0,1] = 2\/(2*ell+1)*ClTE**2\n        cov[:,1,0] = 2\/(2*ell+1)*ClTE**2\n        cov[:,0,3] = 2\/(2*ell+1)*ClTE*(ClTT+NlTT)\n        cov[:,3,0] = 2\/(2*ell+1)*ClTE*(ClTT+NlTT)\n        cov[:,1,3] = 2\/(2*ell+1)*ClTE*(ClEE+NlEE)\n        cov[:,3,1] = 2\/(2*ell+1)*ClTE*(ClEE+NlEE)\n        # now we include the effect of partial sky coverage\n        cov \/= f_sky\n        covmat = Covmat(ell, cov)\n\n        return covmat\n\n    def save(self, filename):\n        np.savetxt(filename, self.values, comments=\",\".join(self.order))\n\n\nclass Noise(PS):\n    def __init__(self, lmin, lmax):\n        self.order = ('ell','TT','EE','BB','TE')\n        self.prefactor = False\n        ell = np.arange(lmin, lmax+1)\n        self.ps = {'ell': ell}\n\n\nclass SimpleNoise(Noise):\n    def __init__(self, nlev, fwhm, lmin, lmax):\n        super().__init__(lmin, lmax)\n        self.nlev = nlev\n        self.fwhm = fwhm\n        ell = self.ps['ell']\n        NlTT = nlev**2*np.exp(ell*(ell+1)*fwhm**2\/(8.*np.log(2)))\n        NlPP = 2*NlTT\n        self.ps.update({'TT': NlTT, 'EE': NlPP,\n                        'BB': NlPP, 'TE': np.zeros_like(ell)})\n\n\nclass Covmat:\n    \"\"\"Simple block diagonal covariance matrix\"\"\"\n    def __init__(self, ell, cov, order=('TT','EE','BB','TE')):\n        self.order = order\n        self.cov = cov\n        self.ell = ell\n    def inv(self):\n        icov = np.zeros_like(self.cov)\n        for i in range(len(self.ell)):\n            icov[i,:,:] = np.linalg.inv(self.cov[i,:,:])\n        return Covmat(self.ell, icov)\n    def save(self, filename):\n        with open(filename, 'wb') as f:\n            pickle.dump(self, f)\n    def __getitem__(self, field):\n        \"\"\"field can be of form TTTT,TTEE, etc\"\"\"\n        if len(field) !=4:\n            raise ValueError(\"Field has to be of form TTEE, TTBB, etc!\")\n        spec1 = field[:2]\n        spec2 = field[2:]\n        if (spec1 not in self.order) or (spec2 not in self.order):\n            raise ValueError(f\"{field} not found\")\n        idx1 = self.order.index(spec1)\n        idx2 = self.order.index(spec2)\n        return self.cov[:,idx1,idx2]\n\n    @classmethod\n    def from_file(cls, filename):\n        with open(filename, \"rb\") as f:\n            try: return pickle.load(f)\n            except UnicodeDecodeError:\n                return pickle.load(f, encoding='latin1')\n\n\ndef _check_ps(ps):\n    \"\"\"Check the type of power spectra\"\"\"\n    # if ps is a 2D array\n    if len(ps.shape)>1:\n        # if ps has five columns -> tensor-like\n        if ps.shape[-1] == 5:\n            return \"TENSOR\"\n        # if ps has four columns -> scaler-like\n        elif ps.shape[-1] == 4:\n            return \"SCALER\"\n        # not sure what's inside\n        else:\n            return None\n    else:\n        raise ValueError\n\ndef add_prefactor(ps):\n    \"\"\"Add the l(l+1)\/2\\pi prefactor in a power spectrum\"\"\"\n    # check the dimension of power spectra\n    ells = ps[:, 0]\n    for i in range(1,ps.shape[1]):\n        ps[:,i] \/= 2*np.pi\/(ells*(ells+1))\n    return ps\n\ndef remove_prefactor(ps):\n    \"\"\"Remove the l(l+1)\/2\\pi prefactor in a power spectrum\"\"\"\n    ells = ps[:, 0]\n    for i in range(1,ps.shape[1]):\n        ps[:,i] *= 2*np.pi\/(ells*(ells+1))\n    return ps\n\ndef resample(ps, ell):\n    ell_old = ps[:, 0]\n\n    # interpolate into the theory,\n    tt_old = ps[:, 1]\n    ee_old = ps[:, 2]\n    bb_old = ps[:, 3]\n    te_old = ps[:, 4]\n\n    tt_predicted = interpolate.interp1d(ell_old, tt_old)(ell)\n    te_predicted = interpolate.interp1d(ell_old, te_old)(ell)\n    ee_predicted = interpolate.interp1d(ell_old, ee_old)(ell)\n    bb_predicted = interpolate.interp1d(ell_old, bb_old)(ell)\n\n    cl_predicted = np.stack([ell, tt_predicted, ee_predicted, bb_predicted, te_predicted], axis=1)\n\n    return cl_predicted\n\ndef join_noise_models(noise_models, method='min'):\n    \"\"\"join multiple noise models by a given method. Currently\n    only method that works is the min, which means choose the\n    noise_models with minimum noise in each ell.\n\n    Args:\n        noise_models: list of noise models\n        method: method used to combine\n    Returns:\n        A new noise model with the noise models combined\n    \"\"\"\n    # find lmin, lmax\n    lmin = min(nm.lmin for nm in noise_models)\n    lmax = max(nm.lmax for nm in noise_models)\n    # placeholder to find corresponding ells\n    ell = np.arange(0, lmax+1)\n    noise = Noise(lmin, lmax)\n    for spec in ['TT','EE','BB','TE']:\n        # place holder to find min noise\n        cl = np.zeros_like(ell).astype('float64')\n        for nm in noise_models:\n            nm_ell = nm.ell.astype(int)\n            mask = np.logical_or(nm[spec]<cl[nm_ell], cl[nm_ell]==0)\n            orig_mask = np.zeros_like(ell).astype(bool)\n            orig_mask[nm_ell] = mask\n            idx = np.where(orig_mask)[0]\n            cl[idx] = nm[spec][mask]\n        noise.ps[spec] = cl[noise.ell]\n    return noise\n\ndef Dl2Cl(ps, inplace=False):\n    \"\"\"Add the l(l+1)\/2\\pi prefactor in a power spectrum\"\"\"\n    # check the dimension of power spectra\n    ells = ps[:, 0]\n    if not inplace:\n        new_ps = ps.copy()\n    else:\n        new_ps = ps\n    for i in range(1,ps.shape[1]):\n        new_ps[:,i] \/= 2*np.pi\/(ells*(ells+1))\n    return new_ps\n\ndef Cl2Dl(ps, inplace=False):\n    \"\"\"Remove the l(l+1)\/2\\pi prefactor in a power spectrum\"\"\"\n    ells = ps[:, 0]\n    if not inplace:\n        new_ps = ps.copy()\n    else:\n        new_ps = ps\n    for i in range(1,ps.shape[1]):\n        new_ps[:,i] *= 2*np.pi\/(ells*(ells+1))\n    return new_ps\n\n\ndef gen_ps_realization(ps, prefactor=True):\n    \"\"\"Generate a random power spectra realization\n\n    Args:\n        ps: power spectra\n        prefactor: true if ps is Dl\n\n    Returns:\n        ps realization: consistent with prefactor choice\n    \"\"\"\n    # first make a copy to make sure we don't affect the original\n    if prefactor:\n        ps = Dl2Cl(ps, inplace=False)\n    ells, ClTT, ClEE, ClBB, ClTE = ps[:,0], ps[:,1], ps[:,2], ps[:,3], ps[:,4]\n\n    # define empty arrays to hold the generated power spectra\n    m_ps = np.zeros_like(ps)\n    m_ps[:,0] = ells\n\n    # this is certainly slow, but i don't need to run this very often\n    # so it's fine to leave it like this. in principle i don't need to\n    # keep all the negative part as well. These can be improved if\n    # performance becomes an issue\n    for i in range(len(ells)):\n        l = int(ells[i])\n        # generate gaussian random complex numbers with unit variance\n        zeta1 = (np.random.randn(l+1)+1j*np.random.randn(l+1))\/np.sqrt(2)\n        zeta2 = (np.random.randn(l+1)+1j*np.random.randn(l+1))\/np.sqrt(2)\n        zeta3 = (np.random.randn(l+1)+1j*np.random.randn(l+1))\/np.sqrt(2)\n\n        # for m=0, zeta has to be real\n        zeta1[0] = np.abs(zeta1[0])\n        zeta2[0] = np.abs(zeta2[0])\n        zeta3[0] = np.abs(zeta3[0])\n\n        # generate alm\n        aTlm = zeta1 * ClTT[i]**0.5\n        aElm = zeta1 * ClTE[i] \/ (ClTT[i])**0.5 + zeta2*(ClEE[i] - ClTE[i]**2\/ClTT[i])**0.5\n        aBlm = zeta3 * ClBB[i]**0.5\n\n        i_ClTT = np.real((aTlm[0]**2 + 2*(np.sum(np.abs(aTlm[1:])**2)))\/(2*l+1))\n        i_ClEE = np.real((aElm[0]**2 + 2*(np.sum(np.abs(aElm[1:])**2)))\/(2*l+1))\n        i_ClBB = np.real((aBlm[0]**2 + 2*(np.sum(np.abs(aBlm[1:])**2)))\/(2*l+1))\n        i_ClTE = np.real((aTlm[0]*aElm[0] + 2*(np.sum(np.conj(aTlm[1:])*aElm[1:])))\/(2*l+1))\n\n        # assign the new values to the new array\n        m_ps[i,1] = i_ClTT\n        m_ps[i,2] = i_ClEE\n        m_ps[i,3] = i_ClBB\n        m_ps[i,4] = i_ClTE\n\n    if prefactor:\n        return Cl2Dl(m_ps, inplace=True)\n    else:\n        return m_ps\n\n\ndef fisher_matrix(model, cov, ratio=0.01):\n    \"\"\"Estimate the fisher matrix near the model provided.\n\n    Args:\n        model: a python dictionary that contains the cosmological\n        parameters that one is interested in estimating the fisher\n        matrix between them (fiducial model)\n\n        cov: the covariance matrix between the power spectra\n\n        ratio: the ratio of the parameter to vary. This is because fisher\n        matrix calculation involves differenciating the power spectra\n        with respect to the parameters given. To estimate the derivatives\n        one needs a small variation near the best fit value. This ratio\n        characterize how much variation is needed.\n\n    Returns:\n        alpha: fisher matrix\n        params: a list of the parameters corresponding to each index\n    \"\"\"\n    # first we need to generate multiple models near the best fit model\n    # we will generate four models for each parameter, so in total the\n    # underlying CAMB is called n_par * 4 times. First we create an empty\n    # list to hold our derivatives. Each element in dCldp will correspond\n    # to the derivative of the corresponding parameter in parameters list\n    params = [key for key in model.keys()]\n    n_params = len(params)\n    dCldp = []\n\n    for p in params:\n        # generate four models by tweaking parameters\n        new_model_m1 = model.copy()\n        new_model_m2 = model.copy()\n        new_model_p1 = model.copy()\n        new_model_p2 = model.copy()\n\n        # step size\n        h = model[p]*ratio\n\n        new_model_m2[p] = model[p] - h\n        new_model_m1[p] = model[p] - 0.5*h\n        new_model_p1[p] = model[p] + 0.5*h\n        new_model_p2[p] = model[p] + h\n\n        # generate four sets of parameters\n        pars_m1 = generate_camb_params(**new_model_m1)\n        pars_m2 = generate_camb_params(**new_model_m2)\n        pars_p1 = generate_camb_params(**new_model_p1)\n        pars_p2 = generate_camb_params(**new_model_p2)\n\n        # get power spectra for both models\n        ClTT_m1, ClEE_m1, ClBB_m1, ClTE_m1 = generate_cmb_power_spectra(pars_m1)\n        ClTT_m2, ClEE_m2, ClBB_m2, ClTE_m2 = generate_cmb_power_spectra(pars_m2)\n        ClTT_p1, ClEE_p1, ClBB_p1, ClTE_p1 = generate_cmb_power_spectra(pars_p1)\n        ClTT_p2, ClEE_p2, ClBB_p2, ClTE_p2 = generate_cmb_power_spectra(pars_p2)\n\n        # calculate differenciations to p\n        dClTTdp = (4.0\/3.0 * (ClTT_p1-ClTT_m1) -1.0\/6.0 * (ClTT_p2 - ClTT_m2)) \/ h\n        dClEEdp = (4.0\/3.0 * (ClEE_p1-ClEE_m1) -1.0\/6.0 * (ClEE_p2 - ClEE_m2)) \/ h\n        dClBBdp = (4.0\/3.0 * (ClBB_p1-ClBB_m1) -1.0\/6.0 * (ClBB_p2 - ClBB_m2)) \/ h\n        dClTEdp = (4.0\/3.0 * (ClTE_p1-ClTE_m1) -1.0\/6.0 * (ClTE_p2 - ClTE_m2)) \/ h\n\n        dCldp.append(np.vstack([dClTTdp, dClEEdp, dClBBdp, dClTEdp]))\n\n    # now that the derivatives are calculated, we are ready to calculate the\n    # fisher matrix alpha.\n    # TODO: This calculation can perhaps be optimized\n    alpha = np.zeros([n_params, n_params])\n    n_ell = cov.shape[0]\n    for i in range(n_params):\n        for j in range(n_params):\n            for l in np.arange(n_ell):\n                alpha[i,j] += np.einsum('i,ij,j', dCldp[i][:,l], np.linalg.inv(cov[l,:,:]), dCldp[j][:,l])\n\n    return alpha, params\n\n\ndef combine_noise_models(noises):\n    \"\"\"Combine noise from multiple frequencies using inverse average, adapted\n    from astropaint\n\n    Parameters\n    ----------\n    noises: list of noise objects\n\n    Returns\n    -------\n    noise object with combined noise power spectrum\n    1\/N_tot = 1\/N1 + 1\/N2 + ...\n\n    \"\"\"\n    assert isinstance(Nls, (list,Noise))\n    # find a dummy noise object by adding them, we simply\n    # use this to get the ell interpolation to work\n    combined = reduce(operator.add, noises)\n    for spec in combined.specs:\n        combined.ps[spec] = np.sum([1\/n.resample(combined.ell).ps[spec]\n                                    for n in noises])**-1\n    return combined\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_165","text":"\n# Standard Library imports\nimport arrow\nfrom datetime import datetime\nfrom itertools import cycle\nimport pandas as pd\nimport numpy as np\nfrom pprint import pprint as pp\nimport statistics\nimport sys\nimport time\nimport traceback\nimport warnings\nimport logging\nwarnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)\n\n# Third party imports\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as ticker\nimport matplotlib.dates as dates\n\n#Bokeh imports\nfrom bokeh.io import push_notebook, show, output_notebook\nfrom bokeh.plotting import figure, output_file, show as bokeh_show\nfrom bokeh.models import LinearAxis, Range1d, DataRange1d, HoverTool\nfrom bokeh.core.validation import check_integrity\nfrom bokeh.layouts import column, row, gridplot, layout\nfrom bokeh.models import ColumnDataSource, Div, Span, CustomJS\n\n# Load Application imports\nfrom dmyplant2.dReliability import demonstrated_reliability_sr\nimport dmyplant2\n\ndef cvset(mp, dset):\n    vset = [d for col in [rec['col'] for rec in dset] for d in col]\n    di = mp.get_dataitems()\n    vset = [d for d in vset if not di.loc[di.name.str.fullmatch(d)].empty]\n    return vset\n\ndef cplotdef(mp, lfigures):\n    for f in lfigures:\n        #print(f, end=', ')\n        plotdef = list(lfigures.keys())\n        vset = []\n        for p in plotdef:\n            dset = lfigures[p]\n            vset += cvset(mp, dset)\n        vset = list(set(vset))\n    return plotdef, vset\n\ndef equal_adjust(dset, ddata, do_not_adjust=[], debug=False, qmin=0.02, qmax=0.95, minfactor=0.9, maxfactor=1.1):\n\n    def debug_dset(dset):\n        for row in dset:\n            print(f\"{str(row['col']):40} {row['ylim'] if 'ylim' in row else 'no ylim'}\")\n\n    data = ddata.fillna(0)\n    vset = [d for col in [rec['col'] for rec in dset] for d in col]\n    do_not_adjust = [x if type(x)==int else vset.index(x) for x in do_not_adjust]\n    num_axes = len(dset) - len(do_not_adjust)\n    dncm = [len(dset) + d for d in do_not_adjust if  d < 0]\n    dncp = [d for d in do_not_adjust if  d >= 0]\n    dnc = dncm + dncp\n    if debug:\n        print(f\"nuber of data columns: {len(dset)}, number of axes:{num_axes}, Rows excluded from adjustement:{dnc}\")\n    k = 0\n    for i, ax in enumerate(dset):\n        if not i in dnc:\n            for j, d in enumerate(ax['col']):\n                lmin = data[d].quantile(q=qmin) if j==0 else min(lmin, data[d].quantile(q=qmin))\n                lmax = data[d].quantile(q=qmax) if j==0 else max(lmax, data[d].quantile(q=qmax))\n                lmin = minfactor * lmin if lmin > 0.0 else maxfactor * lmin\n                lmax = minfactor * lmax if lmax < 0.0 else maxfactor * lmax \n                if debug:\n                    print(f\"{i} {d:20} min={lmin:8.2f}, max={lmax:8.2f}\")\n                smax = k*(lmax - lmin) + lmax\n                smin = lmin - (num_axes - (k + 1))*(lmax - lmin)\n                if (smax - smin) < 1.0:\n                    smin = smin - 5.0 - k; smax = smax + 5.0 - k\n                ax['ylim'] = (smin, smax)\n            k += 1\n    if debug:\n        print(\"\\nCalculated Axes:\")\n        debug_dset(dset)\n    return dset\n\ndef count_columns(dset):\n    cnt = 0\n    for c in dset:\n        cnt += len(c['col'])\n    return cnt\n\ndef _idx(n, s, e, x):\n    return int(n * (x - s) \/ (e - s)+1)\n\ndef add_vlines(lines, ax, *args, **kwargs):\n    for l in lines:\n        ax.axvline(l, *args, **kwargs)\n\ndef add_dbokeh_vlines(lines, fig, *args, **kwargs):\n    for l in lines:\n        fig.add_layout(Span(location=l,dimension='height', *args, **kwargs))   \n\ndef add_dbokeh_hlines(lines, fig, *args, **kwargs):\n    for l in lines:\n        fig.add_layout(Span(location=l,dimension='width', *args, **kwargs))   \n\ndef add_table(summary, ax, *args, **kwargs):\n    \"\"\"\n    available options for loc:\n    best, upper right, upper left, lower left, lower right, center left, center right\n    lower center, upper center, center, top right,top left, bottom left, bottom right\n    right, left, top, bottom\n    \"\"\"\n    ax.table(\n        cellText=summary.values, \n        colWidths=[0.1]*len(summary.columns),\n        colLabels=summary.columns,\n        cellLoc='center', \n        rowLoc='center',\n        *args, **kwargs)\n        #loc='upper left')\n\ndef _plot(idf, x12='datetime', y1 = ['Various_Values_SpeedAct'], y2 = ['Power_PowerAct'], ylim2=(0,5000), *args, **kwargs):\n    ax = idf[[x12] + y1].plot(\n    x=x12,\n    y=y1,\n    kind='line',\n    grid=True, \n    *args, **kwargs)\n\n    ax2 = idf[[x12] + y2].plot(\n    x=x12,\n    y=y2,\n    secondary_y = True,\n    ax = ax,\n    kind='line', \n    grid=True, \n    *args, **kwargs)\n\n    ax2.set_ylim(ylim2)\n    return ax, ax2, idf\n\ndef dbokeh_chart(source, pltcfg, x='datetime', x_ax_unit=None, title=None, grid=True, legend=True, style='line', x_range=None, y_range=None, notebook=True, figsize=(8,6), *args, **kwargs):\n    \"\"\"wrapper function for bokeh_chart from Johannes\"\"\" \n    if notebook: output_notebook(hide_banner=True)\n    if title: title = str(title)\n    for col in pltcfg: \n        if not 'unit' in col: col['unit'] = ''\n    source = ColumnDataSource(source)   \n    fig = bokeh_chart(source, pltcfg, x, x_ax_unit, title, grid, legend, style, x_range, y_range, figsize, *args, **kwargs)\n    return fig\n\ndef bokeh_chart(source, pltcfg, x_ax='datetime', x_ax_unit=None, title=None, grid=True, legend=True, style='line', x_range=None, y_range=None, figsize=(8,6), *args, **kwargs):\n    \"\"\"Generate interactive Diane like chart with multiple axes\n\n    Args:\n        source (bokeh.ColumnDataSource): Data , e.g downloaded by engine.batch_hist_dataItems(...)\n        pltcfg ([list of dicts]): the source columns to plot, and range of y-axis\n        x_ax (str, optional): x-axis column as string. Defaults to 'datetime'.\n        x_ax_unit (str, optional): unit of x-axis as string. Defaults to None.\n        title (str, optional): Main Title of figure. Defaults to None.\n        grid (bool, optional): display grid. Defaults to True.\n        legend (bool, optional): legend. Defaults to True.  \n        style (str, optional): style of markers, options i.e. 'line', 'circle'\n            circle necessary to enable linked brushing (selection of datapoints)\n        x_range (bokeh.figure.x_range, optional): x_range of different bokeh-plot; used to connect x-axis limits\n        y_range (bokeh.figure.y_range, optional): y_range of different bokeh-plot; used to connect y-axis limits\n\n\n    Returns:\n        bokeh.plotting.figure: Bokeh plot ready to plot or embed in a layout\n\n    example:\n    .....\n    from bokeh.io import push_notebook, show, output_notebook\n    from bokeh.plotting import figure, output_file, show\n    from bokeh.models import LinearAxis, Range1d, HoverTool\n    from bokeh.layouts import column, row, gridplot\n    from bokeh.models import ColumnDataSource\n    from itertools import cycle\n    import dmyplant2\n    import arrow\n\n    import pandas as pd\n    import numpy as np\n    import traceback\n    import matplotlib\n    import sys\n    import warnings\n    \n\n    dmyplant2.cred()\n    mp = dmyplant2.MyPlant(0)\n\n    # Version mittels Validation Instance \n    dval = dmyplant2.Validation.load_def_csv('input.csv')\n    vl = dmyplant2.Validation(mp, dval, cui_log=True)\n    e = vl.eng_serialNumber(1145166)\n\n    print(f\"{e} {e.id}\")\n    pltcfg=[]\n    pltcfg.append( [\n        {'col': ['Knock integrator cyl. 07']},\n        {'col': ['Ignition voltage cyl. 07']},\n        {'col': ['ITP cyl. 07']},\n        {'col': ['Exhaust temperature cyl. 07']},\n        {'col': ['Operating hours engine']}\n    ])\n\n    datastr=[]\n    for cfg in pltcfg:\n        for y in cfg:\n            datastr += y['col']\n\n    ans=datastr_to_dict(datastr)\n    dat=ans[0]\n\n    df = mp.hist_data(\n        e.id,\n        itemIds=dat,\n        p_from=arrow.get('2021-03-05 04:00').to('Europe\/Vienna'),\n        p_to=arrow.get('2021-03-05 05:30').to('Europe\/Vienna'),\n        timeCycle=1)\n\n    output_notebook()\n\n    df.loc['2021-03-05 05:00':'2021-03-05 06:00']\n\n    title=e._info.get('Validation Engine')\n\n    source = ColumnDataSource(df)\n    output_file(title+'.html')\n    p=bokeh_chart(source, pltcfg[0], title=title)\n\n    show(p)\n    \"\"\"\n\n    dpi = 66\n    mwidth = figsize[0] * dpi\n    mheight = figsize[1] * dpi\n\n    #dataitems=pd.read_csv('data\/dataitems.csv', sep=';')\n    dataitems=dmyplant2.MyPlant.get_dataitems()\n\n    TOOLS = 'pan, box_zoom, xwheel_zoom, box_select, undo, reset, save' #select Tools to display\n    colors = cycle(matplotlib.rcParams['axes.prop_cycle']) #colors to use for plot\n    linewidth = 2\n\n    if x_ax_unit is not None: #get unit of x_axis either from user or csv-file\n        x_unit=x_ax_unit\n    else:\n        if pd.Series(x_ax).isin(dataitems.myPlantName).any():\n            x_unit=dataitems.loc[dataitems.myPlantName==x_ax].iat[0,2]\n            if x_unit is np.nan: x_unit=''\n        elif x_ax=='Operating hours validation':\n            x_unit='h'\n        else:\n            x_unit=''\n\n    x_axis_label=(f'{x_ax} [{x_unit}]')\n\n    if (x_ax == 'datetime'): #seperate constructors for object for datetime or no datetime x-axis\n        p = figure( plot_width=mwidth, plot_height=mheight, x_axis_label=None, x_axis_type='datetime',\n        x_range=x_range, y_range=y_range, tools=TOOLS)\n    else:\n        p = figure( plot_width=mwidth, plot_height=mheight, x_axis_label=x_axis_label,\n            tools=TOOLS, x_range=x_range, y_range=y_range)\n\n    if grid==False: p.grid.grid_line_color = None\n        \n    p.yaxis.visible = False\n    if x_ax=='datetime':\n        tooltips = [('Datetime', '@'+x_ax+'{%F %T}')]\n    else:\n        tooltips = [(x_ax, '@{'+x_ax +'}{0.1 f} '+x_unit)]\n    for i, y in enumerate(pltcfg):\n        to_remove=[]\n        for col in y['col']: #checks if data is available\n            #if not pd.Series(col).isin(dataitems.myPlantName).any(): ### instead of comparing with dataitems compare with source\n            if col not in source.data: ### instead of comparing with dataitems compare with source\n                to_remove.append(col)\n                logging.info(f\"{col} not found.\")\n            elif source.data[col].all() == None: #remove of columns if no measurement taken\n                to_remove.append(col)\n                logging.info(f\"{col} not available\")\n        y['col'] = [e for e in y['col'] if e not in to_remove] #remove elements not contained in dataframe by assigning new list\n        if len(y['col'])==0: #jump to next iteration if no col remaining\n            continue\n        else:\n            color = next(cycle(colors))['color']\n\n        if y.get('ylim'):\n            ylim = list(y['ylim'])\n            p.extra_y_ranges[str(i)] = Range1d(start=ylim[0], end=ylim[1])\n        else: #if no ylim defined, use automatic Bokeh Range\n            p.extra_y_ranges[str(i)] = DataRange1d()\n\n        unit=[]\n        renderers=[]\n        for ii, col in enumerate(y['col']):\n            if not pd.Series(col).isin(dataitems.myPlantName).any(): #Additional if for handling new data rows generated by function, else is normal behaviour\n                if 'unit' in y:\n                    unit.append(y['unit'])\n                else:\n                    unit.append('')\n            else: \n                unit.append(dataitems.loc[dataitems.myPlantName==col].iat[0,2])\n\n            if pd.isna(unit[-1]): \n                unit[-1]=''\n\n            if 'color' in y:\n                if isinstance(y['color'], list):\n                    color = y['color'][ii]\n                else:\n                    color = y['color']\n            else:\n                color = next(cycle(colors))['color']\n\n            # func = getattr(p, style) #to choose between different plotting styles\n            # renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n            # color=color, y_range_name=str(i), legend_label=col, line_width=linewidth))\n            if legend:\n                if style == 'line':\n                    func = getattr(p, 'line') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col,  #circle or line\n                    color=color, y_range_name=str(i), legend_label=col, line_width=linewidth))\n                if style == 'circle':\n                    func = getattr(p, 'circle') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col,  #circle or line\n                    color=color, y_range_name=str(i), legend_label=col, line_width=linewidth))\n                if style == 'both':\n                    func = getattr(p, 'line') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col,  #circle or line\n                    color=color, y_range_name=str(i), legend_label=col, line_width=linewidth))\n                    func = getattr(p, 'circle') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col,  #circle or line\n                    color=color, y_range_name=str(i), legend_label=col, line_width=linewidth))\n            else:\n                if style == 'line':\n                    func = getattr(p, 'line') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n                    color=color, y_range_name=str(i), line_width=linewidth))\n                if style == 'circle':\n                    func = getattr(p, 'circle') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col,  #circle or line\n                    color=color, y_range_name=str(i), line_width=linewidth))\n                if style == 'both':\n                    func = getattr(p, 'line') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n                    color=color, y_range_name=str(i), line_width=linewidth))\n                    func = getattr(p, 'circle') #to choose between different plotting styles\n                    renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n                    color=color, y_range_name=str(i), line_width=linewidth))\n\n            tooltips.append((col, '@{'+col +'}{0.2 f} '+unit[-1]))  # or 0.0 a\n\n        if not y.get('ylim'):  #only if y-limits not specified\n            p.extra_y_ranges[str(i)].renderers = renderers #only use axis specific renderers for calculation of limits\n\n        if len(unit)==1 or unit.count(unit[0]) == len(unit): #if only one entry or all have the same unit\n            llabel = ', '.join(y['col'])+' ['+unit[0]+']'\n        else:\n            llabel = ', '.join(y['col'])+' ['+', '.join(unit)+']'\n        \n        if len(llabel) > 90:\n                llabel = llabel[:86] + ' ...'\n        if len(y['col']) > 1:\n            color = 'black'\n        p.add_layout(LinearAxis(y_range_name=str(i),\n                            axis_label=llabel, axis_label_text_color=color), 'left')\n\n    callback = CustomJS(code='document.getElementsByClassName(\"bk-tooltip\")[0].style.backgroundColor=“transparent\";')\n    #callback = CustomJS(code='document.getElementsByClassName(\"bk-tooltip\")[0].style.backgroundColor=“rgba(255,255,255,0.2)\";')\n\n    p.add_tools(HoverTool(\n        tooltips=tooltips, \n        formatters={f'@datetime': 'datetime'}, # use 'datetime' formatter for '@date' field    \n        mode='mouse',\n        callback=callback))  # mode=vline -> display a tooltip whenever the cursor is vertically in line with a glyph\n\n    p.toolbar.active_drag = p.select_one('BoxZoomTool')\n    p.toolbar.active_scroll = p.select_one('WheelZoomTool')\n\n    p.legend.click_policy='hide' #hides graph when you click on legend, other option mute (makes them less visible)\n    p.legend.location = 'top_left'\n\n    try: #if legend has more than 10 entries reduce spacing\n        if len(p.legend.items)>10:\n            p.legend.spacing = 0\n    except:\n        pass\n\n    p.title.text = str(title)\n    p.title.text_font_size = '16px' \n\n    return p\n\ndef bokeh_chart_engine_comparison(source, pltcfg, variable, eng_names, x_ax='datetime', x_ax_unit=None, title=None, grid=True, legend=True, style='circle', x_range=None, y_range=None, figsize=(8,6), *args, **kwargs):\n    \"\"\"Generate interactive Diane like chart with multiple axes\n\n    Args:\n        source (bokeh.ColumnDataSource): Data , e.g downloaded by engine.batch_hist_dataItems(...)\n        pltcfg ([list of dicts]): the source columns to plot, and range of y-axis\n        variable (String): Variable name to plot\n        eng_names (list of strings): Engine names\n        x_ax (str, optional): x-axis column as string. Defaults to 'datetime'.\n        x_ax_unit (str, optional): unit of x-axis as string. Defaults to None.\n        title (str, optional): Main Title of figure. Defaults to None.\n        grid (bool, optional): display grid. Defaults to True.\n        legend (bool, optional): legend. Defaults to True.  \n        style (str, optional): style of markers, options i.e. 'line', 'circle'\n            circle necessary to enable linked brushing (selection of datapoints)\n        x_range (bokeh.figure.x_range, optional): x_range of different bokeh-plot; used to connect x-axis limits\n        y_range (bokeh.figure.y_range, optional): y_range of different bokeh-plot; used to connect y-axis limits\n\n\n    Returns:\n        bokeh.plotting.figure: Bokeh plot ready to plot or embed in a layout\n\n\n    Example:\n    pltcfg=[{'col': ['BMW REGENSBURG 5_@_Starts', 'ALPRO M2 616F412 BE_@_Starts', 'BMW REGENSBURG_@_Starts']}]\n    Variable='Starts'\n    eng_names=['BMW REGENSBURG 5', 'ALPRO M2 616F412 BE', 'BMW REGENSBURG']\n    \"\"\"\n\n    dpi = 80\n    mwidth = figsize[0] * dpi\n    mheight = figsize[1] * dpi\n\n    dataitems=pd.read_csv('data\/dataitems.csv', sep=';')\n\n    TOOLS = 'pan, box_zoom, xwheel_zoom, box_select, undo, reset, save' #select Tools to display\n    colors = cycle(matplotlib.rcParams['axes.prop_cycle']) #colors to use for plot\n    linewidth = 1\n    hovers=[]\n\n    if x_ax_unit is not None: #get unit of x_axis either from user or csv-file\n        x_unit=x_ax_unit\n    else:\n        if pd.Series(x_ax).isin(dataitems.myPlantName).any():\n            x_unit=dataitems.loc[dataitems.myPlantName==x_ax].iat[0,2]\n            if x_unit is np.nan: x_unit=''\n        elif x_ax=='Operating hours validation':\n            x_unit='h'\n        else:\n            x_unit=''\n\n    x_axis_label=(f'{x_ax} [{x_unit}]')\n\n    if (x_ax == 'datetime'): #seperate constructors for object for datetime or no datetime x-axis\n        p = figure(\n        plot_width=mwidth,\n        plot_height=mheight,\n        x_axis_label=None,#'datetime',\n        x_axis_type='datetime',\n        x_range=x_range,\n        y_range=y_range,\n        tools=TOOLS\n        )\n    else:\n        p = figure(\n            plot_width=mwidth,\n            plot_height=mheight,\n            x_axis_label=x_axis_label,\n            tools=TOOLS,\n            x_range=x_range,\n            y_range=y_range\n        )\n\n    if grid==False:\n        p.grid.grid_line_color = None\n        \n    p.yaxis.visible = False\n    tooltips = []\n    for i, y in enumerate(pltcfg):\n        to_remove=[]\n        for col in y['col']: #checks if data is available\n            #if not pd.Series(col).isin(dataitems.myPlantName).any(): ### instead of comparing with dataitems compare with source\n            if col not in source.data: ### instead of comparing with dataitems compare with source\n                to_remove.append(col)\n                print (col +' not available! Please check spelling! Not plotted!')\n            elif source.data[col].all()==None: #remove of columns if no measurement taken\n                to_remove.append(col)\n                print (col +' not measured! Can´t be plotted!')\n        y['col'] = [e for e in y['col'] if e not in to_remove] #remove elements not contained in dataframe by assigning new list\n        if len(y['col'])==0: #jump to next iteration if no col remaining\n            continue\n        else:\n            color = next(cycle(colors))['color']\n\n        if y.get('ylim'):\n            ylim = list(y['ylim'])\n            p.extra_y_ranges[str(i)] = Range1d(start=ylim[0], end=ylim[1])\n        else: #if no ylim defined, use automatic Bokeh Range\n            p.extra_y_ranges[str(i)] = DataRange1d()\n\n        unit=[]\n        renderers=[]\n\n        for col in y['col']:\n            eng_name=col.split('_@_')[0]\n            if not pd.Series(variable).isin(dataitems.myPlantName).any(): #Additional if for handling new data rows generated by function, else is normal behaviour\n                if 'unit' in y:\n                    unit.append(y['unit'])\n                else:\n                    unit.append('')\n            else: \n                unit.append(dataitems.loc[dataitems.myPlantName==variable].iat[0,2])\n\n            if unit[-1] is np.nan: unit[-1]=''\n\n            if 'color' in y:\n                color = y['color']\n            else:\n                color = next(cycle(colors))['color']\n\n            func = getattr(p, style) #to choose between different plotting styles\n            if style=='circle':\n                renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n            color=color, y_range_name=str(i), legend_label=eng_name, line_width=linewidth, size=2))\n            else:\n                renderers.append(func(source=source, x=x_ax, y=col, #circle or line\n            color=color, y_range_name=str(i), legend_label=eng_name, line_width=linewidth))        \n            p.add_tools(HoverTool(tooltips=[(eng_name, '@{'+col +'}{0.2 f} '+unit[-1])], renderers=[renderers[-1]],toggleable=False))\n\n        if not y.get('ylim'):  #only if y-limits not specified\n            p.extra_y_ranges[str(i)].renderers = renderers #only use axis specific renderers for calculation of limits\n\n        llabel = variable+' ['+unit[0]+']'\n        \n        p.add_layout(LinearAxis(y_range_name=str(i),\n                            axis_label=llabel), 'left')\n\n        \n    p.toolbar.active_scroll = p.select_one('WheelZoomTool')\n\n    p.legend.click_policy='hide' #hides graph when you click on legend, other option mute (makes them less visible)\n    p.legend.location = 'top_left'\n\n\n    p.title.text = str(title)\n    p.title.text_font_size = '20px' \n\n    return p\n\ndef datastr_to_dict (datastr):\n    \"\"\"Generate dict from myPlantNames\n    In case name is not valid it gets ignored\n\n    Args:\n        datastr (list of str): myPlantNames to be transformed\n\n    Returns:\n        dat (dict): dictionary of dataitems\n        rename (dict): dict of type {name:myPlantName}\n\n    example:\n    .....\n    datastr_to_dict(['test123','Exhaust temperature cyl. 23'])\n\n        Output: \n        test123 not available! Please check spelling.\n\n        dat={191: ['Exhaust_TempCyl23', 'C (high)']},\n        rename={'Exhaust_TempCyl23': 'Exhaust temperature cyl. 23'}\"\"\"\n\n    #updated version, can transform myPlantNames from different languages\n    data=np.unique(datastr).tolist()\n\n    Request_Ids = pd.read_csv('data\/dataitems.csv', sep=';')\n    rel_data=pd.DataFrame()\n\n    rename={}\n    for da in data:\n        # try: \n        #     new=dataitems_df.loc[dataitems_df.myPlantName==da]['dataitem'].values[0]\n        #     rename [new]=da\n        #     da=new\n        # except Exception:\n        #     pass\n\n        data_id=Request_Ids.loc[Request_Ids['myPlantName']==da]\n        if not data_id.empty:\n            new=Request_Ids.loc[Request_Ids.myPlantName==da]['name'].values[0]\n            rename [new]=da\n            rel_data=rel_data.append(data_id)\n\n        #else: #uncommented for less output messages\n            #print(da+' not available! Please check spelling.')\n            #warnings.warn(da+' not available! Please check spelling.')\n\n    dat = {rec['id']:[rec['name'], rec['unit']] for rec in rel_data.to_dict('records')}\n    return dat, rename\n\ndef expand_cylinder (y, rel_cyl=all, engi=0):\n    \"\"\"Check if parameter cylinder specific and expand if aplicable\n\n    Args:\n        y (dict): one line of a single pltcfg\n        rel_cyl (list, optional): Defines relevant cylinders, defaults to all\n        engi (dmyplant2.engine, optional): Engine instance to get number of cylinders from\n\n    Returns:\n        y (dict): line of a single pltcfg with expanded parameters\n\n    example:\n    .....\n    \"\"\"\n\n    if rel_cyl is all:\n        if engi != 0:\n            e_type=engi.get_property('Engine Type')\n            rel_cyl=list(range(1, int(e_type[1:3])+1))\n        else:\n            rel_cyl=list(range(1, 25))\n\n    add_cyl_short_num=['Inlet valve closure noise', 'Outlet valve closure noise']\n    add_cyl_num=['Exhaust temperature','Exhaust temperature delta', 'Ignition voltage', 'ITP','Knock integrator','Knock noise', #'Exhaust temperature delta' added for delta to mean value\n    'Pressure 49° before TDC', 'Mechanical noise', 'Cylinder state', 'Close current gradient',\n     'Inlet valve closure timing', 'Outlet valve closure timing']\n    add_num=['Knock signal','P-max','AI','IMEP','Duration of opening','Conrod bearing temperature','CQ max','CQ','Slow down time']\n    add_mid=[]#talk with Sebastian what is looked at analyzis\n\n    to_remove=[]\n    for col in y['col']:\n        if col in add_cyl_short_num and not col in to_remove:\n            for cyl in rel_cyl:\n                y['col'].append(f'{col} cyl. {cyl}')\n                to_remove.append (col)\n\n        if col in add_cyl_num and not col in to_remove:\n            for cyl in rel_cyl:\n                y['col'].append(f'{col} cyl. {cyl:02d}')\n                to_remove.append (col)\n\n        if col in add_num and not col in to_remove:\n            for cyl in rel_cyl:\n                y['col'].append(f'{col} {cyl:02d}')\n                to_remove.append (col)\n\n        if col in add_mid and not col in to_remove:\n            for cyl in rel_cyl:\n                y['col'].append(f'{col} cyl. {cyl:02d}')\n                to_remove.append (col)\n\n    y['col']=[i for i in y['col'] if not i in to_remove ] #remove original column\n    return y\n\ndef shrink_cylinder (y, rel_cyl=list(range(1, 25))):\n    \"\"\"Sort out some cylinder specific parameters, so that only the ones interested in are displayed\n        The rest is loaded beforehand for shorter overall loading time\n\n    Args:\n        y (dict): one line of a single pltcfg\n        rel_cyl (list, optional): Defines relevant cylinders, defaults to list:[1,2...,23,24]\n\n    Returns:\n        y (dict): line of a single pltcfg with eventually less parameters\n\n    example:\n    .....\n    \"\"\"\n\n    rel_cyl=[str(cyl).zfill(2) for cyl in rel_cyl]\n    add_cyl_short_num=['Inlet valve closure noise', 'Outlet valve closure noise']\n    add_cyl_num=['Exhaust temperature','Exhaust temperature delta', 'Ignition voltage', 'ITP','Knock integrator','Knock noise', #'Exhaust temperature delta' added for delta to mean value\n    'Pressure 49° before TDC', 'Mechanical noise', 'Cylinder state', 'Close current gradient',\n     'Inlet valve closure timing', 'Outlet valve closure timing']\n    add_num=['Knock signal','P-max','AI','IMEP','Duration of opening','Conrod bearing temperature','CQ max','CQ','Slow down time']\n    add_mid=[]#talk with Sebastian what is looked at analyzis\n    to_check=add_cyl_num+add_num+add_mid\n\n    to_remove=[]\n    for col in y['col']:\n        if (any(ele in col for ele in to_check) and not col[-2:] in rel_cyl): #check if elemt in expanded elements and not in rel_cyl\n            #bug with add_cyl_short_num, exception would need to be added\n            to_remove.append (col)\n\n    y['col']=[i for i in y['col'] if not i in to_remove ] #remove original column\n    return y\n\ndef load_pltcfg_from_excel ():\n    \"\"\"Load plotconfig from Excel Sheet \"Input\" necessary in same folder\n\n    Returns:\n        pltcfg (list of dicts): pltcfg with list of dicts\n        plt_titles (list of String): titles of plots\n    .....\n    \"\"\"\n\n    import math\n    def is_number(s):\n        \"\"\" Returns True is string is a number. \"\"\"\n        try:\n            float(s)\n            return math.isfinite(s)\n        except ValueError:\n            return False\n\n    df_cfg=pd.read_excel('Input_validation_dashboard.xlsx', sheet_name='Pltcfg', usecols=['Plot_Nr', 'Axis_Nr', 'Name', 'Unit', 'y-lim min', 'y-lim max'])\n    df_cfg.sort_values(by=['Plot_Nr','Axis_Nr'], inplace=True)\n    df_cfg.dropna(subset=['Plot_Nr', 'Axis_Nr', 'Name'], inplace=True)\n    df_cfg['p_equal'] = df_cfg.Plot_Nr.eq(df_cfg.Plot_Nr.shift())\n    df_cfg['a_equal'] = df_cfg.Axis_Nr.eq(df_cfg.Axis_Nr.shift())\n\n    pltcfg=[]\n    plt_titles=[]\n    for i in range(len(df_cfg)):\n        if df_cfg.p_equal.iloc[i]==False:\n            pltcfg.append([]) #new plot\n            if df_cfg.Axis_Nr.iloc[i]==0: #append title if axis=0\n                plt_titles.append(df_cfg.Name.iloc[i]) #append title\n            else: \n                plt_titles.append('')\n\n        if df_cfg.Axis_Nr.iloc[i]!=0:\n            if df_cfg.a_equal.iloc[i]==False or df_cfg.p_equal.iloc[i]==False:\n                pltcfg[-1].append(dict()) #new axis\n\n            y=pltcfg[-1][-1]\n            if type(df_cfg.Name.iloc[i])==str:\n                if 'col' in y:\n                    y['col'].append(df_cfg.Name.iloc[i].replace('\\xa0', ' '))\n                else:\n                    y['col']=[df_cfg.Name.iloc[i].replace('\\xa0', ' ')]\n                if 'unit' not in y and type(df_cfg.Unit.iloc[i])==str: #take first occurance of unit\n                    y['unit']=df_cfg.Unit.iloc[i].replace('\\xa0', ' ')\n\n                lim_min=df_cfg['y-lim min'].iloc[i]\n                lim_max=df_cfg['y-lim max'].iloc[i]\n                if 'ylim' not in y and is_number(lim_min) and is_number(lim_max):\n                    y['ylim']=(lim_min, lim_max) #add tuple y lim\n    return pltcfg, plt_titles\n\ndef show_val_stats (vl, df_loadrange=None, df_starts_oph=None):\n    \"\"\"\n    Calculates\n    Sort out some cylinder specific parameters, so that only the ones interested in are displayed\n    The rest is loaded beforehand for shorter overall loading time\n\n    Args:\n        vl (dmyplant2.Validation): Validation Objekt\n        df_loadrange (pd.DataFrame) (optional): Dataframe with load information \n        df_starts_oph (pd-DatFrame) (optional): DataFrame with information about oph per start\n\n    Returns:\n        text_lay (bokeh.models.layouts.Column): Bokeh Column, can be displayed directly with show() or used further in a sheet or tab\n\n    example:\n    .....\n    \"\"\"\n    from bokeh.models.widgets import DataTable, DateFormatter, TableColumn\n    elements=[]\n    #### loadrange\n    if not df_loadrange.empty:\n        loadrange_info=Div(text=\"<h3>Power load (P\/Pnom)<\/h3>(Valid for displayed data)\")\n\n        df_loadrange=df_loadrange*100\n        for col in df_loadrange.columns: df_loadrange[col]=df_loadrange[col].map(\"{:,.1f}%\".format)\n        df_loadrange.insert(0, 'Engine', df_loadrange.index)\n        Columns = [TableColumn(field=Ci, title=Ci) for Ci in df_loadrange.columns] # bokeh columns\n        loadrange = DataTable(columns=Columns, source=ColumnDataSource(df_loadrange), autosize_mode='fit_columns', height=30*(len(df_loadrange.index)+1), index_position=None) # bokeh table\n        elements+=[loadrange_info, loadrange]#, loadrange_info2]\n\n    #### starts_oph\n    if not df_starts_oph.empty:\n        starts_oph_info=Div(text=\"<h3>OPH and Starts<\/h3>(Valid for displayed data)\")\n\n        df_starts_oph['OPH']=df_starts_oph['OPH'].map(\"{:,.1f}\".format)\n        df_starts_oph['OPH\/ Start']=df_starts_oph['OPH\/ Start'].map(\"{:,.1f}\".format) \n        df_starts_oph.insert(0, 'Engine', df_starts_oph.index)\n        Columns = [TableColumn(field=Ci, title=Ci) for Ci in df_starts_oph.columns] # bokeh columns\n        starts_oph = DataTable(columns=Columns, source=ColumnDataSource(df_starts_oph), autosize_mode='fit_columns', height=30*(len(df_starts_oph.index)+1), index_position=None) # bokeh table\n        elements+=[starts_oph_info, starts_oph]#, starts_oph_info2]\n\n    d=vl.dashboard\n    # Read Values defined in tdef from Myplant into a pd.dataframe\n    tdef = {161: 'Count_OpHour', 102: 'Power_PowerAct', 1258: 'OperationalCondition', 19074: 'Various_Bits_CollAlarm'}\n    ntable = [[e] + [e.get_dataItem(v) for v in tdef.values()] for e in vl.engines]\n    dft = pd.DataFrame(ntable, columns=['Name'] + list(tdef.values()))\n\n    info_text=Div(text=\"<style>h3, h4{ margin: 0;}<\/style>\"+\n    f\"<h3>{dft.OperationalCondition.count()} Engines in Validation Fleet:<\/h3>\"+\n    f\"{dft[((dft.OperationalCondition == 'Running') | (dft.Power_PowerAct > 0))].OperationalCondition.count()} Validation Engines UP and Running<br>\"+ \n    f\"{dft[((dft.OperationalCondition != 'Running') & (dft.Power_PowerAct == 0))].OperationalCondition.count()} Validation Engines not Running\")\n\n    #Display OPH characteristics\n    oph_info_tit=Div(text=\"<h3>Validation progress<\/h3>\")\n    df_oph=pd.DataFrame(columns=['Characteristic','OPH'])\n    df_oph=df_oph.append({'Characteristic':'Fleet leader', 'OPH': f\"{max(d['OPH Validation']):.0f}\"}, ignore_index=True)\n    #df_oph=df_oph.append({'Characteristic':'75% quantile', 'OPH': f\"{np.quantile(d['oph parts'],q=0.75):.0f}\"}, ignore_index=True)\n    #df_oph=df_oph.append({'Characteristic':'Median', 'OPH': f\"{np.median(d['oph parts']):.0f}\"}, ignore_index=True)\n    #df_oph=df_oph.append({'Characteristic':'50% quantile', 'OPH': f\"{np.quantile(d['oph parts'],q=0.5):.0f}\"}, ignore_index=True)\n    #df_oph=df_oph.append({'Characteristic':'25% quantile', 'OPH': f\"{np.quantile(d['oph parts'],q=0.25):.0f}\"}, ignore_index=True)\n    df_oph=df_oph.append({'Characteristic':'Average', 'OPH': f\"{np.average(d['OPH Validation']):.0f}\"}, ignore_index=True)\n    df_oph=df_oph.append({'Characteristic':'Cumulated', 'OPH': f\"{sum(d['OPH Validation']):.0f}\"}, ignore_index=True)\n\n    Columns = [TableColumn(field=Ci, title=Ci) for Ci in df_oph.columns] # bokeh columns\n    oph_info = DataTable(columns=Columns, source=ColumnDataSource(df_oph), autosize_mode='fit_columns', height=30*(len(df_oph.index)+1),index_position=None) # bokeh table\n\n    #Displayengines with certain states\n    spec_eng=Div(text=\"<h3>Engines with special states:<\/h3>\")\n    tit_run=Div(text=\"<h4>Engines not running:<\/h4>\")\n    dfd=dft[((dft.OperationalCondition != 'Running') & (dft.Power_PowerAct == 0))]\n    if dfd.empty:\n        table_run=Div(text=\"<em>All engines running<\/em>\")\n    else:\n        dfd['Name'] = dfd.apply(lambda row : row[0]._info.get('Validation Engine'), axis=1)\n        Columns2 = [TableColumn(field=Ci, title=Ci) for Ci in dfd.columns] # bokeh columns\n        table_run = DataTable(columns=Columns2, source=ColumnDataSource(dfd), autosize_mode='fit_columns', height=30*(len(dfd.index)+1)) # bokeh table\n\n    tit_con=Div(text=\"<h4>Engines without contact:<\/h4>\")\n    dfc=dft[((dft.OperationalCondition == 'No Contact') | (dft.OperationalCondition == 'Never Connected'))]\n   \n    if dfc.empty:\n        table_con=Div(text=\"<em>All engines in contact<\/em>\")\n    else:\n        dfc['Name'] = dfc.apply(lambda row : row[0]._info.get('Validation Engine'), axis=1)\n        Columns = [TableColumn(field=Ci, title=Ci) for Ci in dfc.columns] # bokeh columns\n        table_con = DataTable(columns=Columns, source=ColumnDataSource(dfc), autosize_mode='fit_columns', height=30*(len(dfc.index)+1)) # bokeh table\n\n    tit_alarm=Div(text=\"<h4>Engines with Alarm Flag not 0:<\/h4>\")\n    dfe=dft[dft.Various_Bits_CollAlarm != 0]\n    if dfe.empty:\n        table_alarm=Div(text=\"<em>No engines with alarms<\/em>\")\n    else:\n        dfe['Name'] = dfe.apply(lambda row : row[0]._info.get('Validation Engine'), axis=1)\n        Columns3 = [TableColumn(field=Ci, title=Ci) for Ci in dfe.columns] # bokeh columns\n        table_alarm = DataTable(columns=Columns3, source=ColumnDataSource(dfe), autosize_mode='fit_columns', height=30*(len(dfe.index)+1)) # bokeh table\n\n    #Display trips\n    trip_div=[Div(text=\"<h3>Recent alarms of engines with alarm:<\/h3>\")]\n    dtripped = dft[dft.Various_Bits_CollAlarm == 1]\n    for eng in dtripped.values:\n        le = eng[0] \n        trip_div.append(Div(text='<h4>'+le._info.get('Validation Engine')+'<\/h4>'))\n        dtrips = le.batch_hist_alarms(p_severities=[800], p_offset=0, p_limit=5)\n        dtrips['datetime'] = pd.to_datetime(dtrips['timestamp'] * 1000000.0).dt.strftime(\"%m-%d-%Y %H:%m\")\n        df_print=dtrips[['datetime', 'message', 'name','severity']]\n        Columns = [TableColumn(field=Ci, title=Ci) for Ci in df_print.columns] # bokeh columns\n        trip_div.append(DataTable(columns=Columns, source=ColumnDataSource(df_print), autosize_mode='fit_columns', height=30*(len(df_print.index)+1))) # bokeh table\n\n    #Create bar for figure call\n    bar_source=ColumnDataSource({'Validation Engines UP and Running': [(dft[((dft.OperationalCondition == 'Running') | (dft.Power_PowerAct > 0))].OperationalCondition.count())], 'Validation Engines not Running': [(dft[((dft.OperationalCondition != 'Running') & (dft.Power_PowerAct == 0))].OperationalCondition.count())]})\n\n    p = figure(plot_width=500,plot_height=50, tools=\"hover\", tooltips=\"$name: @$name\", toolbar_location=None)\n    p.axis.visible = False\n    p.xgrid.visible = False\n    p.ygrid.visible = False\n    p.x_range.range_padding = 0\n    p.y_range.range_padding = 0\n    p.hbar_stack(['Validation Engines UP and Running', 'Validation Engines not Running'], y=10, width=0.9, color=['green', 'grey'], source=bar_source)\n\n    access_time=Div(text='<small>Access time: '+datetime.now().strftime('%d.%m.%y %H:%M')+'<\/small>')\n\n    elements=elements+[info_text, p, access_time, oph_info_tit, oph_info, spec_eng, tit_run, table_run, tit_con, table_con, tit_alarm, table_alarm, [trip_div]]\n    text_lay=layout(children=elements)\n    return text_lay\n\n\n\n############################# Dieter\ndef demonstrated_Reliabillity_Plot(vl, beta=1.21, T=30000, s=1000, ft=pd.DataFrame, cl=[10, 50, 90], xmin=None, xmax=None, factor=2.0, ymax=24000):\n    \"\"\"Plot the demonstrated Reliability of the specified validation fleet\n\n    Example:\n\n    ....\n\n    # load input data from files\n    dval = pd.read_csv(\"input2.csv\",sep=';', encoding='utf-8')\n    dval['val start'] = pd.to_datetime(dval['val start'], format='%d.%m.%Y')\n    failures = pd.read_csv(\"failures.csv\",sep=';', encoding='utf-8')\n    failures['date'] = pd.to_datetime(failures['date'], format='%d.%m.%Y')\n\n    dmyplant2.demonstrated_Reliabillity_Plot(vl,\n            beta=1.21, T=30000, s=1000, ft=failures, cl=[10,50,90], factor=1.3);\n\n    ...\n\n\n    Args:\n        vl ([dmyplant2.Validation class]): [Class with several function around the validation fleet]\n        beta (float, optional): [Weibull beta parameter]. Defaults to 1.21.\n        T (int, optional): [Runtime for Assessment of Reliabiliy, calculated with LIPSON Method]. Defaults to 30000.\n        s (int, optional): [number of points to plot]. Defaults to 1000.\n        ft ([type], optional): [pd.DataFrame with observed failures]. Defaults to pd.DataFrame.\n            required Columns: date;failures;serialNumber;comment\n        cl (list, optional): [list with relialibilty lines for specific confidence levels to plot,\n            Numbers between 0 and 100]. Defaults to [10, 50, 90].\n        xmin ([timestamp], optional): [left margin of x-axis]. Defaults to None.\n        xmax ([timestamp], optional): [right margin of x-axis]. Defaults to None.\n        factor (float, optional): [Extrapolation factor]. Defaults to 2.0.\n        ymax (int, optional): [right y-axis max value]. Defaults to 24000.\n\n    Raises:\n        ValueError: [Time Range not properly specified]\n    \"\"\"\n    # define milestones\n    start_ts = vl.valstart_ts if xmin == None else xmin  # val start\n\n    # the end of the Plotting interval\n    if xmax:\n        last_ts = xmax\n    else:\n        if factor:\n            factor = max(factor, 1.0)  # no factor < 1.0 allowed\n            elapsed = vl.now_ts - start_ts\n            last_ts = start_ts + factor * elapsed\n        else:\n            raise ValueError(\"Error in timerange specification.\")\n\n    fcol = 'grey'\n\n    # calculate the x axis timerange first\n    tr = demonstrated_reliability_sr(vl,\n                                     start_ts, last_ts, beta=beta, size=s, ft=ft)[0]  # timestamp x axis start .. end\n\n    # determine the array - index of 'now'\n    n_i = _idx(s, start_ts, last_ts, vl.now_ts)\n\n    # create Timerow from Start to 'now'\n    n_tr = tr[0:n_i:1]\n\n    # convert to datetime dates - start .. last\n    dtr = [datetime.fromtimestamp(t) for t in tr]\n    # calculate demonstrated reliability curves for the complete period,\n    # confidence intervals CL :\n    rel = {c: demonstrated_reliability_sr(vl, start_ts, last_ts,\n                                          CL=c\/100.0, beta=beta, size=s, ft=ft, T=T)[1] for c in cl}\n\n    # convert to datetime dates - start .. now\n    n_dtr = [datetime.fromtimestamp(t) for t in n_tr]\n    # copy demontrated reliability values for the validation period up to now:\n    n_rel = {c: rel[c][0:n_i:1] for c in cl}\n\n    # define the PLOT\n    fig, ax1 = plt.subplots(  # pylint: disable=unused-variable\n        figsize=(12, 8), constrained_layout=True)\n    # fig, (ax1, ax3) = plt.subplots(2, figsize=(6, 6))\n\n    color = 'tab:red'\n    ax1.set_xlabel('date')\n    ax1.set_ylabel('Demonstrated Reliability [%]', color=color)\n    ax1.set_title('Demonstrated Reliability [%]')\n\n    # now plot the demonstrated reliability curves:\n    for CL in cl:\n        # complete interval in color fcal\n        ax1.plot(dtr, rel[CL], color=fcol, linestyle='-', linewidth=0.5)\n        # the current validation interval in multiple colors\n        ax1.plot(n_dtr, n_rel[CL], color='red', linestyle='-', linewidth=0.7)\n\n    # define the axis ticks\n    ax1.tick_params(axis='y', labelcolor=color)\n\n    # and the axis scales\n    ax1.axis((datetime.fromtimestamp(start_ts),\n              datetime.fromtimestamp(last_ts), 0, 100))\n\n    # define axis intervals y ...\n    ax1.yaxis.set_major_locator(ticker.LinearLocator(13))\n\n    # and x - axis\n    locator = dates.AutoDateLocator()\n    locator.intervald[dates.MONTHLY] = [1]\n    ax1.xaxis.set_major_locator(locator)\n\n    # show a grid\n    ax1.grid(color='lightgrey')\n\n    # instantiate a second axes that shares the same x-axis\n    ax2 = ax1.twinx()\n    ax2.axis((datetime.fromtimestamp(start_ts),\n              datetime.fromtimestamp(last_ts), 0, ymax))\n    color = 'tab:blue'\n    # the x-label was handled with ax1\n    ax2.set_ylabel('hours [h]', color=color)\n    ax2.tick_params(axis='y', labelcolor=color)\n    ax2.yaxis.set_major_locator(ticker.LinearLocator(13))\n\n    # and plot the linearized engine runtime lines vs the 2nd axis\n    for e in vl.engines[:]:\n        # print(e.Name, e['Engine ID'], e['val start'], e['oph parts'])\n        # complete interval in color fcal\n        y = [e.oph2(t) for t in tr]\n        ax2.plot(dtr, y, linewidth=0.5, color=fcol)\n        # the current validation interval in multiple colors\n        n_y = [e.oph2(t) for t in n_tr]\n        ax2.plot(n_dtr, n_y, label=f\"{e.Name} {e['Engine ID']}\")\n\n    # NOW plot some Orientation Lines and Test into the Plot\n\n    # possible runtime line\n    y = [(t-start_ts) \/ 3600.0 for t in tr]\n    ax2.plot(dtr, y, color='grey', linestyle='--', linewidth=0.7)\n\n    # today line\n    ax1.axvline(datetime.now(), color='red',\n                linestyle='--', linewidth=0.7)\n\n    # Point of demonstrated reliability at\n    # highest Confidence Level, today\n    myrel_y = float(\n        rel[max(cl)][int((vl.now_ts-start_ts)\/(last_ts - start_ts)*s-1)])\n    myrel_x = datetime.fromtimestamp(vl.now_ts)\n    ax1.scatter(myrel_x, myrel_y, marker='o', color='black', label='point')\n    txt = f\"CL {max(cl)}%@{T}\\nbeta={beta}\\nR={myrel_y:.1f}%\"\n\n    # some statistical Information.\n    myrel_txt_x = datetime.fromtimestamp(vl.now_ts + 200000)\n    ax1.text(myrel_txt_x, myrel_y - 9, txt)\n    ax1.axis((datetime.fromtimestamp(start_ts),\n              datetime.fromtimestamp(last_ts), 0, 120))\n    # oph Fleet Leader\n    fl = [e.oph2(vl.now_ts) for e in vl.engines]\n    fl_point_x = datetime.fromtimestamp(vl.now_ts)\n    ax2.scatter(fl_point_x, max(fl), marker='o', color='black', label='point')\n    fl_txt_x = datetime.fromtimestamp(vl.now_ts + 200000)\n    txt = f'{len(fl)} engines\\nmax {max(fl):.0f}h\\ncum {sum(fl):.0f}h\\navg {statistics.mean(fl):.0f}h\\n{arrow.now(\"Europe\/Vienna\").format(\"DD.MM.YYYY HH:mm\")}'\n    ax2.text(fl_txt_x, max(fl) - T\/7, txt)\n\n    # def on_plot_hover(event):\n    #     # Iterating over each data member plotted\n    #     for curve in ax2.get_lines():\n    #         # Searching which data member corresponds to current mouse position\n    #         if curve.contains(event)[0]:\n    #             print(\"over %s\" % curve.get_gid())\n\n    # plt.legend()\n    # fig.canvas.mpl_connect('motion_notify_event', on_plot_hover)\n\n    # TATAAAAH!\n    plt.show()\n\ndef chart(d, ys, x='datetime', title=None, grid=True, legend=True, notebook=True, *args, **kwargs):\n    \"\"\"Generate Diane like chart with multiple axes\n\n    example:\n    .....\n\n    dat = {\n        161: ['CountOph','h'],\n        102: ['PowerAct','kW'],\n        107: ['Various_Values_SpeedAct','U\/min'],\n        217: ['Hyd_PressCrankCase','mbar'],\n        16546: ['Hyd_PressOilDif','bar']\n    }\n\n    df = mp.hist_data(\n        e.id,\n        itemIds=dat,\n        p_from=arrow.get('2021-03-05 05:28').to('Europe\/Vienna'),\n        p_to=arrow.get('2021-03-05 05:30').to('Europe\/Vienna'),\n        timeCycle=1)\n\n\n    dmyplant2.chart(df, [\n    {'col': ['PowerAct'],'ylim': [0, 5000]},\n    {'col': ['Various_Values_SpeedAct'],'ylim': [0, 2500], 'color':'darkblue'},\n    {'col': ['CountOph'],'ylim': [0, 500]},\n    {'col': ['Hyd_PressCrankCase'],'ylim': [-40, 60]},\n    {'col': ['Hyd_PressOilDif'],'ylim': [0, 1]}\n    ],\n    title = e,\n    grid = False,\n    figsize = (14,10))\n\n    .....\n\n    Args:\n        d (pd.dataFrame): Data , e.g downloaded by engine.batch_hist_dataItems(...)\n        ys ([list of dicts]): the DataFrame d columns to plot\n        x (str, optional): x-axis column as string. Defaults to 'datetime'.\n        title (str, optional): Main Title of figure. Defaults to None.\n        grid (bool, optional): displaygrid on left axis. Defaults to True.\n        legend (bool, optional): legend. Defaults to True.\n    \"\"\"\n    # for entry in kwargs.items():\n    #     print(\"Key: {}, value: {}\".format(entry[0], entry[1]))\n\n    fig, ax = plt.subplots(*args, **kwargs)\n    fig.patch.set_facecolor('white')\n\n    axes = [ax]\n    ax.tick_params(axis='x', labelrotation=30)\n\n    if grid:\n        ax.grid()\n    if title:\n        ax.set_title(title)\n\n    for y in ys[1:]:\n        # Twin the x-axis twice to make independent y-axes.\n        axes.append(ax.twinx())\n\n    fig.subplots_adjust(top=0.9)\n    fig.subplots_adjust(left=0.1)\n\n    extra_ys = len(axes[2:])\n\n    # Make some space on the right side for the extra y-axes.\n    if extra_ys > 0:\n        if extra_ys > 6:\n            print('you are being ridiculous')\n            raise ValueError('too many Extra Axes')\n        else:\n            temp = 0.9 - extra_ys * 0.05\n\n        # print('you are being ridiculous')\n        fig.subplots_adjust(right=temp)\n        right_additive = 0.065 \/ temp\n\n        # Move the last y-axis spine over to the right by x% of the width of the axes\n        for i, ax in enumerate(axes[2:]):\n            ax.spines['right'].set_position(\n                ('axes', 1.0 + right_additive * (i+1)))\n            ax.set_frame_on(True)\n            ax.patch.set_visible(False)\n            ax.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\n        # To make the border of the right-most axis visible, we need to turn the frame\n        # on. This hides the other plots, however, so we need to turn its fill off.\n\n    cols = []\n    lines = []\n    # line_styles = cycle(['-', '-', '-', '--', '-.', ':', 'dotted', ',', 'o', 'v', '^', '<', '>',\n    #                     '1', '2', '3', '4', 's', 'p', '*', 'h', 'H', '+', 'x', 'D', 'd', '|', '_'])\n    line_styles = cycle(['-', '-', '-', '--', '-.', ':'])\n\n    colors = cycle(matplotlib.rcParams['axes.prop_cycle'])\n    for ax, y in zip(axes, ys):\n        ls = next(cycle(line_styles))\n        if len(y['col']) == 1:\n            col = y['col'][0]\n            cols.append(col)\n            if 'color' in y:\n                    color = y['color']\n            else:\n                color = next(cycle(colors))['color']\n            lines.append(ax.plot(d[x], d[col],\n                                 linestyle=ls, label=col, color=color))\n            ax.set_ylabel(col, color=color)\n            if 'ylim' in y:\n                ax.set_ylim(y['ylim'])\n            ax.tick_params(axis='y', colors=color)\n            ax.spines['right'].set_color(color)\n        else:\n            for ii, col in enumerate(y['col']):\n                if 'color' in y:\n                    if isinstance(y['color'], list):\n                        color = y['color'][ii]\n                    else:\n                        color = y['color']\n                else:\n                    color = next(cycle(colors))['color']\n                lines.append(\n                    ax.plot(d[x], d[col], linestyle=ls, label=col, color=color))\n                cols.append(col)\n            llabel = ', '.join(y['col'])\n            if len(llabel) > 90:\n                llabel = llabel[:87] + ' ..'\n            ax.set_ylabel(llabel)\n            if 'ylim' in y:\n                ax.set_ylim(y['ylim'])\n            ax.tick_params(axis='y')\n    axes[0].set_xlabel(d.index.name)\n    lns = lines[0]\n    for l in lines[1:]:\n        lns += l\n    labs = [l.get_label() for l in lns]\n    if legend:\n        axes[0].legend(lns, labs, loc=0)\n    return fig, ax, axes\n\n# def add_lines(start, lines, ax, *args, **kwargs):\n#     ax.axvline(arrow.get(start).shift(seconds=0).datetime, *args, **kwargs)\n#     for l in lines:\n#         ax.axvline(arrow.get(start).shift(seconds=l).datetime, *args, **kwargs)\n\n\ndef scatter_chart(d, ys, x='datetime', title=None, grid=True, legend=True, notebook=True, *args, **kwargs):\n    \"\"\"Generate Diane like chart with multiple axes\n\n    example:\n    .....\n\n    dat = {\n        161: ['CountOph','h'],\n        102: ['PowerAct','kW'],\n        107: ['Various_Values_SpeedAct','U\/min'],\n        217: ['Hyd_PressCrankCase','mbar'],\n        16546: ['Hyd_PressOilDif','bar']\n    }\n\n    df = mp.hist_data(\n        e.id,\n        itemIds=dat,\n        p_from=arrow.get('2021-03-05 05:28').to('Europe\/Vienna'),\n        p_to=arrow.get('2021-03-05 05:30').to('Europe\/Vienna'),\n        timeCycle=1)\n\n\n    dmyplant2.chart(df, [\n    {'col': ['PowerAct'],'ylim': [0, 5000]},\n    {'col': ['Various_Values_SpeedAct'],'ylim': [0, 2500], 'color':'darkblue'},\n    {'col': ['CountOph'],'ylim': [0, 500]},\n    {'col': ['Hyd_PressCrankCase'],'ylim': [-40, 60]},\n    {'col': ['Hyd_PressOilDif'],'ylim': [0, 1]}\n    ],\n    title = e,\n    grid = False,\n    figsize = (14,10))\n\n    .....\n\n    Args:\n        d (pd.dataFrame): Data , e.g downloaded by engine.batch_hist_dataItems(...)\n        ys ([list of dicts]): the DataFrame d columns to plot\n        x (str, optional): x-axis column as string. Defaults to 'datetime'.\n        title (str, optional): Main Title of figure. Defaults to None.\n        grid (bool, optional): displaygrid on left axis. Defaults to True.\n        legend (bool, optional): legend. Defaults to True.\n    \"\"\"\n    # for entry in kwargs.items():\n    #     print(\"Key: {}, value: {}\".format(entry[0], entry[1]))\n\n    fig, ax = plt.subplots(*args, **kwargs)\n    fig.patch.set_facecolor('white')\n\n    axes = [ax]\n    ax.tick_params(axis='x', labelrotation=30)\n\n    if grid:\n        ax.grid()\n    if title:\n        ax.set_title(title)\n\n    for y in ys[1:]:\n        # Twin the x-axis twice to make independent y-axes.\n        axes.append(ax.twinx())\n\n    fig.subplots_adjust(top=0.9)\n    fig.subplots_adjust(left=0.1)\n\n    extra_ys = len(axes[2:])\n\n    # Make some space on the right side for the extra y-axes.\n    if extra_ys > 0:\n        if extra_ys > 6:\n            print('you are being ridiculous')\n            raise ValueError('too many Extra Axes')\n        else:\n            temp = 0.9 - extra_ys * 0.05\n\n        # print('you are being ridiculous')\n        fig.subplots_adjust(right=temp)\n        right_additive = 0.065 \/ temp\n\n        # Move the last y-axis spine over to the right by x% of the width of the axes\n        for i, ax in enumerate(axes[2:]):\n            ax.spines['right'].set_position(\n                ('axes', 1.0 + right_additive * (i+1)))\n            ax.set_frame_on(True)\n            ax.patch.set_visible(False)\n            ax.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\n        # To make the border of the right-most axis visible, we need to turn the frame\n        # on. This hides the other plots, however, so we need to turn its fill off.\n\n    cols = []\n    lines = []\n    # line_styles = cycle(['-', '-', '-', '--', '-.', ':', 'dotted', ',', 'o', 'v', '^', '<', '>',\n    #                     '1', '2', '3', '4', 's', 'p', '*', 'h', 'H', '+', 'x', 'D', 'd', '|', '_'])\n    line_styles = cycle(['-', '-', '-', '--', '-.', ':'])\n\n    colors = cycle(matplotlib.rcParams['axes.prop_cycle'])\n    for ax, y in zip(axes, ys):\n        ls = next(cycle(line_styles))\n        if len(y['col']) == 1:\n            col = y['col'][0]\n            cols.append(col)\n            if 'color' in y:\n                color = y['color']\n            else:\n                color = next(cycle(colors))['color']\n            lines.append(\n                #ax.plot(d[x], d[col],\n                #                 linestyle=ls, label=col, color=color))\n                ax.scatter(d[x], d[col], label=col, color=color))\n            ax.set_ylabel(col, color=color)\n            if 'ylim' in y:\n                ax.set_ylim(y['ylim'])\n            ax.tick_params(axis='y', colors=color)\n            ax.spines['right'].set_color(color)\n        else:\n            for col in y['col']:\n                if 'color' in y:\n                    color = y['color']\n                else:\n                    color = next(cycle(colors))['color']\n                lines.append(\n                    #ax.plot(d[x], d[col], linestyle=ls, label=col, color=color))\n                    ax.scatter(d[x], d[col], label=col, color=color))\n                cols.append(col)\n            llabel = ', '.join(y['col'])\n            if len(llabel) > 90:\n                llabel = llabel[:87] + ' ..'\n            ax.set_ylabel(llabel)\n            if 'ylim' in y:\n                ax.set_ylim(y['ylim'])\n            ax.tick_params(axis='y')\n    axes[0].set_xlabel(d.index.name)\n    #lns = lines[0]\n    #for l in lines[1:]:\n    #    lns = lns + l\n    #labs = [l.get_label() for l in lns]\n    #if legend:\n    #    axes[0].legend(lns, labs, loc=0)\n\n\n\nif __name__ == '__main__':\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_166","text":"import numpy as np\nfrom scipy.spatial.transform import Rotation as R\nfrom sympy import symbols\nimport utility\nimport cv2\nimport json\n\nclass EPIPOLAR :\n    def __init__(self, args):\n        self.num_cam = args.num_valid_cam\n        self.max_dist_epiline_to_box = args.max_dist_epiline_to_box\n        self.max_dist_epiline_cross_to_box = args.max_dist_epiline_cross_to_box\n        self.num_valid_cam = args.num_valid_cam\n\n        self.rpn_stride = args.rpn_stride\n\n        self.width = args.width\n        self.height = args.height\n\n        self.zoom_out_w = args.rpn_stride * self.width\/args.resized_width\n        self.zoom_out_h = args.rpn_stride * self.height\/args.resized_height\n\n        self.diag = np.sqrt(args.width**2 + args.height**2)\n\n        self.intrin = self.parse_intrin(args.dataset_path) #(num_valid_cam, 3, 3)\n\n        self.args = args\n\n    def parse_intrin(self, path):\n        with open(path) as fp: \n            j = json.load(fp)\n\n        intrins = j['intrinsics']\n        intrins = [np.array(arr).reshape(3, 3) for arr in intrins.values()]\n        return np.array(intrins)\n\n    def reset(self, extrins, debug_imgs) :\n        self.calc_T_a2b(extrins)\n        self.calc_epipole()\n        self.debug_imgs = debug_imgs\n\n    def original_pnt_to_resized_pnt(self, pnt):\n        x, y = pnt\n        x \/= self.zoom_out_w\n        y \/= self.zoom_out_h\n        return np.array([x, y])\n\n    def resized_box_to_original_box(self, bbox_list):\n        x1 = bbox_list[:, 0] * self.zoom_out_w\n        y1 = bbox_list[:, 1] * self.zoom_out_h\n        x2 = bbox_list[:, 2] * self.zoom_out_w\n        y2 = bbox_list[:, 3] * self.zoom_out_h\n        return np.column_stack([x1, y1, x2, y2]).astype('int32')\n\n    def draw_result(self, cam1_idx, cam2_idx, box1, box2, foot, a, b, c):\n        src_img = cv2.resize(self.debug_imgs[cam1_idx], (self.width, self.height)) \n        dst_img = cv2.resize(self.debug_imgs[cam2_idx], (self.width, self.height))\n        src_reuslt_img = utility.draw_box(src_img, box1, name = None, color = (0, 0, 255), is_show = False)\n        dst_reuslt_img = utility.draw_box(dst_img, box2, name = None, color = (0, 0, 255), is_show = False)\n        line_start = (0, int(-c\/b))\n        line_end = (int(self.width), int(-a*self.width\/b - c))\n        print('box', box1, 'box', box2, 'line', line_start, line_end)\n        dst_reuslt_img = utility.draw_line(dst_reuslt_img, line_start, line_end)\n        dst_reuslt_img = cv2.circle(dst_reuslt_img, tuple(map(int, foot)), 5, (0, 0, 255), -1)\n\n        img_list = [src_reuslt_img, dst_reuslt_img]\n        concat_img = utility.get_concat_img(img_list, cols=2)\n        resized_concat_img = cv2.resize(concat_img, (640, 360))\n        cv2.imshow('epipolar', resized_concat_img)\n        cv2.waitKey(0)\n\n    def ext_a2b(self, ext_a, ext_b):\n        T_a2r = np.eye(4)\n        T_a2r[0:3, 0:3] = R.from_euler('xyz', ext_a[3:]).as_dcm()\n        T_a2r[0:3, 3] = np.array(ext_a[:3])\n\n        T_b2r = np.eye(4)\n        T_b2r[0:3, 0:3] = R.from_euler('xyz', ext_b[3:]).as_dcm()\n        T_b2r[0:3, 3] = np.array(ext_b[:3])\n\n        # T_a2b = T_r2b * T_a2r = T_b2r.inv * T_a2r\n        T_a2b = np.matmul(np.linalg.inv(T_b2r), T_a2r)\n\n        return T_a2b\n\n    def find_line(self, pt1, pt2):\n        x1, y1 = pt1\n        x2, y2 = pt2\n        d = (y2 - y1) \/ (x2 - x1)\n        e = y1 - x1 * d\n        return [-d, 1, -e]\n\n    def find_foot(self, a, b, c, pt):\n        x1, y1 = pt\n        temp = (-1 * (a * x1 + b * y1 + c) \/ (a * a + b * b))\n        x = temp * a + x1\n        y = temp * b + y1\n        return [x, y]\n\n    def find_dist(self, pt1, pt2):\n        return ((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2) ** 0.5\n\n    def calc_T_a2b(self, extrin):\n        #input : extrin #(num_valid_cam, 6)\n        self.T_a2b = np.zeros((self.num_valid_cam, self.num_valid_cam, 4, 4))\n        for i in range(self.num_valid_cam):\n            for j in range(self.num_valid_cam):\n                if(i == j): continue\n                self.T_a2b[i, j] = self.ext_a2b(extrin[i], extrin[j])\n        \n    def calc_epipole(self) :\n        self.epipole = np.zeros((self.num_valid_cam, self.num_valid_cam, 2))\n        epipole1_3dpt = np.array([0, 0, 0, 1])\n        for i in range(self.num_valid_cam):\n            for j in range(self.num_valid_cam) :\n                if(i==j) : continue\n                epipole1_in2_3dpt = np.matmul(self.T_a2b[i, j], epipole1_3dpt)[:3]\n                epipole1_in2_2dpt = np.matmul(self.intrin[j], epipole1_in2_3dpt)\n                self.epipole[i, j] = epipole1_in2_2dpt[:2] \/ epipole1_in2_2dpt[2]\n\n    def get_epipolar_lines(self, ref_cam_idx, ref_box):\n        epipolar_line_dict = {}\n        for offset in range(1, self.num_cam):\n            target_cam_idx = (ref_cam_idx + offset) % self.num_cam\n            epipolar_line_dict[target_cam_idx] = self.get_epipolar_line(ref_cam_idx, ref_box, target_cam_idx)\n\n            '''\n            a, b, c = self.get_epipolar_line(ref_cam_idx, ref_box, target_cam_idx)\n            original_ref_box = self.resized_box_to_original_box(ref_box.reshape(-1, 4))\n            ref_box_center = self.get_boxes_centers(original_ref_box)\n            foot = self.find_foot(a, b, c, ref_box_center[0])\n            self.draw_result(ref_cam_idx, target_cam_idx, original_ref_box[0], original_ref_box[0], foot, a, b, c)\n            '''\n\n        return epipolar_line_dict\n\n    def get_epipolar_line(self, ref_cam_idx, ref_box, target_cam_idx):\n        ref_T_a2b = self.T_a2b[ref_cam_idx, target_cam_idx]\n        ref_epipole_in2_2dpt = self.epipole[ref_cam_idx, target_cam_idx]\n\n        ref_intrin = self.intrin[ref_cam_idx]\n        target_intrin = self.intrin[target_cam_idx]\n\n        #print(ref_T_a2b, ref_epipole_in2_2dpt, ref_intrin, target_intrin, ref_box)\n        epipolar_line = self.calc_epipolar_line(ref_T_a2b, ref_epipole_in2_2dpt, ref_intrin, target_intrin, ref_box)\n        return epipolar_line\n\n    def solve_system_of_equations(self, eq1, eq2):\n        a1, b1, c1 = eq1\n        a2, b2, c2 = eq2\n\n        A = np.array([[a1, b1], [a2, b2]]) \n        b = np.array([-c1, -c2])\n\n        x, y = np.linalg.solve(A, b)\n        return x, y\n\n    def calc_epipolar_line(self, T_a2b, epipole1_in2_2dpt, cam1_intrin, cam2_intrin, cam1_box): \n        cam1_box = self.resized_box_to_original_box(cam1_box.reshape(-1, 4))\n        x1, y1, x2, y2 = cam1_box.reshape(4, )\n        bbox1_2dpt = (x1 + x2) \/ 2, (y1 + y2) \/ 2\n\n        # bbox 1 in camera 2\n        bbox1_3dpt = np.matmul(np.linalg.inv(cam1_intrin), np.array([*bbox1_2dpt, 1]))\n        bbox1_3dpt = np.array([*bbox1_3dpt.tolist(), 1])\n\n        bbox1_in2_3dpt = np.matmul(T_a2b, bbox1_3dpt)[:3]\n        bbox1_in2_2dpt = np.matmul(cam2_intrin, bbox1_in2_3dpt)\n        bbox1_in2_2dpt = bbox1_in2_2dpt[:2] \/ bbox1_in2_2dpt[2]\n\n        # find epipolar line\n        a, b, c = self.find_line(bbox1_in2_2dpt, epipole1_in2_2dpt)\n        import math\n        if math.isnan(a) :\n            print('bbox1_2dpt', bbox1_2dpt)\n            print('bbox1_in2_3dpt', bbox1_in2_3dpt)\n            print('bbox1_in2_2dpt', bbox1_in2_2dpt)\n\n        return a, b, c\n\n    def check_cross_pnt_valid(self, cross_pnt):\n        pass\n\n    def get_box_idx_on_cross_line(self, line1, line2, boxes) : \n        cross_pnt = self.solve_system_of_equations(line1, line2)\n        #if not self.check_cross_pnt_valid(cross_pnt):\n        #    return [], [], [-1]\n        boxes = self.resized_box_to_original_box(boxes)\n        boxes_centers = self.get_boxes_centers(boxes)\n        dist = self.find_dist_pnt2pnts(cross_pnt, boxes_centers) \/ self.diag\n        valid_idx = np.where(dist < self.max_dist_epiline_cross_to_box)\n        return valid_idx, dist, cross_pnt\n\n    def draw_boxes_with_epiline(self, ref_cam_idx, ref_box, target_cam_idx, epipolar_line, boxes) :\n        boxes = self.resized_box_to_original_box(boxes)\n        boxes_centers = self.get_boxes_centers(boxes)\n        dists = self.find_dist_line2pnts(epipolar_line, boxes_centers)\n        dists \/= self.diag\n\n        original_ref_box = self.resized_box_to_original_box(ref_box.reshape(-1, 4))[0]\n\n        a, b, c = epipolar_line\n\n        for box, dist in zip(boxes, dists) :\n            box_center = ((box[0]+box[2])\/2, (box[1]+box[3])\/2)\n            foot = self.find_foot(a, b, c, box_center)\n            print('dist', dist, 'thersh', self.max_dist_epiline_to_box)\n            self.draw_result(ref_cam_idx, target_cam_idx, original_ref_box, box, foot, a, b, c)\n\n    def get_box_idx_on_epiline(self, epipolar_line, boxes) :\n        boxes = self.resized_box_to_original_box(boxes)\n        boxes_centers = self.get_boxes_centers(boxes)\n        dist = self.find_dist_line2pnts(epipolar_line, boxes_centers)\n        dist \/= self.diag\n        valid_idx = np.where(dist < self.max_dist_epiline_to_box)\n        return valid_idx\n\n    def find_dist_line2pnts(self, line, pnts):\n        a, b, c = line\n        dist = []\n        for pnt in pnts : \n            foot = self.find_foot(a, b, c, pnt)\n            dist.append(self.find_dist(pnt, foot))\n        return np.array(dist)\n        \n    def find_dist_pnt2pnts(self, pnt, pnts):\n        return np.array( [self.find_dist(pnt, cur_pnt) for cur_pnt in pnts] ) \n\n    def get_boxes_centers(self, bboxes):\n        x_center = (bboxes[:, 0] + bboxes[:, 2]) \/ 2\n        y_center = (bboxes[:, 1] + bboxes[:, 3]) \/ 2\n        return np.column_stack([x_center, y_center])\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_167","text":"#!\/usr\/bin\/env python3\n\nfrom asist_nsf_2018.experiments import experiments\nfrom asist.wave_probe import read_wave_probe_csv\nfrom asist.utility import running_mean\nfrom asist.pressure import read_pressure_from_netcdf\nimport matplotlib.pyplot as plt\nfrom matplotlib.dates import num2date, date2num\nimport numpy as np\nimport os\nfrom scipy.io import loadmat\nfrom scipy.signal import detrend\nfrom datetime import datetime, timedelta\nfrom dispersion import w2k\nfrom netCDF4 import Dataset\nfrom process_leg import leg1, leg2, leg_slope\n\nplt.rcParams.update({'font.size': 12})\n\ndef get_run_elevations(eta, start_index, n, run_length=360, frequency=100, offset=30):\n    n0 = start_index + n * run_length * frequency + offset * frequency\n    n1 = n0 + run_length * frequency - 2 * offset * frequency\n    return eta[n0:n1]\n\ndef demean(x):\n    return x - np.mean(x)\n\ndef variance_spectrum(eta, sampling_rate, fmin=0.1, fmax=100):\n    e = demean(detrend(eta))\n    n = e.size\n    f = np.fft.fftfreq(n, 1 \/ sampling_rate)[:n\/\/2]\n    #df = 2 * sampling_rate \/ e.size\n    df = sampling_rate \/ e.size\n    ai = 2 * np.abs(np.fft.fft(e)[:n\/\/2]) \/ n\n    F = ai**2 \/ 2 \/ df\n    mask = (f >= fmin) & (f < fmax)\n    return F[mask], f[mask], df\n\ndef cp_cg(F, f, df, depth):\n    w = 2 * np.pi * f\n    k = w2k(w, depth)[0]\n    cp = w[1:] \/ k[1:]\n    cg = np.diff(w) \/ np.diff(k)\n    return cp, cg\n\ndef sig_wave_height(F, df):\n    \"\"\"Significant wave height [m].\"\"\"\n    return 4 * np.sqrt(np.sum(F * df))\n\ndef mean_wave_period(F, f, df):\n    \"\"\"First-order mean wave period [s].\"\"\"\n    return np.sum(F * df) \/ np.sum(F * f * df)\n\ndef wave_energy(F, df, rhow=1000, g=9.8):\n    \"\"\"Returns total wave energy.\"\"\"\n    return rhow * g * np.sum(F * df)\n\ndef radiation_stress(F, f, df, depth, rhow=1000, g=9.8):\n    \"\"\"Returns radiation stress.\"\"\"\n    cp, cg = cp_cg(F, f, df, depth)\n    rad_stress_fac = 2 * cg \/ cp - 0.5\n    return rhow * g * np.sum(rad_stress_fac * F[1:] * df)\n\ndef mean_water_height(eta, exp, start_index):\n    fan, h = [], []\n    for n, run in enumerate(exp.runs[:-1]):\n        fan.append(run.fan)\n        e = get_run_elevations(eta, start_index, n)\n        if n == 0:\n            offset = np.mean(e)\n            h.append(0)\n        else:\n            h.append(np.mean(e) - offset)\n    return np.array(fan), np.array(h)\n\ndef mean_slope(h1, h2, dx, rhow=1000, g=9.8, depth=0.42):\n    h1, h2 = np.array(h1), np.array(h2)\n    hmean = 0.5 * (h1 + h2) + depth\n    return rhow * g * hmean * (h2 - h1) \/ dx\n\ndef get_wave_properties(eta, exp, start_index):\n    fan, swh, mwp, Sxx = [], [], [], []\n    for n, run in enumerate(exp.runs[:-1]):\n        e = get_run_elevations(eta, start_index, n)\n        F, f, df = variance_spectrum(e, 100)\n        fan.append(run.fan)\n        swh.append(sig_wave_height(F, df))\n        mwp.append(mean_wave_period(F, f, df))\n        Sxx.append(radiation_stress(F, f, df, 0.42))\n    return np.array(fan), np.array(swh), np.array(mwp), np.array(Sxx)\n\npath = os.environ['WAVEPROBE_DATA_PATH']\nL2_DATA_PATH = os.environ['L2_DATA_PATH']\nhidrag_path = '\/home\/milan\/Work\/sustain\/data\/hidrag'\n\nfrequency = 100 # Hz\nrun_length = 360 # s\n\nfetch1_c18 = 6.02\nfetch2_c18 = 8.71\nfetch1_d04 = 4.592\nfetch2_d04 = 8.991\n\ndx_c18 = fetch2_c18 - fetch1_c18\ndx_d04 = fetch2_d04 - fetch1_d04\n\n# experiments to process\nexp_name = 'asist-windonly-fresh'\nexp = experiments[exp_name]\nknown_index = 241500\nstart_index_fan = 10\n\n_, time, eta3 = read_wave_probe_csv(path + '\/' + exp_name + '\/ch3.csv')\n_, time, eta4 = read_wave_probe_csv(path + '\/' + exp_name + '\/ch4.csv')\n_, time, eta6 = read_wave_probe_csv(path + '\/' + exp_name + '\/ch6.csv')\n\nstart_index = known_index - (start_index_fan \/\/ 5)\\\n                          * run_length * frequency\nstart_index = 0 if start_index < 0 else start_index\n    \nfan, swh3, mwp3, Sxx3 = get_wave_properties(eta3, exp, start_index)\nfan, swh4, mwp4, Sxx4 = get_wave_properties(eta4, exp, start_index)\nfan, swh6, mwp6, Sxx6 = get_wave_properties(eta6, exp, start_index)\n\n# radiation stress\nSxx3, Sxx4, Sxx6 = map(np.array, [Sxx3, Sxx4, Sxx6])\n\n# radiation stress gradient\ndSdx3 = (Sxx6 - Sxx3) \/ dx_c18\ndSdx4 = (Sxx6 - Sxx4) \/ dx_c18\n\nfan, h3 = mean_water_height(eta3, exp, start_index)\nfan, h4 = mean_water_height(eta4, exp, start_index)\nfan, h6 = mean_water_height(eta6, exp, start_index)\n\n# mean slopes\ns3 = (h6 - h3) \/ dx_c18\ns4 = (h6 - h4) \/ dx_c18\n\n# air pressure gradient\nwith Dataset(L2_DATA_PATH + '\/air-pressure_asist-christian-shadowgraph.nc') as nc:\n    seconds = nc.variables['Time'][:]\n    seconds -= seconds[0]\n    origin = datetime.strptime(nc.variables['Time'].origin, '%Y-%m-%dT%H:%M:%S')\n    time_air = np.array([origin + timedelta(seconds=s) for s in seconds])\n    dpdx_air = nc.variables['dpdx'][:]\n    fan_air = nc.variables['fan'][:]\n\nexp = experiments['asist-christian-shadowgraph']\n\ndpdx_c18 = []\nfor run in exp.runs[:-1]:\n    t0 = run.start_time + timedelta(seconds=30)\n    t1 = run.end_time - timedelta(seconds=30)\n    mask = (time_air > t0) & (time_air < t1)\n    dpdx_c18.append(np.mean(dpdx_air[mask]))\n\nrhow = 1000\nrhoa = 1.15\ng = 9.8\ndepth = 0.42\n\ndpdx_c18 = - np.array(dpdx_c18) \/ (rhow * g)\n\n### HIDRAG data\n\n# Location of probes from entrance to tank\nps1 = 3.014\nps2 = 7.012\nps3 = 11.009\n\nmat = loadmat(hidrag_path + '\/uwvsu2-24.mat')\nU = mat['ups'][0]\nuw = mat['uw'][0]\nLEG3 = mat['LEG3'][0] * 1e-2\nLEG1 = mat['LEG1'][0] * 1e-2\nM1 = mat['M1'][0]\nM3 = mat['M3'][0]\n\nps13 = - mat['ps13'][0] * 1e-2\nps12 = - mat['ps12'][0] * 1e-2\ndpdx = ps13 \/ (ps3 - ps1)\ndpdx -= dpdx[0]\n\nLEG3 -= LEG3[0]\nLEG1 -= LEG1[0]\n\nU = np.array([0] + list(U))\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, xlim=(0, 25))\nplt.plot(U[1:], LEG1, 'b--', marker='o', ms=5, label='D04, #1, 4.6 m')\nplt.plot(U[1:], LEG3, 'b-', marker='o', ms=5, label='D04, #2, 9.0 m')\nplt.plot(U, h4, 'r--', marker='o', ms=5, label='C18, #1, 6.0 m')\nplt.plot(U, h6, 'r-', marker='o', ms=5, label='C18, #2, 8.7 m')\nplt.plot(U, leg1, 'r--', marker='*', ms=10, label='C18, LEG1')\nplt.plot(U, leg2, 'r-', marker='*', ms=10, label='C18, LEG2')\nplt.plot([0, 50], [0, 0], 'k--')\nplt.legend(loc='lower left', fancybox=True, shadow=True)\nplt.grid()\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel('Mean surface elevation [m]')\nplt.title('Mean elevation as function of wind speed')\nplt.savefig('HIDRAG_elevation.png', dpi=100)\nplt.close(fig)\n\nslope_d04 = (LEG3 - LEG1) \/ dx_d04\nslope_c18 = (h6 - h4) \/ dx_c18\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, xlim=(0, 25))\nplt.plot(U[1:], slope_d04, 'b-', marker='o', ms=5, label='D04 dh\/dx')\nplt.plot(U[1:], dpdx, 'b-', marker='*', ms=8, label='D04 dp\/dx')\nplt.plot(U, slope_c18, 'r-', marker='o', ms=5, label='C18 dh\/dx')\nplt.plot(U, leg_slope, 'r-', marker='s', ms=5, label='C18 LEG dh\/dx')\nplt.plot(U[1:], dpdx_c18[1:], 'r-', marker='*', ms=8, label='C18 dp\/dx')\nplt.plot([0, 50], [0, 0], 'k--')\nplt.legend(loc='upper left', fancybox=True, shadow=True)\nplt.grid()\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel('Elevation and pressure slope')\nplt.title('Elevation and pressure slope vs wind speed')\nplt.savefig('HIDRAG_slope.png', dpi=100)\nplt.close(fig)\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, xlim=(0, 25))\nplt.plot(U[1:], M1, 'b--', marker='o', ms=5, label='D04, #1, 4.6 m')\nplt.plot(U[1:], M3, 'b-', marker='o', ms=5, label='D04, #2, 9.0 m')\nplt.plot(U, Sxx4, 'r--', marker='o', ms=5, label='C18, #1, 6.0 m')\nplt.plot(U, Sxx6, 'r-', marker='o', ms=5, label='C18, #2, 8.7 m')\nplt.legend(loc='upper left', fancybox=True, shadow=True)\nplt.grid()\nplt.plot([0, 50], [0, 0], 'k--')\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel(r'$S_{xx}$ [$kg\/s^3$]')\nplt.title('Radiation stress $S_{xx}$ vs wind speed')\nplt.savefig('HIDRAG_Sxx.png', dpi=100)\nplt.close(fig)\n\ndSdx_d04 = (M3 - M1) \/ dx_d04\ndSdx_c18 = (Sxx6 - Sxx4) \/ dx_c18\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, xlim=(0, 25))\nplt.plot(U[1:], dSdx_d04, 'b-', marker='o', ms=5, label='D04')\nplt.plot(U, dSdx_c18, 'r-', marker='o', ms=5, label='C18')\nplt.legend(loc='upper left', fancybox=True, shadow=True)\nplt.grid()\nplt.plot([0, 50], [0, 0], 'k--')\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel(r'$dS_{xx}\/dx$ [$N\/m^2$]')\nplt.title('Radiation stress gradient $dS_{xx}\/dx$ vs wind speed')\nplt.savefig('HIDRAG_dSdx.png', dpi=100)\nplt.close(fig)\n\n# Bottom stress from Brian\ntaub = rhow * np.array([.0007, .0014, .0013, .0025, .0030, .0038, .0054, .0040, .0061, .01, .0052, 0.0046])**2\ntaub_c18 = np.array([0] + list(taub))\n\ncd_d04 = (rhow * g * depth * (slope_d04 + dpdx) + dSdx_d04 - taub) \/ rhoa \/ (2 * U[1:])**2\ncd_c18 = (rhow * g * depth * (slope_c18 + dpdx_c18) + dSdx_c18 - taub_c18) \/ rhoa \/ (2 * U)**2\ncd_leg = (rhow * g * depth * (leg_slope + dpdx_c18) + dSdx_c18 - taub_c18) \/ rhoa \/ (2 * U)**2\n\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, ylim=(-5e-3, 1.5e-2), xlim=(0, 50))\nplt.plot(2 * U[1:], cd_d04, 'b-', marker='o', ms=5, label='D04')\nplt.plot(2 * U, cd_c18, 'r-', marker='o', ms=5, label='C18')\nplt.plot(2 * U, cd_leg, 'r-', marker='*', ms=10, label='C18 LEG')\nplt.legend(loc='lower right', fancybox=True, shadow=True)\nplt.grid()\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel(r'$C_{D10}$')\nplt.plot([0, 50], [0, 0], 'k--')\nplt.title('Drag coefficient vs wind speed')\nplt.savefig('HIDRAG_cd.png', dpi=100)\nplt.close(fig)\n\n\nfig = plt.figure(figsize=(8, 6))\nax = fig.add_subplot(111, xlim=(0, 25))\nplt.plot(U[1:], rhow * g * depth * slope_d04, 'b-', marker='o', ms=5, label='D04, dh\/dx')\nplt.plot(U[1:], rhow * g * depth * dpdx, 'b-', marker='*', ms=8, label='D04, dp\/dx')\nplt.plot(U[1:], taub, 'b-', marker='s', ms=8, label=r'D04, $\\tau_b$')\nplt.plot(U[1:], dSdx_d04, 'b-', marker='v', ms=8, label='D04, dSxx\/dx')\nplt.plot(U, rhow * g * depth * slope_c18, 'r-', marker='o', ms=5, label='C18, dh\/dx')\nplt.plot(U, dSdx_c18, 'r-', marker='v', ms=8, label='C18, dSxx\/dx')\nplt.legend(loc='upper left', fancybox=True, shadow=True)\nplt.grid()\nplt.xlabel('Wind speed [m\/s]')\nplt.ylabel('Stress [$N\/m^2$]')\nplt.plot([0, 50], [0, 0], 'k--')\nplt.title('Stress components vs wind speed')\nplt.savefig('HIDRAG_mom_budget.png', dpi=100)\nplt.close(fig)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_168","text":"import os\n# import os.path as pat\nimport h5py\nimport numpy as np\nimport scipy as sp\nimport pandas as pd\nimport soundfile as sf\nimport matplotlib.pyplot as plt\n\nfrom tqdm import tqdm\nfrom scipy.optimize import minimize, minimize_scalar\n\nfrom dechorate.dataset import DechorateDataset, SyntheticDataset\nfrom dechorate.cadzow import cadzow_denoise, condat_denoise\nfrom dechorate.utils.dsp_utils import *\nfrom dechorate.utils.file_utils import save_to_pickle, load_from_pickle\nfrom dechorate import constants\n\ndataset_dir = '.\/data\/dECHORATE\/'\npath_to_processed = '.\/data\/processed\/'\npath_to_note_csv = dataset_dir + 'annotations\/dECHORATE_database.csv'\n\ndatasets = constants['datasets']\n\n\ndef build_all_rirs_matrix_and_annotation(params):\n\n    Fs = params['Fs']\n    I = params['I']\n    J = params['J']\n    D = params['D']\n    K = params['K']\n    Lt = params['Lt']\n    data = params['data']\n    L = int(Fs*Lt)\n\n    all_rirs = np.zeros([L, I, J, D])\n    toa_sym = np.zeros([K, I, J, D])\n    amp_sym = np.zeros_like(toa_sym)\n    ord_sym = np.zeros_like(toa_sym)\n    wal_sym = np.ndarray([K, I, J, D], dtype=object)\n    gen_sym = np.ndarray([K, I, J, D], dtype=object)\n\n    for j in range(0, J):\n        for i in tqdm(range(0, I)):\n            for d, dataset in enumerate(datasets):\n\n                # get real data\n                dset = DechorateDataset(path_to_processed, path_to_note_csv)\n                dset.set_dataset(dataset)\n                dset.set_entry(i, j)\n                mic_pos, src_pos = dset.get_mic_and_src_pos()\n                time, h = dset.get_rir()\n                assert dset.Fs == Fs\n\n                # get simulation annotation\n                synth_dset = SyntheticDataset()\n                synth_dset.set_room_size(constants['room_size'])\n                synth_dset.set_dataset(dataset)\n                synth_dset.set_c(343)\n                synth_dset.set_k_order(3)\n                synth_dset.set_k_reflc(K)\n                synth_dset.set_mic(mic_pos[0], mic_pos[1], mic_pos[2])\n                synth_dset.set_src(src_pos[0], src_pos[1], src_pos[2])\n                # times, hs = synth_dset.get_rir()\n                amp, tau, wall, order, generators = synth_dset.get_note()\n\n                toa_sym[:, i, j, d] = tau\n                amp_sym[:, i, j, d] = amp\n                wal_sym[:, i, j, d] = wall\n                ord_sym[:, i, j, d] = order\n                gen_sym[:, i, j, d] = generators\n\n                # plt.plot(np.abs(h[:L])**p + .5*d, label=dataset)\n                # if d == 0:\n                #     plt.stem(tau*dset.Fs, amp)\n                #     for k in range(K):\n                #         plt.text(tau[k]*dset.Fs, 0.25, r'$\\tau_{%s}^{%d}$' % (wall[k][0], order[k]))\n\n                all_rirs[:, i, j, d] = h[:L]\n\n            # plt.legend()\n            # plt.show()\n\n            # ## DIRECT PATH-DECONVOLUTION\n            # Fs = dset.Fs\n            # rir = rirs[0]\n            # dp_idx = np.argmax(rir)\n            # L = int(0.2*Fs)\n            # rir = rir[:L]\n            # def f(x):\n            #     x1 = int(x)\n            #     dp = rir[dp_idx-x1:dp_idx+x1]\n            #     dp_deconv = np.real(np.fft.ifft(np.fft.fft(rir, L) \/ np.fft.fft(dp, L)))[:L]\n            #     cost = np.linalg.norm(dp_deconv**2, ord=1)\n            #     return cost\n            # res = minimize_scalar(f, bounds=[20, 200], method='Bounded')\n            # print(res)\n            # print(res.x)\n\n    toa_note = {\n        'toa': toa_sym,\n        'amp': amp_sym,\n        'wall': wal_sym,\n        'order': ord_sym,\n        'generators' : gen_sym,\n    }\n    np.save('.\/data\/interim\/all_rirs_9srcs.npy', all_rirs)\n    save_to_pickle('.\/data\/interim\/toa_note_9srcs.pkl', toa_note)\n    1\/0\n    return all_rirs\n\ndef direct_path_deconvolution(all_rirs, params):\n    L, I, J, D = all_rirs.shape\n    all_rirs_dconv = np.zeros_like(all_rirs)\n    Fs = params['Fs']\n\n    for i in range(I):\n        for j in range(J):\n            # assume that the anechoic data have a nice direct path\n            anechoic_rir = all_rirs[:, i, j, 0]\n            dp_idx = np.argmax(np.abs(anechoic_rir))\n\n            # we consider as direct path everything in the interval peak [-1 ms, +3 ms]\n            curr_dp_index = [dp_idx - int(0.001*Fs), dp_idx + int(0.003*Fs)]\n            dp = anechoic_rir[curr_dp_index[0]:curr_dp_index[1]]\n\n            for d in range(D):\n                rir = all_rirs[:, i, j, d]\n                dp_deconv = np.real(np.fft.ifft(np.fft.fft(rir, L) \/ np.fft.fft(dp, L)))\n                # restore the direct path\n                offset = int(0.001*Fs)\n                # dp_deconv = np.concatenate([np.zeros(offset), dp_deconv])\n\n                all_rirs_dconv[offset:, i, j, d] = dp_deconv[:-offset]\n    return all_rirs_dconv\n\n\ndef plot_rir_skyline(rirs, dataset, toa_sym, toa_peak, params):\n    K = params['K']\n    L, I, J, D = rirs.shape\n    IJ = I*J\n    # flat the src-mic axis\n    c = 0\n    rirs_skyline = np.zeros([L, IJ, D])\n    toa_sym_skyline = np.zeros([K, IJ, D])\n    for j in range(J):\n        for i in range(I):\n            for d in range(D):\n                rir = rirs[:, i, j, d]\n                rirs_skyline[:, c, d] = np.abs(rir\/np.max(np.abs(rir)))\n                toa_sym_skyline[:, c, d] = toa_sym[:, i, j, d]\n            c += 1\n\n    for j in range(J):\n        plt.axvline(j*params['I'], color='C7')\n\n    # process the Skyline for visualization\n    L = 2000\n    rirs_skyline = np.clip(rirs_skyline[:L, :, dataset]**2, 0, 0.4)\n\n    plt.imshow(rirs_skyline, extent=[0, I*J, 0, L], aspect='auto')\n    for k in range(7):\n        plt.scatter(np.arange(IJ)+0.5, L - toa_sym_skyline[k, :, dataset]*params['Fs'], c='C%d'%(k+1), alpha=.6, label='Pyroom DP %d' % k)\n\n    plt.tight_layout()\n    plt.legend()\n    plt.savefig('.\/reports\/figures\/rir_dp_dconv_skyline_after_calibration.pdf')\n    plt.show()\n\n\ndef plot_overlapped_rirs(rirs, toa_note, params):\n    L, I, J, D = rirs.shape\n    K, I, J, D = toa_note['toa'].shape\n    Fs = params['Fs']\n\n    for j in range(J):\n        for i in range(I):\n            plt.figure(figsize=(16, 9))\n\n            for d in range(D):\n\n                rir = rirs[:, i, j, d]\n\n                # if d == 0:\n                #     plt.plot(rir**2 + 0.2*d, alpha=.2, color='C1')\n                rir_to_plot = (normalize(rir))**2\n                rir_to_plot = np.clip(rir_to_plot, 0, 0.34)\n                rir_to_plot = normalize(rir_to_plot)\n                plt.plot(rir_to_plot + 0.2*d)\n\n                # Print the dataset name\n                wall_code_name = 'fcwsen'\n                wall_code = [int(i) for i in list(datasets[d])]\n                curr_walls = [wall_code_name[w]\n                              for w, code in enumerate(wall_code) if code == 1]\n                plt.text(50, 0.07 + 0.2*d, datasets[d])\n                plt.text(50, 0.03 + 0.2*d, curr_walls)\n\n            # plot the echo information\n            for k in range(K):\n                toa = toa_note['toa'][k, i, j, d]\n                amp = toa_note['amp'][k, i, j, d]\n                wall = toa_note['wall'][k, i, j, d]\n                order = toa_note['order'][k, i, j, d]\n                plt.axvline(x=int(toa*Fs), alpha=0.5)\n                plt.text(toa*Fs, 0.025, r'$\\tau_{%s}^{%d}$' % (wall.decode(), order), fontsize=12)\n            plt.xlim([0, 2000])\n            plt.title('RIRs dataset %s\\nmic %d, src %d' % (datasets[d], i, j))\n            plt.show()\n\n\ndef write_rir_and_note_as_file(rirs, toa_note, params):\n    L, I, J, D = rirs.shape\n    K, I, J, D = toa_note['toa'].shape\n    Fs = params['Fs']\n\n    os.system('mkdir -p .\/data\/processed\/rirs_manual_annotation\/')\n\n    for j in range(J):\n        print('Processing src', j)\n\n        os.system('mkdir -p .\/data\/processed\/rirs_manual_annotation\/src_%d\/' % j)\n\n        for i in range(I):\n\n            path = '.\/data\/processed\/rirs_manual_annotation\/src_%d\/mic_%d\/' % (j,i)\n            os.system('mkdir -p ' + path)\n\n            for d in range(D):\n\n                rir = rirs[:, i, j, d]\n\n                rir_to_plot = (normalize(rir))**2\n                rir_to_plot = np.clip(rir_to_plot, 0, 0.34)\n                rir_to_plot = normalize(rir_to_plot)\n\n\n\n                # Print the dataset name\n                wall_code_name = 'fcwsen'\n                wall_code = [int(i) for i in list(datasets[d])]\n                curr_walls = [wall_code_name[w]\n                              for w, code in enumerate(wall_code) if code == 1]\n                str_curr_wall = '_'.join(curr_walls)\n                sf.write(path + '%s_%s_rir.wav' % (datasets[d], str_curr_wall), rir_to_plot, Fs)\n\n            # plot the echo information\n            path_to_curr_note = path + '%s_note.txt' % (datasets[d])\n            text = ''\n            for k in range(K):\n                toa = toa_note['toa'][k, i, j, d]\n                amp = toa_note['amp'][k, i, j, d]\n                wall = toa_note['wall'][k, i, j, d]\n                order = toa_note['order'][k, i, j, d]\n                text += '%1.6f\\t%1.6f\\ttau_%s_%d\\n' % (toa, toa, wall.decode(), order)\n\n            with open(path_to_curr_note, \"w\") as text_file:\n                text_file.write(text)\n\n\n# # FFT domain\n# nfft = L\n# freqs = np.linspace(0, dset.Fs\/\/2, nfft\/\/2)\n# freqs_idx = np.arange(0, nfft\/\/2)\n# assert len(freqs) == len(freqs_idx)\n\n\n# fstart, fend = (0, 16000)\n# istart = np.argmin(np.abs(freqs-fstart))\n# iend = np.argmin(np.abs(freqs-fend))\n# print(istart, iend)\n# sub_freqs = np.arange(istart, iend, step=1)\n# F = len(sub_freqs)\n# # frequency_step = np.diff(freqs[sub_freqs])[0]\n# frequency_step = (dset.Fs\/2)\/(L\/2-1)\n# print('Delta Freq', frequency_step)\n\n# h = np.abs(rirs[R])\n# H = np.fft.fft(h, n=nfft)\n# plt.plot(np.abs(H))\n# H = H[sub_freqs]\n# plt.plot(np.abs(np.concatenate([np.zeros(istart), H])))\n# plt.show()\n\n# P = F\/\/2\n# assert F > 2*K+1\n\n# toep_hs = []\n# for i, h in enumerate(rirs):\n\n#     H = np.fft.fft(h)\n\n#     H = H[sub_freqs]\n\n#     if denoising:\n#         print('Cadzow Denoising')\n#         print(H.shape, P)\n#         Th_P = make_toepliz_as_in_mulan(H, P)\n#         Th = condat_denoise(Th_P, K, thr_Cadzow=1e-7)\n#         # Th = cadzow_denoise(Th, K, thr_Cadzow=1e-7)\n#     else:\n#         Th = make_toepliz_as_in_mulan(H, K+1)\n\n#     assert Th.shape[1] == K+1\n#     toep_hs.append(Th)\n\n# Th = np.concatenate(toep_hs, axis=0).squeeze()\n# # Th = toep_hs[0]\n\n# U, Sigma, Vh = np.linalg.svd(Th, full_matrices=False)\n# a = np.conj(Vh[-1,:K+1]).squeeze()  # find it in the nullspace\n\n# assert np.allclose(np.linalg.norm(a), 1, atol=1e-3)\n# assert len(a) == K+1\n\n# roots = np.roots(a)\n# print('Est a')\n# print(a.T)\n\n# roots_ref = np.exp(-1j*2*np.pi*frequency_step * tau)\n# a_ref = np.poly(roots_ref[::-1])\n# print('Ref a')\n# print(a_ref.T)\n\n# # print('Annihilation with est', np.linalg.norm(Th @ a.reshape([K+1,1])))\n# # print('Annihilation with ref', np.linalg.norm(Th @ a_ref.reshape([K+1, 1])))\n\n# print(1\/frequency_step)\n# print(Lt)\n\n# tau_est_mod_freq = np.sort(np.mod(np.angle(roots)\/(-2*np.pi*frequency_step), 1\/frequency_step))\n\n# print('relative peaks ref', tau)\n# print('relative peaks mod freq', tau_est_mod_freq)\n# print('diff', np.abs(tau - tau_est_mod_freq)*dset.Fs)\n\n# # for rir in rirs:\n# # rir = rirs[R]\n# for r, rir in enumerate(rirs):\n#     # rir = np.abs(rir \/ np.max(np.abs(rir)))\n#     plt.plot(np.arange(len(rir))\/dset.Fs, rir**2, label='RIR %d' % r)\n# plt.stem(tau, .5*np.ones_like(tau), use_line_collection = True,\n#          linefmt='C3-', markerfmt='C3o', label='simulation peaks')\n# plt.stem(tau_est_mod_freq, .5*np.ones_like(tau_est_mod_freq), use_line_collection=True,\n#          linefmt='C4-', markerfmt='C4x', label='recovered peaks mod freq')\n# plt.legend()\n# plt.show()\n\n\nif __name__ == \"__main__\":\n    params = {\n        'Fs' : 48000,\n        'I' : 30,\n        'J' : 9,\n        'D' : len(datasets),\n        'R' : 0,\n        'K' : 25,\n        'Lt' : 0.4,\n        'data' : ['real', 'synth'][0]\n    }\n\n    ## BUILD ALL-RIRs MATRIX\n    all_rirs = build_all_rirs_matrix_and_annotation(params)\n    1\/0\n    ## LOAD BACK THE DATA\n    all_rirs = np.load('.\/data\/tmp\/all_rirs.npy')\n    toa_note = load_from_pickle('.\/data\/tmp\/toa_note.pkl')\n\n    ## DIRECT-PATH DECOVOLUTION\n    all_rirs_clean = direct_path_deconvolution(all_rirs, params)\n    np.save('.\/data\/tmp\/all_rirs_clean.npy', all_rirs_clean)\n\n    ## RIR SKYLINE\n    # plot_rir_skyline(all_rirs_clean, 5, toa_sym, None, params)\n\n    ## PLOT OVERLAPPED RIRS\n    plot_overlapped_rirs(all_rirs, toa_note, params)\n\n    ## WRITE RIR as WAV to file for manual annotation with audacity\n    # write_rir_and_note_as_file(all_rirs_clean, toa_note, params)\n\n    denoising = True\n    concatenate = False\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_169","text":"<reponame>shyam196\/egc\nimport click\nimport numpy as np\nimport scipy.sparse as sparse\nimport aggfuse_cpu\n\nfrom test import csr_dmm_cpu, csr_fuse_cpu\n\n\ndef random_sparse(n, k, dtype, density, seed=0):\n    return sparse.rand(\n        n, k, density=density, format=\"csr\", dtype=dtype, random_state=seed\n    )\n\n\ndef random_dense(k, n, dtype, seed=0):\n    rng = np.random.default_rng(seed)\n    return rng.standard_normal(size=(k, n), dtype=dtype)\n\n\n@click.command()\n@click.argument(\"n\", type=int)\n@click.argument(\"k\", type=int)\n@click.argument(\"m\", type=int)\n@click.argument(\"d\", type=float)\ndef main(n, k, m, d):\n    s = random_sparse(n, k, dtype=np.float32, density=d)\n    d = random_dense(k, m, dtype=np.float32)\n    w = np.zeros((n, 3), dtype=np.float32)\n    w[:, 0] = 1\n\n    x_ref = s @ d\n    x_reimple = csr_dmm_cpu(s, d)\n    x_fuse = csr_fuse_cpu(s, d, w)\n\n    print(x_ref, \"\\n\\n\\n\\n\")\n    print(x_reimple, \"\\n\\n\\n\")\n    print(x_fuse)\n\n    print(np.allclose(x_ref, x_reimple))\n    diff = x_ref - x_reimple\n    print(diff.max(), diff.min())\n\n    print(np.allclose(x_ref, x_fuse))\n    diff = x_ref - x_fuse\n    print(diff.max(), diff.min())\n\n\nif __name__ == \"__main__\":\n    main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_170","text":"<reponame>zischg\/targetedheuristics<filename>targetedheuristics_vulnerabilityfunctions.py<gh_stars>0\n#***************************************************************\n#script for plotting flood vulnerability functions including targeted heuristics method\n#<NAME>, 09.11.2019\n#***************************************************************\nimport math\nimport numpy\nimport pandas as pd\nfrom scipy.interpolate import interp1d\nimport matplotlib.pyplot as plt\n\n\n#**************************************************************************\n#functions block\n#**************************************************************************\ndef definebuildingcategory(G_KATS_NWG,G_BAUP, buildingvalue):\n    # buildingvalue in Swiss Francs\n    #catlist=[\"EA\", \"EN\", \"MA\", \"MN\", \"GG\", \"GK\", \"SH\", \"SS\"]\n    if G_BAUP>8018 and G_KATS_NWG==1021:\n        buildingcategory=\"EN\"#detached house new\n    elif G_BAUP<=8018 and G_KATS_NWG==1021:\n        buildingcategory=\"EA\"#detached house old\n    elif G_BAUP>8018 and G_KATS_NWG in [1025,2046]:\n        buildingcategory=\"MN\"#apartment building new\n    elif G_BAUP<=8018 and G_KATS_NWG in [1025,2046]:\n        buildingcategory=\"MA\"#apartment building old\n    else:\n        if buildingvalue>850000:\n            buildingcategory=\"GG\"\n        else:\n            buildingcategory=\"GK\"\n    return buildingcategory\ndef vulnerabilityTotschnig(flowdepth):\n    # vulnerability function (Totschnig et al. 2011)\n    # <NAME>., <NAME>., and <NAME>.: A quantitative vulnerability function for fluvial sediment transport\n    # Nat Hazards, 58, 681-703, doi:10.1007\/s11069-010-9623-5, 2011.\n    # requires math\n    dol = 0.0\n    if float(flowdepth) >=0.0:\n        u = (float(flowdepth)+1.442)\/1.442-1\n        v = math.pow(u, 2.233)\n        w = -0.443*v\n        x = 1-math.exp(w)\n        if x >=0.0 and x <=1.0 :\n            dol = x\n        elif x>1.0:\n            dol = 1.0\n        elif x<0.0:\n            dol = 0.0\n    else:\n        dol = 0.0\n    if dol>1:\n        dol=1\n    elif dol<0:\n        dol=0\n    return dol\ndef vulnerabilityFuchs(magnitude):\n    #<NAME>., <NAME>., <NAME>., <NAME>., Papathoma - <NAME>., and <NAME>.: Short communication: A model to predict flood loss in mountain areas,\n    #Environ.Modell.Softw., doi:10.1016\/j.envsoft.2019.03.026, 2019\n    dol = 0.0\n    if magnitude <= 0:\n        dol = 0.0\n    else:\n        dol = (pow(math.e,-7.40+2.56*magnitude)+(pow(math.e,-3.27+1.67*magnitude)\/(1+pow(math.e,-3.27+1.67*magnitude))))\/(1+pow(math.e,-9.49*magnitude)+pow(math.e,-7.40+2.56*magnitude))\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityPapathoma(magnitude):\n    # vulnerability function (Papathoma)\n    # Papathoma-<NAME>., <NAME>., <NAME>., <NAME>., and <NAME>.:\n    # Loss estimation for landslides in mountain areas - An integrated toolbox for vulnerability assessment\n    # and damage documentation, Environmental Modelling & Software, 63, 156-169, doi:10.1016\/j.envsoft.2014.10.003, 2015.\n    # requires math\n    dol = 0.0\n    a=-1.671\n    b=3.189\n    c=1.746\n    if magnitude <= 0:\n        dol = 0.0\n    else:\n        dol = 1-pow(math.e,a*pow(((magnitude+b)\/b-1),c))\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityHydrotec(magnitude):\n    # vulnerability function HYDROTEC (2001)\n    # <NAME>., <NAME>., <NAME>., <NAME>. (2009): Flood risk\n    # analyses - how detailed do we need to be?.- Natural Hazards, 49, 1, 79-98\n    # DOI: 10.1007\/s11069-008-9277-8\n    # Squareroot function\n    # requires math\n    dol=0.0\n    if magnitude <= 0:\n        dol = 0.0\n    else:\n        dol = (27*math.sqrt(magnitude))\/100\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityKaltenrieder(flowdepth):\n    # *******************************************************************************\n    # <NAME> (2017, Master thesis at GIUB):\n    # \"Physische Vulnerabilitaet von Gebaeuden gegenueber Hochwasserereignissen\".\n    # Model 1:\n    # 1 explaining Variable (flow depth), Tab 24, p 54\n    # Power 2 function#\n    # *******************************************************************************\n    dol=0.0\n    if flowdepth <= 0:\n        dol=0.0\n    else:\n        dol=math.pow((0.18846 + 0.17152*flowdepth),2)\n    if dol > 1:\n        dol = 1.0\n    elif dol < 0:\n        dol == 0.0\n    return dol\ndef vulnerabilityJonkman(flowdepth, arr):\n    # ***********************************************************************************************************************\n    # <NAME>., <NAME>., <NAME>., and <NAME>.: Integrated hydrodynamic and economic modelling of flood\n    # damage in the Netherlands, Ecological Economics, 66, 77-90, https:\/\/doi.org\/10.1016\/j.ecolecon.2007.12.022, 2008.\n    # ***********************************************************************************************************************\n    # requires math\n    dol=0.0\n    depthmin=min(arr[:,0])\n    depthmax=max(arr[:,0])\n    dolmax=max(arr[:,1])\n    x=arr[:,0]\n    y=arr[:,1]\n    f=interp1d(x, y)\n    if flowdepth < depthmin:\n        dol = 0.0\n    elif flowdepth > depthmax:\n        dol = dolmax\n    else:\n        dol = f(float(flowdepth))\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityDutta(flowdepth, arr):\n    # *******************************************************************************\n    # <NAME>, <NAME>, <NAME>. A mathematical model for\n    # flood loss estimation. Journal of Hydrology, Volume 277 (1-2), 2003.\n    # *******************************************************************************\n    # requires math\n    dol=0.0\n    depthmin=min(arr[:,0])\n    depthmax=max(arr[:,0])\n    dolmax=max(arr[:,1])\n    x=arr[:,0]\n    y=arr[:,1]\n    f=interp1d(x, y)\n    if flowdepth < depthmin:\n        dol = 0.0\n    elif flowdepth > depthmax:\n        dol = dolmax\n    else:\n        dol = f(float(flowdepth))\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityKaragiorgos(flowdepth):\n    # vulnerability function (Karagiorgos et al. 2016)\n    # Karagiorgos, Konstantinos; <NAME>; <NAME>; <NAME>; <NAME> (2016): Integrated flash flood vulnerability assessment. Insights from East Attica, Greece. In Journal of Hydrology 541, pp.553-562. DOI: 10.1016\/j.jhydrol.2016.02.052.\n    if float(flowdepth) >=0.0:\n        u = (float(flowdepth)+1.76)\/1.76-1\n        v = math.pow(u, 0.283)\n        w = -0.032*v\n        x = 1-math.exp(w)\n        if x >=0.0 and x <=1.0 :\n            dol = x\n        elif x>1.0:\n            dol = 1.0\n        elif x<0.0:\n            dol = 0.0\n    else:\n        dol = 0.0\n    if dol>1:\n        dol=1\n    elif dol<0:\n        dol=0\n    return dol\ndef vulnerabilityEconoMe(flowdepth, velocity, buildingcategory):\n    # *******************************************************************************\n    # <NAME> (Ed.) 2009. Risikokonzept für Naturgefahren - Leitfaden.\n    # Nationale Plattform für Naturgefahren PLANAT, Bern. 420 S.\n    # s. Chapter 4 (Richtwerte EconoMe), p. 158\n    # resid_units = 1: single-family house (default)\n    # resid_units > 1: multi-family house\n    # resid_units = 0: non-residential buildings\n    # *******************************************************************************\n    dol = 0.0\n    vh = velocity * flowdepth\n    if buildingcategory in [\"EN\",\"EA\"]:#G_KATS_NWG = 1021\n        #single family house\n        if flowdepth > 0 and flowdepth < 0.5:\n          dol = 0.02\n        elif (flowdepth >= 0.5 and flowdepth < 2) or (vh >= 0.5 and vh < 2):\n          dol = 0.2\n        elif flowdepth >= 2 or vh >= 2:\n          dol = 0.3\n    elif buildingcategory in [\"MN\",\"MA\"]:#G_KATS_NWG == 1025 or G_KATS_NWG == 2046\n    # Einheitlicher Gebäudetyp Mehrfamilienhaus oder Ein\/Mehrfamilienhaus gemischt\n        if flowdepth > 0 and flowdepth < 0.5:\n            dol = 0.006\n        elif (flowdepth >= 0.5 and flowdepth < 2) or (vh >= 0.5 and vh < 2):\n            dol = 0.15\n        elif flowdepth >= 2 or vh >= 2:\n            dol = 0.25\n    else:\n    # all other building types\n        if flowdepth > 0 and flowdepth < 0.5:\n          dol = 0.1\n        elif (flowdepth >= 0.5 and flowdepth < 2) or (vh >= 0.5 and vh < 2):\n          dol = 0.3\n        elif flowdepth >= 2 or vh >= 2:\n          dol = 0.4\n    return dol\ndef mortalityJonkmanFastRise(magnitude):\n    # mortality function Jonkman (2007) - dam breaks\n    mue=1.46\n    sigma=0.28\n    if magnitude <= 0.0:\n        dol = 0.0\n    else:\n        dol = (math.log(magnitude,math.e)-mue)\/sigma\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef mortalityJonkmanSlowRise(magnitude):\n    #mortality function Jonkman (2007) - slow rise\n    mue=7.60\n    sigma=2.75\n    if magnitude <= 0.0:\n        dol = 0.0\n    else:\n        dol = (math.log(magnitude,math.e)-mue)\/sigma\n    if dol>1:\n        dol=1.0\n    elif dol<0:\n        dol=0.0\n    return dol\ndef vulnerabilityMURL(flowdepth):\n    if numpy.float(flowdepth) >=0.0 and numpy.float(flowdepth) <=5.0:\n        x = 0.02*flowdepth\n        if x >=0.0 and x <=1.0 :\n            dol = x\n        elif x>1.0:\n            dol = 1.0\n        elif x<0.0:\n            dol = 0.0\n    elif numpy.float(flowdepth) >=5.0:\n        dol=0.10\n    else:\n        dol = 0.0\n    if dol>1:\n        dol=1\n    elif dol<0:\n        dol=0\n    return dol\ndef vulnerabilityICPR(flowdepth):\n    if numpy.float(flowdepth) >=0.0:\n        x = (2*flowdepth*flowdepth+2*flowdepth)\/100.0\n        if x >=0.0 and x <=1.0 :\n            dol = x\n        elif x>1.0:\n            dol = 1.0\n        elif x<0.0:\n            dol = 0.0\n    else:\n        dol = 0.0\n    if dol>1:\n        dol=1\n    elif dol<0:\n        dol=0\n    return dol\ndef vulnerabilityTargetedHeuristics(magnitude, buildingcategory):\n    dol=0.0\n    if buildingcategory==\"EA\":\n        #old detached house\n        if magnitude>0.0 and magnitude <=0.25:\n            dol = 0.008\n        elif magnitude>0.25 and magnitude <=0.5:\n            dol = 0.152\n        elif magnitude>0.5 and magnitude <=1.0:\n            dol = 0.366\n        elif magnitude>1.0:\n            dol = 0.464\n    elif buildingcategory==\"EN\":\n        #new detached house\n        if magnitude>0.0 and magnitude <=0.25:\n            dol = 0.148\n        elif magnitude>0.25:\n            dol = 0.319\n    elif buildingcategory==\"MA\":\n        #old apartment building\n        if magnitude>0.0 and magnitude <=0.5:\n            dol = 0.238\n        elif magnitude>0.5 and magnitude <=0.75:\n            dol = 0.320\n        elif magnitude>0.75 and magnitude <=1.0:\n            dol = 0.328\n        elif magnitude>1.0:\n            dol = 0.393\n    elif buildingcategory==\"MN\":\n        #new apartment building\n        if magnitude>0.0 and magnitude <=0.25:\n            dol = 0.083\n        elif magnitude>0.25 and magnitude <=0.5:\n            dol = 0.222\n        elif magnitude>0.5 and magnitude <=0.75:\n            dol = 0.233\n        elif magnitude>0.75:\n            dol = 0.363\n    elif buildingcategory==\"GG\":\n        #commercial property, large\n        if magnitude>0.0 and magnitude <=1.0:\n            dol = 0.041\n        elif magnitude>1.0:\n            dol = 0.070\n    elif buildingcategory==\"GK\":\n        #commercial property, small\n        if magnitude>0.0 and magnitude <=0.25:\n            dol = 0.088\n        elif magnitude>0.25 and magnitude <=0.5:\n            dol = 0.111\n        elif magnitude>0.5 and magnitude <=0.75:\n            dol = 0.139\n        elif magnitude>0.75:\n            dol = 0.194\n    elif buildingcategory==\"SH\":\n        #hotel\n        if magnitude>0.0 and magnitude <=0.75:\n            dol = 0.020\n        if magnitude>0.75 and magnitude <=1.5:\n            dol = 0.051\n        elif magnitude>1.5:\n            dol = 0.076\n    else:\n        # all others, same as GK\n        if magnitude > 0.0 and magnitude <=0.25:\n            dol = 0.088\n        elif magnitude > 0.25 and magnitude <=0.5:\n            dol = 0.111\n        elif magnitude > 0.5 and magnitude <=0.75:\n            dol = 0.139\n        elif magnitude > 0.75:\n            dol = 0.194\n    return dol\ndef flowvelocity(flowdepth, slope, strickler):\n    velocity=strickler*math.pow(flowdepth,(2.0\/3.0))*math.pow(slope, 0.5)\n    return velocity\n#**************************************************************************\n#end of functions block\n#**************************************************************************\n\n#**************************************************************************\n#prepare x and y vectors for plotting the vulnerability functions\nxlist=numpy.arange(0.0,5.1,0.05).tolist()\nytot=[]\nfor item in xlist:\n    ytot.append(vulnerabilityTotschnig(item))\nyfuchs=[]\nfor item in xlist:\n    yfuchs.append(vulnerabilityFuchs(item))\nykar=[]\nfor item in xlist:\n    ykar.append(vulnerabilityKaragiorgos(item))\nypap=[]\nfor item in xlist:\n    ypap.append(vulnerabilityPapathoma(item))\nyhyd=[]\nfor item in xlist:\n    yhyd.append(vulnerabilityHydrotec(item))\nykal=[]\nfor item in xlist:\n    ykal.append(vulnerabilityKaltenrieder(item))\nyjon=[]\nfor item in xlist:\n    yjon.append(vulnerabilityJonkman(item, jonkmanarr))\nydut=[]\nfor item in xlist:\n    ydut.append(vulnerabilityDutta(item, duttaarr))\nyecoEFH=[]\nfor item in xlist:\n    yecoEFH.append(vulnerabilityEconoMe(item, 0, \"EN\"))\nyecoMFH=[]\nfor item in xlist:\n    yecoMFH.append(vulnerabilityEconoMe(item, 0, \"MN\"))\nyecorest=[]\nfor item in xlist:\n    yecorest.append(vulnerabilityEconoMe(item, 0, \"GG\"))\nyheurEN=[]\nfor item in xlist:\n    yheurEN.append(vulnerabilityTargetedHeuristics(item, \"EN\"))\nyheurEA=[]\nfor item in xlist:\n    yheurEA.append(vulnerabilityTargetedHeuristics(item, \"EA\"))\nyheurMN=[]\nfor item in xlist:\n    yheurMN.append(vulnerabilityTargetedHeuristics(item, \"MN\"))\nyheurMA=[]\nfor item in xlist:\n    yheurMA.append(vulnerabilityTargetedHeuristics(item, \"MA\"))\nyheurGG=[]\nfor item in xlist:\n    yheurGG.append(vulnerabilityTargetedHeuristics(item, \"GG\"))\nyheurGK=[]\nfor item in xlist:\n    yheurGK.append(vulnerabilityTargetedHeuristics(item, \"GK\"))\n\n\n#plot combined figure vulnerability functions\nfig, axes =plt.subplots(nrows=2, ncols=2, figsize = (10,10), sharey=True, sharex=True)\nxlabels=[0,1,2,3,4]\nx = numpy.arange(len(xlabels))\n#targeted heuristics\naxes[0][0].plot(xlist,yheurEN,label=\"new detached building\", color=\"blue\")\naxes[0][0].plot(xlist,yheurEA,label=\"old detached building\", color=\"blue\", dashes=[6,2])\naxes[0][0].plot(xlist,yheurMN,label=\"new apartment building\", color=\"red\")\naxes[0][0].plot(xlist,yheurMA,label=\"old apartment building\", color=\"red\", dashes=[6,2])\naxes[0][0].plot(xlist,yheurGG,label=\"commercial building, high value\", color=\"grey\")\naxes[0][0].plot(xlist,yheurGK,label=\"commercial building\", color=\"grey\", dashes=[6,2])\naxes[0][0].set_title('a) targeted heuristics')\n#axes[0][0].set_xlabel(\"flow depth [m]\", color=\"black\")\naxes[0][0].set_xticks(x)\naxes[0][0].set_xticklabels(xlabels)\naxes[0][0].legend(loc=\"upper left\", frameon=False)\naxes[0][0].set_ylim((0,1))\naxes[0][0].set_xlim((0,4))\naxes[0][0].set_ylabel(\"degree of damage [-]\")\n#multi-model enesemble\naxes[0][1].plot(xlist,ydut,label=\"Dutta et al.\")\naxes[0][1].plot(xlist,yjon,label=\"Jonkman et al.\")\naxes[0][1].plot(xlist,ykar,label=\"Karagiorgos et al.\")\naxes[0][1].plot(xlist,yfuchs,label=\"Fuchs et al.\")\naxes[0][1].set_title('b) multi-model ensemble')\n#axes[0][0].set_xlabel(\"flow depth [m]\", color=\"black\")\naxes[0][1].set_xticks(x)\naxes[0][1].set_xticklabels(xlabels)\naxes[0][1].legend(loc=\"upper left\", frameon=False)\naxes[0][1].set_ylim((0,1))\naxes[0][1].set_xlim((0,4))\n#Kaltenrieder\naxes[1][0].plot(xlist,ykal)\naxes[1][0].set_title('c) regional calibration')\n#axes[0][1].set_ylabel(\"degree of loss [-]\")\n#axes[0][1].set_xlabel(\"flow depth [m]\", color=\"black\")\naxes[1][0].set_xticks(x)\naxes[1][0].set_xticklabels(xlabels)\naxes[1][0].set_ylim((0,1))\naxes[1][0].set_xlim((0,4))\naxes[1][0].set_ylabel(\"degree of damage [-]\")\naxes[1][0].set_xticks(x)\naxes[1][0].set_xticklabels(xlabels)\naxes[1][0].set_xlabel(\"flow depth [m]\", color=\"black\")\n#econome\naxes[1][1].plot(xlist, yecoEFH, label=\"detached building\", color=\"blue\")\naxes[1][1].plot(xlist, yecoMFH, label=\"apartment building\", color=\"red\")\naxes[1][1].plot(xlist, yecorest, label=\"commercial building\", color=\"grey\")\naxes[1][1].set_title('d) econoMe')\naxes[1][1].set_xlabel(\"flow depth [m]\", color=\"black\")\naxes[1][1].set_xticks(x)\naxes[1][1].set_xticklabels(xlabels)\naxes[1][1].legend(loc=\"upper left\", frameon=False)\naxes[1][1].set_ylim((0,1))\naxes[1][1].set_xlim((0,4))\n#axes[1][1].set_ylabel(\"degree of damage [-]\")\naxes[1][1].set_xlabel(\"flow depth [m]\", color=\"black\")\naxes[1][1].set_xticks(x)\naxes[1][1].set_xticklabels(xlabels)\naxes[1][1].set_ylim((0,1))\naxes[1][1].set_xlim((0,4))\n#tight layout\nfig.subplots_adjust(hspace=0.4)\nfig.tight_layout()\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_172","text":"<filename>src\/core\/zone.py\n\"\"\"\r\n    Zone Module - reference storage\r\n        - loaded from database.\r\n        - imported from '..\/data\/houses\/subfolder\/zones.csv'\r\n        - holds zone area and CPE means.\r\n        - holds runtime sampled CPE per zone.\r\n        - calculates Cpe pressure load from wind pressure.\r\n\"\"\"\r\nimport scipy.stats\r\nimport numpy\r\nimport math\r\nfrom sqlalchemy import Integer, String, Float, Column, ForeignKey\r\n\r\nimport database\r\n\r\n\r\n# hackerama to get scipy seeded\r\ndef seed_scipy(seed=42):\r\n    myrs = numpy.random.RandomState(seed)\r\n\r\n    def mysample(size=1):\r\n        return myrs.uniform(size=size)\r\n\r\n    numpy.random.sample = mysample\r\n\r\n\r\ndef getZoneLocFromGrid(gridCol, gridRow):\r\n    \"\"\"\r\n    Create a string location (eg 'A10') from zero based grid refs (col=0,\r\n    row=11)\r\n    \"\"\"\r\n    locX = chr(ord('A') + gridCol)\r\n    locY = str(gridRow + 1)\r\n    return locX + locY\r\n\r\n\r\ndef getGridFromZoneLoc(loc):\r\n    \"\"\"\r\n    Extract 0 based grid refs from string location (eg 'A10' to 0, 11)\r\n    \"\"\"\r\n    locCol = loc[0]\r\n    locRow = int(loc[1:])\r\n    gridCol = ord(locCol) - ord('A')\r\n    gridRow = locRow - 1\r\n    return gridCol, gridRow\r\n\r\n\r\ndirs = ['S', 'SW', 'W', 'NW', 'N', 'NE', 'E', 'SE']\r\n\r\n\r\nclass Zone(database.Base):\r\n    __tablename__ = 'zones'\r\n    id = Column(Integer, primary_key=True)\r\n    zone_name = Column(String)\r\n    zone_area = Column(Float)\r\n    coeff_N = Column(Float)\r\n    coeff_NE = Column(Float)\r\n    coeff_E = Column(Float)\r\n    coeff_SE = Column(Float)\r\n    coeff_S = Column(Float)\r\n    coeff_SW = Column(Float)\r\n    coeff_W = Column(Float)\r\n    coeff_NW = Column(Float)\r\n    struct_coeff_N = Column(Float)\r\n    struct_coeff_NE = Column(Float)\r\n    struct_coeff_E = Column(Float)\r\n    struct_coeff_SE = Column(Float)\r\n    struct_coeff_S = Column(Float)\r\n    struct_coeff_SW = Column(Float)\r\n    struct_coeff_W = Column(Float)\r\n    struct_coeff_NW = Column(Float)\r\n    eaves_coeff_N = Column(Float)\r\n    eaves_coeff_NE = Column(Float)\r\n    eaves_coeff_E = Column(Float)\r\n    eaves_coeff_SE = Column(Float)\r\n    eaves_coeff_S = Column(Float)\r\n    eaves_coeff_SW = Column(Float)\r\n    eaves_coeff_W = Column(Float)\r\n    eaves_coeff_NW = Column(Float)\r\n    leading_roof_N = Column(Integer)\r\n    leading_roof_NE = Column(Integer)\r\n    leading_roof_E = Column(Integer)\r\n    leading_roof_SE = Column(Integer)\r\n    leading_roof_S = Column(Integer)\r\n    leading_roof_SW = Column(Integer)\r\n    leading_roof_W = Column(Integer)\r\n    leading_roof_NW = Column(Integer)\r\n    cpi_alpha = Column(Float)\r\n    wall_dir = Column(Integer)\r\n    house_id = Column(Integer, ForeignKey('houses.id'))\r\n\r\n    def getCpeMeanForDir(self, dir_index):\r\n        return getattr(self, 'coeff_%s' % dirs[dir_index])\r\n\r\n    def getCpeStructMeanForDir(self, dir_index):\r\n        return getattr(self, 'struct_coeff_%s' % dirs[dir_index])\r\n\r\n    def getCpeEavesMeanForDir(self, dir_index):\r\n        return getattr(self, 'eaves_coeff_%s' % dirs[dir_index])\r\n\r\n    def getIsLeadingRoofEdgeForDir(self, dir_index):\r\n        return getattr(self, 'leading_roof_%s' % dirs[dir_index])\r\n\r\n    def getIsWallZone(self):\r\n        if len(self.zone_name) > 3 and self.zone_name[0] == 'W':\r\n            return True\r\n        return False\r\n\r\n    def __repr__(self):\r\n        return \"('%s', '%f', '%f')\" % (\r\n        self.zone_name, self.zone_area, self.cpi_alpha)\r\n\r\n\r\ndef calc_A(cpe_k):\r\n    return (1.0 \/ cpe_k) * (1.0 - math.gamma(1.0 + cpe_k))\r\n\r\n\r\ndef calc_B(cpe_k):\r\n    base_ = math.pow(1.0 \/ cpe_k, 2) * (\r\n        math.gamma(1.0 + 2 * cpe_k) - math.pow(math.gamma(1.0 + cpe_k), 2))\r\n    return math.pow(base_, 0.5)\r\n\r\n\r\ndef calc_a_u(mean, cpe_V, A, B):\r\n    if mean >= 0:\r\n        a = (mean * cpe_V) \/ B\r\n        u = mean - a * A\r\n    else:\r\n        mean = abs(mean)\r\n        a = (mean * cpe_V) \/ B\r\n        u = mean - a * A\r\n    return a, u\r\n\r\n\r\ndef sample_gev(mean, A, B, cpe_V, cpe_k):\r\n    a, u = calc_a_u(mean, cpe_V, A, B)\r\n    if mean >= 0:\r\n        return float(scipy.stats.genextreme.rvs(cpe_k, loc=u, scale=a, size=1))\r\n    else:\r\n        return float(-scipy.stats.genextreme.rvs(cpe_k, loc=u, scale=a, size=1))\r\n\r\n\r\ndef sample_zone_pressures(zones, wind_dir_index, cpe_V, cpe_k, cpe_struct_V):\r\n    \"\"\"\r\n    Sample external Zone Pressures for sheeting, structure and eaves Cpe,\r\n    based on TypeIII General Extreme Value distribution. Prepare effective\r\n    zone areas for load calculations.\r\n    \"\"\"\r\n    A = calc_A(cpe_k)\r\n    B = calc_B(cpe_k)\r\n    for z in zones:\r\n        z.result_effective_area = float(z.zone_area)\r\n        z.sampled_cpe = sample_gev(z.getCpeMeanForDir(wind_dir_index), A, B,\r\n                                   cpe_V, cpe_k)\r\n        z.sampled_cpe_struct = sample_gev(\r\n            z.getCpeStructMeanForDir(wind_dir_index), A, B, cpe_struct_V, cpe_k)\r\n        z.sampled_cpe_eaves = sample_gev(\r\n            z.getCpeEavesMeanForDir(wind_dir_index), A, B, cpe_struct_V, cpe_k)\r\n\r\n\r\ndef calc_zone_pressures(zones, wind_dir_index, cpi, qz, Ms, building_spacing,\r\n                        diff_shielding):\r\n    \"\"\"\r\n    Determine wind pressure loads on each zone (to be distributed onto\r\n    connections)\r\n    \"\"\"\r\n    for z in zones:\r\n        # optionally apply differential shielding\r\n        diff_shielding = 1.0\r\n        if building_spacing > 0 and diff_shielding:\r\n            front_facing = z.getIsLeadingRoofEdgeForDir(wind_dir_index)\r\n            Ms2 = math.pow(Ms, 2)\r\n            dsn = 1.0\r\n            dsd = 1.0\r\n            if building_spacing == 40 and Ms >= 1.0 and front_facing == 0:\r\n                dsd = Ms2\r\n            elif building_spacing == 20 and front_facing == 1:\r\n                dsd = Ms2\r\n                if Ms <= 0.85:\r\n                    dsn = math.pow(0.7, 2)\r\n                else:\r\n                    dsn = math.pow(0.8, 2)\r\n            diff_shielding = (dsn \/ dsd)\r\n\r\n            # calculate zone pressure\r\n        z.result_pz = qz * (\r\n        z.sampled_cpe - (z.cpi_alpha * cpi)) * diff_shielding\r\n\r\n        # calculate zone structure pressure\r\n        z.result_pz_struct = qz * (z.sampled_cpe_struct - (\r\n        z.cpi_alpha * cpi) - z.sampled_cpe_eaves) * diff_shielding\r\n\r\n    # unit tests\r\n\r\n\r\nif __name__ == '__main__':\r\n    import unittest\r\n\r\n\r\n    class MyTestCase(unittest.TestCase):\r\n        # def test_breaks(self):\r\n        #     self.assertEquals(12, 134)\r\n\r\n        def test_zonegrid(self):\r\n            loc = 'N12'\r\n            gridCol, gridRow = getGridFromZoneLoc(loc)\r\n            self.assertEquals(gridRow, 11)\r\n            self.assertEquals(gridCol, 13)\r\n            self.assertEquals(getZoneLocFromGrid(gridCol, gridRow), loc)\r\n\r\n        def test_gev_calc(self):\r\n            A = calc_A(0.1)\r\n            B = calc_B(0.1)\r\n            a, u = calc_a_u(0.95, 0.07, A, B)\r\n            self.assertAlmostEqual(a, 0.058, 2)\r\n            self.assertAlmostEqual(u, 0.922, 2)\r\n            self.assertAlmostEqual(A, 0.4865, 3)\r\n            self.assertAlmostEqual(B, 1.1446, 3)\r\n\r\n\r\n    suite = unittest.TestLoader().loadTestsFromTestCase(MyTestCase)\r\n    unittest.TextTestRunner(verbosity=2).run(suite)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_173","text":"<gh_stars>0\nimport statistics\n\n\nclass Solution:\n  def minMoves2(self, nums: List[int]) -> int:\n    median = int(statistics.median(nums))\n    return sum(abs(num - median) for num in nums)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_174","text":"\"\"\"\nUnittesting for pystokes\n\"\"\"\nimport sys\nimport pystokes\nimport unittest\nimport inspect\nimport numpy as np\nimport scipy as sp\nfrom pystokes.unbounded import Rbm\nfrom pystokes.unbounded import Flow\n\nclass UnboundedTest(unittest.TestCase):\n    \n    def test_translation(self):\n        r = np.array([0,0,0.])\n        F = np.array([0,0,1.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(6*np.pi*a*eta)\n        \n        V1 = mu*F\n        V2 = 0*mu*F\n        \n        uRbm = pystokes.unbounded.Rbm(a, Np, eta)\n        uRbm.mobilityTT(V2, r, F)\n        \n        diff = V1[2] - V2[2] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for translation is not satisfied\")\n\n\n    def test_rotation(self):\n        r = np.array([0,0,0.])\n        T = np.array([0,0,1.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(8*np.pi*a**3*eta)\n\n        W1 = mu*T\n        W2 = 0*mu*T\n        \n        uRbm = pystokes.unbounded.Rbm(a, Np, eta)\n        uRbm.mobilityRR(W2, r, T)\n        \n        diff = W1[2] - W2[2] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for rotation is not satisfied\")\n\n\n\nclass WallBoundedTest(unittest.TestCase):\n    \n\n    def test_parallelTranslation(self):\n        r = np.array([0,0,1.])\n        F = np.array([0,1,0.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(6*np.pi*a*eta)\n        mu = mu*(1- 9.\/16 + 1\/8)  # add the standard wall-correction\n\n        V1 = mu*F\n        V2 = 0*mu*F\n\n        uRbm = pystokes.wallBounded.Rbm(a, Np, eta)\n        uRbm.mobilityTT(V2, r, F)\n        \n        diff = V1[1] - V2[1] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for translation || to wall is not satisfied\")\n\n\n    def test_perpTranslation(self):\n        r = np.array([0,0,1.])\n        F = np.array([0,0,1.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(6*np.pi*a*eta)\n        mu = mu*(1 - 9\/8. + 1.\/2)  # add the standard wall-correction\n\n        V1 = mu*F\n        V2 = 0*mu*F\n\n        uRbm = pystokes.wallBounded.Rbm(a, Np, eta)\n        uRbm.mobilityTT(V2, r, F)\n        \n        diff = V1[2] - V2[2] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for translation perp to wall is not satisfied\")\n   \n\n\n\nclass InterfaceTest(unittest.TestCase):\n    \n\n    def test_parallelTranslation(self):\n        r = np.array([0,0,1.])\n        F = np.array([0,1,0.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(6*np.pi*a*eta)\n        mu = mu*(1 + 3.\/8 + 1\/16)  # add the standard wall-correction\n\n        V1 = mu*F\n        V2 = 0*mu*F\n\n        uRbm = pystokes.interface.Rbm(a, Np, eta)\n        uRbm.mobilityTT(V2, r, F)\n        \n        diff = V1[1] - V2[1] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for translation || to wall is not satisfied\")\n\n\n    def test_perpTranslation(self):\n        r = np.array([0,0,1.])\n        F = np.array([0,0,1.])\n\n        a, Np, eta = 1, 1, 1 \n        mu = 1\/(6*np.pi*a*eta)\n        mu = mu*(1 - 3\/4. + 1.\/8)  # add the standard wall-correction\n\n        V1 = mu*F\n        V2 = 0*mu*F\n\n        uRbm = pystokes.interface.Rbm(a, Np, eta)\n        uRbm.mobilityTT(V2, r, F)\n        \n        diff = V1[2] - V2[2] \n        self.assertTrue((np.asarray(diff) < 0.001).all(),\n                       \"Stokes law for translation perp to wall is not satisfied\")\n   \n\n\n\nclass PeriodicTest(unittest.TestCase):\n\n\n    def test_effectiveMobility(self):\n        a, eta, Np = 1.0, 1.0\/6, 1\n        v = np.zeros(3*Np)\n        r = np.zeros(3*Np)\n        F = np.zeros(3*Np); F[2]=-1\n        \n        ll = ((4*np.pi\/3)**(1.0\/3))\/0.3   # length of simulation box\n        pRbm = pystokes.periodic.Rbm(a, Np, eta, ll)\n\n        pRbm.mobilityTT(v, r, F)\n\n        mu=1.0\/(6*np.pi*eta*a)\n        diff = -v[2]\/mu - 0.498\n        self.assertTrue((np.asarray(diff) < 0.002).all(),\n                       \"Effective mobility does not match Zick & Homsy (1982)\")\n\n\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_175","text":"<reponame>Imperial-iGEM\/synbio<filename>synbio\/protocols\/clone.py\n\"\"\"Clone fragments together with digestion and ligation.\"\"\"\n\nfrom statistics import mean\nfrom typing import Dict, List\n\nfrom Bio.Restriction.Restriction import RestrictionType\nfrom Bio.SeqRecord import SeqRecord\n\nfrom ..assembly import clone_many_combinatorial\nfrom ..containers import Container, Well\nfrom ..designs import Design\nfrom ..instructions import Temperature\nfrom ..mix import Mix\nfrom ..protocol import Protocol\nfrom ..reagents import Reagent\nfrom ..steps import Setup, Pipette, ThermoCycle, HeatShock\n\n\nCLONING_MIX = Mix(\n    {Reagent(\"10X NEBuffer\"): 5.0, SeqRecord: 1.0, RestrictionType: 1.0},\n    fill_with=Reagent(\"water\"),\n    fill_to=50.0,\n)\n\n\nclass Clone(Protocol):\n    \"\"\"Clone SeqRecords together using BioPython enzymes.\n\n    Digest the SeqRecords with all the Enzymes provided, find valid circularized\n    assemblies, and create a protocol for preparing and ligating the fragments.\n\n    This protocol is based on NEB's clone guide:\n    https:\/\/www.neb.com\/tools-and-resources\/usage-guidelines\/clone-guide\n\n    Keyword Args:\n        enzymes: the list of enzymes to digest the SeqRecords with\n        include: include only plasmids with a feature matching something\n            in the include list use in backbone selection (default: {None})\n        mix: the assembly mix to use when mixing the assemblies with enzymes\n        min_count: the minimum number of SeqRecords in an assembly for it to\n            be considered valid. smaller assemblies are ignored\n    \"\"\"\n\n    def __init__(\n        self,\n        name: str = \"\",\n        design: Design = Design(),\n        enzymes: List[RestrictionType] = None,\n        mix: Mix = CLONING_MIX,\n        include: List[str] = None,\n        min_count: int = -1,\n        separate_reagents: bool = False,\n    ):\n        super().__init__(name=name, design=design, separate_reagents=separate_reagents)\n\n        self.enzymes = enzymes or []\n        self.include = include\n        self.mix = mix\n        self.min_count = min_count\n        self.wells_to_construct: Dict[Container, Container] = {}\n\n    def run(self):\n        \"\"\"Filter designs to those that will form valid and new plasmids.\n\n        Run each Clone step on the protocol. See:\n        https:\/\/www.neb.com\/protocols\/2018\/10\/02\/golden-gate-assembly-protocol-for-using-neb-golden-gate-assembly-mix-e1601\n        \"\"\"\n\n        # get all the unique contents and set them up in their own wells\n        mixed_wells = self._create_mixed_wells()\n\n        # get the mean incubation temperature from the enzymes\n        incubate_temp = mean([e.opt_temp for e in self.enzymes])\n\n        for step in [\n            Setup(target=mixed_wells),\n            Pipette(\n                name=\"Mix DNA with the enzymes, NEBuffer, and water\", target=mixed_wells\n            ),\n            ThermoCycle(\n                [\n                    Temperature(temp=incubate_temp, time=3600),\n                    Temperature(temp=65, time=300),\n                    Temperature(temp=4, time=-1),  # hold at 4 degrees\n                ],\n                mutate=self.mutate,  # set the SeqRecords\n            ),\n        ] + HeatShock:\n            step(self)\n\n    def _create_mixed_wells(self) -> List[Container]:\n        \"\"\"Return the valid circularizable assemblies.\n\n        Also build up the dictionary for `self.wells_to_construct`, a map from sorted\n        Fragment IDs to the SeqRecord that they will form after digestion and ligation.\n\n        Returns:\n            a list of wells to mix fragments for Clone\n        \"\"\"\n\n        if not self.enzymes:\n            raise ValueError(\"Clone protocol lacks list of BioPython Enzymes\")\n\n        mixed_wells: List[Container] = []\n        for plasmids, fragments in clone_many_combinatorial(\n            self.design,\n            enzymes=self.enzymes,\n            include=self.include,\n            min_count=self.min_count,\n            linear=self.design.linear,\n        ):\n            # add reaction mix and water\n            well_contents, well_volumes = self.mix(fragments + self.enzymes)\n\n            # create a well that mixes the assembly mix, plasmids, and reagents\n            well = Well(contents=well_contents, volumes=well_volumes)\n\n            # used in self.mutate\n            self.wells_to_construct[well] = Well(plasmids, [sum(well_volumes)])\n            mixed_wells.append(well)\n\n        if not mixed_wells:\n            raise RuntimeError(f\"Failed to create any Clone assemblies\")\n\n        return sorted(mixed_wells)\n\n    def mutate(self, well: Container) -> Container:\n        \"\"\"Given the contents of a well, return single SeqRecord after digest\/ligation.\"\"\"\n\n        if well in self.wells_to_construct:\n            return self.wells_to_construct[well]\n\n        raise KeyError(f\"{well} not recognized as a Clone assembly\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_171","text":"<gh_stars>1-10\nimport os\nimport dill\nimport shutil\nimport numpy as np\nfrom glob import glob\nfrom subprocess import call\nfrom subprocess import Popen\nfrom subprocess import PIPE\nfrom time import sleep\nfrom tqdm import tqdm\nfrom scipy.interpolate import LinearNDInterpolator\nfrom saenopy import Solver\nimport saenopy\nfrom saenopy.materials import SemiAffineFiberMaterial\nimport pandas as pd\n\n\ndef read_meshfile(meshfile, r_inner=None, r_outer=None):\n    # open mesh file\n    with open(meshfile, 'r') as f:\n        lines = f.readlines()\n\n    # if r_inner or r_outer are defined in the mesh-file, ignore user input\n    meshinfo = {}\n    try:\n        paragraph = lines[lines.index('$Jointforces\\n') + 1:lines.index('$EndJointforces\\n')]\n        for line in paragraph:\n            key, value = line.strip().split('=')\n            try:\n                meshinfo[key] = float(value)\n            except ValueError:\n                meshinfo[key] = value\n\n        r_inner = meshinfo['r_inner']\n        r_outer = meshinfo['r_outer']\n\n        print('Geometry for spherical contraction is defined in mesh file (r_inner={:.2f}, r_outer={:.2f}).'.format(r_inner, r_outer))\n        if (r_inner is not None) or (r_outer is not None):\n            print('Will ignore user-defined values of r_inner and r_outer.')\n    except ValueError:\n        if r_inner is None:\n            raise ValueError('r_inner not defined')\n        if r_outer is None:\n            raise ValueError('r_outer not defined')\n            \n    # scale radii to meter\n    r_inner *= 10**-6\n    r_outer *= 10**-6\n    \n    # transform nodes and connection in SAENO format\n    # nodes\n    index_nodes = lines.index('$Nodes\\n')\n    n_nodes = int(lines[index_nodes + 1])\n\n    coords = np.zeros((n_nodes, 3))\n    for i in range(n_nodes):\n        coords[i] = np.array([np.float(x) for x in lines[i + index_nodes + 2].split()[1:]])\n        \n      \n    # connections\n    index_elements = lines.index('$Elements\\n')\n    n_elements = int(lines[index_elements + 1])\n\n    tets = np.zeros((n_elements, 4))\n    for i in range(n_elements):\n        tets[i] = lines[i + index_elements + 2].split()[-4:]\n\n    # to start with 0 and not 1\n    tets -= 1\n    \n    return coords, tets, r_inner, r_outer\n    \n\ndef spherical_contraction_solver(meshfile, outfolder, pressure, material, r_inner=None, r_outer=None, logfile=False, initial_displacenemts=None, max_iter = 600, step = 0.0033, conv_crit = 0.01):\n    \n    \n    coords, tets, r_inner, r_outer = read_meshfile(meshfile, r_inner, r_outer)\n\n    # read in material parameters\n    K_0 = material['K_0']\n    D_0 = material['D_0']\n    L_S = material['L_S']\n    D_S = material['D_S']\n\n    # create output folder if it does not exist, print warning otherwise\n    if not os.path.exists(outfolder):\n        os.makedirs(outfolder)\n    else:\n        print('WARNING: Output folder already exists! ({})'.format(outfolder))\n\n\n    # Initialize saenopy solver opbject\n    M = Solver()\n    material_saenopy = SemiAffineFiberMaterial(K_0, D_0, L_S, D_S)\n    M.setMaterialModel(material_saenopy)\n    M.setNodes(coords)\n    M.setTetrahedra(tets)\n     \n    # define boundary conditions\n    distance = np.sqrt(np.sum(coords ** 2., axis=1))\n    mask_inner = distance < r_inner * 1.001\n    mask_outer = distance > r_outer * 0.999\n\n    # Save Node Density at inner and outer sphere\n    # Area per inner node\n    A_node_inner = (np.pi*4*(r_inner)**2)\/np.sum(mask_inner) \n    # simple sqrt as spacing\n    inner_spacing = np.sqrt(A_node_inner)    \n    \n    # Area per outer node\n    A_node_outer = (np.pi*4*(r_outer)**2)\/np.sum(mask_outer)   \n    # simple sqrt as spacing\n    outer_spacing = np.sqrt(A_node_outer)\n    \n    print ('Inner node spacing: '+str(inner_spacing*1e6)+'µm')\n    print ('Outer node spacing: '+str(outer_spacing*1e6)+'µm')\n\n    \n    # displacements are everywhere NaN\n    bcond_displacement = np.zeros((len(coords), 3))*np.nan\n    # except of a the outer border\n    bcond_displacement[mask_outer] = 0\n    \n    # forces are everywhere 0\n    bcond_forces = np.zeros((len(coords), 3))\n    # except at the outer boder there they are NaN\n    bcond_forces[mask_outer] = np.nan\n    # and at the innter border they depend on the pressure\n    bcond_forces[mask_inner] = coords[mask_inner]\n    bcond_forces[mask_inner] \/= distance[mask_inner, None]\n    A_inner = 4 * np.pi * r_inner ** 2.\n    force_per_node = pressure * A_inner \/ np.sum(mask_inner)\n    bcond_forces[mask_inner, :3] *= force_per_node\n    \n    # give the boundary conditions to the solver\n    M.setBoundaryCondition(bcond_displacement, bcond_forces)\n\n    if initial_displacenemts is not None:\n        M.setInitialDisplacements(initial_displacenemts)\n\n    # create info file with all relevant parameters of the simulation\n    parameters = r\"\"\"K_0 = {}\nD_0 = {}\nL_S = {}\nD_S = {}\nPRESSURE = {}\nFORCE_PER_SURFACE_NODE = {}\nINNER_RADIUS = {} µm\nOUTER_RADIUS = {} µm\nINNER_NODE_SPACING = {} µm\nOUTER_NODE_SPACING = {} µm\nSURFACE_NODES = {}\nTOTAL_NODES = {}\"\"\".format(K_0, D_0, L_S, D_S, pressure, force_per_node, r_inner*1e6, r_outer*1e6, inner_spacing*1e6,\n                           outer_spacing*1e6, np.sum(mask_inner), len(coords))\n\n    with open(outfolder + \"\/parameters.txt\", \"w\") as f:\n        f.write(parameters)\n        \n    # solve the boundary problem\n    M.solve_boundarycondition(stepper=step, i_max=max_iter, rel_conv_crit=conv_crit, relrecname=outfolder + \"\/relrec.txt\") #, verbose=True\n    M.save(outfolder + \"\/solver.npz\")\n    \n  \ndef distribute_solver(func, const_args, var_arg='pressure', start=0.1, end=1000, n=120, log_scaling=True, n_cores=None, get_initial=True, max_iter = 600, step = 0.0033, conv_crit = 0.01, callback=None):\n    # get_intial = True takes the deformationfield from previous simulation as start values for the next simulations, which reduces computation time\n    \n    # by default use spherical contraction as function\n    func = spherical_contraction_solver\n    \n    if n_cores is None:\n        n_cores = os.cpu_count()\n\n    if log_scaling:\n        values = np.logspace(np.log10(start), np.log10(end), n, endpoint=True)\n    else:\n        values = np.linspace(np.log10(start), np.log10(end), n, endpoint=True)\n\n    outfolder = const_args['outfolder']\n    del const_args['outfolder']\n\n    if not os.path.exists(outfolder):\n        os.makedirs(outfolder)\n\n    np.savetxt(outfolder+'\/'+var_arg+'-values.txt', values)\n\n    values = list(values)\n\n    if n_cores == 1:\n        U = None\n        for index, v in enumerate(values):\n            func(const_args[\"meshfile\"], outfolder + '\/simulation' + str(index).zfill(6),\n                    v, const_args[\"material\"], None, None, False, U, max_iter, step, conv_crit)\n            # get the last displacement\n            name = outfolder + '\/simulation' + str(index).zfill(6) + \"\/solver.npz\"\n            if os.path.exists(name):\n                M = saenopy.load(name)\n                U = M.U\n            # optionally call the callback\n            if callback is not None:\n                callback(index, len(values))\n    else:\n        index = 0\n        processes = []\n        import multiprocessing\n        while True:\n            processes = [p for p in processes if p.is_alive()]\n\n            if len(processes) < n_cores and index < len(values):\n                v = values[index]\n                U = None\n                if get_initial==True:\n                    for i in range(index-3, -1, -1):\n                        name = outfolder+'\/simulation'+str(i).zfill(6) + \"\/solver.npz\"\n                        if os.path.exists(name):\n                            M = saenopy.load(name)\n                            U = M.U\n                            break\n                p = multiprocessing.Process(target=func,\n                                            args=(const_args[\"meshfile\"],  outfolder+'\/simulation'+str(index).zfill(6),\n                                                  v, const_args[\"material\"], None, None, False, U, max_iter, step, conv_crit))\n\n                p.start()\n                processes.append(p)\n                if callback is not None:\n                    callback(index, len(values))\n                index += 1\n            sleep(1.)\n\n            if len(processes) == 0:\n                break\n    if callback is not None:\n        callback(index, len(values))\n    return\n    \n  \n\n\ndef extract_deformation_curve_solver(folder, x):\n    # get simulation parameters\n    with open(folder+'\/parameters.txt', 'r') as f:\n        lines = f.readlines()\n\n    parameters = {}\n    for line in lines:\n        try:\n            key, value = line.split('= ')\n            value = value.split(' ')[0]\n            parameters[key.strip()] = float(value.strip())\n        except:\n            pass\n\n    # load coordinates\n    M = saenopy.load(folder + \"\/solver.npz\")\n    coords = M.R \n    # load displacements\n    displ = M.U\n    \n    # compute binned normed displacements and normed coordinates\n    u = np.sqrt(np.sum(coords ** 2., axis=1)) \/ (parameters['INNER_RADIUS']*10**-6)\n    v = np.sqrt(np.sum(displ ** 2., axis=1)) \/ (parameters['INNER_RADIUS']*10**-6)\n\n    y = np.array([np.nanmedian(v[(u >= x[i]) & (u < x[i + 1])]) for i in range(len(x) - 1)])\n\n    # save results\n    results = {'pressure': parameters['PRESSURE'], 'bins': x, 'displacements': y}\n    return results\n  \n    \ndef create_lookup_table_solver(folder, x0=1, x1=50, n=100):\n    subfolders = glob(folder+'\/*\/')\n\n    x = np.logspace(np.log10(x0), np.log10(x1), n+1, endpoint=True)\n    x_center = 10**(0.5*(np.log10(x[1:]) + np.log10(x[:-1])))\n\n    pressure_values = []\n    displacement_curves = []\n\n    for subfolder in tqdm(subfolders):\n        res = extract_deformation_curve_solver(subfolder, x)\n        pressure_values.append(res['pressure'])\n        displacement_curves.append(res['displacements'])\n\n    pressure_values = np.array(pressure_values)\n    displacement_curves = np.array(displacement_curves)\n\n    return {'pressure': pressure_values, 'x': x_center, 'y': displacement_curves}\n  \n\n  \n    \n\"\"\"\nCommand_line_version \n\"\"\"   \n    \n    \n    \n    \ndef spherical_contraction(meshfile, outfolder, pressure, material, r_inner=None, r_outer=None, logfile=False,  max_iter = 600, step = 0.0033, conv_crit = 0.01):\n    # open mesh file\n    with open(meshfile, 'r') as f:\n        lines = f.readlines()\n\n    # if r_inner or r_outer are defined in the mesh-file, ignore user input\n    meshinfo = {}\n    try:\n        paragraph = lines[lines.index('$Jointforces\\n') + 1:lines.index('$EndJointforces\\n')]\n        for line in paragraph:\n            key, value = line.strip().split('=')\n            try:\n                meshinfo[key] = float(value)\n            except ValueError:\n                meshinfo[key] = value\n\n        r_inner = meshinfo['r_inner']\n        r_outer = meshinfo['r_outer']\n\n        print('Geometry for spherical contraction is defined in mesh file (r_inner={:.2f}, r_outer={:.2f}).'.format(r_inner, r_outer))\n        if (r_inner is not None) or (r_outer is not None):\n            print('Will ignore user-defined values of r_inner and r_outer.')\n    except ValueError:\n        if r_inner is None:\n            raise ValueError('r_inner not defined')\n        if r_outer is None:\n            raise ValueError('r_outer not defined')\n    \n    # scale radii to meter\n    r_inner *= 10**-6\n    r_outer *= 10**-6\n\n    # read in material parameters\n    K_0 = material['K_0']\n    D_0 = material['D_0']\n    L_S = material['L_S']\n    D_S = material['D_S']\n\n    # create output folder if it does not exist, print warning otherwise\n    if not os.path.exists(outfolder):\n        os.makedirs(outfolder)\n    else:\n        print('WARNING: Output folder already exists! ({})'.format(outfolder))\n\n    # transform nodes and connection in SAENO format\n    # nodes\n    index_nodes = lines.index('$Nodes\\n')\n    n_nodes = int(lines[index_nodes + 1])\n\n    coords = np.zeros((n_nodes, 3))\n    for i in range(n_nodes):\n        coords[i] = np.array([np.float(x) for x in lines[i + index_nodes + 2].split()[1:]])\n    np.savetxt(outfolder + '\/coords.dat', coords)\n\n    # connections\n    index_elements = lines.index('$Elements\\n')\n    n_elements = int(lines[index_elements + 1])\n\n    tets = np.zeros((n_elements, 4))\n    for i in range(n_elements):\n        tets[i] = lines[i + index_elements + 2].split()[-4:]\n    np.savetxt(outfolder + '\/tets.dat', tets, fmt='%i')\n\n    # define boundary conditions\n    distance = np.sqrt(np.sum(coords ** 2., axis=1))\n    mask_inner = distance < r_inner * 1.001\n    mask_outer = distance > r_outer * 0.999\n\n    # Save Node Density at inner and outer sphere\n    # Area per inner node\n    A_node_inner = (np.pi*4*(r_inner)**2)\/np.sum(mask_inner) \n    # simple sqrt as spacing\n    inner_spacing = np.sqrt(A_node_inner)    \n    \n    # Area per outer node\n    A_node_outer = (np.pi*4*(r_outer)**2)\/np.sum(mask_outer)   \n    # simple sqrt as spacing\n    outer_spacing = np.sqrt(A_node_outer)\n    \n    print ('Inner node spacing: '+str(inner_spacing*1e6)+'µm')\n    print ('Outer node spacing: '+str(outer_spacing*1e6)+'µm')\n\n    bcond = np.zeros((len(coords), 4))\n    bcond[:, 3] = 1.\n\n    # fixed displacements for outer boundary\n    bcond[mask_outer, 3] = 0\n\n    # fixed non-zero force at spheroid surface\n    bcond[mask_inner, :3] = coords[mask_inner, :3]\n    bcond[mask_inner, :3] \/= distance[mask_inner, None]\n\n    A_inner = 4 * np.pi * r_inner ** 2.\n    force_per_node = pressure * A_inner \/ np.sum(mask_inner)\n    bcond[mask_inner, :3] *= force_per_node\n\n    np.savetxt(outfolder + '\/bcond.dat', bcond)\n\n    # define initial configuration\n    iconf = np.zeros((len(coords), 3))\n    np.savetxt(outfolder + '\/iconf.dat', iconf)\n\n    # create config file for SAENO    \n    config = r\"\"\"MODE = relaxation\nBOXMESH = 0\nFIBERPATTERNMATCHING = 0\nREL_CONV_CRIT = {}\nREL_ITERATIONS = {}\nREL_SOLVER_STEP = {}\nK_0 = {}\nD_0 = {}\nL_S = {}\nD_S = {}\nCONFIG = {}\\config.txt\nDATAOUT = {}\"\"\".format(conv_crit, max_iter, step, K_0, D_0, L_S, D_S, os.path.abspath(outfolder), os.path.abspath(outfolder))\n\n    with open(outfolder + \"\/config.txt\", \"w\") as f:\n        f.write(config)\n\n    # create info file with all relevant parameters of the simulation\n    parameters = r\"\"\"K_0 = {}\nD_0 = {}\nL_S = {}\nD_S = {}\nPRESSURE = {}\nFORCE_PER_SURFACE_NODE = {}\nINNER_RADIUS = {} µm\nOUTER_RADIUS = {} µm\nINNER_NODE_SPACING = {} µm\nOUTER_NODE_SPACING = {} µm\nSURFACE_NODES = {}\nTOTAL_NODES = {}\"\"\".format(K_0, D_0, L_S, D_S, pressure, force_per_node, r_inner*1e6, r_outer*1e6, inner_spacing*1e6,\n                           outer_spacing*1e6, np.sum(mask_inner), len(coords))\n\n    with open(outfolder + \"\/parameters.txt\", \"w\") as f:\n        f.write(parameters)\n\n    # Create log file if activated\n    if logfile:\n        \n        # create log file with system output\n        logfile = open(outfolder + \"\/saeno_log.txt\", 'w')\n        cmd = Popen([\"saenopy\",\"CONFIG\",\"{}\/\/config.txt\".format(os.path.abspath(outfolder))], stdout=PIPE, \n                    universal_newlines=True, shell=False)\n        # print and save a reduced version of saeno log\n        for line in cmd.stdout:\n            if not '%' in line:\n                print (line, end='')\n                logfile.write(str(line))\n        # close again to avoid loops            \n        cmd.stdout.close()            \n        \n    # if false just show the non reduced system output    \n    else:\n        cmd = call([\"saenopy\",\"CONFIG\", \"{}\/\/config.txt\".format(os.path.abspath(outfolder))])\n\n    # copy result files from \"*_py2\" folder\n    for filename in glob(outfolder+'_py2\/*.*'):\n        shutil.copy(filename, outfolder)\n\n    # remove \"*_py2\" folder\n    shutil.rmtree(outfolder+'_py2')\n\n\ndef distribute(func, const_args, var_arg='pressure', start=0.1, end=1000, n=120, log_scaling=True, n_cores=None):\n    if n_cores is None:\n        n_cores = os.cpu_count()\n\n    if log_scaling:\n        values = np.logspace(np.log10(start), np.log10(end), n, endpoint=True)\n    else:\n        values = np.linspace(np.log10(start), np.log10(end), n, endpoint=True)\n\n    outfolder = const_args['outfolder']\n    del const_args['outfolder']\n\n    if not os.path.exists(outfolder):\n        os.makedirs(outfolder)\n\n    np.savetxt(outfolder+'\/'+var_arg+'-values.txt', values)\n\n    values = list(values)\n    index = list(np.arange(len(values)))\n    processes = []\n\n    \n    \n    while True:\n        if len(processes) < n_cores and len(values) > 0:\n            command = '''python -c \"import jointforces; import jointforces as jf; {}('''.format(func)\n            for key in const_args:\n                if isinstance(const_args[key], str):\n                    command += '''{}='{}','''.format(key, const_args[key])\n                else:\n                    command += '''{}={},'''.format(key, const_args[key])\n            command += '''outfolder='{}', {}={})\"'''.format(outfolder+'\/simulation'+str(index[0]).zfill(6), var_arg, values[0])\n            print (\"Simulations in the queue: \"+str(len(values)))\n            processes.append(Popen(command, shell='True'))\n            del values[0]\n            del index[0]\n\n        sleep(1.)\n\n        processes = [p for p in processes if p.poll() is None]\n\n        if len(processes) == 0:\n            break\n\n\ndef extract_deformation_curve(folder, x):\n    # get simulation parameters\n    with open(folder+'\/parameters.txt', 'r') as f:\n        lines = f.readlines()\n\n    parameters = {}\n    for line in lines:\n        try:\n            key, value = line.split('= ')\n            value = value.split(' ')[0]\n            parameters[key.strip()] = float(value.strip())\n        except:\n            pass\n\n    # load coordinates\n    coords = np.genfromtxt(folder + '\/R.dat')\n\n    # load displacements\n    displ = np.genfromtxt(folder + '\/U.dat')\n\n    # compute binned normed displacements and normed coordinates\n    u = np.sqrt(np.sum(coords ** 2., axis=1)) \/ (parameters['INNER_RADIUS']*10**-6)\n    v = np.sqrt(np.sum(displ ** 2., axis=1)) \/ (parameters['INNER_RADIUS']*10**-6)\n\n    y = np.array([np.nanmedian(v[(u >= x[i]) & (u < x[i + 1])]) for i in range(len(x) - 1)])\n\n    # save results\n    results = {'pressure': parameters['PRESSURE'], 'bins': x, 'displacements': y}\n    return results\n\n\ndef create_lookup_table(folder, x0=1, x1=50, n=100):\n    subfolders = glob(folder+'\/*\/')\n\n    x = np.logspace(np.log10(x0), np.log10(x1), n+1, endpoint=True)\n    x_center = 10**(0.5*(np.log10(x[1:]) + np.log10(x[:-1])))\n\n    pressure_values = []\n    displacement_curves = []\n\n    for subfolder in tqdm(subfolders):\n        res = extract_deformation_curve(subfolder, x)\n        pressure_values.append(res['pressure'])\n        displacement_curves.append(res['displacements'])\n\n    pressure_values = np.array(pressure_values)\n    displacement_curves = np.array(displacement_curves)\n\n    return {'pressure': pressure_values, 'x': x_center, 'y': displacement_curves}\n\n\ndef create_lookup_functions(lookup_table):\n    pressure = lookup_table['pressure']\n    distance = lookup_table['x']\n    displacement = lookup_table['y']\n\n    log_pressure = np.log(pressure)\n    log_distance = np.log(distance)\n\n    x, y = np.meshgrid(log_distance, log_pressure)\n\n    mask = ~(np.isnan(x) | np.isnan(y) | np.isnan(displacement))\n\n    x = x[mask]\n    y = y[mask]\n    displacement = displacement[mask]\n\n    f = LinearNDInterpolator(np.array([x, y]).T, displacement)\n\n    def get_displacement(distance, pressure):\n        return f(np.log(distance), np.log(pressure))\n\n    f_inv = LinearNDInterpolator(np.array([x, displacement]).T, y)\n\n    def get_pressure(distance, displacement):\n        return np.exp(f_inv(np.log(distance), displacement))\n\n    return get_displacement, get_pressure\n\n\ndef save_lookup_functions(get_displacement, get_pressure, outfile):\n    with open(outfile, 'wb') as f:\n        dill.dump((get_displacement, get_pressure), f)\n\n\ndef load_lookup_functions(file):\n    with open(file, 'rb') as f:\n        get_displacement, get_pressure = dill.load(f)\n    return get_displacement, get_pressure\n\n\n\ndef linear_lookup_interpolator(emodulus, output_newtable=\"new-lin-lookup.pkl\", reference_folder=None):\n    \"\"\"\n    Create individual lookup-tables for linear materials by shifting a reference lookuptable for a linear fiber material.\n    \n    For linear fiber materials the following relation is used:  k0 = 6 * E_Modulus  (for a possion ration of 0.25, see Steinwachs[2015]) \n    \n    Original simulation reached up to 10 000 Pa for a simulated k0 = 2364 (emodul ~394 Pa) - interpolation should be usefull for a wide range of\n     emoduli - however keep in mind that there might be limits for extreme Emoduli-pressures combination due to the range of the original simulations \n     (in such a case a constant maximal or minimal-pressure value will be returned since there are no better fitting simulations)\n    \n    emodulus:ArithmeticError Desired Youngs modulus for which the linear lookup table is created\n    reference_folder: Folder containing the reference lookup functions and reference interpolators to create\n    the new look up table; By default (None) will search for the reference files automatically  \n    output_newtable: name for the new reference table (needs .pkl ending)\n    \"\"\"\n    \n    # if not specified differently we find the correct reference files automatically\n    if not reference_folder:\n        import jointforces\n        reference_folder = os.path.join(jointforces.__file__,\"..\",\"..\",\"docs\",\"data\",\"linear_reference_table\")\n        \n    # load in  reference lookuptable to for a simulated k2364 (emodul ~394 Pa) up to 10 000 Pa \n    get_displacement_ref, get_pressure_ref = load_lookup_functions(os.path.join(reference_folder,'linear-ref-functions-k2364.pkl'))\n\n    # load in in reference interpolators\n    f_ref,f_inv_ref = load_lookup_functions(os.path.join(reference_folder,'linear-interp-f-finv-k2364.pkl')) \n    \n    # shift the table accordingly \n    def get_displacement_new(distance, pressure):\n        return f_ref(np.log(distance), np.log(pressure)) * 2364 \/(emodulus*6)\n\n    def get_pressure_new(distance, displacement):\n        return np.exp(f_inv_ref(np.log(distance), displacement)) * (emodulus*6)\/2364\n    \n    # save the new lookup functions\n    save_lookup_functions(get_displacement_new, get_pressure_new, output_newtable)\n\n    return get_displacement_new, get_pressure_new\n\n\n\ndef plot_lookup_table(lookup_table, pressure=[0,10000], log_scale = True, distance=[2,50], linewidth=2, n_lines = 1000, save_plot = None,\n                      fig_size=(5,4), figure=None, show=True):\n    \"\"\"\n    Create a figure of your (.pkl) material lookuptable\n    \n    lookup_table: path to .pkl file\n    pressure: pressure range which will be plotted as [pressure_min,pressure_max] in pascal (use the range that was used to calculate the lookuptable)\n    log_scale: plot logarithmically or linear if set to False\n    distance: The distance to the spheroid which is plotted on the x-axis; Unit is spheroid radii\n    linewidth: linewidth for the individual plots\n    n_lines: number of lines plotted between the minimal and maximal pressure\n    save_plot: saves the plot as png file if a path is given \n    \"\"\"\n    \n    import matplotlib.cm as cm \n    import matplotlib.colors as colors\n    import matplotlib.pyplot as plt\n    \n    # load lookup table\n    get_displacement, get_pressure = load_lookup_functions(lookup_table)\n    \n    ## to avoid scaling issue for log(0) \n    if pressure[0] == 0:\n        pressure[0] = 0.01     \n   \n    # define pressure range\n    if log_scale:\n        pressure_list = np.logspace(np.log(pressure[0])\/np.log(10), np.log(pressure[1])\/np.log(10),  num=n_lines, base=10)     \n    else:\n        pressure_list = np.arange(pressure[0],pressure[1], step = (pressure[1]-pressure[0])\/n_lines )\n      \n       \n      \n    # make cmaps\n    mycmap = cm.get_cmap('viridis')\n    mynorm = colors.LogNorm(vmin=np.min(pressure_list),vmax=np.max(pressure_list))   \n    c = mycmap(mynorm(pressure_list))\n\n    # make a colorbar\n    sm = plt.cm.ScalarMappable(cmap=mycmap, norm= mynorm)\n    sm.set_array(c)\n        \n    # create distance list\n    distance_list = np.arange(distance[0],distance[1], step =(distance[1]-distance[0]) \/ 1000 )\n    \n    \n    # get displacements for pressures list\n    displacement_list = [get_displacement(distance_list,i) for i in pressure_list]\n\n    # create a figure if no figure is specified\n    if figure is None:\n        figure = plt.figure(figsize=fig_size)\n\n    for i in range(len(displacement_list)):\n        plt.plot( distance_list , displacement_list[i], c= c[i],linewidth=linewidth,alpha=0.5)\n   \n    # set x,y limit - go a bit above minimum and maximum\n    plt.ylim(np.nanmin(displacement_list)-(0.1*np.nanmin(displacement_list)),\n             np.nanmax(displacement_list)+(0.1*np.nanmax(displacement_list)))\n    \n    # set log if activated and go even more above minimum\/maximum in log scale\n    if log_scale:\n        plt.loglog()\n        plt.ylim(np.nanmin(displacement_list)-(0.8*np.nanmin(displacement_list)),\n             np.nanmax(displacement_list)+(0.8*np.nanmax(displacement_list)))\n    \n    plt.grid(False) \n    plt.ylabel('Normalized matrix deformations (u\/r₀)', fontsize=10)           # plt.ylabel('Normed Deformation', fontsize=14)\n    plt.xlabel('Normalized distance from organoid center (r\/r₀)', fontsize=10) # plt.xlabel('Normed Distance', fontsize=14)\n    \n    # make a colorbar\n    cbar= plt.colorbar(sm, )\n    cbar.ax.get_yaxis().labelpad = 15\n    cbar.ax.set_ylabel('Pressure (Pa)', rotation=270 , fontsize=14)\n    plt.tight_layout()\n    # save plot if specified\n    if save_plot is not None:\n        plt.savefig(save_plot,dpi=500)  \n    # show figure if specified\n    if show==True:\n        plt.show()\n    return figure\n\n\ndef plot_lookup_data(lookup_table, data_folder, timesteps=[10,30,60], distance=[2,50], linewidth=2, \n              color_line=\"k\", color_raw=\"r\", scatter_raw_data = True, marker_size_scatter=0.1,\n              marker_size_mean=10,angle_filter=20, color_list = None,  plot_means = True,\n              label_list = None, timesteps_scatter=None , result_file_name =\"result.xlsx\"): \n    \"\"\"\n    plot the pressure for certain timesteps into the lookup table as a grey line;\n    scatter_raw_data option to vuisualize all deformtation-distance data at that timestep\n    \n    Use the function after calling \"plot_lookup_table\" to visualize a certain pressure within the created lookuptable\n    \n    lookup_table: path to .pkl filer\n    data_folder: path to the evaluated folder containing result.xlsx and the dis*.npy & seg*.npy data\n    timesteps: list of the timesteps to plot into the lookup function\n    scatter_raw_data: option to scatter the individual deformations\n    timesteps_scatter: might be used to scatter only several timesteps - if none identical to timesteps\n    angle_filter: use same value as in evaluation\n    if color_list & label_list is provided the given colors and labels are used when plotting the raw data\n    e.g color_list=[\"C0\",\"C1\",\"C2\"], label_list=[\"1h\",\"3h\",\"12h\"],\n    \n    timesteps_scatter: might be used to scatter only several timesteps - if timesteps_scatter=None identical to timesteps;\n    keep the same length as timesteps to asure same coloring :\n    e.g timesteps=[1,2,3] --> timesteps_scatter= [None,2,None]  to show only second element\n    \"\"\"   \n    import matplotlib.pyplot as plt\n    from glob import glob\n    from natsort import natsorted\n    from .simulation import load_lookup_functions\n    from .utils import load\n    from .force import infer_pressure\n    from tqdm import tqdm\n    \n    # scatter same timesteps if not spcified\n    if not timesteps_scatter:\n        timesteps_scatter = timesteps\n    \n    # read in the data\n    pressure = pd.read_excel(os.path.join(data_folder,result_file_name))[\"Mean Pressure (Pa)\"]\n    \n    # load lookup table\n    get_displacement, get_pressure = load_lookup_functions(lookup_table)\n    \n    # define pressure range  # -1 since pressure list is 1 element shorter \n    # compared to image list (differences are taken)\n    pressure_list = [pressure[i-1] for i in timesteps]\n    print (pressure_list)\n    \n    # create distance list\n    distance_list = np.arange(distance[0],distance[1], step =(distance[1]-distance[0]) \/ 1000 )\n\n    # get displacements for pressures list\n    displacement_list = [get_displacement(distance_list,i) for i in pressure_list]\n   \n    # draw simulations in uniform color\n    for i in range(len(displacement_list)):\n       plt.plot( distance_list , displacement_list[i], c= color_line, #linestyle=\"--\",\n                linewidth=linewidth,alpha=0.5,zorder=30)#, label=\"Simulation\") \n       if i==0: # plot label once\n           plt.plot( [] ,[] , c= color_line, #linestyle=\"--\",\n                    linewidth=linewidth,alpha=0.5,zorder=30, label=\"Simulations\") \n        \n    # read in segemntation\n    seg_files = natsorted(glob(data_folder+'\/seg*.npy'))[:np.nanmax(timesteps)]\n    \n    \n    # load deformations\n    # look for accumulated deformation files (new standard)\n    d_accumulated_files = natsorted(glob(data_folder+'\/def*.npy'))[:np.nanmax(timesteps)]  # do not calcualte more then the necessary time steps\n    # look also for not-accummulated deformations (old standard)\n    d_notaccumulated_files = natsorted(glob(data_folder+'\/dis*.npy'))[:np.nanmax(timesteps)]  # do not calcualte more then the necessary time steps\n    # if not-accumulated deformations are found chose different mode\n    if len(d_notaccumulated_files) > len(d_accumulated_files):\n        accumulated = False\n        dis_files = d_notaccumulated_files\n        print(\"Found not-accumulated deformation files (old standard) and will conduct calculations accordingly.\")\n    # else do the calcualtion with accumulated d eformations already\n    else:\n        accumulated = True\n        dis_files = d_accumulated_files\n\n\n    # initial spheroid radius and surface (used for force estimation)\n    r0 = load(seg_files[0])['radius']\n   \n    u_sum = None\n    v_sum = None\n    \n    distance_list_raw = []\n    displacement_list_raw = []\n    pressure_list_raw = []\n    \n    # loop over series of PIV results\n    for (dis_file, seg_file) in tqdm(zip(dis_files, seg_files)):\n        dis = load(dis_file)\n        seg = load(seg_file)\n\n        x_rav = np.ravel(dis['x'])\n        y_rav = np.ravel(dis['y'])\n        #print(\"data_points:\"+str(len(x_rav)))\n              \n        # get deformations\n        # sum up if we have not-accummulated deformations (old standard)\n        if accumulated == False:\n            try:\n                u_sum += np.ravel(dis['u'])\n                v_sum += np.ravel(dis['v'])\n            except:\n                u_sum = np.ravel(dis['u'])\n                v_sum = np.ravel(dis['v'])\n        # else read in accummulated deformations directly (new standard)\n        else:\n            u_sum = np.ravel(dis['u'])\n            v_sum = np.ravel(dis['v'])    \n            \n \n        cx, cy = seg['centroid']\n        distance_raw, displacement_raw, angle_raw, pressure_raw = infer_pressure(x_rav, y_rav, u_sum, v_sum, cx, cy, r0, get_pressure , angle_filter=angle_filter)\n        #print (len(distance_raw)) # length of valid datapoints after angle filter      \n          \n        # create list with accumulated deformations \n        distance_list_raw.append(distance_raw)\n        displacement_list_raw.append(displacement_raw)\n        pressure_list_raw.append(pressure_raw)\n        \n        \n    # SCATTERED RAW DATA\n    #now plot the accumulated raw data at the corresponding timepoints if activated;\n    # deformation and image data have a length difference of 1\n    if scatter_raw_data:\n        # in case colors and labels are defined; \n        if color_list and label_list:\n          for ci,t in enumerate(timesteps_scatter):\n            if t == None: #do not plot None elements \n                  continue\n            plt.scatter(distance_list_raw[t-1],displacement_list_raw[t-1],s=marker_size_scatter,zorder=20,c = color_list[ci])      \n        \n            ## calculate CoV of pressure values for 72h and add to plot\n            # if t == 3*70-2: #3*72:\n            #     mask = (distance_list_raw[t-1]>=5)&(distance_list_raw[t-1]<=10)\n                \n            #     data_masked = pressure_list_raw[t-1][mask]\n            #     CoV = np.std(data_masked)\/np.nanmean(data_masked)\n            #     print (len(data_masked))\n            #     print (len(distance_list_raw[t-1]))\n            #     print (CoV)\n                \n            #     plt.text(0.05,0.93,s=f\"CoV (72h; 5-10r): {np.around(CoV,3)}\",\n            #              transform=plt.gca().transAxes, zorder=200,\n            #              fontsize=11,c=\"darkred\")\n            \n        \n        # else same color for all here\n        else: \n           for ci,t in enumerate(timesteps_scatter):\n            if t == None: #do not plot None elements\n                  continue\n            plt.scatter(distance_list_raw[t-1],displacement_list_raw[t-1],s=marker_size_scatter,zorder=20,c = color_raw) # deformation and image data have a length difference of 1\n        \n        \n    # PLOT THE MEAN RAW DATA\n    if color_list and label_list:\n        for ci,t in enumerate(timesteps):\n            if plot_means == False:\n                continue\n            # calculate the mean in distance windows for timesteps\n            mean_distance = []\n            mean_displacement = []\n            for i in range(distance[0],int(np.max(distance_list_raw[t-1]))):\n                mean_distance.append(i+0.5)\n                mean_disp = np.nanmean(displacement_list_raw[t-1][(distance_list_raw[t-1]>=i) & (distance_list_raw[t-1]<i+1)])\n                mean_displacement.append(mean_disp)\n            plt.plot(mean_distance,mean_displacement,\"o-\",ms=marker_size_mean, zorder=2000, \n                     linewidth=linewidth,  markerfacecolor=\"w\",  markeredgecolor=color_list[ci], \n                     markeredgewidth=2 , label=label_list[ci], color=\"w\" )     \n        ax = plt.legend( markerscale=0.4, fontsize=6.5,loc=\"upper right\")\n        ax.set_zorder(2000)\n    else: \n         for ci,t in enumerate(timesteps):\n            if plot_means == False:\n              continue\n            # calculate the mean in distance windows for timesteps\n            mean_distance = []\n            mean_displacement = []\n            for i in range(distance[0],int(np.max(distance_list_raw[t-1]))):\n                mean_distance.append(i+0.5)\n                mean_disp = np.nanmean(displacement_list_raw[t-1][(distance_list_raw[t-1]>=i) & (distance_list_raw[t-1]<i+1)])\n                mean_displacement.append(mean_disp)\n            plt.plot(mean_distance,mean_displacement,\"o-\",ms=marker_size_mean,zorder=2000,\n                     linewidth=linewidth, markerfacecolor=\"w\",color =\"w\",\n                     markeredgecolor=color_raw, markeredgewidth=2)   \n        #plt.xlim(2,20);plt.ylim(1e-4,3) \n\n    return \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_576","text":"import pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nhousePrice = pd.read_csv('metroMelbHousePrices.csv',encoding = 'ISO-8859-1')\ncommute = pd.read_csv('metroMelbCommuteDistance.csv',encoding = 'ISO-8859-1')\ndistance = pd.read_csv('distanceToCBD.csv',encoding = 'ISO-8859-1')\n\ndf = pd.merge(housePrice,commute,on='postcode')\ndf = df.sort_values('medPrice')\nplt.scatter(df['medCommute'], df['medPrice'])\nplt.xlabel('medCommute (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\n\nx = np.array(df['medCommute'])\ny = np.array(df['medPrice'])\nm,b = np.polyfit(x, y, 1)\nplt.plot(x, m*x + b)\nplt.savefig('withOutliers.png')\n\n##Outlier Detection using IQR\n# Keep only values inside the IQR\nQ1 = df['medPrice'].quantile(0.25)\nQ3 = df['medPrice'].quantile(0.75)\n\nQ1b = df['medCommute'].quantile(0.25)\nQ3b = df['medCommute'].quantile(0.75)\n\ndf1 = df.loc[df['medPrice'] > Q1]\ndf1 = df1.loc[df1['medCommute'] > Q1b]\ndf2 = df1.loc[df1['medPrice'] < Q3]\ndf2 = df2.loc[df2['medCommute'] < Q3b]\n\n# re-plot\nplt.clf()\nplt.scatter(df2['medCommute'], df2['medPrice'])\nplt.xlabel('medCommute (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\nx = np.array(df2['medCommute'])\ny = np.array(df2['medPrice'])\nm,b = np.polyfit(x, y, 1)\nplt.plot(x, m*x + b)\nplt.savefig('noOutliersIQR.png')\n\n# z-score outlier detection #########################################################################\nfrom scipy import stats\n\ndf['zPrice'] = np.abs(stats.zscore(df['medPrice']))\ndf['zCommute'] = np.abs(stats.zscore(df['medCommute']))\ndf1 = df.iloc[np.where(df['zPrice'] < 2)]\ndf2 = df.iloc[np.where(df1['zCommute'] < 2)]\n\n# re-plot\nplt.clf()\nplt.scatter(df2['medCommute'], df2['medPrice'])\nplt.xlabel('medCommute (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\nx = np.array(df2['medCommute'])\ny = np.array(df2['medPrice'])\nm,b = np.polyfit(x, y, 1)\nplt.plot(x, m*x + b)\nplt.savefig('noOutliersZSCORE2STD.png')\n\n\ndf1 = df.iloc[np.where(df['zPrice'] < 1)]\ndf2 = df.iloc[np.where(df1['zCommute'] < 1)]\n# re-plot\nplt.clf()\nplt.scatter(df2['medCommute'], df2['medPrice'])\nplt.xlabel('medCommute (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\nx = np.array(df2['medCommute'])\ny = np.array(df2['medPrice'])\nm,b = np.polyfit(x, y, 1)\nplt.plot(x, m*x + b)\nplt.savefig('noOutliersZSCORE1STD.png')\n\n\n################################################################################\nplt.clf()\ndf = pd.merge(housePrice,distance,on='postcode')\ndf = df.sort_values('medPrice')\nplt.scatter(df['distance'], df['medPrice'])\nplt.xlabel('distance (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\n\ndf['zPrice'] = np.abs(stats.zscore(df['medPrice']))\ndf['zDistance'] = np.abs(stats.zscore(df['distance']))\ndf1 = df.iloc[np.where(df['zPrice'] < 2)]\ndf2 = df.iloc[np.where(df1['zDistance'] < 2)]\n\n# re-plot\nplt.clf()\nplt.scatter(df2['distance'], df2['medPrice'])\nplt.xlabel('distance (km)')\nplt.ylabel('medPrice ($)')\nplt.grid(True)\nx = np.array(df2['distance'])\ny = np.array(df2['medPrice'])\nm,b = np.polyfit(x, y, 1)\nplt.plot(x, m*x + b)\nplt.savefig('DISTANCEnoOutliersZSCORE2STD.png')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_578","text":"<reponame>jernelv\/SpecAnalysis\n\nimport numpy as np\nimport scipy\n\ndef Der(x,y):\n\t\"\"\"Function for finding first derivative of spectral data. Uses finite differences.\"\"\"\n\tn=len(x)\n\tx2=np.zeros(n-1)\n\ty2=np.zeros(n-1)\n\tfor i in range(n-1):\n\t\tx2[i]=0.5*(x[i]+x[i+1])\n\t\ty2[i]=(y[i+1]-y[i])\/(x[i+1]-x[i])\n\treturn(x2,y2)\n\ndef Der2(x,y):\n\t\"\"\"Function for finding second derivative of spectral data. Uses finite differences.\"\"\"\n\tn=len(x)\n\tx2=np.zeros(n-2)\n\ty2=np.zeros(n-2)\n\tdx2=(x[1]-x[0])**2 # assumed constant\n\tfor i in range(n-2):\n\t\tx2[i]=x[i+1]\n\t\ty2[i]=(y[i]-2*y[i+1]+y[i+2])\/dx2\n\treturn(x2,y2)\n\ndef mlr(x,y,order):\n\t\"\"\"Multiple linear regression fit of the columns of matrix x\n\t(dependent variables) to constituent vector y (independent variables)\n\torder -     order of a smoothing polynomial, which can be included\n\tin the set of independent variables. If order is\n\tnot specified, no background will be included.\n\tb -         fit coeffs\n\tf -         fit result (m x 1 column vector)\n\tr -         residual   (m x 1 column vector)\n\t\"\"\"\n\tif order > 0:\n\t\ts=scipy.ones((len(y),1))\n\t\tfor j in range(order):\n\t\t\ts=scipy.concatenate((s,(scipy.arange(0,1+(1.0\/(len(y)-1))-0.5\/(len(y)-1),1.0\/(len(y)-1))**j)[:,nA]),1)\n\t\tX=scipy.concatenate((x, s),1)\n\telse:\n\t\tX = x\n\tb = scipy.dot(scipy.dot(scipy.linalg.pinv(scipy.dot(scipy.transpose(X),X)),scipy.transpose(X)),y)\n\tf = scipy.dot(X,b)\n\tr = y - f\n\treturn b,f,r\n\ndef emsc(case, order, fit=None):\n\t\"\"\"Extended multiplicative scatter correction\n\tcase -   spectral data for background correction\n\torder -     order of polynomial\n\tfit -       if None then use average spectrum, otherwise provide a spectrum\n\t\t\t\tas a column vector to which all others fitted\n\tcorr -      EMSC corrected data\n\tmx -        fitting spectrum\n\t\"\"\"\n\tif not type(fit)==type(None):\n\t\tmx = fit\n\telse:\n\t\tmx = scipy.mean(case,axis=0)[:,nA]\n\tcorr = scipy.zeros(case.shape)\n\tfor i in range(len(case)):\n\t\tb,f,r = mlr(mx, case[i,:][:,nA], order)\n\t\tcorr[i,:] = scipy.reshape((r\/b[0,0]) + mx, (corr.shape[1],))\n\tcorr=np.nan_to_num(corr)\n\treturn corr\n\ndef baseline_corr(case):\n\t\"\"\"Baseline correction that sets the first independent variable of each\n\tspectrum to zero.\"\"\"\n\tsize = case.shape\n\tsubtract = scipy.transpose(scipy.resize(scipy.transpose(case[:,0]),(size[1],size[0])))\n\treturn (case-subtract)\n\ndef baseline_avg(case):\n\t\"\"\"Baseline correction that subtracts an average of the first and last\n\tindependent variable from each variable.\"\"\"\n\tsize = case.shape\n\tsubtract = scipy.transpose(scipy.resize(scipy.transpose((case[:,0]+case[:size[1]-1])\/2),(size[1],size[0])))\n\treturn (case-subtract)\n\ndef baseline_linear(case):\n\t\"\"\"Baseline correction that subtracts a linearly increasing baseline between\n\tthe first and last independent variable.\"\"\"\n\tsize, t = case.shape, 0\n\tsubtract = scipy.zeros((size[0],size[1]), 'd')\n\twhile t < size[0]:\n\t\ta = case[t,0]\n\t\tb = case[t,size[1]-1]\n\t\tdiv = (b-a)\/size[1]\n\t\tif div == 0:\n\t\t\tdiv = 1\n\t\tarr = scipy.arrange(a,b,div,'d')\n\t\tsubtract[t,:] = scipy.resize(arr,(size[1],))\n\t\tt = t+1\n\treturn case-subtract\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_579","text":"# test hamiltonian\n\nimport numpy as np \nimport matplotlib.pyplot as plt \nfrom scipy.linalg import eig_banded\n\nVq = np.array([-0.5, -0.25])*10\nnbasis = 20\nmax_pos_freq = len(Vq)\nhamiton_mat = np.zeros((max_pos_freq, nbasis), dtype=np.complex64)\nfor i in range(max_pos_freq):\n    for j in range(i, nbasis):\n        if i==0:\n            hamiton_mat[max_pos_freq-1, j] = Vq[0]\n        else:\n            hamiton_mat[max_pos_freq-i-1, j] = Vq[i]\n\nh = np.zeros((nbasis, nbasis))\nfor i in range(nbasis):\n    h[i, i] = Vq[0]\n    for j in range(i+1, nbasis):\n        if j-i>1:\n            break\n        else:\n            h[i, j] = h[j, i] = Vq[1]\n\nEn_k, Uq_k = eig_banded(hamiton_mat, overwrite_a_band=True, select='a')\nw, v = np.linalg.eigh(h)\n\nprint(w - En_k)\nplt.matshow(v.real - Uq_k.real)\nplt.colorbar()\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_580","text":"<gh_stars>1-10\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\n\"\"\" layer module\n\nA layer is a collection of bases (see base module) that have the same bottom-up\nand top-down input from adjacent layers.\n\n\"\"\"\n\nimport scipy as sp\nfrom scipy.misc import toimage\n\nimport utils\nimport config\nfrom base import *\n\nimport pycuda_convolution\n#conv = scipy.signal.convolve\nconv = pycuda_convolution.convolve_gpu\n\n# -----------------------------------------------------------------------------\nclass Layer:\n    def __init__(self, model, label, prv_layer=None):\n        \"\"\" Constructor\n        \n        Input:\n            model -- a dict containing the structure and parameters of the layer\n            label -- label assigned to the layer (e.g. \"Layer 1\")\n            prv_layer -- pointer to the previous layer in the network\n        \n        \"\"\"\n\n        # -- copy parameter values to class data members\n        self.model = model\n        self.label = label\n        self.prv_layer = prv_layer\n\n        # -- copy values from model to class data members, to improve code\n        # readability\n        self.block_shape = model['block_shape']\n        self.btmup_window_shape = model['btmup_window_shape']\n        print \"LAYER:BUWS = \", self.btmup_window_shape\n        self.epsilon = model['epsilon']\n        self.regL2 = model['regL2']\n        self.pbias = model['pbias']\n        self.pbias_lambda = model['pbias_lambda']\n        self.init_bias = model['init_bias']\n        self.vbias = model['vbias']\n        self.std_gaussian = model['sigma_start']\n        self.CD_steps = model['CD_steps']\n\n        # amount of change made in the bias of the visible layer while updating\n        self.vbias_inc = 0\n        \n        # a list to hold the errors at each training cycle of the epoch\n        self.epoch_err = []  \n\n        # -- determine the shape of the input vector, depending on whether this \n        # is the first layer in the network.\n        # -- If this is not the first layer\n        if (prv_layer):\n            self.num_channels = len(prv_layer.bases)\n            inshape = prv_layer.output_shape\n        # -- for the first layer\n        else:\n            self.num_channels = model['num_channels']\n            inshape = model['input_data_shape']\n\n        wshape = self.btmup_window_shape  # convolution window shape\n        pshape = self.block_shape  # pooling shape\n\n        # trim the output of the previous layer to be used for maxpooling\n        self.input_shape = utils.trim_array_maxpool(arr_shape=inshape, \\\n                                                     conv_window_shape=wshape, \\\n                                                     pooling_shape=pshape)\n\n        # -- shape of hidden units in each base of the layer\n        h = self.input_shape[0] - self.btmup_window_shape[0] + 1\n        w = self.input_shape[1] - self.btmup_window_shape[1] + 1\n        self.hidden_shape = (h, w)\n\n        # -- shape of output (pooling) units in each base of the layer\n        h = self.hidden_shape[0] \/ self.block_shape[0]\n        w = self.hidden_shape[0] \/ self.block_shape[1]\n        self.output_shape = (h,w)\n\n        # negative data, i.e. network's belief\n        self.neg_data = np.zeros((self.input_shape[0], \\\n                                    self.input_shape[1], self.num_channels))\n        \n        # positive data - input from previus layer (raw input if first layer)\n        self.pos_data = np.zeros((self.input_shape[0],\n                                    self.input_shape[1], self.num_channels))\n\n        # list of bases in the layer\n        self.bases = []\n        # -- create the bases\n        for i in range(model['num_bases']):\n            self.bases.append(Base(self))\n            \n#-----------------------------------------------------------------------------\n    def init_weights_using_prvlayer(self):\n        \"\"\" Weight Initialization\n\n        Initilizes the weights of the layer using input from the prv_layer.\n        Using this sort of initialization is expected to speed up the\n        convergence. However, it is not used in this current version since\n        using random initial weights is a better verification test for the\n        network.\n        \n        \"\"\"\n\n        # make sure there is a previous layer\n        if config.DEBUG_MODE:\n            assert self.prv_layer != None\n\n        # for each base in the layer, grab a random patch of the previous\n        # layer's output and assign the base's weights to the output values\n        for base in self.bases:\n            x_start = np.random.randint(0, self.prv_layer.output_shape[0] - base.Wb.shape[0])\n            y_start = np.random.randint(0, self.prv_layer.output_shape[1] - base.Wb.shape[1])\n            \n            x_end = x_start + base.Wb.shape[0]\n            y_end = y_start + base.Wb.shape[1]\n            \n            for i in range(self.num_channels):\n                c = 10e-5\n                base.Wb[:, :, i] = c * self.prv_layer.bases[i].pooling_units[x_start:x_end, y_start:y_end]\n\n#-----------------------------------------------------------------------------\n    def update(self, learn = False):\n        \"\"\" Update Layer\n        \n        Performs Gibbs sampling of the layer's state variables (given the\n        previous layer), and then updates the parameters and weights\n        accordingly. Here is the steps performed:\n            1) Sample each base given \n        \n        Input:\n            layer_to_learn -- index of the layer to be learned\n        \n        \"\"\"\n        \n        # ------------------------- Prositive Phase --------------------------\n        print \"\\nPositive phase for \", self.label, \"...\"\n        \n        #timer = utils.Timer('positive phase')\n        #with timer:  # measures the time\n        #print \"self.pos_data:\", self.pos_data\n        for base in self.bases:\n            base.pos_sample()\n            \n        # ------------------------- Negative Phase ---------------------------\n        # -- computes P(v|h) : Equation at the end of Section 2.3 in the paper\n        print \"Negative phase for\", self.label, \"...\"\n        #timer = utils.Timer('negative phase')\n        #with timer:  # measures the time\n        # perform the following Gibbs sampling steps, CD_steps times\n        for step_idx in xrange(self.CD_steps):\n            # -- compute the negative data given the hidden layer\n            self.neg_data[:, :, :] = 0\n            for base in self.bases:\n                for channel in range(base.num_channels):\n                    w =  base.Wb[:, :, channel]\n                    self.neg_data[:, :, channel] += conv(base.pos_states, w,\n                                                                        'full')\n            self.neg_data += self.vbias\n    \n            # -- debugging assertion\n            if config.DEBUG_MODE:\n                assert ~np.isnan(self.neg_data).any()\n\n\n\n            for base in self.bases:\n                base.neg_sample()\n                \n\n        # -- compute the error as Euclidean distance between positive and\n        # negative data\n        err = np.mean( (utils.normalize_image(self.pos_data, 0, 1) -\n                                    utils.normalize_image(self.neg_data, 0, 1))**2)\n        self.epoch_err.append(err)\n        print \"Mean error so far: %.3f\" % np.mean(self.epoch_err)\n        \n\n        # -- update the bases only if this layer is being currently        \n        # learned\n        for base in self.bases:\n            # -- reset some book keeping values\n            base.bias_inc = 0\n            base.Wb_inc = 0\n            if (learn == True):\n                base.update()\n\n        self.vbias_inc = 0\n        if (learn == True):\n            # -- update the visible layer (prevous layer) bias\n            print \"Update phase for\", self.label, \"...\"\n            # Gradient Descent change\n            dV_GD = np.mean(self.pos_data - self.neg_data)\n            self.vbias_inc = self.epsilon * dV_GD\n            self.vbias += self.vbias_inc\n        \n            # print the current state variables of the layer\n            self.print_statistics()\n\n#-----------------------------------------------------------------------------\n    def print_statistics(self):\n        \"\"\" Print Statistics\n\n        Prints the current state variables of the network, including sparsity\n        of units' activation, length and change of the weight vector, hidden\n        and visible baises, as well as length of the positive and negative data\n        vectors.\n\n        \"\"\"\n        \n        W_sum = 0\n        Winc_sum = 0\n        Hb_sum = 0\n        Hbinc_sum = 0\n        S_sum = 0\n        # -- update the bases only if this layer is being currently\n        # learned\n        for base in self.bases:\n            W_sum += np.sum(base.Wb) ** 2\n            Winc_sum += np.sum(base.Wb_inc) ** 2\n            S_sum += np.sum(base.pos_states)\n            Hb_sum += base.bias ** 2\n            Hbinc_sum += base.bias_inc ** 2\n            \n        num_units = len(self.bases) * self.hidden_shape[0] *self.hidden_shape[1]\n        print self.label, \": Sparsity measure: %.2f percent\" % (100 * float(S_sum)\/num_units)\n        print self.label, \": ||W|| = %.2f ||dW|| = %.5f\" % (np.sqrt(W_sum), np.sqrt(Winc_sum))\n        print self.label, \": ||Hb|| = %.2f  ||dHb|| = %.5f\" % (np.sqrt(Hb_sum), np.sqrt(Hbinc_sum))\n        print self.label, \": ||Vb|| = %.5f  ||dVb|| = %.6f\" % (abs(self.vbias), abs(self.vbias_inc))\n\n\n#-----------------------------------------------------------------------------\n    def biases_for_visualization(self, tile_shape):\n        \"\"\" Visualize Biases\n        \n        Prepares a visualization array for the hidden biases of the bases in\n        the layer\n        \n        Input:\n            tile_shape -- shape used to arrange the values for different bases\n\n        Output:\n             ret_array -- 2D array containing visualization of biases for \n                          each base in the shape tile_shape\n        \n        \"\"\"\n        \n        all_biases = []\n        for base in self.bases:\n            all_biases.append(base.bias)\n        ret_array = np.array(all_biases).reshape(tile_shape)\n        return ret_array\n        \n\n#-----------------------------------------------------------------------------\n    def simple_activations_for_visualization(self, tile_shape):\n        \"\"\" Visualize Activations\n        \n        Prepares a visualization array for the hidden activations of the bases\n        in the layer\n        \n        Input:\n            tile_shape -- shape used to arrange the values for different bases\n\n        Output:\n             ret_array -- 2D array containing visualization of activations \n                          for each base in the shape tile_shape\n        \n        \"\"\"\n        \n        all_acts = [] \n        for base in self.bases:\n            all_acts.append(base.pos_activation)\n\n        ret_array = np.array(all_acts).reshape(tile_shape)\n        return ret_array\n\n    def avg_filters_for_visualization(self, tile_shape, dir_path=\".\/\", save=False):\n        \"\"\" Visualize Filters\n        \n        Prepares a visualization array for the filters of the bases in the\n        layer. Filter for each base is computed as a weighted linear\n        combination of the filters in the previous layer, where the weight to\n        each filter in the previous layer is proportional to the sum of\n        weights (weight vector of the network) originated from that base.\n        \n        \n        Inputs:\n            tile_shape -- shape used to arrange the values for different bases\n            dir_path -- path to save the result image\n            save -- whether to save the image to a file as well\n        \n        Output:\n            all_weights -- 2D array containing visualization of filters\n                            for each base in the shape tile_shape\n        \n        \"\"\"\n\n        # not implemeted for layer 1 yet\n        if self.prv_layer == None:\n            return\n\n        filt_height = self.prv_layer.btmup_window_shape[0] + self.btmup_window_shape[0] - 1\n        filt_width = self.prv_layer.btmup_window_shape[1] + self.btmup_window_shape[1] - 1\n\n        filt_size = filt_height * filt_width\n        all_filters = np.zeros((len(self.bases), filt_size))\n        \n        for base_idx in range(len(self.bases)):\n            base_filter = np.zeros((filt_height, filt_width))\n            for cnl_idx in range(len(self.prv_layer.bases)):\n                # TODO: should be prv_layers's filter\n                reg = 1\n                if np.isnan((self.bases[base_idx].Wb.any())):\n                    print \"NaN weights while visualizing filters!\"\n                    exit(1)\n                base_filter += conv(self.bases[base_idx].Wb[:, :, cnl_idx]**reg, self.prv_layer.bases[cnl_idx].Wb[:, :, 0], 'full')\n\n            all_filters[base_idx, :] = np.reshape(base_filter, filt_size)\n\n        img_shape = (filt_height, filt_width)\n        all_filters = utils.tile_raster_images(all_filters, img_shape, tile_shape, tile_spacing = (1,1))\n        all_filters = utils.normalize_image(all_filters)\n\n        if save:\n            # -- save the visualization array to a PNG file\n            filename = dir_path + \"\/\" + self.label + \"-filters.jpg\"\n            #img = toimage(all_filters)\n            #img.save(filename)\n            scipy.misc.imsave(filename, all_filters)\n\n\n            #if config.DEBUG_MODE:\n                #img.show()\n\n            print \"Filters of\", self.label, \"were saved to\", filename\n        \n        return all_filters\n\n#-----------------------------------------------------------------------------\n    def weights_for_visualization(self, channel, tile_shape, dir_path=\".\/\", save=False):\n        \"\"\" Visualize Weights\n        \n        Prepares a visualization array for the bottom-up weights of the bases\n        in the layer\n        \n        Input:\n            channel -- index of the channel to whose corresponding weights will\n                        be shown\n            tile_shape -- shape used to arrange the values for different bases\n\n        Output:\n             all_weights -- 2D array containing visualization of weights for \n                            the specified channel of each base in the shape \n                            tile_shape\n        \n        \"\"\"\n        \n        w_size = self.bases[0].Wb.shape[0]*self.bases[0].Wb.shape[1]\n        all_weights = np.zeros((len(self.bases), w_size))\n        \n        for i in range(all_weights.shape[0]):\n            if channel == None:\n                for cnl in range(self.num_channels):\n                    all_weights[i] += np.reshape(self.bases[i].Wb[:, :, cnl], w_size)\n            else:\n                all_weights[i] = np.reshape(self.bases[i].Wb[:, :, channel], w_size)\n            \n        img_shape = (self.bases[0].Wb.shape[0], self.bases[0].Wb.shape[1])\n        all_weights = utils.tile_raster_images(all_weights, img_shape, tile_shape, tile_spacing = (1,1))\n        all_weights = utils.normalize_image(all_weights)\n\n        if save:\n            # -- save the visualization array to a PNG file\n            filename = dir_path + \"\/\" + self.label + \"-cnl_\" + str(channel) + \"-weights.jpg\"\n            #img = toimage(all_weights)\n            #img.save(filename)\n            scipy.misc.imsave(filename, all_weights)\n\n            #if config.DEBUG_MODE:\n                #img.show()\n\n            print \"Weights of\", self.label, \"were saved to\", filename\n            \n        return all_weights\n\n#-----------------------------------------------------------------------------\n    def posstates_for_visualization(self, tile_shape):\n        \"\"\" Visualize Positive States\n        \n        Prepares a visualization array for the states of the hidden units \n        of the bases in the layer inferred by positive data  \n        \n        Input:\n            tile_shape -- shape used to arrange the values for different bases\n\n        Output:\n             all_states -- 2D array containing visualization of activations \n                           for each base in the shape tile_shape\n        \n        \"\"\"\n        \n        s_size = self.bases[0].pos_states.shape[0]*self.bases[0].pos_states.shape[1]\n        all_states = np.zeros((len(self.bases), s_size))\n\n        for i in xrange(all_states.shape[0]):\n            all_states[i] = np.reshape(self.bases[i].pos_states, s_size)\n            \n        img_shape = self.bases[0].pos_states.shape\n        all_states = utils.tile_raster_images(all_states, img_shape, tile_shape, tile_spacing = (1,1))\n        all_states = utils.normalize_image(all_states)\n        return all_states\n\n#-----------------------------------------------------------------------------\n    def output_for_visualization(self, tile_shape, tile_spacing):\n        \"\"\" Visualize Outputs\n        \n        Prepares a visualization array for the output of the bases in the \n        layer (taken from the pooling units)\n        \n        Input:\n            tile_shape -- shape used to arrange the values for different bases\n            tile_spacing -- number of space to put in between tiles of the\n                            output array to make neighboring tiles \n                            distinguishable\n\n        Output:\n             ret_array -- 2D array containing visualization of outputs\n                          for each base in the shape tile_shape\n        \n        \"\"\"\n        \n        size = self.bases[0].pooling_units.size\n        all_outputs = np.zeros((len(self.bases), size))\n\n        for i in xrange(all_outputs.shape[0]):\n            all_outputs[i] = np.reshape(self.bases[i].pooling_units, size)\n            \n        img_shape = self.bases[0].pooling_units.shape\n        all_outputs = utils.tile_raster_images(all_outputs, img_shape, tile_shape, tile_spacing)\n        all_outputs = utils.normalize_image(all_outputs)\n        return all_outputs\n\n#-----------------------------------------------------------------------------\n    def visualize_to_files(self, tile_shape, dir_path):\n        \"\"\"\n\n        Saves the weight vector, and filters to files as images. More images\n        can easily be added if needed.\n\n        \"\"\"\n        \n        for cnl in range(self.num_channels):\n            print \"Saving to file\", cnl\n            self.weights_for_visualization(cnl, tile_shape, dir_path, save=True)\n\n        self.avg_filters_for_visualization(tile_shape, dir_path, save=True)\n\n        # -- visualize the positive data\n        # -- visualize the negagive data\n        for cnl in range(self.num_channels):\n            img = toimage(self.pos_data[:, :, cnl])\n            filename = dir_path + \"\/\" + self.label + \"-cnl_\" + str(cnl) + \"-pos_data.png\"\n            img.save(filename)\n            \n            img = toimage(self.neg_data[:, :, cnl])\n            filename = dir_path + \"\/\" + self.label + \"-cnl_\" + str(cnl) + \"-neg_data.png\"\n            img.save(filename)\n        \n        filename = dir_path + \"\/\" + self.label + \"-poooling.png\"\n        all_outputs = self.output_for_visualization(tile_shape, tile_spacing = (1,1))\n        scipy.misc.imsave(filename, all_outputs)\n        \n        \n#-----------------------------------------------------------------------------\n    def visualize_bu_weights(self, label):\n        \n        all_weights = self.weights_for_visualization()\n        img = Image.frombuffer('L', (all_weights.shape[1], all_weights.shape[0]), all_weights, \"raw\", 'L', 0, 1)\n        img = img.resize((img.size[0]*5, img.size[1]*5), Image.NEAREST)\n        #img.show()\n        #img.save(label + \".tif\")\n        \n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_581","text":"<gh_stars>1-10\n# -*-coding:UTF-8–*-\r\n\r\nfrom scipy import integrate\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib.animation import FuncAnimation\r\nfrom web.rcdata import *\r\nimport os\r\nimport time\r\n\r\n# Build paths inside the project like this: os.path.join(BASE_DIR, ...)\r\nBASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\r\nIMAGE_DIR = os.path.join(BASE_DIR, 'templates\/web\/images')\r\n\r\n\r\nclass RC:\r\n    # def __init__(self, b, h, rc_type, A_s, steel_type, mode):\r\n    def __init__(self, shape, rc_type, A_s, steel_type, mode):\r\n\r\n        # 初始化RC样本\r\n        _fcuk = [15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80]\r\n        _fc = [7.2, 9.6, 11.9, 14.3, 16.7, 19.1, 21.2, 23.1, 25.3, 27.5, 29.7, 31.8, 33.8, 35.9]\r\n        _fy = [270, 300, 360, 435]\r\n        _Es = [2.1 * 1e5, 2.0 * 1e5, 2.0 * 1e5, 2.0 * 1e5]\r\n\r\n        self.timestamp = str(round(time.time() * 1000)) # timestamp\r\n        # shape\r\n        self.shape = shape['shape']\r\n        if self.shape == Shape_Type.REC:\r\n            self.b = shape['b']\r\n            self.h = shape['h']\r\n        elif self.shape == Shape_Type.T:\r\n            self.b = shape['b']\r\n            self.h = shape['h']\r\n            self.bf = shape['bf']\r\n            self.hf = shape['hf']\r\n        elif self.shape == Shape_Type.CIR:\r\n            self.h = shape['d_out']\r\n            self.r = shape['d_out'] \/ 2\r\n        elif self.shape == Shape_Type.RING:\r\n            self.h = shape['d_out']\r\n            self.r_in = shape['d_in'] \/ 2\r\n            self.r_out = shape['d_out'] \/ 2\r\n            self.thickness = self.r_out - self.r_in\r\n\r\n        self.index = rc_type.value\r\n        self.f_c = _fc[self.index]\r\n        self.f_cuk = _fcuk[self.index]\r\n        self.A_s = A_s\r\n        self.f_y = _fy[steel_type.value]\r\n        self.E_s = _Es[steel_type.value]\r\n        self.mode = mode\r\n\r\n        # TODO\r\n        #    修改GZH\r\n        if mode == Mode.GZH:\r\n            # epsilon 10^-6\r\n            _epsilon_0 = [1370, 1470, 1560, 1640, 1720, 1790, 1850, 1920, 1980, 2030, 2080, 2130, 2190, 2240]\r\n            _alpha_a = [2.21, 2.15, 2.09, 2.03, 1.96, 1.9, 1.84, 1.78, 1.71, 1.65, 1.65, 1.65, 1.65]\r\n            _alpha_d = [0.41, 0.74, 1.06, 1.36, 1.65, 1.94, 2.21, 2.48, 2.74, 3.00, 3.25, 3.50, 3.75]\r\n            # epsilon_u_over_0 = [4.2, 3.0, 2.6, 2.3, 2.1, 2.0, 1.9, 1.9, 1.8, 1.8, 1.7, 1.7, 1.7, 1.6]\r\n            self.epsilon_0 = _epsilon_0[self.index] * 1e-6\r\n            self.alpha_a = _alpha_a[self.index]\r\n            self.alpha_d = _alpha_d[self.index]\r\n            # 此处实质上为epsilon_cu 注意和epsilon_u的区别，书P33，此处按GB取\r\n            # self.epsilon_u = 3300\r\n            self.epsilon_u = (0.0033 - (self.f_cuk - 50) * 1e-6) if (\r\n                    0.0033 - (self.f_cuk - 50) * 1e-6 <= 0.0033) else 0.0033\r\n\r\n            # 插值求参数\r\n            # self.epsilon_0 = (_epsilon_0[self.index + 1] - _epsilon_0[self.index]) \/ 5 * (\r\n            #         self.f_c - _fcuk[self.index]) + \\\r\n            #                  _epsilon_0[self.index]  # \/5\r\n            # self.alpha_a = (_alpha_a[self.index + 1] - _alpha_a[self.index]) \/ 5 * (\r\n            #         self.f_c - _fcuk[self.index]) + _alpha_a[self.index]\r\n            # self.alpha_d = (_alpha_d[self.index + 1] - _alpha_d[self.index]) \/ 5 * (\r\n            #         self.f_c - _fcuk[self.index]) + _alpha_d[self.index]\r\n\r\n        elif mode == Mode.GB:\r\n            self.n = 2 - 1 \/ 60 * (self.f_cuk - 50) if 2 - 1 \/ 60 * (self.f_cuk - 50) <= 2 else 2\r\n            self.epsilon_0 = (0.002 + 0.5 * (self.f_cuk - 50) * 1e-6) if (0.002 + 0.5 * (\r\n                    self.f_cuk - 50) * 1e-6 >= 0.002) else 0.002\r\n            self.epsilon_u = (0.0033 - (self.f_cuk - 50) * 1e-6) if (\r\n                    0.0033 - (self.f_cuk - 50) * 1e-6 <= 0.0033) else 0.0033\r\n\r\n        self.xn = self.get_xn()  # 计算中性轴高度\r\n        self.alpha, self.beta = self.equiv_rec()  # 计算等效矩形应力图系数\r\n\r\n    def equiv_rec(self):\r\n        #   计算等效应力图形系数 alpha, beta\r\n        xn = self.xn\r\n        k1, err1 = integrate.quad(self.area, 0, xn, args=xn)\r\n        k2, err2 = integrate.quad(self.inertia, 0, xn, args=xn)\r\n        beta = 2 \/ xn * k2 \/ k1\r\n        alpha = 1 \/ (beta * self.f_c * xn) * k1\r\n        ab = (round(alpha, 4), round(beta, 4))\r\n        return ab\r\n\r\n    def sigma_epsilon(self, epsilon):\r\n        #   2-22过镇海曲线\r\n        #   epsilon 为10^-6\r\n        if self.mode == Mode.GZH:\r\n            x = epsilon \/ self.epsilon_0\r\n            if 0 <= x <= 1:\r\n                y = self.alpha_a * x + (3 - 2 * self.alpha_a) * x ** 2 + (self.alpha_a - 2) * x ** 3\r\n            elif x > 1:\r\n                y = x \/ (self.alpha_d * (x - 1) * (x - 1) + x)\r\n            else:\r\n                # 对epsilon小于0的取0\r\n                y = 0\r\n            return y * self.f_c\r\n        # GB2010公式\r\n        elif self.mode == Mode.GB:\r\n            if epsilon > self.epsilon_0:\r\n                return self.f_c if epsilon < self.epsilon_u else 0\r\n            else:\r\n                # 对epsilon小于0的取0\r\n                return self.f_c * (1 - (1 - epsilon \/ self.epsilon_0) ** self.n) if epsilon > 0 else 0\r\n\r\n    def get_b(self, x):\r\n        if self.shape == Shape_Type.REC:\r\n            return self.b\r\n        elif self.shape == Shape_Type.T:\r\n            return self.bf if x <= self.hf else self.b\r\n        elif self.shape == Shape_Type.CIR:\r\n            return 2 * (2 * self.r * x - x * x) ** 0.5\r\n        elif self.shape == Shape_Type.RING:\r\n            return 2 * ((2 * self.r_out * x - x * x) ** 0.5 - (\r\n                    2 * self.r_in * (x - self.thickness) - (x - self.thickness) ** 2) ** 0.5) if (\r\n                    self.thickness < x < self.h - self.thickness) else 2 * (2 * self.r_out * x - x * x) ** 0.5\r\n\r\n    # def axis_force(self, x, xn):\r\n    #     return self.get_b(x) * self.sigma_epsilon(-1 * self.epsilon_u \/ xn * x + self.epsilon_u)\r\n\r\n    def axis_force(self, x, xn, epsilon_c):\r\n        return self.get_b(x) * self.sigma_epsilon(-1 * epsilon_c \/ xn * x + epsilon_c)\r\n\r\n    def get_xn(self):\r\n        tolerance = 1e-10\r\n        low = 0\r\n        high = self.h\r\n        flag = self.A_s * self.f_y\r\n        while low + tolerance < high:\r\n            xn = (low + high) \/ 2\r\n            # k为轴力\r\n            # k, err = integrate.quad(self.axis_force, 0, xn, args=xn)\r\n            k, err = integrate.quad(self.axis_force, 0, xn, args=(xn, self.epsilon_u))\r\n            if k < flag:\r\n                low = xn\r\n            else:\r\n                high = xn\r\n        return xn\r\n\r\n    def area(self, x, xn):\r\n        # sigma(x)\r\n        return self.sigma_epsilon(-1 * self.epsilon_u \/ xn * x + self.epsilon_u)\r\n\r\n    def inertia(self, x, xn):\r\n        # x*sigma(x)\r\n        return x * self.sigma_epsilon(-1 * self.epsilon_u \/ xn * x + self.epsilon_u)\r\n\r\n    def plot(self):\r\n        # plot\r\n        plt.switch_backend('agg')   # NOT USE GUI\r\n        fig = plt.figure()\r\n        ax1 = plt.subplot(2, 1, 1)\r\n        ax2 = plt.subplot(2, 1, 2)\r\n        fig.tight_layout()  # 调整整体空白\r\n        plt.subplots_adjust(wspace=0, hspace=0.3)  # 调整子图间距\r\n\r\n        x = np.arange(0, self.h, 0.01)\r\n\r\n        # plot epsilon-x\r\n        plt.sca(ax1)\r\n        ax1.set_title('ε-y', fontsize=12, color='black')\r\n        epsilon = -1 * self.epsilon_u \/ self.xn * x + self.epsilon_u\r\n        plt.plot(x, epsilon, color='blue')\r\n\r\n        # plot sigma-x\r\n        plt.sca(ax2)\r\n        ax2.set_title('σ-y', fontsize=12, color='black')\r\n        sigma = np.empty([0, 1])\r\n        for i in x:\r\n            sigma = np.append(sigma, self.area(i, self.xn))\r\n        plt.plot(x, sigma, color='blue')\r\n        plt.plot([0, self.beta * self.xn], [0, 0], color='red', linestyle='--')\r\n        plt.plot([0, self.beta * self.xn], [self.alpha * self.f_c, self.alpha * self.f_c], color='red', linestyle='--')\r\n        plt.plot([self.beta * self.xn, self.beta * self.xn], [0, self.alpha * self.f_c], color='red', linestyle='--')\r\n        plt.plot([0, 0], [0, self.alpha * self.f_c], color='red', linestyle='--')\r\n\r\n        IMAGE_NAME = 'plot' + self.timestamp + '.png'  # timestamp\r\n        # print(IMAGE_NAME)\r\n        # print(IMAGE_DIR)\r\n        plt.savefig(IMAGE_DIR + '\/' + IMAGE_NAME)\r\n        # plt.show()\r\n        return IMAGE_NAME\r\n\r\n    def get_display_xn(self, phi, display_xn):\r\n        tolerance = 1e-3    # set a larger num to accelerate\r\n        low = 0\r\n        high = display_xn   # add limit\r\n        while low + tolerance < high:\r\n            xn = (low + high) \/ 2\r\n            epsilon_c = phi * xn\r\n            epsilon_s = -(-phi * self.h + epsilon_c)  # positive\r\n            steel_sigma = epsilon_s * self.E_s if epsilon_s * self.E_s < self.f_y else self.f_y  # yield or not\r\n            flag = self.A_s * steel_sigma\r\n            # k为轴力\r\n            # k, err = integrate.quad(self.axis_force, 0, xn, args=xn)\r\n            k, err = integrate.quad(self.axis_force, 0, xn, args=(xn, epsilon_c))\r\n            if k < flag:\r\n                low = xn\r\n            else:\r\n                high = xn\r\n        return xn\r\n\r\n    def display_area(self, x, xn, phi):\r\n        # sigma(x)\r\n        epsilon_c = phi * xn\r\n        return self.sigma_epsilon(-1 * epsilon_c \/ xn * x + epsilon_c)\r\n\r\n    def display(self):\r\n        # plot\r\n        plt.switch_backend('agg')   # NOT USE GUI\r\n        fig, ax = plt.subplots()\r\n        # ax1 = plt.subplot(2, 1, 1)\r\n        # ax2 = plt.subplot(2, 1, 2)\r\n        # fig.tight_layout()  # 调整整体空白\r\n        # plt.subplots_adjust(wspace=0, hspace=0.3)  # 调整子图间距\r\n        # x, sigma = [], []\r\n        line, = plt.plot([], [], color='blue')\r\n        limit_frame = int(self.epsilon_u \/ self.xn * 1e6)\r\n        ax.set_xlim(0, self.h)\r\n        ax.set_ylim(0, 1.2 * self.f_c)\r\n\r\n        def init():\r\n            return line,\r\n\r\n        def update(step):\r\n            # plt.sca(ax1)\r\n            phi = step * 1e-6\r\n            title = 'σ-y (phi = ' + str(round(phi, 6)) + ')'\r\n            ax.set_title(title, fontsize=12, color='black')\r\n\r\n            display_xn = self.display_xn  # initial temp\r\n            if display_xn > self.xn:\r\n                display_xn = self.get_display_xn(phi, display_xn)\r\n            else:\r\n                display_xn = self.xn\r\n\r\n            self.display_xn = display_xn\r\n            x = np.arange(0, self.h, 0.01)\r\n            sigma = np.empty([0, 1])\r\n\r\n            for i in x:\r\n                sigma = np.append(sigma, self.display_area(i, display_xn, phi))\r\n\r\n            # for i in x:\r\n            #     sigma = np.append(sigma, self.area(i, self.xn))\r\n\r\n            line.set_data(x, sigma)\r\n            return line, display_xn,\r\n\r\n        self.display_xn = self.h\r\n        anime = FuncAnimation(fig, update, frames=range(1, limit_frame), init_func=init, interval=10)\r\n        # plt.show()\r\n        Anime_NAME = 'anime' + self.timestamp + '.gif'  # timestamp\r\n        anime.save(IMAGE_DIR + '\/' + Anime_NAME, writer='imagemagick', fps=20)\r\n        return Anime_NAME\r\n\r\n\r\ndef test():\r\n    #   default: C30混凝土\r\n    # shape, rc_type, A_s, steel_type, mode\r\n    # rc_set = RC({'shape': Shape_Type.REC, 'b': 250, 'h': 500}, RC_Type.C30, 1256, Steel_Type.HRB335, Mode.GZH)\r\n    # print(rc_set.alpha, rc_set.beta, '\\n')\r\n    # rc_set.plot()\r\n\r\n    rc_set2 = RC({'shape': Shape_Type.T, 'b': 250, 'h': 500, 'bf': 600, 'hf': 100}, RC_Type.C40, 2147,\r\n                 Steel_Type.HRB400, Mode.GB)\r\n    print(rc_set2.alpha, rc_set2.beta, '\\n')\r\n    rc_set2.plot()\r\n    # rc_set2.display()\r\n\r\n    #\r\n    # rc_set3 = RC({'shape': Shape_Type.CIR, 'd_out': 400}, RC_Type.C50, 1212, Steel_Type.HRB335, Mode.GB)\r\n    # print(rc_set3.alpha, rc_set3.beta, '\\n')\r\n    # rc_set3.plot()\r\n    #\r\n    # rc_set4 = RC({'shape': Shape_Type.RING, 'd_in': 300, 'd_out': 500}, RC_Type.C30, 1212, Steel_Type.HRB335, Mode.GB)\r\n    # print(rc_set4.alpha, rc_set4.beta, '\\n')\r\n    # rc_set4.plot()\r\n\r\n    return\r\n\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_583","text":"<reponame>mmaltafe\/Learning\nimport numpy as np\nimport pandas as pd\nimport scipy.stats as stats\nfrom sklearn.decomposition import PCA\nfrom sklearn.preprocessing import StandardScaler\nimport matplotlib.pyplot as plt\nimport pickle\nimport SODA\nimport threading\nfrom datetime import datetime\nfrom psutil import cpu_percent, swap_memory\nfrom progress.bar import Bar\nfrom sklearn.neighbors import kneighbors_graph \nfrom scipy.sparse.linalg import expm\nimport scipy.sparse \nfrom sklearn.metrics.pairwise import euclidean_distances\nfrom sklearn import preprocessing\nimport sklearn\nfrom sklearn.utils.validation import check_array\n\nclass performance(threading.Thread):\n    # Declares variables for perfomance analysis:\n    \n    def __init__(self):\n        threading.Thread.__init__(self)\n        self.control = True\n    \n    def run(self):\n        cpu_p = []\n        ram_p = []\n        ram_u = []\n        while self.control:\n            cpu_p.append(cpu_percent(interval=1, percpu=True))\n            ram_p.append(swap_memory().percent)\n            ram_u.append(swap_memory().used\/(1024**3))\n        self.mean_cpu_p = np.mean(cpu_p)\n        self.mean_ram_p = np.mean(ram_p)\n        self.mean_ram_u = np.mean(ram_u)\n        self.max_cpu_p = np.max(np.mean(cpu_p, axis=1))\n        self.max_ram_p = np.max(ram_p)\n        self.max_ram_u = np.max(ram_u)\n    \n    def stop(self):\n        self.control = False\n    \n    def join(self):\n        threading.Thread.join(self)\n        out = {'mean_cpu_p': self.mean_cpu_p,\n               'mean_ram_p': self.mean_ram_p,\n               'mean_ram_u': self.mean_ram_u,\n               'max_cpu_p': self.max_cpu_p,\n               'max_ram_p': self.max_ram_p,\n               'max_ram_u': self.max_ram_u}\n        return out\n\ndef divide(data, n_windows = 100, n_samples = 50):  \n    \"\"\"Divide the data in n_samples, and the samples are equaly distributed in n_windows\n    -- Input\n    - data = data to split\n    - n_windows = number of windows to separete the data\n    - n_samples = number of samples of the output\n    -- Output\n    - reduced_data = splited data with n_samples\n    - data_sample_id = id of the splited data\"\"\"  \n    L, W = data.shape\n    \n    # Checking if the windows can be of the same size \n    \n    if int(L % n_windows) != 0:\n        \n        # Checking if we need to peak the same amount of data from each window\n        \n        if int(n_samples % n_windows) != 0 or (n_samples\/n_windows) % 1 != 0:\n            \n            lines_per_window = L \/\/ n_windows\n            samples_per_window = n_samples \/\/ n_windows\n            reduced_data = np.zeros((int(n_samples),W))\n            data_sample_id = np.zeros(int(n_samples))\n\n            for i in range(n_windows):\n                if i >= n_windows - 1:\n                    for j in range(samples_per_window + int(n_windows*((n_samples\/n_windows) % 1))):\n                        sample = np.random.randint(i*lines_per_window,int((i+1)*lines_per_window + int(L % n_windows)))\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample\n\n                else:\n                    for j in range(samples_per_window):\n                        sample = np.random.randint(i*lines_per_window,(i+1)*lines_per_window)\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample\n            \n        # Even amount of data \n            \n        else:\n            \n            lines_per_window = L \/\/ n_windows\n            samples_per_window = n_samples \/\/ n_windows\n            reduced_data = np.zeros((int(n_samples),W))\n            data_sample_id = np.zeros(int(n_samples))\n\n            for i in range(n_windows):\n                if i >= n_windows - 1:\n                    for j in range(samples_per_window):\n                        sample = np.random.randint(i*lines_per_window,int((i+1)*lines_per_window + int(L % n_windows)))\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample\n\n                else:\n                    for j in range(samples_per_window):\n                        sample = np.random.randint(i*lines_per_window,(i+1)*lines_per_window)\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample \n                        \n    # Windows of same size \n\n    else:\n        \n        # Checking if we need to pick the same amount of data from each window\n        \n        if int(n_samples % n_windows) != 0 or (n_samples\/n_windows) % 1 != 0:\n            \n            lines_per_window = L \/\/ n_windows\n            samples_per_window = n_samples \/\/ n_windows\n            reduced_data = np.zeros((int(n_samples),W))\n            data_sample_id = np.zeros(int(n_samples))\n            \n            for i in range(n_windows):\n                if i >= n_windows - 1:\n                    for j in range(samples_per_window + int(n_windows*((n_samples\/n_windows) % 1))):\n                        sample = np.random.randint(i*lines_per_window,int((i+1)*lines_per_window + int(L % n_windows)))\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample\n\n                else:\n                    for j in range(samples_per_window):\n                        sample = np.random.randint(i*lines_per_window,(i+1)*lines_per_window)\n                        new_line = data[sample]\n                        reduced_data[j+(i*samples_per_window)] = new_line\n                        data_sample_id[j+(i*samples_per_window)] = sample\n            \n        # Even amount of data\n            \n        else:\n        \n            lines_per_window = L \/\/ n_windows\n            samples_per_window = n_samples \/\/ n_windows\n            reduced_data = np.zeros((int(n_samples),W))\n            data_sample_id = np.zeros(int(n_samples))\n\n            for i in range(n_windows):\n                for j in range(samples_per_window):\n                    sample = np.random.randint(i*lines_per_window,int((i+1)*lines_per_window))\n                    new_line = data[sample]\n                    reduced_data[j+(i*samples_per_window)] = new_line\n                    data_sample_id[j+(i*samples_per_window)] = sample\n        \n    return reduced_data, data_sample_id\n\ndef Normalisation(data):\n    \"\"\"Use standart deviation to normalise the data\n    -- Input\n    - data\n    -- Output\n    - Normalised data\n    \"\"\"\n\n    # Normalizing whole data\n    scaler = StandardScaler().fit(data)\n    norm_data = scaler.transform(data)\n\n    return norm_data\n\ndef PCA_Analysis(mantained_variation, attributes_influence,laplace=True):\n    \"\"\"Create and save the PCA model\n    -- Input\n    - mantained_variation = variation mantained for each PC\n    - attributes_influence = influence of each attribute on the model \n    -- Output\n    - Saves plot figures in results folder\n    \"\"\"\n\n    # Plots the variation mantained by each PC\n\n    fig = plt.figure(figsize=[16,8])\n    ax = fig.subplots(1,1)\n    ax.bar(x=['PC' + str(x) for x in range(1,(len(mantained_variation)+1))],height=mantained_variation)\n\n    ax.set_ylabel('Percentage of Variance Held',fontsize=20)\n    ax.set_xlabel('Principal Components',fontsize=20)\n    ax.tick_params(axis='x', labelsize=14)\n    ax.tick_params(axis='y', labelsize=18)\n    ax.grid()\n\n    fig.savefig('results\/Percentage_of_Variance_Held.png', bbox_inches='tight')\n                        \n    sorted_sensors_contribution = attributes_influence.values[:]      \n                        \n    # Ploting Cntribution Attributes influence\n                        \n    fig = plt.figure(figsize=[25,8])\n\n    fig.suptitle('Attributes Weighted Contribution Percentage', fontsize=16)\n\n    ax = fig.subplots(1,1)\n\n    sorted_sensors_contribution = sorted_sensors_contribution.ravel()\n    ax.bar(x=list(attributes_influence.columns),height=sorted_sensors_contribution)\n    plt.ylabel('Relevance Percentage',fontsize = 20)\n    plt.xlabel('Attributes',fontsize = 20)\n    plt.tick_params(axis='x', labelsize=14)\n    plt.tick_params(axis='y', labelsize=18)\n    plt.xticks(rotation=90)\n    ax.grid()\n    \n    fig.savefig('results\/Attributes_Contribution.png', bbox_inches='tight')\n\n    return\n\ndef PCA_Projection(background_train,streaming_data, N_PCs, maintained_features=0):\n    \"\"\"Transform Data with PCA and normalize\n    -- Input\n    - Offline data\n    - Streaming data\n    - N_PCs = number of PCs to calculate\n    -- Output\n    - Projected Offline data\n    - Projected Streaming data\n    - Variation Mantained\n    - Attributes Influence\n    \"\"\"\n\n    # Calcules the PCA and projects the data-set into them\n\n    pca= PCA(n_components = N_PCs)\n    pca.fit(background_train)\n            \n    # Calculates the total variance maintained by each PCs\n            \n    pca_variation = pca.explained_variance_ratio_ * 100\n    \n\n    print('Normal Variation maintained: %.2f' % np.round(pca_variation.sum(), decimals = 2))\n\n    proj_background_train = pca.transform(background_train)\n    proj_streaming_data = pca.transform(streaming_data)\n \n\n    ### Attributes analyses ###\n\n    columns=[\"px1\",\"py1\",\"pz1\",\"E1\",\"eta1\",\"phi1\",\"pt1\",\\\n                \"px2\",\"py2\",\"pz2\",\"E2\",\"eta2\",\"phi2\",\\\n                \"pt2\",\"Delta_R\",\"M12\",\"MET\",\"S\",\"C\",\"HT\",\\\n                \"A\", \"Min\",\"Max\",\"Mean\",\"Var\",\"Skw\",\"Kurt\",\\\n                \"M2\",\"M3\",\"M4\"] #,\"Bmin\",\"Bmax\"]\n\n    # Gets eigen vectors information from the trained pca object\n    eigen_matrix = np.array(pca.components_)\n\n    # Inverting negative signals\n    eigen_matrix = pow((pow(eigen_matrix,2)),0.5) \n\n    # Calculates the feature contribution\n\n    for i in range (eigen_matrix.shape[0]):\n        LineSum = sum(eigen_matrix[i,:])\n        for j in range (eigen_matrix.shape[1]):\n            eigen_matrix[i,j] = ((eigen_matrix[i,j]*100)\/LineSum)\n\n    weighted_contribution = np.zeros((eigen_matrix.shape[1]))\n\n    for i in range (eigen_matrix.shape[1]):\n        NumeratorSum = 0\n        for j in range (N_PCs):\n            NumeratorSum += eigen_matrix[j,i] * pca_variation[j]\n\n        weighted_contribution[i] = NumeratorSum \/ sum(pca_variation)\n\n    weighted_contribution = weighted_contribution.reshape((1,-1))\n\n    # Sorting attributes by their contribution values \n                        \n    attributes_contribution = pd.DataFrame (weighted_contribution, columns = columns)\n                        \n    attributes_contribution = attributes_contribution.sort_values(by=0, axis=1,ascending=False)\n\n    return proj_background_train, proj_streaming_data, pca_variation, attributes_contribution\n\ndef statistics_attributes(data):\n    \"\"\"\n    When xyz_attributes=True:\n       Concatenate with the data, statistics attributes for each event.\n       Currently Applied:\n        - Minimum Value\n        - Maximum Value\n        - Mean\n        - Variance\n        - Skewness\n        - Kurtosis\n        - 2nd Central Moment\n        - 3rd Central Moment\n        - 4th Central Moment\n        - Bayesian Confidence Interval (Min and Max)\n        More attributes may be added later\n       \n       -- Input\n       - data [numpy.array]\n       -- Output\n       - output_data = data with adition of statistical features for each line [numpy.array]\n       \"\"\"\n    \n    momentum_data = np.concatenate((data[:, 0:3], data[:, 7:10]), axis=1)\n\n    L, W = data.shape\n\n    _, (min_v, max_v), mean, var, skew, kurt = stats.describe(momentum_data.transpose())\n    \n    # Minimum Value\n    min_v = min_v.reshape(-1,1)\n    \n    min_v = check_array(min_v) # Minimum Value\n\n    # Maximum Value\n    max_v = max_v.reshape(-1,1)\n\n    max_v = check_array(max_v) # Maximum Value\n\n    # Mean\n    mean = mean.reshape(-1,1)\n    \n    mean = check_array(mean) # Mean\n\n    # Variance\n    var = var.reshape(-1,1) \n    \n    var = check_array(var) # Variance\n\n    # Skewness\n    skew = skew.reshape(-1,1)\n    \n    skew = check_array(skew) # Skewness\n\n    # Kurtosis\n    kurt = kurt.reshape(-1,1)\n    \n    kurt = check_array(kurt) # Kurtosis\n\n    # 2nd Central Moment\n    moment2 = stats.moment(momentum_data.transpose(), moment=2).reshape(-1,1)\n    \n    moment2 = check_array(moment2) # 2nd Central Moment\n\n    # 3rd Central Moment\n    moment3 = stats.moment(momentum_data.transpose(), moment=3).reshape(-1,1)\n    \n    moment3 = check_array(moment3) # 3rd Central Moment\n\n    # 4th Central Moment\n    moment4 = stats.moment(momentum_data.transpose(), moment=4).reshape(-1,1)\n    \n    moment4 = check_array(moment4) # 4th Central Moment\n\n    \"\"\"\n    bayes_min = np.zeros(L).reshape(-1,1)\n\n    bayes_min = check_array(momentum_data) # bayes_min\n\n    bayes_max = np.zeros(L).reshape(-1,1)\n\n    bayes_max = check_array(momentum_data) # bayes_max\n\n    for i,d in enumerate(momentum_data):\n        bayes = stats.bayes_mvs(d)\n\n        bayes = check_array(momentum_data) # bayes\n\n        bayes_min[i] = bayes[0][1][0]\n\n        bayes_min = check_array(momentum_data) # bayes_min\n\n        bayes_max[i] = bayes[0][1][1]\n\n        bayes_max = check_array(momentum_data) # bayes_max\n    \"\"\"   \n    output_data = np.concatenate((data, min_v, max_v, mean, var, skew, kurt, moment2, moment3, moment4), axis=1)\n                                        #bayes_min, bayes_max\n    return output_data\n\ndef SODA_Granularity_Iteration(offline_data,streaming_data,gra,target,Iteration):\n\n    print('=> Iteration Number {}:         .Executing granularity:'.format(Iteration),gra)\n    # Formmating  Data\n    offline_data = np.matrix(offline_data)\n    L1 = len(offline_data)\n\n    streaming_data = np.matrix(streaming_data)\n    \n    data = np.concatenate((offline_data, streaming_data), axis=0)\n\n    # Dreate data frames to save each iteration result.\n\n    performance_info = pd.DataFrame(np.zeros((1,8)).reshape((1,-1)), columns=['Granularity', 'Time_Elapsed',\n                                                                'Mean CPU_Percentage', 'Max CPU_Percentage',\n                                                                'Mean RAM_Percentage', 'Max RAM_Percentage',\n                                                                'Mean RAM_Usage_GB', 'Max RAM_Usage_GB'])\n\n    begin = datetime.now()\n\n    performance_thread = performance()\n    performance_thread.start()\n    \n    Input = {'GridSize':gra, 'StaticData':np.vstack((offline_data,streaming_data)), 'DistanceType': 'euclidean','Target':target}\n\n    out = SODA.SelfOrganisedDirectionAwareDataPartitioning(Input,'Offline')\n\n    performance_thread.stop()\n    performance_out = performance_thread.join()\n    final = datetime.now()\n    performance_info.loc[0,'Time_Elapsed'] = (final - begin)\n    performance_info.loc[0,'Mean CPU_Percentage'] = performance_out['mean_cpu_p']\n    performance_info.loc[0,'Max CPU_Percentage'] = performance_out['max_cpu_p']\n    performance_info.loc[0,'Mean RAM_Percentage'] = performance_out['mean_ram_p']\n    performance_info.loc[0,'Max RAM_Percentage'] = performance_out['max_ram_p']\n    performance_info.loc[0,'Mean RAM_Usage_GB'] = performance_out['mean_ram_u']\n    performance_info.loc[0,'Max RAM_Usage_GB'] = performance_out['max_ram_u']\n\n    np.savetxt('results\/SODA_labels__'+ str(gra) + '__' + str(Iteration) +'__.csv', out['IDX'],delimiter=',')\n    np.savetxt('results\/Density_1__'+ str(gra) + '__' + str(Iteration) +'__.csv', out['Density1'],delimiter=',')\n    np.savetxt('results\/Density_2__'+ str(gra) + '__' + str(Iteration) +'__.csv', out['Density2'],delimiter=',')\n    performance_info.to_csv('results\/performance_info__' + str(gra) + '__' + str(Iteration) + '__.csv', index=False)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_584","text":"# coding=utf-8\n\"\"\"Face Detection and Recognition\"\"\"\n# MIT License\n#\n# Copyright (c) 2017 <NAME>\n#\n# This is the work of <NAME> and shanren7 remodelled into a\n# high level container. It's an attempt to simplify the use of such\n# technology and provide an easy to use facial recognition package.\n#\n# https:\/\/github.com\/davidsandberg\/facenet\n# https:\/\/github.com\/shanren7\/real_time_face_recognition\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport pickle\nimport os\nimport math\nimport cv2\nimport numpy as np\nimport tensorflow as tf\nfrom scipy import misc\nfrom sklearn.grid_search import GridSearchCV\nfrom sklearn.svm import SVC\nfrom sklearn.model_selection import ParameterGrid\nfrom sklearn.linear_model import SGDClassifier\nfrom sklearn.metrics import roc_auc_score\nfrom sklearn.neighbors import KNeighborsClassifier\nimport align.detect_face\nimport facenet\nfrom tqdm import tqdm\nfrom timeit import timeit\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import MinMaxScaler\nimport time\n\ngpu_memory_fraction = 0.6\ndata_dir = '\/work\/MachineLearning\/my_dataset\/wos_event'\nfacenet_model_checkpoint = '\/work\/MachineLearning\/model_checkpoints\/20180402-114759\/20180402-114759.pb'\n#classifier_model = '\/work\/MachineLearning\/model_checkpoints\/incremental_test.pkl'\nclassifier_model = '\/work\/MachineLearning\/model_checkpoints\/lighter_model.pkl'\n\ndebug = False\nsess = None\ngraph = None\nmodel = SVC(kernel='rbf', probability=True)\nlabels = None\nclass_names = None\nemb_array = None\n\nclass Face(object):\n    def __init__(self):\n        self.name = None\n        self.bounding_box = None\n        self.image = None\n        self.container_image = None\n        self.embedding = None\n        self.confidence = None\n\nclass Recognition(object):\n    def __init__(self):\n        self.detect = Detection()\n        self.encoder = Encoder()\n        self.identifier = Identifier()\n\n    def add_identity(self, image, person_name):\n        faces = self.detect.find_faces(image)\n\n        if len(faces) == 1:\n            face = faces[0]\n            face.name = person_name\n            face.embedding = self.encoder.generate_embedding(face)\n            return faces\n\n    def identify(self, image):\n        faces = self.detect.find_faces(image)\n        for i, face in enumerate(faces):\n            if debug:\n                cv2.imshow(\"Face: \" + str(i), face.image)\n            face.embedding = self.encoder.generate_embedding(face)\n            face.name = self.identifier.identify(face)\n            #face.confidence = 1.0\n            face.confidence = self.identifier.confidence_level(face)\n        return faces\n\n    # def identify(self, image):\n    #     faces = self.detect.find_faces(image)\n\n    #     if len(faces) > 0:\n    #         faces = faces[0]\n\n    #     faces.embedding = self.encoder.generate_embedding(faces)\n    #     faces.name = self.identifier.identify(faces)   \n    #     faces.confidence = self.identifier.confidence_level(faces)\n    #     return faces\n\n\nclass Identifier(object):\n    def __init__(self):\n        with open(classifier_model, 'rb') as infile:\n            self.emb_array, self.labels, self.class_names = pickle.load(infile, encoding='latin1')\n        self.build_model()\n\n    def build_model(self):\n        global labels\n        global emb_array\n        global class_names\n\n        emb_array = self.emb_array\n        labels = self.labels\n        class_names = self.class_names\n        #emb_array = np.concatenate((emb_array, self.emb_array))\n        #labels = np.concatenate((labels , self.labels.tolist())).tolist()     #add new labels to old labels\n        #class_names = np.concatenate((class_names , self.class_names))                          #append new class name to old class names\n\n        #X_train, X_test, y_train, y_test = train_test_split(emb_array, labels, test_size=0.2)\n        #self.model = SGDClassifier(loss='log', verbose=True, n_jobs=-1, n_iter=1000, alpha=1e-5, \n        #    tol=None, shuffle=True, random_state=100, penalty='l2')\n       #self.model = KNeighborsClassifier(n_neighbors=1, algorithm='auto')\n        print('Start building model')\n        start = time.time()\n        #param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],\n        #      'gamma': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.1], }\n        #self.model = GridSearchCV(SVC(kernel='rbf', cache_size=2048, probability=True), param_grid, n_jobs=-1)\n        model.fit(emb_array, labels)\n        #self.model.fit(X_train, y_train)\n        end = time.time()\n        print (\"Fit Time: {0:4f}s\".format(end - start))\n        print('Build model done')\n\n    def identify(self, face):\n        global model\n        global class_names\n        if face.embedding is not None:\n            predictions = model.predict_proba([face.embedding])\n            best_class_indices = np.argmax(predictions, axis=1)\n            best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]\n            return class_names[best_class_indices[0]]\n   \n    def confidence_level(self, face):\n        global model\n        if face.embedding is not None:\n            predictions = model.predict_proba([face.embedding])\n            best_class_indices = np.argmax(predictions, axis=1)\n            best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices]\n            return best_class_probabilities[0]\n\nclass Encoder(object):\n    def __init__(self):\n        self.graph = tf.Graph()\n        self.sess = tf.Session(graph=self.graph)\n        with self.graph.as_default():\n            with self.sess.as_default():\n                facenet.load_model(facenet_model_checkpoint)\n                print(\"Loaded model\")\n\n    def generate_embedding(self, face):\n        # Get input and output tensors\n        images_placeholder = self.graph.get_tensor_by_name(\"input:0\")\n        embeddings = self.graph.get_tensor_by_name(\"embeddings:0\")\n        phase_train_placeholder = self.graph.get_tensor_by_name(\"phase_train:0\")\n\n        prewhiten_face = facenet.prewhiten(face.image)\n\n        # Run forward pass to calculate embeddings\n        feed_dict = {images_placeholder: [prewhiten_face], phase_train_placeholder: False}\n        return self.sess.run(embeddings, feed_dict=feed_dict)[0]\n\n    def incremental_training(self, emb_array_new, labels_new, class_names_new):\n        global labels\n        global emb_array\n        global class_names\n        emb_array = np.concatenate((emb_array, emb_array_new))\n        labels = np.concatenate((labels ,labels_new))     #add new labels to old labels\n        class_names = np.concatenate((class_names ,class_names_new))                          #append new class name to old class names\n\n    def retrain_model(self, incremental):\n        global labels\n        global emb_array\n        global class_names\n        if incremental is True:\n            dataset, append_index = facenet.append_dataset(data_dir, class_names)\n            paths, self.append_labels = facenet.get_image_paths_and_labels(dataset, append_index)\n            self.append_class_names = [cls.name.replace('_', ' ') for cls in dataset]\n\n        else:\n            dataset, append_index = facenet.get_dataset(data_dir)\n            paths, labels = facenet.get_image_paths_and_labels(dataset, append_index)\n            class_names = [cls.name.replace('_', ' ') for cls in dataset]\n\n        np.random.seed(seed=666)\n        # Check that there are at least one training image per class\n        for cls in dataset:\n            assert (len(cls.image_paths) > 0, 'There must be at least one image for each class in the dataset')\n        \n        # Create a list of class names\n\n        print('Number of classes: %d' % len(dataset))\n        print('Number of images: %d' % len(paths))\n        if incremental is True:\n            print(\"new people added: \")\n            print(self.append_class_names)\n \n        # Get input and output tensors\n        images_placeholder = self.graph.get_tensor_by_name(\"input:0\")\n        embeddings = self.graph.get_tensor_by_name(\"embeddings:0\")\n        phase_train_placeholder = self.graph.get_tensor_by_name(\"phase_train:0\")\n        embedding_size = embeddings.get_shape()[1]\n        \n        # Run forward pass to calculate embeddings\n        print('Calculating features for images')\n        nrof_images = len(paths)\n        nrof_batches_per_epoch = int(math.ceil(1.0 * nrof_images \/ 90))\n        self.append_emb_array = np.zeros((nrof_images, embedding_size))\n\n        for i in tqdm(range(nrof_batches_per_epoch)):\n            start_index = i * 90\n            end_index = min((i + 1) * 90, nrof_images)\n            paths_batch = paths[start_index:end_index]\n            images = facenet.load_data(paths_batch, False, False, 160)\n            feed_dict = {images_placeholder: images, phase_train_placeholder: False}\n            self.append_emb_array[start_index:end_index, :] = self.sess.run(embeddings, feed_dict=feed_dict)\n\n        classifier_filename_exp = os.path.expanduser(classifier_model)\n        print('Training classifier')\n     \n        if incremental is True:\n            self.incremental_training(self.append_emb_array, self.append_labels, self.append_class_names)\n  \n        print(len(emb_array))\n        print(class_names)\n        #X_train, X_test, y_train, y_test = train_test_split(emb_array, labels, test_size=0.25)\n        #self.model = SGDClassifier(loss='log', verbose=True, n_jobs=-1, n_iter=1000, alpha=1e-5, \n        #    tol=None, shuffle=True, random_state=100, penalty='l2')\n        #self.model = SVC(kernel='rbf', probability=True, verbose=True, cache_size=1024)\n        #self.model = KNeighborsClassifier(n_neighbors=1, algorithm='auto')\n        print('Start building model')\n        start = time.time()\n        #param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],\n        #      'gamma': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.1], }\n        #self.model = GridSearchCV(SVC(kernel='rbf', cache_size=2048, probability=True), param_grid, n_jobs=-1)\n        model.fit(emb_array, labels)\n        #self.model.fit(X_train, y_train)\n        end = time.time()\n        print (\"Fit Time: {0:4f}s\".format(end - start))\n        print('Build model done')\n       \n        if incremental is False:\n            # Saving classifier model\n            with open(classifier_filename_exp, 'wb') as outfile:\n                pickle.dump((emb_array, labels, class_names), outfile)\n            print('Saved classifier model to file \"%s\"' % classifier_filename_exp)\n\n        return 'Success'\n\nclass Detection(object):\n    # face detection parameters\n    minsize = 50  # minimum size of face\n    threshold = [0.6, 0.7, 0.7]  # three steps's threshold\n    factor = 0.709  # scale factor\n\n    def __init__(self, face_crop_size=160, face_crop_margin=32):\n        self.pnet, self.rnet, self.onet = self._setup_mtcnn()\n        self.face_crop_size = face_crop_size\n        self.face_crop_margin = face_crop_margin\n\n    def _setup_mtcnn(self):\n        with tf.Graph().as_default():\n            gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_memory_fraction)\n            sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))\n            with sess.as_default():\n                return align.detect_face.create_mtcnn(sess, None)\n\n    def find_faces(self, image):\n        faces = []\n\n        bounding_boxes, _ = align.detect_face.detect_face(image, self.minsize,\n                                                          self.pnet, self.rnet, self.onet,\n                                                          self.threshold, self.factor)\n        for bb in bounding_boxes:\n            face = Face()\n            face.container_image = image\n            face.bounding_box = np.zeros(4, dtype=np.int32)\n\n            img_size = np.asarray(image.shape)[0:2]\n            face.bounding_box[0] = np.maximum(bb[0] - self.face_crop_margin \/ 2, 0)\n            face.bounding_box[1] = np.maximum(bb[1] - self.face_crop_margin \/ 2, 0)\n            face.bounding_box[2] = np.minimum(bb[2] + self.face_crop_margin \/ 2, img_size[1])\n            face.bounding_box[3] = np.minimum(bb[3] + self.face_crop_margin \/ 2, img_size[0])\n            cropped = image[face.bounding_box[1]:face.bounding_box[3], face.bounding_box[0]:face.bounding_box[2], :]\n            face.image = misc.imresize(cropped, (self.face_crop_size, self.face_crop_size), interp='bilinear')\n\n            faces.append(face)\n\n        return faces\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_585","text":"#CalcHilbertTrans.py\n#This script opens up relevant nodes and drops in a hilbert transform for the signal.\n#<NAME>, 23 Feb 2012\nfrom MDSplus import *\nfrom scipy import *\nfrom scipy.signal import *\nimport sys\n\ns=int(sys.argv[1])\n\ntree=Tree('magnetics',s)\n\ndef calcHilb(parentNode) :\n\ty=parentNode.getData().data()\n\tyh=hilbert(y)\n\ttimebase_expr='dim_of('+parentNode.getLocalPath()+')'  #Grab timebase with TDI expression so it's local - don't move over network.\n\texpr=Data.compile('BUILD_SIGNAL($1, *, '+timebase_expr+')', yh) #Build a TDI expression for storing signal.\n\tparentNode.getNode('hilbert').putData(expr)\n\n\ncalcHilb(tree.getNode('shoelace:ant_i'))\ncalcHilb(tree.getNode('shoelace:ant_v'))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_586","text":"<reponame>Gabriel-p\/LinearBayes3<gh_stars>0\n\nimport sys\nfrom astropy.io import ascii\nimport numpy as np\nfrom scipy.optimize import differential_evolution as DE\nimport emcee\nimport matplotlib.pyplot as plt\nimport warnings\n\n\ndef main():\n    \"\"\"\n    \"\"\"\n\n    file_name = \"rgb6.poor.txt\"\n    xy_cols = \"RA(deg)\", \"Dec(deg)\"\n\n    # Read data\n    x, ex, y, ey = readData(file_name, xy_cols)\n    # x, ex, y, ey = synthData()\n\n    xy_data = np.array([x, y, ex, ey]).T\n\n    # Some priors: slope, intercept, intrinsic scatter, outlier mean,\n    # outlier scatter (standard deviation of outliers), outlier fraction\n    priors = [0, 400, -400., 0., 0.001, 100., -10., 10., 0.001, 1000.]\n    # priors = [-10., 10., -10., 10., 0.001, 100., -10., 10., 0.001, 1000.]\n\n    # Make the fit\n    samples, point_estim = fit_data(xy_data, priors)\n\n    makePlots(x, ex, y, ey, samples, point_estim)\n\n\ndef readData(file_name, xy_cols):\n    \"\"\"\n    \"\"\"\n\n    data = ascii.read(file_name)\n    x, y = data[xy_cols[0]], data[xy_cols[1]]\n    N = len(x)\n\n    ex, ey = np.zeros(N), np.zeros(N)\n\n    return x, ex, y, ey\n\n\ndef synthData():\n    \"\"\"\n    \"\"\"\n    m, b = np.random.uniform(-10., 10., 2)\n    print(\"True values: m={:.3f}, b={:.3f}\".format(m, b))\n\n    # Generate some synthetic data from the model.\n    N = np.random.randint(10, 500)\n    x = np.sort(10 * np.random.rand(N))\n    ex = 0.1 + 0.5 * np.random.rand(N)\n\n    y = m * x + b\n    ey = 0.2 * (y.max() - y.min()) * np.random.rand(N)\n    y += ey * np.random.randn(N)\n    ey = ey * .5\n\n    return x, ex, y, ey\n\n\ndef fit_data(\n    data,\n        priorlimits=[-10., 10., -10., 10., 0.001, 100., -10., 10., 0.001,\n                     1000.], nwalkers=20, nsteps=5000, burn_frac=.25):\n    \"\"\"\n    This code will fit a straight line with intrinsic dispersion to data with\n    (optionally) covariant errors on both the independent and dependent\n    variables, and takes care of outliers using a mixture model approach.\n\n    The free parameters in the model are:\n\n    * slope: slope of the fitted line.\n\n    * intercept: intercept of the fitted line.\n\n    * intrinsic scatter ('sigma_intrinsic'): Hogg, Bovy, Lang (2010):\n      \"intrinsic Gaussian variance V, orthogonal to the line.\"\n\n    * outlier mean ('y_outlier'): mean of outliers.\n\n    * outlier scatter ('sigma_outlier'): standard deviation of outliers.\n\n    * outlier fraction ('outlier_fraction'): fraction of ouliers in data.\n      Hogg, <NAME> (2010): \"the probability that a data point is bad (or,\n      more properly, the amplitude of the bad-data distribution function in the\n      mixture).\"\n\n\n    Parameters\n    ----------\n\n    data : np.ndarray\n        Should have shape (N,4) (if no covariances on errors) or (N,5) (if\n        covariant errors). Should be in the order (x, y, dx, dy) or\n        (x, y, dx, dy, dxy).\n\n    priorlimits : np.ndarray\n        Upper and lower values for each of the model parameters (except the\n        outlier fraction which has a flat prior between 0 and 1). The limits\n        should be provided in the order:\n        [slope, intercept, intrinsic scatter, outlier mean, outlier scatter]\n        (so that the array has 10 elements).\n\n    nwalkers : int\n        The number of emcee walkers to use in the fit.\n\n    nsteps : int\n        The number of steps each walker should take in the MCMC.\n\n    burn_frac : 0 < float < 1\n        The fraction of initial emcee walkers to discard as burn-in.\n\n    Returns\n    -------\n\n    samples : np.array\n        All the chains (flattened) minus the burn-in period.\n\n    point_estim : np.array\n        (16th, 50th, 84th) percentile for each of the 6 fitted parameters in\n        the order: (slope, intercept, intrinsic scatter, outlier mean,\n        outlier deviation, outlier fraction).\n\n    \"\"\"\n    # Unpack and check data.\n    if data.shape[1] == 4:\n        # No correlations on the errors\n        x, y, dx, dy = data.T\n        dxy = np.zeros_like(x)\n    elif data.shape[1] == 5:\n        # Data with dxy correlations\n        x, y, dx, dy, dxy = data.T\n    else:\n        raise ValueError(\"'data' must have 4 or 5 columns, not {}. \\\n                Try transposing your data.\".format(data.shape[1]))\n\n    # Supress RuntimeWarning\n    warnings.filterwarnings(\"ignore\")\n\n    # The number of dimensions is fixed.\n    ndim = 6\n    # Add outlier fraction prior limits, also fixed.\n    priorlimits = priorlimits + [0., 1.]\n\n    print(\"Running optimization...\")\n\n    # Estimate initial values using DE algorithm.\n    def minfunc(model):\n        return -full_posterior(model, x, y, dx, dy, dxy, priorlimits)\n    bmin, bmax = priorlimits[0::2], priorlimits[1::2]\n    bounds = list(zip(*[bmin, bmax]))\n    pstart = DE(minfunc, bounds, maxiter=5000).x\n    print(\"Initial guesses: \"\n          \"({:.3f}, {:.3f}, {:.3f}, {:.3f}, {:.3f}, {:.3f})\".format(*pstart))\n\n    # Sample ball around the max posterior point.\n    p0 = emcee.utils.sample_ball(\n        pstart, 0.01 * np.ones_like(pstart), size=nwalkers)\n    # Make sure there are no negative outlier fractions\n    p0[:, -1] = np.abs(p0[:, -1])\n\n    print(\"Running emcee...\")\n    sampler = emcee.EnsembleSampler(\n        nwalkers, ndim, full_posterior, args=[x, y, dx, dy, dxy, priorlimits])\n    for i, result in enumerate(sampler.sample(p0, iterations=nsteps)):\n        updt(nsteps, i)\n\n    # Remove burn-in and flatten all chains.\n    nburn = int(burn_frac * nsteps)\n    samples = sampler.chain[:, nburn:, :].reshape((-1, ndim))\n\n    # Shape: (6, 3)\n    point_estim = np.percentile(samples, [16, 50, 84], axis=0).T\n\n    return samples, point_estim\n\n\ndef full_posterior(params, x, y, dx, dy, dxy, priorlimits):\n    \"\"\"\n    The log-posterior of the data given the full mixture model of the linear\n    function and the outlier distribution.\n\n    Parameters\n    ----------\n\n    params : np.ndarray or list\n        [slope,intercept, intrinsic scatter, outlier mean,\n            outlier standard deviation, outlier fraction]\n\n    Returns\n    -------\n\n    float\n        The posterior of the parameters given the data.\n    \"\"\"\n    if log_priors(params, priorlimits) == -np.inf:\n        return -np.inf\n    else:\n        return log_priors(params, priorlimits) +\\\n            full_log_likelihood(params, x, y, dx, dy, dxy)\n\n\ndef log_priors(params, priorlimits):\n    \"\"\"\n    Prior probabilities on the parameters, given upper and lower limits on each\n    parameter. Jeffreys priors are used for the intrinsic and outlier standard\n    deviations, and a prior that is flat in Arctan(slope) is used for the\n    slope. For everything else, priors are uniform within the given limits.\n\n    Parameters\n    ----------\n\n    params : np.ndarray or list\n        [slope, intercept, intrinsic scatter, outlier mean, outlier standard\n         deviation, outlier fraction]\n\n    Returns\n    -------\n\n    float\n        The prior density of these parameters.\n    \"\"\"\n    m, b, sigma_intrinsic, y_outlier, sigma_outlier, outlier_fraction = params\n    mlo, mhi, blo, bhi, silo, sihi, yolo, yohi, solo, sohi, oflo, ofhi =\\\n        priorlimits\n\n    if m < mlo or m > mhi or b < blo or b > bhi or sigma_intrinsic < silo or\\\n        sigma_intrinsic > sihi or sigma_outlier < solo or sigma_outlier > sohi\\\n        or y_outlier < yolo or y_outlier > yohi or outlier_fraction < oflo or\\\n            outlier_fraction > ofhi:\n        return -np.inf\n    else:\n        return -np.log(1. + m * m) - np.log(sigma_intrinsic) -\\\n            np.log(sigma_outlier)\n\n\ndef full_log_likelihood(params, x, y, dx, dy, dxy):\n    \"\"\"\n    The log-likelihood of the data given the full mixture model of the linear\n    function and the outlier distribution.\n\n    This is basically E1. (17) in <NAME> (2010), accounting for the\n    intrinsic scatter term in 'likelihood_line()'.\n\n    Returns\n    -------\n\n    float\n        The likelihood of the data given this set of model parameters.\n    \"\"\"\n    m, b, sigma_intrinsic, y_outlier, sigma_outlier, outlier_fraction = params\n\n    lkl_line = likelihood_line([m, b, sigma_intrinsic], x, y, dx, dy, dxy)\n    out_dist = outlier_distribution(\n        [y_outlier, sigma_outlier], x, y, dx, dy, dxy)\n\n    return np.sum(np.log(\n        (1. - outlier_fraction) * lkl_line + outlier_fraction * out_dist))\n\n\ndef likelihood_line(params, x, y, dx, dy, dxy):\n    \"\"\"\n    Likelihood for the linear function.\n\n    Returns\n    -------\n\n    float\n        The likelihood of the data given this set of model parameters.\n    \"\"\"\n    m, b, sigma_intrinsic = params\n    theta = np.arctan(m)\n\n    sint, cost = np.sin(theta), np.cos(theta)\n\n    # Perpendicular distance to the line\n    delta = -sint * x + cost * y - cost * b\n\n    # Projection of covariance matrix along line\n    Sigma_dd = sint**2. * dx**2. - np.sin(2. * theta) * dxy + cost**2. * dy**2.\n\n    lkl_line = (2. * np.pi * (Sigma_dd + sigma_intrinsic**2.))**-.5 *\\\n        np.exp(-delta**2. \/ (2. * (Sigma_dd + sigma_intrinsic**2.)))\n\n    return lkl_line\n\n\ndef outlier_distribution(params, x, y, dx, dy, dxy):\n    \"\"\"\n    The likelihood for the outlier distribution, which is modeled as a uniform\n    distribution in x and a Gaussian distribution in y with some mean y0 and\n    standard deviation sigma0.\n\n    Returns\n    -------\n\n    float\n        The likelihood of the data given this set of model parameters.\n    \"\"\"\n    y_outlier, sigma_outlier = params\n    sigma_total2 = sigma_outlier**2. + dy**2.\n\n    out_dist = (2. * np.pi * sigma_total2)**-0.5 *\\\n        np.exp(-.5 * (y - y_outlier)**2. \/ sigma_total2)\n\n    return out_dist\n\n\ndef updt(total, progress, extra=\"\"):\n    \"\"\"\n    Displays or updates a console progress bar.\n\n    Original source: https:\/\/stackoverflow.com\/a\/15860757\/1391441\n    \"\"\"\n    barLength, status = 20, \"\"\n    progress = float(progress) \/ float(total)\n    if progress >= 1.:\n        progress, status = 1, \"\\r\\n\"\n    block = int(round(barLength * progress))\n    text = \"\\r[{}] {:.0f}% {}{}\".format(\n        \"#\" * block + \"-\" * (barLength - block),\n        round(progress * 100, 0), extra, status)\n    sys.stdout.write(text)\n    sys.stdout.flush()\n\n\ndef makePlots(x, ex, y, ey, samples, point_estim, m=None, b=None):\n    \"\"\"\n    \"\"\"\n    try:\n        import corner\n        fig = plt.figure(figsize=(10, 10))\n        corner.corner(samples)\n        fig.tight_layout()\n        plt.savefig(\"corner.png\", dpi=150)\n    except ModuleNotFoundError:\n        print(\"No corner module\")\n\n    fig = plt.figure(figsize=(10, 10))\n    ax = plt.subplot(111)\n    ax.minorticks_on()\n    ax.grid(b=True, which='both', color='gray', linestyle='--', lw=.5)\n\n    if m is not None:\n        txt = r\"$True:\\;m={:.3f},\\,b={:.3f}$\".format(m, b)\n    else:\n        txt = ''\n    plt.errorbar(x, y, xerr=ex, yerr=ey, fmt='o', label=txt)\n    xmin, xmax = ax.get_xlim()\n    ymin, ymax = ax.get_ylim()\n\n    mlo, mmed, mhi = point_estim[0]\n    # mlo, mhi = mmed - mlo, mhi - mmed\n    blo, bmed, bhi = point_estim[1]\n    # blo, bhi = bmed - blo, bhi - bmed\n    txt = r\"$Estim:\\;m={:.3f}_{{{:.3f}}}^{{{:.3f}}}$\".format(mmed, mlo, mhi)\n    txt += r\"$,\\;b={:.3f}_{{{:.3f}}}^{{{:.3f}}}$\".format(bmed, blo, bhi)\n    print('\\n' + txt)\n\n    x0 = np.linspace(min(x), max(x), 10)\n    plt.plot(x0, np.poly1d((mmed, bmed))(x0), label=txt, zorder=4)\n\n    plt.xlim(xmin, xmax)\n    plt.ylim(ymin, ymax)\n\n    plt.legend()\n    fig.tight_layout()\n    plt.savefig(\"final_fit.png\", dpi=150)\n\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_587","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Apr 26 13:35:57 2018\n\n@author: cham\n\"\"\"\n\n# %%\n#%pylab qt5\nimport numpy as np\nfrom ruby import get_isochrone_grid, IsoGrid\n# from ruby import isoc_interp, ezinterp\n# from ezpadova.parsec import get_one_isochrone, get_photometry_list\nfrom astropy.table import Table\n\nfrom ruby.isochrone_interp import ezinterp\nfrom ruby.imf import salpeter\n\nfrom ezpadova import parsec\n\n# %%\n\"\"\" 1. define grid \"\"\"\ngrid_feh = np.arange(-4., 1.2, 0.1)  # 4\ngrid_logt = np.arange(6., 10.5, 0.1)  # x2\n\n# ig12 = get_isochrone_grid(\n#        grid_feh, grid_logt, model='parsec12s',\n#        phot='gaiaDR2',Zsun=0.0152, n_jobs=20, verbose=10)\n# ig12.unify(model='parsec12s')\n\n\"\"\" 2. download isochrones \"\"\"\nig_gaiaDR2 = get_isochrone_grid(\n    grid_feh, grid_logt, model='parsec12s_r14',\n    phot='gaiaDR2', Zsun=0.0152, n_jobs=100, verbose=10)\nig_gaiaDR2.Zsun\n\n# %%\nfrom ruby.isochrone_grid import dump_ig, load_ig\n\ndump_ig(ig_gaiaDR2,\n        \"\/media\/cham\/Seagate Expansion Drive\/parsec\/grid\/gaiaDR2.dump\")\n# %%\nfrom ruby.isochrone_grid import dump_ig, load_ig\n\nig_gaiaDR2 = load_ig(\n    \"\/media\/cham\/Seagate Expansion Drive\/parsec\/grid\/gaiaDR2.dump\")\n# %%\nimport copy\n\nig = copy.copy(ig_gaiaDR2)\n\n\"\"\" modify columns \"\"\"\nfrom astropy.table import Column\n\nfor i in range(ig.niso):\n    ig.data[i].add_column(\n        Column(np.log10(ig.data[i][\"Zini\"] \/ ig.Zsun), \"feh_ini\"))\n    # ig.data[i].remove_column(\"feh_ini\")\n    ig.data[i].add_column(Column(np.log10(ig.data[i][\"Z\"] \/ ig.Zsun), \"feh\"))\n    # ig.data[i].remove_column(\"feh\")\n    ig.data[i].add_column(Column(np.log10(ig.data[i][\"Age\"]), \"logt\"))\n    # ig.data[i].remove_column(\"logt\")\n\n# %%\n# ig.unify(model='parsec12s_r14')\n\n\"\"\" 3. select subset of isochrone [columns & rows]\"\"\"\n# ig.sub_rows(cond=(('label', (0, 8)), ('Mini', (0.0, 8.0)), ('logTe', (3.6, 4.1)), ('logg', (2.0, 5.0))))\nig.sub_rows(cond=(('label', (0, 8)), ('Mini', (0.0, 8.0))))\ncolnames = ['feh_ini', 'logt', 'Mini', 'Mass', 'logL', 'logTe', 'logg',\n            'label', 'Mloss', 'feh', 'mbolmag', 'Gmag', 'G_BPmag', 'G_RPmag']\nig.sub_cols(colnames=colnames)\n\n\"\"\" 4. interpolate along Mini, logTe, logg, etc.\"\"\"\nfor i in range(ig.niso):\n    ig.data[i] = ezinterp(ig[i],\n                          restrictions=(\n                          ('Mini', 0.02), ('logTe', 0.02), ('logg', 0.05)),\n                          mode='linear', Mini='Mini')\n\n\"\"\" 5. define volume weight \"\"\"\nig.set_dt(0.2)\nig.set_dfeh(dfeh=0.5)\nig.set_dm()\nig.set_imf(salpeter)\n\n\"\"\" 6. calculate total weight for each point \"\"\"\nfrom astropy.table import Column\n\nfor i in range(ig.niso):\n    w = ig.data[i][\"dm\"] * ig.data[i][\"dt\"] * ig.data[i][\"dfeh\"] * ig.data[i][\n        \"imf\"]\n    try:\n        ig.data[i].add_column(Column(w, \"w\"))\n    except ValueError:\n        ig.data[i][\"w\"] = w\n\n    ig.data[i].add_column(Column(10. ** ig.data[i][\"logTe\"], \"teff\"))\n\n\"\"\" 7. combine all isochrones \"\"\"\nfrom astropy import table\n\ncombined_iso = table.vstack(list(ig.data))\n\n# %%\n# from joblib import dump, load\n# dump(ig, \"\/media\/cham\/Seagate Expansion Drive\/parsec\/grid\/gaiaDR2.dump\")\n\n# %%\n\"\"\" 1. The prior from model \"\"\"\nrcParams.update({\"font.size\": 20})\nH, xe, ye = np.histogram2d(\n    combined_iso[\"logTe\"], combined_iso[\"logg\"],\n    bins=(np.arange(3., 5, .005), np.arange(-1., 6., 0.05)), normed=False,\n    weights=combined_iso[\"w\"])\n\nfig = figure(figsize=(10, 8))\nimshow(np.fliplr(np.log10(H.T)), cmap=cm.jet,\n       extent=(5.005, 2.995, 6.025, -1.025), aspect=\"auto\")\ncolorbar()\nxlim(4.5, 3.3)\nylim(5.5, -1)\n\ntitle(\"log10(Prior)\")\nxlabel(\"$T_{\\\\rm eff}$ [K]\")\nylabel(\"$\\\\log{g}$ [dex]\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/log10_prior.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/log10_prior.svg\")\n\n# %%\nfrom ruby import IsoGrid\n\nx_sun = IsoGrid.predict_from_chi2(\n    combined_iso,\n    var_colnames=[\"teff\", \"logg\", \"feh_ini\"],\n    tlf=np.array(np.array([5750, 4.35, 0.0])),\n    tlf_err=np.array([100., 0.1, 0.1]),\n    return_colnames=(\"Mini\", \"logt\", \"feh_ini\"),\n    q=(0.16, 0.50, 0.84))\n\ntlf = np.array([5750, 4.35, 0.0])  # solar value\ntlf_err = np.array([100., 0.1, 0.1])\n\nvar_colnames = [\"teff\", \"logg\", \"feh_ini\"]\n# 1. convert isochrone(table) into array\nsub_iso = np.array(combined_iso[var_colnames].to_pandas())\n\n# 2. calculate chi2\nchi2_values = 0\nfor i_var in range(len(var_colnames)):\n    chi2_values += ((sub_iso[:, i_var] - tlf[i_var]) \/ tlf_err[\n        i_var]) ** 2.\nchi2_values *= -0.5\n\n# 3. chi2 --> PDF\np_post = np.exp(chi2_values) * combined_iso[\"w\"]\n\nfigure()\nplt.hist(10 ** combined_iso[\"logTe\"], weights=p_post,\n         bins=np.arange(5000, 6000, 30), normed=True)\n\nfigure()\nplt.hist(combined_iso[\"logg\"], weights=p_post, bins=np.arange(4, 5, 0.02),\n         normed=True)\n\nfigure()\nplt.hist(combined_iso[\"feh_ini\"], weights=p_post, bins=np.arange(-1, 1, 0.1),\n         normed=True)\n\nfigure()\nplt.hist2d(10 ** combined_iso[\"logTe\"], combined_iso[\"logg\"],\n           bins=(np.arange(5200, 6250, 25), np.arange(4, 5, 0.05)),\n           weights=p_post, normed=True, cmap=cm.gray_r)\ncolorbar()\n\n# %%\n# H, xe, ye = np.histogram2d(\n#        10.**combined_iso[\"logTe\"], combined_iso[\"logg\"],\n#        bins=(np.arange(3500., 10000, 50.), np.arange(-1., 6., 0.05)), normed=False,\n#        weights=combined_iso[\"w\"])\n#\n# import seaborn as sns\n# Y = np.vstack((10.**combined_iso[\"logTe\"], combined_iso[\"logg\"])).T\n# ax = sns.kdeplot(Y, shade = True, cmap = \"PuBu\")\n#\n#\n# figure()\n# imshow(np.fliplr(np.log10(H.T)), cmap=cm.jet, extent=(10000+25, 3500-25, 6.025, -1.025), aspect=\"auto\")\n# colorbar()\n\n# %%\ntry:\n    combined_iso.add_column(Column(10. ** combined_iso[\"logTe\"], \"teff\"))\n\n# %%\n\ntest_tlf = np.array([5750, 4.35, 0.0])  # solar value\nerr_tlf = np.array([100., 0.1, 0.1])\n\ntest_tlf = np.array([5500, 2.5, 0.0])\nerr_tlf = np.array([100., 0.1, 0.1])\n\ntest_tlf = np.array([10. ** 3.68, 2.44, 0.0])\nerr_tlf = np.array([100., 0.1, 0.1])\n\n\ndef chi2(x, x0, err):\n    return -0.5 * ((x - x0) \/ err) ** 2.\n\n\n# %%timeit\n\ngrid_logt = ig.grid_logt\ngrid_feh = ig.grid_feh\n# grid_mini = np.arange(0.3, 5.1, 0.1)\n\ngrid_logt = ig.grid_logt\n# grid_feh = np.arange(-2.0, 0.8, 0.8)\ngrid_feh = np.array([-2.0, -1.0, 0., 0.4])\ngrid_mini = np.logspace(-1, 1, 30)\n\nmesh_logt, mesh_feh, mesh_mini = np.meshgrid(grid_logt, grid_feh, grid_mini)\n\n\"\"\" ind: 1:feh, 2:logt, 3:mini \"\"\"\nmesh_label = np.zeros_like(mesh_logt)\n# basics, mini, logt, feh\nmesh_logt_est = np.zeros_like(mesh_logt)\nmesh_logt_err = np.zeros_like(mesh_logt)\n\nmesh_feh_est = np.zeros_like(mesh_logt)\nmesh_feh_err = np.zeros_like(mesh_logt)\n\nmesh_mini_est = np.zeros_like(mesh_logt)\nmesh_mini_err = np.zeros_like(mesh_logt)\n\n# spectroscopic, teff, logg\nmesh_teff = np.zeros_like(mesh_logt)\nmesh_teff_est = np.zeros_like(mesh_logt)\nmesh_teff_err = np.zeros_like(mesh_logt)\n\nmesh_logg = np.zeros_like(mesh_logt)\nmesh_logg_est = np.zeros_like(mesh_logt)\nmesh_logg_err = np.zeros_like(mesh_logt)\n\nn_all = np.prod(mesh_logt.shape)\nijk = []\nfor i in range(mesh_logt.shape[0]):\n    for j in range(mesh_logt.shape[1]):\n        for k in range(mesh_logt.shape[2]):\n            o_interp = ig.interp_mini(\n                mesh_logt[i, j, k], mesh_feh[i, j, k], mesh_mini[i, j, k],\n                return_colnames=(\n                'Mini', 'logt', \"feh_ini\", 'teff', 'logg', \"label\"))\n            mesh_teff[i, j, k] = o_interp[3]\n            mesh_logg[i, j, k] = o_interp[4]\n            ijk.append((i, j, k))\n            mesh_label[i, j, k] = o_interp[5]\nprint(len(ijk))\n\nfrom ipyparallel import Client\n\nrc = Client(profile=\"default\")\ndv = rc.direct_view()\ndv.push({\"combined_iso\": combined_iso}).get()\ndv.push({\"mesh_teff\": mesh_teff}).get()\ndv.push({\"mesh_logg\": mesh_logg}).get()\ndv.push({\"mesh_feh\": mesh_feh}).get()\ndv.push({\"flat_mini\": mesh_mini.flatten()}).get()\ndv.push({\"flat_logt\": mesh_logt.flatten()}).get()\n\ndv.execute(\"import numpy as np\").get()\ndv.execute(\"from ruby.isochrone_grid import IsoGrid\").get()\n\ncmd = \"\"\"\nx_all = np.zeros((len(ijk), 3, 3))\nfor i, _ijk in enumerate(ijk):\n    _i, _j, _k = _ijk\n\n    if mesh_teff[_i, _j, _k]>0:\n        try:\n            x_all[i] = IsoGrid.predict_from_chi2(\n                combined_iso, \n                var_colnames=[\"teff\", \"logg\", \"feh_ini\"],\n                tlf=np.array([mesh_teff[_i, _j, _k], mesh_logg[_i, _j, _k], mesh_feh[_i, _j, _k]]), \n                tlf_err=np.array([100., 0.1, 0.1]), \n                return_colnames=(\"Mini\", \"logt\", \"feh_ini\"),\n                q=(0.16, 0.50, 0.84))\n        except ValueError as ae:\n            x_all[i] = np.nan\n    else:\n        x_all[i] = np.nan\n\"\"\"\n\n# %% test\ndv.scatter(\"ijk\", ijk[:100]).get()\n\ndv[\"ijk\"]\ndv[\"len(ijk)\"]\ndv[\"x=1\"]\n% % time\ndv.execute(cmd).get()\n\n# %%\ndv.scatter(\"ijk\", ijk[:]).get()\n\ndv[\"ijk\"]\ndv[\"len(ijk)\"]\ndv[\"x=1\"]\ndv.execute(cmd).get()\n# %%\nx_all = dv.gather(\"x_all\").get()\n# from joblib import dump\n# dump(x_all, \"\/home\/cham\/projects\/gaia\/data\/x_all.dump\")\nfor i, (_i, _j, _k) in enumerate(ijk):\n    mesh_mini_est[_i, _j, _k] = x_all[i][1, 0]\n    mesh_mini_err[_i, _j, _k] = (x_all[i][2, 0] - x_all[i][0, 0]) \/ 2.\n    mesh_logt_est[_i, _j, _k] = x_all[i][1, 1]\n    mesh_logt_err[_i, _j, _k] = (x_all[i][2, 1] - x_all[i][0, 1]) \/ 2.\n\n# %%\nrcParams.update({\"font.size\": 20})\nfig = figure(figsize=(10, 8));\nax = fig.add_subplot(111)\nim = ax.imshow(mesh_logt_err[2], vmin=0., vmax=0.5, cmap=cm.jet,\n               origin=\"lower\",\n               extent=(-1 - 1 \/ 30., 1 + 1 \/ 30., 6. - 0.05, 10.1 + 0.05),\n               aspect=\"auto\")\n\nxticks = np.array([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.])\nax.set_xticks(np.log10(xticks))\nax.set_xticklabels(xticks)\ncolorbar(im)\nax.contour(np.log10(grid_mini), grid_logt, mesh_logt_err[2], [0.1, 0.2, 0.4],\n           colors=\"k\", linewidths=[1, 2, 3])\nax.set_xlabel(\"$M_{ini}$ [$M_\\\\odot$]\")\nax.set_ylabel(\"$\\\\log_{10}$ (age \/ yr)\")\n\nax.plot([0.4, 0.6], [10, 10], lw=1, c=\"k\")\nax.text(.7, 10 - .06, \"0.10\")\n\nax.plot([0.4, 0.6], [9.75, 9.75], lw=2, c=\"k\")\nax.text(.7, 9.75 - .06, \"0.20\")\n\nax.plot([0.4, 0.6], [9.5, 9.50], lw=3, c=\"k\")\nax.text(.7, 9.5 - .06, \"0.40\")\n\nax.set_title(\"Error of $\\\\log_{10}$ (age \/ yr)\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/logt_error.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/logt_error.svg\")\n\n# %%\nrcParams.update({\"font.size\": 20})\nfig = figure(figsize=(10, 8));\nax = fig.add_subplot(111)\nim = ax.imshow(np.abs(mesh_logt_est[2] - mesh_logt[2]), vmin=0, vmax=3,\n               cmap=cm.jet, origin=\"lower\",\n               extent=(-1 - 1 \/ 30., 1 + 1 \/ 30., 6. - 0.05, 10.1 + 0.05),\n               aspect=\"auto\")\n\nxticks = np.array([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.])\nax.set_xticks(np.log10(xticks))\nax.set_xticklabels(xticks)\ncolorbar(im)\nax.contour(np.log10(grid_mini), grid_logt,\n           np.abs(mesh_logt_est[2] - mesh_logt[2]), [0.5, 1.0, 2.0],\n           colors=\"w\", linewidths=[1, 2, 3])\nax.set_xlabel(\"$M_{ini}$ [$M_\\\\odot$]\")\nax.set_ylabel(\"$\\\\log_{10}$ (age \/ yr)\")\n\nax.plot([0.4, 0.6], [10, 10], lw=1, c=\"k\")\nax.text(.7, 10 - .06, \"0.5\")\n\nax.plot([0.4, 0.6], [9.75, 9.75], lw=2, c=\"k\")\nax.text(.7, 9.75 - .06, \"1.0\")\n\nax.plot([0.4, 0.6], [9.5, 9.50], lw=3, c=\"k\")\nax.text(.7, 9.5 - .06, \"2.0\")\n\nax.set_title(\"Bias of $\\\\log_{10}$ (age \/ yr)\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/logt_bias.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/logt_bias.svg\")\n\n# %%\nrcParams.update({\"font.size\": 20})\nfig = figure(figsize=(10, 8));\nax = fig.add_subplot(111)\nim = ax.imshow(mesh_mini_err[2] \/ mesh_mini_est[2], vmin=0., vmax=0.3,\n               cmap=cm.jet, origin=\"lower\",\n               extent=(-1 - 1 \/ 30., 1 + 1 \/ 30., 6. - 0.05, 10.1 + 0.05),\n               aspect=\"auto\")\n\nxticks = np.array([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.])\nax.set_xticks(np.log10(xticks))\nax.set_xticklabels(xticks)\ncolorbar(im)\nax.contour(np.log10(grid_mini), grid_logt, mesh_mini_err[2] \/ mesh_mini_est[2],\n           [0.05, 0.1, 0.2], colors=\"w\", linewidths=[1, 2, 3])\nax.set_xlabel(\"$M_{ini}$ [$M_\\\\odot$]\")\nax.set_ylabel(\"$\\\\log_{10}$ (age \/ yr)\")\n\nax.plot([0.4, 0.6], [10, 10], lw=1, c=\"k\")\nax.text(.7, 10 - .06, \"0.05\")\n\nax.plot([0.4, 0.6], [9.75, 9.75], lw=2, c=\"k\")\nax.text(.7, 9.75 - .06, \"0.10\")\n\nax.plot([0.4, 0.6], [9.5, 9.50], lw=3, c=\"k\")\nax.text(.7, 9.5 - .06, \"0.20\")\n\nax.set_title(\"Error of $M_{ini}$ [$M_\\\\odot$]\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/mass_error.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/mass_error.svg\")\n\n# %%\nrcParams.update({\"font.size\": 20})\nfig = figure(figsize=(10, 8));\nax = fig.add_subplot(111)\nim = ax.imshow(np.abs(mesh_mini_est[2] - mesh_mini[2]) \/ mesh_mini[2], vmin=0.,\n               vmax=0.1, cmap=cm.jet, origin=\"lower\",\n               extent=(-1 - 1 \/ 30., 1 + 1 \/ 30., 6. - 0.05, 10.1 + 0.05),\n               aspect=\"auto\")\n\nxticks = np.array([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.])\nax.set_xticks(np.log10(xticks))\nax.set_xticklabels(xticks)\ncolorbar(im)\nax.contour(np.log10(grid_mini), grid_logt,\n           np.abs(mesh_mini_est[2] - mesh_mini[2]) \/ mesh_mini[2],\n           [0.01, 0.05, 0.08], colors=\"w\", linewidths=[1, 2, 3])\nax.set_xlabel(\"$M_{ini}$ [$M_\\\\odot$]\")\nax.set_ylabel(\"$\\\\log_{10}$ (age \/ yr)\")\n\nax.plot([0.4, 0.6], [10, 10], lw=1, c=\"k\")\nax.text(.7, 10 - .06, \"0.01\")\n\nax.plot([0.4, 0.6], [9.75, 9.75], lw=2, c=\"k\")\nax.text(.7, 9.75 - .06, \"0.05\")\n\nax.plot([0.4, 0.6], [9.5, 9.50], lw=3, c=\"k\")\nax.text(.7, 9.5 - .06, \"0.08\")\n\nax.set_title(\"Bias of $M_{ini}$ [$M_\\\\odot$]\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/mass_bias.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/mass_bias.svg\")\n\n# %%\nrcParams.update({\"font.size\": 20})\nfig = figure(figsize=(10, 8));\nax = fig.add_subplot(111)\nim = ax.imshow(mesh_label[2], vmin=0., vmax=7, cmap=cm.jet, origin=\"lower\",\n               extent=(-1 - 1 \/ 30., 1 + 1 \/ 30., 6. - 0.05, 10.1 + 0.05),\n               aspect=\"auto\")\n\nxticks = np.array([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.])\nax.set_xticks(np.log10(xticks))\nax.set_xticklabels(xticks)\ncolorbar(im)\nax.contour(np.log10(grid_mini), grid_logt, mesh_label[2], [0.5, 1.5, 2.5],\n           colors=\"w\", linewidths=[1, 2, 3])\nax.set_xlabel(\"$M_{ini}$ [$M_\\\\odot$]\")\nax.set_ylabel(\"$\\\\log_{10}$ (age \/ yr)\")\n\nax.plot([0.4, 0.6], [10, 10], lw=1, c=\"k\")\nax.text(.7, 10 - .06, \"0.5\")\n\nax.plot([0.4, 0.6], [9.75, 9.75], lw=2, c=\"k\")\nax.text(.7, 9.75 - .06, \"1.5\")\n\nax.plot([0.4, 0.6], [9.5, 9.50], lw=3, c=\"k\")\nax.text(.7, 9.5 - .06, \"2.5\")\n\nax.set_title(\"Labels\")\nfig.tight_layout()\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/label.pdf\")\nfig.savefig(\"\/home\/cham\/projects\/gaia\/figs\/bayesian\/label.svg\")\n\n# %%\niso = ig.get_iso(9.7, 0)\nfigure()\nplot(iso[\"teff\"], iso[\"logg\"], 'x-')\nfor i in range(len(iso)):\n    #    text(iso[\"teff\"][i], iso[\"logg\"][i], \"{:1.0f}\".format(iso[\"label\"][i]))\n    text(iso[\"teff\"][i], iso[\"logg\"][i], \"{:1.3f}\".format(iso[\"Mini\"][i]))\n\n# %%\n\nfigure()\nplot(mesh_teff[2].flatten(), mesh_logg[2].flatten(), '.')\n\n# %%\ngrid_teff = np.arange(8000., 4000, -100)\ngrid_logg = np.arange(6, -0.1, -0.2)\n# grid_feh  = np.array([0.])\n\n# mesh_teff, mesh_logg, mesh_feh = np.meshgrid(grid_teff, grid_logg, grid_feh)\nmesh_teff, mesh_logg = np.meshgrid(grid_teff, grid_logg)\n\nflat_teff = mesh_teff.flatten()\nflat_logg = mesh_logg.flatten()\n\ndv.scatter(\"flat_teff\", flat_teff).get()\ndv.scatter(\"flat_logg\", flat_logg).get()\ndv[\"flat_teff.shape\"]\n\ncmd = \"\"\"\nx_all = np.zeros((len(flat_teff), 3, 3))\nfor i, (_teff, _logg) in enumerate(zip(flat_teff, flat_logg)):\n    try:\n        x_all[i] = IsoGrid.predict_from_chi2(\n            combined_iso, \n            var_colnames=[\"teff\", \"logg\", \"feh_ini\"],\n            tlf=np.array([_teff, _logg, 0.]), \n            tlf_err=np.array([100., 0.1, 0.1]), \n            return_colnames=(\"Mini\", \"logt\", \"feh_ini\"),\n            q=(0.16, 0.50, 0.84))\n    except ValueError as ae:\n        x_all[i] = np.nan\n\"\"\"\ndv.execute(cmd).get()\n\n# %%\nx2 = dv.gather(\"x_all\").get()\nmesh_mini_est = x2[:, 1, 0].reshape(*mesh_teff.shape)\nmesh_mini_err = ((x2[:, 2, 0] - x2[:, 0, 0]) \/ 2.).reshape(*mesh_teff.shape)\nmesh_logt_est = x2[:, 1, 1].reshape(*mesh_teff.shape)\nmesh_logt_err = ((x2[:, 2, 1] - x2[:, 0, 1]) \/ 2.).reshape(*mesh_teff.shape)\n# %%\n\nfigure()\nimshow(mesh_mini_err)\n# %%\nif mesh_teff[i, j, k] > 0 and i > 0 and j > 0:\n    # do a chi2 matching\n    try:\n        x = ig.predict_from_chi2(\n            combined_iso,\n            var_colnames=[\"teff\", \"logg\", \"feh_ini\"],\n            tlf=np.array(\n                [mesh_teff[i, j, k], mesh_logg[i, j, k], mesh_feh[i, j, k]]),\n            tlf_err=np.array([100., 0.1, 0.1]),\n            return_colnames=(\"Mini\", \"logt\", \"feh_ini\"),\n            q=(0.16, 0.50, 0.84))\n        mesh_mini_est[i, j, k] = x[1, 0]\n        mesh_mini_err[i, j, k] = (x[2, 0] - x[0, 0]) \/ 2.\n        mesh_logt_est[i, j, k] = x[1, 1]\n        mesh_logt_err[i, j, k] = (x[2, 1] - x[0, 1]) \/ 2.\n        print(i, j, k, n_all, \"success\")\n    except ValueError as ae:\n        mesh_mini_est[i, j, k] = np.nan\n        mesh_mini_err[i, j, k] = np.nan\n        mesh_logt_est[i, j, k] = np.nan\n        mesh_logt_err[i, j, k] = np.nan\n        print(i, j, k, n_all, \"failure\")\nelse:\n    mesh_mini_est[i, j, k] = np.nan\n    mesh_mini_err[i, j, k] = np.nan\n    mesh_logt_est[i, j, k] = np.nan\n    mesh_logt_err[i, j, k] = np.nan\n    print(i, j, k, n_all, \"failure\")\n\nx = ig.predict_from_chi2(\n    combined_iso,\n    var_colnames=[\"teff\", \"logg\", \"feh_ini\"],\n    tlf=np.array([5500, 2.5, 0.0]),\n    tlf_err=np.array([100., 0.1, 0.1]),\n    return_colnames=(\"Mini\", \"logt\", \"feh_ini\", \"G\"),\n    q=(0.16, 0.50, 0.84))\n\n# %%\n\n\nvar_colnames = [\"teff\", \"logg\", \"feh_ini\"]\nsub_iso = np.array(combined_iso[var_colnames].to_pandas())\n\nchi2_values = 0\nfor ivar in range(len(var_colnames)):\n    chi2_values += ((sub_iso[:, ivar] - test_tlf[ivar]) \/ err_tlf[ivar]) ** 2.\nchi2_values *= -0.5\n\np_post = np.exp(chi2_values) * combined_iso[\"w\"]\n\nu_feh_ini, inv_ind = np.unique(combined_iso[\"feh_ini\"], return_inverse=True)\n\nu_p_post = np.zeros(u_feh_ini.shape)\nu_p_post[inv_ind] = u_p_post[inv_ind] + p_post\nfor i, _ in enumerate(inv_ind):\n    if _ < len(u_p_post):\n        u_p_post[_] += 0.5 * p_post[i]\n        u_p_post[_ + 1] += 0.5 * p_post[i]\n    else:\n        u_p_post[_] += p_post[i]\n\nfrom scipy.interpolate import interp1d\n\ninterp1d(np.cumsum(u_p_post) \/ np.sum(u_p_post), u_feh_ini)((0.16, 0.50, 0.84))\n\nfigure()\nplot(u_feh_ini, u_p_post)\nplot(u_feh_ini, np.cumsum(u_p_post))\n\nu_teff, inv_ind = np.unique(combined_iso[\"teff\"], return_inverse=True)\nu_p_post = np.zeros_like(u_teff)\nu_p_post[inv_ind] += p_post\nfigure()\nplot(u_teff, u_p_post)\nplot(u_teff, np.cumsum(u_p_post))\n# %% teff\nhist, bin_edges = np.histogram(combined_iso[\"teff\"],\n                               bins=np.arange(3500., 10000, 50.), normed=True,\n                               weights=p_post)\n\nfigure()\nplt.step(bin_edges[:-1], hist)\n\n# %% logg\nhist, bin_edges = np.histogram(combined_iso[\"logg\"],\n                               np.arange(-1., 6., 0.1), normed=True,\n                               weights=p_post)\n\nfigure()\nplt.step(bin_edges[:-1], hist)\n\n# %% Mini\nhist, bin_edges = np.histogram(combined_iso[\"Mini\"],\n                               np.arange(0., 6., 0.2), normed=True,\n                               weights=p_post)\n\nfigure()\nplt.step(bin_edges[:-1], hist)\n\n# %% logt\nhist, bin_edges = np.histogram(combined_iso[\"logt\"],\n                               np.arange(0., 13., 0.2), normed=True,\n                               weights=p_post)\n\nfigure()\nplt.step(bin_edges[:-1], hist)\n\n# %%\n\nH, xe, ye = np.histogram2d(\n    combined_iso[\"teff\"], combined_iso[\"logg\"],\n    bins=(np.arange(3500., 10000, 100.), np.arange(-1., 6., 0.1)), normed=True,\n    weights=p_post)\nH = np.log10(H)\nfigure()\nimshow(np.fliplr(H.T), cmap=cm.jet,\n       extent=(10000 + 25, 3500 - 25, 6.025, -1.025),\n       aspect=\"auto\", vmin=-10, vmax=np.nanmax(H))\n\n# %%\nH, xe, ye = np.histogram2d(\n    combined_iso[\"Mini\"], combined_iso[\"logt\"],\n    bins=(np.arange(0, 5, 0.1), np.arange(0, 13., 0.2)), normed=True,\n    weights=p_post)\nH = np.log10(H)\n# H *= H>-10\nfigure()\nimshow(H.T, cmap=cm.gray_r,\n       extent=(0 - 0.025, 5 + 0.025, 6 - 0.05, 10.0 + 0.05),\n       aspect=\"auto\", vmin=-10, vmax=np.nanmax(H))\n\n# %%\n\nfigure()\nplot(sub_iso[:, 1], chi2_values, 'o', alpha=0.5)\n\nfigure()\nscatter(sub_iso[:, 0], sub_iso[:, 1], s=10, c=chi2_values, alpha=0.5, vmin=-10,\n        vmax=0, cmap=cm.gray_r)\ncolorbar()\nxlim(6500, 5000)\nylim(, 5500)\n\n\n# %%\nfigure()\nplot(combined_iso[\"logTe\"], combined_iso[\"logg\"], '.')\n\nfrom joblib import dump\n\ndump(ig, \"\/media\/cham\/Seagate Expansion Drive\/parsec\/grid\/gaiaDR2.dump\")\n\n\n# %%\ndef salpeter(m, ksi0=1.0):\n    return ksi0 * (m) ** -2.35\n\n\nx = np.arange(0.08, 12.0, 0.01)\ny = salpeter(x)\nfigure()\nplot(np.log10(x), np.log10(y))\ni\n\nd_mini\n\n# %%\n\nfigure()\nfor isoc in ig.data:\n    ind = (isoc[\"label\"] >= 1) & (isoc[\"label\"] < 8) & (isoc[\"Mini\"] < 12)\n    ind = (isoc[\"label\"] < 9) & (isoc[\"Mini\"] < 12)\n    plot(isoc[\"logTe\"][ind], isoc[\"logg\"][ind], 'kx', alpha=0.05)\n\n# %%\nfigure();\nx = ig.get_iso(9.0, 0)\nplot(x[\"logTe\"], x[\"logg\"], \"r-.\")\nfor i in range(len(x)):\n    text(x[\"logTe\"][i], x[\"logg\"][i], \"{}\".format(x[\"label\"][i]))\n\nx = ig12.get_iso(9.0, 0)\nplot(x[\"logTe\"], x[\"logg\"], \"b-.\")\nfor i in range(len(x)):\n    text(x[\"logTe\"][i], x[\"logg\"][i], \"{}\".format(x[\"label\"][i]))\n\n# %%\n\"\"\"\nProcess:\n    0. Download grid d_logt=0.05, d_feh_ini=0.05\n    1. unify colnames\n    2. subcol & subrow, Mini<12.0, 1<=label<8\n    3. interpolate : \n        Mini 0.02\n        logTe 0.01\n        logg 0.01\n    4. calculate weight\n    5. add prior\/weight\n\nstage. The labels are: \n0=PMS, \n1=MS, \n2=SGB, \n3=RGB, \n(4,5,6)=different stages of CHEB, \n7=EAGB, \n8=TPAGB.\n\"\"\"\n# %%\nprint(ig)\nprint(ig12)\n\n# %%\nig12.get_iso(9.0, 0.0)\nig.get_iso(9.0, 0.0)[\"label\"]\n\nunify12(isoc)\n\n# %%\n# Mini\n\n# Mass --> Mact\n# isoc.rename_column(\"Mass\", \"Mact\")\n\n# Mass --> Mact\n\n\n# define (minit, logt, feh) column names\n\n\nx12 = ig12.get_iso(7.0, 0.0)\nx = ig.get_iso(7.0, 0.0)\n\nplot(isoc_interp(x, restrictions=((\"Mini\", 0.05),),\n                 interp_config=((\"label\", \"linear\"),), M_ini=\"Mini\"))\n\nfigure();\nplot(x[\"Mini\"][:-1], np.diff(x[\"Mini\"]))\n\n# %%\nfrom ruby import IsoSet\n\nIsoSet(isoc_list, vgrid_feh)\n\n# %%\n# get_one_isochrone(1e9, 0.0152, model=\"parsec12s\",phot=\"gaia\")\n\ngrid_feh = np.arange(-4., 1.2, 0.2)\ngrid_logt = np.arange(6., 10.5, 0.05)\n\nvgrid_feh, vgrid_logt, grid_list, isoc_list = get_isochrone_grid(\n    grid_feh, grid_logt, model='parsec12s_r14', phot='gaiaDR2',\n    Zsun=0.0152, n_jobs=20, verbose=10)\n\nnp.sum([_.data.shape[0] for _ in isoc_list])\n\nfrom ezpadova import parsec\n\nprint(parsec.get_one_isochrone(1e7, 0.02, model='parsec12s',\n                               phot='gaia').colnames)\nprint(parsec.get_one_isochrone(1e7, 0.02, model='parsec12s_r14',\n                               phot='gaia').colnames)\n\n# %%\n\ngdr1 = parsec.get_one_isochrone(1e9, 0.0152, model='parsec12s', phot='gaia')\ngdr1_r14 = parsec.get_one_isochrone(1e9, 0.0152, model='parsec12s_r14',\n                                    phot='gaia')\ngdr2 = parsec.get_one_isochrone(1e9, 0.0152, model='parsec12s', phot='gaiaDR2')\n# %%\nfigure()\nplot(gdr1[\"G\"] - gdr1[\"G_RP\"], gdr1[\"G\"], '-')\nscatter(gdr1[\"G\"] - gdr1[\"G_RP\"], gdr1[\"G\"], s=10, c=gdr1[\"stage\"],\n        cmap=cm.jet)\n\nind = gdr1_r14[\"label\"] < 8\nplot(gdr1_r14[\"Gmag\"][ind] - gdr1_r14[\"G_RPmag\"][ind], gdr1_r14[\"Gmag\"][ind],\n     '-')\ncolorbar()\nylim(30, -30)\n# %%\nfigure()\nplot(gdr1[\"Gmag\"] - gdr1[\"G_RPmag\"], gdr1[\"Gmag\"], '-')\nplot(gdr2[\"Gmag\"] - gdr2[\"G_RPmag\"], gdr2[\"Gmag\"], '-')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_588","text":"\"\"\"Xiaomi Mi BLE monitor integration.\"\"\"\nfrom datetime import timedelta\nimport logging\nimport os\nimport statistics as sts\nimport struct\nimport subprocess\nimport sys\nimport tempfile\nimport voluptuous as vol\n\nfrom homeassistant.const import (\n    DEVICE_CLASS_TEMPERATURE,\n    DEVICE_CLASS_HUMIDITY,\n    TEMP_CELSIUS,\n    ATTR_BATTERY_LEVEL,\n)\nfrom homeassistant.components.sensor import PLATFORM_SCHEMA\nimport homeassistant.helpers.config_validation as cv\nfrom homeassistant.helpers.entity import Entity\nfrom homeassistant.helpers.event import track_point_in_utc_time\nimport homeassistant.util.dt as dt_util\n\nfrom .const import (\n    DEFAULT_ROUNDING,\n    DEFAULT_DECIMALS,\n    DEFAULT_PERIOD,\n    DEFAULT_LOG_SPIKES,\n    DEFAULT_USE_MEDIAN,\n    DEFAULT_HCITOOL_ACTIVE,\n    DEFAULT_IFACE,\n    CONF_ROUNDING,\n    CONF_DECIMALS,\n    CONF_PERIOD,\n    CONF_LOG_SPIKES,\n    CONF_USE_MEDIAN,\n    CONF_HCITOOL_ACTIVE,\n    CONF_IFACE,\n    CONF_TMIN,\n    CONF_TMAX,\n    CONF_HMIN,\n    CONF_HMAX,\n    XIAOMI_TYPE_DICT,\n)\n\n_LOGGER = logging.getLogger(__name__)\n\nPLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(\n    {\n        vol.Optional(CONF_ROUNDING, default=DEFAULT_ROUNDING): cv.boolean,\n        vol.Optional(CONF_DECIMALS, default=DEFAULT_DECIMALS): cv.positive_int,\n        vol.Optional(CONF_PERIOD, default=DEFAULT_PERIOD): cv.positive_int,\n        vol.Optional(CONF_LOG_SPIKES, default=DEFAULT_LOG_SPIKES): cv.boolean,\n        vol.Optional(CONF_USE_MEDIAN, default=DEFAULT_USE_MEDIAN): cv.boolean,\n        vol.Optional(\n            CONF_HCITOOL_ACTIVE, default=DEFAULT_HCITOOL_ACTIVE\n        ): cv.boolean,\n        vol.Optional(CONF_IFACE, default=DEFAULT_IFACE): cv.positive_int,\n    }\n)\n\n# Structured objects for data conversions\nTH_STRUCT = struct.Struct(\"<hH\")\nH_STRUCT = struct.Struct(\"<H\")\nT_STRUCT = struct.Struct(\"<h\")\nCND_STRUCT = struct.Struct(\"<H\")\nILL_STRUCT = struct.Struct(\"<I\")\n\n\ndef reverse_mac(rmac):\n    \"\"\"Change LE order to BE.\"\"\"\n    if len(rmac) != 12:\n        return None\n    return (\n        rmac[10:12]\n        + rmac[8:10]\n        + rmac[6:8]\n        + rmac[4:6]\n        + rmac[2:4]\n        + rmac[0:2]\n    )\n\n\ndef parse_xiomi_value(hexvalue, typecode):\n    \"\"\"Convert value depending on its type.\"\"\"\n    vlength = len(hexvalue) \/ 2\n    if vlength == 4:\n        if typecode == \"0D\":\n            temp, humi = TH_STRUCT.unpack(bytes.fromhex(hexvalue))\n            return {\"temperature\": temp \/ 10, \"humidity\": humi \/ 10}\n    if vlength == 2:\n        if typecode == \"06\":\n            humi, = H_STRUCT.unpack(bytes.fromhex(hexvalue))\n            return {\"humidity\": humi \/ 10}\n        if typecode == \"04\":\n            temp, = T_STRUCT.unpack(bytes.fromhex(hexvalue))\n            return {\"temperature\": temp \/ 10}\n        if typecode == \"09\":\n            cond, = CND_STRUCT.unpack(bytes.fromhex(hexvalue))\n            return {\"conductivity\": cond}\n    if vlength == 1:\n        if typecode == \"0A\":\n            return {\"battery\": int(hexvalue, 16)}\n        if typecode == \"08\":\n            return {\"moisture\": int(hexvalue, 16)}\n    if vlength == 3:\n        if typecode == \"07\":\n            illum, = ILL_STRUCT.unpack(bytes.fromhex(hexvalue + \"00\"))\n            return {\"illuminance\": illum}\n    return {}\n\n\ndef parse_raw_message(data):\n    \"\"\"Parse the raw data.\"\"\"\n    if data is None:\n        return None\n\n    # check for Xiaomi service data\n    xiaomi_index = data.find(\"1695FE\", 33)\n    if xiaomi_index == -1:\n        return None\n\n    # check for no BR\/EDR + LE General discoverable mode flags\n    adv_index = data.find(\"020106\", 28, 34)\n    if adv_index == -1:\n        return None\n\n    # check for BTLE msg size\n    msg_length = int(data[4:6], 16) * 2 + 6\n    if msg_length != len(data):\n        return None\n\n    # check for MAC presence in message and in service data\n    xiaomi_mac_reversed = data[xiaomi_index + 16:xiaomi_index + 28]\n    source_mac_reversed = data[adv_index - 14:adv_index - 2]\n    if xiaomi_mac_reversed != source_mac_reversed:\n        return None\n\n    # check if RSSI is valid\n    rssi, = struct.unpack(\n        \"<b\", bytes.fromhex(data[msg_length - 2:msg_length])\n    )\n    if not 0 >= rssi >= -127:\n        return None\n\n    try:\n        sensor_type, toffset = XIAOMI_TYPE_DICT[\n            data[xiaomi_index + 8:xiaomi_index + 14]\n        ]\n    except KeyError:\n        _LOGGER.debug(\n            \"Unknown sensor type: %s\",\n            data[xiaomi_index + 8:xiaomi_index + 14],\n        )\n        return None\n\n    # xiaomi data length = message length\n    #     -all bytes before XiaomiUUID\n    #     -3 bytes Xiaomi UUID + ADtype\n    #     -1 byte rssi\n    #     -3+1 bytes sensor type\n    #     -1 byte packet_id\n    #     -6 bytes MAC\n    #     - sensortype offset\n    xdata_length = msg_length - xiaomi_index - 30 - toffset * 2\n    if xdata_length < 8:\n        return None\n    xdata_point = xiaomi_index + (14 + toffset) * 2\n    xnext_point = xdata_point + 6\n    # check if xiaomi data start and length is valid\n    if xdata_length != len(data[xdata_point:-2]):\n        return None\n\n    packet_id = int(data[xiaomi_index + 14:xiaomi_index + 16], 16)\n    result = {\n        \"rssi\": rssi,\n        \"mac\": reverse_mac(xiaomi_mac_reversed),\n        \"type\": sensor_type,\n        \"packet\": packet_id,\n    }\n\n    # loop through xiaomi payload\n    # assume that the data may have several values ​​of different types,\n    # although I did not notice this behavior with my LYWSDCGQ sensors\n    while True:\n        xvalue_typecode = data[xdata_point:xdata_point + 2]\n        try:\n            xvalue_length = int(data[xdata_point + 4:xdata_point + 6], 16)\n        except ValueError as error:\n            _LOGGER.error(\"xvalue_length conv. error: %s\", error)\n            result = {}\n            break\n        xnext_point = xdata_point + 6 + xvalue_length * 2\n        xvalue = data[xdata_point + 6:xnext_point]\n        res = parse_xiomi_value(xvalue, xvalue_typecode)\n        if res:\n            result.update(res)\n        if xnext_point > msg_length - 6:\n            break\n        xdata_point = xnext_point\n    return result\n\n\nclass BLEScanner:\n    \"\"\"BLE scanner.\"\"\"\n\n    hcitool = None\n    hcidump = None\n    tempf = tempfile.TemporaryFile(mode=\"w+b\")\n    devnull = (\n        subprocess.DEVNULL\n        if sys.version_info > (3, 0)\n        else open(os.devnull, \"wb\")\n    )\n\n    def start(self, config):\n        \"\"\"Start receiving broadcasts.\"\"\"\n        hcitool_active = config[CONF_HCITOOL_ACTIVE]\n        iface = config[CONF_IFACE]\n        _LOGGER.debug(\"Start receiving broadcasts\")\n        hcitoolcmd = [\"hcitool\", \"lescan\", \"--duplicates\", \"--passive\"]\n        if hcitool_active:\n            hcitoolcmd = [\"hcitool\", \"lescan\", \"--duplicates\"]\n        if iface != 0:\n            hcitoolcmd.append(\"-i hci\" + iface)\n        self.hcitool = subprocess.Popen(\n            hcitoolcmd, stdout=self.devnull, stderr=self.devnull\n        )\n        hcidumpcmd = [\"hcidump\", \"--raw\"]\n        if iface != 0:\n            hcidumpcmd.append(\"-i hci\" + iface)\n        hcidumpcmd.append(\"hci\")\n        self.hcidump = subprocess.Popen(\n            hcidumpcmd, stdout=self.tempf, stderr=self.devnull\n        )\n\n    def stop(self):\n        \"\"\"Stop receiving broadcasts.\"\"\"\n        _LOGGER.debug(\"Stop receiving broadcasts\")\n        self.hcidump.terminate()\n        self.hcidump.communicate()\n        self.hcitool.terminate()\n        self.hcitool.communicate()\n\n    def shutdown_handler(self, event):\n        \"\"\"Run homeassistant_stop event handler.\"\"\"\n        _LOGGER.debug(\"Running homeassistant_stop event handler: %s\", event)\n        self.hcidump.kill()\n        self.hcidump.communicate()\n        self.hcitool.kill()\n        self.hcitool.communicate()\n        self.tempf.close()\n\n    def messages(self):\n        \"\"\"Get data from hcidump.\"\"\"\n        data = \"\"\n        try:\n            _LOGGER.debug(\"reading hcidump...\")\n            self.tempf.flush()\n            self.tempf.seek(0)\n            for line in self.tempf:\n                try:\n                    sline = line.decode()\n                except AttributeError:\n                    _LOGGER.debug(\"Error decoding line: %s\", line)\n                # _LOGGER.debug(line)\n                if sline.startswith(\"> \"):\n                    yield data\n                    data = sline[2:].strip().replace(\" \", \"\")\n                elif sline.startswith(\"< \"):\n                    yield data\n                    data = \"\"\n                else:\n                    data += sline.strip().replace(\" \", \"\")\n        except RuntimeError as error:\n            _LOGGER.error(\"Error during reading of hcidump: %s\", error)\n            data = \"\"\n        self.tempf.seek(0)\n        self.tempf.truncate(0)\n        yield data\n\n\ndef setup_platform(hass, config, add_entities, discovery_info=None):\n    \"\"\"Set up the sensor platform.\"\"\"\n    _LOGGER.debug(\"Starting\")\n    scanner = BLEScanner()\n    hass.bus.listen(\"homeassistant_stop\", scanner.shutdown_handler)\n    scanner.start(config)\n\n    sensors_by_mac = {}\n\n    def discover_ble_devices(config):\n        \"\"\"Discover Bluetooth LE devices.\"\"\"\n        _LOGGER.debug(\"Discovering Bluetooth LE devices\")\n        rounding = config[CONF_ROUNDING]\n        decimals = config[CONF_DECIMALS]\n        log_spikes = config[CONF_LOG_SPIKES]\n        use_median = config[CONF_USE_MEDIAN]\n\n        _LOGGER.debug(\"Stopping\")\n        scanner.stop()\n\n        _LOGGER.debug(\"Analyzing\")\n        stype = {}\n        hum_m_data = {}\n        temp_m_data = {}\n        illum_m_data = {}\n        moist_m_data = {}\n        cond_m_data = {}\n        batt = {}  # battery\n        lpacket = {}  # last packet number\n        rssi = {}\n        macs = {}  # all found macs\n        for msg in scanner.messages():\n            data = parse_raw_message(msg)\n            if data and \"mac\" in data:\n                # ignore duplicated message\n                packet = int(data[\"packet\"])\n                if data[\"mac\"] in lpacket:\n                    prev_packet = lpacket[data[\"mac\"]]\n                else:\n                    prev_packet = None\n                if prev_packet == packet:\n                    _LOGGER.debug(\"DUPLICATE: %s, IGNORING!\", data)\n                    continue\n                _LOGGER.debug(\"NEW DATA: %s\", data)\n                lpacket[data[\"mac\"]] = packet\n                # store found readings per device\n                if \"temperature\" in data:\n                    if CONF_TMAX >= data[\"temperature\"] >= CONF_TMIN:\n                        if data[\"mac\"] not in temp_m_data:\n                            temp_m_data[data[\"mac\"]] = []\n                        temp_m_data[data[\"mac\"]].append(data[\"temperature\"])\n                        macs[data[\"mac\"]] = data[\"mac\"]\n                    elif log_spikes:\n                        _LOGGER.error(\n                            \"Temperature spike: %s (%s)\",\n                            data[\"temperature\"],\n                            data[\"mac\"],\n                        )\n                if \"humidity\" in data:\n                    if CONF_HMAX >= data[\"humidity\"] >= CONF_HMIN:\n                        if data[\"mac\"] not in hum_m_data:\n                            hum_m_data[data[\"mac\"]] = []\n                        hum_m_data[data[\"mac\"]].append(data[\"humidity\"])\n                        macs[data[\"mac\"]] = data[\"mac\"]\n                    elif log_spikes:\n                        _LOGGER.error(\n                            \"Humidity spike: %s (%s)\",\n                            data[\"humidity\"],\n                            data[\"mac\"],\n                        )\n                if \"conductivity\" in data:\n                    if data[\"mac\"] not in cond_m_data:\n                        cond_m_data[data[\"mac\"]] = []\n                    cond_m_data[data[\"mac\"]].append(data[\"conductivity\"])\n                    macs[data[\"mac\"]] = data[\"mac\"]\n                if \"moisture\" in data:\n                    if data[\"mac\"] not in moist_m_data:\n                        moist_m_data[data[\"mac\"]] = []\n                    moist_m_data[data[\"mac\"]].append(data[\"moisture\"])\n                    macs[data[\"mac\"]] = data[\"mac\"]\n                if \"illuminance\" in data:\n                    if data[\"mac\"] not in illum_m_data:\n                        illum_m_data[data[\"mac\"]] = []\n                    illum_m_data[data[\"mac\"]].append(data[\"illuminance\"])\n                    macs[data[\"mac\"]] = data[\"mac\"]\n                if \"battery\" in data:\n                    batt[data[\"mac\"]] = int(data[\"battery\"])\n                    macs[data[\"mac\"]] = data[\"mac\"]\n                if data[\"mac\"] not in rssi:\n                    rssi[data[\"mac\"]] = []\n                rssi[data[\"mac\"]].append(int(data[\"rssi\"]))\n                stype[data[\"mac\"]] = data[\"type\"]\n\n        # for every seen device\n        for mac in macs:\n            if mac in sensors_by_mac:\n                sensors = sensors_by_mac[mac]\n            else:\n                if stype[mac] == \"HHCCJCY01\":\n                    sensors = [\n                        TemperatureSensor(mac),\n                        MoistureSensor(mac),\n                        ConductivitySensor(mac),\n                        IlluminanceSensor(mac),\n                    ]\n                else:\n                    sensors = [TemperatureSensor(mac), HumiditySensor(mac)]\n                sensors_by_mac[mac] = sensors\n                add_entities(sensors)\n            for sensor in sensors:\n                getattr(sensor, \"_device_state_attributes\")[\n                    \"last packet id\"\n                ] = lpacket[mac]\n                getattr(sensor, \"_device_state_attributes\")[\"rssi\"] = round(\n                    sts.mean(rssi[mac])\n                )\n                getattr(sensor, \"_device_state_attributes\")[\n                    \"sensor type\"\n                ] = stype[mac]\n                if mac in batt:\n                    getattr(sensor, \"_device_state_attributes\")[\n                        ATTR_BATTERY_LEVEL\n                    ] = batt[mac]\n            # averaging and states updating\n            tempstate_mean = None\n            humstate_mean = None\n            illumstate_mean = None\n            moiststate_mean = None\n            condstate_mean = None\n            tempstate_median = None\n            humstate_median = None\n            illumstate_median = None\n            moiststate_median = None\n            condstate_median = None\n            if use_median:\n                textattr = \"last median of\"\n            else:\n                textattr = \"last mean of\"\n            if mac in temp_m_data:\n                try:\n                    if rounding:\n                        tempstate_median = round(\n                            sts.median(temp_m_data[mac]), decimals\n                        )\n                        tempstate_mean = round(\n                            sts.mean(temp_m_data[mac]), decimals\n                        )\n                    else:\n                        tempstate_median = sts.median(temp_m_data[mac])\n                        tempstate_mean = sts.mean(temp_m_data[mac])\n                    if use_median:\n                        setattr(sensors[0], \"_state\", tempstate_median)\n                    else:\n                        setattr(sensors[0], \"_state\", tempstate_mean)\n                    getattr(sensors[0], \"_device_state_attributes\")[\n                        textattr\n                    ] = len(temp_m_data[mac])\n                    getattr(sensors[0], \"_device_state_attributes\")[\n                        \"median\"\n                    ] = tempstate_median\n                    getattr(sensors[0], \"_device_state_attributes\")[\n                        \"mean\"\n                    ] = tempstate_mean\n                    sensors[0].async_schedule_update_ha_state()\n                except AttributeError:\n                    _LOGGER.info(\"Sensor %s not yet ready for update\", mac)\n                except ZeroDivisionError:\n                    _LOGGER.error(\n                        \"Division by zero while temperature averaging!\"\n                    )\n                    continue\n                except IndexError as error:\n                    _LOGGER.error(\n                        \"Sensor %s (%s, temp.) update error:\", mac, stype[mac]\n                    )\n                    _LOGGER.error(\"%s. Index is 0!\", error)\n                    _LOGGER.error(\"sensors list size: %i\", len(sensors))\n            if mac in hum_m_data:\n                try:\n                    if rounding:\n                        humstate_median = round(\n                            sts.median(hum_m_data[mac]), decimals\n                        )\n                        humstate_mean = round(\n                            sts.mean(hum_m_data[mac]), decimals\n                        )\n                    else:\n                        humstate_median = sts.median(hum_m_data[mac])\n                        humstate_mean = sts.mean(hum_m_data[mac])\n                    if use_median:\n                        setattr(sensors[1], \"_state\", humstate_median)\n                    else:\n                        setattr(sensors[1], \"_state\", humstate_mean)\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        textattr\n                    ] = len(hum_m_data[mac])\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        \"median\"\n                    ] = humstate_median\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        \"mean\"\n                    ] = humstate_mean\n                    sensors[1].async_schedule_update_ha_state()\n                except AttributeError:\n                    _LOGGER.info(\"Sensor %s not yet ready for update\", mac)\n                except ZeroDivisionError:\n                    _LOGGER.error(\"Division by zero while humidity averaging!\")\n                    continue\n                except IndexError as error:\n                    _LOGGER.error(\n                        \"Sensor %s (%s, hum.) update error:\", mac, stype[mac]\n                    )\n                    _LOGGER.error(\"%s. Index is 1!\", error)\n                    _LOGGER.error(\"sensors list size: %i\", len(sensors))\n            if mac in moist_m_data:\n                try:\n                    if rounding:\n                        moiststate_median = round(\n                            sts.median(moist_m_data[mac]), decimals\n                        )\n                        moiststate_mean = round(\n                            sts.mean(moist_m_data[mac]), decimals\n                        )\n                    else:\n                        moiststate_median = sts.median(moist_m_data[mac])\n                        moiststate_mean = sts.mean(moist_m_data[mac])\n                    if use_median:\n                        setattr(sensors[1], \"_state\", moiststate_median)\n                    else:\n                        setattr(sensors[1], \"_state\", moiststate_mean)\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        textattr\n                    ] = len(moist_m_data[mac])\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        \"median\"\n                    ] = moiststate_median\n                    getattr(sensors[1], \"_device_state_attributes\")[\n                        \"mean\"\n                    ] = moiststate_mean\n                    sensors[1].async_schedule_update_ha_state()\n                except AttributeError:\n                    _LOGGER.info(\"Sensor %s not yet ready for update\", mac)\n                except ZeroDivisionError:\n                    _LOGGER.error(\"Division by zero while moisture averaging!\")\n                    continue\n                except IndexError as error:\n                    _LOGGER.error(\n                        \"Sensor %s (%s, moist.) update error:\", mac, stype[mac]\n                    )\n                    _LOGGER.error(\"%s. Index is 1!\", error)\n                    _LOGGER.error(\"sensors list size: %i\", len(sensors))\n            if mac in cond_m_data:\n                try:\n                    if rounding:\n                        condstate_median = round(\n                            sts.median(cond_m_data[mac]), decimals\n                        )\n                        condstate_mean = round(\n                            sts.mean(cond_m_data[mac]), decimals\n                        )\n                    else:\n                        condstate_median = sts.median(cond_m_data[mac])\n                        condstate_mean = sts.mean(cond_m_data[mac])\n                    if use_median:\n                        setattr(sensors[2], \"_state\", condstate_median)\n                    else:\n                        setattr(sensors[2], \"_state\", condstate_mean)\n                    getattr(sensors[2], \"_device_state_attributes\")[\n                        textattr\n                    ] = len(cond_m_data[mac])\n                    getattr(sensors[2], \"_device_state_attributes\")[\n                        \"median\"\n                    ] = condstate_median\n                    getattr(sensors[2], \"_device_state_attributes\")[\n                        \"mean\"\n                    ] = condstate_mean\n                    sensors[2].async_schedule_update_ha_state()\n                except AttributeError:\n                    _LOGGER.info(\"Sensor %s not yet ready for update\", mac)\n                except ZeroDivisionError:\n                    _LOGGER.error(\"Division by zero while humidity averaging!\")\n                    continue\n                except IndexError as error:\n                    _LOGGER.error(\n                        \"Sensor %s (%s, cond.) update error:\", mac, stype[mac]\n                    )\n                    _LOGGER.error(\"%s. Index is 2!\", error)\n                    _LOGGER.error(\"sensors list size: %i\", len(sensors))\n            if mac in illum_m_data:\n                try:\n                    if rounding:\n                        illumstate_median = round(\n                            sts.median(illum_m_data[mac]), decimals\n                        )\n                        illumstate_mean = round(\n                            sts.mean(illum_m_data[mac]), decimals\n                        )\n                    else:\n                        illumstate_median = sts.median(illum_m_data[mac])\n                        illumstate_mean = sts.mean(illum_m_data[mac])\n                    if use_median:\n                        setattr(sensors[3], \"_state\", illumstate_median)\n                    else:\n                        setattr(sensors[3], \"_state\", illumstate_mean)\n                    getattr(sensors[3], \"_device_state_attributes\")[\n                        textattr\n                    ] = len(illum_m_data[mac])\n                    getattr(sensors[3], \"_device_state_attributes\")[\n                        \"median\"\n                    ] = illumstate_median\n                    getattr(sensors[3], \"_device_state_attributes\")[\n                        \"mean\"\n                    ] = illumstate_mean\n                    sensors[3].async_schedule_update_ha_state()\n                except AttributeError:\n                    _LOGGER.info(\"Sensor %s not yet ready for update\", mac)\n                except ZeroDivisionError:\n                    _LOGGER.error(\n                        \"Division by zero while illuminance averaging!\"\n                    )\n                    continue\n                except IndexError as error:\n                    _LOGGER.error(\n                        \"Sensor %s (%s, illum.) update error:\", mac, stype[mac]\n                    )\n                    _LOGGER.error(\"%s. Index is 3!\", error)\n                    _LOGGER.error(\"sensors list size: %i\", len(sensors))\n        scanner.start(config)\n        return []\n\n    def update_ble(now):\n        \"\"\"Lookup Bluetooth LE devices and update status.\"\"\"\n        period = config[CONF_PERIOD]\n        _LOGGER.debug(\"update_ble called\")\n\n        try:\n            discover_ble_devices(config)\n        except RuntimeError as error:\n            _LOGGER.error(\"Error during Bluetooth LE scan: %s\", error)\n\n        track_point_in_utc_time(\n            hass, update_ble, dt_util.utcnow() + timedelta(seconds=period)\n        )\n\n    update_ble(dt_util.utcnow())\n\n\nclass TemperatureSensor(Entity):\n    \"\"\"Representation of a sensor.\"\"\"\n\n    def __init__(self, mac):\n        \"\"\"Initialize the sensor.\"\"\"\n        self._state = None\n        self._battery = None\n        self._unique_id = \"t_\" + mac\n        self._device_state_attributes = {}\n\n    @property\n    def name(self):\n        \"\"\"Return the name of the sensor.\"\"\"\n        return \"mi {}\".format(self._unique_id)\n\n    @property\n    def state(self):\n        \"\"\"Return the state of the sensor.\"\"\"\n        return self._state\n\n    @property\n    def unit_of_measurement(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return TEMP_CELSIUS\n\n    @property\n    def device_class(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return DEVICE_CLASS_TEMPERATURE\n\n    @property\n    def should_poll(self):\n        \"\"\"No polling needed.\"\"\"\n        return False\n\n    @property\n    def device_state_attributes(self):\n        \"\"\"Return the state attributes.\"\"\"\n        return self._device_state_attributes\n\n    @property\n    def unique_id(self) -> str:\n        \"\"\"Return a unique ID.\"\"\"\n        return self._unique_id\n\n    @property\n    def force_update(self):\n        \"\"\"Force update.\"\"\"\n        return True\n\n\nclass HumiditySensor(Entity):\n    \"\"\"Representation of a Sensor.\"\"\"\n\n    def __init__(self, mac):\n        \"\"\"Initialize the sensor.\"\"\"\n        self._state = None\n        self._battery = None\n        self._unique_id = \"h_\" + mac\n        self._device_state_attributes = {}\n\n    @property\n    def name(self):\n        \"\"\"Return the name of the sensor.\"\"\"\n        return \"mi {}\".format(self._unique_id)\n\n    @property\n    def state(self):\n        \"\"\"Return the state of the sensor.\"\"\"\n        return self._state\n\n    @property\n    def unit_of_measurement(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return \"%\"\n\n    @property\n    def device_class(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return DEVICE_CLASS_HUMIDITY\n\n    @property\n    def should_poll(self):\n        \"\"\"No polling needed.\"\"\"\n        return False\n\n    @property\n    def device_state_attributes(self):\n        \"\"\"Return the state attributes.\"\"\"\n        return self._device_state_attributes\n\n    @property\n    def unique_id(self) -> str:\n        \"\"\"Return a unique ID.\"\"\"\n        return self._unique_id\n\n    @property\n    def force_update(self):\n        \"\"\"Force update.\"\"\"\n        return True\n\n\nclass MoistureSensor(Entity):\n    \"\"\"Representation of a Sensor.\"\"\"\n\n    def __init__(self, mac):\n        \"\"\"Initialize the sensor.\"\"\"\n        self._state = None\n        self._battery = None\n        self._unique_id = \"m_\" + mac\n        self._device_state_attributes = {}\n\n    @property\n    def name(self):\n        \"\"\"Return the name of the sensor.\"\"\"\n        return \"mi {}\".format(self._unique_id)\n\n    @property\n    def state(self):\n        \"\"\"Return the state of the sensor.\"\"\"\n        return self._state\n\n    @property\n    def unit_of_measurement(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return \"%\"\n\n    @property\n    def device_class(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return DEVICE_CLASS_HUMIDITY\n\n    @property\n    def should_poll(self):\n        \"\"\"No polling needed.\"\"\"\n        return False\n\n    @property\n    def device_state_attributes(self):\n        \"\"\"Return the state attributes.\"\"\"\n        return self._device_state_attributes\n\n    @property\n    def unique_id(self) -> str:\n        \"\"\"Return a unique ID.\"\"\"\n        return self._unique_id\n\n    @property\n    def force_update(self):\n        \"\"\"Force update.\"\"\"\n        return True\n\n\nclass ConductivitySensor(Entity):\n    \"\"\"Representation of a Sensor.\"\"\"\n\n    def __init__(self, mac):\n        \"\"\"Initialize the sensor.\"\"\"\n        self._state = None\n        self._battery = None\n        self._unique_id = \"c_\" + mac\n        self._device_state_attributes = {}\n\n    @property\n    def name(self):\n        \"\"\"Return the name of the sensor.\"\"\"\n        return \"mi {}\".format(self._unique_id)\n\n    @property\n    def state(self):\n        \"\"\"Return the state of the sensor.\"\"\"\n        return self._state\n\n    @property\n    def unit_of_measurement(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return \"µS\/cm\"\n\n    @property\n    def icon(self):\n        \"\"\"Return the icon of the sensor.\"\"\"\n        return \"mdi:flash-circle\"\n\n    @property\n    def should_poll(self):\n        \"\"\"No polling needed.\"\"\"\n        return False\n\n    @property\n    def device_state_attributes(self):\n        \"\"\"Return the state attributes.\"\"\"\n        return self._device_state_attributes\n\n    @property\n    def unique_id(self) -> str:\n        \"\"\"Return a unique ID.\"\"\"\n        return self._unique_id\n\n    @property\n    def force_update(self):\n        \"\"\"Force update.\"\"\"\n        return True\n\n\nclass IlluminanceSensor(Entity):\n    \"\"\"Representation of a Sensor.\"\"\"\n\n    def __init__(self, mac):\n        \"\"\"Initialize the sensor.\"\"\"\n        self._state = None\n        self._battery = None\n        self._unique_id = \"l_\" + mac\n        self._device_state_attributes = {}\n\n    @property\n    def name(self):\n        \"\"\"Return the name of the sensor.\"\"\"\n        return \"mi {}\".format(self._unique_id)\n\n    @property\n    def state(self):\n        \"\"\"Return the state of the sensor.\"\"\"\n        return self._state\n\n    @property\n    def unit_of_measurement(self):\n        \"\"\"Return the unit of measurement.\"\"\"\n        return \"lx\"\n\n    @property\n    def icon(self):\n        \"\"\"Return the icon of the sensor.\"\"\"\n        return \"mdi:white-balance-sunny\"\n\n    @property\n    def should_poll(self):\n        \"\"\"No polling needed.\"\"\"\n        return False\n\n    @property\n    def device_state_attributes(self):\n        \"\"\"Return the state attributes.\"\"\"\n        return self._device_state_attributes\n\n    @property\n    def unique_id(self) -> str:\n        \"\"\"Return a unique ID.\"\"\"\n        return self._unique_id\n\n    @property\n    def force_update(self):\n        \"\"\"Force update.\"\"\"\n        return True\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_589","text":"<reponame>dankovacek\/dkhydrotech\nimport numpy as np\nimport scipy.stats as st\n\n\ndef calculate_Q(data):\n    mean = np.mean(data)\n    stdev = np.std(data)\n    \n    return np.power(10,mean + K * stdev)\n\ndef calculate_skew(data):\n    \"\"\"\n    Calculate weighted skew.\n    Reference: CFA2 Manual.\n    Based on (Wallis, Matalas, and Slack)\n    K_n is 'standard normal deviate' which I'm assuming means standard deviation\n    \"\"\"\n\n    g = abs(np.log10(st.skew(data)))\n\n    mu = np.mean(np.log10(data))\n    s = np.std(np.log10(data))\n    alpha = 4 \/ g**2\n    beta = 0.5 * s * g\n    epsilon = mu - 2 * s \/ g\n\n    return K, MSE_g\n\ndef calculate_K_weighted(data):\n    g = abs(np.log10(st.skew(data)))\n\n    if g == 0: \n        print('Skew cannot equal zero.')\n        return None\n\n    if g <= 0.9:\n        A = -0.33 + 0.08 * g\n    else:\n        A = -0.52 + 0.3 * g\n\n    if g <= 1.5:\n        B = 0.94 - 0.26 * g\n    else:\n        B = 0.55\n\n    # assuming 'standard normal deviate'\n    K_n = np.std(data)\n\n    K = (2 \/ g) * (((K_n - g\/6)*g\/6 + 1)**3 - 1)\n\n    # MSE_g = (A - B * (np.log10(len(data)\/10)))\n    return K"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_590","text":"<gh_stars>0\n\"\"\"\nScript used to run most of the results used in the paper.\nCompring different PCEs, uncertainty measures due to factor fixing.\n\"\"\"\n\nimport pandas as pd\nimport numpy as np\nfrom SALib.util import read_param_file\nimport pyapprox as pya\nfrom pyapprox.approximate import approximate\nfrom pyapprox.indexing import compute_hyperbolic_indices\nfrom pyapprox.multivariate_polynomials import PolynomialChaosExpansion\nfrom pyapprox.multivariate_polynomials import \\\n        define_poly_options_from_variable_transformation, AffineRandomVariableTransformation\nfrom pyapprox.variables import IndependentMultivariateRandomVariable\n\nfrom basic.boots_pya import fun\nfrom basic.utils import to_df, adjust_sampling\nfrom basic.group_fix import group_fix, uncond_cal\nfrom basic.read_data import file_settings, read_specify\n\n##==============================##============================##\n##==============================##============================##\n# apply_pya to produce the sensitivities of parameters for different PCEs\nfrom apply_pya import run_pya, pce_22\noutpath = file_settings()[0]\nseed=222\n# check whether the mean and variance from 'exact' is correct\ndef pmf_check(product_uniform = False):    \n    variable, _ = read_specify('parameter', 'reduced', product_uniform, num_vars=11)\n    samples, values = read_specify('model', 'reduced', product_uniform, num_vars=11)\n\n    approx_list_all = {}\n    mean_list = {}\n    variance_list = {}\n    n_strat, n_end, n_step = [156, 252, 13]\n    for i in range(n_strat, n_end+1, n_step):\n    # for i in n_list:\n        print(i)\n        if (n_end - i)  < n_step:\n            i = n_end\n        np.random.seed(seed)                                                    \n        approx_list_all[f'nsample_{i}'] = fun(variable, samples[:, :i], values[:i], product_uniform, nboot=1)\n    for key, pce in approx_list_all.items():\n        mean_list[key], variance_list[key] = pce.mean(), pce.variance()\n    pmf_stat = pd.concat([pd.DataFrame.from_dict(mean_list).T, \\\n        pd.DataFrame.from_dict(variance_list).T], axis=1)\n        \n    return pmf_stat\n\npmf_stat = pmf_check(product_uniform = 'exact')\npmf_stat.to_csv('mean_var.csv')\n\n\"\"\"\nScript used to run most of the results used in the paper.\nCompring different PCEs, uncertainty measures due to factor fixing.\n\"\"\"\n\nimport pandas as pd\nimport numpy as np\nimport pyapprox as pya\nfrom pyapprox.approximate import approximate\nfrom pyapprox.indexing import compute_hyperbolic_indices\nfrom pyapprox.multivariate_polynomials import PolynomialChaosExpansion\nfrom pyapprox.multivariate_polynomials import \\\n        define_poly_options_from_variable_transformation, AffineRandomVariableTransformation\nfrom pyapprox.variables import IndependentMultivariateRandomVariable\n\n##==============================##============================##\n##===============RUN test with a analytic function=============##\ndef fun_prod(x1, x2, x3, x4, x5, x6):\n    \"\"\"\n    x: array-like\n    \"\"\"\n    y = x1*x2 + x3 + x4 * x5 * x6\n    return y\n\nfrom scipy.stats import uniform, norm\nunivariate_variables = [uniform(0, 1)] * 6\n# the dist. of the first and last vars are not correct but will be overwriten using the product\nre_univariable = [uniform(0, 1.5), uniform(0, 1), uniform(0.2, 1)] \nre_variable = IndependentMultivariateRandomVariable(re_univariable)\nre_var_trans = AffineRandomVariableTransformation(re_variable)\n\nvariable = IndependentMultivariateRandomVariable(univariate_variables)\nvar_trans = AffineRandomVariableTransformation(variable)\n\n# generate samples and values for training and comparison\nsamples = pya.generate_independent_random_samples(variable, 10000)\nvalues = np.array([[fun_prod(*ii)] for ii in (samples.T)])\nindex_product = [[0, 1], [3, 4, 5]]\nsamples_adjust = np.zeros((3, samples.shape[1]))\nsamples_adjust[0, :] = np.prod(samples[index_product[0], :], axis=0)\nsamples_adjust[1, :] = samples[2, :]\nsamples_adjust[2, :] = np.prod(samples[index_product[1], :], axis=0)\n\n\n# the following use the product of uniforms to define basis\nfrom pyapprox.variables import get_distribution_info\nfrom pyapprox.univariate_quadrature import gauss_jacobi_pts_wts_1D\nfrom pyapprox.utilities import total_degree_space_dimension\n\ndef identity_fun(x):\n    return x\n\ndegree = 3\npoly = PolynomialChaosExpansion()\nbasis_opts = dict()\nidentity_map_indices = []\ncnt = 0\nfor ii in range(re_variable.nunique_vars):\n    rv = re_variable.unique_variables[ii]\n    name, scales, shapes = get_distribution_info(rv)\n    if ii not in [0, 2]:\n        opts = {'rv_type': name, 'shapes': shapes,\n                'var_nums': re_variable.unique_variable_indices[ii]}\n        basis_opts['basis%d' % ii] = opts\n        continue\n\n    #identity_map_indices += re_variable.unique_variable_indices[ii] # wrong\n    identity_map_indices += list(re_variable.unique_variable_indices[ii]) # right\n    \n    quad_rules = []    \n    inds = index_product[cnt]\n    nquad_samples_1d = 50\n\n    for jj in inds:\n        a, b = variable.all_variables()[jj].interval(1)\n        x, w = gauss_jacobi_pts_wts_1D(nquad_samples_1d, 0, 0)\n        x = (x+1)\/2 # map to [0, 1]\n        x = (b-a)*x+a # map to [a,b]\n        quad_rules.append((x, w))\n    funs = [identity_fun]*len(inds)\n    basis_opts['basis%d' % ii] = {'poly_type': 'product_indpnt_vars',\n                                    'var_nums': [ii], 'funs': funs,\n                                    'quad_rules': quad_rules}\n    cnt += 1\n        \npoly_opts = {'var_trans': re_var_trans}\npoly_opts['poly_types'] = basis_opts\n#var_trans.set_identity_maps(identity_map_indices) #wrong\nre_var_trans.set_identity_maps(identity_map_indices) #right\n\nindices = compute_hyperbolic_indices(re_variable.num_vars(), degree)\nnterms = total_degree_space_dimension(samples_adjust.shape[0], degree)\noptions = {'basis_type': 'fixed', 'variable': re_variable,\n            'poly_opts': poly_opts,\n            'options': {'linear_solver_options': dict(),\n                        'indices': indices, 'solver_type': 'lstsq'}}\n                        \napprox_res = approximate(samples_adjust[:, 0:(2 * nterms)], values[0:(2 * nterms)], 'polynomial_chaos', options).approx\ny_hat = approx_res(samples_adjust[:, 2 * nterms:])\nprint((y_hat - values[2 * nterms:]).mean())\nprint(f'Mean of samples: {values.mean()}')\nprint(f'Mean of pce: {approx_res.mean()}')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_591","text":"<reponame>njoel-ethz\/saliency-rl<filename>run_train.py\nimport sys\nimport os\nimport random\nimport numpy as np\nimport cv2\nimport time\nfrom datetime import timedelta\nimport torch\nfrom model import TASED_v2\nfrom loss import KLDLoss\nfrom dataset import DHF1KDataset, InfiniteDataLoader\nfrom itertools import islice\nimport matplotlib.pyplot as plt\nfrom PIL import Image\nfrom scipy.ndimage import gaussian_filter\nimport csv\n\ndef main():\n    ''' concise script for training '''\n    # optional two command-line arguments\n    path_indata = 'Atari_dataset'\n    path_output = 'output'\n    shuffle_data = True\n\n    if len(sys.argv) > 1:\n        path_indata = sys.argv[1]\n        if len(sys.argv) > 2:\n            path_output = sys.argv[2]\n\n    # we checked that using only 2 gpus is enough to produce similar results\n    num_gpu = 1 #2 on Server\n    pile = 5\n    batch_size = 1 #6 on Server\n    num_iters = 1000\n    len_temporal = 32\n    file_weight = 'TASED_updated.pt'\n    path_output = os.path.join(path_output, time.strftime(\"%m-%d_%H-%M-%S\"))\n    if not os.path.isdir(path_output):\n        os.makedirs(path_output)\n    if shuffle_data or not os.path.isfile('Atari_num_frame_train.csv'):\n        split_train_test_set()\n\n    model = TASED_v2()\n\n    # load the weight file and copy the parameters\n    if os.path.isfile(file_weight):\n        print ('loading weight file')\n        weight_dict = torch.load(file_weight)\n        model_dict = model.state_dict()\n        for name, param in weight_dict.items():\n            if 'module' in name:\n                name = '.'.join(name.split('.')[1:])\n            if 'base.' in name:\n                bn = int(name.split('.')[1])\n                sn_list = [0, 5, 8, 14]\n                sn = sn_list[0]\n                if bn >= sn_list[1] and bn < sn_list[2]:\n                    sn = sn_list[1]\n                elif bn >= sn_list[2] and bn < sn_list[3]:\n                    sn = sn_list[2]\n                elif bn >= sn_list[3]:\n                    sn = sn_list[3]\n                name = '.'.join(name.split('.')[2:])\n                name = 'base%d.%d.'%(sn_list.index(sn)+1, bn-sn)+name\n            if name in model_dict:\n                if param.size() == model_dict[name].size():\n                    model_dict[name].copy_(param)\n                else:\n                    print (' size? ' + name, param.size(), model_dict[name].size())\n            else:\n                print (' name? ' + name)\n\n        print (' loaded')\n    else:\n        print ('weight file?')\n\n    # parameter setting for fine-tuning\n    params = []\n    lr1 = 0.002 #0.0001 David\n    lr2 = 0.05 #0.01 David\n    for key, value in dict(model.named_parameters()).items():\n        if 'convtsp' in key:\n            params += [{'params':[value], 'key':key+'(new)'}]\n        else:\n            params += [{'params':[value], 'lr':lr1, 'key':key}] #0.001\n\n    optimizer = torch.optim.SGD(params, lr=lr2, momentum=0.9, weight_decay=2e-7) #lr = 0.1\n    lr_adaption = 0.1\n    criterion = KLDLoss()\n\n    model = model.cuda()\n    model = torch.nn.DataParallel(model, device_ids=range(num_gpu))\n    torch.backends.cudnn.benchmark = False\n    model.train()\n\n    train_loader = InfiniteDataLoader(DHF1KDataset(path_indata, len_temporal), batch_size=batch_size, shuffle=True, num_workers=0) #was 24, 0 means that data is loaded in the main process\n\n    loss_statistic = []\n    averaged_loss_statistic = []\n    index_statistic = []\n\n    i, step = 0, 0\n    loss_sum = 0\n    start_time = time.time()\n    for clip, annt, (file_name, picture_name) in islice(train_loader, num_iters*pile):\n        with torch.set_grad_enabled(True):\n            output = model(clip.cuda())\n            loss = criterion(output, annt.cuda())\n\n        loss_sum += loss.item()\n        loss.backward()\n        if (i+1) % pile == 0:\n            optimizer.step()\n            optimizer.zero_grad()\n            step += 1\n\n            # whole process takes less than 3 hours\n            print ('iteration: [%4d\/%4d], loss: %.4f, %s' % (step, num_iters, loss_sum\/pile, timedelta(seconds=int(time.time()-start_time))), flush=True)\n\n            loss_statistic.append(loss_sum\/pile)\n\n            visualize(output, path_indata, file_name[0], picture_name[0], step)\n            plt.ylabel('Loss')\n            plt.xlabel(path_indata + ', weights: ' + file_weight + ', lr\/optim = ' + str((lr1, lr2)))\n            plt.plot(loss_statistic, color='b')\n            if step==1:\n                plt.show(block=False)\n            else:\n                plt.draw()\n            plt.pause(0.00001)\n\n            if step%10==0:\n                averaged_loss_statistic.append(sum(loss_statistic[step-10:step])\/10)\n                index_statistic.append(step)\n\n            loss_sum = 0\n            # adjust learning rate\n            if step in [250, 750, 950]:\n                for opt in optimizer.param_groups:\n                    if 'new' in opt['key']:\n                        opt['lr'] *= lr_adaption   #0.1\n\n            if step % 25 == 0:\n                try:\n                    if not os.path.exists(os.path.join(path_output, 'weights')):\n                        os.makedirs(os.path.join(path_output, 'weights'))\n                except OSError:\n                    print('Error: Creating directory of data')\n                torch.save(model.state_dict(), os.path.join(path_output, 'weights', 'iter_%04d.pt' % step))\n\n        i += 1\n    torch.save(model.state_dict(), os.path.join(path_indata, 'produced_weight_file.pt'))\n\n    print('plotten')\n    #plt.plot(loss_statistic)\n    plt.savefig(os.path.join(path_indata, \"loss.png\"))\n\n    plt.plot(index_statistic, averaged_loss_statistic, color='r')\n    plt.ylabel('Averaged loss')\n    plt.xlabel(path_indata + ', weights: ' + file_weight + ', lr\/optim = ' + str((lr1, lr2)))\n    plt.savefig(os.path.join(path_indata, \"averaged_loss.png\"))\n\n    os.system('python run_saliency_metrics.py')\n\ndef split_train_test_set():\n    path_full = 'Atari_num_frame_FullData.csv'\n    path_train = 'Atari_num_frame_train.csv'\n    path_test = 'Atari_num_frame_testing.csv'\n\n    list_num_frame = [int(row[0]) for row in csv.reader(open(path_full, 'r'))]\n    total_len = len(list_num_frame)\n    half_len = int(np.floor(total_len\/2)) #for 50\/50 split\n    idx = range(1, total_len+1)\n    z = list(zip(list_num_frame, idx))\n\n    #comment this out for training on ~ highscore data\n    random.shuffle(z)\n\n    list_num_frame, idx = zip(*z)\n\n    test_list, test_idx = list_num_frame[:half_len], idx[:half_len]\n    train_list, train_idx = list_num_frame[half_len:], idx[half_len:]\n    train_strings = []\n    test_strings = []\n\n    for i in range(len(train_list)):\n        train_strings.append(str(train_list[i])+',%04d'%train_idx[i])\n    for i in range(len(test_list)):\n        test_strings.append(str(test_list[i])+',%04d'%test_idx[i])\n\n    with open(path_train, 'w') as file:\n        for line in train_strings:\n            file.write(line)\n            file.write('\\n')\n    with open(path_test, 'w') as file:\n        for line in test_strings:\n            file.write(line)\n            file.write('\\n')\n\n    return 0\n\ndef visualize(output, path_indata, file_name, picture_name, step):\n    # print(output.shape)  ---> torch.Size([1, 224, 384])\n    # print(output.cpu().data.numpy())\n    np_array = (output.cpu().data[0].numpy()*255.).astype(np.int)\/255.\n    # print(np_array.shape)    ---> (224, 384)\n    np_array = gaussian_filter(np_array, sigma=7)\n    np_array = (np_array\/np.max(np_array)*255.).astype(np.uint8)\n    mask = Image.fromarray(np_array)  # gives a 384x224 Image object\n    path_to_clip = os.path.join(path_indata, 'video', file_name, picture_name)\n    video_img = cv2.resize(cv2.imread(path_to_clip, cv2.IMREAD_COLOR), (384, 224))\n    video_img = Image.fromarray(video_img)\n    red_img = Image.new('RGB', (384, 224), (0, 0, 255))\n    video_img.paste(red_img, mask=mask)\n\n    open_cv_image = cv2.resize(np.array(video_img), (160, 210))\n\n    output_path = os.path.join(path_indata, 'training_visualized')\n    try:\n        if not os.path.exists(output_path):\n            os.makedirs(output_path)\n    except OSError:\n        print('Error: Creating directory of data')\n    cv2.imwrite(os.path.join(output_path, '%06d.png' % (step)), open_cv_image)\n    \"\"\"cv2.imshow('step', open_cv_image)\n    cv2.waitKey(3000)\n    cv2.destroyAllWindows()\"\"\"\n    return 0\n\nif __name__ == '__main__':\n    main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_577","text":"import sys\nsys.path.insert(0, \"\/home\/hardik\/dl_exp\/nglod\/sdf-net\/lib\/submodules\/libigl\/python\/\") \n\nimport pyigl as igl\nfrom decimal import *\nimport iglhelpers \n# import miniball\nimport math\n\nimport numpy as np \n\nfrom matplotlib import pyplot\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfrom scipy.stats import gaussian_kde\n\nimport matplotlib.cm as cm\n\n#constants used for sampling box AND miniball normalization\nBOUNDING_SPHERE_RADIUS = 0.9\nSAMPLE_SPHERE_RADIUS = 1.0\n\n\nclass CubeMarcher():\n    def __init__(self):\n        self._rV = igl.eigen.MatrixXd()\n        self._rF = igl.eigen.MatrixXi()\n        self.hasMarched = False\n\n    def march(self, pts, sdf):\n        res = round(pts.shape[0]**(1\/3))\n        v = iglhelpers.p2e(pts)\n        s = iglhelpers.p2e(sdf)\n        igl.copyleft.marching_cubes(s, v, res, res, res, self._rV, self._rF)\n        self.hasMarched = True\n\n    def createGrid(self, res):\n        K = np.linspace(\n            -SAMPLE_SPHERE_RADIUS,\n            SAMPLE_SPHERE_RADIUS,\n            res\n        )\n        grid = [[x,y,z] for x in K for y in K for z in K]\n        return np.array(grid)\n\n    def getMesh(self, viewer = None):\n        if self.hasMarched:\n            V = self._rV\n            F = self._rF\n        else:\n            raise(\"Mesh has not been marched!\")\n            \n        if viewer is None:\n            return Mesh(V=V.copy(), F=F.copy(), doNormalize=False)\n  \n        return Mesh(V=V.copy(), F=F.copy(), doNormalize=False, viewer=viewer) \n\n# class PointSampler(): \n#     def __init__(self, mesh, ratio = 0.0, std=0.0, verticeSampling=False, importanceSampling=False):\n#         self._V = iglhelpers.e2p(mesh.V())\n#         self._F = iglhelpers.e2p(mesh.F())\n#         self._sampleVertices = verticeSampling\n\n#         if ratio < 0 or ratio > 1:\n#             raise(ValueError(\"Ratio must be [0,1]\"))\n        \n#         self._ratio = ratio\n        \n#         if std < 0 or std > 1:\n#             raise(ValueError(\"Normal deviation must be [0,1]\"))\n\n#         self._std = std\n\n#         self._calculateFaceBins()\n    \n#     def _calculateFaceBins(self):\n#         \"\"\"Calculates and saves face area bins for sampling against\"\"\"\n#         vc = np.cross(\n#             self._V[self._F[:, 0], :] - self._V[self._F[:, 2], :],\n#             self._V[self._F[:, 1], :] - self._V[self._F[:, 2], :])\n\n#         A = np.sqrt(np.sum(vc ** 2, 1))\n#         FA = A \/ np.sum(A)\n#         self._faceBins = np.concatenate(([0],np.cumsum(FA))) \n\n#     def _surfaceSamples(self,n):\n#         \"\"\"Returns n points uniformly sampled from surface of mesh\"\"\"\n#         R = np.random.rand(n)   #generate number between [0,1]\n#         sampleFaceIdxs = np.array(np.digitize(R,self._faceBins)) -1\n\n#         #barycentric coordinates for each face for each sample :)\n#         #random point within face for each sample\n#         r = np.random.rand(n, 2)\n#         A = self._V[self._F[sampleFaceIdxs, 0], :]\n#         B = self._V[self._F[sampleFaceIdxs, 1], :]\n#         C = self._V[self._F[sampleFaceIdxs, 2], :]\n#         P = (1 - np.sqrt(r[:,0:1])) * A \\\n#                 + np.sqrt(r[:,0:1]) * (1 - r[:,1:]) * B \\\n#                 + np.sqrt(r[:,0:1]) * r[:,1:] * C\n\n#         return P\n\n#     def _verticeSamples(self, n):\n#         \"\"\"Returns n random vertices of mesh\"\"\"\n#         verts = np.random.choice(len(self._V), n)\n#         return self._V[verts]\n    \n#     def _normalDist(self, V):\n#         \"\"\"Returns normal distribution about each point V\"\"\"\n#         if self._std > 0.0:\n#             return np.random.normal(loc = V,scale = self._std)\n\n#         return V\n        \n#     def _randomSamples(self, n):\n#         \"\"\"Returns n random points in unit sphere\"\"\"\n#         # we want to return points in unit sphere, could do using spherical coords\n#         #   but rejection method is easier and arguably faster :)\n#         points = np.array([])\n#         while points.shape[0] < n:\n#             remainingPoints = n - points.shape[0]\n#             p = (np.random.rand(remainingPoints,3) - 0.5)*2\n#             #p = p[np.linalg.norm(p, axis=1) <= SAMPLE_SPHERE_RADIUS]\n\n#             if points.size == 0:\n#                 points = p \n#             else:\n#                 points = np.concatenate((points, p))\n#         return points\n\n#     def sample(self,n):\n#         \"\"\"Returns n points according to point sampler settings\"\"\"\n\n#         nRandom = round(Decimal(n)*Decimal(self._ratio))\n#         nSurface = n - nRandom\n\n#         xRandom = self._randomSamples(nRandom)\n\n#         if nSurface > 0:\n#             if self._sampleVertices:\n#                 # for comparison later :)\n#                 xSurface = self._verticeSamples(nSurface)\n#             else:\n#                 xSurface = self._surfaceSamples(nSurface)\n\n#             xSurface = self._normalDist(xSurface)\n#             if nRandom > 0:\n#                 x = np.concatenate((xSurface,xRandom))\n#             else:\n#                 x = xSurface\n#         else:\n#             x = xRandom\n\n#         np.random.shuffle(x)    #remove bias on order\n\n#         return x\n\n# class ImportanceSampler():\n#     # M, initital uniform set size, N subset size.\n#     def __init__(self, mesh, M, W):\n#         self.M = M # uniform sample set size\n#         self.W = W # sample weight...\n    \n#         if (not mesh is None):\n#             #if mesh given, we can create our own uniform sampler\n#             self.uniformSampler = PointSampler(mesh, ratio=1.0) # uniform sampling\n#             self.sdf = SDF(mesh)\n#         else:\n#             # otherwise we assume uniform samples (and the sdf val) will be passed in.\n#             self.uniformSampler = None \n#             self.sdf = None\n\n#     def _subsample(self, s, N):\n\n#         # weighted by exp distance to surface\n#         w = np.exp(-self.W*np.abs(s))\n#         # probabilities to choose each\n#         pU = w \/ np.sum(w)\n#         # exclusive sum\n#         C = np.concatenate(([0],np.cumsum(pU)))\n#         C = C[0:-1]\n\n#         # choose N random buckets\n#         R = np.random.rand(N)\n\n#         # histc\n#         I = np.array(np.digitize(R,C)) - 1\n\n#         return I\n\n\n#     ''' importance sample a given mesh, M uniform samples, N subset based on importance'''\n#     def sample(self, N):\n#         if (self.uniformSampler is None):\n#             raise(\"No mesh supplied, cannot run importance sampling...\")\n\n#         #uniform samples\n#         U = self.uniformSampler.sample(self.M)\n#         s = self.sdf.query(U)\n#         I = self._subsample(s, N)\n\n#         R = np.random.choice(len(U), int(N*0.1))\n#         S = U[I,:]#np.concatenate((U[I,:],U[R, :]), axis=0)\n#         return S\n\n#     ''' sampling against a supplied U set, where s is sdf at each U'''\n#     def sampleU(self, N, U, s):\n#         I = self._subsample(s, N)\n#         q = U[I,:]\n#         d = s[I]\n#         return U[I,:], s[I] \n\n# class SDF():\n#     _V = igl.eigen.MatrixXd()\n#     _F = igl.eigen.MatrixXi()\n\n#     def __init__(self, mesh, signType = 'fast_winding_number', doPrecompute=True):\n#         self._V = mesh.V()\n#         self._F = mesh.F()\n#         self._precomputed = False\n\n#         if signType == 'fast_winding_number':\n#             self._signType = igl.SIGNED_DISTANCE_TYPE_FAST_WINDING_NUMBER\n#             if doPrecompute:\n#                 self._tree = igl.AABB()\n#                 self._fwn_bvh = igl.FastWindingNumberBVH()\n#                 print(\"[INFO] Precomuting bvh trees...\")\n#                 self._tree.init(self._V,self._F)\n#                 igl.fast_winding_number(self._V,self._F,2,self._fwn_bvh)\n#                 print(\"[INFO] Done precomputing\")\n#                 self._precomputed = True\n#         elif signType == 'pseudonormal':\n#             self._signType = igl.SIGNED_DISTANCE_TYPE_PSEUDONORMAL\n#         else:\n#             raise(\"Invalid signing type given\")\n\n#     def query(self, queries):\n#         \"\"\"Returns numpy array of SDF values for each point in queries\"\"\"\n#         queryV = iglhelpers.p2e(queries)\n\n#         S = igl.eigen.MatrixXd()\n#         B = igl.eigen.MatrixXd()\n#         I = igl.eigen.MatrixXi()\n#         C = igl.eigen.MatrixXd()\n#         N = igl.eigen.MatrixXd()\n\n#         if self._precomputed and self._signType == igl.SIGNED_DISTANCE_TYPE_FAST_WINDING_NUMBER:\n#             # generate samples from precomputed bvh's\n#             print(\"[INFO] Generating SDFs\")\n#             igl.signed_distance_fast_winding_number(\n#                 queryV, \n#                 self._V,\n#                 self._F,\n#                 self._tree,\n#                 self._fwn_bvh,\n#                 S\n#             )\n#             print(\"[INFO] SDFs done\")\n#         else:\n#             igl.signed_distance(\n#                 queryV, \n#                 self._V, \n#                 self._F, \n#                 self._signType,\n#                 S, \n#                 I, \n#                 C,\n#                 N\n#             )\n\n#         return iglhelpers.e2p(S)\n\nclass Mesh():\n    _V = igl.eigen.MatrixXd()\n    _F = igl.eigen.MatrixXi()\n    _normalized = False\n\n    def __init__(\n        self, \n        meshPath=None, \n        V=None, \n        F=None,\n        viewer = None, \n        doNormalize = True):\n\n        if meshPath == None:\n            if V == None or F == None:\n                raise(\"Mesh path or Mesh data must be given\")\n            else:\n                self._V = V\n                self._F = F\n                # self._normalizeMesh()                \n        else:\n            self._loadMesh(meshPath,doNormalize)\n\n        self._viewer = viewer\n\n    def _loadMesh(self, fp, doNormalize):\n        #load mesh\n        igl.read_triangle_mesh(fp, self._V, self._F)\n\n        if doNormalize:\n            self._normalizeMesh()\n        \n    def V(self):\n        return self._V.copy()\n\n    def F(self):\n        return self._F.copy()\n\n    # def _normalizeMesh(self):\n    #     mb = miniball.Miniball(iglhelpers.e2p(self._V))\n    #     scale = BOUNDING_SPHERE_RADIUS \/ math.sqrt(mb.squared_radius())\n \n    #     T = igl.eigen.Affine3d()\n    #     T.setIdentity()\n    #     T.translate(\n    #         igl.eigen.MatrixXd(\n    #             [\n    #                 -mb.center()[0] * scale, \n    #                 -mb.center()[1] * scale, \n    #                 -mb.center()[2] * scale \n    #             ]\n    #         )\n    #     )\n    #     print(\"[INFO] scaled down by\", scale)\n    #     Vscale = T.matrix().block(0,0,3,3).transpose()\n    #     Vtrans = igl.eigen.MatrixXd(self._V.rows(), self._V.cols())\n    #     Vtrans.rowwiseSet(T.matrix().block(0,3,3,1).transpose())\n\n    #     self._V = (self._V*Vscale)*scale + Vtrans\n\n    def show(self, doLaunch = False):\n        if self._viewer == None:\n            self._viewer = igl.glfw.Viewer()\n\n        self._viewer.data(0).set_mesh(self._V,self._F)\n\n        if doLaunch:\n            self._viewer.launch()\n\n    def save(self, fp):\n        igl.writeOBJ(fp,self._V,self._F)\n        \n\n# def normSDF(S, minVal=None,maxVal=None):\n#     if minVal is None:\n#         minVal = np.min(S)\n#         maxVal = np.max(S)\n    \n#     # we don't shift. Keep 0 at 0.\n#     S = np.array([item for sublist in S for item in sublist])\n\n#     #S[S<0] = -(S[S<0] \/ minVal)\n#     #S[S>0] = (S[S>0] \/ maxVal)\n#     #S = (S + 1)\/2\n\n#     S[S<0] = -0.8\n#     S[S>0] = 0.8\n    \n#     return S\n\n# def createAx(idx):\n#     subplot = pyplot.subplot(idx, projection='3d')\n#     subplot.set_xlim((-1,1))\n#     subplot.set_ylim((-1,1))\n#     subplot.set_zlim((-1,1))\n#     subplot.view_init(elev=10, azim=100)\n#     subplot.axis('off')\n#     subplot.dist = 8\n#     return subplot\n\n# def createAx2d(idx):\n#     subplot = pyplot.subplot(idx)\n#     subplot.set_xlim((-1,1))\n#     subplot.set_ylim((-1,1))\n#     subplot.axis('off')\n#     return subplot\n\n# def plotCube(ax):\n#     # draw cube\n#     r = [-1, 1]\n\n#     from itertools import product, combinations\n#     for s, e in combinations(np.array(list(product(r, r, r))), 2):\n#         if np.sum(np.abs(s-e)) == r[1]-r[0]:\n#             ax.plot3D(*zip(s, e), color=\"black\")\n\n# def density(U):\n#     c = gaussian_kde(np.transpose(U))(np.transpose(U))\n#     return c\n\n# def plotMesh(ax, mesh, N=10000):\n#     surfaceSampler = PointSampler(mesh, ratio=0.0, std=0.0)\n#     surfaceSamples = surfaceSampler.sample(N)\n#     x,y,z = np.hsplit(surfaceSamples,3)\n#     ax.scatter(x,z,y, c='black', marker='.')\n\n# def plotSamples(ax, U, c, vmin = -1, is2d = False):\n#     x,y,z = np.hsplit(U,3)\n#     ax.scatter(x,y,z,c=c, marker='.',cmap='coolwarm', norm=None, vmin=vmin, vmax=1)\n\n# def importanceSamplingComparisonPlot(mesh,sdf):\n#     fig = pyplot.figure(figsize=(30,10))\n#     axUniform = createAx(131)\n#     axSurface = createAx(132)\n#     axImportance = createAx(133)\n\n#     plotCube(axUniform)\n#     plotCube(axSurface)\n#     plotCube(axImportance)\n\n    \n#     #plotMesh(axUniform,mesh)\n#     #plotMesh(axImportance,mesh)\n#     #plotMesh(axSurface,mesh)\n    \n#     # plot uniform sampled \n#     uniformSampler = PointSampler(mesh, ratio = 1.0)    \n#     U = uniformSampler.sample(10000)\n#     SU = sdf.query(U)\n#     c = normSDF(SU)\n#     plotSamples(axUniform, U,c)\n\n#     # plot surface + noise sampling\n#     sampler = PointSampler(mesh, ratio = 0.1, std = 0.01, verticeSampling=False)\n#     p = sampler.sample(10000)\n#     S = sdf.query(p)\n#     c = normSDF(S, np.min(SU), np.max(SU))\n#     plotSamples(axSurface, p,c)\n\n#     # plot importance\n#     importanceSampler = ImportanceSampler(mesh, 100000, 20)\n#     p = importanceSampler.sample(10000)\n#     S = sdf.query(p)\n#     c = normSDF(S, np.min(SU), np.max(SU))\n\n#     plotSamples(axImportance, p,c)\n\n#     fig.patch.set_visible(False)\n\n#     pyplot.axis('off')\n#     pyplot.show()\n\n# def beforeAndAfterPlot(mesh,sdf):\n#     fig = pyplot.figure(figsize=(10,10))\n#     fig.patch.set_visible(False)\n#     axBefore = createAx(111)\n    \n#     pyplot.axis('off')\n#     #plotCube(axBefore)\n#     #plotCube(axAfter)\n\n#     # plot importance\n#     importanceSampler = ImportanceSampler(mesh, 100000, 20)\n#     p = importanceSampler.sample(10000)\n#     plotSamples(axBefore, p,'grey')\n#     pyplot.savefig('before.png', dpi=300, transparent=True)\n    \n#     fig = pyplot.figure(figsize=(10,10))\n#     fig.patch.set_visible(False)\n#     axAfter = createAx(111)\n#     S = sdf.query(p)\n#     c = normSDF(S)\n#     plotSamples(axAfter, p,c)\n#     pyplot.savefig('after.png', dpi=300, transparent=True)\n\n\n# def importanceMotivationPlot(mesh,sdf):\n\n#     fig = pyplot.figure(figsize=(10,10))\n#     axSurface = createAx(111)\n\n#     #surface sampling\n#     sampler = PointSampler(mesh, ratio = 0.0, std = 0.01, verticeSampling=False)\n#     p = sampler.sample(10000)\n#     c = density(p)\n#     maxDensity = np.max(c)\n#     c = c\/maxDensity\n#     plotSamples(axSurface, p,c, vmin=0)\n#     #pyplot.show()\n#     pyplot.savefig('surface.png', dpi=300, transparent=True)\n\n\n#     #vertex sampling\n#     fig = pyplot.figure(figsize=(10,10))\n#     axVertex = createAx(111)\n#     sampler = PointSampler(mesh, ratio = 0.0, std = 0.1, verticeSampling=True)\n#     p = sampler.sample(10000)\n#     c = density(p)\n#     maxDensity = np.max(c)\n#     c = c\/maxDensity\n#     plotSamples(axVertex, p,c, vmin=0)\n#     #pyplot.show()\n#     pyplot.savefig('vertex.png', dpi=300, transparent=True)\n\n#     fig = pyplot.figure(figsize=(10,10))\n#     axImportance = createAx(111)\n    \n#     # importance sampling\n#     importanceSampler = ImportanceSampler(mesh, 1000000, 50)\n#     p = importanceSampler.sample(10000)\n#     c = density(p)\n#     maxDensity = np.max(c)\n#     c = c\/maxDensity\n#     plotSamples(axImportance, p, c, vmin = 0)\n#     #pyplot.show()\n#     pyplot.savefig('importance.png', dpi=300, transparent=True)\n\n\n# if __name__ == '__main__':\n#     def main():\n#         import argparse\n#         import h5py\n#         import os\n#         parser = argparse.ArgumentParser(description='Train model to predict sdf of a given mesh, by default visualizes reconstructed mesh to you, and plots loss.')\n#         parser.add_argument('input_mesh', help='path to input mesh')\n\n#         args = parser.parse_args()\n\n#         mesh = Mesh(meshPath = args.input_mesh)\n\n#         # first test mesh is loaded correctly\n#         mesh.show()\n\n#         # test sdf sampling mesh\n#         sdf = SDF(mesh)\n\n#         cubeMarcher = CubeMarcher()\n#         grid = cubeMarcher.createGrid(64)\n\n#         S = sdf.query(grid)\n\n#         cubeMarcher.march(grid, S)\n#         marchedMesh = cubeMarcher.getMesh()\n\n#         marchedMesh.show()\n\n#         #importanceSamplingComparisonPlot(mesh, sdf)\n#         #beforeAndAfterPlot(mesh,sdf)\n#         #importanceMotivationPlot(mesh,sdf)\n    \n#     main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_582","text":"r\"\"\"\r\nArray expressions are expressions representing N-dimensional arrays, without\r\nevaluating them. These expressions represent in a certain way abstract syntax\r\ntrees of operations on N-dimensional arrays.\r\n\r\nEvery N-dimensional array operator has a corresponding array expression object.\r\n\r\nTable of correspondences:\r\n\r\n=============================== =============================\r\n         Array operator           Array expression operator\r\n=============================== =============================\r\n        tensorproduct                 ArrayTensorProduct\r\n        tensorcontraction             ArrayContraction\r\n        tensordiagonal                ArrayDiagonal\r\n        permutedims                   PermuteDims\r\n=============================== =============================\r\n\r\nExamples\r\n========\r\n\r\n``ArraySymbol`` objects are the N-dimensional equivalent of ``MatrixSymbol``\r\nobjects in the matrix module:\r\n\r\n>>> from sympy.tensor.array.expressions import ArraySymbol\r\n>>> from sympy.abc import i, j, k\r\n>>> A = ArraySymbol(\"A\", (3, 2, 4))\r\n>>> A.shape\r\n(3, 2, 4)\r\n>>> A[i, j, k]\r\nA[i, j, k]\r\n>>> A.as_explicit()\r\n[[[A[0, 0, 0], A[0, 0, 1], A[0, 0, 2], A[0, 0, 3]],\r\n  [A[0, 1, 0], A[0, 1, 1], A[0, 1, 2], A[0, 1, 3]]],\r\n [[A[1, 0, 0], A[1, 0, 1], A[1, 0, 2], A[1, 0, 3]],\r\n  [A[1, 1, 0], A[1, 1, 1], A[1, 1, 2], A[1, 1, 3]]],\r\n [[A[2, 0, 0], A[2, 0, 1], A[2, 0, 2], A[2, 0, 3]],\r\n  [A[2, 1, 0], A[2, 1, 1], A[2, 1, 2], A[2, 1, 3]]]]\r\n\r\nComponent-explicit arrays can be added inside array expressions:\r\n\r\n>>> from sympy import Array\r\n>>> from sympy import tensorproduct\r\n>>> from sympy.tensor.array.expressions import ArrayTensorProduct\r\n>>> a = Array([1, 2, 3])\r\n>>> b = Array([i, j, k])\r\n>>> expr = ArrayTensorProduct(a, b, b)\r\n>>> expr\r\nArrayTensorProduct([1, 2, 3], [i, j, k], [i, j, k])\r\n>>> expr.as_explicit() == tensorproduct(a, b, b)\r\nTrue\r\n\r\nConstructing array expressions from index-explicit forms\r\n--------------------------------------------------------\r\n\r\nArray expressions are index-implicit. This means they do not use any indices to\r\nrepresent array operations. The function ``convert_indexed_to_array( ... )``\r\nmay be used to convert index-explicit expressions to array expressions.\r\nIt takes as input two parameters: the index-explicit expression and the order\r\nof the indices:\r\n\r\n>>> from sympy.tensor.array.expressions import convert_indexed_to_array\r\n>>> from sympy import Sum\r\n>>> A = ArraySymbol(\"A\", (3, 3))\r\n>>> B = ArraySymbol(\"B\", (3, 3))\r\n>>> convert_indexed_to_array(A[i, j], [i, j])\r\nA\r\n>>> convert_indexed_to_array(A[i, j], [j, i])\r\nPermuteDims(A, (0 1))\r\n>>> convert_indexed_to_array(A[i, j] + B[j, i], [i, j])\r\nArrayAdd(A, PermuteDims(B, (0 1)))\r\n>>> convert_indexed_to_array(Sum(A[i, j]*B[j, k], (j, 0, 2)), [i, k])\r\nArrayContraction(ArrayTensorProduct(A, B), (1, 2))\r\n\r\nThe diagonal of a matrix in the array expression form:\r\n\r\n>>> convert_indexed_to_array(A[i, i], [i])\r\nArrayDiagonal(A, (0, 1))\r\n\r\nThe trace of a matrix in the array expression form:\r\n\r\n>>> convert_indexed_to_array(Sum(A[i, i], (i, 0, 2)), [i])\r\nArrayContraction(A, (0, 1))\r\n\r\nCompatibility with matrices\r\n---------------------------\r\n\r\nArray expressions can be mixed with objects from the matrix module:\r\n\r\n>>> from sympy import MatrixSymbol\r\n>>> from sympy.tensor.array.expressions import ArrayContraction\r\n>>> M = MatrixSymbol(\"M\", 3, 3)\r\n>>> N = MatrixSymbol(\"N\", 3, 3)\r\n\r\nExpress the matrix product in the array expression form:\r\n\r\n>>> from sympy.tensor.array.expressions import convert_matrix_to_array\r\n>>> expr = convert_matrix_to_array(M*N)\r\n>>> expr\r\nArrayContraction(ArrayTensorProduct(M, N), (1, 2))\r\n\r\nThe expression can be converted back to matrix form:\r\n\r\n>>> from sympy.tensor.array.expressions import convert_array_to_matrix\r\n>>> convert_array_to_matrix(expr)\r\nM*N\r\n\r\nAdd a second contraction on the remaining axes in order to get the trace of `M \\cdot N`:\r\n\r\n>>> expr_tr = ArrayContraction(expr, (0, 1))\r\n>>> expr_tr\r\nArrayContraction(ArrayContraction(ArrayTensorProduct(M, N), (1, 2)), (0, 1))\r\n\r\nFlatten the expression by calling ``.doit()`` and remove the nested array contraction operations:\r\n\r\n>>> expr_tr.doit()\r\nArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))\r\n\r\nGet the explicit form of the array expression:\r\n\r\n>>> expr.as_explicit()\r\n[[M[0, 0]*N[0, 0] + M[0, 1]*N[1, 0] + M[0, 2]*N[2, 0], M[0, 0]*N[0, 1] + M[0, 1]*N[1, 1] + M[0, 2]*N[2, 1], M[0, 0]*N[0, 2] + M[0, 1]*N[1, 2] + M[0, 2]*N[2, 2]],\r\n [M[1, 0]*N[0, 0] + M[1, 1]*N[1, 0] + M[1, 2]*N[2, 0], M[1, 0]*N[0, 1] + M[1, 1]*N[1, 1] + M[1, 2]*N[2, 1], M[1, 0]*N[0, 2] + M[1, 1]*N[1, 2] + M[1, 2]*N[2, 2]],\r\n [M[2, 0]*N[0, 0] + M[2, 1]*N[1, 0] + M[2, 2]*N[2, 0], M[2, 0]*N[0, 1] + M[2, 1]*N[1, 1] + M[2, 2]*N[2, 1], M[2, 0]*N[0, 2] + M[2, 1]*N[1, 2] + M[2, 2]*N[2, 2]]]\r\n\r\nExpress the trace of a matrix:\r\n\r\n>>> from sympy import Trace\r\n>>> convert_matrix_to_array(Trace(M))\r\nArrayContraction(M, (0, 1))\r\n>>> convert_matrix_to_array(Trace(M*N))\r\nArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))\r\n\r\nExpress the transposition of a matrix (will be expressed as a permutation of the axes:\r\n\r\n>>> convert_matrix_to_array(M.T)\r\nPermuteDims(M, (0 1))\r\n\r\nCompute the derivative array expressions:\r\n\r\n>>> from sympy.tensor.array.expressions import array_derive\r\n>>> d = array_derive(M, M)\r\n>>> d\r\nPermuteDims(ArrayTensorProduct(I, I), (3)(1 2))\r\n\r\nVerify that the derivative corresponds to the form computed with explicit matrices:\r\n\r\n>>> d.as_explicit()\r\n[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]\r\n>>> Me = M.as_explicit()\r\n>>> Me.diff(Me)\r\n[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]\r\n\r\n\"\"\"\r\n\r\n__all__ = [\r\n    \"ArraySymbol\", \"ArrayElement\", \"ZeroArray\", \"OneArray\",\r\n    \"ArrayTensorProduct\",\r\n    \"ArrayContraction\",\r\n    \"ArrayDiagonal\",\r\n    \"PermuteDims\",\r\n    \"ArrayAdd\",\r\n    \"ArrayElementwiseApplyFunc\",\r\n    \"Reshape\",\r\n    \"convert_array_to_matrix\",\r\n    \"convert_matrix_to_array\",\r\n    \"convert_array_to_indexed\",\r\n    \"convert_indexed_to_array\",\r\n    \"array_derive\",\r\n]\r\n\r\nfrom sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayAdd, PermuteDims, ArrayDiagonal, \\\r\n    ArrayContraction, Reshape, ArraySymbol, ArrayElement, ZeroArray, OneArray, ArrayElementwiseApplyFunc\r\nfrom sympy.tensor.array.expressions.arrayexpr_derivatives import array_derive\r\nfrom sympy.tensor.array.expressions.conv_array_to_indexed import convert_array_to_indexed\r\nfrom sympy.tensor.array.expressions.conv_array_to_matrix import convert_array_to_matrix\r\nfrom sympy.tensor.array.expressions.conv_indexed_to_array import convert_indexed_to_array\r\nfrom sympy.tensor.array.expressions.conv_matrix_to_array import convert_matrix_to_array\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_640","text":"#Auto mesh generator \r\n#Importing libraries\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport pandas as pd\r\nimport pygmsh as pg\r\nfrom PIL import Image\r\nfrom scipy import ndimage as ndi\r\n\r\nfrom skimage import io, filters,feature\r\nfrom skimage.measure import find_contours, approximate_polygon, \\\r\n    subdivide_polygon\r\nimport meshio\r\nimport cv2 as cv\r\n#import os\r\n#os.environ.pop(\"QT_QPA_PLATFORM_PLUGIN_PATH\")\r\nimport pymesh\r\nimport matplotlib.colors as mcolors\r\nfrom contour_selc import contour_selc, contour_tree\r\ndef Mesh(contours, cont_idx,mesh_holes, dim, indices, lcar, remove_low_dim_cells = True):\r\n\r\n\t\"\"\"\r\n\tCreates a mesh based on the contours given as input along with containment hierarchy. \r\n\r\n\tParameters\r\n\t----------\r\n\r\n\tcontours \t: list,\r\n\t\t\t\tlist containing a list of contour points\r\n\tcont_idx \t: list,\r\n\t\t\t\tlist of indices of contours to be meshed\r\n\tmesh_holes\t: list,\r\n\t\t\t\tlist containing the information regarding the child contours of each contour\r\n\tdim \t\t:list (int,int),\r\n\t\t\t\tdimension of the image file\r\n\tindices\t\t: list of arrays,\r\n\t\t\t\ta list containing the subset of indices of the contours to be used in the mesh\r\n\tlcar \t\t: list,\r\n\t\t\t\tthe meshing distance parameter\r\n\tremove_low_dim_cells : Bool, default True\r\n\t\t\t\tRemoves the lower dimensional objects from the mesh after meshing\r\n\r\n\tReturns\r\n\t-------\r\n\tout: \r\n\t\tmesh: meshio instance\r\n\r\n\r\n\t\"\"\"\r\n\r\n\r\n\twith pg.geo.Geometry() as geom:\r\n\t\t\r\n\t\tm,n = dim #dimensions of the CT scan image\r\n\r\n\t\tb1 = geom.add_point([0,0],40) #first boundary point element in the mesh\r\n\t\tb2 = geom.add_point([0,m],40) #second boundary point element in the mesh\r\n\t\tb3 = geom.add_point([n,0],40) #third boundary point element in the mesh\r\n\t\tb4 = geom.add_point([n,m],40) #fourth boundary point element in the mesh\r\n\t\tline1 = geom.add_line(b1,b2) #we create a line element in the mesh between points b1 and b2\r\n\t\tline2 = geom.add_line(b2,b4) #we create a line element in the mesh between points b2 and b4\r\n\t\tline3 = geom.add_line(b4,b3) #we create a line element in the mesh between points b4 and b3\r\n\t\tline4 = geom.add_line(b3,b1) #we create a line element in the mesh between points b3 and b1\r\n\r\n\t\tlines = geom.add_curve_loop([line1,line2,line3,line4]) #Creating a loop in the mesh using the four lines created above\r\n\r\n\t\tloops = [] #empty list to which we append the loop elements created using the contours\r\n\t\tfor k in range(len(cont_idx)):\r\n\t\t\tl = []\t#empty list to append the point elements created using the points in a particular contour\r\n\t\t\tindex = indices[k] #we do not use all the points of a contour but only a portion of it which we obtain using specific indices\r\n\t\t\tcont = contours[cont_idx[k]][:,0,:]\t #extracting the list of points of a contour\r\n\t\t\t#print(k,len(cont),len(index)) \r\n\t\t\tfor i in range(len(index)):\r\n\t\t\t\tp = geom.add_point(cont[index[i]],lcar[k]) #creating a point element in the mesh of the k^th contour\r\n\t\t\t\tl.append(p) #appending the point element to l \r\n\r\n\t\t\ts1_l = geom.add_bspline(l) #creating a spline using the points in the list l\r\n\t\t\t#creating a two point spline element with the first and last point of the contour as the add_curve_loop function requires \r\n\t\t\t#that the first and the last points of two spline elements that are to be stitched together must have the same point element\r\n\t\t\ts2_l = geom.add_spline([l[-1],l[0]]) \r\n\r\n\t\t\tl_loop = geom.add_curve_loop([s1_l,s2_l]) #creating the loop element of the contour\r\n\t\t\tloops.append(l_loop) #appending this element to loops\r\n\r\n\t\tgeom.add_plane_surface(lines, holes = loops) #creating boundary surface element that can now be meshed\r\n\t\t#print(loops)\r\n\r\n\r\n\t\t#We create surface elements in the mesh for each loop (k). Using the hierarchy structure of the loops we \r\n\t\t#specify the loops (i1, i2,...,ir) that are contained the loop k and they form holes in surface element \r\n\t\t#corresponding to loop k\r\n\r\n\t\tfor k in range(len(cont_idx)):\r\n\t\t\tholes_idx = mesh_holes[cont_idx[k]] #loading the indices of the loops that form holes in the kth loop\r\n\t\t\tholes = [] #empty list to append the loop elements according to the indices\r\n\t\t\tfor i in range(len(holes_idx)):\r\n\t\t\t\tfor j in range(len(cont_idx)):\r\n\t\t\t\t\tif holes_idx[i] == cont_idx[j]:\r\n\t\t\t\t\t\tholes.append(loops[j]) \r\n\t\t\tif not holes:\r\n\t\t\t\tgeom.add_plane_surface(loops[k])\r\n\t\t\t\tprint('surface with no holes',cont_idx[k])\r\n\t\t\telse:\r\n\t\t\t\tgeom.add_plane_surface(loops[k], holes = holes) \r\n\t\t\t\tprint('surface with holes',cont_idx[k])\r\n\t\tmesh = geom.generate_mesh() #generate the mesh element \r\n\r\n\t\tif remove_low_dim_cells == True:\r\n\t\t\tmesh.remove_orphaned_nodes()\r\n\t\t\tmesh.remove_lower_dimensional_cells()\r\n\r\n\t\treturn mesh\r\n\t\r\ndef contrast_equ(img_filename,out_filename):\r\n\timage = cv.imread(img_filename,0)\r\n\r\n\tclahe = cv.createCLAHE(clipLimit = 5.0, tileGridSize = (8,8))\r\n\tcl1 = clahe.apply(image)\r\n\tequ = cv.equalizeHist(cl1)\r\n\r\n\tcv.imwrite(out_filename,equ)\r\n\r\n\r\ndef mesh_from_image(image_path, mesh_path, num_points, method = 'watershed', small_contour = False, default_lcar = True, plot_contours = True):\r\n\t\r\n\t\"\"\"\r\n\tCreates a meshio instance containing the desired mesh based on the given image.\r\n\r\n\tParameters\r\n\t----------\r\n\r\n\timage_path\t: str,\r\n\t\t\t\tlocation of the image on the device\r\n\tmesh_path\t: str,\r\n\t\t\t\tlocation where the mesh should be stored with the name of the file. Must be in .vtk format, for example, \r\n\t\t\t\t'C:\/Documents\/meshautogen.vtk'\r\n\tnum_points\t: int,\r\n\t\t\t\tnumber of points to be used for selecting contours, must be an even number\r\n\tmethod\t\t: str, \r\n\t\t\t\tmethod to use for contouring the image, default is 'watershed'\r\n\tsmall_contour : Bool,\r\n\t\t\t\tIf True, all the contours which have lower than 10 points are removed\r\n\tdefault_lcar : Bool or list,\r\n\t\t\t\tIf True uses the in-built meshing parameters for the mesh, feed this as a list otherwise\r\n\tplot_contours : Bool,\r\n\t\t\t\tIf True plots the selected contours on top of the contoured image, default is False\r\n\r\n\r\n\tReturns\r\n\t-------\r\n\r\n\r\n\r\n\r\n\t\"\"\"\t\r\n\r\n\tcont_idx,contours,hierarchy, dim = contour_selc(image_path,method,num_points)\r\n\r\n\tmesh_holes = contour_tree(hierarchy)\r\n\r\n\tif small_contour == False:\r\n\t\tdel_list = []\r\n\t\tfor k in range(len(cont_idx)):\r\n\t\t\tif len(contours[cont_idx[k]]) < 10:\r\n\t\t\t\tdel_list.append(k)\r\n\r\n\t\tcont_idx = np.delete(cont_idx,del_list)\r\n\r\n\tif default_lcar == True:\r\n\t\tindices = []\r\n\t\tlcar = []\r\n\t\tfor i in range(len(cont_idx)):\r\n\t\t\tif len(contours[cont_idx[i]]) <= 25:\r\n\t\t\t\tindex = np.arange(0,len(contours[cont_idx[i]]),1)\r\n\t\t\t\tlcar_val = 10\r\n\t\t\telif 25 < len(contours[cont_idx[i]]) <= 50:\r\n\t\t\t\tindex = np.arange(0,len(contours[cont_idx[i]]),2)\r\n\t\t\t\tlcar_val = 10\r\n\t\t\telif 50 < len(contours[cont_idx[i]]) <= 200:\r\n\t\t\t\tindex = np.arange(0,len(contours[cont_idx[i]]),5)\r\n\t\t\t\tlcar_val = 20\r\n\t\t\telif 200 < len(contours[cont_idx[i]]) <= 1000:\r\n\t\t\t\tindex = np.arange(0,len(contours[cont_idx[i]]),10)\r\n\t\t\t\tlcar_val = 25\r\n\t\t\telse:\r\n\t\t\t\tindex = np.arange(0,len(contours[cont_idx[i]]),15)\r\n\t\t\t\tlcar_val = 40\r\n\t\t\tindices.append(index)\r\n\t\t\tlcar.append(lcar_val)\r\n\telse:\r\n\t\tlcar = default_lcar\r\n\r\n\tfor i in range(len(cont_idx)):\r\n\t\tplt.scatter(contours[cont_idx[i]][:,0,0],contours[cont_idx[i]][:,0,1], label = '{}'.format(cont_idx[i]))\r\n\tplt.legend()\r\n\tplt.show()\r\n\r\n\tplt.close()\r\n\r\n\r\n\tmesh = Mesh(contours,cont_idx,mesh_holes,dim, indices,lcar,remove_low_dim_cells = True)\r\n\t#help(mesh.write)\r\n\r\n\tmesh.write(mesh_path)\r\n\r\n\t\r\ncontrast_equ('G:\\\\HiWi\\\\Prostate_1.png','G:\\\\HiWi\\\\Prostate_1_conteq.png')\r\n\r\nmesh_from_image('G:\\\\HiWi\\\\Prostate_1_conteq.png','G:\\\\HiWi\\\\autogentest.vtk',4)\r\n\r\n\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_641","text":"from pysb import *\nfrom pysb.macros import *\nfrom scipy.constants import N_A\n\nModel()\n\nVOL = 1e-20\nNA_V = N_A*VOL\n\nParameter('k1', 0.015*NA_V)\n# Parameter('k1', 0.015)\n\nParameter('k2', 0)\n\nParameter('k3', 200\/NA_V)\n# Parameter('k3', 200)\n\nParameter('k4', 2*180\/NA_V\/NA_V)\n# Parameter('k4', 2*180)\n\nParameter('kp4', 0.018)\nParameter('k5', 0)\nParameter('k6', 1.0)\nParameter('k7', 0.6)\nParameter('k8', 1e6) #1e12)\nParameter('k9', 1e3) #1e6)\n\nMonomer('cyclin', ['Y', 'b'], {'Y': ['U','P']})\nMonomer('cdc2', ['Y', 'b'], {'Y': ['U','P']})\n\n# Rule 1\nsynthesize(cyclin(Y='U', b=None), k1)\n\n# Rule 2\n#degrade(cyclin(Y='U', b=None), k2)\n\n# Rule 3\nRule('BindingAndPhosphoylation', cyclin(Y='U', b=None) + cdc2(Y='P', b=None) >> cyclin(Y='P', b=1) % cdc2(Y='P', b=1), k3)\n\n# Rule 4\nRule('Activation', cyclin(Y='P', b=1) % cdc2(Y='P', b=1) >> cyclin(Y='P', b=1) % cdc2(Y='U', b=1), kp4)\n\n# Rule 4'\nRule('Autocatalytic', cyclin(Y='P', b=1) % cdc2(Y='P', b=1) + cyclin(Y='P', b=2) % cdc2(Y='U', b=2) + cyclin(Y='P', b=2) % cdc2(Y='U', b=2) >>\ncyclin(Y='P', b=1) % cdc2(Y='U', b=1) + cyclin(Y='P', b=2) % cdc2(Y='U', b=2) + cyclin(Y='P', b=2) % cdc2(Y='U', b=2), k4)\n\n# Rule 5\n#Rule('Opposed', cyclin(Y='P', b=1) % cdc2(Y='U', b=1) >> cyclin(Y='P', b=1) % cdc2(Y='P', b=1), k5)\n\n# Rule 6\n#Rule('Dissociation', cyclin(Y='P', b=1) % cdc2(Y='U', b=1) >> cyclin(Y='P', b=None) + cdc2(Y='U', b=None), k6)\nRule('Dissociation', cyclin(Y='P', b=1) % cdc2(Y='U', b=1) >> cdc2(Y='U', b=None), k6)\n\n# Rule 7\n#degrade(cyclin(Y='P', b=None), k7)\n\n# Rules 8 and 9\nequilibrate(cdc2(Y='U', b=None), cdc2(Y='P', b=None), [k8, k9])\n\nObservable(\"YT\", cyclin()) # Total Cyclin\nObservable(\"CT\", cdc2()) # Total CDC2\nObservable(\"M\", cyclin(Y='P', b=1) % cdc2(Y='U', b=1) ) # Active Complex\n\nObservable(\"Y1\", cdc2(Y='U', b=None))\nObservable(\"Y2\", cdc2(Y='P', b=None))\nObservable(\"Y3\", cdc2(Y='U', b=1) % cyclin(Y='P', b=1))\nObservable(\"Y4\", cdc2(Y='P', b=1) % cyclin(Y='P', b=1))\nObservable(\"Y5\", cyclin(Y='U', b=None))\n\n#Observable(\"CYCLIN_P\", cyclin(Y='P', b=None))\n# [C2] in Tyson\n\nParameter(\"cdc0\", 1*NA_V)\n# Parameter(\"cdc0\", 1.0)\nInitial(cdc2(Y='P', b=None), cdc0)\n\n# [Y] in Tyson\nParameter('cyc0', 0.25*NA_V)\n# Parameter('cyc0', 0.25)\nInitial(cyclin(Y='U', b=None), cyc0)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_642","text":"# -*- coding: utf-8 -*-\n\"\"\"project.ipynb\n\nAutomatically generated by Colaboratory.\n\nOriginal file is located at\n    https:\/\/colab.research.google.com\/drive\/1X5s8AO6MC_VvVxfA6r-1j0R5SRpeN_rT\n\"\"\"\n\nimport wave\nimport numpy as np\nfrom scipy.io import wavfile\nimport matplotlib.pyplot as plot\n\nFREQ = 1000\nTHRESHOLD = 128\nWPM = 5\nNOISE_FACTOR = 0.01\n#AUDIO_FILENAME = '\/content\/Hello Ahmed 5 wpm freq 1000.wav'\n#AUDIO_FILENAME = '\/content\/Hello Ahmed 0 wpm freq 500.wav'\nAUDIO_FILENAME = '\/content\/hello this is sara 10 wpm.wav'\nletter_to_morse = {\n\t\"a\" : \".-\",\t\"b\" : \"-...\",\t\"c\" : \"-.-.\",\n\t\"d\" : \"-..\",\t\"e\" : \".\",\t\"f\" : \"..-.\",\n\t\"g\" : \"--.\",\t\"h\" : \"....\",\t\"i\" : \"..\",\n\t\"j\" : \".---\",\t\"k\" : \"-.-\",\t\"l\" : \".-..\",\n\t\"m\" : \"--\",\t\"n\" : \"-.\",\t\"o\" : \"---\",\n\t\"p\" : \".--.\",\t\"q\" : \"--.-\",\t\"r\" : \".-.\",\n\t\"s\" : \"...\",\t\"t\" : \"-\",\t\"u\" : \"..-\",\n\t\"v\" : \"...-\",\t\"w\" : \".--\",\t\"x\" : \"-..-\",\n\t\"y\" : \"-.--\",\t\"z\" : \"--..\",\t\"1\" : \".----\",\n\t\"2\" : \"..---\",\t\"3\" : \"...--\",\t\"4\" : \"....-\",\n\t\"5\" : \".....\", \t\"6\" : \"-....\",\t\"7\" : \"--...\",\n\t\"8\" : \"---..\",\t\"9\" : \"----.\",\t\"0\" : \"-----\",\t\n\t\" \" : \" \"}\nmorse_to_letters = dict([(value, key) for key, value in letter_to_morse.items()])\n\ndef digitize(snd_data):\n  sampled = np.asarray(snd_data).copy()\n  if sampled[0] == THRESHOLD:\n    sampled[0] = 0\n  else: sampled[0] = 1\n  for i in range(1, len(snd_data)-1):\n    if snd_data[i]>THRESHOLD + 4 or snd_data[i]<THRESHOLD-4:\n      sampled[i] = 1\n    elif snd_data[i-1]<THRESHOLD+4 and snd_data[i-1]>THRESHOLD-4 and snd_data[i+1]<THRESHOLD+4 and snd_data[i+1]>THRESHOLD-4:\n      sampled[i] = 0\n    else:\n      sampled[i] = 1\n  sampled[-1] = sampled[-2]\n  return np.asarray(sampled)\n\ndef preprocess(AUDIO_FILENAME):\n  wav_file = wave.open(AUDIO_FILENAME)\n  fs, data = wavfile.read(AUDIO_FILENAME)\n  data = data\n  data = digitize(data) #convert to zeros and ones\n  length = data.shape[0] \/ fs\n  time = np.linspace(0., length, data.shape[0])\n  plot.plot(data[:3000])\n  return time, data\n\ndef tone_separator(AUDIO_FILENAME): # returns list of tuples (duration,high\/low)\n  time, data = preprocess(AUDIO_FILENAME)\n  c1 = 0\n  c2 = 0\n  c3 = 0\n  c4 = 0\n  tone_sep = []\n  rising_edge = 0\n  falling_edge = 0\n  for i in range(1, len(time)):\n    #rising edge 0->1\n    if data[i] == 1:\n      if data[i-1] == 0:\n        c1 = time[i]\n        c4 = time[i] #why c4 and c3 ??\n        rising_edge = 1\n    #falling edge 1->0\n    elif data[i] == 0:\n      if data[i-1] == 1:\n        c2 = time[i]\n        c3 = time[i]\n        falling_edge = 1\n    if c1 != 0 and c2 != 0:\n      tone_sep.append((c2-c1, falling_edge))\n      rising_edge = 0\n      falling_edge = 0\n      c1 = 0\n      c2 = 0\n    if c3 != 0 and c4 != 0 and c4>c3:\n      tone_sep.append((c4-c3, falling_edge))\n      c3 = 0\n      c4 = 0\n  tone_sep = filter_tones(tone_sep)\n  tone_sep = np.asarray(tone_sep)\n  tone_sep = np.round(tone_sep, 2)\n  print(tone_sep)\n  return tone_sep\n\ndef filter_tones(tone_list):\n  tone_list = [s for s in tone_list if s[0]>NOISE_FACTOR]\n  return tone_list\n\n\ndef normalize_time(tone_list):  ##normaloze the values of the tones, 1  = '.', 2= '-', 3 = letter separation, 4= word separation\n  normalized = []\n  dot_len= min(tone_list, key = lambda t: t[0]) [0]\n  dash_len= dot_len * 3\n  word_space = dot_len * 7\n  for x in tone_list:\n    if x[1] == 1:\n      if x[0] == dot_len:\n        normalized.append((1, x[1]))\n      elif x[0] == dash_len :\n        normalized.append((2, x[1]))\n    elif x[1]==0:\n      if x[0] == word_space:   \n        normalized.append((4, x[1]))\n      elif x[0] == dash_len:\n        normalized.append((3, x[1]))\n  normalized.append((3,0.0))\n  #print(normalized)\n  return normalized\n\ndef encode(Tones): #convert the resultant audio into text morse (dots & dashes)\n  scentence=[]\n  letter = ''\n  for tone in Tones:\n      if tone[0] == 1 and tone[1] == 1:\n        letter+='.'\n      elif tone[0] == 2:\n        letter += '-'\n      elif tone[0] == 3:\n        scentence.append(letter)\n        letter=''\n      elif tone[0] == 4:\n        scentence.append(letter)\n        scentence.append(' ')\n        letter = ''\n  return scentence\n\ndef decode(morse): #convert the text morse into english letters \n  scentence = ''\n  for e in morse:\n    scentence += morse_to_letters[e]\n  return scentence\n\ndef Translate_Morse(AUDIO_FILENAME):\n  tones = tone_separator(AUDIO_FILENAME) #correct with all\n  get_types(tones)\n  tones = normalize_time(tones)\n  Morse = encode(tones)\n  translation = decode(Morse)\n  return translation\n\ntranslated = Translate_Morse(AUDIO_FILENAME)\nprint(translated)\n\n\"\"\"The above cell has the main code the runs all the functions and converts the audio file in 'AUDIO_FILENAME' into english\nthe morse has to be generated via https:\/\/www.meridianoutpost.com\/resources\/etools\/calculators\/calculator-morse-code.php?\nwith the following settings:  \nfrequency = 1000\nWPM = 5\nfurther adjustments may be made to make the translation more generic \n\n*** \nhttps:\/\/morsecode.world\/international\/translator.html\n\"\"\"\n\nwav_file = wave.open(AUDIO_FILENAME)\nfs, data = wavfile.read(AUDIO_FILENAME)\ndata = data\ndata=digitize(data)\nprint(data)\nlength = data.shape[0] \/ fs\ntime = np.linspace(0., length, data.shape[0])\nplot.figure(figsize=(20, 7))\nplot.plot(time, data, label=\"Audio Signal\")\nplot.legend()\nplot.xlabel(\"Time (sec)\")\nplot.ylabel(\"Amplitude\")\nplot.show()\n\n\"\"\"to be general :  we have to get the length of a dot \n\n1 dash = 3 dots high\n\nspace between dots and dashes of the letter = 1 dot low\n\nspace between letters = 3 dots low \n\nspace between words = 7 dots low\n\nwe can check the smallest length we detected and that would be the length of 1 dot. then, translate high and low dots to dots\/dashes or spaces accordingly\n\"\"\"\n\nimport math\nimport wave\nimport struct\n\n# Audio will contain a long list of samples (i.e. floating point numbers describing the\n# waveform).  If you were working with a very long sound you'd want to stream this to\n# disk instead of buffering it all in memory list this.  But most sounds will fit in \n# memory.\naudio = []\nsample_rate = 44100.0\n\n\ndef append_silence(duration_milliseconds=500):\n    \"\"\"\n    Adding silence is easy - we add zeros to the end of our array\n    \"\"\"\n    num_samples = duration_milliseconds * (sample_rate \/ 1000.0)\n\n    for x in range(int(num_samples)): \n        audio.append(0.0)\n\n    return\n\n\ndef append_sinewave(\n        freq=440.0, \n        duration_milliseconds=500, \n        volume=1.0):\n    \"\"\"\n    The sine wave generated here is the standard beep.  If you want something\n    more aggresive you could try a square or saw tooth waveform.   Though there\n    are some rather complicated issues with making high quality square and\n    sawtooth waves... which we won't address here :) \n    \"\"\" \n\n    global audio # using global variables isn't cool.\n\n    num_samples = duration_milliseconds * (sample_rate \/ 1000.0)\n\n    for x in range(int(num_samples)):\n        audio.append(volume * math.sin(2 * math.pi * freq * ( x \/ sample_rate )))\n\n    return\n\n\ndef save_wav(file_name):\n    # Open up a wav file\n    wav_file=wave.open(file_name,\"w\")\n\n    # wav params\n    nchannels = 1\n\n    sampwidth = 2\n\n    # 44100 is the industry standard sample rate - CD quality.  If you need to\n    # save on file size you can adjust it downwards. The stanard for low quality\n    # is 8000 or 8kHz.\n    nframes = len(audio)\n    comptype = \"NONE\"\n    compname = \"not compressed\"\n    wav_file.setparams((nchannels, sampwidth, sample_rate, nframes, comptype, compname))\n\n    # WAV files here are using short, 16 bit, signed integers for the \n    # sample size.  So we multiply the floating point data we have by 32767, the\n    # maximum value for a short integer.  NOTE: It is theortically possible to\n    # use the floating point -1.0 to 1.0 data directly in a WAV file but not\n    # obvious how to do that using the wave module in python.\n    for sample in audio:\n        wav_file.writeframes(struct.pack('h', int( sample * 32767.0 )))\n\n    wav_file.close()\n\n    return\n\n\nappend_sinewave(duration_milliseconds=500, volume=0.25)\nappend_silence()\nappend_sinewave(duration_milliseconds=1000, volume=0.5)\nappend_silence()\nappend_sinewave()\nsave_wav(\"output.wav\")\n\nwav_file = wave.open(\"output.wav\")\nfs, data = wavfile.read(\"output.wav\")\ndata = data\n#data=digitize(data)\nprint(data)\nlength = data.shape[0] \/ fs\ntime = np.linspace(0., length, data.shape[0])\nplot.figure(figsize=(20, 7))\nplot.plot(time, data, label=\"Audio Signal\")\nplot.legend()\nplot.xlabel(\"Time (sec)\")\nplot.ylabel(\"Amplitude\")\nplot.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_643","text":"# Helper functions for 14 time domain features calculation\n\nimport numpy as np\nfrom scipy import stats\n\nEPSILON = 1e-15\n\ndef time_domain_features(a) :\n    squared_a = np.square(a)\n    abs_a = np.absolute(a)\n    sqrt_a = np.sqrt(abs_a)\n    arange_a = np.arange(1, a.shape[0]+1)\n\n    max =  np.maximum.accumulate(a).reshape(-1, 1)\n    min = np.minimum.accumulate(a).reshape(-1, 1)\n\n    absmean = np.cumsum(abs_a) \/ arange_a\n    absmean = absmean.reshape(-1, 1)\n    \n    mean = np.cumsum(a) \/ arange_a\n    mean = mean.reshape(-1, 1)\n\n    rms = np.sqrt(np.cumsum(squared_a) \/ arange_a )\n    rms = rms.reshape(-1, 1)\n \n    smr = np.square(np.cumsum(sqrt_a) \/ arange_a )\n    smr = smr.reshape(-1, 1)\n\n    peaktopeak =  np.maximum.accumulate(abs_a) * 2\n    peaktopeak = peaktopeak.reshape(-1, 1)\n    \n    stddev = np.sqrt( (np.cumsum(squared_a) \/ arange_a) -  (np.square(np.cumsum(a) \/ arange_a)) )\n    stddev = stddev.reshape(-1, 1)\n\n    kurtosis = np.zeros((a.shape[0], 1))\n    for i in range(a.shape[0]):\n        subarr = a[0:i+1]\n        kurtosis[i] = stats.kurtosis(subarr)\n   \n\n    # kurtosisfactor = kurtosis \/ (EPSILON + (stddev ** 4))\n\n    waveformfactor =  rms \/ (EPSILON + absmean)\n    \n    crestfactor =  peaktopeak \/ (EPSILON + rms)\n    \n    impactfactor = peaktopeak \/ (EPSILON + absmean)\n    \n    clearancefactor =  peaktopeak \/ (EPSILON + rms)\n    \n    res = np.concatenate((max, min, absmean, mean, rms, smr, peaktopeak, \n                          stddev, kurtosis, waveformfactor, crestfactor,\n                          impactfactor, clearancefactor), axis=1)\n\n    \n    return res\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_644","text":"\nimport pathlib, sys\nimport numpy as np\nimport pressiotools.linalg as ptla\nimport scipy.linalg as la\n\nnp.set_printoptions(linewidth=140)\n\n#-----------------------------------------\ndef pinv_run(comm):\n  rank = comm.Get_rank()\n  np.random.seed(312367)\n\n  # create matrix\n  A = np.asfortranarray(np.random.rand(15,4))\n\n  BT = la.pinv(A).T\n  if rank==0:\n    print(BT)\n\n  # create distributed A\n  myStartRow = rank*5\n  A1 = ptla.MultiVector(A[myStartRow:myStartRow+5, :])\n  piO = ptla.PseudoInverse()\n  piO.compute(A1)\n  # view the local part of A^*T\n  # remember that pressiotools.PseudoInverse stores A^*T NOT A^*\n  AstarT = piO.viewTransposeLocal()\n  print(\"rank\", rank, AstarT)\n\n  myBT = BT[myStartRow:myStartRow+5, :]\n  assert(np.allclose(myBT, AstarT, atol=1e-10))\n\n#-----------------------------------------\ndef pinv_apply(comm):\n  print(\"\\n\")\n  rank = comm.Get_rank()\n  np.random.seed(312367)\n\n  # create the matrix\n  A = np.asfortranarray(np.random.rand(15,4))\n\n  # compute scipy pseudo-inverse\n  B = la.pinv(A)\n  print(B.T)\n  # apply to vector of ones\n  d0 = np.ones(15)\n  c = np.dot(B, d0)\n  print(c)\n\n  # do same using our code\n  # create distributed A\n  myStartRow = rank*5\n  A1 = ptla.MultiVector(A[myStartRow:myStartRow+5, :])\n  piO = ptla.PseudoInverse()\n  piO.compute(A1)\n  d1 = ptla.Vector(np.ones(5))\n  c1 = piO.apply(d1)\n  print(c1)\n\n  assert(np.allclose(c, c1, atol=1e-10))\n\n\nif __name__ == '__main__':\n  from mpi4py import MPI\n  comm = MPI.COMM_WORLD\n  assert(comm.Get_size() == 3)\n\n  pinv_run(comm)\n  pinv_apply(comm)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_645","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Oct  1 14:02:59 2019\n\n@author: ag\n\"\"\"\n\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Oct  1 12:36:44 2019\n\n@author: ag\n\"\"\"\n\nimport numpy as np\nimport re\nfrom scipy import interpolate\nimport pandas as pd\nimport pickle\n\ndef loadfile(txt):\n    df = pd.read_csv(txt,delim_whitespace=True)\n    df.columns = df.columns.str.strip()\n\n    #remove 20year means in bottom of file.\n    ix = df.index[df.year.apply(lambda x: not x.isnumeric())]\n    if len(ix)>0:\n        ix=ix[0]\n        df=df.iloc[0:ix]\n    df.year=pd.to_numeric(df.year)\n    df['05']=pd.to_numeric(df['05'])\n\n    df = df.append({'year': 1995.5, '05': 0.0, '50':0.0, '95':0.0},ignore_index=True)\n    df.set_index('year',inplace=True)\n    \n    add = pd.DataFrame({'year': np.arange(1996,2007), '50': np.nan})\n    add.set_index('year',inplace=True)\n    df= pd.concat((df,add),sort=False)\n    df = df.loc[~df.index.duplicated(keep='first')]\n    df.sort_index(inplace=True)\n    df.interpolate(inplace=True)\n    \n#    V = np.append(V, [[1995.5,0]], axis=0) # baseline: 1986–2005\n    \n#    f = interpolate.interp1d(V[:,0], V, axis=0, fill_value='extrapolate',bounds_error=0)\n#    V= f(np.arange(2000,2101)) #ensure that it has exactly this period! Some files goes to 2099\n    return df\n    \n    \noutput={}\n\nd=['ant_26','ant_45','ant_85','gmsl_26','gmsl_45','gmsl_85']\nfor ii,filename in enumerate(d):\n    (component,scenario)=re.findall(r'(.*)_(\\d+)',filename)[0]\n    \n    df = loadfile(filename)\n   \n    if scenario not in output:\n        output[scenario] = {}\n    if component not in output[scenario]:\n        output[scenario][component] = {}\n    output[scenario][component]=df\n\n\nwith open('SROCC.pickle', 'wb') as file:\n    pickle.dump(output, file)\n\n\n\n#-------------------JOIN WITH AR5--------------------------\nar5 = loadpickle('..\/..\/AR5datafiles\/13.SM.1\/AR5.pickle')\n\nnaming = {'26': 'rcp26', '45': 'rcp45', '85': 'rcp85'}\nfor k,v in naming.items():\n    output[v] = output.pop(k)\n\n   \nnaming = {'05': 'low', '50': 'mid', '95': 'upper'}\nfor scen,sitem in output.items():\n    for contrib,item in sitem.items():\n        for k,v in naming.items():\n            item[v] = item.pop(k)\n\nnaming = {'ant': 'antnet', 'gmsl': 'sum'}\nfor scenario,item in output.items():\n    for k,v in naming.items():\n        item[v] = item.pop(k)\n    item['temperature'] = ar5[scenario]['temperature']\n    \n    \nwith open('SROCC-AR5.pickle', 'wb') as file:\n    pickle.dump(output, file)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_646","text":"<filename>harmonizome\/utility_functions.py\n# Adapted from code created by <NAME>\n\nimport datetime\nimport os\nimport zipfile\n\nimport numpy as np\nimport pandas as pd\nimport scipy.spatial.distance as dist\nimport scipy.sparse as sp\nfrom statsmodels.distributions.empirical_distribution import ECDF\n\nfrom tqdm import tqdm\n\n\ndef remove_impute(df):\n    '''\n    Removes rows and columns that have more than 95% of their data missing,\n    or 0. Replacing any missing data leftover after removal with\n    the means of the rows.\n    '''\n    r, c = df.shape\n    df.loc[np.sum(np.logical_or(np.isnan(df), df == 0), axis=1) < 0.05 * r,\n           np.sum(np.logical_or(np.isnan(df), df == 0), axis=0) < 0.05 * c]\n\n    return df.fillna(df.mean(axis=0))\n\n\ndef merge(df, axis):\n    '''\n    Merges duplicate rows or columns, depending on the axis specified. The\n    final values of the merged rows or columns is determined by the method.\n    '''\n    if axis == 'column':\n        return df.groupby(df.columns, axis=1).mean()\n    elif axis == 'row':\n        return df.groupby(level=0, axis=0).mean()\n\n\ndef quantile_normalize(df):\n    '''\n    Performs quantile normalization on the input DataFrame.\n    '''\n    # from ayhan on StackOverflow\n    rank_mean = df.stack().groupby(\n        df.rank(method='first').stack().astype(int)).mean()\n    return df.rank(method='min').stack().astype(int).map(\n        rank_mean).unstack()\n\n\ndef zscore(df, epsilon=0):\n    '''\n    Calculates the modified z-score of df according to the specified axis.\n\n    Parameters:\n        axis - the axis on which to calculate the z-scores. Either 'row' or 'column'\n        epsilon - small adjustment in the case of divide by 0 errors.\n    '''\n    np.seterr(divide='ignore', invalid='ignore')\n    median_y = np.median(df, axis=1)[:, np.newaxis]\n    abs_dev = np.abs(df - median_y)\n    median_dev = np.median(abs_dev, axis=1)\n    mean_dev = np.mean(abs_dev, axis=1)\n    median_abs_dev = np.broadcast_to(median_dev[:, np.newaxis], df.shape)\n    mean_abs_dev = np.broadcast_to(mean_dev[:, np.newaxis], df.shape)\n    modified_z_scores = np.where(median_abs_dev != 0,\n                                 0.6745 * (df - median_y) \/ median_abs_dev,\n                                 (df - median_y) \/ (1.253314 * mean_abs_dev + epsilon))\n\n    return pd.DataFrame(data=modified_z_scores, index=df.index,\n                        columns=df.columns)\n\n\ndef log2(df):\n    '''\n    Returns a dataframe with the adjusted log2 values of the input.\n    '''\n    return np.log2(df + 1)\n\n\ndef map_symbols(df, symbol_lookup, remove_duplicates=False):\n    '''\n    Replaces the index of the df, which are gene names, with\n    corresponding approved gene symbols according to the given symbol_lookup \n    dictionary. If any gene names are not in the mapping, they are discarded \n    from the DataFrame.\n    '''\n    tqdm.pandas()\n    df = df.reset_index()\n\n    df.iloc[:, 0] = df.iloc[:, 0].progress_map(\n        lambda x: symbol_lookup.get(x, np.nan))\n\n    df = df.dropna(subset=[df.columns[0]])\n    if remove_duplicates:\n        df = df.drop_duplicates()\n    df = df.set_index(df.columns[0])\n    return df\n\n\ndef binary_matrix(df):\n    '''\n    Creates an adjacency matrix from df, which is a gene-attribute edge\n    list.\n    '''\n    matrix = pd.crosstab(df.index, df.iloc[:, 0]) > 0\n    matrix.index.name = df.index.name\n    matrix.columns.name = df.columns[0]\n    return matrix\n\n\ndef ternary_matrix(df):\n    '''\n    Returns the input matrix with all significant values, greater than 0.95\n    or less than -0.95, mapped to 1 or -1, respectively. All other values\n    are mapped to 0.\n    '''\n    def mapter(x):\n        if x >= 0.95:\n            return 1\n        elif x <= -0.95:\n            return -1\n        else:\n            return 0\n\n    return df.applymap(mapter)\n\n\ndef save_setlib(df, lib, direction, path, name):\n    '''\n    If lib = 'gene', this creates a file which lists all attributes and the\n    genes that are correlated in the direction given with that attribute.\n\n    If lib = 'attribute', this creates a file which lists all genes and the\n    attributes that are correlated in the direction given with that gene.\n    The year and month are added at the end of the name. The path the file is\n    saved to is thus\n        path + name + '_<year>_<month>.gmt'\n    '''\n    filenameGMT = file_name(path, name, 'gmt')\n    direction = {'up': 1, 'down': -1}[direction]\n\n    if not (lib == 'gene' or lib == 'attribute'):\n        return\n    if lib == 'attribute':\n        df = df.T\n\n    with open(filenameGMT, 'w') as f:\n        arr = df.reset_index(drop=True).to_numpy(dtype=np.int_)\n        attributes = df.columns\n\n        w, h = arr.shape\n        for i in tqdm(range(h)):\n            print(attributes[i], *df.index[arr[:, i] == direction],\n                  sep='\\t', end='\\n', file=f)\n\n\ndef similarity_matrix(df, metric, dtype=None, sparse=False):\n    '''\n    Creates a similarity matrix between the rows of the df based on\n    the metric specified. The resulting matrix has both rows and columns labeled\n    by the index of df.\n    '''\n    if sparse and metric == 'jaccard':\n        # from na-o-ys on Github\n        sparse = sp.csr_matrix(df.to_numpy(dtype=np.bool).astype(np.int))\n        cols_sum = sparse.getnnz(axis=1)\n        ab = sparse * sparse.T\n        denom = np.repeat(cols_sum, ab.getnnz(axis=1)) + \\\n            cols_sum[ab.indices] - ab.data\n        ab.data = ab.data \/ denom\n        similarity_matrix = ab.todense()\n        np.fill_diagonal(similarity_matrix, 1)\n\n    else:\n        similarity_matrix = dist.pdist(df.to_numpy(dtype=dtype), metric)\n        similarity_matrix = dist.squareform(similarity_matrix)\n        similarity_matrix = 1 - similarity_matrix\n\n    similarity_df = pd.DataFrame(\n        data=similarity_matrix, index=df.index, columns=df.index)\n    similarity_df.index.name = None\n    similarity_df.columns.name = None\n    return similarity_df\n\n\ndef gene_list(df, geneid_lookup):\n    '''\n    Creates a list of genes and the corresponding Entrez Gene IDs(supplied by\n    the NCBI)\n\n    Note: this differs from the previous function in its behavior with dealing\n    with genes that do not have an ID. This function will set the id of the gene\n    to -1, whereas the previous script will set them to np.nan.\n    '''\n    gene_ids = np.array([geneid_lookup.get(x, -1)\n                         if np.isfinite(geneid_lookup.get(x, -1))\n                         else -1 for x in tqdm(df.index)], dtype=np.int_)\n    df = pd.DataFrame(gene_ids, index=df.index,\n                      columns=['Gene ID'])\n    return df\n\n\ndef attribute_list(df, metaData=None):\n    '''\n    Creates a list of attributes in the form of a DataFrame, with the attributes\n    as the indices. If metaData is specified, it returns appends the attributes\n    of df onto the metaData DataFrame.\n    '''\n    if metaData is not None:\n        attribute_list = metaData.reindex(df.columns)\n        attribute_list.index.name = df.columns.name\n    else:\n        attribute_list = pd.DataFrame(index=df.columns)\n    return attribute_list\n\n\ndef standardized_matrix(df):\n    '''\n    Creates a standardized matrix by using an emperical CDF for each row.\n    Each row in the df should represent a single gene.\n\n    Requires:\n    Indices of the DataFrame are unique.\n    '''\n    arr = df.to_numpy(copy=True)\n\n    def process(array):\n        ourECDF = ECDF(array)\n        array = ourECDF(array)\n        mean = np.mean(array)\n        array = 2 * (array - mean)\n        return array\n\n    for i in tqdm(range(arr.shape[0])):\n        arr[i, :] = process(arr[i, :])\n\n    values = arr.flatten()\n    ourECDF = ECDF(values)\n    ourECDF = ourECDF(values).reshape(arr.shape)\n\n    mean = np.mean(ourECDF)\n    ourECDF = 2 * (ourECDF - mean)\n    newDF = pd.DataFrame(data=ourECDF, index=df.index,\n                         columns=df.columns)\n    return newDF\n\n\ndef edge_list(df):\n    '''\n    Creates the gene-attribute edge list from the given input DataFrame,\n    attribute and gene lists. The year and month are added at the\n    end of the name. The path the file is saved to is thus\n        path + name + '_<year>_<month>.gmt'\n    Also prints the number of cells in df that are statistically\n    significant, i.e. > 0.95 confidence.\n    Requires:\n        attributelist and genelist were generated from running\n        createAttributeList and createGeneList on df, respectively.\n    '''\n    count = np.sum(np.sum(df >= 0.95) + np.sum(df <= -0.95))\n    df = df.stack()\n    df.name = 'Weight'\n    print('The number of statisticaly relevent gene-attribute associations is: %d' % count)\n    return df\n\n\ndef file_name(path, name, ext):\n    '''\n    Returns the file name by taking the path and name, adding the year and month\n    and then the extension. The final string returned is thus\n        '<path>\/<name>_<year>_<month>.ext'\n    '''\n    date = str(datetime.date.today())[0:7].replace('-', '_')\n    filename = ''.join([name, '_', date, '.', ext])\n    return os.path.join(path, filename)\n\n\ndef save_data(df, path, name, compression=None, ext='tsv',\n              symmetric=False, dtype=None, **kwargs):\n    '''\n    Save df according to the compression method given. \n    compression can take these values:\n        None or 'gmt' - defaults to pandas to_csv() function.\n        'gzip' - uses the gzip compression method of the pandas to_csv() function\n        'npz' - converts the DataFrame to a numpy array, and saves the array.\n                The array is stored as 'axes[0]_axes[1]'. If symmetric is true,\n                it is stored as 'axes[0]_axes[1]_symmetric' instead.\n    ext is only used if compression is None or 'gzip'. The extension of the file\n    will be .ext, or .ext.gz if 'gzip' is specified.\n    axes must only be specified if compression is 'npz'. It is a string tuple\n    that describes the index and columns df, i.e. (x, y) where x, y = \n    'gene' or 'attribute'.\n    symmetric is only used if compression is 'npz', and indicates if df\n    is symmetric and can be stored as such. \n    dtype is only used if compression is 'npz', and indicates a dtype that the\n    array can be cast to before storing.\n\n    The year and month are added at the end of the name. The path the file is \n    saved to is thus\n        path + name + '_<year>_<month>.ext'\n    where ext is .ext, .ext.gz, or .npz depending on the compression method.\n    '''\n\n    if compression is None:\n        name = file_name(path, name, ext)\n        df.to_csv(name, sep='\\t', **kwargs)\n    elif compression == 'gzip':\n        name = file_name(path, name, ext + '.gz')\n        df.to_csv(name, sep='\\t', compression='gzip', **kwargs)\n    elif compression == 'npz':\n        name = file_name(path, name, 'npz')\n\n        data = df.to_numpy(dtype=dtype)\n        index = np.array(df.index)\n        columns = np.array(df.columns)\n\n        if symmetric:\n            data = np.triu(data)\n            np.savez_compressed(name, symmetric=data, index=index)\n        else:\n            np.savez_compressed(name, nonsymmetric=data,\n                                index=index, columns=columns)\n\n\ndef load_data(filename):\n    '''\n    Loads a pandas DataFrame stored in a .npz data numpy array format.\n    '''\n    with np.load(filename, allow_pickle=True) as data_load:\n        arrays = data_load.files\n        if arrays[0] == 'symmetric':\n            data = data_load['symmetric']\n            index = data_load['index']\n            data = data + data.T - np.diag(data.diagonal())\n            df = pd.DataFrame(data=data, index=index, columns=index)\n            return df\n        elif arrays[0] == 'nonsymmetric':\n            data = data_load['nonsymmetric']\n            index = data_load['index']\n            columns = data_load['columns']\n            df = pd.DataFrame(data=data, index=index, columns=columns)\n            return df\n\n\ndef archive(path):\n    with zipfile.ZipFile('output_archive.zip', 'w', zipfile.ZIP_DEFLATED) as zipf:\n        for root, _, files in os.walk(path):\n            for f in files:\n                zipf.write(os.path.join(root, f))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_647","text":"\"\"\"\nUtilities\n\n<NAME> <<EMAIL>>\n\nThe Australian National University\nAustralian Centre for Robotic Vision\n\"\"\"\n\nimport os\nimport torch\nimport pickle\nimport numpy as np\nimport scipy.io as sio\n\nfrom tqdm import tqdm\nfrom collections import defaultdict\nfrom torch.utils.data import Dataset\n\nfrom hicodet.hicodet import HICODet\n\nimport pocket\nfrom pocket.core import DistributedLearningEngine\nfrom pocket.utils import DetectionAPMeter, BoxPairAssociation\n\nimport sys\nsys.path.append('detr')\nimport datasets.transforms as T\n\n\ndef get_iou(bb1, bb2):\n    assert bb1['x1'] < bb1['x2']\n    assert bb1['y1'] < bb1['y2']\n    assert bb2['x1'] < bb2['x2']\n    assert bb2['y1'] < bb2['y2']\n\n    # determine the coordinates of the intersection rectangle\n    x_left = max(bb1['x1'], bb2['x1'])\n    y_top = max(bb1['y1'], bb2['y1'])\n    x_right = min(bb1['x2'], bb2['x2'])\n    y_bottom = min(bb1['y2'], bb2['y2'])\n\n    if x_right < x_left or y_bottom < y_top:\n        return 0.0\n\n    # The intersection of two axis-aligned bounding boxes is always an\n    # axis-aligned bounding box\n    intersection_area = (x_right - x_left) * (y_bottom - y_top)\n\n    # compute the area of both AABBs\n    bb1_area = (bb1['x2'] - bb1['x1']) * (bb1['y2'] - bb1['y1'])\n    bb2_area = (bb2['x2'] - bb2['x1']) * (bb2['y2'] - bb2['y1'])\n\n    # compute the intersection over union by taking the intersection\n    # area and dividing it by the sum of prediction + ground-truth\n    # areas - the interesection area\n    iou = intersection_area \/ float(bb1_area + bb2_area - intersection_area)\n    assert iou >= 0.0\n    assert iou <= 1.0\n    return iou\n\ndef custom_collate(batch):\n    images = []\n    targets = []\n    for im, tar in batch:\n        images.append(im)\n        targets.append(tar)\n    return images, targets\n\nclass DataFactory(Dataset):\n    def __init__(self, name, partition, data_root):\n        if name not in ['hicodet', 'vcoco']:\n            raise ValueError(\"Unknown dataset \", name)\n\n        if name == 'hicodet':\n            assert partition in ['train2015', 'test2015'], \\\n                \"Unknown HICO-DET partition \" + partition\n            self.dataset = HICODet(\n                root=os.path.join(data_root, 'hico_20160224_det\/images', partition),\n                anno_file=os.path.join(data_root, 'instances_{}.json'.format(partition)),\n                target_transform=pocket.ops.ToTensor(input_format='dict')\n            )\n        else:\n            print(\"ERROR!!!\")\n            exit(0)\n\n        # Prepare dataset transforms\n        normalize = T.Compose([\n            T.ToTensor(),\n            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n        ])\n        scales = [480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800]\n        if partition.startswith('train'):\n            self.transforms = T.Compose([\n                T.RandomHorizontalFlip(),\n                T.ColorJitter(.4, .4, .4),\n                T.RandomSelect(\n                    T.RandomResize(scales, max_size=1333),\n                    T.Compose([\n                        T.RandomResize([400, 500, 600]),\n                        T.RandomSizeCrop(384, 600),\n                        T.RandomResize(scales, max_size=1333),\n                    ])\n                ), normalize,\n        ])\n        else:\n            self.transforms = T.Compose([\n                T.RandomResize([800], max_size=1333),\n                normalize,\n            ])\n\n        self.name = name\n\n    def __len__(self):\n        return len(self.dataset)\n\n    def __getitem__(self, i):\n        image, target = self.dataset[i]\n        if self.name == 'hicodet':\n            target['labels'] = target['verb']\n            # Convert ground truth boxes to zero-based index and the\n            # representation from pixel indices to coordinates\n            target['boxes_h'][:, :2] -= 1\n            target['boxes_o'][:, :2] -= 1\n        else:\n            target['labels'] = target['actions']\n            target['object'] = target.pop('objects')\n\n        image, target = self.transforms(image, target)\n\n        return image, target\n\nclass CacheTemplate(defaultdict):\n    \"\"\"A template for VCOCO cached results \"\"\"\n    def __init__(self, **kwargs):\n        super().__init__()\n        for k, v in kwargs.items():\n            self[k] = v\n    def __missing__(self, k):\n        seg = k.split('_')\n        # Assign zero score to missing actions\n        if seg[-1] == 'agent':\n            return 0.\n        # Assign zero score and a tiny box to missing <action,role> pairs\n        else:\n            return [0., 0., .1, .1, 0.]\n\nclass CustomisedDLE(DistributedLearningEngine):\n    def __init__(self, net, dataloader, max_norm=0, num_classes=117, **kwargs):\n        super().__init__(net, None, dataloader, **kwargs)\n        self.max_norm = max_norm\n        self.num_classes = num_classes\n\n    def _on_each_iteration(self):\n        loss_dict = self._state.net(\n            *self._state.inputs, targets=self._state.targets)\n\n        if loss_dict['interaction_loss'].isnan():\n            raise ValueError(f\"The HOI loss is NaN for rank {self._rank}\")\n\n        self._state.loss = sum(loss for loss in loss_dict.values())\n        self._state.optimizer.zero_grad(set_to_none=True)\n        self._state.loss.backward()\n        if self.max_norm > 0:\n            torch.nn.utils.clip_grad_norm_(self._state.net.parameters(), self.max_norm)\n        self._state.optimizer.step()\n\n    @torch.no_grad()\n    def test_hico(self, dataloader):\n        net = self._state.net\n        net.eval()\n\n        all_correct = []\n        verb_correct_obj_wrong = []\n        obj_correct_verb_wrong = []\n        obj_wrong_verb_wrong = []\n        all_wrong = []\n        missed = []\n\n        dataset = dataloader.dataset.dataset\n        associate = BoxPairAssociation(min_iou=0.5)\n        conversion = torch.from_numpy(np.asarray(\n            dataset.object_n_verb_to_interaction, dtype=float\n        ))\n\n        #test_anno = [0 for _ in range(len(dataset.anno_interaction))]\n        #test_anno[30] = 2\n        meter = DetectionAPMeter(\n            91 * 2, nproc=1,\n            #num_gt=test_anno,\n            num_gt=dataset.anno_interaction,\n            algorithm='11P'\n        )\n\n        for batch_idx, batch in tqdm(enumerate(dataloader)):\n            if batch_idx < 4:\n                continue\n\n            inputs = pocket.ops.relocate_to_cuda(batch[0])\n            #print(\"----\")\n            output = net(inputs)\n\n            # Skip images without detections\n            if output is None or len(output) == 0:\n                continue\n            # Batch size is fixed as 1 for inference\n            assert len(output) == 1, f\"Batch size is not 1 but {len(output)}.\"\n            output = pocket.ops.relocate_to_cpu(output[0], ignore=True)\n            output.pop(\"attn_maps\")\n            target = batch[-1][0]\n            # Format detections\n            boxes = output['boxes']\n            boxes_h, boxes_o = boxes[output['pairing']].unbind(0)\n            objects = output['objects']\n            scores = output['scores']\n            verbs = output['labels']\n            interactions = conversion[objects, verbs]\n            gt_bx_h = net.module.recover_boxes(target['boxes_h'], target['size'])\n            print(gt_bx_h)\n            gt_bx_o = net.module.recover_boxes(target['boxes_o'], target['size'])\n            print(gt_bx_o)\n            labels = torch.zeros_like(scores)\n            unique_hoi = interactions.unique()\n\n            for hoi_idx in unique_hoi:\n                gt_idx = torch.nonzero(target['hoi'] == hoi_idx).squeeze(1)\n                det_idx = torch.nonzero(interactions == hoi_idx).squeeze(1)\n                if len(gt_idx):\n                    labels[det_idx] = associate(\n                        (gt_bx_h[gt_idx].view(-1, 4),\n                        gt_bx_o[gt_idx].view(-1, 4)),\n                        (boxes_h[det_idx].view(-1, 4),\n                        boxes_o[det_idx].view(-1, 4)),\n                        scores[det_idx].view(-1)\n                    )\n            print(\".....\")\n            print(scores)\n            print(interactions)\n            print(labels)\n            meter.append(scores, interactions, labels)\n\n\n\n            inx = np.array([i for i in range(len(boxes_h)) if i % 2 == 0])\n            boxes_h_filter = boxes_h[inx]\n            boxes_o_filter = boxes_o[inx]\n            objects_filter = objects[inx]\n            scores_reshape = scores.reshape(-1, 2)\n\n            pred_hbox = []\n            pred_obox = []\n            pred_obj = []\n            pre_verb = []\n            pred_verb_score = []\n            for hbox, obox, score, obj in zip(boxes_h_filter, boxes_o_filter, scores_reshape, objects_filter.reshape(-1, 1)):\n                max_score, max_idx = torch.max(score, 0)\n                if max_score.item() > 0.1:\n                    pred_hbox.append(hbox)\n                    pred_obox.append(obox)\n                    pred_obj.append(obj.item())\n                    pre_verb.append(max_idx.item())\n                    pred_verb_score.append(score)\n\n            if len(pre_verb) == 0:\n                max_score, max_idx = torch.max(scores, 0)\n                pred_hbox.append(boxes_h[max_idx])\n                pred_obox.append(boxes_o[max_idx])\n                pred_obj.append(objects[max_idx].item())\n                pre_verb.append(max_idx.item() % 2)\n                pred_verb_score.append(scores[max_idx])\n            # Recover target box scale\n            all_correct.append(0)\n            verb_correct_obj_wrong.append(0)\n            obj_correct_verb_wrong.append(0)\n            obj_wrong_verb_wrong.append(0)\n            all_wrong.append(0)\n            for hbox, obox, verb, obj in zip(pred_hbox, pred_obox, pre_verb, pred_obj):\n                print(str(hbox) + \" - \" + str(obox) + \" :\" + str(obj) + \" - \" + str(verb))\n                found = False\n                for ghbox, gobox, gverb, gobj in zip(gt_bx_h, gt_bx_o, target[\"verb\"], target[\"object\"]):\n                    hbox_overlap = get_iou({\"x1\": hbox[0].item(), \"x2\": hbox[2].item(), \"y1\": hbox[1].item(), \"y2\": hbox[3].item()},\n                                           {\"x1\": ghbox[0].item(), \"x2\": ghbox[2].item(), \"y1\": ghbox[1].item(),\n                                            \"y2\": ghbox[3].item()})\n                    obox_overlap = get_iou({\"x1\": obox[0].item(), \"x2\": obox[2].item(), \"y1\": obox[1].item(), \"y2\": obox[3].item()},\n                                           {\"x1\": gobox[0].item(), \"x2\": gobox[2].item(), \"y1\": gobox[1].item(),\n                                            \"y2\": gobox[3].item()})\n\n                    if hbox_overlap > 0.5 and obox_overlap > 0.5:\n                        found = True\n                        if verb == gverb.item() and obj == gobj.item():\n                            all_correct[-1] += 1\n                        elif verb == gverb:\n                            verb_correct_obj_wrong[-1] += 1\n                        elif obj == gobj:\n                            obj_correct_verb_wrong[-1] += 1\n                        else:\n                            obj_wrong_verb_wrong[-1] += 1\n                        break\n                if not found:\n                    all_wrong[-1] += 1\n\n            missed.append(len(target[\"verb\"]) - sum([all_correct[-1], verb_correct_obj_wrong[-1], obj_correct_verb_wrong[-1], obj_wrong_verb_wrong[-1]]))\n            break\n        return meter.eval(), {\"all_correct\": sum(all_correct), \"verb_correct_obj_wrong\": sum(verb_correct_obj_wrong), \"obj_correct_verb_wrong\": sum(obj_correct_verb_wrong),\n                              \"obj_wrong_verb_wrong\": sum(obj_wrong_verb_wrong), \"all_wrong\": sum(all_wrong), \"missed\": sum(missed)}\n\n\n    @torch.no_grad()\n    def cache_hico(self, dataloader, cache_dir='matlab'):\n        net = self._state.net\n        net.eval()\n\n        dataset = dataloader.dataset.dataset\n        conversion = torch.from_numpy(np.asarray(\n            dataset.object_n_verb_to_interaction, dtype=float\n        ))\n        object2int = dataset.object_to_interaction\n\n        # Include empty images when counting\n        nimages = len(dataset.annotations)\n        all_results = np.empty((600, nimages), dtype=object)\n\n        for i, batch in enumerate(tqdm(dataloader)):\n            inputs = pocket.ops.relocate_to_cuda(batch[0])\n            output = net(inputs)\n\n            # Skip images without detections\n            if output is None or len(output) == 0:\n                continue\n            # Batch size is fixed as 1 for inference\n            assert len(output) == 1, f\"Batch size is not 1 but {len(output)}.\"\n            output = pocket.ops.relocate_to_cpu(output[0], ignore=True)\n            # NOTE Index i is the intra-index amongst images excluding those\n            # without ground truth box pairs\n            image_idx = dataset._idx[i]\n            # Format detections\n            boxes = output['boxes']\n            boxes_h, boxes_o = boxes[output['pairing']].unbind(0)\n            objects = output['objects']\n            scores = output['scores']\n            verbs = output['labels']\n            interactions = conversion[objects, verbs]\n            # Rescale the boxes to original image size\n            ow, oh = dataset.image_size(i)\n            h, w = output['size']\n            scale_fct = torch.as_tensor([\n                ow \/ w, oh \/ h, ow \/ w, oh \/ h\n            ]).unsqueeze(0)\n            boxes_h *= scale_fct\n            boxes_o *= scale_fct\n\n            # Convert box representation to pixel indices\n            boxes_h[:, 2:] -= 1\n            boxes_o[:, 2:] -= 1\n\n            # Group box pairs with the same predicted class\n            permutation = interactions.argsort()\n            boxes_h = boxes_h[permutation]\n            boxes_o = boxes_o[permutation]\n            interactions = interactions[permutation]\n            scores = scores[permutation]\n\n            # Store results\n            unique_class, counts = interactions.unique(return_counts=True)\n            n = 0\n            for cls_id, cls_num in zip(unique_class, counts):\n                all_results[cls_id.long(), image_idx] = torch.cat([\n                    boxes_h[n: n + cls_num],\n                    boxes_o[n: n + cls_num],\n                    scores[n: n + cls_num, None]\n                ], dim=1).numpy()\n                n += cls_num\n        \n        # Replace None with size (0,0) arrays\n        for i in range(600):\n            for j in range(nimages):\n                if all_results[i, j] is None:\n                    all_results[i, j] = np.zeros((0, 0))\n        if not os.path.exists(cache_dir):\n            os.makedirs(cache_dir)\n        # Cache results\n        for object_idx in range(80):\n            interaction_idx = object2int[object_idx]\n            sio.savemat(\n                os.path.join(cache_dir, f'detections_{(object_idx + 1):02d}.mat'),\n                dict(all_boxes=all_results[interaction_idx])\n            )\n\n    @torch.no_grad()\n    def cache_vcoco(self, dataloader, cache_dir='vcoco_cache'):\n        net = self._state.net\n        net.eval()\n\n        dataset = dataloader.dataset.dataset\n        all_results = []\n        for i, batch in enumerate(tqdm(dataloader)):\n            inputs = pocket.ops.relocate_to_cuda(batch[0])\n            output = net(inputs)\n\n            # Skip images without detections\n            if output is None or len(output) == 0:\n                continue\n            # Batch size is fixed as 1 for inference\n            assert len(output) == 1, f\"Batch size is not 1 but {len(output)}.\"\n            output = pocket.ops.relocate_to_cpu(output[0], ignore=True)\n            # NOTE Index i is the intra-index amongst images excluding those\n            # without ground truth box pairs\n            image_id = dataset.image_id(i)\n            # Format detections\n            boxes = output['boxes']\n            boxes_h, boxes_o = boxes[output['pairing']].unbind(0)\n            scores = output['scores']\n            actions = output['labels']\n            # Rescale the boxes to original image size\n            ow, oh = dataset.image_size(i)\n            h, w = output['size']\n            scale_fct = torch.as_tensor([\n                ow \/ w, oh \/ h, ow \/ w, oh \/ h\n            ]).unsqueeze(0)\n            boxes_h *= scale_fct\n            boxes_o *= scale_fct\n\n            for bh, bo, s, a in zip(boxes_h, boxes_o, scores, actions):\n                a_name = dataset.actions[a].split()\n                result = CacheTemplate(image_id=image_id, person_box=bh.tolist())\n                result[a_name[0] + '_agent'] = s.item()\n                result['_'.join(a_name)] = bo.tolist() + [s.item()]\n                all_results.append(result)\n\n        if not os.path.exists(cache_dir):\n            os.makedirs(cache_dir)\n        with open(os.path.join(cache_dir, 'cache.pkl'), 'wb') as f:\n            # Use protocol 2 for compatibility with Python2\n            pickle.dump(all_results, f, 2)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_648","text":"<filename>code\/lr_train.py\nimport torch\nimport torch.nn.functional as F\nfrom torch_geometric.datasets import Reddit\nfrom torch_geometric.data import ClusterData, ClusterLoader, Data\nfrom torch_geometric.nn import SAGEConv, GCNConv\n\nimport argparse, time, datetime, shutil\nimport sys, os, glob, json\n\nimport warnings\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport pandas as pd\nfrom sklearn.metrics import classification_report\nfrom sklearn.metrics import f1_score, recall_score, precision_score, accuracy_score\n\nfrom torch.utils.tensorboard import SummaryWriter\n\nimport nltk\nnltk.download('punkt')\nfrom torch.autograd import Variable\nimport torch.nn as nn\nfrom statistics import stdev\nimport sys\nsys.path.append(\"..\")\n\nfrom models.model import *\nfrom utils.utils import *\nfrom utils.data_utils_gnn import *\nfrom utils.data_utils_txt import *\nfrom utils.data_utils_hygnn import *\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n\n\n\n\nclass LR_model(torch.nn.Module):\n    def __init__(self, config):\n        super(LR_model, self).__init__()\n        self.text_dim = 1024 if config['text_encoder'] == 'roberta' else 384\n        self.graph_dim = config['graph_dim']\n        \n        if config['mode'] == 'gnn':\n            self.in_dim = self.graph_dim*3 if config['model_name'] in ['gat', 'rgat'] else self.graph_dim\n        elif config['mode'] == 'text':\n            self.in_dim = self.text_dim\n        else:\n            self.in_dim = self.graph_dim*3 if config['model_name'] == 'gat' else self.graph_dim\n            self.in_dim+=self.text_dim\n        self.classifier = nn.Linear(self.in_dim, config['n_classes'])\n            \n\n    def forward(self, x):\n        out = self.classifier(x)\n        return out\n    \n\nclass LR_Learner():\n    def __init__(self, config):\n        self.best_val_acc, self.best_val_f1, self.best_val_recall, self.best_val_precision = 0, 0, 0, 0\n        self.actual_best_f1 = 0\n        self.preds_list, self.labels_list = [] , []\n        self.train_f1, self.train_precision, self.train_recall, self.train_accuracy = 0,0,0,0\n        self.train_loss = []\n        self.threshold = 0\n        self.prev_val_loss, self.not_improved  = 0, 0\n        self.best_val_loss = 1e4\n        self.total_iters = 0\n        self.terminate_training = False\n        self.start_epoch, self.iters = 1, 0\n        self.preds, self.loss = 0, 0\n        self.start = time.time()\n         \n        self.model = LR_model(config)\n        if config['optimizer'] == 'Adam':\n            self.optimizer = torch.optim.AdamW(self.model.parameters(), lr = config['lr'], weight_decay = config['weight_decay'])\n        else:\n            self.optimizer = torch.optim.SGD(self.model.parameters(), lr = config['lr'], momentum = config['momentum'], weight_decay = config['weight_decay'])\n        self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=config['lr_decay_step'], gamma = config['lr_decay_factor'])\n        self.criterion = nn.BCELoss() if config['loss_func'] == 'bce' else nn.CrossEntropyLoss()\n        \n    \n    \n    def eval_lr(self, test = False):\n        self.model.eval()\n        preds_list, labels_list = [], []\n        docs_list = []\n        eval_loss = []\n        \n        loader = test_loader if test else val_loader\n        with torch.no_grad():\n            for iters, (batch_x, batch_y, doc) in enumerate(loader):\n                batch_x = Variable(batch_x)\n                batch_y = Variable(batch_y)         \n                preds = self.model(batch_x)\n                if config['loss_func'] == 'bce':\n                    preds = F.sigmoid(preds)\n                labels = batch_y.float()\n                # labels = batch_y.float()\n                preds = torch.where(torch.isnan(preds), torch.zeros_like(preds), preds)\n                loss = self.criterion(preds.to(device), labels.to(device))\n                eval_loss.append(loss.detach().item())\n                if config['loss_func'] == 'ce':\n                    preds = F.softmax(preds, dim=1)\n                    preds = torch.argmax(preds, dim=1)\n                else:\n                    preds = (F.sigmoid(preds)>0.5).type(torch.FloatTensor) if config['loss_func'] == 'bce_logits' else (preds>0.5).type(torch.FloatTensor)\n                preds_list.append(preds.cpu().detach().numpy())\n                labels_list.append(labels.cpu().detach().numpy())\n                docs_list.append(doc)\n\n                \n            preds_list = [pred for batch_pred in preds_list for pred in batch_pred]\n            labels_list = [label for batch_labels in labels_list for label in batch_labels]\n            docs_list = [doc for docs in docs_list for doc in docs]\n            # if test:\n            #     self.save_correct_preds(docs_list, preds_list, labels_list)\n            eval_loss = sum(eval_loss)\/len(eval_loss)\n            \n            if test:\n                print(classification_report(np.array(labels_list), np.array(preds_list)))\n            \n            if not test:\n                eval_f1, eval_macro_f1, eval_recall, eval_precision, eval_accuracy = evaluation_measures(config, np.array(preds_list), np.array(labels_list))\n                return eval_f1, eval_macro_f1, eval_precision, eval_recall, eval_accuracy, eval_loss\n            \n            else:\n                eval_f1, eval_macro_f1, eval_recall, eval_precision, eval_accuracy = evaluation_measures(config, np.array(preds_list), np.array(labels_list))\n                return eval_f1, eval_macro_f1, eval_precision, eval_recall, eval_accuracy, eval_loss\n                \n            \n    \n    \n    \n    \n    def save_correct_preds(self, docs, preds, labels):\n        print(len(preds), len(labels), len(docs))\n        idx_correct_preds = [idx for idx in range(len(preds)) if preds[idx]==labels[idx]]\n        correct_pred_docs = [docs[idx] for idx in range(len(docs)) if idx in idx_correct_preds]\n        print(len(correct_pred_docs))\n        temp_dict = {'correct_preds' : list(correct_pred_docs)}\n        model = 'roberta' if config['mode'] == 'text' else config['model_name']\n        dataname = config['data_name']\n        correct_doc_file = os.path.join('data', 'complete_data', dataname, 'cached_embeds', 'correct_docs_{}.json'.format(model))\n        \n        print(\"Saving the list of correct test preds in : \", correct_doc_file)\n        with open(correct_doc_file, 'w+') as j:\n            json.dump(temp_dict, j)\n        \n        \n    def train_epoch_step(self):\n        self.model.train()\n        lr = self.scheduler.get_lr()[0]\n        self.total_iters += self.iters\n        self.preds_list = [pred for batch_pred in self.preds_list for pred in batch_pred]\n        self.labels_list = [label for batch_labels in self.labels_list for label in batch_labels]\n\n        self.train_f1, self.train_macro_f1, self.train_recall, self.train_precision, self.train_accuracy = evaluation_measures(config, np.array(self.preds_list), np.array(self.labels_list))\n            \n        # Evaluate on dev set\n        self.eval_f1, self.eval_macro_f1, self.eval_precision, self.eval_recall, self.eval_accuracy, self.eval_loss = self.eval_lr()\n               \n        # print stats\n        print_stats(config, self.epoch, self.train_loss, self.train_accuracy, self.train_f1, self.train_precision, self.train_recall,\n                    self.eval_loss, self.eval_accuracy, self.eval_f1, self.eval_precision, self.eval_recall, self.start, lr)\n        \n\n        if self.eval_f1 > self.best_val_f1:\n            print(\"New High Score! Saving model...\")\n            self.best_val_f1 = self.eval_f1\n            self.best_val_acc = self.eval_accuracy\n            self.best_val_recall = self.eval_recall\n            self.best_val_precision = self.eval_precision\n            best_model = self.model.state_dict()\n            # Save the state and the vocabulary\n            torch.save({\n                'epoch': self.epoch,\n                'best_val_f1' : self.best_val_f1,\n                'model_state_dict': best_model,\n                # 'model_classif_state_dict': model.classifier.state_dict(),\n                'optimizer_state_dict': self.optimizer.state_dict(),\n            }, os.path.join(model_path, config['model_save_name']))\n            \n        \n        if self.epoch==1:\n            print(\"Saving model !\")\n            best_model = self.model.state_dict()\n            # Save the state and the vocabulary\n            torch.save({\n                'epoch': self.epoch,\n                'best_val_f1' : self.best_val_f1,\n                'model_state_dict': best_model,\n                # 'model_classif_state_dict': model.classifier.state_dict(),\n                'optimizer_state_dict': self.optimizer.state_dict(),\n            }, os.path.join(model_path, config['model_save_name']))\n            \n            \n        self.scheduler.step()\n        \n        \n        if self.eval_f1 - self.best_val_f1!=0 and self.eval_f1 - self.best_val_f1 < 1e-3:\n            self.not_improved+=1\n            print(self.not_improved)\n            if self.not_improved >= config['patience']:\n                self.terminate_training= True\n        else:\n            self.not_improved = 0\n        \n        if self.eval_f1 > self.best_val_f1 and self.eval_f1 - self.best_val_f1 > 1e-3:\n            self.best_val_f1 = self.eval_f1\n            self.not_improved=0        \n        \n        # if self.best_val_loss - self.eval_loss < 1e-3:\n        #     self.not_improved+=1\n        #     print(self.not_improved)\n        #     if self.not_improved >= config['patience']:\n        #         self.terminate_training= True\n        # else:\n        #     self.not_improved = 0\n        \n        # if self.eval_loss < self.best_val_loss and self.best_val_loss - self.eval_loss > 1e-3:\n        #     self.best_val_loss = self.eval_loss\n        #     self.not_improved = 0\n            \n            \n        self.preds_list = []\n        self.labels_list = []\n        \n        \n        \n        \n    def train_iters_step(self):\n        if config['loss_func'] == 'bce':\n            self.preds = F.sigmoid(self.preds)\n        \n        self.batch_labels = self.batch_y.float()\n        self.loss = self.criterion(self.preds.to(device),  self.batch_labels.to(device))\n\n        self.optimizer.zero_grad()\n        self.loss.backward()\n        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 5)\n        self.optimizer.step()\n\n        if config['loss_func'] == 'ce':\n            self.preds = F.softmax(self.preds, dim=1)\n            self.preds = torch.argmax(self.preds, dim=1)\n        elif config['loss_func'] == 'bce':\n            self.preds = (self.preds>0.5).type(torch.FloatTensor)\n        elif config['loss_func'] == 'bce_logits': \n            self.preds = F.sigmoid(self.preds)\n            self.preds = (self.preds>self.threshold).type(torch.FloatTensor).squeeze(1)\n            \n        self.preds_list.append(self.preds.cpu().detach().numpy())\n        self.labels_list.append(self.batch_labels.cpu().detach().numpy())\n\n        self.train_loss.append(self.loss.detach().item())\n        \n            \n            \n    def train_main(self):\n        print(\"\\n\\n\"+ \"=\"*100 + \"\\n\\t\\t\\t\\t\\t Training Network\\n\" + \"=\"*100)\n\n        # Seeds for reproduceable runs\n        torch.manual_seed(config['seed'])\n        torch.cuda.manual_seed(config['seed'])\n        np.random.seed(config['seed'])\n        random.seed(config['seed'])\n        torch.backends.cudnn.deterministic = True\n        torch.backends.cudnn.benchmark = False\n        \n        print(\"\\nBeginning training at:  {} \\n\".format(datetime.datetime.now()))\n        \n        for self.epoch in range(1, config['max_epoch']+1):\n            for self.iters, (batch_x, batch_y, doc) in enumerate(train_loader):\n                self.batch_x = Variable(batch_x)\n                self.batch_y = Variable(batch_y)\n                self.preds = self.model(self.batch_x)\n                # print(self.preds)\n                self.train_iters_step()\n            self.train_epoch_step()\n            if self.terminate_training:\n                    break\n\n        # Termination message\n        if self.terminate_training:\n            print(\"\\n\" + \"-\"*100 + \"\\nTraining terminated early because the Validation loss did not improve for   {}   epochs\" .format(config['patience']))\n        else:\n            print(\"\\n\" + \"-\"*100 + \"\\nMaximum epochs reached. Finished training !!\")\n        \n        print(\"\\n\" + \"-\"*50 + \"\\n\\t\\tEvaluating on test set\\n\" + \"-\"*50)\n        \n        if os.path.isfile(os.path.join(model_path, config['model_save_name'])):\n            checkpoint = torch.load(os.path.join(model_path, config['model_save_name']))\n            self.model.load_state_dict(checkpoint['model_state_dict'])\n            self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n        else:\n            raise ValueError(\"No Saved model state_dict found for the chosen model...!!! \\nAborting evaluation on test set...\".format(config['model_name']))\n            \n        \n        # Evaluate on dev set\n        test_f1, test_macro_f1, test_precision, test_recall, test_accuracy, test_loss = self.eval_lr(test=True)\n        \n        print_test_stats(test_accuracy, test_precision, test_recall, test_f1, test_macro_f1, self.best_val_acc, self.best_val_precision, self.best_val_recall, self.best_val_f1)\n        return test_f1, test_macro_f1, test_accuracy\n                \n        \n\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser()\n    # Required Paths\n    parser.add_argument('--data_path', type = str, default = '.\/data\/complete_data',\n                          help='path to dataset folder that contains the adj and feat matrices, etc')\n    parser.add_argument('--model_checkpoint_path', type = str, default = '.\/model_checkpoints_lr',\n                          help='Directory for saving trained model checkpoints')\n    parser.add_argument(\"--model_save_name\", type=str, default= 'best_model_lr.pt',\n                       help = 'saved model name')\n    \n    #### Training Params ####\n    \n    # Named params    \n    parser.add_argument('--data_name', type = str, default = 'gossipcop',\n                          help='dataset name: politifact \/ gossipcop \/ pheme \/ HealthRelease \/ HealthStory')\n    parser.add_argument('--model_name', type = str, default = 'HGCN',\n                          help='model name: gcn \/ graph_sage \/ graph_conv \/ gat \/ rgcn \/ HGCN')\n    parser.add_argument('--text_encoder', type = str, default = 'roberta',\n                          help='text encoder: cnn \/ roberta')\n    parser.add_argument('--mode', type=str, default='gnn+text',\n                        help='what features to use for classification: gnn \/ text \/ gnn+text')\n    parser.add_argument('--loss_func', type = str, default = 'bce',\n                        help = 'Loss function to use for optimization: bce \/ bce_logits \/ ce')\n    parser.add_argument('--scheduler', type = str, default = 'step',\n                        help = 'The type of lr scheduler to use anneal learning rate: step\/multi_step')\n    parser.add_argument('--optimizer', type = str, default = 'SGD',\n                        help = 'Optimizer to use for training')\n    \n    # Dimensions\/sizes params   \n    parser.add_argument('--batch_size', type = int, default = 16,\n                          help='batch size for training\"')\n    parser.add_argument('--graph_dim', type = int, default = 512,\n                          help='batch size for training\"')\n        \n    # Numerical params\n    parser.add_argument('--lr', type = float, default = 1e-3,\n                          help='Learning rate for training')\n    parser.add_argument('--weight_decay', type = float, default = 2e-3,\n                        help = 'weight decay for optimizer')\n    parser.add_argument('--momentum', type = float, default = 0.8,\n                        help = 'Momentum for optimizer')\n    parser.add_argument('--max_epoch', type = int, default = 50,\n                        help = 'Max epochs to train for')\n    parser.add_argument('--lr_decay_step', type = float, default = 3,\n                        help = 'No. of epochs after which learning rate should be decreased')\n    parser.add_argument('--lr_decay_factor', type = float, default = 0.8,\n                        help = 'Decay the learning rate of the optimizer by this multiplicative amount')\n    parser.add_argument('--patience', type = float, default = 10,\n                        help = 'Patience no. of epochs for early stopping')\n    parser.add_argument('--seed', type=int, default=168,\n                        help='set seed for reproducability')\n    \n    # Options params\n    parser.add_argument('--shuffle', type=bool, default=True,\n                        help='whether to shuffle batches')\n    \n    \n    \n    \n    args, unparsed = parser.parse_known_args()\n    config = args.__dict__\n\n    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n    config['device'] = device   \n\n    config['n_classes'] = 1             \n   \n    # Check all provided paths:    \n    model_path = os.path.join(config['model_checkpoint_path'], config['data_name'], config['model_name'])\n    \n    if not os.path.exists(config['data_path']):\n        raise ValueError(\"[!] ERROR: Dataset path does not exist\")\n    else:\n        print(\"\\nData path checked..\")\n    if not os.path.exists(model_path):\n        print(\"\\nCreating checkpoint path for saved models at:  {}\\n\".format(model_path))\n        os.makedirs(model_path)\n    else:\n        print(\"\\nModel save path checked..\")\n    \n    \n\n    # Print args\n    print(\"\\n\" + \"x\"*50 + \"\\n\\nRunning training with the following parameters: \\n\")\n    for key, value in config.items():\n        print(key + ' : ' + str(value))\n    print(\"\\n\" + \"x\"*50)\n    \n    # # Prepare dataset and iterators for training\n    # train_loader, val_loader, test_loader = prepare_lr_training(config)\n\n    seeds = [3, 21, 42, 84, 168]\n    # seeds = [3]\n    f1_list = []\n    macro_f1_list = []\n    acc_list = []\n    for seed in seeds:\n        config['seed']= 21\n        print(\"\\nseed= \", seed)\n        # Prepare dataset and iterators for training\n        prep_data = Prepare_Dataset(config)\n        train_loader, val_loader, test_loader = prep_data.prepare_lr_training(config, seed)\n        lr_model = LR_Learner(config)\n        f1, macro_f1, acc = lr_model.train_main()\n        f1_list.append(f1)\n        macro_f1_list.append(macro_f1)\n        acc_list.append(acc)\n        # sys.exit()\n    \n    print(f1_list)\n    print(\"\\nmean accuracy= \", sum(acc_list)\/len(acc_list))\n    print(\"std accuracy = \", stdev(acc_list))\n    print(\"\\nmean f1= \", sum(f1_list)\/len(f1_list))\n    print(\"std f1= \", stdev(f1_list))\n    print(\"\\nmean macro-f1= \", sum(macro_f1_list)\/len(macro_f1_list))\n    print(\"std macro-f1= \", stdev(macro_f1_list))\n        \n        \n    \n    # try:\n    #     lr_model = LR_Learner(config)\n    #     lr_model.train_main()\n    # except KeyboardInterrupt:\n    #     print(\"Keyboard interrupt by user detected...\\nClosing the tensorboard writer!\")\n    #     print(\"Best val f1 = \", lr_model.best_val_f1)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_649","text":"#!\/usr\/bin\/python\n\nprint(f'Loading {__file__}')\n\n### Andrei - importing channel access function - sprry for that DAMA :) 12 Dec 2019\n\nfrom bluesky.plan_stubs import one_1d_step, abs_set, wait, sleep\nimport time\nfrom collections import ChainMap\nimport bluesky.plans as bp\nimport matplotlib.ticker as mtick\nget_fields = db.get_fields\nget_images = db.get_images\nget_table = db.get_table\n\n\nfrom lmfit import  Model\nfrom lmfit import minimize, Parameters, Parameter, report_fit\nfrom scipy.special import erf\n\n# TODO: create a conda package for it and include to collection profiles\nimport peakutils\n\n\ndef get_scan(scan_id, debug=False):\n    \"\"\"Get scan from databroker using provided scan id.\nfrom Maksim\n    :param scan_id: scan id from bluesky.\n    :param debug: a debug flag.\n    :return: a tuple of scan and timestamp values.\n    \"\"\"\n    scan = db[scan_id]\n    #t = datetime.datetime.fromtimestamp(scan['start']['time']).strftime('%Y-%m-%d %H:%M:%S')\n    #t = dtt.datetime.fromtimestamp(scan['start']['time']).strftime('%Y-%m-%d %H:%M:%S')\n    t='N.A. conflicting with other macro'\n    if debug:\n        print(scan)\n    print('Scan ID: {}  Timestamp: {}'.format(scan_id, t))\n    return scan, t\n\ndef get_data(scan_id, field='ivu_gap', intensity_field='elm_sum_all', det=None, debug=False):\n    \"\"\"Get data from the scan stored in the table.\nfrom Maksim\n    :param scan_id: scan id from bluesky.\n    :param field: visualize the intensity vs. this field.\n    :param intensity_field: the name of the intensity field.\n    :param det: the name of the detector.\n    :param debug: a debug flag.\n    :return: a tuple of X, Y and timestamp values.\n    \"\"\"\n    scan, t = get_scan(scan_id)\n    if det:\n        imgs = get_images(scan, det)\n        im = imgs[-1]\n        if debug:\n            print(im)\n\n    table = get_table(scan)\n    fields = get_fields(scan)\n\n    if debug:\n        print(table)\n        print(fields)\n    x = table[field]\n    y = table[intensity_field]\n\n    return x, y, t\n\n\ndef ps(uid='-1',det='default',suffix='default',shift=.5,logplot='off', der  = False ):\n    '''\n    YG Copied from CHX beamline@March 18, 2018\n    function to determine statistic on line profile (assumes either peak or erf-profile)\n    calling sequence: uid='-1',det='default',suffix='default',shift=.5)\n    det='default' -> get detector from metadata, otherwise: specify, e.g. det='eiger4m_single'\n    suffix='default' -> _stats1_total \/ _sum_all, otherwise: specify, e.g. suffix='_stats2_total'\n    shift: scale for peak presence (0.5 -> peak has to be taller factor 2 above background)\n    '''\n    #import datetime\n    #import time\n    #import numpy as np\n    #from PIL import Image\n    #from databroker import db, get_fields, get_images, get_table\n    #from matplotlib import pyplot as pltfrom\n    #from lmfit import  Model\n    #from lmfit import minimize, Parameters, Parameter, report_fit\n    #from scipy.special import erf\n\n    # get the scan information:\n    if uid == '-1':\n        uid=-1\n    if det == 'default':\n        if db[uid].start.detectors[0] == 'elm' and suffix=='default':\n            intensity_field='elm_sum_all'\n        elif db[uid].start.detectors[0] == 'elm':\n            intensity_field='elm'+suffix\n        elif suffix == 'default':\n            intensity_field= db[uid].start.detectors[0]+'_stats4_total'\n        else:\n            intensity_field= db[uid].start.detectors[0]+suffix\n    else:\n        if det=='elm' and suffix == 'default':\n            intensity_field='elm_sum_all'\n        elif det=='elm':\n            intensity_field = 'elm'+suffix\n        elif suffix == 'default':\n            intensity_field=det+'_stats4_total'\n        else:\n            intensity_field=det+suffix\n\n    field = db[uid].start.motors[0]\n\n    #field='dcm_b';intensity_field='elm_sum_all'\n    [x,y,t]=get_data(uid,field=field, intensity_field=intensity_field, det=None, debug=False)  #need to re-write way to get data\n    x=np.array(x)\n    y=np.array(y)\n    #print(t)\n    if der:\n        y = np.diff( y )\n        x = x[1:]\n        \n    PEAK=x[np.argmax(y)]\n    PEAK_y=np.max(y)\n    COM=np.sum(x * y) \/ np.sum(y)\n\n    ### from Maksim: assume this is a peak profile:\n    def is_positive(num):\n        return True if num > 0 else False\n\n    # Normalize values first:\n    ym = (y - np.min(y)) \/ (np.max(y) - np.min(y)) - shift  # roots are at Y=0\n\n    positive = is_positive(ym[0])\n    list_of_roots = []\n    for i in range(len(y)):\n        current_positive = is_positive(ym[i])\n        if current_positive != positive:\n            list_of_roots.append(x[i - 1] + (x[i] - x[i - 1]) \/ (abs(ym[i]) + abs(ym[i - 1])) * abs(ym[i - 1]))\n            positive = not positive\n    if len(list_of_roots) >= 2:\n        FWHM=abs(list_of_roots[-1] - list_of_roots[0])\n        CEN=list_of_roots[0]+0.5*(list_of_roots[1]-list_of_roots[0])\n        ps.fwhm=FWHM\n        ps.cen=CEN\n        #return {\n        #    'fwhm': abs(list_of_roots[-1] - list_of_roots[0]),\n        #    'x_range': list_of_roots,\n       #}\n    else:    # ok, maybe it's a step function..\n        print('no peak...trying step function...')\n        ym = ym + shift\n        def err_func(x, x0, k=2, A=1,  base=0 ):     #### erf fit from Yugang\n            return base - A * erf(k*(x-x0))\n        mod = Model(  err_func )\n        ### estimate starting values:\n        x0=np.mean(x)\n        #k=0.1*(np.max(x)-np.m getattr(quadem, f\"current{i}\").mean_value.kind = \"hinted\"in(x))\n        pars  = mod.make_params( x0=x0, k=200,  A = 1., base = 0. )\n        result = mod.fit(ym, pars, x = x )\n        CEN=result.best_values['x0']\n        FWHM = result.best_values['k']\n        ps.cen = CEN\n        ps.fwhm = FWHM\n\n    ### re-plot results:\n    if logplot=='on':\n        plt.close(999)\n        plt.figure(999)\n        plt.semilogy([PEAK,PEAK],[np.min(y),np.max(y)],'k--',label='PEAK')\n        #plt.hold(True)\n        plt.semilogy([CEN,CEN],[np.min(y),np.max(y)],'r-.',label='CEN')\n        plt.semilogy([COM,COM],[np.min(y),np.max(y)],'g.-.',label='COM')\n        plt.semilogy(x,y,'bo-')\n        plt.xlabel(field);plt.ylabel(intensity_field)\n        plt.legend()\n        plt.title('uid: '+str(uid)+' @ '+str(t)+'\\nPEAK: '+str(PEAK_y)[:8]+' @ '+str(PEAK)[:8]+'   COM @ '+str(COM)[:8]+ '\\n FWHM: '+str(FWHM)[:8]+' @ CEN: '+str(CEN)[:8],size=9)\n        plt.show()\n    else:\n        plt.close(999)\n        plt.figure(999)\n        plt.plot([PEAK,PEAK],[np.min(y),np.max(y)],'k--',label='PEAK')\n        #plt.hold(True)\n        plt.plot([CEN,CEN],[np.min(y),np.max(y)],'r-.',label='CEN')\n        plt.plot([COM,COM],[np.min(y),np.max(y)],'g.-.',label='COM')\n        plt.plot(x,y,'bo-')\n        plt.xlabel(field);plt.ylabel(intensity_field)\n        plt.legend()\n        plt.title('uid: '+str(uid)+' @ '+str(t)+'\\nPEAK: '+str(PEAK_y)[:8]+' @ '+str(PEAK)[:8]+'   COM @ '+str(COM)[:8]+ '\\n FWHM: '+str(FWHM)[:8]+' @ CEN: '+str(CEN)[:8],size=9)\n        plt.show()\n\n    ### assign values of interest as function attributes:\n    ps.peak=PEAK\n    ps.com=COM\n    #return x, y \n\n\ndef set_abs_value(pv_prefix, abs_value):\n    \"\"\"\n    Use an absolute value for a PV\n    Input\n    ---\n    pv_prefix:string, the prefix of a pv, e.g., 'XF:12ID1-ES{XtalDfl-Ax:IH}' for XtalDfl IH\n    abs_value, float, the absolute value to be set\n   \n    Example:\n    set_abs_value( 'XF:12ID1-ES{XtalDfl-Ax:IH}', 0 ) #set diff.yv abolute value to 0\n    \"\"\"    \n    pv_set = EpicsSignal(pv_prefix + 'Mtr.VAL', name=\"pv_set\")\n    pv_use_button = EpicsSignal(pv_prefix + 'Mtr.SET', name=\"pv_use_button\")\n\n    yield from bps.mv(pv_use_button, 'Set')\n\n    old_val = pv_set.get()\n    yield from bps.mv(pv_set, abs_value)\n    yield from bps.mv(pv_use_button, 'Use')\n\n    print('The absolute value of %s was changed from %s to %s.'%(pv_set, old_val, abs_value))\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_650","text":"import config\nimport numpy as np\nimport pandas as pd\nfrom math import sqrt\nfrom scipy.io import FortranFile\n\nh = list(map(lambda r1, r2: sqrt(r2-r1), config.RADIUS1, config.RADIUS2))\n\ndef body_matrix(fileprefix):\n    table = pd.read_csv(f\"{config.MATPATH}\/{fileprefix}.table\", delim_whitespace=True)\n    M = table.shape[0]\n    y = table['residual']\n    error = table['error']\n    cor1 = table['ellipcor']\n    cor2 = table['crustcor']\n    \n    K = np.ndarray(shape=(M,config.N))\n    f = FortranFile(f\"{config.MATPATH}\/{fileprefix}.swp.mat\", 'r')\n    \n    for i in range(M):\n        mh = f.read_record(dtype='i4, a4, i4, i4')\n        (nrow, sta, yr, dat) = mh[0]\n        rin = f.read_record(dtype=np.float32)\n        kmat = f.read_record(dtype=np.int32)\n\n        row = np.zeros(config.N)\n        for j in range(nrow):\n            row[kmat[j]-1] = rin[j] \/ error.values[i]\n            # if is_thickness_to_weight: row[kmat[j]-1] \/= h[(kmat[j]-1)\/\/2578]\n        K[i][:] = row\n        # if i == 1:\n            # print(csr_matrix(row).nonzero())\n\n    residuals = (y.values[0:M]+cor1.values[0:M]+cor2.values[0:M])\/error.values[0:M]\n    residuals = np.reshape(residuals,(len(residuals),1))\n    return residuals, K\n\ndef surface_matrix(filenames):\n    K = np.ndarray(shape=(2578*len(filenames), config.N))\n    residuals = []\n\n    for i in range(len(filenames)):\n        f = FortranFile(f\"{config.MATPATH}\/{filenames[i]}\", 'r')\n        count = 0\n        while(1):\n            if count == 2578: break\n            mh = f.read_record(dtype='f4, f4, i4')\n            if not mh: break\n            (rem, res, nrow) = mh[0]\n            \n            rin = f.read_record(dtype=np.float32)\n            kmat = f.read_record(dtype=np.int32)\n\n            residuals.append(rem\/(2*res))\n\n            row = np.zeros(config.N)\n            for j in range(len(kmat)):\n            # for j in range(nrow):\n                row[kmat[j]-1] = rin[j] \/ (2*res)\n                # if is_thickness_to_weight: row[kmat[j]-1] \/= h[(kmat[j]-1)\/\/2578] \n            K[count + 2578*i] = row\n\n            count += 1\n\n    residuals = np.reshape(residuals,(len(residuals),1))\n    return residuals, K\n\ndef revert_h_weighting(m):\n    newm = [ m[j]\/h[j\/\/2578] for j in range(len(m))]\n    return np.array(newm)\n\ndef revert_c_weighting(m, c):\n    return m[:,0]\/c if len(m.shape)==2 else m[:]\/c\n\ndef createInputFile(A, filename):\n\n    f = FortranFile(filename, 'w')\n    if len(A.shape) == 2:\n        (M, N) = A.shape\n    else:\n        (M, N) = (len(A), 1)\n    f.write_record(int(M))\n    f.write_record(int(N))\n    # f.write_record(np.array([M,N], dtype=int))\n    # for val in A.flatten(order='F'):\n    #     f.write_record(float(val))\n    for i in range(N):\n        this_column = A[:,i] if N>1 else A[:]\n        this_column = np.array(this_column, dtype=np.float64)\n        f.write_record(this_column)\n\ndef readOutputFile(filename):\n    data = np.fromfile(filename, dtype='i4')\n    (M, N) = (data[0], data[1])\n    del data\n    data = np.fromfile(filename, dtype=np.float64)[1:].reshape(M, N, order='F')\n    return data"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_652","text":"\"\"\"\nCreated by anonymous author on 9\/16\/20\n\nAdapted from https:\/\/github.com\/vlukiyanov\/pt-dec\n\"\"\"\n\n\nimport numpy as np\nfrom scipy.optimize import linear_sum_assignment\n\nimport torch\nimport torch.nn as nn\nfrom torch.nn import Parameter\nfrom typing import Optional, Tuple\nfrom cross_loss_influence.data.scripts.generate_mog_data import MOGDataset\nfrom sklearn.cluster import KMeans\n\n\nclass ClusterAssignment(nn.Module):\n    def __init__(\n        self,\n        cluster_number: int,\n        embedding_dimension: int,\n        alpha: float = 1.0,\n        cluster_centers: Optional[torch.Tensor] = None,\n    ) -> None:\n        \"\"\"\n        Module to handle the soft assignment, for a description see in 3.1.1. in Xie\/Girshick\/Farhadi,\n        where the Student's t-distribution is used measure similarity between feature vector and each\n        cluster centroid.\n        :param cluster_number: number of clusters\n        :param embedding_dimension: embedding dimension of feature vectors\n        :param alpha: parameter representing the degrees of freedom in the t-distribution, default 1.0\n        :param cluster_centers: clusters centers to initialise, if None then use Xavier uniform\n        \"\"\"\n        super(ClusterAssignment, self).__init__()\n        self.embedding_dimension = embedding_dimension\n        self.cluster_number = cluster_number\n        self.alpha = alpha\n        if cluster_centers is None:\n            initial_cluster_centers = torch.zeros(\n                self.cluster_number, self.embedding_dimension, dtype=torch.float\n            )\n            # initial_cluster_centers = torch.rand((self.cluster_number, self.embedding_dimension), dtype=torch.float)\n            nn.init.xavier_uniform_(initial_cluster_centers)\n        else:\n            initial_cluster_centers = cluster_centers\n        self.cluster_centers = Parameter(initial_cluster_centers)\n\n    def forward(self, batch: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Compute the soft assignment for a batch of feature vectors, returning a batch of assignments\n        for each cluster.\n        :param batch: FloatTensor of [batch size, embedding dimension]\n        :return: FloatTensor [batch size, number of clusters]\n        \"\"\"\n        norm_squared = torch.sum((batch.unsqueeze(1) - self.cluster_centers) ** 2, 2)\n        numerator = 1.0 \/ (1.0 + (norm_squared \/ self.alpha))\n        power = float(self.alpha + 1) \/ 2\n        numerator = numerator ** power\n        return numerator \/ torch.sum(numerator, dim=1, keepdim=True)\n\n\nclass DEC(nn.Module):\n    def __init__(\n        self,\n        input_dim: int,\n        cluster_number: int,\n        hidden_dimension: int,\n        alpha: float = 1.0,\n    ):\n        \"\"\"\n        Module which holds all the moving parts of the DEC algorithm, as described in\n        Xie\/Girshick\/Farhadi; this includes the AutoEncoder stage and the ClusterAssignment stage.\n        :param cluster_number: number of clusters\n        :param hidden_dimension: hidden dimension, output of the encoder\n        :param encoder: encoder to use\n        :param alpha: parameter representing the degrees of freedom in the t-distribution, default 1.0\n        \"\"\"\n        super(DEC, self).__init__()\n        self.embedding_layers = nn.Sequential(\n            nn.Linear(input_dim, hidden_dimension),\n            nn.ReLU(),\n            nn.Linear(hidden_dimension, hidden_dimension)\n        )\n        self.hidden_dimension = hidden_dimension\n        self.cluster_number = cluster_number\n        self.alpha = alpha\n        self.assignment = ClusterAssignment(\n            cluster_number, self.hidden_dimension, alpha\n        )\n\n    def encode(self, data_in: torch.Tensor) -> torch.Tensor:\n        return self.embedding_layers(data_in)\n\n    def forward(self, data_in: torch.Tensor) -> torch.Tensor:\n        \"\"\"\n        Compute the cluster assignment using the ClusterAssignment after running the batch\n        through the encoder part of the associated AutoEncoder module.\n        :param batch: [batch size, embedding dimension] FloatTensor\n        :return: [batch size, number of clusters] FloatTensor\n        \"\"\"\n        embedded_data = self.embedding_layers(data_in)\n        return self.assignment(embedded_data)\n\n\ndef init_model(model_in: torch.nn.Module,\n               dataset_in: Tuple[torch.Tensor, torch.Tensor] = None,\n               device: str = 'cpu',\n               save: bool = True,\n               save_dir=None):\n    import os\n    from cross_loss_influence.config import MODEL_SAVE_DIR\n    if save_dir is not None:\n        model_save_path = save_dir\n    else:\n        model_save_path = MODEL_SAVE_DIR\n    model_fn = os.path.join(model_save_path, 'mog_model_init.pth.tar')\n    if save:\n        ds = MOGDataset(dataset_in)\n        num_clusters = len(np.unique(dataset_in[1]))\n\n        kmeans = KMeans(n_clusters=model_in.cluster_number, n_init=num_clusters)\n        model_in.train()\n        features = []\n        actual = []\n        # form initial cluster centres\n        for data, label in zip(dataset_in[0], dataset_in[1]):\n            if ds.kl:\n                label = torch.argmax(label)\n            actual.append(label.item())\n            data = data.to(device)\n            features.append(model_in.encode(data).detach().cpu())\n        predicted = kmeans.fit_predict(torch.stack(features).numpy())\n        cluster_centers = torch.tensor(\n            kmeans.cluster_centers_, dtype=torch.float, requires_grad=True, device=device\n        )\n        cluster_centers = cluster_centers + torch.randn(cluster_centers.size()).to(device)\/2.0\n        with torch.no_grad():\n            model_in.state_dict()[\"assignment.cluster_centers\"].copy_(cluster_centers)\n        torch.save({\n            'model':model_in.state_dict(),\n        }, model_fn)\n    else:\n        chk = torch.load(model_fn, map_location='cpu')\n        model_in.load_state_dict(chk['model'])\n    return model_in\n\n\ndef cluster_accuracy(y_true, y_predicted, cluster_number: Optional[int] = None):\n    \"\"\"\n    Calculate clustering accuracy after using the linear_sum_assignment function in SciPy to\n    determine reassignments.\n    :param y_true: list of true cluster numbers, an integer array 0-indexed\n    :param y_predicted: list  of predicted cluster numbers, an integer array 0-indexed\n    :param cluster_number: number of clusters, if None then calculated from input\n    :return: reassignment dictionary, clustering accuracy\n    \"\"\"\n    if cluster_number is None:\n        cluster_number = (\n            max(y_predicted.max(), y_true.max()) + 1\n        )  # assume labels are 0-indexed\n    count_matrix = np.zeros((cluster_number, cluster_number), dtype=np.int64)\n    for i in range(y_predicted.size):\n        count_matrix[y_predicted[i], y_true[i]] += 1\n\n    row_ind, col_ind = linear_sum_assignment(count_matrix.max() - count_matrix)\n    reassignment = dict(zip(row_ind, col_ind))\n    accuracy = count_matrix[row_ind, col_ind].sum() \/ y_predicted.size\n    return reassignment, accuracy\n\n\ndef target_distribution(batch: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Compute the target distribution p_ij, given the batch (q_ij), as in 3.1.3 Equation 3 of\n    Xie\/Girshick\/Farhadi; this is used the KL-divergence loss function.\n    :param batch: [batch size, number of clusters] Tensor of dtype float\n    :return: [batch size, number of clusters] Tensor of dtype float\n    \"\"\"\n    weight = (batch ** 2) \/ torch.sum(batch, 0)\n    return (weight.t() \/ torch.sum(weight, 1)).t()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_654","text":"<reponame>omangin\/multimodal<filename>multimodal\/lib\/sklearn_utils.py\n# Authors: <NAME> <<EMAIL>>\n#          <NAME> <<EMAIL>>\n#          <NAME> <<EMAIL>>\n#          <NAME> <<EMAIL>>\n#          <NAME>\n#          <NAME>\n#          <NAME>\n\n# These files where extracted from the scikit-learn project\n# (http:\/\/scikit-learn.org\/).\n\n# Scikit-learn is a Python module for machine learning built on top\n# of SciPy and distributed under the 3-Clause BSD license.\n\n# New BSD License\n#\n# Copyright (c) 2007--2013 The scikit-learn developers.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n#   a. Redistributions of source code must retain the above copyright notice,\n#      this list of conditions and the following disclaimer.\n#   b. Redistributions in binary form must reproduce the above copyright\n#      notice, this list of conditions and the following disclaimer in the\n#      documentation and\/or other materials provided with the distribution.\n#   c. Neither the name of the Scikit-learn Developers  nor the names of\n#      its contributors may be used to endorse or promote products\n#      derived from this software without specific prior written\n#      permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR\n# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH\n# DAMAGE.\n\n\nimport numpy as np\nfrom scipy import sparse\n\n\n# Source utils\/fixes.py\n\ndef safe_copy(X):\n        # Copy, but keep the order\n        return np.copy(X, order='K')\n\n\n# Source utils\/validation.py\n\ndef assert_all_finite(X):\n    \"\"\"Throw a ValueError if X contains NaN or infinity.\n\n    Input MUST be an np.ndarray instance or a scipy.sparse matrix.\"\"\"\n\n    # First try an O(n) time, O(1) space solution for the common case that\n    # there everything is finite; fall back to O(n) space np.isfinite to\n    # prevent false positives from overflow in sum method.\n    if X.dtype.char in np.typecodes['AllFloat'] and not np.isfinite(X.sum()) \\\n      and not np.isfinite(X.data if sparse.issparse(X) else X).all():\n            raise ValueError(\"array contains NaN or infinity\")\n\n\ndef array2d(X, dtype=None, order=None, copy=False):\n    \"\"\"Returns at least 2-d array with data from X\"\"\"\n    if sparse.issparse(X):\n        raise TypeError('A sparse matrix was passed, but dense data '\n                        'is required. Use X.todense() to convert to dense.')\n    X_2d = np.asarray(np.atleast_2d(X), dtype=dtype, order=order)\n    if X is X_2d and copy:\n        X_2d = safe_copy(X_2d)\n    return X_2d\n\n\ndef atleast2d_or_csr(X, dtype=None, order=None, copy=False):\n    \"\"\"Like numpy.atleast_2d, but converts sparse matrices to CSR format\n\n    Also, converts np.matrix to np.ndarray.\n    \"\"\"\n    if sparse.issparse(X):\n        # Note: order is ignored because CSR matrices hold data in 1-d arrays\n        if dtype is None or X.dtype == dtype:\n            X = X.tocsr()\n        else:\n            X = sparse.csr_matrix(X, dtype=dtype)\n    else:\n        X = array2d(X, dtype=dtype, order=order, copy=copy)\n    assert_all_finite(X)\n    return X\n\n\n# Source utils\/extmath.py\n\ndef safe_sparse_dot(a, b, dense_output=False):\n    \"\"\"Dot product that handle the sparse matrix case correctly\"\"\"\n    if sparse.issparse(a) or sparse.issparse(b):\n        ret = a * b\n        if dense_output and hasattr(ret, \"toarray\"):\n            ret = ret.toarray()\n        return ret\n    else:\n        return np.dot(a, b)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_655","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Jul 27 09:23:27 2021\n\n@author: gianni\n\"\"\"\n\n#for testing with pytest (just type \"pytest\" in the terminal)\n\nimport ionisation_photodissociation as ip\nimport numpy as np\nimport pytest\nfrom scipy import constants\nimport os\nimport itertools\n\n\nclass Test_ISF_scalings():\n\n    fields = [ip.DraineISF,ip.HabingField]\n\n    def test_scaling(self):\n        scalings = [lambda wavelength: 2, lambda wavelength: wavelength**2]\n        for field in self.fields:\n            unscaled_field = field()\n            for scaling in scalings:\n                scaled_field = field(scaling=scaling)\n                wavelength = unscaled_field.lambda_grid\n                expected_flux = unscaled_field.flux(wavelength=wavelength)\\\n                                              *scaling(wavelength=wavelength)\n                assert np.all(expected_flux == scaled_field.flux(wavelength=wavelength))\n\n\nclass Test_DraineISF():\n\n    def test_lambda_check(self):\n        isf = ip.DraineISF()\n        too_small_lambda = np.array((0.1*isf.lambda_min,0.5*isf.lambda_min))\n        too_large_lambda = np.array((1.01*isf.lambda_max,2*isf.lambda_max))\n        for lamb in (too_small_lambda,too_large_lambda):\n            assert np.all(isf.flux(lamb) == 0)\n\n\nclass Test_Habing():\n\n    def test_interpolation(self):\n        field = ip.HabingField()\n        out_of_range_lambda = np.array([90,2000])*constants.nano\n        for lamb in out_of_range_lambda:\n            assert field.flux(lamb) == 0\n        test_lamb = 650.2*constants.nano\n        test_energy = constants.h*constants.c\/test_lamb\n        expected_flux = 3.90754e+06*test_energy\/constants.centi**2\/constants.nano\n        assert np.isclose(field.flux(650.2*constants.nano),expected_flux,rtol=1e-6,atol=0)\n\n\ndef generate_test_atm():\n    atm = ip.StellarAtmosphere()\n    atm.lambda_grid = np.array([1,2.2,3.3,4.6])\n    atm.modelflux = np.array((10.2,20,40.4,90))\n    atm.ref_distance = 2\n    return atm\n\n\nclass Test_StellarAtmosphere():\n\n    atm = generate_test_atm()\n\n    def test_lamb_limits(self):\n        too_large_lamb = np.array((5,7))\n        too_small_lamb = np.array((0.1,0.9))\n        for lamb in (too_large_lamb,too_small_lamb):\n            assert np.all(self.atm.flux(wavelength=lamb,distance=1)==0)\n\n    def test_flux_interpolation(self):\n        assert self.atm.flux(wavelength=self.atm.lambda_grid[0],\n                             distance=self.atm.ref_distance)\\\n                                                   == self.atm.modelflux[0]\n        assert self.atm.flux(wavelength=self.atm.lambda_grid[0],\n                             distance=2*self.atm.ref_distance)\\\n                                                   == self.atm.modelflux[0]\/4\n\n    def test_luminosity(self):\n        expected_lum = np.trapz(self.atm.modelflux,self.atm.lambda_grid)\\\n                                *4*np.pi*self.atm.ref_distance**2\n        assert self.atm.luminosity() == expected_lum\n\n    def test_scaling(self):\n        scalings = [lambda wavelength: 3.5,\n                    lambda wavelength: wavelength**2]\n        for scaling in scalings:\n            test_atm = generate_test_atm()\n            original_model_flux = test_atm.modelflux.copy()\n            unscaled_flux = test_atm.flux(wavelength=test_atm.lambda_grid,\n                                          distance=test_atm.ref_distance)\n            test_atm._scale_spectrum(scaling=scaling)\n            scaling_factors = scaling(wavelength=test_atm.lambda_grid)\n            assert np.all(original_model_flux*scaling_factors==test_atm.modelflux)\n            scaled_flux = test_atm.flux(wavelength=test_atm.lambda_grid,\n                                        distance=test_atm.ref_distance)\n            assert np.all(unscaled_flux*scaling_factors==scaled_flux)\n            expected_luminosity = np.trapz(unscaled_flux*scaling_factors,\n                                           test_atm.lambda_grid)\\\n                                 *4*np.pi*test_atm.ref_distance**2\n            assert expected_luminosity == test_atm.luminosity()\n\n    def test_plot_model(self):\n        self.atm.plot_model()\n\n    def test_file_writing(self):\n        test_filepath = 'test.npz'\n        dist = 1*constants.au\n        self.atm.write_modelflux_to_file(filepath=test_filepath,distance=dist)\n        data = np.load(test_filepath)\n        assert np.all(data['wavelength']==self.atm.lambda_grid)\n        assert np.all(data['flux']\n                        ==self.atm.flux(wavelength=data['wavelength'],distance=dist))\n        os.remove(test_filepath)\n\n\ndef general_test_flux_scaling(unscaled_atm,atm_cls,atm_kwargs):\n    scalings = [lambda wavelength: 3,lambda wavelength: wavelength\/3]\n    dist = 1*constants.au\n    for scaling in scalings:\n        #make a copy in order not to modify atm_kwargs\n        scaled_atm_kwargs = atm_kwargs.copy()\n        scaled_atm_kwargs['scaling'] = scaling\n        scaled_atm = atm_cls(**scaled_atm_kwargs)\n        scaling_factors = scaling(wavelength=scaled_atm.lambda_grid)\n        assert np.all(unscaled_atm.modelflux*scaling_factors == scaled_atm.modelflux)\n        flux_kwargs = {'wavelength':scaled_atm.lambda_grid,'distance':dist}\n        unscaled_flux = unscaled_atm.flux(**flux_kwargs)\n        scaled_flux = scaled_atm.flux(**flux_kwargs)\n        assert np.allclose(scaling_factors*unscaled_flux,scaled_flux,rtol=1e-6,atol=0)\n        expected_lum = np.trapz(unscaled_flux*scaling_factors,unscaled_atm.lambda_grid)\\\n                                                               *4*np.pi*dist**2\n        assert np.isclose(expected_lum,scaled_atm.luminosity(),rtol=1e-6,atol=0)\n\nclass Test_ATLAS():\n\n    test_grid = np.array((1,2,3,4))\n    R_Sun = 6.955e8\n    template_init_kwargs = {'Teff':5780,'metallicity':-0.6,'logg':4.3,'Rstar':R_Sun,\n                            'calibration_spec':None,'verbose':True}\n    template_atm = ip.ATLASModelAtmosphere(**template_init_kwargs)\n\n    def test_grid_checking(self):\n        for value in (0,5):\n            with pytest.raises(AssertionError):\n                ip.ATLASModelAtmosphere.assert_within_grid(value=value,\n                                                           grid=self.test_grid)\n\n    def test_grid_searching(self):\n        values = np.array((0,2,2.9,7))\n        expected_grid_values = np.array((1,2,3,4))\n        for v,expec_v in zip(values,expected_grid_values):\n            grid_value = ip.ATLASModelAtmosphere.get_closest_grid_value(\n                                              value=v,grid=self.test_grid)\n            assert grid_value == expec_v\n\n    def test_bad_grid_values(self):\n        bad_init_kwargs = {'Teff':[2000,1e5],'metallicity':[-3,3],'logg':[-1,7]}\n        for kw,bad_values in bad_init_kwargs.items():\n            for v in bad_values:\n                kwargs = self.template_init_kwargs.copy()\n                kwargs[kw] = v\n                with pytest.raises(AssertionError):\n                    ip.ATLASModelAtmosphere(**kwargs)\n\n    def test_initialisation(self):\n        #test all None:\n        kwargs = self.template_init_kwargs.copy()\n        kwargs['Rstar'] = None\n        with pytest.raises(ValueError):\n            ip.ATLASModelAtmosphere(**kwargs)\n        #test 2x not None\n        for key in ('calibration_spec','obs_luminosity'):\n            kwargs = self.template_init_kwargs.copy()\n            assert kwargs['Rstar'] is not None\n            kwargs[key] = 1\n            with pytest.raises(AssertionError):\n                ip.ATLASModelAtmosphere(**kwargs)\n        #test 3x not None\n        kwargs = self.template_init_kwargs.copy()\n        assert kwargs['Rstar'] is not None\n        kwargs['calibration_spec'] = 1\n        kwargs['obs_luminosity'] = 1\n        with pytest.raises(AssertionError):\n            ip.ATLASModelAtmosphere(**kwargs)\n\n    def test_adopted_grid_values(self):\n        assert self.template_atm.Teff == 5750\n        assert self.template_atm.metallicity == -0.5\n        assert self.template_atm.logg == 4.5\n\n    def test_positive_metallicity(self):\n        kwargs = self.template_init_kwargs.copy()\n        kwargs['metallicity'] = 0.3\n        ip.ATLASModelAtmosphere(**kwargs)\n\n    def test_distance_scaling(self):\n        test_lamb = 700*constants.nano\n        assert self.template_atm.flux(wavelength=test_lamb,distance=1*constants.au)\\\n                == 4*self.template_atm.flux(wavelength=test_lamb,distance=2*constants.au)\n\n    def test_RJ_extrapolation(self):\n        atm = ip.ATLASModelAtmosphere(**self.template_init_kwargs)\n        test_lamb = 2*constants.milli\n        dist = 1*constants.au\n        RJ_flux = atm.flux(wavelength=test_lamb,distance=dist)\n        expected_flux = atm.modelflux[-1]*(atm.lambda_grid[-1]\/test_lamb)**4\\\n                         *(atm.ref_distance\/dist)**2\n        assert np.isclose(RJ_flux,expected_flux,rtol=1e-3,atol=0)\n\n    def test_calibration_with_luminosity(self):\n        test_lum = 3\n        test_kwargs = self.template_init_kwargs.copy()\n        test_kwargs[\"Rstar\"] = None\n        test_kwargs['obs_luminosity'] = test_lum\n        test_atm = ip.ATLASModelAtmosphere(**test_kwargs)\n        assert test_lum == test_atm.luminosity()\n\n    def test_calibration_with_spec(self):\n        ref_atm = ip.ATLASModelAtmosphere(**self.template_init_kwargs)\n        calibration_spec = {'wave':ref_atm.lambda_grid,'flux':ref_atm.modelflux\/2,\n                            'ref_distance':ref_atm.ref_distance}\n        kwargs = self.template_init_kwargs.copy()\n        kwargs['Rstar'] = None\n        kwargs['calibration_spec'] = calibration_spec\n        atm = ip.ATLASModelAtmosphere(**kwargs)\n        expected_scaling = 0.5\n        assert np.isclose(atm.spec_calibration_scaling,expected_scaling,rtol=1e-4,atol=0)\n\n    def test_flux_scaling(self):\n        general_test_flux_scaling(unscaled_atm=self.template_atm,\n                                  atm_cls=ip.ATLASModelAtmosphere,\n                                  atm_kwargs=self.template_init_kwargs)\n\n    def test_plot_model(self):\n        atm = ip.ATLASModelAtmosphere(**self.template_init_kwargs)\n        atm.plot_model()\n\n\nclass Test_betaPic():\n\n    betaPic = ip.betaPicObsSpectrum()\n\n    def test_flux_reading(self):    \n        test_lamb = 1327.75*constants.angstrom\n        expected_flux = 10**(1.65467e-001)*constants.erg\/constants.centi**2\/constants.angstrom\n        flux = self.betaPic.flux(wavelength=test_lamb,distance=1*constants.au)\n        assert expected_flux == flux\n\n    def test_dilution(self):\n        betaPic_diluted = ip.betaPicObsSpectrum(dilution=3)\n        assert self.betaPic.lambda_grid.size > betaPic_diluted.lambda_grid.size\n        betaPic_int = np.trapz(self.betaPic.modelflux,self.betaPic.lambda_grid)\n        betaPic_diluted_int = np.trapz(betaPic_diluted.modelflux,\n                                       betaPic_diluted.lambda_grid)\n        assert np.isclose(betaPic_int,betaPic_diluted_int,rtol=1e-3,atol=0)\n\n    def test_scaling(self):\n        general_test_flux_scaling(\n                     unscaled_atm=self.betaPic,atm_cls=ip.betaPicObsSpectrum,\n                     atm_kwargs={})\n\n    def test_plot_model(self):\n        self.betaPic.plot_model()\n\n\nclass Test_pd_cross_section():\n\n    cs = ip.PhotodissociationCrossSection('CO.hdf5')\n\n    def test_crosssection(self):\n        too_small_lamb = 5e-9\n        too_large_lamb = 1.8e-7\n        for lamb in (too_small_lamb,too_large_lamb):\n            assert self.cs.crosssection(lamb) == 0\n\n    def test_plot(self):\n        self.cs.plot()\n\n\ndef test_Osterbrock_ionisation_and_recombination():\n    for element in ip.ionisation_potential.keys():\n        ionisation = ip.OsterbrockIonisationCrossSection(element=element)\n        nu_min = ip.ionisation_potential[element]\/constants.h\n        lamb_max = constants.c\/nu_min\n        assert ionisation.crosssection(wavelength=10*lamb_max) == 0\n        recomb = ip.OsterbrockRecombination(element=element)\n        too_small_T, too_large_T = 7000, 16000\n        for T in (too_small_T,too_large_T):\n            with pytest.raises(AssertionError):\n                recomb.recombination_coeff(T)\n\n\ndef test_Nahar_ionisation_and_recombination():\n    for element,io_potential in ip.ionisation_potential.items():\n        ionisation = ip.NaharIonisationCrossSection(element=element)\n        non_ionising_wavelength = 1.1*constants.h*constants.c\/io_potential\n        assert ionisation.crosssection(non_ionising_wavelength) == 0\n        recomb = ip.NaharRecombination(element=element)\n        too_small_T, too_large_T = 1, 10e10\n        for T in (too_small_T,too_large_T):\n            with pytest.raises(AssertionError):\n                recomb.recombination_coeff(T)\n\n\nsolar_atmosphere = ip.ATLASModelAtmosphere(\n                          Teff=5780,metallicity=0.01,logg=4.43,Rstar=6.955e8)\n\ndef pd_crosssections_iterator():\n    for mol in ('CO','H2O','OH'):\n        yield ip.PhotodissociationCrossSection(f'{mol}.hdf5')\ndef io_crosssections_iterator():\n    for element in ('C','O'):\n        for cs in (ip.NaharIonisationCrossSection(element=element),\n                   ip.OsterbrockIonisationCrossSection(element=element)):\n            yield cs\nisf = ip.DraineISF()\n\n\nclass Test_rate():\n\n    def rate_iterator(self):\n        for crosssection in itertools.chain(pd_crosssections_iterator(),\n                                            io_crosssections_iterator()):\n            for atm in (solar_atmosphere,None):\n                rate = ip.Rate(stellar_atmosphere=atm,crosssection=crosssection)\n                yield crosssection,atm,rate\n\n    def test_lambda_grid_construction(self):\n        for crosssection,atm,rate in self.rate_iterator():\n            assert np.all(np.diff(rate.lambda_grid)>0)\n            assert np.all(np.unique(rate.lambda_grid) == rate.lambda_grid)\n            assert np.all(np.isin(isf.lambda_grid,rate.lambda_grid))\n            if hasattr(crosssection,'lambda_grid'):\n                assert np.all(np.isin(crosssection.lambda_grid,rate.lambda_grid))\n            if atm is not None:\n                assert np.all(np.isin(atm.lambda_grid,rate.lambda_grid))\n            if not hasattr(crosssection,'lambda_grid') and atm is None:\n                assert np.all(rate.lambda_grid==isf.lambda_grid)\n\n    def test_stellar_rate_distance_scaling(self):\n        for crosssection,atm,rate in self.rate_iterator():\n            if atm is not None:\n                assert rate.stellar_rate(distance=1*constants.au)\\\n                              == 4*rate.stellar_rate(distance=2*constants.au)\n\n    def test_stellar_rate_flux_scaling(self):\n        dist = 1*constants.au\n        scaling = lambda wavelength: 3.5\n        atm_kwargs = {'Teff':6000,'metallicity':0.01,'logg':4.2,'Rstar':7e8}\n        for crosssection in itertools.chain(pd_crosssections_iterator(),\n                                            io_crosssections_iterator()):\n            atm = ip.ATLASModelAtmosphere(**atm_kwargs)\n            original_rate = ip.Rate(stellar_atmosphere=atm,crosssection=crosssection)\n            original_stellar_rate = original_rate.stellar_rate(distance=dist)\n            scaled_atm = ip.ATLASModelAtmosphere(scaling=scaling,**atm_kwargs)\n            scaled_rate = ip.Rate(stellar_atmosphere=scaled_atm,crosssection=crosssection)\n            scaled_stellar_rate = scaled_rate.stellar_rate(distance=dist)\n            scaling_factors = scaling(wavelength=atm.lambda_grid)\n            assert np.isclose(scaled_stellar_rate,scaling_factors*original_stellar_rate,\n                              rtol=1e-6,atol=0)\n\n    def test_ISF_scaling(self):\n        scalar_scaling = 6.7\n        ISF_scaling = lambda wavelength: scalar_scaling\n        for crosssection,atm,rate in self.rate_iterator():\n            unscaled_isf_rate = rate.isf_rate\n            scaled_rate = ip.Rate(stellar_atmosphere=atm,crosssection=crosssection,\n                                  ISF_scaling=ISF_scaling)\n            assert np.isclose(scalar_scaling*unscaled_isf_rate,scaled_rate.isf_rate,\n                              rtol=1e-6,atol=0)\n\n    def test_rate(self):\n        for crosssection,atm,rate in self.rate_iterator():\n            rate.isf_rate\n            if atm is not None:\n                rate.stellar_rate(distance=1*constants.au)\n\n    def test_plot_print(self):\n        for crosssection,atm,rate in self.rate_iterator():\n            rate = ip.Rate(stellar_atmosphere=solar_atmosphere,\n                           crosssection=crosssection)\n            rate.plot_ISF_rate()\n            dist = 1*constants.au\n            rate.plot_stellar_rate(distance=dist)\n            rate.print_rates(distance=dist)\n\n\nclass Test_pd_and_io_rate():\n\n    def rate_iterator(self):\n        for crosssection in pd_crosssections_iterator():\n            for rate_cls in (ip.PhotodissociationRate,ip.IonisationRate):\n                rate = rate_cls(stellar_atmosphere=solar_atmosphere,\n                                crosssection=crosssection)\n            yield crosssection,rate\n\n    def test_total_rate(self):\n        for crosssection,rate in self.rate_iterator():\n            dist = 1*constants.au\n            stellar_rate = rate.stellar_rate(distance=dist)\n            if isinstance(rate,ip.PhotodissociationRate):\n                CR_rate = 0\n            elif isinstance(rate,ip.IonisationRate):\n                CR_rate = ip.IonisationRate.CR_ionisation_rate\n            tot_rate = rate.isf_rate + stellar_rate + CR_rate\n            assert rate.total_rate(distance=dist) == tot_rate\n\n    def test_print(self):\n        for crosssection,rate in self.rate_iterator():\n            rate = ip.PhotodissociationRate(stellar_atmosphere=solar_atmosphere,\n                                            crosssection=crosssection)\n            rate.print_rates(distance=1*constants.au)\n\n\nclass Test_ionisation_balance():\n\n    elements = ('C','O')\n    recombinations = [ip.NaharRecombination,ip.OsterbrockRecombination]\n    io_crosssections = [ip.NaharIonisationCrossSection,\n                        ip.OsterbrockIonisationCrossSection]\n\n    def io_balance_iterator(self):\n        for element in self.elements:\n            for recomb,io_cs in itertools.product(self.recombinations,\n                                                  self.io_crosssections):\n                recombination = recomb(element=element)\n                io_rate = ip.IonisationRate(crosssection=io_cs(element=element),\n                                            ISF_scaling=lambda wavelength: 1,\n                                            stellar_atmosphere=solar_atmosphere)\n                balance = ip.IonisationBalance(ionisation_rate=io_rate,\n                                               recombination=recombination)\n                yield balance\n\n    def test_balance_computations(self):\n        #don't know how to test this properly, so mostly just call all functions\n        #to make sure that they at least execute without throwing errors\n        n = 500\/constants.centi**3\n        n_ion = 300\/constants.centi**3\n        n_neutral = n-n_ion\n        n_e = 100\/constants.centi**3\n        distance = 100*constants.au\n        T = 8000\n        for balance in self.io_balance_iterator():\n            balance.get_ionisation_rate(distance=distance)\n            balance.get_recomb_coeff(T=T)\n            balance.determine_n_neutral(n_ion=n_ion,n_e=n_e,distance=distance,T=T)\n            n_neu_e_from_ion = balance.determine_n_neutral_e_from_ion(\n                                 n_ion=n_ion,distance=distance,T=T)\n            n_neu_e_from_ion_check = balance.determine_n_neutral(\n                                       n_ion=n_ion,n_e=n_ion,distance=distance,T=T)\n            assert n_neu_e_from_ion == n_neu_e_from_ion_check\n            balance.determine_n_ion(n_neutral=n_neutral,n_e=n_e,distance=distance,T=T)\n            n_ion_e_from_ion = balance.determine_n_ion_e_from_ion(\n                                  n_neutral=n_neutral,distance=distance,T=T)\n            n_ion_e_from_ion_check = balance.determine_n_ion(\n                                      n_neutral=n_neutral,n_e=n_ion_e_from_ion,\n                                      distance=distance,T=T)\n            assert np.isclose(n_ion_e_from_ion,n_ion_e_from_ion_check,rtol=1e-6,atol=0)\n            balance.determine_ionisation_balance(n=n,n_e=n_e,distance=distance,T=T)\n            balance.determine_ionisation_balance_e_from_ion(n=n,distance=distance,T=T)\n    \n    def test_ionisation_fraction(self):\n        for balance in self.io_balance_iterator():\n            assert balance.ionisation_fraction(n_neutral=0.3,n_ion=0.7) == 0.7\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_651","text":"from pyqm import *\nimport os, sys\nimport time\n\n### Parameters:\n\nnx = 500 #mesh size\nsigma = .4 #gaussian standard deviation\ndx = .01 #spatial resolution\nX = create1Dmesh(dx,nx)\nX = X.reshape(len(X),-1)\nT = 10 #number of timesteps\ndt = 1\/(2\/(dx**2)) #.08\n#python toolbox nibot crank-nicolson  ilikear\n\n## Hamiltonian\ndef potential(x): return renormalize(x**2)\nHamiltonian = -laplacematrix(dx,nx) #+ X*X\n\n### Time Evolution\ndef propagate(H,dt):\n    '''H must be a matrix in K basis'''\n    #return (1 - 1j * dt * H)\n    from scipy.linalg import expm \n    return matrix(expm(-1j*H))#* dt * H)\n    #return inv((1 + .5j * dt * H)) * (1 - .5j * dt * H)\n\ndef evolve(initial, t):\n    U = propagate(Hamiltonian,dt)\n    allvec = [initial]\n    for i in range(t):\n        #allvec.append(renormalize(U*allvec[i]))\n        allvec.append(U*allvec[i])\n    return allvec\n    #return [initial, U*initial, U*U*initial, U*U*U*initial]\n\n   \n### Actions\n\nInitial = renormalize(gaussian(X,sigma))\n#Initial = renormalize(sin(X))\n\nion()\namplitudes = map(abs,evolve(Initial,T))\nanimate1D(X,amplitudes)\n#waitforbuttonpress()\n\n\n#createvideo(amplitudes,plotsurface)\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_653","text":"import numpy as np\nimport scipy.signal\nimport scipy.interpolate\n\nfrom .filterfactory import (gammatone, asymmetric_compensation_coeffs, loggammachirp, erbspace)\nfrom .tools import sosfreqz\n\nNFFT = 2**16\n\ndef make_cgc_filter(freqs, compression_degree, level_max, level_step, sample_rate, dtype='float32'):\n    \"\"\"\n    \n    parameters\n    ----\n    \n    freqs: vector of central freqquencies Hz\n    \n    compression_degree: vector of compression degree for each freq with:\n        * 1=no compression impairement\n        * 0= maximum compression impairement\n    \n    returns\n    ---\n        \n        coefficients_pgc: sos coefficient of pgc filters shape is (freqs.size, 8, 6)\n        \n        coefficients_hpaf: sos coefficient of hpaf (level dependant). Filter shape is\n            (freqs.size, levels.size, 4, 6)\n        \n        levels: vector of levels.\n        \n        band_overlap_gain: gain for conpensating the overlap between bands. this depend\n          the number of band\n        \n    \n    \n    \n    \"\"\"\n    freqs = np.asarray(freqs)\n    compression_degree = np.asarray(compression_degree)\n    \n    nb_freq_band = len(freqs)\n    \n    # pgc filter coefficient\n    b1 = 1.81\n    c1 = -2.96\n    \n    # hpaf filter coefficient\n    b2 = 2.17\n    c2 = 2.2\n    \n    p0=2\n    p1=1.7818*(1-0.0791*b2)*(1-0.1655*abs(c2))\n    p2=0.5689*(1-0.1620*b2)*(1-0.0857*abs(c2))\n    p3=0.2523*(1-0.0244*b2)*(1+0.0574*abs(c2))\n    p4=1.0724\n\n    coefficients_pgc = loggammachirp(freqs, sample_rate, b=b1, c=c1).astype(dtype)\n    \n    #noramlize PGC to 0 db at maximum\n    #pcg_freqs = np.zeros_like(freqs)  #for testing\n    for f, freq in enumerate(freqs):\n        w, h = sosfreqz(coefficients_pgc[f,:,:], worN =2**16,)\n        gain = np.max(np.abs(h))\n        coefficients_pgc[f,0, :3] \/= gain\n        #pcg_freqs[f] = (w\/np.pi*(sample_rate\/2.))[np.argmax(np.abs(h))] #for testing\n    \n    # Construct hpaf filters : pre compute for all sound levels for each freq\n    levels = np.arange(0, level_max+level_step,level_step)\n    nlevel = levels.size\n    \n    # construct hpaf depending on compression_degree for each freq\n    coefficients_hpaf = np.zeros((nb_freq_band, len(levels), 4, 6), dtype = dtype)\n        \n    alpha = compression_degree\n    \n    # <NAME> coefficient (if this is correct)\n    # need to be check with irino\n    frat0r = 1 + 0.466 * (1-alpha)\n    frat1r =  - 0.0109 * (1-alpha)\n    \n    # <NAME> coefficient 2015\n    #~ w = (1-alpha) * 5 \/ 3\n    #~ frat1r = -w\/65\/2.\n    #~ frat0r = 1+w\/2.\n\n    # <NAME> coefficient 2016\n    #~ frat0r = 1 + (1-alpha)*1.3333\n    #~ frat1r = - (1-alpha) * 0.0205\n    \n    for l, level in enumerate(levels):\n        # minus for inverse compression = moving left\n        frat = frat0r + frat1r * level\n        freqs2 = freqs*frat\n        #freqs2 = pcg_freqs*frat #for testing\n        coefficients_hpaf[:, l, : , : ] = asymmetric_compensation_coeffs(freqs2, sample_rate, b2,c2,p0,p1,p2,p3,p4)\n    \n    #noramlize for highest level\n    for f, freq in enumerate(freqs):\n        #~ print('freq', freq)\n        filter = np.concatenate([coefficients_pgc[f,:,:], coefficients_hpaf[f , -1, : , : ],coefficients_pgc[f,:,:] ], axis = 0)\n        w, h = sosfreqz(filter, worN =NFFT)\n        gain = np.max(np.abs(h))\n        coefficients_hpaf[f , :, 0 , :3 ] \/= gain\n    \n    # compensate final gain of sum of all band freqs\n    all = np.zeros(NFFT)\n    for f, freq in enumerate(freqs):\n        #~ print('freq', freq)\n        all_filter = np.concatenate([coefficients_pgc[f,:,:],coefficients_hpaf[f,-1,:,:], coefficients_pgc[f,:,:]], axis = 0)\n        w, h = sosfreqz(all_filter,worN = NFFT)\n        all += np.abs(h) \n    \n    # check this\n    fft_freqs = w\/np.pi*(sample_rate\/2.)\n    #all = all[(fft_freqs>freqs[0]) & (fft_freqs<freqs[-1])] \n    \n    # this is bad because of side effect\n    #dbgain_final = -np.mean(20*np.log10(all))\n    \n    band_overlap_gain_db = -np.max(20*np.log10(all))\n    \n    band_overlap_gain = 10**(band_overlap_gain_db\/20.)\n    \n    #~ print('band_overlap_gain_db', band_overlap_gain_db)\n    \n    return coefficients_pgc, coefficients_hpaf, levels, band_overlap_gain\n\n\ndef make_invcomp_filter(freqs, compression_degree, level_max, level_step, sample_rate, dtype='float32'):\n    \"\"\"\n    Similar than make_cgc_filter except coefficients_hpaf is replace by gain_controlled.\n    \n    Used by the class InvComp.\n    \n    parameters\n    ----\n    \n    freqs: vector of central freqquencies Hz\n    \n    compression_degree: vector of compression degree for each freq with:\n        * 1=no compression impairement\n        * 0= maximum compression impairement\n    \n    returns\n    ---\n        \n        coefficients_pgc: sos coefficient of pgc filters shape is (freqs.size, 8, 6)\n        \n        gain_controlled: gain level dependant. Filter shape is (freqs.size, levels.size)\n        \n        levels: vector of levels.\n        \n        band_overlap_gain: gain for conpensating the overlap between bands. this depend\n          the number of band\n\n    Note that  for computing gain_controlled we use the same dynamic that InvCGC.\n    So internally HPAF is computed to extract the equivalent gain level controlled.\n    Also note than this HPAF is alwas done at 1000Hz because the gain response is\n    better in the middle of the spectrum.\n\n    \n    \"\"\"\n    freqs = np.asarray(freqs)\n    compression_degree = np.asarray(compression_degree)\n    \n    nb_freq_band = len(freqs)\n    \n    # pgc filter coefficient\n    b1 = 1.81\n    c1 = -2.96\n    \n    # hpaf filter coefficient\n    b2 = 2.17\n    c2 = 2.2\n    \n    p0=2\n    p1=1.7818*(1-0.0791*b2)*(1-0.1655*abs(c2))\n    p2=0.5689*(1-0.1620*b2)*(1-0.0857*abs(c2))\n    p3=0.2523*(1-0.0244*b2)*(1+0.0574*abs(c2))\n    p4=1.0724\n\n    coefficients_pgc = loggammachirp(freqs, sample_rate, b=b1, c=c1).astype(dtype)\n    \n    #noramlize PGC to 0 db at maximum\n    #pcg_freqs = np.zeros_like(freqs)  #for testing\n    for f, freq in enumerate(freqs):\n        w, h = sosfreqz(coefficients_pgc[f,:,:], worN =2**16,)\n        gain = np.max(np.abs(h))\n        coefficients_pgc[f,0, :3] \/= gain\n        #pcg_freqs[f] = (w\/np.pi*(sample_rate\/2.))[np.argmax(np.abs(h))] #for testing\n    \n    # Construct hpaf filters : pre compute for all sound levels for each freq\n    levels = np.arange(0, level_max+level_step,level_step)\n    nlevel = levels.size\n    \n    # construct hpaf depending on compression_degree for each freq\n    \n        \n    #for efficieny we compute only once each compression_degree for deifferent bands\n    _freqs = np.array([1000.])\n    pgc_1000Hz = loggammachirp(_freqs, sample_rate, b=b1, c=c1).astype(dtype)\n    pgc_1000Hz = pgc_1000Hz[0,:,:]\n    \n    w, h = sosfreqz(pgc_1000Hz, worN =2**16,)\n    gain = np.max(np.abs(h))\n    pgc_1000Hz[0, :3] \/= gain\n    hpaf_1000Hz = np.zeros((len(levels), 4, 6), dtype = dtype)\n    gain_controlled_by_alpha = {}\n    #~ print('all alpha', np.unique(compression_degree))\n    for alpha in np.unique(compression_degree):\n        print('alpha', alpha)\n        # Toshio Irino coefficient (if this is correct)\n        # need to be check with irino\n        frat0r = 1 + 0.466 * (1-alpha)\n        frat1r =  - 0.0109 * (1-alpha)\n        \n        for l, level in enumerate(levels):\n            print('level', level)\n            # minus for inverse compression = moving left\n            frat = frat0r + frat1r * level\n            freqs2 = _freqs*frat\n            #freqs2 = pcg_freqs*frat #for testing\n            hpaf_1000Hz[l,:,:] = asymmetric_compensation_coeffs(freqs2, sample_rate, b2,c2,p0,p1,p2,p3,p4)\n        \n        #noramlize for highest level\n        filter = np.concatenate([pgc_1000Hz, hpaf_1000Hz[-1, : , : ],pgc_1000Hz], axis = 0)\n        w, h = sosfreqz(filter, worN =NFFT)\n        gain = np.max(np.abs(h))\n        hpaf_1000Hz[:, 0 , :3 ] \/= gain\n        \n        gains = np.zeros(len(levels))\n        for l, level in enumerate(levels):\n            print('level', level)\n            filter = np.concatenate([pgc_1000Hz, hpaf_1000Hz[l, : , : ],pgc_1000Hz], axis = 0)\n            w, h = sosfreqz(filter, worN =NFFT)\n            #~ gains[l] = np.max(20*np.log10(np.abs(h)))\n            gains[l] = np.max(np.abs(h))\n        gain_controlled_by_alpha[alpha] = gains\n    \n    \n    \n    \n    #~ alpha = compression_degree\n    \n    \n    # <NAME> coefficient 2015\n    #~ w = (1-alpha) * 5 \/ 3\n    #~ frat1r = -w\/65\/2.\n    #~ frat0r = 1+w\/2.\n\n    # <NAME> coefficient 2016\n    #~ frat0r = 1 + (1-alpha)*1.3333\n    #~ frat1r = - (1-alpha) * 0.0205\n    \n    #~ for l, level in enumerate(levels):\n        # minus for inverse compression = moving left\n        #~ frat = frat0r + frat1r * level\n        #~ freqs2 = freqs*frat\n        #freqs2 = pcg_freqs*frat #for testing\n        #~ coefficients_hpaf[:, l, : , : ] = asymmetric_compensation_coeffs(freqs2, sample_rate, b2,c2,p0,p1,p2,p3,p4)\n    \n    #noramlize for highest level\n    #~ for f, freq in enumerate(freqs):\n        #~ filter = np.concatenate([coefficients_pgc[f,:,:], coefficients_hpaf[f , -1, : , : ],coefficients_pgc[f,:,:] ], axis = 0)\n        #~ w, h = sosfreqz(filter, worN =NFFT)\n        #~ gain = np.max(np.abs(h))\n        #~ coefficients_hpaf[f , :, 0 , :3 ] \/= gain\n    \n    gain_controlled = np.zeros((freqs.size, levels.size), dtype=dtype)\n    for f, freq in enumerate(freqs):\n        alpha = compression_degree[f]\n        gain_controlled[f, :] = gain_controlled_by_alpha[alpha]\n    \n    # compensate final gain of sum of all band freqs\n    all = np.zeros(NFFT)\n    for f, freq in enumerate(freqs):\n        all_filter = np.concatenate([coefficients_pgc[f,:,:], coefficients_pgc[f,:,:]], axis = 0)\n        w, h = sosfreqz(all_filter,worN = NFFT)\n        all += np.abs(h) \n    \n    # check this\n    fft_freqs = w\/np.pi*(sample_rate\/2.)\n    #all = all[(fft_freqs>freqs[0]) & (fft_freqs<freqs[-1])] \n    \n    # this is bad because of side effect\n    #dbgain_final = -np.mean(20*np.log10(all))\n    \n    band_overlap_gain_db = -np.max(20*np.log10(all))\n    \n    band_overlap_gain = 10**(band_overlap_gain_db\/20.)\n    \n    #~ print('band_overlap_gain_db', band_overlap_gain_db)\n    \n    return coefficients_pgc, gain_controlled, levels, band_overlap_gain\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_608","text":"#\n# Description: example of a bootstrapping and forward curve generation\n# script, this can be used to build a set of curves for different currencies\n# TODO: include some spline smoothing to the zero curve, from first principles!\n#\n\nfrom sympy.solvers import solve\nfrom sympy import Symbol, abs, Real\nx = Symbol('x', real=True)\n\nimport pylab as pylab\n\ndef g(yieldCurve, zeroRates,n, verbose):\n    '''\n        generates recursively the zero curve \n        expressions eval('(0.06\/1.05)+(1.06\/(1+x)**2)-1')\n        solves these expressions to get the new rate\n        for that period\n    \n    '''\n    if len(zeroRates) >= len(yieldCurve):\n        print(\"\\n\\n\\t+zero curve boot strapped [%d iterations]\" % (n))\n        return\n    else:\n        legn = ''\n        for i in range(0,len(zeroRates),1):\n            if i == 0:\n                legn = '%2.6f\/(1+%2.6f)**%d'%(yieldCurve[n], zeroRates[i],i+1)\n            else:\n                legn = legn + ' +%2.6f\/(1+%2.6f)**%d'%(yieldCurve[n], zeroRates[i],i+1)\n        legn = legn + '+ (1+%2.6f)\/(1+x)**%d-1'%(yieldCurve[n], n+1)\n        # solve the expression for this iteration\n        if verbose:\n            print(\"-[%d] %s\" % (n, legn.strip()))\n        rate1 = solve(eval(legn), x)\n        # Abs here since some solutions can be complex\n        rate1 = min([Real(abs(r)) for r in rate1])\n        if verbose:\n            print(\"-[%d] solution %2.6f\" % (n, float(rate1)))\n        # stuff the new rate in the results, will be \n        # used by the next iteration\n        zeroRates.append(rate1)\n        g(yieldCurve, zeroRates,n+1, verbose)\n        \nverbose = True\ntenors = [.1,.25,0.5,1,2,3,5,7,10,20,30]\n#\n# money market, futures, swap rates\n#\nyieldCurve = [0.07,\t0.09,\t0.15,\t0.21,\t0.37,\t0.57,\t1.13,\t1.70,\t2.31,\t3.08\t,3.41]\n\n#yieldCurve = [0.05, 0.06, 0.07, 0.08 ,0.085 ,0.0857 ,0.0901,0.0915,0.0925,0.0926,0.0934,0.0937]\nzeroRates = [yieldCurve[0]] # TODO: check that this is the correct rate\n\nprint(\"\\n\\n\\t<NAME>, March 2012\\n\\tYield Curve Bootstrapper\\n\\t<NAME>\\n\\n\")\n\n# kick off the recursive code\ng(yieldCurve, zeroRates, 1, verbose)\nprint(\"\\tZeroRate Array\",zeroRates)\n\npylab.plot(tenors,yieldCurve)\npylab.plot(tenors,zeroRates)\npylab.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_609","text":"<gh_stars>1-10\nimport torch\nimport cv2\nimport numpy as np\n\nfrom skimage.transform import PiecewiseAffineTransform, warp\nfrom scipy.ndimage.interpolation import map_coordinates\nfrom scipy.ndimage.filters import gaussian_filter\nfrom skimage import io, transform\nfrom PIL import Image\n\nclass Rescale(object):\n    \"\"\"Rescale the image in a sample to a given size.\n\n    Args:\n        output_size (tuple or tuple): Desired output size. If tuple, output is\n            matched to output_size. If int, smaller of image edges is matched\n            to output_size keeping aspect ratio the same.\n    \"\"\"\n\n    def __init__(self, output_size, keep_ratio=False):\n        self.output_size = output_size\n        self.keep_ratio = keep_ratio\n\n    def __call__(self, sample):\n        image = sample\n        image = np.array(image)\n\n        h, w = image.shape[:2]\n        if isinstance(self.output_size, int):\n            new_h, new_w = self.output_size, self.output_size * w \/ h\n            new_h, new_w = int(new_h), int(new_w)\n            img = cv2.resize(image,(new_w, new_h))\n        else:\n            if self.keep_ratio:\n                ratio = w\/h\n                img_h, img_w = self.output_size\n                new_h = img_h\n                new_w = min(img_w, new_h * ratio)\n                new_h, new_w = int(new_h), int(new_w)\n                img = cv2.resize(image,(new_w, new_h))\n                pad = img_w - new_w\n                # img = np.pad(img, ((0, 0),(0, pad)), 'maximum')\n                img = np.pad(img, ((0, 0),(0, pad)), 'constant', constant_values=(255, ))\n            else:\n                new_h, new_w = self.output_size\n                new_h, new_w = int(new_h), int(new_w)\n                img = cv2.resize(image,(new_w, new_h))\n        # print(img.shape)\n        # img = Image.fromarray(img)\n        return img\n\nclass ElasticTransformation(object):\n    \"\"\"ElasticTransformation the image in a sample to a given size.\n    Code adapted from https:\/\/www.kaggle.com\/bguberfain\/elastic-transform-for-data-augmentation\n\n    Reducing sigma increases distortion\n    increasing alpha increases distortion\n    \"\"\"\n    def __init__(self, prob, alpha=0.3, sigma=0.04, borderValue=255):\n        self.prob = prob\n        self.borderValue = borderValue\n        self.sigma = sigma\n        self.alpha = alpha\n\n    def __call__(self, sample):\n\n        image = np.array(sample)\n\n        if(np.random.rand()>self.prob):\n            return image\n        alpha = image.shape[0]*self.alpha\n        sigma = image.shape[0]*self.sigma\n        random_state = None\n\n        if random_state is None:\n            random_state = np.random.RandomState(None)\n\n        shape = image.shape\n        shape_size = shape[:2]\n        dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode='reflect',\n                                         cval=self.borderValue) * alpha\n        dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode='reflect',\n                                         cval=self.borderValue) * alpha\n\n        x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\n        indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))\n\n        newimage = map_coordinates(image, indices, order=1, mode='constant',\n                                         cval=self.borderValue).reshape(shape)\n        return newimage\n\n\n\nclass AffineTransformation(object):\n    \"\"\"AffineTransformation\n    \"\"\"\n    def __init__(self, prob, rotate=2, shear=0.5, borderValue=255):\n        self.prob = prob\n        self.borderValue = borderValue\n        self.rotate = rotate\n        self.shear = shear\n        assert shear <= 1, 'Max shear value is 1'\n\n    def __call__(self, sample):\n        image = np.array(sample)\n\n        if(np.random.rand()>self.prob):\n            return Image.fromarray(image)\n\n        rows, cols = image.shape\n        if(np.random.rand()<0.5):\n            rotAngle = np.random.randint(-self.rotate, self.rotate)\n\n            height, width = image.shape[:2]\n            image_center = (width\/2, height\/2)\n\n            rotation_mat = cv2.getRotationMatrix2D(image_center, rotAngle, 1.)\n\n            abs_cos = abs(rotation_mat[0,0])\n            abs_sin = abs(rotation_mat[0,1])\n\n            bound_w = int(height * abs_sin + width * abs_cos)\n            bound_h = int(height * abs_cos + width * abs_sin)\n\n            rotation_mat[0, 2] += bound_w\/2 - image_center[0]\n            rotation_mat[1, 2] += bound_h\/2 - image_center[1]\n\n            image = cv2.warpAffine(image, rotation_mat, (bound_w, bound_h), borderMode=cv2.BORDER_CONSTANT, borderValue=self.borderValue)\n\n        if(np.random.rand()<0.5):\n            shearAngle = -self.shear + np.random.rand()\n            M = np.array([[1.0,shearAngle,0.0],[0.0,1.0,0.0]])\n            image = cv2.warpAffine(image, M, (cols,rows), borderMode=cv2.BORDER_CONSTANT, borderValue=self.borderValue)\n        image = cv2.resize(image,(cols,rows))\n        return Image.fromarray(image)\n\n\nclass MultiScale(object):\n    def __init__(self, prob, scale_axis=2, scale_factor=2):\n        self.prob = prob\n        self.scale_axis = scale_axis\n        self.scale_factor = scale_factor\n\n    def __call__(self, sample):\n        image = sample\n        h, w = image.shape\n        if np.random.rand()>self.prob:\n            return image\n\n        colors_ = np.unique(image)\n        if np.max(colors_) >= 170:\n            color = colors_[colors_>=170].mean()\n        else:\n            color = 255\n        color = 255\n        nw = w\n        nh = h\n        if self.scale_axis == 0 or self.scale_axis == 2:\n            nw = w\/\/(2**np.random.randint(1, self.scale_factor))\n        if self.scale_axis == 1 or self.scale_axis == 2:\n            nh = h\/\/(2**np.random.randint(1, self.scale_factor))\n\n        rimage = cv2.resize(image, (nw, nh))\n        image = color*np.ones((h, w))\n        # print(image.shape, rimage.shape)\n        if self.scale_axis == 2:\n            nx = np.random.randint(3, w-nw)\n            ny = np.random.randint(3, h-nh)\n            image[ny:ny+nh, nx:nx+nw] = rimage\n        elif self.scale_axis == 0:\n            nx = np.random.randint(3, w-nw)\n            image[0:h, nx:nx+nw] = rimage\n        elif self.scale_axis == 1:\n            ny = np.random.randint(3, h-nh)\n            image[ny:ny+nh, 0:w] = rimage\n        return image\n\nclass PiecewiseAffine(object):\n    def __init__(self, prob, dfactor=10, pfactor=(0, 2)):\n        self.prob = prob\n        self.dfactor = dfactor\n        self.pfactor = pfactor\n\n    def __call__(self, sample):\n        image = sample\n        if np.random.rand()>self.prob:\n            return image\n\n        image = np.array(image)\n        rows, cols = image.shape[0], image.shape[1]\n        src_cols = np.linspace(0, cols, 4)\n        src_rows = np.linspace(0, rows, 2)\n        src_rows, src_cols = np.meshgrid(src_rows, src_cols)\n        src = np.dstack([src_cols.flat, src_rows.flat])[0]\n\n        dfactor = np.random.randint(10, 20)\n        pfactor = (np.random.randint(0, 3), np.random.randint(2, 4))\n        dst_rows = src[:, 1] - np.sin(np.linspace(pfactor[0]*np.pi\/2, pfactor[1]*np.pi, src.shape[0]))*dfactor\n        dst_cols = src[:, 0]\n        dst = np.vstack([dst_cols, dst_rows]).T\n\n        tform = PiecewiseAffineTransform()\n        tform.estimate(src, dst)\n        out_image = warp(image, tform, output_shape=(rows, cols), cval=255, preserve_range=True)\n        out_image = Image.fromarray(np.uint8(out_image))\n        return out_image\n\n\nclass Normalize(object):\n    \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n\n    def __call__(self, sample):\n        image = sample\n        image = (image-np.mean(image)) \/ ((np.std(image) + 0.0001) \/ 128.0)\n\n        return image\n\nclass ColorInvert(object):\n    \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n    def __init__(self, prob=0.5):\n        self.prob = prob\n\n    def __call__(self, sample):\n        image = sample\n\n        if np.random.rand()>self.prob:\n            return image\n\n        cnst = 255\n        image = cnst - image\n        return image\n\nclass ToTensor(object):\n    \"\"\"Convert arrays in sample to Tensors.\"\"\"\n\n    def __call__(self, sample):\n        image = np.array(sample)\n        image = torch.from_numpy(np.array(image))\n        image = image.float().sub(128).div(128)\n        image = image.unsqueeze(0)\n        return image\n\nclass NormalizedTensor(object):\n    def __call__(self, sample):\n        image = np.array(sample)\n        image = torch.from_numpy(np.array(image, dtype=np.double))\n        image.sub_(0.5).div_(0.5)\n        image = image.unsqueeze(0)\n        return image\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_610","text":"import numpy as np\r\nimport datetime, sys\r\nimport scipy.io\r\nimport pdb\r\nimport os\r\nimport cartopy.crs as ccrs\r\nimport cartopy.feature as cfeature\r\nfrom shapely.geometry import Polygon,Point\r\nimport scipy.interpolate\r\nimport xarray as xr\r\nimport matplotlib.pyplot as plt\r\nimport utilities.hfr_util\r\nimport pyproj\r\nfrom matplotlib import animation, rc\r\nplt.rcParams['animation.html'] = 'jshtml'\r\nanimation.rcParams['animation.embed_limit'] = 60\r\n\r\nclass TrackingModel(object):\r\n\r\n    def __init__(self):\r\n        self.minlon, self.maxlon, self.minlat, self.maxlat, self.resolution_km, self.url, self.days_to_capture, self.start_time = self.set_model_parameters(default=True)\r\n        self.current_dataset = self._get_HFR_subset()\r\n        self.lat = self.current_dataset['lat'].values\r\n        self.lon = self.current_dataset['lon'].values\r\n        self.x = np.arange(0, len(self.lon), 1) * 1850\r\n        self.y = np.arange(0, len(self.lat), 1) * 1995\r\n        self.x_grid, self.y_grid = np.meshgrid(self.x, self.y)\r\n        self.lon_grid, self.lat_grid = np.meshgrid(self.lon, self.lat)\r\n        self.origin = ccrs.UTM(zone=10).transform_point(self.lon[0], self.lat[0], ccrs.PlateCarree())\r\n        self.time_index = 0\r\n        self.hours_elapsed = 0\r\n        self.current_time = self.start_time\r\n        self.particles = np.array([])\r\n        self.time_step = .25\r\n\r\n\r\n    def set_model_parameters(self, default=False):\r\n        ''' Hotwire the default parameters for developement '''\r\n        crs = ccrs.PlateCarree() # Make cartopy projection object\r\n\r\n        resolution_km = 2\r\n        days_to_capture=3\r\n\r\n        if int(resolution_km)==2:\r\n            url='http:\/\/hfrnet-tds.ucsd.edu\/thredds\/dodsC\/HFR\/USWC\/2km\/hourly\/RTV\/HFRADAR_US_West_Coast_2km_Resolution_Hourly_RTV_best.ncd'\r\n        if int(resolution_km)==6:\r\n            url='http:\/\/hfrnet-tds.ucsd.edu\/thredds\/dodsC\/HFR\/USWC\/6km\/hourly\/RTV\/HFRADAR_US_West_Coast_6km_Resolution_Hourly_RTV_best.ncd'\r\n\r\n        if default:\r\n            year,month,day,hour,minu,secs = 2017,5,27,5,0,0\r\n            start_time = datetime.datetime(year,month,day,hour,minu,secs)\r\n            maxlat, minlat = 38.5, 37\r\n            maxlat=float(maxlat)\r\n            minlat=float(minlat)\r\n            minlon, maxlon = -123.5, -122\r\n            minlon=float(minlon)\r\n            maxlon=float(maxlon)\r\n\r\n        else:\r\n            try:\r\n                year,month,day,hour,minu,secs=input(\"Enter the start date [yr mn dy hr mn sc] \").split()\r\n            except ValueError:\r\n                print('Defaulting to 2017-05-27T05:00:00')\r\n                year,month,day,hour,minu,secs = 2017,5,27,5,0,0\r\n                start_time = datetime.datetime(year,month,day,hour,minu,secs)\r\n            #[year,month,day,hour,minu,secs]=input('Enter the start date [yr,mn,dy,hr,mn,sc]): ')\r\n            #[2017,5,27,5,0,0]\r\n            try:\r\n                maxlat,minlat=input('Enter the north and south boundary []: ').split()\r\n            except ValueError:\r\n                maxlat, minlat = 38.5, 37\r\n            maxlat=float(maxlat)\r\n            minlat=float(minlat)\r\n            # [38.5,37]\r\n            try:\r\n                minlon, maxlon=input('Enter the west and east boundary []: ').split()\r\n            except ValueError:\r\n                minlon, maxlon = -123.5, -122\r\n            minlon=float(minlon)\r\n            maxlon=float(maxlon)\r\n\r\n        return minlon, maxlon, minlat, maxlat, resolution_km, url, days_to_capture, start_time\r\n\r\n    def _get_HFR_subset(self):\r\n\r\n        \"\"\"\r\n        Open netcdf from hfrnet as xarray datase, subset the desired data in space and time\r\n        Currently, using global variables for parameters, should reduce as code becomes object-oriented\r\n\r\n        :return hfr_ds = xarray dataset over the specified spatial grid and time\r\n        \"\"\"\r\n        try:\r\n            ds = xr.open_dataset(self.url)\r\n        except Exception as e:\r\n            print(\"Trouble downloading data, check connections.\")\r\n            print(e)\r\n            sys.exit()\r\n\r\n        subset_ds = ds.sel(time = slice(self.start_time, self.start_time + datetime.timedelta(days=self.days_to_capture)),\r\n                      lat =  slice(self.minlat,self.maxlat),\r\n                      lon = slice(self.minlon,self.maxlon))\r\n        clean_u = hfr_util.interp_time_surface_currents(subset_ds['u'].values) # linear interpolate currents through time, given a threshold of availible data\r\n        clean_v = hfr_util.interp_time_surface_currents(subset_ds['v'].values)\r\n        subset_ds['u_clean'] =  xr.DataArray(clean_u, coords={'time': subset_ds['time'].values, 'lon': subset_ds['lon'].values, 'lat': subset_ds['lat'].values}, dims=['time','lat','lon'])\r\n        subset_ds['v_clean'] =  xr.DataArray(clean_v, coords={'time': subset_ds['time'].values, 'lon': subset_ds['lon'].values, 'lat': subset_ds['lat'].values}, dims=['time','lat','lon'])\r\n        return subset_ds\r\n\r\n    def add_particle(self, coord):\r\n        utm = ccrs.UTM(zone=10)\r\n        p_dist = utm.transform_point(coord[0], coord[1], ccrs.PlateCarree())\r\n        p_dist = [p_dist[0] - self.origin[0], p_dist[1] - self.origin[1]]\r\n        self.particles = np.append(self.particles, Particle(p_dist))\r\n\r\n    def part_to_coor(self, particle, last=False):\r\n        pc_proj = ccrs.PlateCarree()\r\n        p_dist = particle.coordinates\r\n        p_dist = [p_dist[:,0] + self.origin[0], p_dist[:,1] + self.origin[1]]\r\n        if last:\r\n            p_coor = pc_proj.transform_points(ccrs.UTM(zone=10), np.array((p_dist[:,-1])),np.array((p_dist[:,-1])))\r\n        else:\r\n            p_coor = pc_proj.transform_points(ccrs.UTM(zone=10), np.array([p_dist[:,0]]),np.array([p_dist[:,1]]))\r\n        p_coor = p_coor[:,:2]\r\n        return p_coor\r\n\r\n    def draw_map(self, draw_bathy=True, whole_extent=False):\r\n        ''' Draw a map of the domain '''\r\n\r\n        land_feature  = cfeature.NaturalEarthFeature('physical','land','10m')\r\n        self.fig = plt.figure()\r\n#        self.fig.set_size_inches(8,8)\r\n        self.geo_axes = plt.axes(projection=ccrs.PlateCarree())\r\n        if whole_extent:\r\n            extent = [self.minlon, self.maxlon, self.minlat, self.maxlat]\r\n        else:\r\n            extent = [-123, -122.3, 37.26, 38]\r\n        self.geo_axes.set_extent(extent, crs=ccrs.PlateCarree())\r\n        self.geo_axes.add_feature(land_feature, edgecolor='k', zorder=40)\r\n#        self.geo_axes.gridlines(draw_labels=True, zorder= 20)\r\n        if draw_bathy:\r\n            self._draw_bathymetry_SFBAY()\r\n\r\n\r\n    def _draw_bathymetry_SFBAY(self):\r\n        '''\r\n        Draw and return an axes with bathymetry contours\r\n\r\n        Bathy grid retrieved from: https:\/\/maps.ngdc.noaa.gov\/viewers\/wcs-client\/\r\n        '''\r\n        file = '.\/data\/SF_Bay_coastal_relief_model.nc'\r\n        bathy = xr.open_dataset(file)\r\n        blat = bathy['lat'].values\r\n        blon = bathy['lon'].values\r\n        elev = bathy['Band1'].values\r\n        levels = np.arange(10*(-2000\/\/10), -499, 450)\r\n        levels = np.append(levels, np.arange(-475, 25, 25))\r\n        lws = [0.5 if l%100 else 1 for l in levels]\r\n        cs = self.geo_axes.contour(blon, blat, elev, levels, linewidths=lws, linestyles='solid', colors=['black'], alpha=0.4)\r\n        plt.clabel(cs, list(np.arange(-125,1,25)),fmt='%1d', inline=True, fontsize=15, colors='k',inline_spacing=10)\r\n\r\n\r\n    def plot_particles(self, plot_type='all', save_dir):\r\n        \"\"\" \r\n        Make plots of the particle trajectories. Can make static plots, last locations, or animations\r\n        \"\"\"\r\n        if plot_type == 'last':\r\n            #Only if you want to plot the last position (debugging)\r\n            for p in self.particles[:]:\r\n                pos = self.part_to_coor(p, last=True)\r\n                self.geo_axes.scatter(pos[0,0],pos[0,1], zorder=50, marker='.', c='grey')\r\n        \r\n        \r\n        elif plot_type == 'animation':\r\n            # make animation of all the particle trajectories\r\n            Q = self.geo_axes.quiver(self.lon_grid, self.lat_grid, model.current_dataset['u_clean'].isel(time=0), model.current_dataset['v_clean'].isel(time=0), color='b', units='inches')\r\n            p = self.particles[0]\r\n            px, py = p.coordinates[:,0]+self.origin[0], p.coordinates[:,1]+self.origin[1]\r\n            line, = self.geo_axes.plot(px[0],py[0],\r\n                                       color='.75',\r\n                                       transform=ccrs.UTM(zone=10))\r\n            front_marker = self.geo_axes.scatter(px[0],py[0],\r\n                                                 color='b',\r\n                                                 s=10,\r\n                                                 transform=ccrs.UTM(zone=10))\r\n            tail_marker = self.geo_axes.scatter(px[0],py[0],\r\n                                                marker='x',\r\n                                                color='b',\r\n                                                s=10,\r\n                                                transform=ccrs.UTM(zone=10)) # last\r\n            line, = self.geo_axes.plot(px[0],py[0],\r\n                                       color='.75',\r\n                                       transform=ccrs.UTM(zone=10))\r\n            time_text = self.geo_axes.text(0.5, 1.05, 'Hours Before: ' + str(0), fontsize=16, transform=self.geo_axes.transAxes,zorder=300)\r\n            \r\n            def update_geoaxes(num, front_marker, tail_marker, line, Q, time_text):\r\n                \"\"\"\r\n                Animation function - updates the data of each plot at each\r\n                timestep and the hour textbox\r\n                \"\"\"\r\n                Q.set_UVC(model.current_dataset['u_clean'].isel(time=num\/\/4),model.current_dataset['v_clean'].isel(time=num\/\/4))\r\n                front_marker.set_offsets((px[num],py[num]))\r\n                if num == 0:\r\n                    tail = 0\r\n                    line.set_data(px[num], py[num])\r\n                \r\n                elif num <= 24:\r\n                    tail = 0\r\n                    line.set_data(px[tail:num], py[tail: num])\r\n                else:\r\n                    tail = num - 24\r\n                    line.set_data(px[tail:num], py[tail: num])\r\n\r\n                tail_marker.set_offsets((px[tail], py[tail]))\r\n                time_text.set_text('Hours Before: ' + str(num\/\/4))\r\n\r\n                return(front_marker, tail_marker, line, Q, time_text)\r\n            \r\n            anim = animation.FuncAnimation(self.fig,\r\n                                           update_geoaxes, fargs=(front_marker, tail_marker, line, Q, time_text),\r\n                                           interval=150,\r\n                                           blit=True,\r\n                                           frames=len(px))\r\n            Writer = animation.writers['ffmpeg']\r\n            writer = Writer(fps=15, metadata=dict(artist='<NAME>'), bitrate=1800)\r\n            anim.save('testing_traj.mp4', dpi=200, writer=writer)\r\n            \r\n            \r\n        elif plot_type == 'all':\r\n            for p in self.particles[:]:\r\n                self.geo_axes.plot(p.coordinates[:,0]+self.origin[0], p.coordinates[:,1]+self.origin[1],\r\n                                   zorder=50,\r\n                                   c='blue',\r\n                                   markerfacecolor='.5',\r\n                                   markeredgecolor='None',\r\n                                   marker='.',\r\n                                   markersize=5,\r\n                                   transform=ccrs.UTM(zone=10))\r\n        else:\r\n             raise ValueError(\"Plot type not valid.\")\r\n        \r\n    def advect_particle(self):\r\n        \"\"\"\r\n        Advect a particle object based on the current\r\n        Fixed timestep to 1\/4 hour --> If this is to be worked update self.timestep\r\n        \"\"\"\r\n        for p in self.particles:\r\n            current_pos = p.get_position()\r\n            if not np.any(np.isnan(current_pos)): # check if advection previously failed if so skip\r\n                new_x = self._solve_position(current_pos[0], current_pos[1], self.time_step, dim=0)\r\n                new_y = self._solve_position(current_pos[0], current_pos[1], self.time_step, dim=1)\r\n                p.update_position([new_x, new_y])\r\n        self.update_time()\r\n    \r\n    def update_time(self):\r\n        \"\"\"\r\n        Update the time_index and number of elapsed hours with each advection\r\n        \"\"\"\r\n        \r\n        self.hours_elapsed += self.time_step\r\n        self.time_index = int(self.hours_elapsed)\r\n\r\n    def _solve_position(self, x, y, h, dim):\r\n            \"\"\"\r\n            Solves for the next position of a particle in after time, h, in either the x\r\n            or y using a runge-kutta 4th order scheme.\r\n\r\n            TODO: Update function to get next half timestep if goes into next hour\r\n\r\n            Arguments\r\n            ---------\r\n            X, Y: mesh grid.\r\n            x, y: coordinates where to begin the evolution.\r\n            f: the current vector f that will be evolved.\r\n            h: the time step\r\n            dim: 0 for x and 1 for y.\r\n\r\n            Returns\r\n            ---------\r\n            interp_value: interpolated value of f(y,x)\r\n            \"\"\"\r\n            X = self.x_grid\r\n            Y = self.y_grid\r\n            if dim == 0:\r\n                f = self.current_dataset['u_clean'].isel(time=self.time_index).values * 60 * 60\r\n            if dim == 1:\r\n                f = self.current_dataset['v_clean'].isel(time=self.time_index).values * 60 * 60\r\n            try:\r\n                k1 = h * self.bilinear_interpolation(X, Y, f, x, y)\r\n                k2 = h * self.bilinear_interpolation(X, Y, f, x + 0.5 * h, y + 0.5 * k1)\r\n                k3 = h * self.bilinear_interpolation(X, Y, f, x + 0.5 * h, y + 0.5 * k2)\r\n                k4 = h * self.bilinear_interpolation(X, Y, f, x + h, y + k3)\r\n            except ValueError as e:\r\n                print('Error in Interpolation, trying to interpolate a NAN value')\r\n                print(e)\r\n                return\r\n            \r\n            try:\r\n                if dim == 0:\r\n                    return x + 1. \/ 6 * k1 + 1. \/ 3 * k2 + 1. \/ 3 * k3 + 1. \/ 6 * k4\r\n                elif dim == 1:\r\n                    return y + 1. \/ 6 * k1 + 1. \/ 3 * k2 + 1. \/ 3 * k3 + 1. \/ 6 * k4\r\n            except Exception as e:\r\n                print(e)\r\n                sys.exit()\r\n\r\n    def bilinear_interpolation(self, X, Y, f, x, y):\r\n        \"\"\"\r\n        Interpolation methods for estimating surface current values in between grid points. Edge cases are outlined in the\r\n        top of the function and may need to be refactored. NaNs is returned for cases where values can not be interpolated.\r\n\r\n        Arguments\r\n        ---------\r\n        X, Y: Coordinate mesh grid\r\n        f: Grid of velocity values that can be accessed as f(j,i) Remeber row, column\r\n        x, y: coordinates to compute interpolation to f(y,x)\r\n\r\n        Returns\r\n        ---------\r\n        interp_value: interpolated value of f(y,x)\r\n        \"\"\"\r\n\r\n        # Grid index shape\r\n        M = np.shape(X[:, 0])[0]\r\n        N = np.shape(X[0, :])[0]\r\n\r\n        dx, dy = X[0, 1] - X[0, 0], Y[1, 0] - Y[0, 0]\r\n        x_start, y_start = X[0, 0], Y[0, 0]\r\n\r\n        # Find the index of each value\r\n        i1, i2 = int((x - x_start) \/ dx), int((x - x_start) \/ dx) + 1\r\n        j1, j2 = int((y - y_start) \/ dy), int((y - y_start) \/ dy) + 1\r\n\r\n        # Boundary Conditions when interpolating near the edge.\r\n        # 1. Eastern boundary\r\n        if (i1 - N) > 1:\r\n            return np.nan\r\n        if i1 >= N - 1 and j1 <= N - 1 and j1 >= 0: # If on the Eastern edge of the boundary\r\n            return f[j1, N - 1]\r\n        if i1 >= N - 1 and j1 <= 0:\r\n            return f[0, N - 1]\r\n        if i1 >= N - 1 and j1 >= N - 1:\r\n            return f[N - 1, N - 1]\r\n\r\n        # 2. Western boundary\r\n        if i1 <= 0 and j1 <= N - 1 and j1 >= 0:\r\n            return f[j1, 0]\r\n        if i1 <= 0 and j1 <= 0:\r\n            return f[0, 0]\r\n        if i1 <= 0 and j1 >= N - 1:\r\n            return f[N - 1, 0]\r\n\r\n        # 3. Northern boundary\r\n        if j1 >= M - 1 and i1 <= M - 1 and i1 >= 0:\r\n            return f[M - 1, i1]\r\n        if j1 >= N - 1 and i1 <= 0:\r\n            return f[M - 1, 0]\r\n\r\n        # 3. Bottom boundary\r\n        if j1 <= 0 and i1 <= M - 1 and i1 >= 0:\r\n            return f[0, i1]\r\n        if j1 <= 0 and i1 >= M - 1:\r\n            return f[M - 1, 0]\r\n\r\n        x1, x2 = X[j1, i1], X[j2, i2]\r\n        y1, y2 = Y[j1, i1], Y[j2, i2]\r\n\r\n        interp_value = (1 \/ (x2 - x1) * 1 \/ (y2 - y1) *\r\n                          (f[j1, i1] * (x2 - x) * (y2 - y) + f[j1, i2] * (x - x1) * (y2 - y)\r\n                           + f[j2, i1] * (x2 - x) * (y - y1) + f[j2, i2] * (x - x1) * (y - y1)))\r\n\r\n        return interp_value\r\n\r\n    def seed_particles(self, center_coord, radius):\r\n        ''' Create a of cluster of particles within a radius in (km)'''\r\n\r\n        x_pos, y_pos = ccrs.UTM(zone=10).transform_point(center_coord[0],center_coord[1], ccrs.PlateCarree())\r\n        \r\n        col_num = [1,3,5,3,1]\r\n        dx = radius\/4 * 1000\r\n        ylevel = (np.arange(max(col_num)) - 3) * dx\r\n        for i, n in enumerate(col_num):\r\n            x = np.arange(n)\r\n            x = x - (n-1)\/2\r\n            x = x * dx\r\n            y = np.ones(shape=x.shape) * ylevel[i]\r\n            pos_x = x_pos + x\r\n            pos_y = y_pos + y\r\n            coors = ccrs.PlateCarree().transform_points(ccrs.UTM(zone=10), pos_x, pos_y)\r\n            x_coors = coors[:,0]\r\n            y_coors = coors[:,1]\r\n            for pos in zip(x_coors, y_coors):\r\n                self.add_particle(pos)\r\n        \r\n\r\n\r\nclass Particle(object):\r\n\r\n    def __init__(self,coord):\r\n        self.coordinates = np.array([coord])\r\n\r\n    def get_position(self):\r\n        ''' Return latest postion of particle class '''\r\n        return self.coordinates[-1,:]\r\n\r\n    def update_position(self, pos):\r\n        ''' Append to coord array '''\r\n        pos = np.array(pos)\r\n        self.coordinates = np.vstack((self.coordinates,pos))\r\n\r\n\r\n\r\n\r\nif __name__ == \"__main__\":\r\n    model = TrackingModel()\r\n    model.draw_map(draw_bathy=True)\r\n    # Debugging Particles\r\n    center_coord = [-122.6, 37.77]\r\n    model.seed_particles(center_coord, radius=3)  \r\n    ax = model.geo_axes\r\n#    ax.quiver(model.lon_grid, model.lat_grid, model.current_dataset['u_clean'].isel(time=0), model.current_dataset['v'].isel(time=0))\r\n    ix = np.where(np.isfinite(model.current_dataset['u_clean'].isel(time=0)))\r\n    ixnan = np.where(np.isnan(model.current_dataset['u_clean'].isel(time=0)))\r\n#    ax.scatter(model.lon_grid[ix], model.lat_grid[ix], marker='.', s=10)\r\n    ax.scatter(model.lon_grid[ixnan], model.lat_grid[ixnan], marker='x', s=10, c='r')\r\n#    \r\n    for i in range(24*4*3):\r\n        try:\r\n            model.advect_particle()\r\n            \r\n        except Exception as e:\r\n            print(e)\r\n            print(round(i\/4,2),'hours have passed before breaking')\r\n            break\r\n    model.plot_particles(plot_type='animation')\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_611","text":"<reponame>sandflow\/camdkit\n#!\/usr\/bin\/env python\n# -*- coding: UTF-8 -*-\n\n# Copyright (c) 2022, Sandflow Consulting LLC\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# 1. Redistributions of source code must retain the above copyright notice, this\n#    list of conditions and the following disclaimer.\n# 2. Redistributions in binary form must reproduce the above copyright notice,\n#    this list of conditions and the following disclaimer in the documentation\n#    and\/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\n# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n'''RED camera reader'''\n\nimport csv\nimport typing\nfrom fractions import Fraction\n\nimport camdkit.model\nimport camdkit.red.cooke as cooke\n\n_LENS_NAME_PIXEL_PITCH_MAP = {\n  \"RAPTOR 8K VV\": 5,\n  \"MONSTRO 8K VV\": 5,\n  \"KOMODO 6K S35\": 4.4,\n  \"HELIUM 8K S35\": 3.65,\n  \"GEMINI 5K S35\": 6,\n  \"DRAGON\": 5\n}\n\ndef to_clip(meta_3_file: typing.IO, meta_5_file: typing.IO) -> camdkit.model.Clip:\n  \"\"\"Read RED camera metadata into a `Clip`.\n  `meta_3_file`: Static camera metadata. CSV file generated using REDline (`REDline --silent --i {camera_file_path} --printMeta 3`)\n  `meta_5_file`: Per-frame camera metadata. CSV file generated using REDline (`REDline --silent --i {camera_file_path} --printMeta 5`)\n  \"\"\"\n\n  # read clip metadata\n  clip_metadata = next(csv.DictReader(meta_3_file))\n  clip = camdkit.model.Clip()\n\n  clip.set_iso(int(clip_metadata['ISO']))\n\n  clip.set_lens_serial_number(clip_metadata[\"Lens Serial Number\"])\n\n  clip.set_white_balance(int(clip_metadata[\"Kelvin\"]))\n\n  clip.set_sensor_pixel_dimensions(\n    camdkit.model.SensorPixelDimensions(\n      width=int(clip_metadata[\"Frame Width\"]),\n      height=int(clip_metadata[\"Frame Height\"])\n    )\n  )\n\n  pixel_pitch = _LENS_NAME_PIXEL_PITCH_MAP[clip_metadata[\"Sensor Name\"]]\n  pix_dims = clip.get_sensor_pixel_dimensions()\n  clip.set_sensor_physical_dimensions(\n    camdkit.model.SensorPhysicalDimensions(\n      width=round(pix_dims.width * pixel_pitch),\n      height=round(pix_dims.height * pixel_pitch)\n    )\n  )\n\n  # read frame metadata\n  csv_data = list(csv.DictReader(meta_5_file))\n\n  n_frames = int(clip_metadata[\"Total Frames\"])\n\n  if len(csv_data) != n_frames:\n    raise ValueError(f\"Inconsistent frame count between header {n_frames} and frame {len(csv_data)} files\")\n\n  clip.set_duration(len(csv_data)\/Fraction(clip_metadata[\"FPS\"]))\n\n  clip.set_fps(Fraction(clip_metadata[\"FPS\"]))\n\n  clip.set_focal_length(tuple(int(m[\"Focal Length\"]) * 1000 for m in csv_data))\n\n  clip.set_focal_position(tuple(int(m[\"Focus Distance\"]) * 1000 for m in csv_data))\n\n  cooke_metadata = tuple(cooke.from_binary_string(bytes(int(i, 16) for i in m[\"Cooke Metadata\"].split(\"\/\"))) for m in csv_data)\n\n  clip.set_entrance_pupil_position(m.entrance_pupil_position for m in cooke_metadata)\n\n  clip.set_iris_position(Fraction(m.aperture_value, 100) for m in cooke_metadata)\n\n  return clip\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_613","text":"#!\/opt\/anaconda\/bin\/python\r\n# -*- coding: utf-8 -*-\r\n# Unfortunately the `which` way of calling python can't accept command-line arguments.\r\n\"\"\"\r\nCreated on Mon Nov 03 16:13:48 2014\r\n\r\n@author: <NAME>\r\n@email: <EMAIL> OR <EMAIL>\r\n\r\nA selection of alignment routines designed for registering and summing stacks \r\nof images or diffraction patterns in the field of electron microscopy.\r\n\"\"\"\r\nfrom __future__ import division, print_function, absolute_import, unicode_literals\r\n\r\nimport numpy as np\r\nif np.version.version.split('.')[1] == 7:\r\n    print( \"WARNING: NUMPY VERSION 1.7 DETECTED, ZORRO IS DESIGNED FOR >1.10\" )\r\n    print( \"CHECK YOUR ENVIRONMENT VARIABLES TO SEE IF EMAN2 HAS HIJACKED YOUR PYTHON DISTRIBUTION\" )\r\n    \r\nimport numexprz as nz\r\n# Now see which numexpr we have, by the dtype of float (whether it casts or not)\r\ntry:\r\n    # Now see which numexpr we have, by the dtype of float (whether it casts or not)\r\n    tdata = np.complex64( 1.0 + 2.0j )\r\n    fftw_dtype = nz.evaluate( 'tdata + tdata' ).dtype\r\n    float_dtype = nz.evaluate( 'real(tdata+tdata)' ).dtype\r\nexcept: \r\n    fftw_dtype = 'complex128'\r\n    float_dtype = 'float64'\r\n\r\n\r\nimport scipy.optimize\r\nimport scipy.ndimage\r\nimport scipy.stats\r\nimport time\r\ntry:\r\n    import ConfigParser as configparser\r\nexcept:\r\n    import configparser # Python 3\r\n\r\n# Here we have to play some games depending on where the file was called from\r\n# with the use of absolute_import\r\n# print( \"__name__ of zorro: \" + str(__name__) )\r\ntry:\r\n    import zorro_util as util\r\n    import zorro_plotting as plot\r\nexcept ImportError:\r\n    from . import zorro_util as util\r\n    from . import zorro_plotting as plot\r\n    \r\nimport mrcz\r\n    \r\nimport os, os.path, tempfile, sys\r\nimport subprocess\r\n\r\n# Should we disable Multiprocessing on Windows due to general bugginess in the module?\r\nimport multiprocessing as mp\r\n\r\ntry:\r\n    import pyfftw\r\nexcept:\r\n    print( \"Zorro did not find pyFFTW package: get it at https:\/\/pypi.python.org\/pypi\/pyFFTW\" )\r\ntry:\r\n    import tables\r\nexcept:\r\n    print( \"Zorro did not find pyTables installation for HDF5 file support\" )\r\nimport matplotlib.pyplot as plt\r\n\r\n# Numpy.pad is bad at dealing with interpreted strings\r\nif sys.version_info >= (3,0):\r\n    symmetricPad = u'symmetric'\r\n    constantPad = u'constant'\r\nelse: \r\n    symmetricPad = b'symmetric'\r\n    constantPad = b'constant'\r\n\r\n#### OBJECT-ORIENTED INTERFACE ####\r\nclass ImageRegistrator(object):\r\n# Should be able to handle differences in translation, rotation, and scaling\r\n# between images\r\n    \r\n    def __init__( self ):\r\n        # Declare class members\r\n        self.verbose = 0\r\n        self.umask = 2\r\n        \r\n        # Meta-information for processing, not saved in configuration files.\r\n        self.METApriority = 0.0\r\n        self.METAstatus = u'new'\r\n        self.METAmtime = 0.0\r\n        self.METAsize = 0\r\n        \r\n        self.xcorrMode = 'zorro' # 'zorro', 'unblur v1.02', 'motioncorr v2.1'\r\n        # FFTW_PATIENT is bugged for powers of 2, so use FFTW_MEASURE as default\r\n        self.fftw_effort = u\"FFTW_MEASURE\"\r\n        # TODO: change this to drop into cachePath\r\n        \r\n        self.n_threads = nz.nthreads # Number of cores to limit FFTW to, if None uses all cores \r\n        self.cachePath = tempfile.gettempdir()\r\n          \r\n        # CALIBRATIONS\r\n        self.pixelsize = None # Typically we use nanometers, the same units as Digital Micrograph\r\n        self.voltage = 300.0 # Accelerating voltage, kV\r\n        self.C3 = 2.7 # Spherical aberration of objective, mm\r\n        self.gain = None\r\n        self.detectorPixelSize = None # Physical dimensions of detector pixel (5 um for K2)\r\n\r\n        # Timings\r\n        self.bench = {} # Dict holds various benchmark times for the code\r\n        self.saveC = False # Save the cross-correlation within +\/- maxShift\r\n        \r\n        # INFORMATION REDUCTION\r\n        # The SNR at high spatial frequencies tends to be lower due to how information transfer works, so \r\n        # removing\/filtering those frequencies can improve stability of the registration.  YMMV, IMHO, etc.\r\n        \r\n        self.Brad = 512 # Gaussian low-pass applied to data before registration, units are radius in Fourier space, or equivalent point-spread function in real-space\r\n        self.Bmode = u'opti' # can be a real-space Gaussian convolution, 'conv' or Fourier filter, 'fourier', or 'opti' for automatic Brad\r\n        # For Bmode = 'fourier', a range of available filters can be used: gaussian, gauss_trunc, butterworth.order (order is an int), hann, hamming\r\n        self.BfiltType = u'gaussian'\r\n        self.fouCrop = [3072,3072] # Size of FFT in frequency-space to crop to (e.g. [2048,2048])\r\n        self.reloadData = True\r\n        \r\n        # Data\r\n        self.images = None\r\n        self.imageSum = None\r\n        self.filtSum = None # Dose-filtered, Wiener-filtered, etc. representations go here\r\n        self.gainRef = None # For application of gain reference in Zorro rather than Digital Micrograph\/TIA\/etc.\r\n        self.gainInfo = { \r\n            \"Horizontal\": True, \"Vertical\": True, \"Diagonal\":False,\r\n            \"GammaParams\": [ 0.12035633, -1.04171635, -0.03363192,  1.03902726],\r\n        }\r\n        \r\n        # One of None,  'dose', 'dose,background', 'dosenorm', 'gaussLP', 'gaussLP,background'\r\n        # also 'hot' can be in the comma-seperated list for pre-filtering of hot pixels\r\n        self.filterMode = None \r\n        # Dose filt param = [dosePerFrame, critDoseA, critDoseB, critDoseC, cutoffOrder, missingStartFrame]\r\n        self.doseFiltParam = [None, 0.24499, -1.6649, 2.8141, 32, 0]\r\n        # for 'hot' in filterMode\r\n        self.hotpixInfo = { u\"logisticK\":6.0, u\"relax\":0.925, u\"maxSigma\":8.0, u\"psf\": u\"K2\",\r\n                           u\"guessHotpix\":0, u\"guessDeadpix\":0, u\"decorrOutliers\":False,\r\n                           u\"cutoffLower\":-4.0, u\"cutoffUpper\":3.25, u\"neighborPix\":0 }\r\n        \r\n        \r\n        self.FFTSum = None\r\n        # If you want to use one mask, it should have dims [1,N_Y,N_X]. This is \r\n        # to ensure Cythonized code can interact safely with Numpy\r\n        self.incohFouMag = None # Incoherent Fourier magnitude, for CTF determination, resolution checks\r\n        self.masks = None\r\n        self.maskSum = None\r\n        self.C = None\r\n        \r\n        # Results\r\n        self.translations = None\r\n        self.transEven = None # For even-odd tiled FRC, the half-stack translations\r\n        self.transOdd = None # For even-odd tiled FRC, the half-stack translations\r\n        self.velocities = None # pixel velocity, in pix\/frame, to find frames that suffer from excessive drift\r\n        self.rotations = None # rotations, for polar-transformed data\r\n        self.scales = None # scaling, for polar-transformed data\r\n        self.errorDictList = [] # A list of dictionaries of errors and such from different runs on the same data.\r\n        self.trackCorrStats = False\r\n        self.corrStats = None\r\n        \r\n        \r\n        self.doLazyFRC = True\r\n        self.doEvenOddFRC = False\r\n        self.FRC = None # A Fourier ring correlation\r\n\r\n        # Filtering\r\n        # TODO: add more fine control over filtering options        \r\n        \r\n        # CTF currently supports CTFFIND4.1 or GCTF\r\n        self.CTFProgram = None # None, \"ctffind4.1\", or \"gctf\", 'ctffind4.1,sum' works on (aligned) sum, same for 'gctf,sum'\r\n        self.CTFInfo = { u'DefocusU':None, u'DefocusV': None, u'DefocusAngle':None, u'CtfFigureOfMerit':None,\r\n                         u'FinalResolution': None, u'AmplitudeContrast':0.07, u'AdditionalPhaseShift':None,\r\n                         }\r\n        self.CTFDiag = None # Diagnostic image from CTFFIND4.1 or GCTF\r\n        \r\n        # DEPRICATED ctf stuff\r\n        #self.doCTF = False\r\n        #self.CTF4Results = None # Micrograph number, DF1, DF2, Azimuth, Additional Phase shift, CC, and max spacing fit-to\r\n        #self.CTF4Diag = None\r\n        \r\n        # Registration parameters\r\n        self.shapePadded = [4096,4096]\r\n        self.shapeOriginal = None\r\n        self.shapeBinned = None \r\n        self.subPixReg = 16 # fraction of a pixel to REGISTER image shift to\r\n        # Subpixel alignment method: None (shifts still registered subpixally), lanczos, or fourier\r\n        # lanczos is cheaper computationally and has fewer edge artifacts\r\n        self.shiftMethod = u'lanczos' \r\n        self.maxShift = 100 # Generally should be 1\/2 distance to next lattice spacing\r\n        # Pre-shift every image by that of the previous frame, useful for high-resolution where one can jump a lattice\r\n        # i.e. should be used with small values for maxShift\r\n        self.preShift = False\r\n        # Solver weighting can be raw max correlation coeffs (None), normalized to [0,1] by the \r\n        # min and max correlations ('norm'), or 'logistic' function weighted which\r\n        # requires corrThres to be set.\r\n        self.peakLocMode = u'interpolated' # interpolated (oversampled), or a RMS-best fit like fitlaplacian\r\n        self.weightMode = u'autologistic' # autologistic, normalized, unweighted, logistic, or corr\r\n        self.peaksigThres = 6.0\r\n        self.logisticK = 5.0\r\n        self.logisticNu = 0.15\r\n        self.originMode = u'centroid' # 'centroid' or None\r\n        self.suppressOrigin = True # Delete the XC pixel at (0,0).  Only necessary if gain reference is bad, but defaults to on.\r\n        \r\n        # Triangle-matrix indexing parameters\r\n        self.triMode = u'diag' # Can be: tri, diag, auto, first\r\n        self.startFrame = 0\r\n        self.endFrame = 0\r\n        self.diagStart = 0 # XC to neighbour frame on 0, next-nearest neighbour on +1, etc.\r\n        self.diagWidth = 5\r\n        self.autoMax = 10\r\n\r\n        self.corrThres = None # Use with 'auto' mode to stop doing cross-correlations if the values drop below the threshold\r\n        \r\n        self.velocityThres = None # Pixel velocity threshold (pix\/frame), above which to throw-out frames with too much motion blur.\r\n        \r\n        #### INPUT\/OUTPUT ####\r\n        self.files = { u\"config\":None, u\"stack\":None, u\"mask\":None, u\"sum\":None, \r\n                       u\"align\":None, u\"figurePath\":None, u\"xc\":None, \r\n                       u\"moveRawPath\":None, u\"original\":None, u\"gainRef\":None,\r\n                       u\"stdout\": None, u\"automatch\":None, u\"rejected\":None,\r\n                       u\"compressor\": None, u\"clevel\": 1 }\r\n\r\n        #self.savePDF = False\r\n        self.savePNG = True\r\n        self.saveMovie = True\r\n        self.doCompression = False\r\n        \r\n        self.compress_ext = \".bz2\"\r\n\r\n        #### PLOTTING ####\r\n        self.plotDict = { u\"imageSum\":True, u\"imageFirst\":False, u\"FFTSum\":True, u\"polarFFTSum\":True, \r\n                         u\"filtSum\":True, u'stats': False,\r\n                         u\"corrTriMat\":False, u\"peaksigTriMat\": True, \r\n                         u\"translations\":True, u\"pixRegError\":True, \r\n                         u\"CTFDiag\":True, u\"logisticWeights\": True, u\"FRC\": True, \r\n                         u'Transparent': True, u'plot_dpi':144, u'image_dpi':250,\r\n                         u'image_cmap':u'gray', u'graph_cmap':u'gnuplot', \r\n                         u'fontsize':12, u'fontstyle': u'serif', u'colorbar': True,\r\n                         u'backend': u'Qt4Agg', u'multiprocess':True,\r\n                         u'show':False }\r\n        pass\r\n    \r\n    def initDefaultFiles( self, stackName ):\r\n        self.files[u'stack'] = stackName\r\n        self.files[u'config'] = stackName + u\".zor\"\r\n\r\n        stackPath, stackFront = os.path.split( stackName )\r\n        stackFront = os.path.splitext( stackFront )[0]\r\n        \r\n        if not 'compressor' in self.files or not bool(self.files['compressor']):\r\n            mrcExt = \".mrc\"\r\n            mrcsExt = \".mrcs\"\r\n        else:\r\n            mrcExt = \".mrcz\"\r\n            mrcsExt = \".mrcsz\" \r\n            \r\n        self.files[u'align'] = os.path.relpath( \r\n                    os.path.join( u\".\/align\", \"%s_zorro_movie%s\" %(stackFront, mrcsExt)  ), \r\n                    start=stackPath )\r\n        self.files[u'sum'] = os.path.relpath( stackPath, \r\n                    os.path.join( u\".\/sum\", \"%s_zorro%s\" %(stackFront, mrcExt) ), \r\n                    start=stackPath ) \r\n        self.files[u'figurePath'] = os.path.relpath( \r\n                os.path.join(stackPath, u\".\/figs\"), start=stackPath  )\r\n\r\n            \r\n    def xcorr2_mc2_1( self, gpu_id = 0, loadResult=True, clean=True ):\r\n        \"\"\"\r\n        This makes an external operating system call to the Cheng's lab GPU-based \r\n        B-factor multireference executable. It and CUDA libraries must be on the system \r\n        path and libary path respectively.\r\n        \r\n        NOTE: Spyder looks loads PATH and LD_LIBRARY_PATH from .profile, not .bashrc\r\n        \"\"\"\r\n            \r\n        \r\n        \r\n        dosef_cmd = util.which(\"dosefgpu_driftcorr\")\r\n        if dosef_cmd is None:\r\n            print( \"Error: dosefgpu_driftcorr not found in system path.\" )\r\n            return\r\n        \r\n        #tempFileHash = str(uuid.uuid4() ) # Key let's us multiprocess safely\r\n        stackBase = os.path.basename( os.path.splitext( self.files['stack'] )[0] )\r\n        \r\n        if self.cachePath is None:\r\n            self.cachePath = \".\"\r\n            \r\n        InName = os.path.join( self.cachePath, stackBase + u\"_mcIn.mrc\" )\r\n        # Unfortunately these files may as well be in the working directory.    \r\n        OutAvName = os.path.join( self.cachePath, stackBase + u\"_mcOutAv.mrc\" )\r\n        OutStackName = os.path.join( self.cachePath, stackBase + u\"_mcOut.mrc\" )\r\n        logName = os.path.join( self.cachePath, stackBase + u\"_mc.zor\" )\r\n        mrcz.writeMRC( self.images, InName )\r\n\r\n        # Force binning to 1, as performance with binning is poor\r\n        binning = 1\r\n        if self.Brad is not None:\r\n            # Li masking is in MkPosList() in cufunc.cu (line 413)\r\n            # Their r2 is normalized and mine isn't\r\n            # Li has mask = exp( -0.5 * bfactor * r_norm**2 )\r\n            # r_norm**2 = x*x\/Nx*Nx + y*y\/Ny*Ny = r**2 \/ (Nx**2 + Ny**2)\r\n            # For non-square arrays they have a non-square (but constant frequency) filter \r\n            # RAM has mask = exp( -(r\/brad)**2 )\r\n            # We can only get Bfactor approximately then but it's close enough for 3710x3838\r\n            bfac = 2.0 * (self.images.shape[1]**2 + self.images.shape[2]**2) \/ (self.Brad**2) \r\n            print( \"Using B-factor of \" + str(bfac) + \" for dosefgpu_driftcorr\" )\r\n        else:\r\n            bfac = 1000 # dosef default 'safe' bfactor for mediocre gain reference\r\n        # Consider: Dosef suffers at the ends of the sequence, so make the middle frame zero drift?\r\n        # align_to = np.floor( self.images.shape[0]\/2 )\r\n        # This seems to cause more problems then it's worth.\r\n        align_to = 0\r\n        if self.diagWidth != None:\r\n            fod = self.diagWidth\r\n        else:\r\n            fod = 0\r\n        # Dosef can limit search to a certain box size    \r\n        if self.maxShift == None:\r\n            maxshift = 96\r\n        else:\r\n            maxshift = self.maxShift * 2\r\n        if self.startFrame == None:\r\n            self.startFrame = 0\r\n        if self.endFrame == None:\r\n            self.endFrame = 0\r\n\r\n        motion_flags = (  \" \" + InName \r\n                + \" -gpu \" + str(gpu_id)\r\n                + \" -nss \" + str(self.startFrame) \r\n                + \" -nes \" + str(self.endFrame) \r\n                + \" -fod \" + str(fod) \r\n                + \" -bin \" + str(binning) \r\n                + \" -bft \" + str(bfac) \r\n                + \" -atm -\" + str(align_to) \r\n                + \" -pbx \" + str(maxshift)\r\n                + \" -ssc 1 -fct \" + OutStackName \r\n                + \" -fcs \" + OutAvName \r\n                + \" -flg \" + logName )\r\n\r\n        sub = subprocess.Popen( dosef_cmd + motion_flags, shell=True )\r\n        sub.wait()\r\n        \r\n        \r\n        self.loadMCLog( logName )\r\n            \r\n\r\n        time.sleep(0.5)\r\n        if bool(clean):\r\n            try: os.remove(InName)\r\n            except: pass\r\n            try: os.remove(OutStackName)\r\n            except: pass\r\n            try: os.remove(OutAvName)\r\n            except: pass\r\n            try: os.remove(logName)\r\n            except: pass\r\n        \r\n    def loadMCLog( self, logName ):\r\n        \"\"\"\r\n        Load and part a MotionCorr log from disk using regular expressions.\r\n        \"\"\"\r\n        import re\r\n        \r\n        # Parse to get the translations\r\n        fhMC = open( logName )\r\n        MClog = fhMC.readlines()\r\n        fhMC.close()\r\n        \r\n        # Number of footer lines changes with the options you use.\r\n        # I would rather find Sum Frame #000\r\n        for linenumber, line in enumerate(MClog):\r\n            try: \r\n                test = re.findall( \"Sum Frame #000\", line)\r\n                if bool(test): \r\n                    frameCount = np.int( re.findall( \"\\d\\d\\d\", line )[1] ) + 1\r\n                    break\r\n            except: pass\r\n        \r\n        MClog_crop = MClog[linenumber+1:linenumber+frameCount+1]\r\n        MCdrifts = np.zeros( [frameCount,2] )\r\n        for J in np.arange(0,frameCount):\r\n            MCdrifts[J,:] = re.findall( r\"([+-]?\\d+.\\d+)\", MClog_crop[J] )[1:]\r\n        # Zorro saves translations, motioncorr saves shifts.\r\n        self.translations = -np.fliplr( MCdrifts )\r\n        \r\n        if self.originMode == u'centroid':\r\n            centroid = np.mean( self.translations, axis=0 )\r\n            self.translations -= centroid\r\n            \r\n    def xcorr2_unblur1_02( self, dosePerFrame = None, minShift = 2.0, terminationThres = 0.1, \r\n                      maxIteration=10, verbose=False, loadResult=True, clean=True   ):\r\n        \"\"\"\r\n        Calls UnBlur by <NAME> Rohou using the Zorro interface.\r\n        \"\"\"\r\n        self.bench['unblur0']  = time.time()\r\n        unblur_exename = \"unblur_openmp_7_17_15.exe\"\r\n        if util.which( unblur_exename ) is None:\r\n            print( \"UnBlur not found in system path\" )\r\n            return\r\n        \r\n        print( \"Calling UnBlur for \" + self.files['stack'] )\r\n        print( \"   written by <NAME> and <NAME>: http:\/\/grigoriefflab.janelia.org\/unblur\" )\r\n        print( \"   http:\/\/grigoriefflab.janelia.org\/node\/4900\" )\r\n        \r\n        import os\r\n        \r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass\r\n        \r\n        if self.cachePath is None:\r\n            self.cachePath = \".\"\r\n            \r\n        # Force trailing slashes onto cachePatch\r\n        stackBase = os.path.basename( os.path.splitext( self.files[u'stack'] )[0] )\r\n        frcOutName = os.path.join( self.cachePath, stackBase + u\"_unblur_frc.txt\" )\r\n        shiftsOutName = os.path.join( self.cachePath, stackBase + u\"_unblur_shifts.txt\" )\r\n        outputAvName = os.path.join( self.cachePath, stackBase + u\"_unblur.mrc\" )\r\n        outputStackName = os.path.join( self.cachePath, stackBase + u\"_unblur_movie.mrc\" )\r\n        \r\n\r\n        ps = self.pixelsize * 10.0\r\n        if 'dose' in self.filterMode:\r\n            doDoseFilter = True\r\n            if dosePerFrame == None:\r\n                # We have to guesstimate the dose per frame in e\/A^2 if it's not provided\r\n                dosePerFrame = np.mean( self.images ) \/ (ps*ps)\r\n            preExposure = 0.0\r\n            if 'dosenorm' in self.filterMode:\r\n                restoreNoise=True\r\n            else:\r\n                restoreNoise=False\r\n        else:\r\n            doDoseFilter = False\r\n            \r\n        if self.Brad is not None:\r\n            # Li masking is in MkPosList() in cufunc.cu (line 413)\r\n            # Their r2 is normalized and mine isn't\r\n            # Li has mask = exp( -0.5 * bfactor * r_norm**2 )\r\n            # r_norm**2 = x*x\/Nx*Nx + y*y\/Ny*Ny = r**2 \/ (Nx**2 + Ny**2)\r\n            # For non-square arrays they have a non-square (but constant frequency) filter \r\n            # RAM has mask = exp( -(r\/brad)**2 )\r\n            # We can only get Bfactor approximately then but it's close enough for 3710x3838\r\n            bfac = 2.0 * (self.images.shape[1]**2 + self.images.shape[2]**2) \/ (self.Brad**2) \r\n            print( \"Using B-factor of \" + str(bfac) + \" for UnBlur\" )\r\n        else:\r\n            bfac = 1500 # dosef default 'safe' bfactor for mediocre gain reference\r\n        outerShift = self.maxShift * ps\r\n        # RAM: I see no reason to let people change the Fourier cross masking\r\n        vertFouMaskHW = 1\r\n        horzFouMaskHW = 1\r\n        \r\n        try: \r\n            mrcName = os.path.join( self.cachePath, stackBase + \"_unblurIN.mrc\" )\r\n            mrcz.writeMRC( self.images, mrcName )\r\n        except:\r\n            print( \"Error in exporting MRC file to UnBlur\" )\r\n            return\r\n         \r\n        # Are there flags for unblur?  Check the source code.\r\n        flags = \"\" # Not using any flags\r\n         \r\n        unblurexec = ( unblur_exename + \" \" + flags + \" << STOP_PARSING \\n\" + mrcName )\r\n        \r\n        unblurexec = (unblurexec + \"\\n\" + str(self.images.shape[0]) + \"\\n\" +\r\n            outputAvName + \"\\n\" + shiftsOutName + \"\\n\" + str(ps) + \"\\n\" +\r\n            str(doDoseFilter) )\r\n            \r\n        if bool(doDoseFilter):\r\n            unblurexec += \"\\n\" + str(dosePerFrame) + \"\\n\" + str(self.voltage) + \"\\n\" + str(preExposure)\r\n            \r\n        unblurexec += (\"\\n yes \\n\" + outputStackName + \"\\n yes \\n\" + \r\n            frcOutName + \"\\n\" + str(minShift) + \"\\n\" + str(outerShift) + \"\\n\" +\r\n            str(bfac) + \"\\n\" + str( np.int(vertFouMaskHW) ) + \"\\n\" + str( np.int(horzFouMaskHW) ) + \"\\n\" +\r\n            str(terminationThres) + \"\\n\" + str(maxIteration) )\r\n            \r\n        if bool(doDoseFilter):\r\n            unblurexec += \"\\n\" + str(restoreNoise)\r\n            \r\n        unblurexec += \"\\n\" + str(verbose) \r\n              \r\n        unblurexec = unblurexec + \"\\nSTOP_PARSING\"\r\n        \r\n        print( unblurexec )\r\n        sub = subprocess.Popen( unblurexec, shell=True )\r\n        sub.wait()\r\n        \r\n        try:\r\n            # Their FRC is significantly different from mine.\r\n            self.FRC = np.loadtxt(frcOutName, comments='#', skiprows=0 )\r\n            self.translations = np.loadtxt( shiftsOutName, comments='#', skiprows=0 ).transpose()\r\n            # UnBlur uses Fortran ordering, so we need to swap y and x for Zorro C-ordering\r\n            self.translations = np.fliplr( self.translations )\r\n            # UnBlur returns drift in Angstroms\r\n            self.translations \/= ps\r\n            # UnBlur registers to middle frame\r\n            self.translations -= self.translations[0,:]\r\n            \r\n            if bool( loadResult ):\r\n                print( \"Loading UnBlur aligned frames into ImageRegistrator.images\" )\r\n                if 'dose' in self.filterMode:\r\n                    # TODO: WHow to get both filtered images and unfiltered?\r\n                    self.imageSum = mrcz.readMRC( outputAvName )[0]\r\n                else:\r\n                    self.imageSum = mrcz.readMRC( outputAvName )[0]\r\n                # TODO: We have a bit of an issue, this UnBlur movie is dose filtered...\r\n                self.images = mrcz.readMRC( outputStackName )[0]\r\n        except IOError:\r\n            print( \"UnBlur likely core-dumped, try different input parameters?\" )\r\n        finally:\r\n            time.sleep(0.5) # DEBUG: try and see if temporary files are deleteable now.\r\n        \r\n            frcOutName = os.path.join( self.cachePath, stackBase + \"_unblur_frc.txt\" )\r\n            shiftsOutName = os.path.join( self.cachePath, stackBase + \"_unblur_shifts.txt\" )\r\n            outputAvName = os.path.join( self.cachePath, stackBase + \"_unblur.mrc\" )\r\n            outputStackName = os.path.join( self.cachePath, stackBase + \"_unblur_movie.mrc\" )\r\n        pass\r\n    \r\n        if self.originMode == 'centroid':\r\n            centroid = np.mean( self.translations, axis=0 )\r\n            self.translations -= centroid\r\n    \r\n        time.sleep(0.5)\r\n        if bool(clean):\r\n            try: os.remove( mrcName )\r\n            except: print( \"Could not remove Unblur MRC input file\" )\r\n            try: os.remove( frcOutName )\r\n            except: print( \"Could not remove Unblur FRC file\" )\r\n            try: os.remove( shiftsOutName )\r\n            except: print( \"Could not remove Unblur Shifts file\" )\r\n            try: os.remove( outputAvName )\r\n            except: print( \"Could not remove Unblur MRC average\" )\r\n            try: os.remove( outputStackName )\r\n            except: print( \"Could not remove Unblur MRC stack\" )\r\n        self.bench['unblur1']  = time.time()\r\n        \r\n        \r\n    def __init_xcorrnm2( self, triIndices=None ):\r\n        \"\"\"\r\n        \r\n        \"\"\"\r\n        self.bench['xcorr0'] = time.time() \r\n        \r\n        shapeImage = np.array( [self.images.shape[1], self.images.shape[2]] )\r\n        self.__N = np.asarray( self.images.shape )[0]\r\n            \r\n        if self.preShift:\r\n            print( \"Warning: Preshift will break if there are skipped frames in a triIndices row.\" )\r\n\r\n        # Test to see if triIndices is a np.array or use self.triMode\r\n        if hasattr( triIndices, \"__array__\" ): # np.array\r\n            # Ensure triIndices is a square array of the right size\r\n            if triIndices.shape[0] != self.__N or triIndices.shape[1] != self.__N:\r\n                raise IndexError(\"triIndices is wrong size, should be of length: \" + str(self.__N) )\r\n\r\n        elif triIndices is None:\r\n            [xmesh, ymesh] = np.meshgrid( np.arange(0,self.__N), np.arange(0,self.__N) )\r\n            trimesh = xmesh - ymesh\r\n            # Build the triMat if it wasn't passed in as an array\r\n            if( self.triMode == 'first' ):\r\n                print( \"Correlating in template mode to first image\" )\r\n                triIndices = np.ones( [1,self.__N], dtype='bool' )\r\n                triIndices[0,0] = False # Don't autocorrelate the first frame.\r\n            elif( self.triMode == u'diag' ):\r\n                if (self.diagWidth is None) or (self.diagWidth < 0):\r\n                    # For negative numbers, align the entire triangular matrix\r\n                    self.diagWidth = self.__N\r\n                    \r\n                triIndices = (trimesh <= self.diagWidth + self.diagStart ) * (trimesh > self.diagStart )\r\n                print( \"Correlating in diagonal mode with width \" + str(self.diagWidth) )\r\n            elif( self.triMode == u'autocorr' ):\r\n                triIndices = (trimesh == 0)\r\n            elif( self.triMode == u'refine' ):\r\n                triIndices = trimesh == 0\r\n            else: # 'tri' or 'auto' ; default is an upper triangular matrix\r\n                triIndices = trimesh >= 1\r\n            pass\r\n        else:\r\n            raise TypeError( \"Error: triIndices not recognized as valid: \" + str(triIndices) )\r\n            \r\n\r\n        if self.masks is None or self.masks == []:\r\n            print( \"Warning: No mask not recommened with MNXC-style correlation\" )\r\n            self.masks = np.ones( [1,shapeImage[0],shapeImage[1]], dtype = self.images.dtype )\r\n            \r\n        if( self.masks.ndim == 2 ):\r\n            self.masks = np.reshape( self.masks.astype(self.images.dtype), [1,shapeImage[0],shapeImage[1]] )\r\n             \r\n        # Pre-loop allocation\r\n        self.__shiftsTriMat = np.zeros( [self.__N,self.__N,2], dtype=float_dtype ) # Triagonal matrix of shifts in [I,J,(y,x)]\r\n        self.__corrTriMat = np.zeros( [self.__N,self.__N], dtype=float_dtype ) # Triagonal matrix of maximum correlation coefficient in [I,J]\r\n        self.__peaksigTriMat = np.zeros( [self.__N,self.__N], dtype=float_dtype ) # Triagonal matrix of correlation peak contrast level\r\n        self.__originTriMat= np.zeros( [self.__N,self.__N], dtype=float_dtype ) # Triagonal matrix of origin correlation coefficient in [I,J]\r\n        \r\n        # Make pyFFTW objects\r\n        if not bool( np.any( self.fouCrop ) ):\r\n            self.__tempFullframe = np.empty( shapeImage, dtype=fftw_dtype )\r\n            self.__FFT2, self.__IFFT2 = util.pyFFTWPlanner( self.__tempFullframe, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ), effort = self.fftw_effort, n_threads=self.n_threads )\r\n            self.__shapeCropped = shapeImage\r\n            self.__tempComplex = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n        else:\r\n            self.__tempFullframe = np.empty( shapeImage,  dtype=fftw_dtype )\r\n            self.__FFT2, _ = util.pyFFTWPlanner( self.__tempFullframe, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , effort = self.fftw_effort, n_threads=self.n_threads, doReverse=False )\r\n            # Force fouCrop to multiple of 2\r\n            self.__shapeCropped = 2 * np.floor( np.array( self.fouCrop ) \/ 2.0 ).astype('int')\r\n            self.__tempComplex = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n            _, self.__IFFT2 = util.pyFFTWPlanner( self.__tempComplex, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , effort = self.fftw_effort, n_threads=self.n_threads, doForward=False )\r\n        \r\n        self.__shapeCropped2 = (np.array( self.__shapeCropped) \/ 2.0).astype('int')\r\n        self.__templateImageFFT = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n        self.__templateSquaredFFT = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n        self.__templateMaskFFT = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n        self.__tempComplex2 = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n        \r\n        # Subpixel initialization\r\n        # Ideally subPix should be a power of 2 (i.e. 2,4,8,16,32)\r\n        self.__subR = 8 # Sampling range around peak of +\/- subR\r\n        if self.subPixReg is None: self.subPixReg = 1;\r\n        if self.subPixReg > 1.0:  \r\n            # hannfilt = np.fft.fftshift( ram.apodization( name='hann', size=[subR*2,subR*2], radius=[subR,subR] ) ).astype( fftw_dtype )\r\n            # Need a forward transform that is [subR*2,subR*2] \r\n            self.__Csub = np.empty( [self.__subR*2,self.__subR*2], dtype=fftw_dtype )\r\n            self.__CsubFFT = np.empty( [self.__subR*2,self.__subR*2], dtype=fftw_dtype )\r\n            self.__subFFT2, _ = util.pyFFTWPlanner( self.__Csub, fouMage=self.__CsubFFT, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , effort = self.fftw_effort, n_threads=self.n_threads, doReverse = False )\r\n            # and reverse transform that is [subR*2*subPix, subR*2*subPix]\r\n            self.__CpadFFT = np.empty( [self.__subR*2*self.subPixReg,self.__subR*2*self.subPixReg], dtype=fftw_dtype )\r\n            self.__Csub_over = np.empty( [self.__subR*2*self.subPixReg,self.__subR*2*self.subPixReg], dtype=fftw_dtype )\r\n            _, self.__subIFFT2 = util.pyFFTWPlanner( self.__CpadFFT, fouMage=self.__Csub_over, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , effort = self.fftw_effort, n_threads=self.n_threads, doForward = False )\r\n        \r\n        \r\n        self.__maskProduct = np.zeros( self.__shapeCropped, dtype=float_dtype )\r\n        self.__normConst2 = np.float32( 1.0 \/ ( np.float64(self.__shapeCropped[0])*np.float64(self.__shapeCropped[1]))**2.0 )\r\n        self.bench['xcorr1'] = time.time() \r\n        \r\n        return triIndices \r\n        \r\n    def xcorrnm2_speckle( self, triIndices=None ):\r\n        \"\"\"\r\n        <NAME>\r\n        <EMAIL>\r\n        October 1, 2016\r\n        \r\n        With data recorded automatically from SerialEM, we no long have access to the gain reference\r\n        normalization step provided by Gatan.  With the K2 detector, gain normalization is no \r\n        longer a simple multiplication.  Therefore we see additional, multiplicative (or speckle) \r\n        noise in the images compared to those recorded by Gatan Microscopy Suite.  Here we want \r\n        to use a different approach from the Padfield algorithm, which is useful for suppressing \r\n        additive noise, and \r\n        \r\n        In general Poisson noise should be speckle noise, especially at the dose rates commonly \r\n        seen in cryo-EM.\r\n        \r\n        \"\"\"\r\n        triIndices = self.__init_xcorrnm2( triIndices = triIndices)\r\n        \r\n        # Pre-compute forward FFTs (template will just be copied conjugate Fourier spectra)\r\n        self.__imageFFT = np.empty( [self.__N, self.shapePadded[0], self.shapePadded[1]], dtype=fftw_dtype )\r\n        \r\n        self.__autocorrHalfs = np.empty( [self.__N, self.__shapeCropped[0], self.__shapeCropped[1]], dtype=float_dtype )\r\n        \r\n        currIndex = 0\r\n        self.__originC = []; self.C = []\r\n        \r\n        print( \"Pre-computing forward Fourier transforms and autocorrelations\" )\r\n        # For even-odd and noise estimates, we often skip many rows\r\n        # precompIndices = np.unique( np.vstack( [np.argwhere( np.sum( triIndices, axis=1 ) > 0 ), np.argwhere( np.sum( triIndices, axis=0 ) > 0 ) ] ) )\r\n        precompIndices = np.unique( np.vstack( [np.argwhere( np.sum( triIndices, axis=1 ) >= 0 ), \r\n                                                np.argwhere( np.sum( triIndices, axis=0 ) >= 0 ) ] ) )\r\n        for I in precompIndices:\r\n            if self.verbose >= 2: \r\n                print( \"Precomputing forward FFT frame: \" + str(I) )\r\n                \r\n            # Apply masks to images\r\n            if self.masks.shape[0] == 1:\r\n                masks_block = self.masks[0,:,:]\r\n                images_block = self.images[I,:,:]\r\n            else:\r\n                masks_block = self.masks[I,:,:]\r\n                images_block = self.images[I,:,:]\r\n                \r\n            self.__tempComplex = nz.evaluate( \"masks_block * images_block\" ).astype( fftw_dtype )    \r\n            self.__FFT2.update_arrays( self.__tempComplex, self.__imageFFT[I,:,:]); self.__FFT2.execute()\r\n            \r\n            print( \"TODO: FOURIER CROPPING\" )\r\n            \r\n            # Compute autocorrelation\r\n            imageFFT = self.__imageFFT[I,:,:]\r\n            # Not sure if numexpr is useful for such a simple operation?\r\n            self.__tempComplex = nz.evaluate( \"imageFFT * conj(imageFFT)\" )\r\n            self.__IFFT2.update_arrays( self.__tempComplex, self.__tempComplex2 )\r\n            tempComplex2 = self.__tempComplex2\r\n            \r\n            nz.evaluate( \"0.5*abs(tempComplex2)\", out=self.__autocorrHalfs[I,:,:] )\r\n        self.bench['xcorr2'] = time.time() \r\n        \r\n        \r\n    \r\n        ########### COMPUTE PHASE CORRELATIONS #############\r\n        print( \"Starting correlation calculations, mode: \" + self.triMode )\r\n        if self.triMode == u'refine':\r\n            # Find FFT sum (it must be reduced by the current frame later)\r\n            # FIXME: Is there some reason this might not be linear after FFT?\r\n            # FIXME: is it the complex conjugate operation below???\r\n            self.__sumFFT = np.sum( self.__baseImageFFT, axis = 0 )\r\n            self.__sumSquaredFFT = np.sum( self.__baseSquaredFFT, axis = 0 )\r\n            \r\n            print( \"In refine\" )\r\n            for I in np.arange(self.images.shape[0] - 1):\r\n                # In refine mode we have to build the template on the fly from imageSum - currentImage\r\n                self.__templateImageFFT = np.conj( self.__sumFFT - self.__baseImageFFT[I,:,:]  ) \/ self.images.shape[0]\r\n                self.__templateSquaredFFT = np.conj( self.__sumSquaredFFT - self.__baseSquaredFFT[I,:,:] ) \/ self.images.shape[0]\r\n                tempComplex2 = None\r\n                \r\n                self.mnxc2_SPECKLE( I, I, self.__shapeCropped, refine=True )\r\n                #### Find maximum positions ####    \r\n                self.locatePeak( I, I )\r\n                if self.verbose: \r\n                    print( \"Refine # \" + str(I) + \" shift: [%.2f\"%self.__shiftsTriMat[I,I,0] \r\n                            + \", %.2f\"%self.__shiftsTriMat[I,I,1]\r\n                            + \"], cc: %.6f\"%self.__corrTriMat[I,I] \r\n                            + \", peak sig: %.3f\"%self.__peaksigTriMat[I,I] )    \r\n        else:\r\n            # For even-odd and noise estimates, we often skip many rows\r\n            rowIndices = np.unique( np.argwhere( np.sum( triIndices, axis=1 ) > 0 ) )\r\n            #print( \"rowIndices: \" + str(rowIndices) )\r\n            for I in rowIndices:\r\n                # I is the index of the template image\r\n                tempComplex = self.__baseImageFFT[I,:,:]\r\n                self.__templateImageFFT = nz.evaluate( \"conj(tempComplex)\")\r\n\r\n        \r\n                # Now we can start looping through base images\r\n                columnIndices = np.unique( np.argwhere( triIndices[I,:] ) )\r\n                #print( \"columnIndices: \" + str(columnIndices) )\r\n                for J in columnIndices:\r\n                    \r\n                    ####### MNXC2 revisement with private variable to make the code more manageable.\r\n                    self.mnxc2_speckle( I, J, self.__shapeCropped )\r\n                    \r\n                    #### Find maximum positions ####    \r\n                    self.locatePeak( I, J )\r\n                    \r\n                    if self.verbose: \r\n                        print( \"# \" + str(I) + \"->\" + str(J) + \" shift: [%.2f\"%self.__shiftsTriMat[I,J,0] \r\n                            + \", %.2f\"%self.__shiftsTriMat[I,J,1]\r\n                            + \"], cc: %.6f\"%self.__corrTriMat[I,J] \r\n                            + \", peak sig: %.3f\"%self.__peaksigTriMat[I,J] )    \r\n                        \r\n                    # Correlation stats is for establishing correlation scores for fixed-pattern noise.\r\n                    if bool( self.trackCorrStats ):\r\n                        self.calcCorrStats( currIndex, triIndices )\r\n                        \r\n                    # triMode 'auto' diagonal mode    \r\n                    if self.triMode == u'auto' and (self.__peaksigTriMat[I,J] <= self.peaksigThres or J-I >= self.autoMax):\r\n                        if self.verbose: print( \"triMode 'auto' stopping at frame: \" + str(J) )\r\n                        break\r\n                    currIndex += 1\r\n                pass # C max position location\r\n        \r\n        \r\n\r\n        if bool( np.any( self.fouCrop ) ):\r\n            self.__shiftsTriMat[:,:,0] *= self.shapePadded[0] \/ self.__shapeCropped[0]\r\n            self.__shiftsTriMat[:,:,1] *= self.shapePadded[1] \/ self.__shapeCropped[1]\r\n        \r\n        self.bench['xcorr3'] = time.time()\r\n        # Pointer reference house-keeping\r\n        del images_block, masks_block, imageFFT, tempComplex2\r\n        \r\n            \r\n    def xcorrnm2_tri( self, triIndices=None ):\r\n        \"\"\"\r\n        <NAME>\r\n        <EMAIL>\r\n        April 16, 2015\r\n        \r\n        triIndices is the index locations to correlate to.  If None, self.triMode \r\n        is used to build one.  Normally you should use self.triMode for the first iteration, \r\n        and pass in a triIndice from the errorDict if you want to repeat.\r\n        \r\n        returns : [shiftsTriMat, corrTriMat, peaksTriMat]\r\n        \r\n        This is an evolution of the Padfield cross-correlation algorithm  to take \r\n        advantage of the Cheng multi-reference approach for cross-correlation \r\n        alignment of movies. \r\n            Padfield, \"Masked object registration in the Fourier domain,\" IEEE\r\n            Transactions on Image Processing 21(5) (2012): 3706-2718.\r\n            \r\n            <NAME> al. Nature Methods, 10 (2013): 584-590.\r\n            \r\n        It cross-correlates every frame to every other frame to build a triangular\r\n        matrix of shifts and then does a functional minimization over the set of \r\n        equations. This means the computational cost grows with a power law with\r\n        the number of frames but it is more noise resistant.  \r\n        \r\n\r\n        triIndices can be an arbitrary boolean N x N matrix of frames to correlate\r\n        Alternatively it can be a string which will generate an appropriate matrix:\r\n             'tri' (default) correlates all frames to eachother\r\n             'first' is correlate to the first frame as a template\r\n             'diag' correlates to the next frame (i.e. a diagonal )\r\n             'auto' is like diag but automatically determines when to stop based on corrcoeffThes\r\n        diagWidth is for 'diag' and the number of frames to correlate each frame to, \r\n            default is None, which does the entire triangular matrix\r\n            diagWidth = 1 correlates to each preceding frame\r\n        \r\n        NOTE: only calculates FFTs up to Nyquist\/2.\r\n        \"\"\"\r\n        \r\n        triIndices = self.__init_xcorrnm2( triIndices = triIndices)\r\n        \r\n        if self.masks.shape[0] == 1 :\r\n            # tempComplex = self.masks[0,:,:].astype( fftw_dtype ) \r\n            self.__baseMaskFFT = np.empty( self.__shapeCropped, dtype=fftw_dtype )\r\n\r\n            self.__FFT2.update_arrays( self.masks[0,:,:].squeeze().astype( fftw_dtype ), self.__tempFullframe ); self.__FFT2.execute()\r\n            # FFTCrop\r\n            sC2 = self.__shapeCropped2\r\n            self.__baseMaskFFT[0:sC2[0],0:sC2[1]] = self.__tempFullframe[0:sC2[0],0:sC2[1]]\r\n            self.__baseMaskFFT[0:sC2[0],-sC2[1]:] = self.__tempFullframe[0:sC2[0],-sC2[1]:] \r\n            self.__baseMaskFFT[-sC2[0]:,0:sC2[1]] = self.__tempFullframe[-sC2[0]:,0:sC2[1]] \r\n            self.__baseMaskFFT[-sC2[0]:,-sC2[1]:] = self.__tempFullframe[-sC2[0]:,-sC2[1]:] \r\n            \r\n            self.__templateMaskFFT = np.conj( self.__baseMaskFFT )\r\n            \r\n            # maskProduct term is M1^* .* M2\r\n            templateMaskFFT = self.__templateMaskFFT; \r\n            baseMaskFFT = self.__baseMaskFFT # Pointer assignment\r\n            self.__tempComplex2 = nz.evaluate( \"templateMaskFFT * baseMaskFFT\" )\r\n            self.__IFFT2.update_arrays( self.__tempComplex2, self.__tempComplex ); self.__IFFT2.execute()\r\n            tempComplex = self.__tempComplex\r\n            normConst2 = self.__normConst2\r\n            self.__maskProduct = nz.evaluate( \"normConst2*real(tempComplex)\" )\r\n        else:\r\n            # Pre-allocate only\r\n            self.__baseMaskFFT = np.zeros( [self.__N, self.__shapeCropped[0], self.__shapeCropped[1]], dtype=fftw_dtype )\r\n        \r\n            \r\n        if bool( self.maxShift ) or self.Bmode is u'fourier':\r\n            if self.maxShift is None or self.preShift is True:\r\n                [xmesh,ymesh] = np.meshgrid( np.arange(-self.__shapeCropped2[0], self.__shapeCropped2[0]), \r\n                                            np.arange(-self.__shapeCropped2[1], self.__shapeCropped2[1])  )\r\n            else:\r\n                [xmesh,ymesh] = np.meshgrid( np.arange(-self.maxShift, self.maxShift), np.arange(-self.maxShift, self.maxShift)  )\r\n            \r\n            rmesh2 = nz.evaluate( \"xmesh*xmesh + ymesh*ymesh\" )\r\n            # rmesh2 = xmesh*xmesh + ymesh*ymesh\r\n            if bool( self.maxShift ): \r\n                self.__mask_maxShift = ( rmesh2 < self.maxShift**2.0 )\r\n            if self.Bmode is u'fourier':\r\n                self.__Bfilter = np.fft.fftshift( util.apodization( name=self.BfiltType, \r\n                                                                   size=self.__shapeCropped, \r\n                                                                   radius=[self.Brad,self.Brad] ) )\r\n\r\n        self.bench['xcorr1'] = time.time() \r\n        # Pre-compute forward FFTs (template will just be copied conjugate Fourier spectra)\r\n        self.__imageFFT = np.empty( [self.__N, self.shapePadded[0], self.shapePadded[1]], dtype=fftw_dtype )\r\n        self.__baseImageFFT = np.empty( [self.__N, self.__shapeCropped[0], self.__shapeCropped[1]], dtype=fftw_dtype )\r\n        self.__baseSquaredFFT = np.empty( [self.__N, self.__shapeCropped[0], self.__shapeCropped[1]], dtype=fftw_dtype )\r\n        \r\n        # Looping for triagonal matrix\r\n        # For auto this is wrong, so make these lists instead\r\n        currIndex = 0\r\n        self.__originC = []; self.C = []\r\n\r\n\r\n            \r\n        print( \"Pre-computing forward Fourier transforms\" )\r\n        # For even-odd and noise estimates, we often skip many rows\r\n        # precompIndices = np.unique( np.vstack( [np.argwhere( np.sum( triIndices, axis=1 ) > 0 ), np.argwhere( np.sum( triIndices, axis=0 ) > 0 ) ] ) )\r\n        precompIndices = np.unique( np.vstack( [np.argwhere( np.sum( triIndices, axis=1 ) >= 0 ), \r\n                                                np.argwhere( np.sum( triIndices, axis=0 ) >= 0 ) ] ) )\r\n        for I in precompIndices:\r\n            if self.verbose >= 2: \r\n                print( \"Precomputing forward FFT frame: \" + str(I) )\r\n                \r\n            # Apply masks to images\r\n            if self.masks.shape[0] == 1:\r\n                masks_block = self.masks[0,:,:]\r\n                images_block = self.images[I,:,:]\r\n            else:\r\n                masks_block = self.masks[I,:,:]\r\n                images_block = self.images[I,:,:]\r\n                \r\n            tempReal = nz.evaluate( \"masks_block * images_block\" ).astype( fftw_dtype )\r\n\r\n                    \r\n            self.__FFT2.update_arrays( tempReal, self.__tempFullframe ); self.__FFT2.execute()\r\n            if self.shiftMethod == u\"fourier\":\r\n                self.__imageFFT[I,:,:] = self.__tempFullframe.copy(order='C')\r\n                # FFTCrop\r\n                self.__baseImageFFT[I,0:sC2[0],0:sC2[1]] = self.__imageFFT[I,0:sC2[0],0:sC2[1]]\r\n                self.__baseImageFFT[I,0:sC2[0],-sC2[1]:] = self.__imageFFT[I,0:sC2[0],-self.__sC2[1]:] \r\n                self.__baseImageFFT[I,-sC2[0]:,0:sC2[1]] = self.__imageFFT[I,-sC2[0]:,0:self.__sC2[1]] \r\n                self.__baseImageFFT[I,-sC2[0]:,-sC2[1]:] = self.__imageFFT[I,-sC2[0]:,-sC2[1]:] \r\n                print( \"TODO: check memory consumption\" )\r\n            else:\r\n                # FFTCrop\r\n                self.__baseImageFFT[I,0:sC2[0],0:sC2[1]] = self.__tempFullframe[0:sC2[0],0:sC2[1]]\r\n                self.__baseImageFFT[I,0:sC2[0],-sC2[1]:] = self.__tempFullframe[0:sC2[0],-sC2[1]:] \r\n                self.__baseImageFFT[I,-sC2[0]:,0:sC2[1]] = self.__tempFullframe[-sC2[0]:,0:sC2[1]] \r\n                self.__baseImageFFT[I,-sC2[0]:,-sC2[1]:] = self.__tempFullframe[-sC2[0]:,-sC2[1]:] \r\n            \r\n\r\n\r\n            \r\n            self.__FFT2.update_arrays( nz.evaluate( \"tempReal*tempReal\" ).astype( fftw_dtype ), self.__tempFullframe ); self.__FFT2.execute()\r\n            # FFTCrop\r\n            self.__baseSquaredFFT[I,0:sC2[0],0:sC2[1]] = self.__tempFullframe[0:sC2[0],0:sC2[1]]\r\n            self.__baseSquaredFFT[I,0:sC2[0],-sC2[1]:] = self.__tempFullframe[0:sC2[0],-sC2[1]:] \r\n            self.__baseSquaredFFT[I,-sC2[0]:,0:sC2[1]] = self.__tempFullframe[-sC2[0]:,0:sC2[1]] \r\n            self.__baseSquaredFFT[I,-sC2[0]:,-sC2[1]:] = self.__tempFullframe[-sC2[0]:,-sC2[1]:] \r\n            \r\n            \r\n            \r\n            if not self.masks.shape[0] == 1:\r\n                self.__FFT2.update_arrays( self.masks[I,:,:].squeeze().astype( fftw_dtype), self.__tempFullframe ); self.__FFT2.execute()\r\n                # FFTCrop\r\n                self.__baseMaskFFT[I,0:sC2[0],0:sC2[1]] = self.__tempFullframe[0:sC2[0],0:sC2[1]]\r\n                self.__baseMaskFFT[I,0:sC2[0],-sC2[1]:] = self.__tempFullframe[0:sC2[0],-sC2[1]:] \r\n                self.__baseMaskFFT[I,-sC2[0]:,0:sC2[1]] = self.__tempFullframe[-sC2[0]:,0:sC2[1]] \r\n                self.__baseMaskFFT[I,-sC2[0]:,-sC2[1]:] = self.__tempFullframe[-sC2[0]:,-sC2[1]:] \r\n\r\n            pass\r\n        del masks_block, images_block\r\n        \r\n\r\n                \r\n        self.bench['xcorr2'] = time.time() \r\n    \r\n        print( \"Starting correlation calculations, mode: \" + self.triMode )\r\n        if self.triMode == u'refine':\r\n            \r\n            # Find FFT sum (it must be reduced by the current frame later)\r\n            # FIXME: Is there some reason this might not be linear after FFT?\r\n            # FIXME: is it the complex conjugate operation below???\r\n            self.__sumFFT = np.sum( self.__baseImageFFT, axis = 0 )\r\n            self.__sumSquaredFFT = np.sum( self.__baseSquaredFFT, axis = 0 )\r\n            \r\n            print( \"In refine\" )\r\n            for I in np.arange(self.images.shape[0] - 1):\r\n                # In refine mode we have to build the template on the fly from imageSum - currentImage\r\n                self.__templateImageFFT = np.conj( self.__sumFFT - self.__baseImageFFT[I,:,:]  ) \/ self.images.shape[0]\r\n                self.__templateSquaredFFT = np.conj( self.__sumSquaredFFT - self.__baseSquaredFFT[I,:,:] ) \/ self.images.shape[0]\r\n                tempComplex2 = None\r\n                \r\n                self.mnxc2( I, I, self.__shapeCropped, refine=True )\r\n                #### Find maximum positions ####    \r\n                self.locatePeak( I, I )\r\n                if self.verbose: \r\n                    print( \"Refine # \" + str(I) + \" shift: [%.2f\"%self.__shiftsTriMat[I,I,0] \r\n                            + \", %.2f\"%self.__shiftsTriMat[I,I,1]\r\n                            + \"], cc: %.6f\"%self.__corrTriMat[I,I] \r\n                            + \", peak sig: %.3f\"%self.__peaksigTriMat[I,I] )    \r\n        else:\r\n            # For even-odd and noise estimates, we often skip many rows\r\n            rowIndices = np.unique( np.argwhere( np.sum( triIndices, axis=1 ) > 0 ) )\r\n            #print( \"rowIndices: \" + str(rowIndices) )\r\n            for I in rowIndices:\r\n                # I is the index of the template image\r\n                tempComplex = self.__baseImageFFT[I,:,:]\r\n                self.__templateImageFFT = nz.evaluate( \"conj(tempComplex)\")\r\n                    \r\n                tempComplex2 =  self.__baseSquaredFFT[I,:,:]\r\n                self.__templateSquaredFFT = nz.evaluate( \"conj(tempComplex2)\")\r\n        \r\n                if not self.masks.shape[0] == 1:\r\n                    tempComplex = baseMaskFFT[I,:,:]\r\n                    self.__templateMaskFFT = nz.evaluate( \"conj(tempComplex)\")\r\n        \r\n                # Now we can start looping through base images\r\n                columnIndices = np.unique( np.argwhere( triIndices[I,:] ) )\r\n                #print( \"columnIndices: \" + str(columnIndices) )\r\n                for J in columnIndices:\r\n                    \r\n                    ####### MNXC2 revisement with private variable to make the code more manageable.\r\n                    self.mnxc2( I, J, self.__shapeCropped )\r\n                    \r\n                    #### Find maximum positions ####    \r\n                    self.locatePeak( I, J )\r\n                    \r\n                    if self.verbose: \r\n                        print( \"# \" + str(I) + \"->\" + str(J) + \" shift: [%.2f\"%self.__shiftsTriMat[I,J,0] \r\n                            + \", %.2f\"%self.__shiftsTriMat[I,J,1]\r\n                            + \"], cc: %.6f\"%self.__corrTriMat[I,J] \r\n                            + \", peak sig: %.3f\"%self.__peaksigTriMat[I,J] )    \r\n                        \r\n                    # Correlation stats is for establishing correlation scores for fixed-pattern noise.\r\n                    if bool( self.trackCorrStats ):\r\n                        # Track the various statistics about the correlation map, mean, std, max, skewness\r\n                        self.calcCorrStats( currIndex, triIndices )\r\n                        \r\n                    # triMode 'auto' diagonal mode    \r\n                    if self.triMode == u'auto' and (self.__peaksigTriMat[I,J] <= self.peaksigThres or J-I >= self.autoMax):\r\n                        if self.verbose: print( \"triMode 'auto' stopping at frame: \" + str(J) )\r\n                        break\r\n                    currIndex += 1\r\n                pass # C max position location\r\n        \r\n        \r\n\r\n        if bool( np.any( self.fouCrop ) ):\r\n            self.__shiftsTriMat[:,:,0] *= self.shapePadded[0] \/ self.__shapeCropped[0]\r\n            self.__shiftsTriMat[:,:,1] *= self.shapePadded[1] \/ self.__shapeCropped[1]\r\n        \r\n        self.bench['xcorr3'] = time.time()\r\n        # Pointer reference house-keeping\r\n        del templateMaskFFT, tempComplex, tempComplex2 # Pointer\r\n        return\r\n\r\n        \r\n    def mnxc2( self, I, J, shapeCropped, refine=False ):\r\n        \"\"\"\r\n        2-D Masked, Intensity Normalized, Cross-correlation\r\n        \"\"\"\r\n        tempComplex = self.__tempComplex # Pointer re-assignment\r\n        tempComplex2 = self.__tempComplex2 # Pointer re-assignment\r\n        maskProduct = self.__maskProduct\r\n        normConst2 = self.__normConst2\r\n        \r\n        if not self.masks.shape[0] == 1:\r\n            # Compute maskProduct, term is M1^* .* M2\r\n            baseMask_block = self.__baseMaskFFT[J,:,:]; templateMaskFFT = self.__templateMaskFFT # Pointer re-assignment\r\n            tempComplex2 = nz.evaluate( \"templateMaskFFT * baseMask_block\" )\r\n            self.__IFFT2.update_arrays( tempComplex2, tempComplex ); self.__IFFT2.execute()\r\n            # maskProduct = np.clip( np.round( np.real( tempComplex ) ), eps, np.Inf )\r\n            self.__maskProduct = nz.evaluate( \"real(tempComplex)*normConst2\" )\r\n            \r\n        # Compute mask correlation terms\r\n        if self.masks.shape[0] == 1:\r\n            templateImageFFT = self.__templateImageFFT; baseMask_block = self.__baseMaskFFT # Pointer re-assignment\r\n        self.__IFFT2.update_arrays( nz.evaluate( \"baseMask_block * templateImageFFT\"), tempComplex ); self.__IFFT2.execute()\r\n        \r\n\r\n        Corr_templateMask = nz.evaluate( \"real(tempComplex)*normConst2\" ) # Normalization\r\n        \r\n        baseImageFFT_block = self.__baseImageFFT[J,:,:]; templateMaskFFT = self.__templateMaskFFT\r\n        self.__IFFT2.update_arrays( nz.evaluate( \"templateMaskFFT * baseImageFFT_block\"), tempComplex ); self.__IFFT2.execute()\r\n\r\n        # These haven't been normalized, so let's do so.  They are FFT squared, so N*N\r\n        # This reduces the strain on single-precision range.\r\n        Corr_baseMask =  nz.evaluate( \"real(tempComplex)*normConst2\" ) # Normalization\r\n\r\n        # Compute the intensity normalzaiton for the template\r\n        if self.masks.shape[0] == 1:\r\n            baseMaskFFT = self.__baseMaskFFT; templateSquaredFFT = self.__templateSquaredFFT\r\n            self.__IFFT2.update_arrays( nz.evaluate( \"baseMaskFFT * templateSquaredFFT\"), tempComplex ); self.__IFFT2.execute()\r\n        else:\r\n            self.__IFFT2.update_arrays( nz.evaluate( \"baseMaskFFT_block * templateSquaredFFT\"), tempComplex ); self.__IFFT2.execute()\r\n\r\n        # DenomTemplate = nz.evaluate( \"real(tempComplex)*normConst2 - real( Corr_templateMask * (Corr_templateMask \/ maskProduct) )\" )\r\n        \r\n        # Compute the intensity normalzaiton for the base Image\r\n        baseSquared_block = self.__baseSquaredFFT[J,:,:]\r\n        self.__IFFT2.update_arrays( nz.evaluate( \"templateMaskFFT * baseSquared_block\"), tempComplex2 ); self.__IFFT2.execute()\r\n        \r\n        # Compute Denominator intensity normalization\r\n        # DenomBase = nz.evaluate( \"real(tempComplex2)*normConst2- real( Corr_baseMask * (Corr_baseMask \/ maskProduct) )\" )\r\n        Denom = nz.evaluate( \"sqrt( (real(tempComplex2)*normConst2- real( Corr_baseMask * (Corr_baseMask \/ maskProduct)))\" + \r\n            \"* (real(tempComplex)*normConst2 - real( Corr_templateMask * (Corr_templateMask \/ maskProduct)) ) )\" )\r\n            \r\n        # What happened to numexpr clip?\r\n        Denom = np.clip( Denom, 1, np.Inf )\r\n        # print( \"Number of small Denominator values: \" + str(np.sum(DenomTemplate < 1.0)) )\r\n        \r\n        # Compute Numerator (the phase correlation)\r\n        tempComplex2 = nz.evaluate( \"baseImageFFT_block * templateImageFFT\" )\r\n        self.__IFFT2.update_arrays( tempComplex2, tempComplex ); self.__IFFT2.execute()\r\n        # Numerator = nz.evaluate( \"real(tempComplex)*normConst2 - real( Corr_templateMask * Corr_baseMask \/ maskProduct)\" ) \r\n        \r\n        # Compute final correlation\r\n        self.__C = nz.evaluate( \"(real(tempComplex)*normConst2 - real( Corr_templateMask * Corr_baseMask \/ maskProduct)) \/ Denom\" )\r\n        \r\n\r\n        # print( \"%%%% mnxc2.Denom.dtype = \" + str(Denom.dtype) )\r\n        self.__originTriMat[I,J] = self.__C[0,0]\r\n        if bool(self.suppressOrigin):\r\n            # If gain reference is quite old we can still get one bright pixel at the center.\r\n            # The hot pixel filter has mitigated this but it's still a minor source of bias.\r\n            self.__C[0,0] = 0.125 * ( self.__C[1,0] + self.__C[0,1] + self.__C[-1,0] + self.__C[-1,0] +\r\n                self.__C[1,1] + self.__C[-1,1] + self.__C[-1,1] + self.__C[-1,-1] )\r\n            \r\n        # We have everything in normal FFT order until here; Some speed-up could be found by its removal.\r\n        # Pratically we don't have to do this fftshift, but it makes plotting easier to understand\r\n        self.__C = np.fft.ifftshift( self.__C )\r\n\r\n        # We can crop C if maxShift is not None and preShift is False\r\n        if self.maxShift is not None and self.preShift is False:\r\n            shapeCropped2 = (np.array(shapeCropped)\/2.0).astype('int')\r\n            self.__C = self.__C[shapeCropped2[0]-self.maxShift:shapeCropped2[0]+self.maxShift, shapeCropped2[1]-self.maxShift:shapeCropped2[1]+self.maxShift]\r\n\r\n     \r\n        del normConst2, baseMask_block, templateMaskFFT, templateImageFFT, Corr_templateMask, baseImageFFT_block\r\n        del Corr_baseMask, baseSquared_block, baseMaskFFT, templateSquaredFFT, maskProduct\r\n        del tempComplex, tempComplex2\r\n    \r\n    def locatePeak( self, I, J ):\r\n        \"\"\"\r\n        Subpixel peak location by Fourier interpolation.\r\n        \"\"\"\r\n        tempComplex = self.__tempComplex;  tempComplex2 = self.__tempComplex2\r\n        # Apply B-factor low-pass filter to correlation function\r\n        if self.Bmode == 'opti':\r\n            self.bench['opti0'] = time.time()\r\n            # Want to define this locally so it inherits scope variables.\r\n            def inversePeakContrast( Bsigma ):\r\n                self.__C_filt = scipy.ndimage.gaussian_filter( self.__C, Bsigma )\r\n                return  np.std(self.__C_filt ) \/ (np.max(self.__C_filt ) - np.mean(self.__C_filt ) )\r\n                    \r\n            # B_opti= scipy.optimize.fminbound( inversePeakContrast, 0.0, 10.0, xtol=1E-3 )\r\n            sigmaOptiMax = 7.0\r\n            sigmaOptiMin = 0.0\r\n            maxIter = 15 # Let's apply some more constraints to speed this up\r\n            tolerance = 0.01\r\n            result = scipy.optimize.minimize_scalar( inversePeakContrast, \r\n                                    bounds=[sigmaOptiMin,sigmaOptiMax], method=\"bounded\", \r\n                                    options={'maxiter':maxIter, 'xatol':tolerance }  )\r\n                                    \r\n            self.__C_filt = scipy.ndimage.gaussian_filter( self.__C, result.x )\r\n            self.bench['opti0'] = time.time()\r\n            if self.verbose >= 2:\r\n                print( \"Found optimum B-sigma: %.3f\"%result.x + \", with peak sig: %.3f\"%(1.0\/result.fun)+\" in %.1f\"%(1E3*(self.bench['opti1']-self.bench['opti0']))+\" ms\" ) \r\n        elif bool(self.Brad) and self.Bmode =='fourier':\r\n            tempComplex = self.__C.astype(fftw_dtype)\r\n            self.__FFT2.update_arrays( tempComplex, tempComplex2 ); self.__FFT2.execute()\r\n            Bfilter = self.__Bfilter\r\n            self.__IFFT2.update_arrays( nz.evaluate( \"tempComplex2*Bfilter\" ), tempComplex ); self.__IFFT2.execute()\r\n            # Conservation of counts with Fourier filtering is not \r\n            # very straight-forward.\r\n            C_filt = nz.evaluate( \"real( tempComplex )\/sqrt(normConst)\" )\r\n        elif bool(self.Brad) and self.Bmode == u'conv' or self.Bmode == u'convolution':\r\n            # Convert self.Brad as an MTF to an equivalent sigma for a PSF\r\n            # TODO: Check that Bsigma is correct with Fourier cropping\"\r\n            Bsigma = self.shapePadded \/ (np.sqrt(2) * np.pi * self.Brad)\r\n            # Scipy's gaussian filter conserves total counts\r\n            self.__C_filt = scipy.ndimage.gaussian_filter( self.__C, Bsigma )\r\n        else: # No filtering\r\n            self.__C_filt = self.__C\r\n        \r\n   \r\n        # Apply maximum shift max mask, if present\r\n        if bool( self.maxShift ):\r\n            \r\n            # for previous frame alignment compensation, we need to shift the mask around...\r\n            C_filt = self.__C_filt\r\n            if bool( self.preShift ):\r\n                # print( \"In pre-shift\" )\r\n                # This isn't working with 'refine'\r\n                if self.triMode != u'refine':\r\n                    rolledMask = np.roll( np.roll( self.__mask_maxShift, \r\n                        np.round(self.__shiftsTriMat[I,J-1,0]).astype('int'), axis=0 ), \r\n                        np.round(self.__shiftsTriMat[I,J-1,1]).astype('int'), axis=1 )\r\n                elif self.triMode == u'refine':\r\n                    # With refine the matrix is populated like an autocorrelation function.\r\n                    rolledMask = np.roll( np.roll( self.__mask_maxShift, \r\n                        np.round(self.__shiftsTriMat[I-1,I-1,0]).astype('int'), axis=0 ), \r\n                        np.round(self.__shiftsTriMat[I-1,I-1,1]).astype('int'), axis=1 )\r\n                    pass\r\n                C_masked = nz.evaluate(\"C_filt*rolledMask\")\r\n                cmaxpos = np.unravel_index( np.argmax( C_masked ), C_masked.shape )\r\n                self.__peaksigTriMat[I,J] = (C_masked[cmaxpos] - np.mean(C_filt[rolledMask]))\/ np.std(C_filt[rolledMask])\r\n            else:\r\n                mask_maxShift = self.__mask_maxShift\r\n                C_masked = nz.evaluate(\"C_filt*mask_maxShift\")\r\n                cmaxpos = np.unravel_index( np.argmax( C_masked ), C_filt.shape )\r\n                self.__peaksigTriMat[I,J] = (C_masked[cmaxpos] - np.mean(C_filt[self.__mask_maxShift]))\/ np.std(C_filt[self.__mask_maxShift])\r\n        else: # No maxshift\r\n            cmaxpos = np.unravel_index( np.argmax(C_filt), C_filt.shape )\r\n            self.__peaksigTriMat[I,J] = (self.__corrTriMat[I,J] - np.mean(C_filt))\/ np.std(C_filt)\r\n        \r\n        if self.saveC:\r\n            # Maybe save in a pyTable if it's really needed.peaksig\r\n            if self.preShift:\r\n                self.C.append(self.__C_filt*rolledMask)\r\n            else:\r\n                self.C.append(self.__C_filt)\r\n                \r\n        if self.subPixReg > 1.0: # Subpixel peak estimation by Fourier interpolation\r\n\r\n            Csub = C_filt[cmaxpos[0]-self.__subR:cmaxpos[0]+self.__subR, cmaxpos[1]-self.__subR:cmaxpos[1]+self.__subR ]\r\n                \r\n            # Csub is shape [2*subR, 2*subR]\r\n            if Csub.shape[0] == 2*self.__subR and Csub.shape[1] == 2*self.__subR:\r\n                self.__subFFT2.update_arrays( Csub.astype( fftw_dtype ), self.__CsubFFT ); self.__subFFT2.execute()\r\n                # padding has to be done from the middle\r\n                # TODO: I think pad has issues with complex numbers?\r\n                #CpadFFT = np.pad( np.fft.fftshift(self.__CsubFFT), ((self.subPixReg-1)*self.__subR,), mode=b'constant', constant_values=(0.0,)  )\r\n                \r\n\r\n                self.__CpadFFT = np.zeros( [self.subPixReg*self.__subR*2,self.subPixReg*self.__subR*2], dtype=fftw_dtype )\r\n                \r\n                # NUMPY BUG: mode has to be a byte string\r\n                \r\n                self.__CpadFFT.real = np.pad( np.fft.fftshift(self.__CsubFFT.real), ((self.subPixReg-1)*self.__subR,), mode=constantPad, constant_values=(0.0,)  )\r\n                self.__CpadFFT.imag = np.pad( np.fft.fftshift(self.__CsubFFT.imag), ((self.subPixReg-1)*self.__subR,), mode=constantPad, constant_values=(0.0,)  )\r\n                self.__CpadFFT = np.fft.ifftshift( self.__CpadFFT )\r\n                self.__subIFFT2.update_arrays( self.__CpadFFT, self.__Csub_over ); self.__subIFFT2.execute()\r\n                # Csub_overAbs = nz.evaluate( \"abs( Csub_over )\") # This is still complex\r\n                Csub_overAbs = np.abs( self.__Csub_over )\r\n                \r\n                \r\n                Csub_maxpos = np.unravel_index( np.argmax( Csub_overAbs ), Csub_overAbs.shape )\r\n\r\n                round_pos = cmaxpos - np.array(self.__C.shape)\/2.0\r\n                # Csub_max is being shifted 1 sub-pixel in the negative direction compared to the integer shift\r\n                # because of array centering, hence the np.sign(round_pos)\r\n                remainder_pos = Csub_maxpos - np.array(self.__Csub_over.shape)\/2.0 + np.sign( round_pos )\r\n                remainder_pos \/= self.subPixReg\r\n                \r\n                # shiftsTriMat[I,J-1,:] = cmaxpos + np.array( Csub_maxpos, dtype='float' )\/ np.float(self.subPixReg) - np.array( [subR, subR] ).astype('float')\r\n                self.__shiftsTriMat[I,J,:] = round_pos + remainder_pos\r\n                # Switching from FFTpack to pyFFTW has messed up the scaling of the correlation coefficients, so\r\n                # scale by (subR*2.0)**2.0\r\n                self.__corrTriMat[I,J] = Csub_overAbs[ Csub_maxpos[0], Csub_maxpos[1] ] \/ (self.__subR*2.0)**2.0\r\n            else:\r\n                print( \"Correlation sub-area too close to maxShift!  Subpixel location broken.  Consider increasing maxShift.\" )\r\n                self.__shiftsTriMat[I,J,:] = cmaxpos - np.array(self.__C.shape)\/2.0\r\n                self.__corrTriMat[I,J] = self.__C[ cmaxpos[0], cmaxpos[1] ]   \r\n        else: # Do integer pixel registration\r\n            self.__shiftsTriMat[I,J,:] = cmaxpos - np.array(self.__C.shape)\/2.0\r\n            self.__corrTriMat[I,J] = self.__C[ cmaxpos[0], cmaxpos[1] ] \r\n            \r\n\r\n            \r\n        del tempComplex, tempComplex2\r\n        try: \r\n            del mask_maxShift, Bfilter \r\n        except: pass\r\n        pass\r\n    \r\n\r\n    def calcCorrStats( self, currIndex, triIndices ):\r\n        # Track the various statistics about the correlation map, mean, std, max, skewness\r\n        if currIndex == 0 or self.corrStats is None:\r\n            # Mean, std, max, maxposx, maxposy, (val at 0,0), imageI mean, imageI std, imageJ mean, imageJ std =  10 columns\r\n            K = np.sum(triIndices)\r\n            self.corrStats = {}\r\n            self.corrStats[u'K'] = K\r\n            self.corrStats[u'meanC'] = np.zeros([K])\r\n            self.corrStats[u'varC'] = np.zeros([K])\r\n            self.corrStats[u'maxC'] = np.zeros([K])\r\n            self.corrStats[u'maxPos'] = np.zeros([K,2])\r\n            self.corrStats[u'originC'] = np.zeros([K])\r\n            print( \"Computing stack mean\" )\r\n            self.corrStats[u'stackMean'] = np.mean( self.images )\r\n            print( \"Computing stack variance\" )\r\n            self.corrStats[u'stackVar'] = np.var( self.images )\r\n            \r\n        self.corrStats[u'meanC'][currIndex] = np.mean(self.__C_filt)\r\n        self.corrStats[u'varC'][currIndex] = np.var(self.__C_filt)\r\n        self.corrStats[u'maxC'][currIndex] = np.max(self.__C_filt)\r\n        self.corrStats[u'maxPos'][currIndex,:] = np.unravel_index( np.argmax(self.__C_filt), \\\r\n                                                self.__shapeCropped ) - \\\r\n                                                np.array([self.__C_filt.shape[0]\/2, self.__C_filt.shape[1]\/2])\r\n        self.corrStats[u'originC'][currIndex] = self.__C_filt[self.__C.shape[0]\/2, self.__C.shape[1]\/2]   \r\n    \r\n                        \r\n    def shiftsSolver( self, shiftsTriMat_in, corrTriMat_in, peaksigTriMat_in, \r\n                     acceptedEqns=None, mode='basin', Niter=100 ):\r\n        \"\"\"\r\n        Functional minimization optimization of the triangular correlation matrix\r\n        \r\n        Minimizes the RMS error for the individual frame position equations, and \r\n        outputs an error dictionary.\r\n        \r\n            acceptedEqns is 'good' equations as determined by a previous run.  \r\n                Should always be None for the first iteration.\r\n            \r\n            mode can be 'basin' for the global optimizer or 'local' for the local optimizer.\r\n                In general the performance penalty for the global optimizer is trivial.\r\n                \r\n            Niter is the number of iterations for the \r\n        \"\"\"\r\n        \r\n\r\n        # Change to allow the autocorrelations to be present, but we never want them in the solver\r\n        shiftsTriMat = shiftsTriMat_in[:-1,1:,:]\r\n        corrTriMat = corrTriMat_in[:-1,1:]\r\n        peaksigTriMat = peaksigTriMat_in[:-1,1:]\r\n        triIndices = corrTriMat.astype( 'bool' )\r\n        \r\n        # Build a dictionary of all the feedback parameters \r\n        errorDict = {}\r\n        # Append the dictionary to the list of dicts and return it as well\r\n        self.errorDictList.append( errorDict )\r\n        errorDict['corrTriMat'] = corrTriMat_in\r\n        errorDict['peaksigTriMat'] = peaksigTriMat_in\r\n\r\n        shapeImage = np.array( [self.images.shape[1], self.images.shape[2]] )\r\n        N = np.asarray( self.images.shape )[0] - 1\r\n        last_col = np.zeros( N, dtype='int' )\r\n            \r\n        #### BUILD VECTORIZED SHIFTS b_x, b_y AND EQUATION COEFFICIENT MATRIX Acoeff\r\n        M = 0\r\n        for I in np.arange(0,N, dtype='int'):\r\n            # Find the last non-zero element in the tri-matrix for each row\r\n            # This determines the sub-sampled view for each equation set.\r\n            if triIndices[I,:].any():\r\n                last_col[I] = np.argwhere(triIndices[I,:])[-1] + 1\r\n                M += last_col[I] - I\r\n        \r\n        # For some reason this becomes -1 if we make last_col not float.\r\n        M = np.int(M)\r\n        Acoeff = np.zeros( [M,N] )\r\n        Arow_pos = 0\r\n        for I in np.arange(0,N, dtype='int'):\r\n            rotview = np.rot90( triIndices[I:last_col[I],I:last_col[I]], k=2 )\r\n            Acoeff[ Arow_pos:Arow_pos+rotview.shape[0], I:I+rotview.shape[1] ] = rotview\r\n            Arow_pos += rotview.shape[0]\r\n            \r\n        #  triIndices = corrTriMat.astype( 'bool' )\r\n        # Now we can ravel triIndices and get the indices from that\r\n        vectorIndices = np.arange(0,triIndices.size)[np.ravel( triIndices )]\r\n        # And this is to go backwards from a vector to an upper-triangular matrix\r\n        unravelIndices = np.unravel_index( vectorIndices, [N,N] )    \r\n\r\n        b_x = np.ravel( shiftsTriMat[triIndices,1] )\r\n        b_y = np.ravel( shiftsTriMat[triIndices,0] )\r\n        \r\n        #### REMOVE UNACCEPTED EQUATIONS FROM THE SOLVER ####\r\n        # This was a cornerstone of MotionCorr but it often leads to problems, so let's avoid it completely\r\n        # in favour of deweighting bad equations.\r\n        if acceptedEqns is None:\r\n            Maccepted = M\r\n            acceptedEqns = np.ones_like( b_x, dtype='bool' )\r\n        else:\r\n            Maccepted = np.sum( acceptedEqns )\r\n        print( \"Optimization of shifts over M = \" + str(Maccepted) + \" equations.\" )\r\n        \r\n        #### WEIGHTS FOR OPTIMIZATION ####\r\n        # There's only 2.5 % difference between the weighted and un-weighted versions for the STEM test cases.\r\n        # CryoEM would be expected to be higher as the CC's are about 0.001 compared to 0.3\r\n        if self.weightMode is None or self.weightMode == u'corr': # use raw correlation scores or peaksig\r\n            weights =  np.ravel( peaksigTriMat[triIndices] )\r\n        elif self.weightMode is u'unweighted': # don't weight peaks\r\n            weights = np.ones_like( np.ravel( peaksigTriMat[triIndices] ) )\r\n        elif self.weightMode == u'norm' or self.weightMode == u'normalized':\r\n            ### Scale the weights so that lower correlations count for next-to-nothing\r\n            weights = util.normalize( np.ravel( peaksigTriMat[triIndices] ) )\r\n        elif self.weightMode == u'autologistic':\r\n            # Calculate a logistic from the CDF of the peaksig values\r\n            self.cdfLogisticCurve() # Sets peaksigThres, logisticK, and logisticNu\r\n            \r\n            peakSig = np.ravel( peaksigTriMat[triIndices] ).astype( 'float64' )\r\n            weights = 1.0 - 1.0 \/ (1.0 + np.exp( -self.logisticK*(-peakSig + self.peaksigThres) ) )**self.logisticNu\r\n        elif self.weightMode == u'logistic':\r\n            # Use a fixed \r\n            peakSig = np.ravel( peaksigTriMat[triIndices] ).astype( 'float64' )\r\n            weights = 1.0 - 1.0 \/ (1.0 + np.exp( -self.logisticK*(-peakSig + self.peaksigThres) ) )**self.logisticNu\r\n        else:   \r\n            print( \"UNKNOWN WEIGHTING METHOD, REVERTING TO CORRELATION SCORES\" )\r\n            weights =  np.ravel( peaksigTriMat[triIndices] )\r\n#            logisticCutoff = 0.01 # Value of logistic weight at the cutoff Correlation threshold. Should never, ever be below 0.5\r\n#            C_cutoff = (1\/self.weightK)* np.log( 1.0 \/ logisticCutoff - 1 )\r\n#            if self.corrThres is None:\r\n#                raise AssertionError(\"Zorro.shiftsSolver requires a correlation threshold for logistical weighting\")\r\n#            weights = 1.0 \/ ( 1.0 + self.weightK * np.exp(np.ravel( peaksigTriMat[triIndices] ) - self.corrThres - C_cutoff) ) \r\n            \r\n\r\n        \r\n        #### REMOVE UNACCEPTED EQUATIONS FROM THE SOLVER ####\r\n        if acceptedEqns is None:\r\n            Maccepted = M\r\n            acceptedEqns = np.ones_like( b_x, dtype='bool' )\r\n        else:\r\n            Maccepted = np.sum( acceptedEqns )\r\n        \r\n        #### SETUP THE FUNCTIONAL OPTIMIZER ####\r\n        pix_tol = 1.0E-5 # The fraction of a pixel we try to solve to (so one 10'000th of a pixel)\r\n        relativeEst = np.zeros( [N, 2] )\r\n        drift_guess = np.zeros( N )\r\n        bounds = np.ones( [N,2] )\r\n        bounds[:,0] = -1.0\r\n        # Bounds scales by self.maxShift * number of frames\r\n        if self.maxShift is None:\r\n            bounds *= np.min( [shapeImage[0]\/2.0, shapeImage[1]\/2.0] )\r\n        else:\r\n            bounds *= np.min( [shapeImage[0]\/2.0, shapeImage[1]\/2.0, N*self.maxShift] )\r\n            \r\n        if mode == u'local':\r\n            #### LOCAL MINIMIZATION X, Y SOLUTION ####\r\n            # Is there any value for a simultaneous X-Y solution?  No, because the A-coefficient \r\n            # matrix would be:\r\n            #     Acoeff2 = np.hstack( (np.vstack( (Acoeff, zeroA) ), np.vstack( (zeroA, Acoeff) )) )\r\n            # So the two sets of equations are completely independent\r\n            try:\r\n                outX = scipy.optimize.minimize( util.weightedErrorNorm, drift_guess, method=\"L-BFGS-B\", \r\n                    args=(Acoeff, b_x, weights*acceptedEqns), \r\n                    bounds=bounds, tol=pix_tol  )\r\n#                outX = scipy.optimize.minimize( weightedErrorNorm, drift_guess, method=\"L-BFGS-B\", \r\n#                    args=(Acoeff[acceptedEqns,:], b_x[acceptedEqns], weights[acceptedEqns]), \r\n#                    bounds=bounds, tol=pix_tol  )\r\n                relativeEst[:,1] = outX.x\r\n            except:\r\n                raise RuntimeError( \"Error: caught exception on X-minimizer\" )\r\n\r\n            try:   \r\n                outY = scipy.optimize.minimize( util.weightedErrorNorm, drift_guess, method=\"L-BFGS-B\", \r\n                    args=(Acoeff, b_y, weights*acceptedEqns), \r\n                    bounds=bounds, tol=pix_tol  )\r\n                relativeEst[:,0] = outY.x\r\n            except:\r\n                raise RuntimeError( \"Error: caught exception on Y-minimizer\" )\r\n                \r\n        elif mode == u'basin':\r\n            #### GLOBAL MINIMIZATION X, Y SOLUTION ####\r\n            basinArgs = {}\r\n            basinArgs[u\"bounds\"] = bounds\r\n            basinArgs[u\"tol\"] = pix_tol\r\n            basinArgs[u\"method\"] =  u\"L-BFGS-B\"\r\n            basinArgs[u\"args\"] = (Acoeff, b_x, weights*acceptedEqns)\r\n            try:\r\n                outX = scipy.optimize.basinhopping( util.weightedErrorNorm, drift_guess, niter=Niter, minimizer_kwargs=basinArgs )\r\n                relativeEst[:,1] = outX.x\r\n            except:\r\n                raise RuntimeError( \"Error: caught exception on X-minimizer\" )   \r\n            # basinArgs[\"args\"] = (Acoeff[acceptedEqns], b_y[acceptedEqns], weights[acceptedEqns])\r\n            basinArgs[u\"args\"] = (Acoeff, b_y, weights*acceptedEqns)\r\n            try:\r\n                outY = scipy.optimize.basinhopping( util.weightedErrorNorm, drift_guess, niter=Niter, minimizer_kwargs=basinArgs )\r\n                relativeEst[:,0] = outY.x\r\n            except:\r\n                raise RuntimeError( \"Error: caught exception on Y-minimizer\" )   \r\n                \r\n        else:\r\n            print( \"Error: mode not understood by shiftsMinimizer: \" + mode )\r\n            return\r\n        \r\n        #### ERROR ANALYSIS (for precision of estimated shifts) ####\r\n        acceptedEqnsUnraveled = np.zeros( [N,N] )\r\n        acceptedEqnsUnraveled[unravelIndices[0], unravelIndices[1]] = acceptedEqns\r\n        acceptedEqnsUnraveled = np.pad( acceptedEqnsUnraveled, ((0,1),(1,0)), mode=constantPad )\r\n        \r\n        # Ok so how big is relativeEst?  Can we add in zeros?\r\n        # Or maybe I should just give weights as weights*acceptedEqnsUnr\r\n        errorXY = np.zeros( [M,2] )\r\n        \r\n        ############# Unweighted error ################\r\n        \"\"\"\r\n        errorXY[:,1] = np.dot( Acoeff, relativeEst[:,1] ) - b_x\r\n        errorXY[:,0] = np.dot( Acoeff, relativeEst[:,0] ) - b_y\r\n        \r\n        errorNorm = np.sqrt( errorXY[:,0]*errorXY[:,0] + errorXY[:,1]*errorXY[:,1] )\r\n \r\n        mean_errorNorm = np.mean( errorNorm[acceptedEqns] )\r\n        std_errorNorm = np.std( errorNorm[acceptedEqns] )\r\n    \r\n        # Error unraveled (i.e. back to the upper triangular matrix form)\r\n        errorUnraveled = np.zeros( [N,N] )\r\n        errorXun = np.zeros( [N,N] )\r\n        errorYun = np.zeros( [N,N] )\r\n        errorUnraveled[unravelIndices[0], unravelIndices[1]] = errorNorm\r\n        errorXun[unravelIndices[0], unravelIndices[1]] = np.abs( errorXY[:,1] )\r\n        errorYun[unravelIndices[0], unravelIndices[1]] = np.abs( errorXY[:,0] )\r\n        \r\n        errorXun = np.pad( errorXun, ((0,1),(1,0)), mode=constantPad )\r\n        errorYun = np.pad( errorYun, ((0,1),(1,0)), mode=constantPad )\r\n        triPadded = np.pad( triIndices, ((0,1),(1,0)), mode=constantPad )\r\n        \r\n        # Mask out un-used equations from error numbers\r\n        errorYun = errorYun * acceptedEqnsUnraveled\r\n        errorXun = errorXun * acceptedEqnsUnraveled\r\n        triPadded = triPadded * acceptedEqnsUnraveled    \r\n\r\n        # errorX and Y are per-frame error estimates\r\n        errorX = np.zeros( N+1 )\r\n        errorY = np.zeros( N+1 )\r\n        # Sum horizontally and vertically, keeping in mind diagonal is actually at x-1\r\n        for J in np.arange(0,N+1):\r\n            # Here I often get run-time warnings, which suggests a divide-by-zero or similar.\r\n            try:\r\n                errorX[J] = ( np.sum( errorXun[J,:]) + np.sum(errorXun[:,J-1]) ) \/ ( np.sum( triPadded[J,:]) + np.sum(triPadded[:,J-1]) )\r\n            except:\r\n                pass\r\n            try:\r\n                errorY[J] = ( np.sum( errorYun[J,:]) + np.sum(errorYun[:,J-1]) ) \/ ( np.sum( triPadded[J,:]) + np.sum(triPadded[:,J-1]) )\r\n            except:\r\n                pass\r\n        \"\"\"\r\n\r\n        ################## Weighted error ######################\r\n        # Make any zero weight just very small\r\n        weights = np.clip( weights, 1E-6, np.Inf )\r\n        \r\n        errorXY[:,1] = np.dot( Acoeff, relativeEst[:,1] ) - b_x\r\n        errorXY[:,0] = np.dot( Acoeff, relativeEst[:,0] ) - b_y\r\n        \r\n        errorNorm = np.sqrt( errorXY[:,0]*errorXY[:,0] + errorXY[:,1]*errorXY[:,1] )\r\n\r\n        acceptedErrorNorm = errorNorm[acceptedEqns]\r\n        \r\n        mean_errorNorm = np.sum( weights * acceptedErrorNorm ) \/ np.sum(weights)\r\n        mean_unweighted = np.mean( errorNorm[acceptedEqns] )\r\n        \r\n        # print( \"RMS: \" + str(np.sum( weights * acceptedErrorNorm**2 )) )\r\n        # print( \"Normed RMS: \" + str(np.sum( weights * acceptedErrorNorm**2 ) \/ np.sum(weights)))\r\n        # print( \"mean_errorNorm**2 + \" + str(  mean_errorNorm**2 ))\r\n        std_errorNorm = np.sqrt( np.sum( weights * acceptedErrorNorm**2 ) \r\n                \/ np.sum(weights) - mean_errorNorm**2 )\r\n        # np.sqrt( np.sum( unalignedHist * unalignedCounts**2 )\/ sumFromHist - meanFromHist*meanFromHist  )\r\n\r\n        std_unweighted = np.std( acceptedErrorNorm )\r\n        # print( \"sum(acceptedErrorNorm): %f\" % np.sum(acceptedErrorNorm) )\r\n        print( \"MEAN ERROR (weighted: %f | unweighted: %f )\" % (mean_errorNorm, mean_unweighted)  )\r\n        print( \"STD ERROR (weighted: %f | unweighted: %f )\" % (std_errorNorm, std_unweighted)  )\r\n        \r\n        # Error unraveled (i.e. back to the upper triangular matrix form)\r\n        errorUnraveled = np.zeros( [N,N] )\r\n        errorXun = np.zeros( [N,N] )\r\n        errorYun = np.zeros( [N,N] )\r\n        weightsUn = np.zeros( [N,N] )\r\n        errorUnraveled[unravelIndices[0], unravelIndices[1]] = errorNorm\r\n        weightsUn[unravelIndices[0], unravelIndices[1]] = weights\r\n        errorXun[unravelIndices[0], unravelIndices[1]] = np.abs( errorXY[:,1] )\r\n        errorYun[unravelIndices[0], unravelIndices[1]] = np.abs( errorXY[:,0] )\r\n        \r\n        errorXun = np.pad( errorXun, ((0,1),(1,0)), mode=constantPad )\r\n        errorYun = np.pad( errorYun, ((0,1),(1,0)), mode=constantPad )\r\n        triPadded = np.pad( triIndices, ((0,1),(1,0)), mode=constantPad )\r\n        weightsUn = np.pad( weightsUn, ((0,1),(1,0)), mode=constantPad )\r\n        \r\n        # DEBUG: weighted error trimats\r\n        # plot.ims( (errorXun, weightsUn, errorYun, acceptedEqnsUnraveled), titles=( \"errorXun\",\"weightsUn\",\"errorYun\", \"AcceptedUnraveled\") )\r\n        \r\n        # Mask out un-used equations from error numbers\r\n        errorYun = errorYun * acceptedEqnsUnraveled\r\n        errorXun = errorXun * acceptedEqnsUnraveled\r\n        triPadded = triPadded * acceptedEqnsUnraveled    \r\n\r\n        # errorX and Y are per-frame error estimates\r\n        errorX = np.zeros( N+1 )\r\n        errorY = np.zeros( N+1 )\r\n        # Sum horizontally and vertically, keeping in mind diagonal is actually at x-1\r\n        for J in np.arange(0,N+1):\r\n            try:\r\n                errorX[J] = ( ( np.sum( errorXun[J,:]*weightsUn[J,:]) + np.sum(errorXun[:,J-1]*weightsUn[:,J-1]) ) \/ \r\n                        ( np.sum( weightsUn[J,:]) + np.sum(weightsUn[:,J-1]) ) )\r\n            except:\r\n                print( \"Warning: per-frame error estimation failed, possibly due to zero-weight in solution solver\" )\r\n            try:\r\n                errorY[J] = ( ( np.sum( errorYun[J,:]*weightsUn[J,:]) + np.sum(errorYun[:,J-1]*weightsUn[:,J-1]) ) \/ \r\n                        ( np.sum( weightsUn[J,:]) + np.sum(weightsUn[:,J-1]) ) )\r\n            except:\r\n                print( \"Warning: per-frame error estimation failed, possibly due to zero-weight in solution solver\" )\r\n        #### END WEIGHTED ERROR ############\r\n        \r\n        # translations (to apply) are the negative of the found shifts\r\n        errorDict[u'translations'] = -np.vstack( (np.zeros([1,2]), np.cumsum( relativeEst, axis=0 ) ) )\r\n        errorDict[u'relativeEst'] = relativeEst\r\n        errorDict[u'acceptedEqns'] = acceptedEqns\r\n        # Not necessary to save triIndices, it's the non-zero elements of corrTriMat\r\n        # errorDict['triIndices'] = triIndices\r\n        errorDict[u'weights'] = weights\r\n        errorDict[u'errorXY'] = errorXY\r\n        errorDict[u'shiftsTriMat'] = shiftsTriMat_in\r\n        errorDict[u'errorX'] = errorX \r\n        errorDict[u'errorY'] = errorY \r\n        errorDict[u'errorUnraveled'] = errorUnraveled\r\n        errorDict[u'mean_errorNorm'] = mean_errorNorm\r\n        errorDict[u'std_errorNorm'] = std_errorNorm \r\n        errorDict[u'M'] = M\r\n        errorDict[u'Maccepted'] = Maccepted\r\n        \r\n        \r\n        return errorDict\r\n        \r\n    def alignImageStack( self ):\r\n        \"\"\"\r\n        alignImageStack does a masked cross-correlation on a set of images.  \r\n        masks can be a single mask, in which case it is re-used for each image, or \r\n        individual for each corresponding image.  \r\n        \r\n        Subpixel shifting is usually done with a large, shifted Lanczos resampling kernel. \r\n        This was found to be faster than with a phase gradient in Fourier space.\r\n        \"\"\"\r\n        \r\n        # Setup threading, pyFFTW is set elsewhere in planning\r\n        if self.n_threads is None:\r\n            self.n_threads = nz.detect_number_of_cores()\r\n        else:\r\n            nz.set_num_threads( self.n_threads )\r\n        print( \"Numexprz using %d threads and float dtype: %s\" % (nz.nthreads, float_dtype) )\r\n\r\n\r\n            \r\n        #Baseline un-aligned stack, useful for see gain reference problems\r\n        # self.unalignedSum = np.sum( self.images, axis=0 )\r\n        if np.any( self.shapeBinned ):\r\n            self.binStack()\r\n            \r\n        # It's generally more robust to do the hot pixel filtering after binning \r\n        # from SuperRes.\r\n        if self.filterMode != None and 'hot' in self.filterMode.lower():\r\n            self.hotpixFilter()\r\n            \r\n        # Do CTF measurement first, so we save processing if it can't fit the CTF\r\n        # Alternatively if CTFProgram == 'ctffind,sum' this is performed after alignment. \r\n        if bool(self.CTFProgram): \r\n            splitCTF = self.CTFProgram.lower().replace(' ','').split(',')\r\n            if len(splitCTF) == 1 and ( splitCTF[0] == u'ctffind' or splitCTF[0] == u'ctffind4.1'):\r\n                self.execCTFFind41( movieMode=True )\r\n            elif len(splitCTF) == 1 and ( splitCTF[0] == u'ctffind4' ):\r\n                self.execCTFFind4( movieMode=True )    \r\n            elif len(splitCTF) == 1 and (splitCTF[0] == u'gctf'): # Requires CUDA and GPU\r\n                self.execGCTF( movieMode=True )\r\n            \r\n\r\n            \r\n        \"\"\"\r\n        Registration, first run: Call xcorrnm2_tri to do the heavy lifting\r\n        \"\"\"\r\n        if self.xcorrMode.lower() == 'zorro':\r\n            \"\"\"\r\n            Application of padding.\r\n            \"\"\"\r\n            if np.any(self.shapePadded):\r\n                self.padStack()\r\n            \r\n            self.xcorrnm2_tri()\r\n\r\n            \"\"\"\r\n            Functional minimization over system of equations\r\n            \"\"\"\r\n            self.bench['solve0'] = time.time()\r\n            if self.triMode == u'first':\r\n                self.translations = -self.__shiftsTriMat[0,:]\r\n                self.errorDictList.append({})\r\n                self.errorDictList[-1][u'shiftsTriMat'] = self.__shiftsTriMat\r\n                self.errorDictList[-1][u'corrTriMat'] = self.__corrTriMat\r\n                self.errorDictList[-1][u'originTriMat'] = self.__originTriMat\r\n                self.errorDictList[-1][u'peaksigTriMat'] = self.__peaksigTriMat\r\n                self.errorDictList[-1][u'translations'] = self.translations.copy()\r\n            elif self.triMode == u'refine':\r\n                self.errorDictList.append({})\r\n                self.errorDictList[-1][u'shiftsTriMat'] = self.__shiftsTriMat\r\n                self.errorDictList[-1][u'corrTriMat'] = self.__corrTriMat\r\n                self.errorDictList[-1][u'originTriMat'] = self.__originTriMat\r\n                self.errorDictList[-1][u'peaksigTriMat'] = self.__peaksigTriMat\r\n                \r\n                m = self.images.shape[0]\r\n                self.translations = np.zeros( [m,2], dtype='float32' )\r\n    \r\n                for K in np.arange(m): \r\n                    self.translations[K,:] = -self.__shiftsTriMat[K,K,:]\r\n                self.errorDictList[-1][u'translations'] = self.translations.copy()\r\n                \r\n            else:\r\n                # Every round of shiftsSolver makes an error dictionary\r\n                self.shiftsSolver( self.__shiftsTriMat, self.__corrTriMat, self.__peaksigTriMat )\r\n                self.errorDictList[-1][u'originTriMat'] = self.__originTriMat\r\n                self.translations = self.errorDictList[-1][u'translations'].copy( order='C' )\r\n            self.bench['solve1'] = time.time()\r\n            \r\n            \"\"\"\r\n            Alignment and projection through Z-axis (averaging)\r\n            \"\"\"\r\n            if np.any(self.shapePadded): # CROP back to original size\r\n                self.cropStack()\r\n            self.applyShifts()\r\n        elif self.xcorrMode.lower() == 'unblur v1.02':\r\n            self.xcorr2_unblur1_02()\r\n        elif self.xcorrMode.lower() == 'motioncorr v2.1':\r\n            self.xcorr2_mc2_1()\r\n        elif self.xcorrMode.lower() == 'move only':\r\n            pass\r\n        else:\r\n            raise ValueError( \"Zorro.alignImageStack: Unknown alignment tool %s\" % self.xcorrMode )\r\n        \r\n\r\n        # Calculate CTF on aligned sum if requested\r\n        if bool(self.CTFProgram) and len(splitCTF) >= 2 and splitCTF[1]== u'sum':\r\n            if splitCTF[0] == u'ctffind' or splitCTF[0] == u'ctffind4.1':\r\n                self.execCTFFind41( movieMode=False )\r\n            elif splitCTF[0] == u'ctffind4':\r\n                self.execCTFFind4( movieMode=False )\r\n            elif splitCTF[0] == u'gctf': # Requires CUDA\r\n                self.execGCTF( movieMode=False )\r\n        \r\n        if bool(self.doEvenOddFRC):\r\n            self.evenOddFouRingCorr()\r\n        elif bool(self.doLazyFRC): # Even-odd FRC has priority\r\n            self.lazyFouRingCorr()\r\n\r\n        \r\n        \r\n        # Apply filters as a comma-seperated list.  Whitespace is ignored.\r\n        if bool( self.filterMode ):\r\n            splitFilter = self.filterMode.lower().replace(' ','').split(',')\r\n            if len(splitFilter) > 0:\r\n                self.bench['dose0'] = time.time()\r\n                for filt in splitFilter:\r\n                    if filt == u\"dose\" and not \"unblur\" in self.xcorrMode.lower():\r\n                        print( \"Generating dose-filtered sum\" )\r\n                        # Dose filter will ALWAYS overwrite self.filtSum because it has to work with individual frames\r\n                        self.doseFilter( normalize=False )\r\n                    elif filt == u\"dosenorm\" and not \"unblur\" in self.xcorrMode.lower():\r\n                        print( \"Generating Fourier-magnitude normalized dose-filtered sum\" )\r\n                        # Dose filter will ALWAYS overwrite self.filtSum because it has to work with individual frames\r\n                        self.doseFilter( normalize=True )\r\n                    elif filt == u\"background\":\r\n                        print( \"Removing 2D Gaussian background from micrograph\" )\r\n                        if not np.any(self.filtSum):\r\n                            self.filtSum = self.imageSum.copy()\r\n                        self.filtSum -= util.backgroundEstimate( self.filtSum )\r\n                    elif filt == u\"gausslp\":\r\n                        print( \"TODO: implement parameters for gauss filter\" )\r\n                        if not np.any(self.filtSum):\r\n                            self.filtSum = self.imageSum.copy()\r\n                        self.filtSum = scipy.ndimage.gaussian_filter( self.filtSum, 3.0 )\r\n                self.bench['dose1'] = time.time()\r\n        \r\n        \r\n        self.cleanPrivateVariables()\r\n        pass # End of alignImageStack\r\n        \r\n    def cleanPrivateVariables(self):\r\n        \"\"\"\r\n        Remove all private (\"__\") variables so the memory they occupy is released.\r\n        \"\"\"\r\n        # TODO: go through the code and see if there's anything large leftover.\r\n        try: del self.__FFT2, self.__IFFT2\r\n        except: pass\r\n        try:  del self.__subFFT2, self.__subIFFT2\r\n        except: pass\r\n        try: del self.__imageFFT\r\n        except: pass\r\n        try: del self.__Bfilter\r\n        except: pass\r\n        try: del self.__baseImageFFT, self.__baseMaskFFT, self.__baseSquaredFFT, self.__C\r\n        except: pass\r\n        \r\n    def applyShifts( self ):\r\n        self.bench['shifts0'] = time.time()\r\n        # Apply centroid origin, or origin at frame #0 position?\r\n        if self.originMode == u'centroid':\r\n            centroid = np.mean( self.translations, axis=0 )\r\n            self.translations -= centroid\r\n        # if self.originMode == None do nothing\r\n        \r\n        shifts_round = np.round( self.translations ).astype('int')\r\n        #shifts_remainder = self.translations - shifts_round\r\n        \r\n        # Use RAMutil.imageShiftAndCrop to do a non-circular shift of the images to \r\n        # integer pixel shifts, then subpixel with Lanczos\r\n        m = self.images.shape[0] # image count\r\n        if self.subPixReg > 1.0 and self.shiftMethod == u'fourier':\r\n            # Fourier gradient subpixel shift\r\n            # Setup FFTs for shifting.\r\n            FFTImage = np.empty( self.shapePadded, dtype=fftw_dtype )\r\n            RealImage = np.empty( self.shapePadded, dtype=fftw_dtype )\r\n            normConst = 1.0 \/ (self.shapePadded[0]*self.shapePadded[1])\r\n            # Make pyFFTW objects\r\n            _, IFFT2 = util.pyFFTWPlanner( FFTImage, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ), effort = self.fftw_effort, n_threads=self.n_threads, doForward=False )\r\n            [xmesh, ymesh] = np.meshgrid( np.arange(-RealImage.shape[1]\/2,RealImage.shape[1]\/2) \/ np.float(RealImage.shape[1] ), \r\n                np.arange(-RealImage.shape[0]\/2,RealImage.shape[0]\/2)\/np.float(RealImage.shape[0]) )\r\n            twoj_pi = np.complex64( -2.0j * np.pi )\r\n            \r\n            for J in np.arange(0,m):\r\n                # Normalize and reduce to float32\r\n                tX = self.translations[J,1]; tY = ymesh*self.translations[J,0]\r\n                FFTImage = self.__imageFFT[J,:,:] * np.fft.fftshift( nz.evaluate( \"exp(twoj_pi * (xmesh*tX + ymesh*tY))\")  )\r\n                             \r\n                IFFT2.update_arrays( FFTImage, RealImage ); IFFT2.execute()\r\n                # Normalize and reduce to float32\r\n                if self.images.shape[1] < RealImage.shape[0] or self.images.shape[2] < RealImage.shape[1]:\r\n                    self.images[J,:,:] = np.real( nz.evaluate( \"normConst * real(RealImage)\" ) ).astype(self.images.dtype)[:self.images.shape[1],:self.images.shape[2]]\r\n                else:\r\n                    self.images[J,:,:] = np.real( nz.evaluate( \"normConst * real(RealImage)\" ) ).astype(self.images.dtype)\r\n                \r\n                if self.verbose: print( \"Correction (fourier) \"+ str(np.around(self.translations[J,:],decimals=4))+\" applied to image: \" + str(J) )\r\n        \r\n        elif self.subPixReg > 1.0 and self.shiftMethod == u'lanczos':\r\n            # Lanczos realspace shifting\r\n            util.lanczosSubPixShiftStack( self.images, self.translations, n_threads=self.n_threads )\r\n\r\n            # Original unparallelized version\r\n#            shifts_remainder = self.translations - shifts_round\r\n#            for J in np.arange(0,m):\r\n#                # self.images[J,:,:] = util.imageShiftAndCrop( self.images[J,:,:], shifts_round[J,:] )\r\n#                #Roll the image instead to preserve information in the stack, in case someone deletes the original\r\n#                self.images[J,:,:] = np.roll( np.roll( self.images[J,:,:], shifts_round[J,0], axis=0 ), shifts_round[J,1], axis=1 )\r\n#                \r\n#                self.images[J,:,:] = util.lanczosSubPixShift( self.images[J,:,:], subPixShift=shifts_remainder[J,:], kernelShape=5, lobes=3 )\r\n#                \r\n#                if self.verbose: print( \"Correction (lanczos) \"+ str(np.around(self.translations[J,:],decimals=4))+\" applied to image: \" + str(J) )\r\n\r\n\r\n        else:\r\n            for J in np.arange(0,m):\r\n                # self.images[J,:,:] = util.imageShiftAndCrop( self.images[J,:,:], shifts_round[J,:] )\r\n                #Roll the image instead to preserve information in the stack, in case someone deletes the original\r\n                self.images[J,:,:] = np.roll( np.roll( self.images[J,:,:], shifts_round[J,0], axis=0 ), shifts_round[J,1], axis=1 )\r\n\r\n                if self.verbose: print( \"Correction (integer) \"+ str(shifts_round[J,:])+\" applied to image: \" + str(J) )\r\n                \r\n        # Also do masks (single-pixel precision only) if seperate for each image\r\n        if not self.masks is None and self.masks.shape[0] > 1:\r\n            for J in np.arange(0,m):\r\n                self.masks[J,:,:] = util.imageShiftAndCrop( self.masks[J,:,:], shifts_round[J,:] )\r\n                \r\n        # Build sum\r\n        self.imageSum = np.sum( self.images, axis=0 )\r\n        # Clean up numexpr pointers\r\n        try: del normConst, tX, tY, twoj_pi\r\n        except: pass\r\n        self.bench['shifts1'] = time.time()\r\n    \r\n    def __lanczosSubPixShiftStack( self ):\r\n        \r\n        tPool = mp.ThreadPool( self.n_threads )\r\n\r\n        slices = self.images.shape[0]\r\n        # Build parameters list for the threaded processeses, consisting of index\r\n        tArgs = [None] * slices\r\n        for J in np.arange(slices):\r\n            tArgs[J] = (J, self.images, self.translations)\r\n        \r\n        # All operations are done 'in-place' \r\n        tPool.map( util.lanczosIndexedShift, tArgs )\r\n        tPool.close()\r\n        tPool.join()\r\n        pass\r\n\r\n    def binStack( self, binKernel = 'fourier' ):\r\n        \"\"\"\r\n        binKernel can be 'lanczos2' or 'fourier', which does a Lanczos resampling or Fourier cropping, \r\n        respectively.  Lanczos kernel can only resample by powers of 2 at present.  \r\n        \r\n        The Lanczos kernel has some aliasing problems at present so it's use isn't advised yet.\r\n        \"\"\"\r\n        self.bench['bin0'] = time.time()\r\n        bShape2 = (np.array( self.shapeBinned ) \/ 2).astype('int')\r\n        binScale = np.array( [self.images.shape[1], self.images.shape[2]] ) \/ np.array( self.shapeBinned )\r\n        self.pixelsize *= np.mean( binScale )\r\n        print( \"Binning stack from %s to %s\" % (str(self.images.shape[1:]),str(self.shapeBinned)))\r\n        \r\n        if binKernel == u'lanczos2':\r\n            import math\r\n            binFact = [ np.floor( math.log( binScale[0], 2 ) ) ** 2, np.floor( math.log( binScale[1], 2 ) ) ** 2]\r\n            # Add some error checking if binShape isn't precisely the right size.\r\n            \r\n            print( \"binFact = \" + str(binFact) )\r\n            \r\n            # 2nd order Lanczos kernel\r\n            lOrder = 2\r\n            xWin = np.arange( -lOrder, lOrder + 1.0\/binFact[1], 1.0\/binFact[1] )\r\n            yWin = np.arange( -lOrder, lOrder + 1.0\/binFact[0], 1.0\/binFact[0] )\r\n            xWinMesh, yWinMesh = np.meshgrid( xWin, yWin )\r\n            rmesh = np.sqrt( xWinMesh*xWinMesh + yWinMesh*yWinMesh )\r\n        \r\n            import warnings\r\n            with warnings.catch_warnings():\r\n                warnings.simplefilter(\"ignore\")\r\n                windowKernel = (lOrder\/(np.pi*np.pi*rmesh*rmesh)) * np.sin( np.pi \/ lOrder * rmesh ) * np.sin( np.pi * rmesh ) \r\n            windowKernel[ yWin==0, xWin==0 ] = 1.0\r\n            print( windowKernel.shape )\r\n            \r\n            binArray = np.zeros( [self.images.shape[0], self.shapeBinned[0], self.shapeBinned[1]], dtype='float32' )\r\n            for J in np.arange( self.images.shape[0] ):\r\n                # TODO: switch from squarekernel to an interpolator so we can use non-powers of 2\r\n                binArray[J,:,:] = util.squarekernel( scipy.ndimage.convolve( self.images[J,:,:], windowKernel ), \r\n                    k= binFact[0] )\r\n\r\n        elif binKernel == u'fourier':\r\n\r\n    \r\n            binArray = np.zeros( [self.images.shape[0], self.shapeBinned[0], self.shapeBinned[1]], dtype='float32' )\r\n            FFTImage = np.zeros( [ self.images.shape[1], self.images.shape[2] ], dtype=fftw_dtype)\r\n            FFTBinned = np.zeros( self.shapeBinned, dtype=fftw_dtype )\r\n            FFT2, _ = util.pyFFTWPlanner( FFTImage, FFTImage, \r\n                            wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ), \r\n                            effort = self.fftw_effort, n_threads=self.n_threads, doReverse=False )\r\n            _, IFFT2bin = util.pyFFTWPlanner( FFTBinned, FFTBinned, \r\n                            wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ), \r\n                            effort = self.fftw_effort, n_threads=self.n_threads, doForward=False ) \r\n    \r\n            \r\n            ImageBinned = np.zeros( self.shapeBinned, dtype=fftw_dtype )\r\n            normConst = 1.0 \/ (self.shapeBinned[0]*self.shapeBinned[1])\r\n            for J in np.arange( self.images.shape[0] ):\r\n                FFT2.update_arrays( self.images[J,:,:].astype( fftw_dtype ), FFTImage ); FFT2.execute()\r\n                # Crop\r\n                FFTBinned[:bShape2[0],:bShape2[1]] = FFTImage[:bShape2[0],:bShape2[1]]\r\n                FFTBinned[:bShape2[0], -bShape2[1]:] = FFTImage[:bShape2[0], -bShape2[1]:]\r\n                FFTBinned[-bShape2[0]:,:bShape2[1]] = FFTImage[-bShape2[0]:,:bShape2[1]]\r\n                FFTBinned[-bShape2[0]:,-bShape2[1]:] = FFTImage[-bShape2[0]:,-bShape2[1]:]\r\n                \r\n                # Normalize\r\n                FFTBinned *= normConst\r\n                \r\n                # Invert\r\n                IFFT2bin.update_arrays( FFTBinned, ImageBinned ); IFFT2bin.execute()\r\n                \r\n                # De-complexify\r\n                binArray[J,:,:] = np.real( ImageBinned )\r\n                pass\r\n            \r\n        pass\r\n    \r\n        del self.images\r\n        self.images = binArray\r\n        self.bench['bin1'] = time.time()\r\n\r\n\r\n        \r\n    def padStack( self, padSize=None, interiorPad=0 ):\r\n        \"\"\"\r\n        This function is used to zero-pad both the images and masks.  This breaks\r\n        the circular shift issues.\r\n        \r\n        Defaults to self.shapePadded\r\n        \r\n        It can also improve performance as FFTW is fastest for dimensions that are powers of 2, \r\n        and still fast for powers of 2,3, and 5.  Wierd dimensions then should be padded \r\n        to an optimized size, which the helper function FindValidFFTDim can provide good\r\n        guesses for.\r\n        \r\n        In general try to have 20 % of your total number of pixels within the mask to reduce\r\n        floating-point round-off error in the masked cross-correlation.\r\n        \"\"\"\r\n        # Take the stack and zero-pad it \r\n        # Unfortunately this step is memory intensive as we need to make a new array\r\n        # to copy the values of the old one into.\r\n        self.bench['pad0'] = time.time()\r\n        if padSize is None:\r\n            padSize = self.shapePadded \r\n            \r\n        if not np.any(padSize):\r\n            print( \"Cannot pad to: \" + str(padSize) )\r\n            return\r\n        \r\n        m = self.images.shape[0]\r\n        self.shapeOriginal = [ self.images.shape[1], self.images.shape[2] ]\r\n        self.shapePadded = padSize # This needs to be recorded for undoing the padding operation\r\n        \r\n        print( \"Padding images and masks to shape: \" + str(padSize) )\r\n        paddedImages = np.zeros( [m, padSize[0], padSize[1]], dtype=self.images.dtype )\r\n        paddedImages[:,:self.shapeOriginal[0],:self.shapeOriginal[1]] = self.images\r\n        self.images = paddedImages\r\n        # Then make or pad the mask appropriately.\r\n        if self.masks is None:\r\n            self.masks = np.zeros( [1,padSize[0],padSize[1]], dtype='bool', order='C' )\r\n            if interiorPad > 0:\r\n                self.masks[0, interiorPad:self.shapeOriginal[0]-interiorPad,\r\n                           interiorPad:self.shapeOriginal[1]-interiorPad] = 1.0\r\n            else:\r\n                self.masks[0,:self.shapeOriginal[0], :self.shapeOriginal[1] ] = 1.0\r\n        else:\r\n            if self.masks.shape[1] != self.shapePadded[0] and self.masks.shape[2] != self.shapePadded[1]:\r\n                mmask = self.masks.shape[0]\r\n                paddedMasks = np.zeros( [mmask, padSize[0], padSize[1]], dtype=self.masks.dtype )\r\n                paddedMasks[:,:self.shapeOriginal[0],:self.shapeOriginal[1]] = self.masks\r\n                self.masks = paddedMasks\r\n            pass # else do nothing\r\n        pass\r\n        self.bench['pad1'] = time.time()\r\n    \r\n    def cropStack( self, cropSize=None ):\r\n        \"\"\"\r\n        Undos the operation from ImageRegistrator.padStack()\r\n        \r\n        Defaults to self.shapeOriginal.\r\n        \"\"\"\r\n        if cropSize is None:\r\n            cropSize = self.shapeOriginal\r\n            \r\n        if not bool(cropSize):\r\n            print( \"Cannot crop to: \" + str(cropSize) )\r\n            return\r\n        \r\n        print( \"Cropping auto-applied mask pixels back to shape: \" + str(self.shapeOriginal) )\r\n        self.images = self.images[ :, :cropSize[0], :cropSize[1] ]\r\n        # Crop masks too\r\n        self.masks = self.masks[ :, :cropSize[0], :cropSize[1] ]\r\n        # And sum if present\r\n        if self.imageSum is not None:\r\n            self.imageSum = self.imageSum[ :cropSize[0], :cropSize[1] ]\r\n            \r\n    def cdfLogisticCurve( self, errIndex = -1, bins = None ):\r\n        \"\"\"\r\n        Calculate the cumulative distribution function of the peak significance scores, and fit a logistic \r\n        curve to them, for deriving a weighting function.\r\n        \"\"\"\r\n        # The error dict list doesn't normally exist here.\r\n        \r\n        peaksigTriMat = self.errorDictList[errIndex]['peaksigTriMat']\r\n        peaksigs = peaksigTriMat[ peaksigTriMat > 0.0 ]\r\n        if bins == None:\r\n            bins = np.int( peaksigs.size\/7.0 )\r\n            \r\n        [pdfPeaks, hSigma ] = np.histogram( peaksigs, bins=bins )\r\n        hSigma = hSigma[:-1]\r\n        pdfPeaks = pdfPeaks.astype( 'float32' )\r\n        cdfPeaks = np.cumsum( pdfPeaks )\r\n        cdfPeaks \/= cdfPeaks[-1]\r\n    \r\n        # BASIN-HOPPING\r\n        basinArgs = {}\r\n        bounds = ( (np.min(peaksigs), np.max(peaksigs)), (0.1, 20.0), (0.05, 5.0) )\r\n        basinArgs[u\"bounds\"] = bounds\r\n        basinArgs[u\"tol\"] = 1E-6\r\n        basinArgs[u\"method\"] =  u\"L-BFGS-B\"\r\n        basinArgs[u\"args\"] = ( hSigma, cdfPeaks )\r\n        # x is [SigmaThres, K, Nu, background]\r\n        x0 = [np.mean(peaksigs), 5.0, 1.0]\r\n        outBasin = scipy.optimize.basinhopping( util.minLogistic, x0, niter=50, minimizer_kwargs=basinArgs )\r\n        \r\n        # Set the logistics curve appropriately.\r\n        self.peaksigThres = outBasin.x[0]\r\n        self.logisticK = outBasin.x[1]\r\n        self.logisticNu = outBasin.x[2]\r\n        \r\n        # Diagnostics (for plotting)\r\n        self.errorDictList[errIndex][u'pdfPeaks'] = pdfPeaks\r\n        self.errorDictList[errIndex][u'cdfPeaks'] = cdfPeaks\r\n        self.errorDictList[errIndex][u'hSigma'] = hSigma\r\n        self.errorDictList[errIndex][u'logisticNu'] = self.logisticNu\r\n        self.errorDictList[errIndex][u'logisticK'] = self.logisticK\r\n        self.errorDictList[errIndex][u'peaksigThres'] = self.peaksigThres\r\n        pass\r\n        \r\n    def velocityCull( self, velocityThres=None ):\r\n        \"\"\"\r\n        Computes the pixel velocities, using a 5-point numerical differentiation on the \r\n        translations.  Note that a 5-point formula inherently has some low-pass filtering\r\n        built-in.\r\n        \r\n        TODO: this would be better of using a spline interpolation (def smoothTrajectory() ) to \r\n        estimate the local velocity than numerical differentiation.\r\n        \r\n        if velocityThres == None, self.velocityThres is used.\r\n        if velocityThres < 0.0, no thresholding is applied (i.e. good for just \r\n        computing the velocity to produce plots)\r\n        \"\"\"\r\n\r\n        velo_diff2 = np.diff( self.translations, axis=0 )\r\n        speed_diff2 = np.sqrt( np.sum( velo_diff2**2.0, axis=1 ))\r\n        self.velocities = np.zeros( [self.translations.shape[0]] )\r\n        self.velocities[0] = speed_diff2[0]\r\n        self.velocities[1:-1] = 0.5*(speed_diff2[:-1] + speed_diff2[1:])\r\n        self.velocities[-1] = speed_diff2[-1]\r\n        \r\n        # Establish what velocities we should crop?\r\n        plt.figure()\r\n        plt.plot( np.arange(0,self.velocities.shape[0]), self.velocities, 'o-k' )\r\n        plt.xlabel( 'Frame number, m' )\r\n        plt.ylabel( 'Pixel velocity, v (pix\/frame)' )\r\n        \r\n        # TODO: this is fairly useless due to noise, properly minimum-acceleration splines fits would work \r\n        # much better I suspect\r\n        print( \"Velocity culling still under development, useful only for diagnostics at present.\" )\r\n        pass\r\n    \r\n    def smoothTrajectory( self, dampen = 0.5 ):\r\n        \"\"\"\r\n        Fit a dampened spline to the translations. This seems to be most useful for refinement as it has been \r\n        shown in UnBlur to help break correlated noise systems.  It reminds me a bit of simulated annealing \r\n        but the jumps aren't random.\r\n        \r\n        dampen should be std of position estimates, so about 0.25 - 1.0 pixels.  If generating smoothing for \r\n        velocity estimation use a higher dampening factor.  \r\n        \"\"\"\r\n        \r\n        if np.any( self.translations ) == None:\r\n            print( \"smoothTrajectory requires an estimate for translations\" )\r\n            return\r\n        import scipy.interpolate\r\n        \r\n        \r\n        frames = np.arange( self.translations.shape[0] )\r\n        ySplineObj = scipy.interpolate.UnivariateSpline( frames, self.translations[:,0], k=5, s=dampen )\r\n        xSplineObj = scipy.interpolate.UnivariateSpline( frames, self.translations[:,1], k=5, s=dampen )\r\n        \r\n        smoothedTrans = np.zeros( self.translations.shape )\r\n        smoothedTrans[:,0] = ySplineObj(frames); smoothedTrans[:,1] = xSplineObj(frames)\r\n        return smoothedTrans\r\n    \r\n    def calcIncoherentFourierMag( self ):\r\n        \"\"\"\r\n        Compute the Fourier transform of each frame in the movie and average\r\n        the Fourier-space magnitudes.  This gives a baseline to compare how \r\n        well the alignment did vesus the  spatial information content of the \r\n        individual images.\r\n        \r\n        This is the square root of the power spectrum.  \r\n        \"\"\"\r\n        frameFFT = np.empty( self.images.shape[1:], dtype=fftw_dtype )\r\n        self.incohFouMag = np.zeros( self.images.shape[1:], dtype=float_dtype )\r\n        FFT2, _ = util.pyFFTWPlanner( frameFFT, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ), n_threads = self.n_threads, doReverse=False )\r\n        \r\n        for J in np.arange(0,self.images.shape[0]):\r\n            FFT2.update_arrays( np.squeeze( self.images[J,:,:]).astype(fftw_dtype), frameFFT ); FFT2.execute()\r\n            self.incohFouMag += np.abs( frameFFT )\r\n        pass\r\n        self.incohFouMag = np.fft.fftshift( self.incohFouMag \/ self.images.shape[0] )\r\n        \r\n    def evenOddFouRingCorr( self, xcorr = 'tri', box=[512,512], overlap=0.5, debug=False ):\r\n        \"\"\" \r\n        Seperates the frames into even and odd frames and tries to calculate a \r\n        Fourier Ring Correlation (FRC) from the two sets.  Oscillations in the \r\n        FRC are normal for this application because of the objective contrast \r\n        transfer function. Note: this function is not well-optimized. It reloads \r\n        the data from disk several times to conserve memory.\r\n        THIS FUNCTION DESTROYS THE DATA IN THE OBJECT.\r\n        \r\n            xcorr = 'tri'  uses the zorro approach.\r\n            xcorr = 'mc' tries to use dosefgpu_driftcorr (Motioncorr)\r\n            xcorr = 'unblur' uses UnBlur\r\n            \r\n            box is the shape of the moving window, and limits the maximum \r\n            resolution the FRC is calculated to.\r\n        If you plan to run both, use 'mc' first.  \r\n        \"\"\"\r\n        self.bench['frc0'] = time.time()\r\n        m = self.images.shape[0]\r\n        evenIndices = np.arange(0, m, 2)\r\n        oddIndices = np.arange(1, m, 2)\r\n        \r\n        original_configName = self.files[u'config']\r\n        import uuid\r\n        tempLogName = str(uuid.uuid4() ) + u\".zor\"\r\n        self.saveConfig( tempLogName ) \r\n        self.files[u'config'] = original_configName # Restore original configuration file.\r\n        \r\n        evenReg = ImageRegistrator()\r\n        evenReg.loadConfig( tempLogName )\r\n        evenReg.images = self.images[evenIndices,:,:].copy(order='C')\r\n        \r\n        oddReg = ImageRegistrator()\r\n        oddReg.loadConfig( tempLogName )\r\n        oddReg.images = self.images[oddIndices,:,:].copy(order='C')\r\n        \r\n        \r\n        \r\n        if xcorr == u'tri' or xcorr is None:\r\n            if self.masks is None:\r\n                evenReg.masks = util.edge_mask( maskShape=[ self.images.shape[1], self.images.shape[2] ] )\r\n                oddReg.masks = evenReg.masks\r\n            elif self.masks.shape[0] > 1:\r\n                evenReg.masks = self.masks[evenIndices,:,:]\r\n                oddReg.masks = self.masks[oddIndices,:,:]\r\n            elif self.masks.shape[0] == 1:\r\n                evenReg.masks = self.masks\r\n                oddReg.masks = self.masks\r\n            \r\n            print( \"#####  Zorro even frames alignment  #####\" )\r\n            evenReg.alignImageStack()\r\n            self.transEven = evenReg.translations.copy( order='C' )\r\n\r\n            print( \"#####  Zorro odd frames alignment  #####\" )\r\n            oddReg.alignImageStack()\r\n            self.transOdd = oddReg.translations.copy( order='C' )\r\n            \r\n        \r\n            \r\n        elif xcorr == 'mc':\r\n            print( \"#####  Motioncorr even frames alignment  #####\" )\r\n            evenReg.xcorr2_mc( loadResult = False )\r\n            evenReg.applyShifts()\r\n            self.transEven = evenReg.translations.copy( order='C' )\r\n\r\n            print( \"#####  Motioncorr odd frames alignment  #####\" )\r\n            oddReg.xcorr2_mc( loadResult = False )\r\n            oddReg.applyShifts()\r\n            self.transOdd = oddReg.translations.copy( order='C' )\r\n            \r\n        elif xcorr == 'unblur':\r\n            print( \"#####  UnBlur even frames alignment  #####\" )\r\n            evenReg.xcorr2_unblur( loadResult=False )\r\n            evenReg.applyShifts()\r\n            self.transEven = evenReg.translations.copy( order='C' )\r\n\r\n            print( \"#####  UnBlur odd frames alignment  #####\" )\r\n            oddReg.xcorr2_unblur( loadResult=False )\r\n            oddReg.applyShifts()\r\n            self.transOdd = oddReg.translations.copy( order='C' )\r\n            \r\n        else:\r\n            print( \"Unknown xcorr method for even-odd FRC: \" + str(xcorr) )\r\n            \r\n\r\n        print( \"#####  Computing even-odd Fourier ring correlation  #####\" )\r\n        eoReg = ImageRegistrator()\r\n        eoReg.loadConfig( tempLogName )\r\n        eoReg.images = np.empty( [2, evenReg.imageSum.shape[0], evenReg.imageSum.shape[1] ], dtype=float_dtype)\r\n        eoReg.images[0,:,:] = evenReg.imageSum; eoReg.images[1,:,:] = oddReg.imageSum\r\n        eoReg.triMode = u'first'\r\n        \r\n        \r\n        \r\n        try: os.remove( tempLogName )\r\n        except: print( \"Could not remove temporary log file: \" + tempLogName )\r\n\r\n        # This actually aligns the two phase images\r\n        # We use Zorro for this for all methods because we have more trust in the masked, normalized\r\n        # cross correlation\r\n        eoReg.alignImageStack()\r\n        \r\n        # Save the aligned eoReg images for subZorro use\r\n        stackFront = os.path.splitext( self.files[u'sum'] )[0]\r\n        if not 'compressor' in self.files or not bool(self.files['compressor']):\r\n            mrcExt = \".mrc\"\r\n        else:\r\n            mrcExt = \".mrcz\"\r\n            \r\n        mrcz.writeMRC( evenReg.imageSum, u\"%s_even%s\" % (stackFront, mrcExt ),\r\n                        compressor=self.files[u'compressor'], clevel=self.files[u'clevel'], n_threads=self.n_threads)\r\n        mrcz.writeMRC( oddReg.imageSum, u\"%s_odd%s\" % (stackFront, mrcExt ),\r\n                        compressor=self.files[u'compressor'], clevel=self.files[u'clevel'], n_threads=self.n_threads) \r\n        \r\n        eoReg.tiledFRC( eoReg.images[0,:,:], eoReg.images[1,:,:], \r\n                       trans=np.hstack( [self.transEven, self.transOdd] ), box=box, overlap=overlap )\r\n        \r\n        self.FRC2D = eoReg.FRC2D\r\n        self.FRC = eoReg.FRC\r\n        \r\n        if self.saveC:\r\n            self.evenC = evenReg.C\r\n            self.oddC = oddReg.C\r\n\r\n        self.bench['frc1'] = time.time()\r\n        return evenReg, oddReg\r\n        \r\n    def lazyFouRingCorr( self, box=[512,512], overlap=0.5, debug=False ):\r\n        \"\"\"\r\n        Computes the FRC from the full stack, taking even and odd frames for the half-sums\r\n        These are not independent half-sets! ... but it still gives us a decent impression \r\n        of alignment success or failure, and it's very fast.\r\n        \"\"\"\r\n        self.bench['frc0'] = time.time()\r\n        m = self.images.shape[0]\r\n        evenIndices = np.arange(0, m, 2)\r\n        oddIndices = np.arange(1, m, 2)                     \r\n        \r\n        evenSum = np.sum( self.images[evenIndices,:,:], axis=0 )\r\n        oddSum = np.sum( self.images[oddIndices,:,:], axis=0 )\r\n        \r\n        self.tiledFRC( evenSum, oddSum, box=box, overlap=overlap )\r\n        # Force the length to be box\/2 because the corners are poorly sampled\r\n        self.FRC = self.FRC[: np.int(box[0]\/2)]\r\n        self.bench['frc1'] = time.time()\r\n\r\n    \r\n    def tiledFRC( self, Image1, Image2, trans=None, box=[512,512], overlap=0.5 ):\r\n        \"\"\"\r\n        Pass in two images, which are ideally averages from two independently processed half-sets. \r\n        Compute the FRC in many tiles of shape 'box', and average the FRC over all tiles.\r\n        \r\n        Overlap controls how much tiles overlap by, with 0.5 being half-tiles and 0.0 being no overlap,\r\n        i.e. they are directly adjacent.  Negative overlaps may be used for sparser samping.  \r\n        \r\n        Produced both a 2D FRC, which is generally of better quality than a power-spectrum, and \r\n        \"\"\"\r\n        FFT2, _ = util.pyFFTWPlanner( np.zeros(box, dtype=fftw_dtype), \r\n                             wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , n_threads = self.n_threads, \r\n                             effort=self.fftw_effort, doReverse=False )\r\n        if overlap > 0.8:\r\n            print(\"tiledFRC takes huge amounts of time as overlap->1.0\" )\r\n            overlap = 0.8                \r\n            \r\n        if trans is None:\r\n            trans = self.translations\r\n            \r\n        minCrop = 5\r\n        if not np.any(trans):\r\n            cropLim = np.array( [minCrop,minCrop,minCrop,minCrop] ) # Keep away from any edge artifacts\r\n        else:\r\n            yendcrop = -np.minimum( np.floor( trans[:,0].min() ), minCrop )\r\n            xendcrop = -np.minimum( np.floor( trans[:,1].min() ), minCrop )\r\n            ystartcrop = np.maximum( np.ceil( trans[:,0].max() ), minCrop )\r\n            xstartcrop = np.maximum( np.ceil( trans[:,1].max() ), minCrop )\r\n            cropLim =  np.array( [ystartcrop, xstartcrop, yendcrop, xendcrop] )\r\n\r\n                         \r\n        hann = util.apodization( name=u'hann', shape=box ).astype(float_dtype)\r\n        tilesX = np.floor( np.float( Image1.shape[1] - cropLim[1] - cropLim[3] - box[1])\/ box[1] \/ (1.0-overlap) ).astype('int')\r\n        tilesY = np.floor( np.float( Image1.shape[0] - cropLim[0] - cropLim[2] - box[0])\/ box[0] \/ (1.0-overlap) ).astype('int')\r\n        if self.verbose >= 2:\r\n            print( \"Tiles for FRC: \" + str( tilesX) + \":\" + str(tilesY))\r\n            \r\n        FFTEven = np.zeros( box, dtype=fftw_dtype )\r\n        FFTOdd = np.zeros( box, dtype=fftw_dtype )\r\n        normConstBox = np.float32( 1.0 \/ FFTEven.size**2 )\r\n        FRC2D = np.zeros( box, dtype=float_dtype )\r\n        for I in np.arange(0,tilesY):\r\n            for J in np.arange(0,tilesX):\r\n                offset = np.array( [ I*box[0]*(1.0-overlap)+cropLim[0], J*box[1]*(1.0-overlap)+cropLim[1] ]).astype('int')\r\n                \r\n                tileEven = (hann*Image1[offset[0]:offset[0]+box[0], offset[1]:offset[1]+box[1] ]).astype(fftw_dtype)\r\n                FFT2.update_arrays( tileEven, FFTEven ); FFT2.execute()\r\n                tileOdd = (hann*Image2[offset[0]:offset[0]+box[0], offset[1]:offset[1]+box[1] ]).astype(fftw_dtype)\r\n                FFT2.update_arrays( tileOdd, FFTOdd ); FFT2.execute()\r\n    \r\n                FFTOdd *= normConstBox\r\n                FFTEven *= normConstBox\r\n                \r\n                # Calculate the normalized FRC in 2-dimensions\r\n                # FRC2D += nz.evaluate( \"real(FFTEven*conj(FFTOdd)) \/ sqrt(real(abs(FFTOdd)**2) * real(abs(FFTEven)**2) )\" )\r\n                # Some issues with normalization?\r\n                FRC2D += nz.evaluate( \"real(FFTEven*conj(FFTOdd)) \/ sqrt(real(FFTOdd*conj(FFTOdd)) * real(FFTEven*conj(FFTEven)) )\" )\r\n              \r\n        # Normalize\r\n        FRC2D \/= FRC2D[0,0]\r\n        FRC2D = np.fft.fftshift( FRC2D )\r\n        \r\n        rotFRC, _ = util.rotmean( FRC2D )\r\n        self.FRC = rotFRC\r\n        self.FRC2D = FRC2D\r\n\r\n    def localFRC( self, box=[256,256], overlap=0.5 ):\r\n        # Only work on the even and odd frames?\r\n        m = self.images.shape[0]\r\n        box2 = (np.array(box)\/2).astype('int')\r\n        evenIndices = np.arange(0, m, 2)\r\n        oddIndices = np.arange(1, m, 2)  \r\n        \r\n        center = 2048\r\n        \r\n        evenBox = np.sum( self.images[evenIndices, center-box2[0]:center+box2[0], center-box2[1]:center+box2[1] ], axis=0 )\r\n        oddBox = np.sum( self.images[oddIndices, center-box2[0]:center+box2[0], center-box2[1]:center+box2[1] ], axis=0 )\r\n        FFTEven = np.zeros( box, dtype=fftw_dtype )\r\n        FFTOdd = np.zeros( box, dtype=fftw_dtype )\r\n        \r\n        normConstBox = np.float32( 1.0 \/ FFTEven.size**2 )\r\n        \r\n        FFT2, _ = util.pyFFTWPlanner( np.zeros(box, dtype=fftw_dtype), \r\n                             wisdomFile=os.path.join( self.cachePath, u\"fftw_wisdom.pkl\" ) , n_threads = self.n_threads, \r\n                             effort=self.fftw_effort, doReverse=False )\r\n        FFT2.update_arrays( evenBox, FFTEven ); FFT2.execute()\r\n        FFT2.update_arrays( oddBox, FFTOdd ); FFT2.execute()\r\n        \r\n        FFTOdd *= normConstBox\r\n        FFTEven *= normConstBox\r\n        \r\n        FRC2D = nz.evaluate( \"real(FFTEven*conj(FFTOdd)) \/ sqrt(real(FFTOdd*conj(FFTOdd)) * real(FFTEven*conj(FFTEven)) )\" )\r\n        FRC2D \/= FRC2D[0,0]\r\n        FRC2D = np.fft.fftshift( FRC2D )\r\n        \r\n        rotFRC, _ = util.rotmean( FRC2D )\r\n        \r\n        plt.figure()\r\n        plt.plot( rotFRC )\r\n        plt.title( \"Local FRC over box = \" + str(box) )\r\n      \r\n     \r\n        \r\n    def doseFilter( self, normalize=False ):\r\n        \"\"\"\r\n        This is a port from Grant's electron_dose.f90 from UnBlur.  It uses fixed critical dose factors\r\n        to apply filters to each image based on their accumulated dose.  We can potentially use \r\n        high-dose detector like the Medipix to determine these dose factors in advance, on a per-protein \r\n        basis.  However in that case the assumption is that radiation damage measured from diffraction of crystals \r\n        results accurately contrast, which is perhaps not true for single particle.\r\n        \r\n        dosePerFrame by default is estimated from the data. If zorroReg.gain = None, we assume \r\n        the input numbers are in electrons.  \r\n        \r\n        missingStartFrames is for data that has the starting x frames removed. It will guess (based on the gain if \r\n        present) the missing total dose.\r\n        \r\n        Paramaters are set as follows:\r\n        \r\n            zorroReg.doseFiltParam = [dosePerFrame, critDoseA, critDoseB, critDoseC, cutoffOrder, missingStartFrame]\r\n        \r\n        When using a tight objective aperture and a GIF and thicker ice it's best to record the dose \r\n        rate in a hole and set self.doseFiltParam[0] appropriately, in terms of electrons per pixel per frame\r\n        \r\n        Also fits a 2D gaussian to the image background and subtracts it.  This improves performance of particle \r\n        picking tools such as Gauto match, and keeps all the intensities uniform for Relion's group scale correction.\r\n        This can be used with Zorro's particle extraction routines.  \r\n        \"\"\"\r\n        # print( \"DEBUG 1: doseFilter: imageSum # nans %d\" % np.sum(np.isnan(self.imageSum) ) )\r\n        critDoseA = np.float32( self.doseFiltParam[1] )\r\n        critDoseB = np.float32( self.doseFiltParam[2] )\r\n        critDoseC = np.float32( self.doseFiltParam[3] )\r\n        cutoffOrder = np.float32( self.doseFiltParam[4] )\r\n        \r\n        if not bool( self.voltage ):\r\n            self.METAstatus = u\"error\"\r\n            self.saveConfig()\r\n            raise ValueError( \"Accelerating voltage not set in advance for dose filtering\" )\r\n        voltageScaling = np.float32( np.sqrt( self.voltage \/ 300.0  ) ) # increase in radiolysis at lower values.\r\n        \r\n        \r\n        # It looks like they build some mesh that is sqrt(qxmesh + qymesh) \/ pixelsize\r\n        # I think this is probably just qmesh in inverse Angstroms (keeping in mind Zorro's internal\r\n        # pixelsize is nm)\r\n        m = self.images.shape[0]\r\n        N = self.shapePadded[0]\r\n        M = self.shapePadded[1]\r\n        invPSx = np.float32( 1.0 \/ (M*(self.pixelsize*10)) )\r\n        invPSy = np.float32( 1.0 \/ (N*(self.pixelsize*10)) )\r\n        \r\n        xmesh, ymesh = np.meshgrid( np.arange(-M\/2,M\/2), np.arange(-N\/2,N\/2))\r\n        xmesh = xmesh.astype(float_dtype);  ymesh = ymesh.astype(float_dtype)\r\n        #print( \"xmesh.dtype: %s\" % xmesh.dtype )\r\n        qmesh = nz.evaluate( \"sqrt(xmesh*xmesh*(invPSx**2) + ymesh*ymesh*(invPSy**2))\" )\r\n        #print( \"qmesh.dtype: %s\" % qmesh.dtype )\r\n        qmesh = np.fft.fftshift( qmesh )\r\n        \r\n        #print( \"qmesh.dtype: %s\" % qmesh.dtype )\r\n        \r\n        # Since there's a lot of hand waving, let's assume dosePerFrame is constant\r\n        # What about on a GIF where the observed dose is lower due to the filter?  That can be incorporated \r\n        # with a gain estimator.\r\n        if self.doseFiltParam[0] == None:\r\n            totalDose = np.mean( self.imageSum ) \r\n            dosePerFrame = totalDose \/ m\r\n            missingDose = dosePerFrame * np.float32( self.doseFiltParam[5] )\r\n        else:\r\n            dosePerFrame = self.doseFiltParam[0]\r\n            \r\n        accumDose = np.zeros( m + 1, dtype=float_dtype ) \r\n        accumDose[1:] = np.cumsum( np.ones(m) * dosePerFrame )\r\n        accumDose += missingDose\r\n        # optimalDose = 2.51284 * critDose\r\n        \r\n        critDoseMesh = nz.evaluate( \"voltageScaling*(critDoseA * qmesh**critDoseB + critDoseC)\" )\r\n        #critDoseMesh[N\/2,M\/2] = 0.001 * np.finfo( 'float32' ).max\r\n        critDoseMesh[ np.int(N\/2), np.int(M\/2)] = critDoseMesh[ np.int(N\/2), np.int(M\/2)-1]**2\r\n        #print( \"critDoseMesh.dtype: %s\" % critDoseMesh.dtype )\r\n\r\n        # We probably don't need an entire mesh here...\r\n        qvect = (np.arange(0,self.shapePadded[0]\/2) * np.sqrt( invPSx*invPSy ) ).astype( float_dtype )\r\n        optiDoseVect = np.zeros( int(self.shapePadded[0]\/2), dtype=float_dtype )\r\n        optiDoseVect[1:] = np.float32(2.51284)*voltageScaling*(critDoseA * qvect[1:]**critDoseB + critDoseC)\r\n        optiDoseVect[0] = optiDoseVect[1]**2\r\n        #print( \"optiDoseVect.dtype: %s\" % optiDoseVect.dtype )\r\n        \r\n        \r\n        padWidth = np.array(self.shapePadded) - np.array(self.imageSum.shape)\r\n        doseFilteredSum = np.zeros( self.shapePadded, dtype=fftw_dtype )\r\n        filterMag = np.zeros( self.shapePadded, dtype=float_dtype )\r\n        FFTimage = np.empty( self.shapePadded, dtype=fftw_dtype )\r\n        # zorroReg.filtSum = np.zeros_like( zorroReg.imageSum )\r\n        FFT2, IFFT2 = util.pyFFTWPlanner( doseFilteredSum, wisdomFile=os.path.join( self.cachePath, \"fftw_wisdom.pkl\" ) , \r\n                                     effort = self.fftw_effort, n_threads=self.n_threads )\r\n        \r\n\r\n        for J in np.arange(0,m):\r\n            print( \"Filtering for dose: %.2f e\/A^2\"% (accumDose[J+1]\/(self.pixelsize*10)**2) )\r\n            doseFinish = accumDose[J+1] # Dose at end of frame period\r\n            doseStart = accumDose[J] # Dose at start of frame period\r\n            # qmesh is in reciprocal angstroms, so maybe I can ignore how they build the mesh and \r\n            # use a matrix meshgrid\r\n            \r\n            minusHalfDose = np.float32( -0.5*doseFinish )\r\n            filt = nz.evaluate( \"exp( minusHalfDose\/critDoseMesh)\")\r\n            #print( \"filt.dtype: %s\" % filt.dtype )\r\n            thresQ = qvect[ np.argwhere( np.abs(doseFinish - optiDoseVect) < np.abs(doseStart - optiDoseVect) )[-1] ]\r\n            \r\n            # thres = nz.evaluate( \"abs(doseFinish - optiDoseMesh) < abs(doseStart - optiDoseMesh)\" )\r\n            # This filter step is slow, try to do this analytically?  Can we find the radius from the above equation?\r\n            # thres = scipy.ndimage.gaussian_filter( thres.astype(zorro.float_dtype), cutoffSigma )\r\n            thres = nz.evaluate( \"exp( -(qmesh\/thresQ)**cutoffOrder )\" )\r\n            #print( \"thres.dtype: %s\" % thres.dtype )\r\n            #print( \"qmesh.dtype: %s\" % qmesh.dtype )\r\n            #print( \"thresQ.dtype: %s\" % thresQ.dtype )\r\n            #print( \"cutoffOrder.dtype: %s\" % cutoffOrder.dtype )\r\n            \r\n            # Numpy's pad is also quite slow\r\n            paddedImage = np.pad( self.images[J,:,:].astype(fftw_dtype),\r\n                                     ((0,padWidth[0]),(0,padWidth[1])), mode=symmetricPad   )\r\n                                     \r\n            FFT2.update_arrays( paddedImage, FFTimage ); FFT2.execute()\r\n            # print( \"FFTimage.dtype: %s\" % FFTimage.dtype )\r\n            # Adding Fourier complex magntiude works fine\r\n            if bool(normalize):\r\n                currentFilter = nz.evaluate( \"thres*filt\" )\r\n                filterMag += currentFilter\r\n                doseFilteredSum += nz.evaluate( \"FFTimage * currentFilter\" )\r\n                \r\n            else:\r\n                doseFilteredSum += nz.evaluate( \"FFTimage * thres * filt\" )\r\n        pass\r\n        \r\n        # print( \"doseFilteredSum.dtype: %s\" % doseFilteredSum.dtype )\r\n        if bool( normalize ):\r\n            alpha = np.float32(1.0) # Prevent divide by zero errors by adding a fixed factor of unity before normalizing.\r\n            filterMag = np.float32(1.0) \/ ( filterMag + alpha )\r\n            # Using FFTimage as a temporary array \r\n            IFFT2.update_arrays( doseFilteredSum*filterMag, FFTimage ); IFFT2.execute()\r\n        else:\r\n            # Using FFTimage as a temporary array \r\n            IFFT2.update_arrays( doseFilteredSum, FFTimage ); IFFT2.execute()\r\n        self.filtSum = np.abs( FFTimage[:self.imageSum.shape[0],:self.imageSum.shape[1]] )\r\n        # print( \"filtSum.dtype: %s\" % self.filtSum.dtype )\r\n\r\n\r\n        \r\n        del invPSx, invPSy, qmesh, optiDoseVect, doseFinish, doseStart, critDoseA, critDoseB, critDoseC, \r\n        del voltageScaling, filt, thres, thresQ, cutoffOrder, minusHalfDose\r\n     \r\n        \r\n    def hotpixFilter( self, cutoffLower=None, cutoffUpper=None, neighbourThres = 0.01 ):\r\n        \"\"\"\r\n        Identifies and removes hot pixels using a stocastic weighted approach.\r\n        replaced with a Gaussian filter.  Hot pixels do not affect Zorro too much \r\n        due to the intensity-normalized cross-correlation but the tracks of the \r\n        hot pixels do upset other software packages.\r\n        \r\n        PSF is used to provide a camera-specific PSF to filter hot pixels.  If \r\n        you have an MTF curve for a detector we can provide a psf tailored to that\r\n        particular device, otherwise use None for a uniform filter.\r\n        \"\"\"\r\n        self.bench['hot0'] = time.time()\r\n\r\n        # 3 x 3 kernels\r\n        if self.hotpixInfo[u\"psf\"] == u\"K2\":\r\n            psf = np.array( [0.0, 0.173235968], dtype=float_dtype )\r\n        else: # default to uniform filter\r\n            psf = np.array( [0.0, 1.0], dtype=float_dtype )\r\n        \r\n        psfKernel = np.array( [  [psf[1]*psf[1], psf[1], psf[1]*psf[1] ],\r\n               [psf[1], 0.0, psf[1] ],\r\n               [psf[1]*psf[1], psf[1], psf[1]*psf[1] ]], dtype=float_dtype  )\r\n        psfKernel \/= np.sum( psfKernel )\r\n        \r\n        if self.images.ndim == 2: \r\n            # Mostly used when processing flatfields for gain reference normalization\r\n            self.images = np.reshape( self.images, [1, self.images.shape[0], self.images.shape[1]])\r\n            MADE_3D = True\r\n        else:\r\n            MADE_3D = False\r\n        \r\n        \r\n        unalignedSum = np.sum( self.images, axis=0 )\r\n        sumMean = np.mean( unalignedSum )\r\n        poissonStd = np.sqrt( sumMean )\r\n        \r\n        histBins = np.arange( np.floor( sumMean - self.hotpixInfo[u\"maxSigma\"]*poissonStd)-0.5, np.ceil(sumMean+self.hotpixInfo[u\"maxSigma\"]*poissonStd)+0.5, 1 )\r\n        unalignedHist, unalignedCounts = np.histogram( unalignedSum, histBins )\r\n        unalignedHist = unalignedHist.astype(float_dtype); \r\n        \r\n        # Make unalignedCounts bin centers rather than edges\r\n        unalignedCounts = unalignedCounts[:-1].astype(float_dtype) \r\n        unalignedCounts += 0.5* (unalignedCounts[1]-unalignedCounts[0])\r\n        \r\n        \r\n        # Here we get sigma values from the CDF, which is smoother than the PDF due \r\n        # to the integration applied.\r\n        cdfHist = np.cumsum( unalignedHist )\r\n        cdfHist \/= cdfHist[-1]\r\n        \r\n        ###################################\r\n        # Optimization of mean and standard deviation\r\n        # TODO: add these stats to the object\r\n        \r\n        def errorNormCDF( params ):\r\n            return np.sum( np.abs( cdfHist - \r\n                scipy.stats.norm.cdf( unalignedCounts, loc=params[0], scale=params[1] ) ) )\r\n        \r\n        bestNorm = scipy.optimize.minimize( errorNormCDF, (sumMean,poissonStd),\r\n                            method=\"L-BFGS-B\", \r\n                            bounds=((sumMean-0.5*poissonStd,  sumMean+0.5*poissonStd),\r\n                                    (0.7*poissonStd, 1.3*poissonStd) ) )\r\n        #####################################\r\n        \r\n        sigmaFromCDF = np.sqrt(2) * scipy.special.erfinv( 2.0 * cdfHist - 1 ) \r\n        \r\n        normalSigma = (unalignedCounts - bestNorm.x[0]) \/ bestNorm.x[1] \r\n        \r\n        errorNormToCDF = normalSigma - sigmaFromCDF\r\n        keepIndices = ~np.isinf( errorNormToCDF )\r\n        errorNormToCDF = errorNormToCDF[keepIndices]\r\n        normalSigmaKeep = normalSigma[keepIndices]\r\n        \r\n\r\n        # Try for linear fits, resort to defaults if it fails\r\n        if not bool(cutoffLower):\r\n            try:\r\n                lowerIndex = np.where( errorNormToCDF > -0.5 )[0][0]\r\n                lowerA = np.array( [normalSigmaKeep[:lowerIndex], np.ones(lowerIndex )] )\r\n                lowerFit = np.linalg.lstsq( lowerA.T, errorNormToCDF[:lowerIndex] )[0]\r\n                cutoffLower = np.float32( -lowerFit[1]\/lowerFit[0] )\r\n                self.hotpixInfo[u'cutoffLower'] = float( cutoffLower )\r\n            except:\r\n                print( \"zorro.hotpixFilter failed to estimate bound for dead pixels, defaulting to -4.0\" )\r\n                cutoffLower = np.float32( self.hotpixInfo['cutoffLower'] )\r\n                \r\n        if not bool(cutoffUpper):\r\n            try:\r\n                upperIndex = np.where( errorNormToCDF < 0.5 )[0][-1]\r\n                upperA = np.array( [normalSigmaKeep[upperIndex:], np.ones( len(normalSigmaKeep) - upperIndex )] )\r\n                upperFit = np.linalg.lstsq( upperA.T, errorNormToCDF[upperIndex:] )[0]\r\n                cutoffUpper = np.float32( -upperFit[1]\/upperFit[0] )\r\n                self.hotpixInfo[u'cutoffUpper'] = float( cutoffUpper )\r\n            except:\r\n                print( \"zorro.hotpixFilter failed to estimate bound for hot pixels, defaulting to +3.25\" )\r\n                cutoffUpper = np.float32( self.hotpixInfo['cutoffUpper'] )\r\n            \r\n            \r\n        unalignedSigma = (unalignedSum - bestNorm.x[0]) \/ bestNorm.x[1]\r\n        \r\n        \r\n        # JSON isn't serializing numpy types anymore, so we have to explicitely cast them\r\n        self.hotpixInfo[u\"guessDeadpix\"] = int( np.sum( unalignedSigma < cutoffLower ) )\r\n        self.hotpixInfo[u\"guessHotpix\"] = int( np.sum( unalignedSigma > cutoffUpper  ) )\r\n        self.hotpixInfo[u\"frameMean\"] = float( bestNorm.x[0]\/self.images.shape[0] )\r\n        self.hotpixInfo[u\"frameStd\"] = float( bestNorm.x[1]\/np.sqrt(self.images.shape[0]) )\r\n        \r\n        print( \"Applying outlier pixel filter with sigma limits (%.2f,%.2f), n=(dead:%d,hot:%d)\" \\\r\n              % (cutoffLower, cutoffUpper, self.hotpixInfo[u\"guessDeadpix\"],self.hotpixInfo[u\"guessHotpix\"] ) )\r\n        # Some casting problems here with Python float up-casting to np.float64...\r\n        UnityFloat32 = np.float32( 1.0 )\r\n        logK = np.float32( self.hotpixInfo[u'logisticK'] )\r\n        relax = np.float32( self.hotpixInfo[u'relax'] )\r\n        logisticMask = nz.evaluate( \"1.0 - 1.0 \/ ( (1.0 + exp(logK*(unalignedSigma-cutoffLower*relax)) ) )\" )\r\n        logisticMask = nz.evaluate( \"logisticMask \/ ( (1.0 + exp(logK*(unalignedSigma-cutoffUpper*relax)) ) )\" ).astype(float_dtype)\r\n        \r\n        convLogisticMask = nz.evaluate( \"UnityFloat32 - logisticMask\" )\r\n        # So we need 2 masks, one for pixels that have no outlier-neighbours, and \r\n        # another for joined\/neighbourly outlier pixels.\r\n        # I can probably make the PSF kernel smaller... to speed things up.\r\n        neighbourlyOutlierMask = (UnityFloat32 - logisticMask) * scipy.ndimage.convolve( np.float32(1.0) - logisticMask, psfKernel )\r\n        \r\n        \"\"\"\r\n        Singleton outliers have no neighbours that are also outliers, so we substitute their values \r\n        with the expected value based on the point-spread function of the detector.\r\n        \"\"\"\r\n        singletonOutlierMask = nz.evaluate( \"convLogisticMask * (neighbourlyOutlierMask <= neighbourThres)\" )\r\n        m = self.images.shape[0]\r\n        unalignedMean = nz.evaluate( \"unalignedSum\/m\" )\r\n        psfFiltMean = scipy.ndimage.convolve( unalignedMean, psfKernel ).astype(float_dtype)\r\n        \r\n        \r\n        \"\"\"\r\n        The neighbourFilt deals with outliers that have near neihbours that are also \r\n        outliers. This isn't uncommon due to defects in the camera.\r\n        \"\"\"\r\n        neighbourlyOutlierMask = nz.evaluate( \"neighbourlyOutlierMask > neighbourThres\" )\r\n        neighbourlyIndices = np.where( nz.evaluate( \"neighbourlyOutlierMask > neighbourThres\" ) )\r\n        bestMean = bestNorm.x[0] \/ m\r\n        print( \"Number of neighborly outlier pixels: %d\" % len(neighbourlyIndices[0]) )\r\n        self.hotpixInfo[u'neighborPix'] = len(neighbourlyIndices[0])\r\n        neighbourFilt = np.zeros_like( psfFiltMean )\r\n        for (nY, nX) in zip( neighbourlyIndices[0], neighbourlyIndices[1] ):\r\n            # We'll use 5x5 here, substituting the bestMean if it's all garbage\r\n            neighbourhood = neighbourlyOutlierMask[nY-1:nY+2,nX-1:nX+2]\r\n            nRatio = np.sum( neighbourhood ) \/ neighbourhood.size\r\n            if nRatio > 0.66 or nRatio <= 0.001 or np.isnan(nRatio):\r\n                neighbourFilt[nY,nX] = bestMean\r\n            else:\r\n                neighbourFilt[nY,nX] = convLogisticMask[nY,nX]*np.mean(unalignedMean[nY-1:nY+2,nX-1:nX+2][~neighbourhood])\r\n        \r\n        stack = self.images\r\n        self.images = nz.evaluate( \"logisticMask*stack + singletonOutlierMask*psfFiltMean + neighbourFilt\" )\r\n        \r\n        if u\"decorrOutliers\" in self.hotpixInfo and self.hotpixInfo[ u\"decorrOutliers\" ]:\r\n            \"\"\"\r\n            This adds a bit of random noise to pixels that have been heavily filtered \r\n            to a uniform value, so they aren't correlated noise.  This should only \r\n            affect Zorro and Relion movie processing.\r\n            \"\"\"\r\n            decorrStd = np.sqrt( bestNorm.x[1]**2 \/ m ) \/ 2.0\r\n            N_images = self.images.shape[0]\r\n            filtPosY, filtPosX = np.where( logisticMask < 0.5 )\r\n        \r\n            # I don't see a nice way to vectorize this loop.  With a ufunc?\r\n            for J in np.arange( filtPosY.size ):\r\n                self.images[ :, filtPosY[J], filtPosX[J] ] += np.random.normal( \\\r\n                            scale=decorrStd*convLogisticMask[filtPosY[J],filtPosX[J]], size=N_images )\r\n                \r\n        \r\n        if MADE_3D:\r\n            self.images = np.squeeze( self.images )\r\n            \r\n        self.bench['hot1'] = time.time()\r\n        del logK, relax, logisticMask, psfFiltMean, stack, UnityFloat32, singletonOutlierMask\r\n        pass\r\n    \r\n    def hotpixFilter_SINGLETON( self, cutoffLower=None, cutoffUpper=None  ):\r\n        \"\"\"\r\n        Identifies and removes hot pixels using a stocastic weighted approach.\r\n        replaced with a Gaussian filter.  Hot pixels do not affect Zorro too much \r\n        due to the intensity-normalized cross-correlation but the tracks of the \r\n        hot pixels do upset other software packages.\r\n        \r\n        PSF is used to provide a camera-specific PSF to filter hot pixels.  If \r\n        you have an MTF curve for a detector we can provide a psf tailored to that\r\n        particular device, otherwise use None for a uniform filter.\r\n        \"\"\"\r\n        self.bench['hot0'] = time.time()\r\n        \r\n        if self.hotpixInfo[u\"psf\"] == u\"K2\":\r\n            psf = np.array( [0.0, 0.173235968, 0.016518], dtype='float32' )\r\n        else: # default to uniform filter\r\n            psf = np.array( [0.0, 1.0, 1.0], dtype='float32' )\r\n        \r\n        psfKernel = np.array( [  [psf[2]*psf[2], psf[2]*psf[1], psf[2], psf[2]*psf[1], psf[2]*psf[2] ],\r\n               [psf[2]*psf[1], psf[1]*psf[1], psf[1], psf[1]*psf[1], psf[1]*psf[2] ],\r\n               [psf[2], psf[1], 0.0, psf[1], psf[2] ],\r\n               [psf[2]*psf[1], psf[1]*psf[1], psf[1], psf[1]*psf[1], psf[1]*psf[2] ],\r\n               [ psf[2]*psf[2], psf[2]*psf[1], psf[2], psf[2]*psf[1], psf[2]*psf[2] ] ], dtype='float32'  )\r\n        psfKernel \/= np.sum( psfKernel )\r\n        \r\n        if self.images.ndim == 2: \r\n            # Mostly used when processing flatfields for gain reference normalization\r\n            self.images = np.reshape( self.images, [1, self.images.shape[0], self.images.shape[1]])\r\n            MADE_3D = True\r\n        else:\r\n            MADE_3D = False\r\n        \r\n        \r\n        unalignedSum = np.sum( self.images, axis=0 )\r\n        sumMean = np.mean( unalignedSum )\r\n        poissonStd = np.sqrt( sumMean )\r\n        \r\n        \r\n        \r\n        histBins = np.arange( np.floor( sumMean - self.hotpixInfo[u\"maxSigma\"]*poissonStd)-0.5, np.ceil(sumMean+self.hotpixInfo[u\"maxSigma\"]*poissonStd)+0.5, 1 )\r\n        unalignedHist, unalignedCounts = np.histogram( unalignedSum, histBins )\r\n        unalignedHist = unalignedHist.astype('float32'); \r\n        \r\n        # Make unalignedCounts bin centers rather than edges\r\n        unalignedCounts = unalignedCounts[:-1].astype('float32') \r\n        unalignedCounts += 0.5* (unalignedCounts[1]-unalignedCounts[0])\r\n\r\n\r\n        # Here we get sigma values from the CDF, which is smoother than the PDF due \r\n        # to the integration applied.\r\n        cdfHist = np.cumsum( unalignedHist )\r\n        cdfHist \/= cdfHist[-1]\r\n        \r\n        ###################################\r\n        # Optimization of mean and standard deviation\r\n        # TODO: add these stats to the object\r\n        \r\n        def errorNormCDF( params ):\r\n            return np.sum( np.abs( cdfHist - \r\n                scipy.stats.norm.cdf( unalignedCounts, loc=params[0], scale=params[1] ) ) )\r\n        \r\n        bestNorm = scipy.optimize.minimize( errorNormCDF, (sumMean,poissonStd),\r\n                            method=\"L-BFGS-B\", \r\n                            bounds=((sumMean-0.5*poissonStd,  sumMean+0.5*poissonStd),\r\n                                    (0.7*poissonStd, 1.3*poissonStd) ) )\r\n        # normCDF = scipy.stats.norm.cdf( unalignedCounts, loc=bestNorm.x[0], scale=bestNorm.x[1] )\r\n        #####################################\r\n    \r\n        sigmaFromCDF = np.sqrt(2) * scipy.special.erfinv( 2.0 * cdfHist - 1 ) \r\n        \r\n        #sumFromHist = np.sum( unalignedHist )\r\n        #meanFromHist = np.float32( np.sum( unalignedHist * unalignedCounts ) \/ sumFromHist )\r\n        #stdFromHist = np.float32( np.sqrt( np.sum( unalignedHist * unalignedCounts**2 )\/ sumFromHist - meanFromHist*meanFromHist  ) )\r\n        #invStdFromHist = np.float32(1.0 \/ stdFromHist )\r\n        \r\n        normalSigma = (unalignedCounts - bestNorm.x[0]) \/ bestNorm.x[1] \r\n        \r\n        # TODO: try to keep these infs from being generated in the first place\r\n        errorNormToCDF = normalSigma - sigmaFromCDF\r\n        keepIndices = ~np.isinf( errorNormToCDF )\r\n        errorNormToCDF = errorNormToCDF[keepIndices]\r\n        # unalignedCountsKeep = unalignedCounts[keepIndices]\r\n        normalSigmaKeep = normalSigma[keepIndices]\r\n    \r\n        # TODO: add try-except, using a fixed error difference if the fitting fails\r\n        if not bool(cutoffLower):\r\n            try:\r\n                lowerIndex = np.where( errorNormToCDF > -0.5 )[0][0]\r\n                lowerA = np.array( [normalSigmaKeep[:lowerIndex], np.ones(lowerIndex )] )\r\n                lowerFit = np.linalg.lstsq( lowerA.T, errorNormToCDF[:lowerIndex] )[0]\r\n                cutoffLower = np.float32( -lowerFit[1]\/lowerFit[0] )\r\n            except:\r\n                print( \"zorro.hotpixFilter failed to estimate bound for dead pixels, defaulting to -4.0\" )\r\n                cutoffLower = np.float32( -4.0 )\r\n                \r\n        if not bool(cutoffUpper):\r\n            try:\r\n                upperIndex = np.where( errorNormToCDF < 0.5 )[0][-1]\r\n                upperA = np.array( [normalSigmaKeep[upperIndex:], np.ones( len(normalSigmaKeep) - upperIndex )] )\r\n                upperFit = np.linalg.lstsq( upperA.T, errorNormToCDF[upperIndex:] )[0]\r\n                cutoffUpper = np.float32( -upperFit[1]\/upperFit[0] )\r\n            except:\r\n                print( \"zorro.hotpixFilter failed to estimate bound for hot pixels, defaulting to +3.25\" )\r\n                cutoffLower = np.float32( 3.25 )\r\n            \r\n        unalignedSigma = (unalignedSum - bestNorm.x[0]) \/ bestNorm.x[1]\r\n\r\n        print( \"Applying progressive outlier pixel filter with sigma limits (%.2f,%.2f)\" % (cutoffLower, cutoffUpper) )\r\n        # JSON isn't serializing numpy types anymore, so we have to explicitely cast them\r\n        self.hotpixInfo[u'cutoffLower'] = float( cutoffLower )\r\n        self.hotpixInfo[u'cutoffUpper'] = float( cutoffUpper )\r\n        self.hotpixInfo[u\"guessDeadpix\"] = int( np.sum( unalignedSigma < cutoffLower ) )\r\n        self.hotpixInfo[u\"guessHotpix\"] = int( np.sum( unalignedSigma > cutoffUpper  ) )\r\n        self.hotpixInfo[u\"frameMean\"] = float( bestNorm.x[0]\/self.images.shape[0] )\r\n        self.hotpixInfo[u\"frameStd\"] = float( bestNorm.x[1]\/np.sqrt(self.images.shape[0]) )\r\n        \r\n        logK = np.float32( self.hotpixInfo[u'logisticK'] )\r\n        relax = np.float32( self.hotpixInfo[u'relax'] )\r\n        logisticMask = nz.evaluate( \"1.0 - 1.0 \/ ( (1.0 + exp(logK*(unalignedSigma-cutoffLower*relax)) ) )\" )\r\n        \r\n        logisticMask = nz.evaluate( \"logisticMask \/ ( (1.0 + exp(logK*(unalignedSigma-cutoffUpper*relax)) ) )\" ).astype('float32')\r\n        \r\n        # So we need 2 masks, one for pixels that have no outlier-neighbours, and \r\n        # another for joined\/neighbourly outlier pixels.\r\n        singletonOutlierMask = scipy.ndimage.convolve( logisticMask, np.ones_like(psfKernel) )\r\n        \r\n        \r\n        # Some casting problems here with Python float up-casting to np.float64...\r\n        UnityFloat32 = np.float32( 1.0 )\r\n        \r\n        psfFiltMean = scipy.ndimage.convolve( unalignedSum\/self.images.shape[0], psfKernel ).astype('float32')\r\n        \r\n        \r\n        stack = self.images\r\n        nz.evaluate( \"(UnityFloat32-logisticMask) *stack + logisticMask*psfFiltMean\" )\r\n        \r\n        \r\n        if u\"decorrOutliers\" in self.hotpixInfo and self.hotpixInfo[ u\"decorrOutliers\" ]:\r\n            \"\"\"\r\n            This adds a bit of random noise to pixels that have been heavily filtered \r\n            to a uniform value, so they aren't correlated noise.  This should only \r\n            affect Zorro and Relion movie processing.\r\n            \"\"\"\r\n            decorrStd = np.std( self.images[0,:,:] )\r\n            N_images = self.images.shape[0]\r\n            filtPosY, filtPosX = np.where( logisticMask < 0.98 )\r\n\r\n            # I don't see a nice way to vectorize this loop.  With a ufunc?\r\n            for J in np.arange( filtPosY.size ):\r\n                self.images[ :, filtPosY[J], filtPosX[J] ] += np.random.normal( scale=decorrStd, size=N_images )\r\n            \r\n\r\n        if MADE_3D:\r\n            self.images = np.squeeze( self.images )\r\n            \r\n        self.bench['hot1'] = time.time()\r\n        del logK, relax, logisticMask, psfFiltMean, stack, UnityFloat32, singletonOutlierMask\r\n\r\n    def setBfiltCutoff( self, cutoffSpacing ):\r\n        \"\"\"\r\n        stackReg.bBfiltCutoff( cutoffSpacing )\r\n        \r\n        Expects stackReg.pixelsize to be set, and stackReg.images to be loaded.  \r\n        Units of pixelsize from DM4 is nm, so the cutoff spacing should also be \r\n        nm.  E.g. cutoffspacing = 0.3 [nm] is 3.0 Angstroms. \r\n        \r\n        For a gaussian B-filter, the cutoff is where the filter ampitude drops \r\n        to 1\/exp(1)\r\n        \"\"\"\r\n        shapeImage = np.array( self.images.shape[1:] )\r\n        psInv = 1.0 \/ (self.pixelsize*shapeImage)\r\n        \r\n        cutoffInv = 1.0 \/ cutoffSpacing\r\n        \r\n        self.Brad = cutoffInv \/ psInv\r\n        print( \"Setting Brad to: \" + str(self.Brad) )\r\n        pass\r\n    \r\n    def getCropLimits( self, trans = None ):\r\n        if trans is None:\r\n            trans = self.translations\r\n\r\n        yendcrop = np.minimum( np.floor( trans[:,0].min() ), 0 ).astype('int')\r\n        if yendcrop == 0:\r\n            yendcrop = None\r\n        xendcrop = np.minimum( np.floor( trans[:,1].min() ), 0 ).astype('int')\r\n        if xendcrop == 0:\r\n            xendcrop = None\r\n        ystartcrop = np.maximum( np.ceil( trans[:,0].max() ), 0 ).astype('int')\r\n        xstartcrop = np.maximum( np.ceil( trans[:,1].max() ), 0 ).astype('int')\r\n        return np.array( [ystartcrop, xstartcrop, yendcrop, xendcrop] )\r\n        \r\n    def getSumCropToLimits( self ):\r\n        \"\"\"\r\n        Gets imageSum cropped so that no pixels with partial dose are kept.\r\n\r\n        \"\"\"\r\n        cropLim = self.getCropLimits()\r\n        return self.imageSum[cropLim[0]:cropLim[2], cropLim[1]:cropLim[3]]\r\n        \r\n    def getFiltSumCropToLimits( self ):\r\n        \"\"\"\r\n        Gets filtSum cropped so that no pixels with partial dose are kept.\r\n        \"\"\"\r\n        cropLim = self.getCropLimits()\r\n        return self.filtSum[cropLim[0]:cropLim[2], cropLim[1]:cropLim[3]]\r\n        \r\n    def getImagesCropToLimits( self ):\r\n        \"\"\"\r\n        Gets images stack cropped so that no pixels with partial dose are kept.\r\n        \"\"\"\r\n        cropLim = self.getCropLimits()\r\n        return self.images[:,cropLim[0]:cropLim[2], cropLim[1]:cropLim[3]]\r\n        \r\n    def getMaskCropLimited( self ):\r\n        \"\"\"\r\n        Get a mask that crops the portion of the image that moved, for refinement.\r\n        \"\"\"\r\n        cropLim = self.getCropLimits()\r\n        if cropLim[2] == None: cropLim[2] = 0;\r\n        if cropLim[3] == None: cropLim[3] = 0;\r\n            \r\n        if np.any( self.shapeOriginal ):\r\n            newMask = np.zeros( [1,self.shapeOriginal[0],self.shapeOriginal[1]], dtype=float_dtype )\r\n            newMask[:,cropLim[0]:self.shapeOriginal[0]+cropLim[2], cropLim[1]:self.shapeOriginal[1]+cropLim[3]] = 1.0\r\n        else:\r\n            newMask = np.zeros( [1,self.images.shape[1],self.images.shape[2]], dtype=float_dtype )\r\n            newMask[:,cropLim[0]:self.images.shape[1]+cropLim[2], cropLim[1]:self.images.shape[2]+cropLim[3]] = 1.0\r\n        return newMask\r\n        \r\n    def execGCTF( self, movieMode=False, movieFrameToAverage=8, movieFit=0, movieType=1  ):\r\n        \"\"\"\r\n        Calls GCTF.  \r\n        \r\n        I.e. movieMode=True\r\n        # Movie options to calculate defocuses of each frame:  \r\n        # --mdef_aveN         8                 Average number of moive frames for movie or particle stack CTF refinement\r\n        # --mdef_fit          0                 0: no fitting; 1: linear fitting defocus changes in Z-direction\r\n        # --mdef_ave_type     0                 0: coherent average, average FFT with phase information(suggested for movies); 1:incoherent average, only average amplitude(suggested for particle stack); \r\n        \"\"\"\r\n        self.bench['ctf0'] = time.time()\r\n        print( \"   <NAME>, 'Gctf: real-time CTF determination and correction',  J. Struct. Biol., 193(1): 1-12, (2016)\" )\r\n        print( \"   http:\/\/www.sciencedirect.com\/science\/article\/pii\/S1047847715301003\" )\r\n\r\n        if self.cachePath is None:\r\n            self.cachePath = \".\"\r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass\r\n            \r\n        stackBase = os.path.splitext( os.path.basename( self.files[u'stack'] ) )[0]\r\n        \r\n        mrcName = os.path.join( self.cachePath, stackBase + u\"_gctf.mrc\" )\r\n        mrcFront = os.path.splitext( mrcName )[0]\r\n        diagOutName = mrcFront + u\".ctf\"\r\n        logName = mrcFront + u\"_ctffind3.log\"\r\n        epaName = mrcFront + u\"_EPA.log\"\r\n        \r\n        if bool( movieMode ):\r\n            # Write an MRCS\r\n            mrcz.writeMRC( self.images, mrcName )\r\n            # Call GCTF\r\n\r\n            gctf_exec = \"gctf %s --apix %f --kV %f --cs %f --do_EPA 1 --mdef_ave_type 1 --logsuffix  _ctffind3.log \" % (mrcName, self.pixelsize*10, self.voltage, self.C3 )\r\n            gctf_exec += \" --mdef_aveN %d --mdef_fit %d --mdef_ave_type %d\" %( movieFrameToAverage, movieFit, movieType )\r\n        else: # No movieMode\r\n            if not np.any( self.imageSum ):\r\n                raise AttributeError( \"Error in execGCTF: No image sum found\" )\r\n            mrcz.writeMRC( self.imageSum, mrcName )\r\n            # Call GCTF\r\n            gctf_exec = \"gctf %s --apix %f --kV %f --cs %f --do_EPA 1 --logsuffix  _ctffind3.log \" % (mrcName, self.pixelsize*10, self.voltage, self.C3 )\r\n\r\n        # Need to redirect GCTF output to null because it's formatted with UTF-16 and this causes Python 2.7 problems.\r\n        devnull = open(os.devnull, 'w' )\r\n        subprocess.call( gctf_exec, shell=True, stdout=devnull, stderr=devnull )\r\n        # sub = subprocess.Popen( gctf_exec, shell=True )\r\n        #sub.wait() \r\n\r\n        # Diagnostic image ends in .ctf\r\n        self.CTFDiag = mrcz.readMRC( diagOutName )[0]\r\n\r\n        # Parse the output _ctffind3.log for the results\r\n        with open( logName, 'r' ) as fh:\r\n            logCTF = fh.readlines()\r\n\r\n        ctf = logCTF[-5].split()\r\n        self.CTFInfo[u'DefocusU'] = float( ctf[0] )\r\n        self.CTFInfo[u'DefocusV'] = float( ctf[1] )\r\n        self.CTFInfo[u'DefocusAngle'] = float( ctf[2] )\r\n        self.CTFInfo[u'CtfFigureOfMerit'] = float( ctf[3] )\r\n        self.CTFInfo[u'FinalResolution'] = float( logCTF[-3].split()[-1] )\r\n        self.CTFInfo[u'Bfactor'] = float( logCTF[-2].split()[-1] )\r\n\r\n        # Output compact _ctffind3.log\r\n        self.saveRelionCTF3( )\r\n        \r\n        # Remove temporary files and log file\r\n        try: os.remove( diagOutName )\r\n        except: pass\r\n        try: os.remove( logName ) # Technically we could keep this.\r\n        except: pass\r\n        try: os.remove( mrcName )\r\n        except: pass\r\n        try: os.remove( epaName )\r\n        except: pass\r\n        self.bench['ctf1'] = time.time()\r\n     \r\n    def execCTFFind41( self, movieMode=False, box_size = 1024, contrast=0.067, \r\n                     min_res=50.0, max_res=4.0, \r\n                     min_C1=5000.0, max_C1=45000.0, C1_step = 500.0, \r\n                     A1_tol = 500.0 ):\r\n        \"\"\"\r\n        Calls CTFFind4, must be on the system path.\r\n             movieMode = True does not require an aligned image (works on Fourier magnitudes)\r\n             box_size = CTFFind parameter, box size to FFT\r\n             contrast = estimated phase contrast in images\r\n             min_res = minimum resolution to fit, in Angstroms\r\n             max_res = maximum resolution to fit, in Angstroms.  Water ice is around 3.4 Angstroms\r\n             min_C1 = minimum defocus search range, in Angstroms\r\n             max_C1 = maximum defocus search range, in Angstroms\r\n             C1_step = defocus search step size, in Angstroms\r\n             A1_tol = 2-fold astigmatism tolerance, in Angstroms\r\n        \"\"\"\r\n        self.bench['ctf0'] = time.time()\r\n        if util.which( 'ctffind' ) is None:\r\n            print( \"Error: CTFFIND not found!\" )\r\n            return\r\n        if self.pixelsize is None:\r\n            print( \"Set pixelsize (in nm) before calling execCTFFind4\" )\r\n            return\r\n        elif self.voltage is None:\r\n            print( \"Set voltage (in kV) before calling execCTFFind4\" )\r\n            return\r\n        elif self.C3 is None:\r\n            print( \"Set C3 (in mm) before calling execCTFFind4\" )\r\n            return\r\n        \r\n        print( \"Calling CTFFIND4.1 for %s\" % self.files['stack']  )\r\n        print( \"   written by <NAME>: http:\/\/grigoriefflab.janelia.org\/ctffind4\" )\r\n        print( \"   http:\/\/biorxiv.org\/content\/early\/2015\/06\/16\/020917\" )\r\n        \r\n        ps = self.pixelsize * 10.0\r\n        min_res = np.min( [min_res, 50.0] )\r\n        \r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass\r\n        \r\n        if self.cachePath is None:\r\n            self.cachePath = \".\"\r\n            \r\n        # Force trailing slashes onto cachePatch\r\n        stackBase = os.path.splitext( os.path.basename( self.files[u'stack'] ) )[0]\r\n            \r\n        diagOutName = os.path.join( self.cachePath, stackBase + u\".ctf\" )\r\n         \r\n        try: \r\n            mrcName = os.path.join( self.cachePath, stackBase + u\"_ctf4.mrc\" )\r\n            if bool(movieMode):\r\n                mrcz.writeMRC( self.images, mrcName )\r\n                number_of_frames_to_average = 1\r\n            else:\r\n                mrcz.writeMRC( self.imageSum, mrcName )\r\n        except:\r\n            print( \"Error in exporting MRC file to CTFFind4.1\" )\r\n            return\r\n         \r\n        # flags = \"--amplitude-spectrum-input --filtered-amplitude-spectrum-input\"\r\n        flags = \"\" # Not using any flags\r\n        find_additional_phase_shift = \"no\"\r\n        knownAstig = \"no\"\r\n        largeAstig = \"no\"\r\n        restrainAstig = \"yes\"\r\n        expertOptions = \"no\"\r\n        \r\n        ctfexec = ( \"ctffind \" + flags + \" << STOP_PARSING \\n\" + mrcName + \"\\n\" )\r\n        if bool(movieMode):\r\n             ctfexec = ctfexec + \"yes\\n\" + str(number_of_frames_to_average + \"\\n\" )\r\n         \r\n        ctfexec = (ctfexec + diagOutName + \"\\n\" + str(ps) + \"\\n\" + str(self.voltage) + \"\\n\" +\r\n            str(self.C3) + \"\\n\" + str(contrast) + \"\\n\" + str(box_size) + \"\\n\" +\r\n            str(min_res) + \"\\n\" + str(max_res) + \"\\n\" + str(min_C1) + \"\\n\" + \r\n            str(max_C1) + \"\\n\" + str(C1_step) + \"\\n\" + str(knownAstig) + \"\\n\" + \r\n            str(largeAstig) + \"\\n\" + str(restrainAstig) + \"\\n\" +\r\n            str(A1_tol) + \"\\n\" + find_additional_phase_shift + \"\\n\" +\r\n            str(expertOptions) )    \r\n        ctfexec = ctfexec + \"\\nSTOP_PARSING\"\r\n\r\n        subprocess.call( ctfexec, shell=True )\r\n\r\n        \r\n        try:\r\n            logName = os.path.join( self.cachePath, stackBase + \".txt\" )\r\n            print( \"Trying to load from: \" + logName )\r\n            # Log has 5 comment lines, then 1 header, and\r\n            # Micrograph number, DF1, DF2, Azimuth, Additional Phase shift, CC, and max spacing fit-to\r\n            CTF4Results = np.loadtxt(logName, comments='#', skiprows=1 )\r\n            self.CTFInfo[u'DefocusU'] = float( CTF4Results[1] )\r\n            self.CTFInfo[u'DefocusV'] = float( CTF4Results[2] )\r\n            self.CTFInfo[u'DefocusAngle'] = float( CTF4Results[3] )\r\n            self.CTFInfo[u'AdditionalPhaseShift'] = float( CTF4Results[4] )\r\n            self.CTFInfo[u'CtfFigureOfMerit'] = float( CTF4Results[5] )\r\n            self.CTFInfo[u'FinalResolution'] = float( CTF4Results[6] )\r\n            \r\n            self.CTFDiag = mrcz.readMRC( diagOutName )[0]\r\n            \r\n        except:\r\n            print( \"CTFFIND4 likely core-dumped, try different input parameters?\" )\r\n        pass\r\n        # Write a RELION-style _ctffind3.log file, with 5 um pixel size...\r\n        self.saveRelionCTF3()\r\n            \r\n        # TODO: having trouble with files not being deletable, here.  Is CTFFIND4 holding them open?  Should \r\n        # I just pause for a short time?\r\n        time.sleep(0.5) # DEBUG: try and see if temporary files are deletable now.\r\n        try: os.remove( mrcName )\r\n        except IOError: \r\n            print( \"Could not remove temporary file: \" + str(IOError) )\r\n        try: os.remove( diagOutName )\r\n        except IOError: \r\n            print( \"Could not remove temporary file: \" + str(IOError) )\r\n        # Delete CTF4 logs\r\n        try: os.remove( os.path.join( self.cachePath, stackBase + \"_avrot.txt\") )\r\n        except: pass\r\n        try: os.remove( logName )\r\n        except: pass\r\n        try: os.remove( os.path.join( self.cachePath, stackBase + \".ctf\" ) )\r\n        except: pass\r\n        self.bench['ctf1'] = time.time()\r\n                                \r\n    def execCTFFind4( self, movieMode=False, box_size = 512, contrast=0.067, \r\n                     min_res=50.0, max_res=4.0, \r\n                     min_C1=5000.0, max_C1=45000.0, C1_step = 500.0, \r\n                     A1_tol = 100.0, displayDiag=False ):\r\n        \"\"\"\r\n        Calls CTFFind4, must be on the system path.\r\n             movieMode = True does not require an aligned image (works on Fourier magnitudes)\r\n             box_size = CTFFind parameter, box size to FFT\r\n             contrast = estimated phase contrast in images\r\n             min_res = minimum resolution to fit, in Angstroms\r\n             max_res = maximum resolution to fit, in Angstroms.  Water ice is around 3.4 Angstroms\r\n             min_C1 = minimum defocus search range, in Angstroms\r\n             max_C1 = maximum defocus search range, in Angstroms\r\n             C1_step = defocus search step size, in Angstroms\r\n             A1_tol = 2-fold astigmatism tolerance, in Angstroms\r\n             displayDiag = True plots the diagnostic output image\r\n        \"\"\"\r\n        self.bench['ctf0'] = time.time()\r\n        if util.which( 'ctffind' ) is None:\r\n            print( \"Error: CTFFIND not found!\" )\r\n            return\r\n        if self.pixelsize is None:\r\n            print( \"Set pixelsize (in nm) before calling execCTFFind4\" )\r\n            return\r\n        elif self.voltage is None:\r\n            print( \"Set voltage (in kV) before calling execCTFFind4\" )\r\n            return\r\n        elif self.C3 is None:\r\n            print( \"Set C3 (in mm) before calling execCTFFind4\" )\r\n            return\r\n        \r\n        print( \"Calling CTFFIND4 for \" + self.files['stack'] )\r\n        print( \"   written by <NAME>: http:\/\/grigoriefflab.janelia.org\/ctffind4\" )\r\n        print( \"   http:\/\/biorxiv.org\/content\/early\/2015\/06\/16\/020917\" )\r\n        \r\n        ps = self.pixelsize * 10.0\r\n        min_res = np.min( [min_res, 50.0] )\r\n        \r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass\r\n        \r\n        if self.cachePath is None:\r\n            self.cachePath = \".\"\r\n            \r\n        # Force trailing slashes onto cachePatch\r\n        stackBase = os.path.splitext( os.path.basename( self.files[u'stack'] ) )[0]\r\n            \r\n        diagOutName = os.path.join( self.cachePath, stackBase + u\".ctf\" )\r\n         \r\n        try: \r\n            mrcName = os.path.join( self.cachePath, stackBase + u\"_ctf4.mrc\" )\r\n            if movieMode:\r\n                input_is_a_movie = 'true'\r\n                mrcz.writeMRC( self.images, mrcName )\r\n                number_of_frames_to_average = 1\r\n            else:\r\n                input_is_a_movie = 'false'\r\n                mrcz.writeMRC( self.imageSum, mrcName )\r\n        except:\r\n            print( \"Error in exporting MRC file to CTFFind4\" )\r\n            return\r\n         \r\n        # flags = \"--amplitude-spectrum-input --filtered-amplitude-spectrum-input\"\r\n        flags = \"\" # Not using any flags\r\n        find_additional_phase_shift = 'false'\r\n        \r\n        ctfexec = ( \"ctffind \" + flags + \" << STOP_PARSING \\n\" + mrcName )\r\n        if input_is_a_movie == 'true' or input_is_a_movie == 'yes':\r\n             ctfexec = ctfexec + \"\\n\" + input_is_a_movie + \"\\n\" + str(number_of_frames_to_average)\r\n         \r\n        ctfexec = (ctfexec + \"\\n\" + diagOutName + \"\\n\" + str(ps) + \"\\n\" + str(self.voltage) + \"\\n\" +\r\n            str(self.C3) + \"\\n\" + str(contrast) + \"\\n\" + str(box_size) + \"\\n\" +\r\n            str(min_res) + \"\\n\" + str(max_res) + \"\\n\" + str(min_C1) + \"\\n\" + \r\n            str(max_C1) + \"\\n\" + str(C1_step) + \"\\n\" + str(A1_tol) + \"\\n\" + \r\n            find_additional_phase_shift )    \r\n        ctfexec = ctfexec + \"\\nSTOP_PARSING\"\r\n\r\n        print( ctfexec )\r\n        sub = subprocess.Popen( ctfexec, shell=True )\r\n        sub.wait()\r\n        # os.system( ctfexec )\r\n        \r\n        #print( \"CTFFIND4 execution time (s): \" + str(t1-t0))    \r\n        try:\r\n            logName = os.path.join( self.cachePath, stackBase + \".txt\" )\r\n            print( \"Trying to load from: \" + logName )\r\n            # Log has 5 comment lines, then 1 header, and\r\n            # Micrograph number, DF1, DF2, Azimuth, Additional Phase shift, CC, and max spacing fit-to\r\n            CTF4Results = np.loadtxt(logName, comments='#', skiprows=1 )\r\n            self.CTFInfo[u'DefocusU'] = float( CTF4Results[1] )\r\n            self.CTFInfo[u'DefocusV'] = float( CTF4Results[2] )\r\n            self.CTFInfo[u'DefocusAngle'] = float( CTF4Results[3] )\r\n            self.CTFInfo[u'AdditionalPhaseShift'] = float( CTF4Results[4] )\r\n            self.CTFInfo[u'CtfFigureOfMerit'] = float( CTF4Results[5] )\r\n            self.CTFInfo[u'FinalResolution'] = float( CTF4Results[6] )\r\n            \r\n            self.CTFDiag = mrcz.readMRC( diagOutName )[0]\r\n            \r\n        except IOError:\r\n            print( \"CTFFIND4 likely core-dumped, try different input parameters?\" )\r\n        pass\r\n        # Write a RELION-style _ctffind3.log file, with 5 um pixel size...\r\n        self.saveRelionCTF3()\r\n            \r\n        # TODO: having trouble with files not being deletable, here.  Is CTFFIND4 holding them open?  Should \r\n        # I just pause for a short time?\r\n        time.sleep(0.5) # DEBUG: try and see if temporary files are deletable now.\r\n        try: os.remove( mrcName )\r\n        except IOError: \r\n            print( \"Could not remove temporary file: \" + str(IOError.message) )\r\n        try: os.remove( diagOutName )\r\n        except: pass\r\n        # Delete CTF4 logs\r\n        try: os.remove( os.path.join( self.cachePath, stackBase + \"_avrot.txt\") )\r\n        except: pass\r\n        try: os.remove( logName )\r\n        except: pass\r\n        try: os.remove( os.path.join( self.cachePath, stackBase + \".ctf\" ) )\r\n        except: pass\r\n        self.bench['ctf1'] = time.time()\r\n       \r\n    def saveRelionCTF3( self ):\r\n        # Saves the results from CTF4 in a pseudo-CTF3 log that RELION 1.3\/1.4 can handle\r\n        # Relevant code is in ctffind_runner.cpp, in the function getCtffindResults() (line 248)\r\n        # Relion searchs for: \r\n        #   \"CS[mm], HT[kV], AmpCnst, XMAG, DStep[um]\"\r\n        # and\r\n        #      DFMID1      DFMID2      ANGAST          CC\r\n        #\r\n        #    15876.71    16396.97       52.86     0.10179  Final Values\r\n    \r\n        # Mag goes from micrometers of detector pixel size, to specimen pixel size (in nm)\r\n        amp_contrast = self.CTFInfo[u'AmplitudeContrast']\r\n        \r\n        if bool(self.detectorPixelSize):\r\n            dstep = self.detectorPixelSize # Assumed to be in microns\r\n        else:\r\n            dstep = 5.0 # default value of 5.0 microns, Relion-2 doesn't use it anyway...\r\n        \r\n        mag = (dstep*1E-6) \/ (self.pixelsize*1E-9)\r\n        \r\n        if self.files[u'sum'] != None:\r\n            sumFront = os.path.splitext( self.files[u'sum'] )[0]\r\n        else:\r\n            sumFront = os.path.splitext( self.files[u'stack'] )[0]\r\n        # Check to see if the sum directory exists already or not\r\n        sumDir = os.path.split( sumFront )[0]\r\n        if bool(sumDir) and not os.path.isdir( sumDir ):\r\n            os.mkdir( sumDir )         \r\n        \r\n        self.files[u'ctflog'] = sumFront + u\"_ctffind3.log\"\r\n        logh = open( self.files[u'ctflog'], \"w\" )\r\n        \r\n        logh.write( u\"CS[mm], HT[kV], AmpCnst, XMAG, DStep[um]\\n\" )\r\n        logh.write( u\"%.2f\"%self.C3 + u\" %.1f\"%self.voltage + u\" \" + \r\n            str(amp_contrast) + u\" %.1f\" %mag + u\" %.2f\"%dstep + u\"\\n\" )\r\n        \r\n        try:\r\n            logh.write( u\"%.1f\"%self.CTFInfo['DefocusU']+ u\" %.1f\"%self.CTFInfo['DefocusV'] \r\n                + u\" %.4f\"%self.CTFInfo['DefocusAngle']+ u\" %.4f\"%self.CTFInfo['CtfFigureOfMerit'] \r\n                + u\" Final Values\\n \")\r\n        except:\r\n            print( \"Warning: Could not write CTFInfo to ctf3-style log, probably CTF estimation failed\" )\r\n        logh.close()\r\n        pass\r\n    \r\n    def loadData( self, stackNameIn = None, target=u\"stack\", leading_zeros=0, useMemmap=False ):\r\n        \"\"\"\r\n        Import either a sequence of DM3 files, a MRCS stack, a DM4 stack, or an HDF5 file.\r\n        \r\n        Target is a string representation of the member name, i.e. 'images', 'imageSum', 'C0'\r\n        \r\n        Files can be compressed with 'lbzip2' (preferred) or 'pigz' with extension '.bz2' or '.gz'\r\n        \r\n        On Windows machines you must have 7-zip in the path to manage compression, and \r\n        only .bz2 is supported\r\n        \r\n        filename can be an absolute path name or relative pathname.  Automatically \r\n        assumes file format based on extension.\r\n        \"\"\"\r\n        self.bench['loaddata0'] = time.time() \r\n        # import os\r\n        from os.path import splitext\r\n        \r\n        if stackNameIn != None:\r\n            self.files[target] = stackNameIn\r\n            \r\n        #### DECOMPRESS FILE ####\r\n        # This will move the file to the cachePath, so potentially could result in some confusion\r\n        self.files[target] = util.decompressFile( self.files[target], outputDir = self.cachePath )\r\n        \r\n        \r\n        [file_front, file_ext] = splitext( self.files[target] )\r\n        \r\n        #### IMAGE FILES ####\r\n        if file_ext == u\".dm3\" :\r\n            print( \"Loading DM3 files in sequence\" )\r\n            try:\r\n                import DM3lib as dm3\r\n                from glob import glob\r\n            except:\r\n                raise ImportError( \"Error: DM3lib not found, download at: http:\/\/imagejdocu.tudor.lu\/doku.php?id=plugin:utilities:python_dm3_reader:start\" )\r\n                return\r\n             \r\n            file_seq = file_front.rstrip( '1234567890' )\r\n            filelist = glob( file_seq + \"*\" + file_ext )\r\n            \r\n            file_nums = []\r\n            for I in range(0, len(filelist) ):\r\n                # Get all the file_nums\r\n                [file_front, fit_ext] = splitext( filelist[I] )\r\n                file_strip = file_front.rstrip( '1234567890' ) # Strip off numbers\r\n                file_nums.append( file_front[len(file_strip):]  )\r\n            file_nums = np.sort( np.array(file_nums,dtype='int' ) )\r\n            \r\n            filecount = len(filelist)\r\n            \r\n            # TO DO: handle things that aren't sequential lists of DM3 files\r\n            # Note, ideally we append to images rather than overwriting\r\n            dm3struct = dm3.DM3( self.files[target] )\r\n            tempData = np.empty( [ filecount, dm3struct.imagedata.shape[0], dm3struct.imagedata.shape[1]]  )\r\n            tempData[0,:,:] = dm3struct.imagedata\r\n\r\n            for I in np.arange( 1, filecount ):\r\n                filenameDM3 = file_strip + str(file_nums[I]).zfill(leading_zeros) + self.file_ext\r\n                print( \"Importing: \" + filenameDM3 )\r\n                dm3struct = dm3.DM3( filenameDM3 )\r\n                tempData[I,:,:] = dm3struct.imagedata\r\n        elif file_ext == u'.tif' or file_ext == u'.tiff':\r\n            # For compressed TIFFs we should use PIL, as it's the fastest.  Freeimage\r\n            # is actually the fastest but it only imports the first frame in a stack...\r\n            try:\r\n                import skimage.io\r\n            except:\r\n                print( \"Error: scikit-image or glob not found!\" )\r\n                return  \r\n                \r\n            print( \"Importing: \" + self.files[target] )\r\n            try:\r\n                tempData = skimage.io.imread( self.files[target], plugin='pil' ).astype( 'float32' )\r\n            except:\r\n                print( \"Error: PILlow image library not found, reverting to (slow) TIFFFile\" )\r\n                tempData = skimage.io.imread( self.files[target], plugin='tifffile' ).astype( 'float32' )\r\n                \r\n            \"\"\"\r\n            # Sequence mode\r\n            print( \"Loading TIFF files in sequence\" )\r\n            try:\r\n                import skimage.io\r\n                from glob import glob\r\n            except:\r\n                print( \"Error: scikit-image or glob not found!\" )\r\n                return\r\n\r\n            file_seq = file_front.rstrip( '1234567890' )\r\n            filelist = glob( file_seq + \"*\" + self.file_ext )\r\n            \r\n            file_nums = []\r\n            for I in range(0, len(filelist) ):\r\n                # Get all the file_nums\r\n                [file_front, fit_ext] = splitext( filelist[I] )\r\n                file_strip = file_front.rstrip( '1234567890' ) # Strip off numbers\r\n                file_nums.append( file_front[len(file_strip):]  )\r\n            file_nums = np.sort( np.array(file_nums,dtype='int' ) )\r\n            filecount = len(filelist)\r\n            \r\n            # see if freeimage is available\r\n            try:\r\n                skimage.io.use_plugin( 'freeimage' )\r\n            except:\r\n                print( \"FreeImage library not found, it is recommended for TIFF input.\" )\r\n                skimage.io.use_plugin( 'tifffile' )\r\n                \r\n            mage1 = skimage.io.imread( self.files[target] )\r\n            tempData = np.empty( [ filecount, mage1.shape[0], mage1.shape[1]]  )\r\n            tempData[0,:,:] = mage1\r\n\r\n            for I in np.arange( 1, filecount ):\r\n                filenameTIFF = file_strip + str(file_nums[I]).zfill(leading_zeros) + self.file_ext\r\n                print( \"Importing: \" + filenameTIFF )\r\n                tempData[I,:,:] = skimage.io.imread( filenameTIFF )\r\n            \"\"\"\r\n        elif file_ext == u\".dm4\":\r\n            # Expects a DM4 image stack\r\n            print( \"Open as DM4: \" + self.files[target] )\r\n            dm4obj = mrcz.readDM4( self.files[target], verbose=False, useMemmap = useMemmap )\r\n            tempData = np.copy( dm4obj.im[1].imageData.astype( float_dtype ), order='C' )\r\n            # Load pixelsize from file\r\n            try:\r\n                if bool( dm4obj.im[1].imageInfo['DimXScale'] ):\r\n                    if dm4obj.im[1].imageInfo[u'DimXUnits'] == u'\\x14\\x00': # This is what we get with no value set.\r\n                        print( \"DM4 pixels have no units, keeping previously set pixelsize\" )\r\n                        if self.pixelsize == None:\r\n                            self.pixelsize\r\n                        #else do nothing\r\n                    else:\r\n                        self.pixelsize = dm4obj.im[1].imageInfo['DimXScale'] # DM uses units of nm, we assume we don't have rectangular pixels because that's evil\r\n            except KeyError: pass\r\n            try: \r\n                if bool(dm4obj.im[1].imageInfo['Voltage'] ):\r\n                    self.voltage = dm4obj.im[1].imageInfo['Voltage'] \/ 1000.0 # in kV\r\n            except KeyError: pass\r\n            try:\r\n                if bool(dm4obj.im[1].imageInfo['C3']):\r\n                    self.C3 = dm4obj.im[1].imageInfo['C3'] # in mm\r\n            except KeyError: pass\r\n            try:\r\n                if bool(dm4obj.im[1].imageInfo['DetectorPixelSize']):\r\n                    self.detectorPixelSize = dm4obj.im[1].imageInfo['DetectorPixelSize'][0] # in um\r\n            except KeyError: pass    \r\n            \r\n            del dm4obj\r\n        elif file_ext == u\".mrc\" or file_ext == u'.mrcs' or file_ext == u\".mrcz\" or file_ext == u\".mrczs\":\r\n            # Expects a MRC image stack\r\n            tempData, header = mrcz.readMRC( self.files[target], pixelunits=u'nm' )\r\n            # Force data to 32-bit float if it uint8 or uint16\r\n            if tempData.dtype.itemsize < 4:\r\n                tempData = tempData.astype('float32')\r\n                \r\n            # As old MotionCorr data has no pixelsize in the header, only accept if the MRC file has non-zero\r\n            # This allows a pre-set of ImageRegistrator.pixelsize\r\n            if not np.isclose( header[u'pixelsize'][0] , 0.0 ):\r\n                # Convert from Angstroms to nm performed internally\r\n                self.pixelsize = np.float32( header[u'pixelsize'][0]  ) \r\n            # Should try writing C3 and voltage somewhere \r\n        elif file_ext == u\".hdf5\" or file_ext == u\".h5\":\r\n            \r\n            try:\r\n                h5file = tables.open_file( self.files[target], mode='r' )\r\n            except:\r\n                print( \"Could not open HDF5 file: \" + self.files[target] )\r\n            print( h5file )\r\n            try: tempData = np.copy( h5file.get_node( '\/', \"images\" ), order='C' ).astype('float32')\r\n            except: print( \"HDF5 file import did not find \/images\" )\r\n            # TODO: load other nodes\r\n            try: self.pixelsize = np.copy( h5file.get_node( '\/', \"pixelsize\" ), order='C' )\r\n            except: print( \"HDF5 file import did not find \/pixelsize\" )\r\n            try: self.voltage = np.copy( h5file.get_node( '\/', \"voltage\" ), order='C' )\r\n            except: print( \"HDF5 file import did not find \/voltage\" )\r\n            try: self.detectorPixelSize = np.copy( h5file.get_node( '\/', \"detectorPixelSize\" ), order='C' )\r\n            except: print( \"HDF5 file import did not find \/detectorPixelSize\" )\r\n            try: self.C3 = np.copy( h5file.get_node( '\/', \"C3\" ), order='C' )\r\n            except: print( \"HDF5 file import did not find \/C3\" )\r\n            \r\n            try:\r\n                h5file.close()\r\n            except:\r\n                pass\r\n            pass\r\n        else:\r\n            print( \"Unknown file extesion: \" + stackNameIn )\r\n            return\r\n        \r\n        #### GAIN REFERENCE MANAGEMENT ####\r\n        if target != u'gainRef' and u'gainRef' in self.files and bool(self.files[u'gainRef']):\r\n        \r\n            # The Gatan gain reference is always a multiplication operation.  What of FEI and DE detectors?  \r\n            if not np.any( self.gainRef ):\r\n                self.loadData( self.files[u'gainRef'], target=u'gainRef' )\r\n            \r\n            gainRef = self.gainRef\r\n\r\n            # Apply gain reference to each tempData, this should broadcast with numexpr?\r\n            print( \"Applying gain reference: %s\" % self.files[u'gainRef'] )\r\n            tempData = nz.evaluate( \"gainRef * tempData\" )\r\n            pass\r\n        \r\n        # Finally, assign to target\r\n        # TODO: set self.files[] dict values?\r\n        if target == u\"stack\" or target == u'align' or target == u'images':\r\n            if tempData.ndim != 3: # Probably the user saved a 2D image by mistake\r\n                self.METAstatus = u\"error\"\r\n                self.saveConfig()\r\n                raise ValueError( \"zorro.loadData: stacks must be 3D data\" )\r\n                \r\n            if bool(self.gain) and not np.isclose( self.gain, 1.0 ):\r\n                self.images = tempData \/ self.gain\r\n            else:\r\n                self.images = tempData\r\n                \r\n        elif target == u\"sum\" or target == u'imageSum':\r\n            self.imageSum = tempData\r\n            \r\n            \r\n        elif target == u\"gainRef\":\r\n            # Apply flips and rotations\r\n            if 'Diagonal' in self.gainInfo and self.gainInfo['Diagonal']:\r\n                print( \"Rotating gain reference by 90 degrees\" )\r\n                tempData = np.rot90( tempData, k = 1 )\r\n                \r\n            if 'Horizontal' in self.gainInfo and self.gainInfo['Horizontal'] and \\\r\n                'Vertical' in self.gainInfo and  self.gainInfo['Vertical']:\r\n                # This is an image mirror, usually.\r\n                print( \"Rotating gain reference by 180 degrees (mirror)\" )\r\n                tempData = np.rot90( tempData, k =2 )\r\n            elif 'Horizontal' in self.gainInfo and self.gainInfo['Horizontal']:\r\n                print( \"Flipping gain reference horizontally (mirror)\" )\r\n                tempData = np.fliplr( tempData )\r\n            elif 'Vertical' in self.gainInfo and  self.gainInfo['Vertical']:\r\n                print( \"Flipping gain reference vertically (mirror)\" )\r\n                tempData = np.flipud( tempData )\r\n            # TODO: see if any other labs have some wierd configuration of flips and rotations.\r\n                \r\n            # The Gatan gain reference has a lot of hot pixel artifacts, that we'll clip away for the moment\r\n            # Perhaps we should explicitely use the same algorithm as the hot pixel mask.\r\n                \r\n            #gainCutoff = 1E-4\r\n            #gainLim = util.histClim( tempData, cutoff=gainCutoff )\r\n            #hotpix = ( tempData <= gainLim[0] ) | ( tempData >= gainLim[1] )\r\n            # Possibly we could skip the uniform filter and just force hot pixels to \r\n            # 1.0?  I might get in trouble from a non-Gatan detector?\r\n            \r\n            # self.gainRef = ~hotpix*tempData + hotpix*scipy.ndimage.uniform_filter( tempData, size=5 )\r\n            #self.gainRef = ~hotpix*tempData + hotpix\r\n            self.gainRef = tempData\r\n            \r\n        elif target == u\"filt\" or target == u'filtSum':\r\n            self.filtSum = tempData\r\n        elif target == u\"xc\":\r\n            self.C = tempData\r\n            print( \"TODO: set filename for C in loadData\" )\r\n        elif target == u\"mask\":\r\n            self.masks = tempData\r\n            \r\n        self.bench['loaddata1'] = time.time() \r\n        \r\n    def saveData( self ):\r\n        \"\"\"\r\n        Save files to disk.  \r\n        \r\n        Do compression of stack if requested, self.compression = '.bz2' for example\r\n        uses lbzip2 or 7-zip. '.gz' is also supported by not recommended.\r\n        \r\n        TODO: add dtype options, including a sloppy float for uint16 and uint8\r\n        \"\"\"\r\n        self.bench['savedata0'] = time.time()\r\n        import os, shutil\r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass\r\n\r\n        # If self.files['config'] exists we save relative to it.  Otherwise we default to the place of \r\n        # self.files['stack']\r\n#        if bool( self.files['config'] ): \r\n#            baseDir = os.path.dirname( self.files['config'] )\r\n#        else:\r\n#            baseDir = os.path.dirname( self.files['stack'] )\r\n        stackFront, stackExt = os.path.splitext( os.path.basename( self.files[u'stack'] ) )\r\n        \r\n        if not 'compressor' in self.files or not bool(self.files['compressor']):\r\n            mrcExt = \".mrc\"\r\n            mrcsExt = \".mrcs\"\r\n            self.files['compressor'] = None\r\n            self.files['clevel'] = 0\r\n        else:\r\n            mrcExt = \".mrcz\"\r\n            mrcsExt = \".mrcsz\" \r\n        \r\n        # Change the current directory to make relative pathing sensible\r\n#        try:\r\n#            os.chdir( baseDir )\r\n#        except: \r\n#            baseDir = \".\"# Usually baseDir is \"\" which is \".\"\r\n        \r\n        if stackExt == \".bz2\" or stackExt == \".gz\" or stackExt == \".7z\":\r\n            # compressExt = stackExt\r\n            stackFront, stackExt = os.path.splitext( stackFront )\r\n            \r\n        if self.files[u'sum'] is None: # Default sum name\r\n            self.files[u'sum'] = os.path.join( u\"sum\", u\"%s_zorro%s\" %(stackFront, mrcExt) )\r\n\r\n        # Does the directory exist?  Often this will be a relative path to file.config\r\n        sumPath, sumFile = os.path.split( self.files[u'sum'] )\r\n        if not os.path.isabs( sumPath ):\r\n            sumPath = os.path.realpath( sumPath ) # sumPath is always real\r\n        if bool(sumPath) and not os.path.isdir( sumPath ):\r\n            os.mkdir( sumPath )\r\n        relativeSumPath = os.path.relpath( sumPath )\r\n        \r\n        #### SAVE ALIGNED SUM ####\r\n        if self.verbose >= 1:\r\n            print( \"Saving: \" + os.path.join(sumPath,sumFile) )\r\n        mrcz.writeMRC( self.imageSum, os.path.join(sumPath,sumFile), \r\n                        pixelsize=self.pixelsize, pixelunits=u'nm',\r\n                        voltage = self.voltage, C3 = self.C3, gain = self.gain,\r\n                        compressor=self.files[u'compressor'], \r\n                        clevel=self.files[u'clevel'], \r\n                        n_threads=self.n_threads) \r\n\r\n        # Compress sum\r\n        if bool(self.doCompression):\r\n            util.compressFile( os.path.join(sumPath,sumFile), self.compress_ext, n_threads=self.n_threads )\r\n\r\n        #### SAVE ALIGNED STACK ####\r\n        if bool(self.saveMovie):\r\n            if self.files[u'align'] is None: # Default filename for aligned movie\r\n                self.files[u'align'] = os.path.join( u\"align\", u\"%s_zorro_movie%s\" % (stackFront, mrcsExt) )\r\n                \r\n            # Does the directory exist?\r\n            alignPath, alignFile = os.path.split( self.files[u'align'] )\r\n            if not os.path.isabs( sumPath ):\r\n                alignPath = os.path.realpath( alignPath )\r\n            if bool(alignPath) and not os.path.isdir( alignPath ):\r\n                os.mkdir( alignPath )\r\n            \r\n            if self.verbose >= 1:\r\n                print( \"Saving: \" + os.path.join(alignPath,alignFile) )\r\n            mrcz.writeMRC( self.images, os.path.join(alignPath,alignFile), \r\n                            pixelsize=self.pixelsize, pixelunits=u'nm',\r\n                            voltage = self.voltage, C3 = self.C3, gain = self.gain,\r\n                            compressor=self.files[u'compressor'], \r\n                            clevel=self.files[u'clevel'], \r\n                            n_threads=self.n_threads) \r\n\r\n            # Compress stack\r\n            if bool(self.doCompression):\r\n                util.compressFile( os.path.join(alignPath,alignFile), self.compress_ext, n_threads=self.n_threads )\r\n                \r\n        if bool(self.filterMode) and np.any(self.filtSum): # This will be in the same place as sum\r\n            if not u'filt' in self.files or self.files[u'filt'] is None: # Default filename for filtered sum\r\n                self.files[u'filt'] = os.path.join( relativeSumPath, u\"%s_filt%s\" %(os.path.splitext(sumFile)[0], mrcExt) )\r\n            \r\n            filtPath, filtFile = os.path.split( self.files[u'filt'] )\r\n            if not os.path.isabs( filtPath ):\r\n                filtPath = os.path.realpath( filtPath ) \r\n                \r\n            if self.verbose >= 1:\r\n                print( \"Saving: \" + os.path.join(filtPath, filtFile) )\r\n            mrcz.writeMRC( self.filtSum, os.path.join(filtPath, filtFile), \r\n                            pixelsize=self.pixelsize, pixelunits=u'nm',\r\n                            voltage = self.voltage, C3 = self.C3, gain = self.gain,\r\n                            compressor=self.files[u'compressor'], \r\n                            clevel=self.files[u'clevel'], \r\n                            n_threads=self.n_threads) \r\n\r\n        #### SAVE CROSS-CORRELATIONS FOR FUTURE PROCESSING OR DISPLAY ####\r\n        if self.saveC and self.C != None:\r\n            self.files[u'xc'] = os.path.join( sumPath, u\"%s_xc%s\" % (os.path.splitext(sumFile)[0],mrcsExt) )\r\n            if self.verbose >= 1:\r\n                print( \"Saving: \" + self.files[u'xc'] )\r\n                \r\n            mrcz.writeMRC( np.asarray( self.C, dtype='float32'), self.files[u'xc'], \r\n                            pixelsize=self.pixelsize, pixelunits=u'nm',\r\n                            voltage = self.voltage, C3 = self.C3, gain = self.gain,\r\n                            compressor=self.files[u'compressor'], \r\n                            clevel=self.files[u'clevel'], \r\n                            n_threads=self.n_threads) \r\n                            \r\n            if bool(self.doCompression):\r\n                util.compressFile( self.files[u'xc'], self.compress_ext, n_threads=self.n_threads )\r\n            \r\n        #### SAVE OTHER INFORMATION IN A LOG FILE ####\r\n        # Log file is saved seperately...  Calling it here could lead to confusing behaviour.\r\n\r\n        if u'moveRawPath' in self.files and bool( self.files[u'moveRawPath'] ) and not os.path.isdir( self.files[u'moveRawPath'] ):\r\n            os.mkdir( self.files[u'moveRawPath'] )\r\n                \r\n        if bool( self.doCompression ): # does compression and move in one op\r\n            self.files[u'stack'] = util.compressFile( self.files[u'stack'], outputDir=self.files[u'moveRawPath'], \r\n                                               n_threads=self.n_threads, compress_ext=self.compress_ext )\r\n        elif u'moveRawPath' in self.files and bool( self.files[u'moveRawPath'] ):\r\n            newStackName = os.path.join( self.files[u'moveRawPath'], os.path.split( self.files[u'stack'])[1] )\r\n            print( \"Moving \" +self.files[u'stack'] + \" to \" + newStackName )\r\n            \r\n            try:\r\n                os.rename( self.files[u'stack'], newStackName )\r\n            except:\r\n                # Often we can't rename between file systems so we need to copy and delete instead\r\n                shutil.copyfile( self.files[u'stack'], newStackName )\r\n                # if os.path.isfile( newStackName) and filecmp.cmp( self.files['stack'], newStackName ):\r\n                # filecmp is very, very slow...  we need a better trick, maybe just compare sizes\r\n                if os.path.isfile( newStackName):\r\n                    os.remove( self.files[u'stack'] )\r\n                else:\r\n                    print( \"Error in copying raw stack, original will not be deleted from input directory\" )\r\n\r\n            self.files[u'stack'] = newStackName\r\n        pass\r\n        self.bench['savedata1'] = time.time()\r\n\r\n\r\n    def loadConfig( self, configNameIn = None, loadData=False ):\r\n        \"\"\"\r\n        Initialize the ImageRegistrator class from a config file\r\n        \r\n        loadData = True will load data from the given filenames.\r\n        \"\"\"\r\n        \r\n        import json\r\n        if not bool(configNameIn):\r\n            if not bool( self.files['config'] ):\r\n                pass # Do nothing\r\n            else:\r\n                print( \"Cannot find configuration file: \" + self.files[u'config'] )\r\n        else:\r\n            self.files[u'config'] = configNameIn\r\n\r\n        print( \"Loading config file: \" + self.files[u'config'] )\r\n        config = configparser.RawConfigParser(allow_no_value = True)\r\n        try:\r\n            config.optionxform = unicode # Python 2\r\n        except:\r\n            config.optionxform = str # Python 3\r\n        \r\n        ##### Paths #####\r\n        # I'd prefer to pop an error here if configName doesn't exist\r\n        if not os.path.isfile( self.files[u'config'] ):\r\n            raise IOError( \"zorro.loadConfig: Could not load config file %s\" % self.files[u'config'] )\r\n        config.read( self.files[u'config'] )\r\n        \r\n        \r\n         \r\n        # Initialization\r\n        try: self.verbose = config.getint( u'initialization', u'verbose' )\r\n        except: pass\r\n        try: self.umask = config.getint( u'initialization', u'umask' )\r\n        except: pass\r\n        try: self.fftw_effort = config.get( u'initialization', u'fftw_effort' ).upper()\r\n        except: pass\r\n        try: self.n_threads = config.getint( u'initialization', u'n_threads' )\r\n        except: pass\r\n        try: self.saveC = config.getboolean( u'initialization', u'saveC' )\r\n        except: pass\r\n        try: self.METAstatus = config.get( u'initialization', u'METAstatus' )\r\n        except: pass\r\n        try: self.cachePath = config.get( u'initialization', u'cachePath' )\r\n        except: pass\r\n    \r\n        # Calibrations\r\n        try: self.pixelsize = config.getfloat(u'calibration',u'pixelsize')\r\n        except: pass\r\n        try: self.voltage = config.getfloat(u'calibration',u'voltage')\r\n        except: pass\r\n        try: self.C3 = config.getfloat(u'calibration',u'C3')\r\n        except: pass\r\n        try: self.gain = config.getfloat(u'calibration',u'gain')\r\n        except: pass\r\n        try: self.detectorPixelSize = config.getfloat(u'calibration',u'detectorPixelSize')\r\n        except: pass\r\n        try: self.gainInfo = json.loads( config.get( u'calibration', u'gainInfo' ))   \r\n        except: pass\r\n    \r\n        # Data\r\n        try: self.trackCorrStats = config.getboolean( u'data', u'trackCorrStats' )\r\n        except: pass\r\n        try: self.corrStats = json.loads( config.get(u'data', u'corrStats') )\r\n        except: pass\r\n        try: self.bench = json.loads( config.get(u'data', u'bench') )\r\n        except: pass\r\n        try: self.hotpixInfo = json.loads( config.get(u'data', u'hotpixInfo') )\r\n        except: pass\r\n        \r\n\r\n        # Results \r\n        # Load arrays with json\r\n        try: self.translations = np.array( json.loads( config.get( u'results', u'translations' ) ) )\r\n        except: pass\r\n        try: self.transEven = np.array( json.loads( config.get( u'results', u'transEven' ) ) )\r\n        except: pass\r\n        try: self.transOdd = np.array( json.loads( config.get( u'results', u'transOdd' ) ) )\r\n        except: pass\r\n        try: self.velocities = np.array( json.loads( config.get( u'results', u'velocities' ) ) )\r\n        except: pass\r\n        try: self.rotations = np.array( json.loads( config.get( u'results', u'rotations' ) ) )\r\n        except: pass\r\n        try: self.scales = np.array( json.loads( config.get( u'results', u'scales' ) ) )\r\n        except: pass\r\n        try: self.FRC = np.array( json.loads( config.get( u'results', u'FRC' ) ) )\r\n        except: pass\r\n    \r\n        try: self.CTFProgram = config.get( u'ctf', u'CTFProgram' )\r\n        except: pass\r\n        # CTF dict\r\n        try: self.ctfInfo = json.loads( config.get( u'ctf', u'CTFInfo' ) )\r\n        except: pass\r\n\r\n\r\n        errorDictsExist=True\r\n        errCnt = 0\r\n        while errorDictsExist:\r\n            try:\r\n                newErrorDict = {}\r\n                dictName = u'errorDict%d' % errCnt\r\n                # Load the list of keys and then load them element-by-element\r\n                # newErrorDict = json.loads( config.get( 'data', dictName ) )\r\n                keyList = json.loads( config.get( dictName, u'keyList' ) )\r\n                for key in keyList:\r\n                    newErrorDict[key] = np.array( json.loads( config.get( dictName, key ) ) )\r\n                    # convert singular values from arrays\r\n                    if newErrorDict[key].size == 1:\r\n                        newErrorDict[key] = newErrorDict[key].item(0)\r\n                self.errorDictList.append(newErrorDict)\r\n            except: # This stops loading dicts on more or less any error at present\r\n                errorDictsExist=False\r\n                break\r\n            errCnt += 1\r\n            \r\n        \r\n        # Registration parameters\r\n        try: self.xcorrMode = config.get( u'registration', u'xcorrMode' )\r\n        except: pass\r\n        try: self.triMode = config.get( u'registration', u'triMode' )\r\n        except: pass\r\n    \r\n        try: self.startFrame = config.getint( u'registration', u'startFrame' )\r\n        except: pass\r\n        try: self.endFrame = config.getint( u'registration', u'endFrame' )\r\n        except: pass\r\n    \r\n        try: self.shapePadded = np.array( json.loads( config.get( u'registration', u'shapePadded' ) ) )\r\n        except: pass\r\n    \r\n        try: self.shapeOriginal = np.array( json.loads( config.get( u'registration', u'shapeOriginal' ) ) )\r\n        except: pass\r\n        try: self.shapeBinned = np.array( json.loads( config.get( u'registration', u'shapeBinned' ) ) )\r\n        except: pass\r\n        try: self.fouCrop = np.array( json.loads( config.get( u'registration', u'fouCrop' ) ) )\r\n        except: pass\r\n        try: self.subPixReg = config.getint( u'registration', u'subPixReg' )\r\n        except: pass\r\n        try: self.shiftMethod = config.get( u'registration', u'shiftMethod' )\r\n        except: pass\r\n        try: self.maxShift = config.getint( u'registration', u'maxShift' )\r\n        except: pass\r\n        try: self.preShift = config.getboolean( u'registration', u'preShift' )\r\n        except: pass\r\n        try: self.triMode = config.get( u'registration', u'triMode' )\r\n        except: pass\r\n        try: self.diagWidth = config.getint( u'registration', u'diagWidth' )\r\n        except: pass\r\n        try: self.diagStart = config.getint( u'registration', u'diagStart' )\r\n        except: pass\r\n        try: self.autoMax = config.getint( u'registration', u'autoMax' )\r\n        except: pass\r\n        try: self.peaksigThres = config.getfloat( u'registration', u'peaksigThres' )\r\n        except: pass\r\n\r\n        try: self.corrThres = config.getfloat( u'registration', u'corrThres' )\r\n        except: pass\r\n        try: self.velocityThres = config.getfloat( u'registration', u'velocityThres' )\r\n        except: pass\r\n        try: self.Brad = config.getfloat( u'registration', u'Brad' )\r\n        except: pass\r\n        try: self.Bmode = config.get( u'registration', u'Bmode' )\r\n        except: pass\r\n        try: self.BfiltType = config.get( u'registration', u'BfiltType' )\r\n        except: pass\r\n        try: self.originMode = config.get( u'registration', u'originMode' )\r\n        except: pass\r\n        try: self.suppressOrigin = config.getboolean( u'registration', u'suppressOrigin' )\r\n        except: pass\r\n        try: self.weightMode = config.get( u'registration', u'weightMode' )\r\n        except: pass\r\n        try: self.logisticK = config.getfloat( u'registration', u'logisticK' )\r\n        except: pass\r\n        try: self.logisticNu = config.getfloat( u'registration', u'logisticNu' )\r\n        except: pass\r\n        try: self.filterMode = config.get( u'registration', u'filterMode' )\r\n        except: pass\r\n        try: self.doFRC = config.getboolean( u'registration', u'doLazyFRC' )\r\n        except: pass\r\n        try: self.doEvenOddFRC = config.getboolean( u'registration', u'doEvenOddFRC' )\r\n        except: pass\r\n        try: self.doseFiltParam = json.loads( config.get( u'registration', u'doseFiltParam' ) ) # This one stays a list\r\n        except: pass\r\n\r\n    \r\n        # IO \r\n        try: self.files = json.loads( config.get( u'io', u'files' ) )\r\n        except: pass\r\n        try: self.savePNG = config.getboolean( u'io', u'savePNG' )\r\n        except: pass\r\n        try: self.compress_ext = config.get( u'io', u'compress_ext' )\r\n        except: pass\r\n        try: self.saveMovie = config.getboolean( u'io', u'saveMovie' )\r\n        except: pass\r\n        try: self.doCompression = config.getboolean( u'io', u'doCompression' )\r\n        except: pass\r\n    \r\n        # Plot \r\n        try: self.plotDict = json.loads( config.get( u'plot', u'plotDict' ) )\r\n        except: pass\r\n\r\n        \r\n        if bool(loadData) and u'stack' in self.files and self.files[u'stack'] != None:\r\n            self.loadData()\r\n        pass\r\n    \r\n    def saveConfig( self, configNameIn=None ):\r\n        \"\"\"\r\n        Write the state of the ImageRegistrator class from a config file\r\n        \"\"\"\r\n\r\n        import json\r\n        import os\r\n        try: os.umask( self.umask ) # Why is Python not using default umask from OS?\r\n        except: pass        \r\n        \r\n        if not bool( configNameIn ):\r\n            if self.files[u'config'] is None:\r\n                self.files[u'config'] = self.files[u'stack'] + u\".zor\"\r\n        else:\r\n            self.files['config'] = configNameIn\r\n        # Does the directory exist?\r\n        configPath = os.path.realpath( os.path.dirname( self.files[u'config'] ) )\r\n        if bool(configPath) and not os.path.isdir( configPath ):\r\n            os.mkdir( configPath )\r\n        \r\n        # Write config\r\n        config = configparser.RawConfigParser(allow_no_value = True)\r\n        try:\r\n            config.optionxform = unicode # Python 2\r\n        except:\r\n            config.optionxform = str # Python 3\r\n        \r\n        # Initialization\r\n        config.add_section( u'initialization' )\r\n        config.set( u'initialization', u'METAstatus', self.METAstatus )\r\n        config.set( u'initialization', u'# METAstatus _MUST_ appear as second line in file' )\r\n        config.set( u'initialization', u'# For detailed use instructions: github.com\/C-CINA\/zorro\/wiki', None )\r\n        config.set( u'initialization', u'verbose', self.verbose )\r\n        config.set( u'initialization', u'umask', self.umask )\r\n        config.set( u'initialization', u'fftw_effort', self.fftw_effort )\r\n        # Any time we cast variables we need handle errors from numpy\r\n        config.set( u'initialization', u'# n_threads is usually best if set to the number of physical cores (CPUs)' )\r\n        try: config.set( u'initialization', u'n_threads', np.int(self.n_threads) )\r\n        except: pass\r\n        config.set( u'initialization', u'saveC', self.saveC )\r\n        config.set( u'initialization', u'cachePath', self.cachePath )\r\n        \r\n        \r\n        # Calibrations\r\n        config.add_section( u'calibration' )\r\n        config.set( u'calibration', u\"# Zorro can strip this information from .DM4 files if its is present in tags\" )\r\n        config.set( u'calibration' , u\"# Pixel size in nanometers\" )\r\n        config.set( u'calibration',u'pixelsize', self.pixelsize )\r\n        config.set( u'calibration' , u\"# Accelerating voltage in kV\" )\r\n        config.set( u'calibration',u'voltage', self.voltage )\r\n        config.set( u'calibration' , u\"# Spherical aberration in mm\" )\r\n        config.set( u'calibration',u'C3', self.C3 )\r\n        config.set( u'calibration' , u\"# Gain in electrons\/count\" )\r\n        config.set( u'calibration',u'gain', self.gain )\r\n        config.set( u'calibration',u'detectorPixelSize', self.detectorPixelSize )\r\n        config.set( u'calibration', u'gainInfo', json.dumps( self.gainInfo ) )\r\n        \r\n        # Registration parameters\r\n        config.add_section( u'registration' )\r\n        config.set( u'registration', u'xcorrMode', self.xcorrMode )\r\n        config.set( u'registration' , u\"# tri, diag, first, auto, or autocorr\" )\r\n        config.set( u'registration', u'triMode', self.triMode )\r\n        \r\n        \r\n        if self.shapePadded is not None:\r\n            if type(self.shapePadded) == type(np.array(1)):\r\n                self.shapePadded = self.shapePadded.tolist()\r\n            config.set( u'registration', u\"# Use a padding 10 % bigger than the original image, select an efficient size with zorro_util.findValidFFTWDim()\" )   \r\n            config.set( u'registration', u'shapePadded', json.dumps( self.shapePadded) )\r\n            \r\n        if self.shapeOriginal is not None:\r\n            if type(self.shapeOriginal) == type(np.array(1)):\r\n                self.shapeOriginal = self.shapeOriginal.tolist()\r\n            config.set( u'registration', u'shapeOriginal', json.dumps( self.shapeOriginal ) )\r\n        if self.shapeBinned is not None:\r\n            if type(self.shapeBinned) == type(np.array(1)):\r\n                self.shapeBinned = self.shapeBinned.tolist()\r\n            config.set( u'registration', u'shapeBinned', json.dumps( self.shapeBinned ) )\r\n            \r\n        if self.fouCrop is not None:\r\n            if type(self.fouCrop) == type(np.array(1)):\r\n                self.fouCrop = self.fouCrop.tolist()\r\n            config.set( u'registration', u'fouCrop', json.dumps( self.fouCrop ) )\r\n        \r\n        try: config.set( u'registration', u'subPixReg', np.int(self.subPixReg) )\r\n        except: pass\r\n        config.set( u'registration', u'shiftMethod', self.shiftMethod )\r\n        config.set( u'registration' , u\"# Maximum shift in pixels within diagWidth\/autoMax frames\" )\r\n        try: config.set( u'registration', u'maxShift', np.int(self.maxShift) )\r\n        except: pass\r\n        config.set( u'registration' ,u\"# preShift = True is useful for crystalline specimens where you want maxShift to follow the previous frame position\" )\r\n        config.set( u'registration', u'preShift', self.preShift )\r\n        \r\n        try: config.set( u'registration', u'diagStart', np.int(self.diagStart) )\r\n        except: pass\r\n        try: config.set( u'registration', u'diagWidth', np.int(self.diagWidth) )\r\n        except: pass\r\n        try: config.set( u'registration', u'autoMax', np.int(self.autoMax) )\r\n        except: pass\r\n        try: config.set( u'registration', u'startFrame', np.int(self.startFrame) )\r\n        except: pass\r\n        try: config.set( u'registration', u'endFrame', np.int(self.endFrame) )\r\n        except: pass\r\n        \r\n        config.set( u'registration' , u\"# peakSigThres changes with dose but usually is uniform for a dataset\" )\r\n        config.set( u'registration', u'peaksigThres', self.peaksigThres )\r\n        config.set( u'registration' , u\"# corrThres is DEPRECATED\" )\r\n        config.set( u'registration', u'corrThres', self.corrThres )\r\n        config.set( u'registration', u'velocityThres', self.velocityThres )\r\n        config.set( u'registration' , u\"# Brad is radius of B-filter in Fourier pixels\" )\r\n        config.set( u'registration', u'Brad', self.Brad )\r\n        config.set( u'registration' , u\"# Bmode = conv, opti, or fourier\" )\r\n        config.set( u'registration', u'Bmode', self.Bmode )\r\n        config.set( u'registration', u'BFiltType', self.BfiltType )\r\n        config.set( u'registration' , u\"# originMode is centroid, or (empty), empty sets frame 1 to (0,0)\" )\r\n        config.set( u'registration', u'originMode', self.originMode )\r\n        config.set( u'registration' , u\"# weightMode is one of logistic, corr, norm, unweighted\" )\r\n        config.set( u'registration', u'weightMode', self.weightMode )\r\n        config.set( u'registration', u'logisticK', self.logisticK )\r\n        config.set( u'registration', u'logisticNu', self.logisticNu )\r\n        config.set( u'registration' , u\"# Set suppressOrigin = True if gain reference artifacts are excessive\" )\r\n        config.set( u'registration', u'suppressOrigin', self.suppressOrigin )\r\n        config.set( u'registration', u'filterMode', self.filterMode )\r\n        config.set( u'registration', u'doLazyFRC', self.doLazyFRC )\r\n        config.set( u'registration', u'doEvenOddFRC', self.doEvenOddFRC )\r\n        if np.any( self.doseFiltParam ) and bool( self.filterMode ):\r\n            config.set( u'registration', u'doseFiltParam', json.dumps( self.doseFiltParam ) )\r\n\r\n        \r\n        # CTF\r\n        config.add_section( u'ctf' )\r\n        config.set( u'ctf', u'CTFProgram', self.CTFProgram )\r\n        config.set( u'ctf', u'CTFInfo', json.dumps( self.CTFInfo ) )\r\n        \r\n        # IO\r\n        config.add_section(u'io')\r\n        config.set( u'io', u'savePNG', self.savePNG )\r\n        config.set( u'io', u'compress_ext', self.compress_ext )\r\n        config.set( u'io', u'saveMovie', self.saveMovie )\r\n        config.set( u'io', u'doCompression', self.doCompression )\r\n\r\n        config.set( u'io' , u\"# Note: all paths are relative to the current working directory.\" )\r\n        config.set( u'io', u'files', json.dumps( self.files ) )\r\n\r\n\r\n        # Plot\r\n        config.add_section( u'plot' )\r\n        config.set( u'plot', u'plotDict', json.dumps( self.plotDict ) )\r\n\r\n        \r\n        # Results \r\n        # Seems Json does a nice job of handling numpy arrays if converted to lists\r\n        config.add_section( u'results' )\r\n        if self.translations is not None:\r\n            config.set( u'results', u'translations', json.dumps( self.translations.tolist() ) )\r\n        if self.transEven is not None:\r\n            config.set( u'results', u'transEven', json.dumps( self.transEven.tolist() ) )\r\n        if self.transOdd is not None:\r\n            config.set( u'results', u'transOdd', json.dumps( self.transOdd.tolist() ) )\r\n        if self.rotations is not None:    \r\n            config.set( u'results', u'rotations', json.dumps( self.rotations.tolist() ) )\r\n        if self.scales is not None:\r\n            config.set( u'results', u'scales', json.dumps( self.scales.tolist() ) )\r\n        if self.velocities is not None:\r\n            config.set( u'results', u'velocities', json.dumps( self.velocities.tolist() ) )\r\n        if self.FRC is not None:\r\n            config.set( u'results', u'FRC', json.dumps( self.FRC.tolist() ) )\r\n\r\n    \r\n        # Data\r\n        config.add_section( u'data' )\r\n        config.set( u'data', u'hotpixInfo', json.dumps( self.hotpixInfo) )\r\n        config.set( u'data', u'trackCorrStats', self.trackCorrStats )\r\n        config.set( u'data', u'corrStats', json.dumps( self.corrStats) )\r\n        config.set( u'data', u'bench', json.dumps( self.bench ) )\r\n                    \r\n        # Error dicts\r\n        for errCnt, errorDict in enumerate(self.errorDictList):\r\n            # For serialization, the errorDict arrays have to be lists.)\r\n            dictName = u'errorDict%d'%errCnt\r\n            config.add_section( dictName )\r\n            keyList = list( errorDict.keys() )\r\n            config.set( dictName, u'keyList', json.dumps( keyList ) )\r\n            for key in keyList:\r\n                if( hasattr( errorDict[key], \"__array__\" ) ):\r\n                    config.set( dictName, key, json.dumps( errorDict[key].tolist() ) )\r\n                else:\r\n                    config.set( dictName, key, json.dumps( errorDict[key] ) )\r\n        \r\n        try:\r\n            # Would be nice to have some error handling if cfgFH already exists\r\n            # Could try and open it with a try: open( 'r' )\r\n            cfgFH = open( self.files[u'config'] , 'w+' )\r\n            if self.verbose >= 1:\r\n                print( \"Saving config file: \" + self.files[u'config'] )\r\n            config.write( cfgFH )\r\n            cfgFH.close()\r\n        except:\r\n            print( \"Error in loading config file: \" + self.files[u'config'] )\r\n\r\n\r\n    def plot( self, title = \"\" ):\r\n        \"\"\"\r\n        Multiprocessed matplotlib diagnostic plots. \r\n        \r\n        For each plot, make a list that contains the name of the plot, and a dictionary that contains all the \r\n        information necessary to render the plot.\r\n        \"\"\"\r\n        self.bench['plot0'] = time.time()\r\n        if not bool(title):\r\n            # Remove any pathing from default name as figurePath overrides this.\r\n            if bool( self.files[u'stack'] ):\r\n                self.plotDict[u'title'] = os.path.split( self.files[u'stack'] )[1]\r\n            else:\r\n                self.plotDict[u'title'] = u\"default\"\r\n        else:\r\n            self.plotDict[u'title'] = title\r\n            \r\n        # figurePath needs to be relative to the config directory, which may not be the current directory.\r\n#        if bool(self.savePNG ) and bool(self.files['config']):\r\n#            try: # Sometimes this is empty\r\n#                os.chdir( os.path.split(self.files['config'])[0] )\r\n#            except: pass\r\n        \r\n        # Error checks on figurePath\r\n        if not bool( self.files[u'figurePath'] ):\r\n            self.files[u'figurePath'] = u\".\/fig\"\r\n        if not os.path.isdir( self.files[u'figurePath'] ):\r\n            os.mkdir( self.files[u'figurePath'] )\r\n            \r\n        plotArgs = []\r\n        # IF IMAGESUM\r\n        if np.any(self.imageSum) and u'imageSum' in self.plotDict and ( self.plotDict[u'imageSum'] ):\r\n            #print( \"zorro.plot.imageSum\" )\r\n            plotDict = self.plotDict.copy()\r\n            \r\n            # Unfortunately binning only saves time if we do it before pickling the data off to multiprocess.\r\n            # TODO: http:\/\/stackoverflow.com\/questions\/7894791\/use-numpy-array-in-shared-memory-for-multiprocessing\r\n            binning = 2\r\n            plotDict[u'pixelsize'] = self.pixelsize * binning\r\n            imageSumBinned = util.magickernel( self.getSumCropToLimits(), k=1 )\r\n            plotDict[u'image'] = imageSumBinned\r\n            # RAM: temporary expidient of filtering FFTs of large images to increase contrast\r\n            if self.imageSum.shape[0]*binning > 3072 and self.imageSum.shape[1]*binning > 3072:\r\n                plotDict[u'lowPass'] = 0.75\r\n\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_imageSum.png\")\r\n                self.files[u'figImageSum'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'image', plotDict] )\r\n            \r\n        # IF FILTSUM\r\n        if np.any(self.filtSum) and u'filtSum' in self.plotDict and bool( self.plotDict[u'filtSum'] ):\r\n            #print( \"zorro.plot.filtSum\" )\r\n            plotDict = self.plotDict.copy()\r\n            \r\n            # Unfortunately binning only saves time if we do it before pickling the data off to multiprocess.\r\n            # TODO: http:\/\/stackoverflow.com\/questions\/7894791\/use-numpy-array-in-shared-memory-for-multiprocessing\r\n            binning = 2\r\n            plotDict[u'pixelsize'] = self.pixelsize * binning\r\n            filtSumBinned = util.magickernel( self.getFiltSumCropToLimits(), k=1 )\r\n            plotDict[u'image'] = filtSumBinned        \r\n            # RAM: temporary expidient of filtering FFTs of large images to increase contrast\r\n            if self.imageSum.shape[0]*binning > 3072 and self.imageSum.shape[1]*binning > 3072:\r\n                plotDict[u'lowPass'] = 0.75\r\n\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_filtSum.png\")\r\n                self.files[u'figFiltSum'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'image', plotDict] )\r\n        \r\n        # IF FFTSUM\r\n        if np.any(self.imageSum) and u'FFTSum' in self.plotDict and bool( self.plotDict[u'FFTSum'] ):\r\n            #print( \"zorro.plot.FFTSum\" )\r\n            plotDict = self.plotDict.copy()\r\n\r\n            \r\n            # No FFT binning please\r\n            plotDict[u'pixelsize'] = self.pixelsize\r\n            # We would like the cropped sum but that can be a wierd size that is slow for the FFT\r\n            plotDict[u'image'] = self.imageSum \r\n            \r\n            # RAM: temporary expidient of filtering FFTs of large images to increase contrast\r\n            if self.imageSum.shape[0] > 3072 and self.imageSum.shape[1] > 3072:\r\n                plotDict[u'lowPass'] = 3.0\r\n            \r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_FFTSum.png\")\r\n                self.files[u'figFFTSum'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'FFT', plotDict] )\r\n            pass\r\n        \r\n        # IF POLARFFTSUM\r\n        if np.any(self.imageSum) and u'polarFFTSum' in self.plotDict and bool( self.plotDict[u'polarFFTSum'] ):\r\n            #print( \"zorro.plot.PolarFFTSum\" )\r\n            plotDict = self.plotDict.copy()\r\n\r\n            # No FFT binning please\r\n            plotDict[u'pixelsize'] = self.pixelsize\r\n            # We would like the cropped sum but that can be a wierd size that is slow for the FFT\r\n            plotDict[u'image'] = self.imageSum     \r\n            \r\n            # RAM: temporary expidient of filtering FFTs of large images to increase contrast\r\n            if self.imageSum.shape[0] > 3072 and self.imageSum.shape[1] > 3072:\r\n                plotDict[u'lowPass'] = 1.5\r\n                \r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_polarFFTSum.png\")\r\n                self.files[u'figPolarFFTSum'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'polarFFT', plotDict] )\r\n            pass\r\n        \r\n        # IF TRANSLATIONS\r\n        if np.any(self.translations) and u'translations' in self.plotDict and bool( self.plotDict[u'translations'] ):\r\n            #print( \"zorro.plot.Translations\" )\r\n            plotDict = self.plotDict.copy()\r\n            if np.any( self.translations ):\r\n                plotDict[u'translations'] = self.translations\r\n                try:\r\n                    plotDict[u'errorX'] = self.errorDictList[0][u'errorX']\r\n                    plotDict[u'errorY'] = self.errorDictList[0][u'errorY']\r\n                except: pass\r\n                if bool(self.savePNG):\r\n                    plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_translations.png\")\r\n                    self.files[u'figTranslations'] = plotDict[u'plotFile']\r\n                plotArgs.append( [u'translations', plotDict] )  \r\n                \r\n        # IF PIXEL REGISTRATION ERROR\r\n        if len(self.errorDictList) > 0 and u'pixRegError' in self.plotDict and bool( self.plotDict[u'pixRegError'] ):\r\n            #print( \"zorro.plot.PixRegError\" )\r\n            plotDict = self.plotDict.copy()\r\n            plotDict[u'errorX'] = self.errorDictList[0][u'errorX']\r\n            plotDict[u'errorY'] = self.errorDictList[0][u'errorY']\r\n            plotDict[u'errorXY'] = self.errorDictList[0][u'errorXY']\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_pixRegError.png\")\r\n                self.files[u'figPixRegError'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'pixRegError', plotDict] )  \r\n            \r\n        # IF CORRTRIMAT\r\n        if len(self.errorDictList) > 0 and u'corrTriMat' in self.plotDict and bool( self.plotDict[u'corrTriMat'] ):\r\n            #print( \"zorro.plot.coor\" )\r\n            plotDict = self.plotDict.copy()\r\n            plotDict[u'corrTriMat'] = self.errorDictList[-1][u'corrTriMat']\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_corrTriMat.png\")\r\n                self.files[u'figCorrTriMat'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'corrTriMat', plotDict] )  \r\n            \r\n        # IF PEAKSIGTRIMAT\r\n        if len(self.errorDictList) > 0 and u'peaksigTriMat' in self.plotDict and bool( self.plotDict[u'peaksigTriMat'] ):\r\n            #print( \"zorro.plot.peaksig\" )\r\n            plotDict = self.plotDict.copy()\r\n            plotDict[u'peaksigTriMat'] = self.errorDictList[-1][u'peaksigTriMat']\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_peaksigTriMat.png\")\r\n                self.files[u'figPeaksigTriMat'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'peaksigTriMat', plotDict] )  \r\n            \r\n        # IF LOGISTICS CURVE        \r\n        if len(self.errorDictList) > 0 and u'logisticWeights' in self.plotDict and bool( self.plotDict[u'logisticWeights'] ):\r\n            #print( \"zorro.plot.logist\" )\r\n            plotDict = self.plotDict.copy()\r\n            if self.weightMode == u'autologistic' or self.weightMode == u'logistic':\r\n                plotDict[u'peaksigThres'] = self.peaksigThres\r\n                plotDict[u'logisticK'] = self.logisticK\r\n                plotDict[u'logisticNu'] = self.logisticNu\r\n            plotDict[u'errorXY'] = self.errorDictList[0][u\"errorXY\"]\r\n            plotDict[u'peaksigVect'] = self.errorDictList[0][u\"peaksigTriMat\"][ self.errorDictList[0][\"peaksigTriMat\"] > 0.0  ]\r\n            \r\n            if u'cdfPeaks' in self.errorDictList[0]:\r\n               plotDict[u'cdfPeaks'] = self.errorDictList[0][u'cdfPeaks']\r\n               plotDict[u'hSigma'] = self.errorDictList[0][u'hSigma']\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_logisticWeights.png\")\r\n                self.files[u'figLogisticWeights'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'logisticWeights', plotDict] )\r\n             \r\n        # IF FRC PLOT\r\n        if np.any(self.FRC) and u'FRC' in self.plotDict and bool( self.plotDict[u'FRC'] ):\r\n            #print( \"zorro.plot.FRC\" )\r\n            plotDict = self.plotDict.copy()\r\n            plotDict[u'FRC'] = self.FRC\r\n            plotDict[u'pixelsize'] = self.pixelsize\r\n\r\n                \r\n            if bool( self.doEvenOddFRC ):\r\n                plotDict[u'labelText'] = u\"Even-odd frame independent FRC\"\r\n            else:\r\n                plotDict[u'labelText'] = u\"Non-independent FRC is not a resolution estimate\"\r\n                \r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_FRC.png\")\r\n                self.files[u'figLazyFRC'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'lazyFRC', plotDict] )\r\n            \r\n        # IF CTFDIAG PLT\r\n        if np.any(self.CTFDiag) and u'CTFDiag' in self.plotDict and bool( self.plotDict[u'CTFDiag'] ):\r\n            plotDict = self.plotDict.copy()\r\n            \r\n            plotDict[u'CTFDiag'] = self.CTFDiag\r\n            plotDict[u'CTFInfo'] = self.CTFInfo\r\n            plotDict[u'pixelsize'] = self.pixelsize\r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_CTFDiag.png\")\r\n                self.files[u'figCTFDiag'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'CTFDiag', plotDict] )\r\n            \r\n        # IF STATS PLOT\r\n        if u'stats' in self.plotDict and bool( self.plotDict[u'stats'] ):\r\n            #print( \"zorro.plot.stats\" )\r\n            plotDict = self.plotDict.copy()\r\n            plotDict[u'pixelsize'] = self.pixelsize\r\n            plotDict[u'voltage'] = self.voltage\r\n            plotDict[u'C3'] = self.C3\r\n            if len( self.errorDictList ) > 0 and u'peaksigTriMat' in self.errorDictList[-1]:\r\n                peaksig = self.errorDictList[-1][u'peaksigTriMat']\r\n                peaksig = peaksig[ peaksig > 0.0 ]\r\n                plotDict[u'meanPeaksig'] = np.mean( peaksig )\r\n                plotDict[u'stdPeaksig'] = np.std( peaksig )\r\n                plotDict[u'CTFInfo'] = self.CTFInfo\r\n        \r\n            if bool(self.savePNG):\r\n                plotDict[u'plotFile'] = os.path.join( self.files[u'figurePath'], self.plotDict[u'title'] + \"_Stats.png\")\r\n                self.files[u'figStats'] = plotDict[u'plotFile']\r\n            plotArgs.append( [u'stats', plotDict] )\r\n                \r\n        ######\r\n        #Multiprocessing pool (to speed up matplotlib's slow rendering and hopefully remove polling loop problems)\r\n        #####      \r\n        if os.name != u'nt' and bool( self.plotDict[u'multiprocess'] ):\r\n            figPool = mp.Pool( processes=self.n_threads )\r\n            print( \" n_threads = %d, plotArgs length = %d\" %( self.n_threads, len(plotArgs) ) )\r\n            figPool.map( plot.generate, plotArgs )\r\n            \r\n            figPool.close()\r\n            figPool.terminate()\r\n            # Wait for everyone to finish, otherwise on the infinityband cluster we have problems with partially rendered files.\r\n            figPool.join() \r\n        else: # Windows mode, can also be used for debugging when plot goes haywire\r\n            # Don't multiprocess the plots, but execute serially.\r\n            for plotArg in plotArgs:\r\n                plot.generate( plotArg )\r\n        self.bench['plot1'] = time.time()\r\n        \r\n    def makeMovie( self, movieName = None, clim = None, frameRate=3, graph_cm = u'gnuplot' ):\r\n        \"\"\"\r\n        Use FFMPEG to generate movies showing the correlations.  C0 must not be Nonz.\r\n        \r\n        The ffmpeg executable must be in the system path.\r\n        \"\"\"\r\n        import os\r\n\r\n        fex = '.png'\r\n        print( \"makeMovie must be able to find FFMPEG on the system path\" )\r\n        print( \"Strongly recommended to use .mp4 extension\" )\r\n        if movieName is None:\r\n            movieName = self.files[u'stack'] + u\".mp4\"\r\n        \r\n        m = self.C0.shape[0]\r\n        \r\n        # Turn off display of matplotlib temporarily\r\n        originalBackend = plt.get_backend()\r\n        plt.switch_backend(u'agg')\r\n        plt.rc(u'font', family=self.plotDict[u'fontstyle'], size=self.plotDict[u'fontsize'])\r\n        corrmat = self.errorDictList[-1][ u'corrTriMat' ]\r\n        climCM = [np.min(corrmat[corrmat>0.0]) * 0.75, np.max(corrmat[corrmat>0.0])]\r\n        # Get non-zero indices from corrmat\r\n        \r\n        # Note that FFMPEG starts counting at 0.  \r\n        for J in np.arange(0,m):\r\n            corrMap = self.C0[J,:,:].copy(order='C')\r\n            \r\n            figCM = plt.figure()\r\n            plt.subplot( '121' )\r\n            # corrTriMat\r\n            plt.imshow( corrmat, interpolation=\"nearest\", vmin=climCM[0], vmax=climCM[1] )\r\n            plt.xlabel( \"Base image\" )\r\n            plt.ylabel( \"Template image\" )\r\n            plt.colorbar( orientation='horizontal' )\r\n            plt.title( \"Maximum correlation upper-tri matrix\" )\r\n            plt.set_cmap( graph_cm )\r\n            # Draw lines (How to unravel J???)\r\n            plt.plot(  )\r\n            plt.plot(  )\r\n            # Reset xlim and ylim\r\n            plt.xlim( [0, corrMap.shape[2]-1] )\r\n            plt.ylim( [0, corrMap.shape[1]-1] )\r\n            \r\n            \r\n            # C0\r\n            plt.subplot( '122' )\r\n            if clim is None:\r\n                plt.imshow( corrMap, interpolation='none' )\r\n            else:\r\n                plt.imshow( corrMap, interpolation='none', vmin=clim[0], vmax=clim[1] )\r\n            plt.set_cmap( graph_cm )\r\n            plt.colorbar( orientation='horizontal' )\r\n            \r\n            # Render and save\r\n            plt.tight_layout()\r\n            plt.pause(0.05)\r\n            plt.savefig( \"corrMap_%05d\"%J + fex, dpi=self.plotDict['image_dpi'] )\r\n            plt.close( figCM )\r\n            # corrMap = ( 255.0 * util.normalize(corrMap) ).astype('uint8')\r\n            # Convert to colormap as follows: Image.fromarray( np.uint8( cm.ocean_r(stddesk)*255))\r\n            # skimage.io.imsave( \"corrMap_%05d\"%J + fex, mage, plugin='freeimage' )\r\n            # skimage.io.imsave( \"corrMap_%05d\"%J + fex, corrMap )\r\n            pass\r\n        time.sleep(0.5)\r\n        \r\n        # Remove the old movie if it's there\r\n        try: \r\n            os.remove( movieName )\r\n        except:\r\n            pass\r\n        \r\n        # Make a movie with lossless H.264\r\n        # One problem is that H.264 isn't compatible with PowerPoint.  Can use Handbrake to make it so...\r\n        # Framerate command isn't working...\r\n        comstring = \"ffmpeg -r \"+str(frameRate)+ \" -f image2 -i \\\"corrMap_%05d\"+fex+\"\\\" -c:v libx264 -preset veryslow -qp 0 -r \"+str(frameRate)+ \" \"+movieName\r\n        print( comstring )\r\n        sub = subprocess.Popen( comstring, shell=True )\r\n        sub.wait()\r\n        # os.system( comstring )\r\n        # Clean up\r\n        for J in np.arange(0,m):\r\n            os.remove( \"corrMap_%05d\"%J + fex )\r\n        pass\r\n        plt.switch_backend(originalBackend)\r\n\r\n    def printProfileTimes( self ):\r\n        \"\"\" Go through and print out all the profile times in self.t \"\"\"\r\n        print( \"----PROFILING TIMES----\" )\r\n        print( \"    dtypes: float: %s, complex: %s\" %(float_dtype, fftw_dtype) )\r\n        if bool( np.any(self.filtSum) ):\r\n            print( \"    images.dtype: %s, filtSum.dtype: %s\" % (self.images.dtype, self.filtSum.dtype) )\r\n        else:\r\n            print( \"    images.dtype: %s\" % (self.images.dtype) )\r\n            \r\n        if str(self.images.dtype) == 'float64':\r\n            print( \"    WARNING: running in double-precision (may be slow)\" )\r\n            \r\n        try: print( \"    Loading files (s): %.3f\"%(self.bench['loaddata1'] - self.bench['loaddata0']) )\r\n        except: pass\r\n        try: print( \"    Image\/mask binning (s): %.3f\"%(self.bench['bin1'] - self.bench['bin0']) ) \r\n        except: pass\r\n        try: print( \"    X-correlation initialization (s): %.3f\"%(self.bench['xcorr1'] - self.bench['xcorr0']) )\r\n        except: pass\r\n        try: print( \"    X-correlation forward FFTs (s): %.3f\"%(self.bench['xcorr2'] - self.bench['xcorr1']) )\r\n        except: pass\r\n        try: print( \"    X-correlation main computation (s): %.3f\"%(self.bench['xcorr3'] - self.bench['xcorr2']) )\r\n        except: pass\r\n        try: print( \"    Complete (entry-to-exit) xcorrnm2_tri (s): %.3f\"%(self.bench['xcorr3'] - self.bench['xcorr0']) ) \r\n        except: pass\r\n        try: print( \"    Complete Unblur (s): %.3f\" % (self.bench['unblur1'] - self.bench['unblur0']) )\r\n        except: pass\r\n        try: print( \"    Shifts solver (last iteration, s): %.3f\"%(self.bench['solve1'] - self.bench['solve0']) )\r\n        except: pass\r\n        try: print( \"    Subpixel alignment (s): %.3f\"%(self.bench['shifts1'] - self.bench['shifts0']) )\r\n        except: pass\r\n        try: print( \"    Fourier Ring Correlation (s): %.3f\"%(self.bench['frc1'] - self.bench['frc0']))\r\n        except: pass\r\n        try: print( \"    Post-process filtering (s): %.3f\"%(self.bench['dose1'] - self.bench['dose0']))\r\n        except: pass\r\n        try: print( \"    Hotpixel mask (s): %.3f\" % (self.bench['hot1'] - self.bench['hot0']))\r\n        except: pass\r\n        try: print( \"    CTF estimation with %s (s): %.3f\" %( self.CTFProgram, self.bench['ctf1']-self.bench['ctf0'] ) )\r\n        except: pass\r\n        try: print( \"    Plot rendering (s): %.3f\"%(self.bench['plot1'] - self.bench['plot0']))\r\n        except: pass\r\n        try:  print( \"    Save files (s): %.3f\"%(self.bench['savedata1'] - self.bench['savedata0']))\r\n        except: pass\r\n        print( \"###############################\" )\r\n        try: print( \"    Total execution time (s): %.3f\"%(time.time() - self.bench['total0']) )\r\n        except: pass\r\n        pass\r\n\r\n\r\n\r\n    \r\n##### COMMAND-LINE INTERFACE ####\r\n#if __name__ == '__main__':\r\n#    main()\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_615","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Jul  2 14:35:46 2018\n\n@author: SilverDoe\n\"\"\"\n\n\n\n#=================== Still to verify\/correct===================================\n\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nfrom scipy.cluster.vq import kmeans, kmeans2, whiten\n\ndf = pd.read_csv('E:\\\\Documents\\\\PythonProjects\\\\1_Basics\\\\DataForFiles\\\\scidata.csv')\nprint(df.shape)\ndf.head()\n\ncoordinates = df.as_matrix(columns=['V1', 'V2'])\nplt.figure(figsize=(10, 6), dpi=100)\nplt.scatter(coordinates[:,0], coordinates[:,1], c='c', s=100)\nplt.show()\n\n\n\nN = len(coordinates)\nw = whiten(coordinates)\nk = 100\ni = 20\n\ncluster_centroids1, distortion = kmeans(w, k, iter=i)\ncluster_centroids2, closest_centroids = kmeans2(w, k, iter=i)\n\nplt.figure(figsize=(10, 6), dpi=100)\nplt.scatter(cluster_centroids2[:,0], cluster_centroids2[:,1], c='r', s=100)\nplt.show()\n\n#==============================================================================\nfrom numpy import vstack,array\nfrom numpy.random import rand\nimport pandas as pd\nfrom scipy.cluster import vq\nfrom matplotlib import pyplot as plt\n\n\n\n\n# data generation with three features\ndata = vstack((rand(100,3) + array([.5,.5,.5]),rand(100,3)))\nprint(data)\nprint('===================================================')\n#The features in obs(observation) should have unit variance, which can be achieved by passing them through the whiten function\ndata = vq.whiten(data)\nprint(data)\n\n# computing K-Means with K = 3 (2 clusters)\ncentroids,_ = vq.kmeans(data,3)\nprint(centroids)\n\n# assign each sample to a cluster\nclx,_ = vq.vq(data,centroids)\n\n# check clusters of observation\nprint(clx)\n\nplt.figure(figsize=(10, 6), dpi=100)\nplt.scatter(centroids[:,0], centroids[:,1], c='r', s=100)\nplt.show()\n\n\n#====================== using sklearn =====================================\n# example a\nimport numpy as np\nfrom sklearn.cluster import KMeans\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.read_csv('E:\\\\Documents\\\\PythonProjects\\\\1_Basics\\\\DataForFiles\\\\scidata.csv')\nprint(df.shape)\ndf.head()\n# whitening of data\n# df = whiten(df)\nf1 = df['V1'].values\nf2 = df['V2'].values\n\nX=np.matrix(zip(f1,f2))\nplt.scatter(f1, f2, c='black', s=7)\n\nkmeans = KMeans(n_clusters=2).fit(X)\n\nkmeans = KMeans(n_clusters=4).fit(X)\n\n\n# example 1 ===================================================\nfrom sklearn.cluster import KMeans\nfrom mpl_toolkits.mplot3d import Axes3D\nimport numpy as np\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nplt.rcParams['figure.figsize'] = (16, 9)\nplt.style.use('ggplot')\n\n# Importing the dataset\ndata = pd.read_csv('E:\\\\Documents\\\\PythonProjects\\\\1_Basics\\\\DataForFiles\\\\scidata.csv')\nprint(\"Input Data and Shape\")\nprint(data.shape)\ndata.head()\n\n# Getting the values and plotting it\nf1 = data['V1'].values\nf2 = data['V2'].values\nX = np.array(list(zip(f1, f2)))\n#plt.scatter(f1, f2, c='black', s=7)\n#====\n\n# Number of clusters\nkmeans = KMeans(n_clusters=3)\n# Fitting the input data\nkmeans = kmeans.fit(X)\n# Getting the cluster labels\nlabels = kmeans.predict(X)\n# Centroid values\ncentroids = kmeans.cluster_centers_\nprint(centroids) # From sci-kit learn\n\nfig = plt.figure()\nax = Axes3D(fig)\nax.scatter(X[:, 0], X[:, 1], X[:, 2], c='y',s=100)\nax.scatter(centroids[:, 0], centroids[:, 1], centroids[:, 2], marker='*', c='#050505', s=1000)\n#====================================================================\n# example 2\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom sklearn.cluster import KMeans\nfrom sklearn.datasets import make_blobs\n\nplt.rcParams['figure.figsize'] = (16, 9)\n\n# Creating a sample dataset with 4 clusters\nX, y = make_blobs(n_samples=800, n_features=3, centers=4)\ny\nfig = plt.figure()\nax = Axes3D(fig)\nax.scatter(X[:, 0], X[:, 1], X[:, 2])\n\n# Initializing KMeans\nkmeans = KMeans(n_clusters=4)\n# Fitting with inputs\nkmeans = kmeans.fit(X)\n# Predicting the clusters\nlabels = kmeans.predict(X)\n# Getting the cluster centers\nC = kmeans.cluster_centers_\n\nfig = plt.figure()\nax = Axes3D(fig)\nax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y)\nax.scatter(C[:, 0], C[:, 1], C[:, 2], marker='*', c='#050505', s=1000)\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_617","text":"# Released under The MIT License (MIT)\n# http:\/\/opensource.org\/licenses\/MIT\n# Copyright (c) 2015 <NAME>\n\n\"\"\"\nSummary\n-------\nProvides functions to warp electrode layouts.\n\"\"\"\n\nimport numpy as np\nimport scipy as sp\n\n\ndef warp_locations(locations, y_center=None, return_ellipsoid=False, verbose=False):\n    \"\"\" Warp EEG electrode locations to spherical layout.\n\n    EEG Electrodes are warped to a spherical layout in three steps:\n        1. An ellipsoid is least-squares-fitted to the electrode locations.\n        2. Electrodes are displaced to the nearest point on the ellipsoid's surface.\n        3. The ellipsoid is transformed to a sphere, causing the new locations to lie exactly on a spherical surface\n           with unit radius.\n\n    This procedure intends to minimize electrode displacement in the original coordinate space. Simply projecting\n    electrodes on a sphere (e.g. by normalizing the x\/y\/z coordinates) typically gives much larger displacements.\n\n    Parameters\n    ----------\n    locations : array-like, shape = [n_electrodes, 3]\n        Eeach row of `locations` corresponds to the location of an EEG electrode in cartesian x\/y\/z coordinates.\n    y_center : float, optional\n        Fix the y-coordinate of the ellipsoid's center to this value (optional). This is useful to align the ellipsoid\n        with the central electrodes.\n    return_ellipsoid : bool, optional\n        If `true` center and radii of the ellipsoid are returned.\n\n    Returns\n    -------\n    newlocs : array-like, shape = [n_electrodes, 3]\n        Electrode locations on unit sphere.\n    c : array-like, shape = [3], (only returned if `return_ellipsoid` evaluates to `True`)\n        Center of the ellipsoid in the original location's coordinate space.\n    r : array-like, shape = [3], (only returned if `return_ellipsoid` evaluates to `True`)\n        Radii (x, y, z) of the ellipsoid in the original location's coordinate space.\n    \"\"\"\n    locations = np.asarray(locations)\n\n    if y_center is None:\n        c, r = _fit_ellipsoid_full(locations)\n    else:\n        c, r = _fit_ellipsoid_partial(locations, y_center)\n\n    elliptic_locations = _project_on_ellipsoid(c, r, locations)\n\n    if verbose:\n        print('Head ellipsoid center:', c)\n        print('Head ellipsoid radii:', r)\n        distance = np.sqrt(np.sum((locations - elliptic_locations)**2, axis=1))\n        print('Minimum electrode displacement:', np.min(distance))\n        print('Average electrode displacement:', np.mean(distance))\n        print('Maximum electrode displacement:', np.max(distance))\n\n    spherical_locations = (elliptic_locations - c) \/ r\n\n    if return_ellipsoid:\n        return spherical_locations, c, r\n\n    return spherical_locations\n\n\ndef _fit_ellipsoid_full(locations):\n    \"\"\"identify all 6 ellipsoid parametes (center, radii)\"\"\"\n    a = np.hstack([locations*2, locations**2])\n    lsq = sp.linalg.lstsq(a, np.ones(locations.shape[0]))\n    x = lsq[0]\n    c = -x[:3] \/ x[3:]\n    gam = 1 + np.sum(x[:3]**2 \/ x[3:])\n    r = np.sqrt(gam \/ x[3:])\n    return c, r\n\n\ndef _fit_ellipsoid_partial(locations, cy):\n    \"\"\"identify only 5 ellipsoid parameters (y-center determined by e.g. Cz)\"\"\"\n    a = np.vstack([locations[:, 0]**2,\n                   locations[:, 1]**2 - 2 * locations[:, 1] * cy,\n                   locations[:, 2]**2,\n                   locations[:, 0]*2,\n                   locations[:, 2]*2]).T\n    x = sp.linalg.lstsq(a, np.ones(locations.shape[0]))[0]\n    c = [-x[3] \/ x[0], cy, -x[4] \/ x[2]]\n    gam = 1 + x[3]**2 \/ x[0] + x[4]**2 \/ x[2]\n    r = np.sqrt([gam \/ x[0], gam \/ x[1], gam \/ x[2]])\n    return c, r\n\n\ndef _project_on_ellipsoid(c, r, locations):\n    \"\"\"displace locations to the nearest point on ellipsoid surface\"\"\"\n    p0 = locations - c  # original locations\n\n    l2 = 1 \/ np.sum(p0**2 \/ r**2, axis=1, keepdims=True)\n    p = p0 * np.sqrt(l2)  # initial approximation (projection of points towards center of ellipsoid)\n\n    fun = lambda x: np.sum((x.reshape(p0.shape) - p0)**2)              # minimize distance between new and old points\n    con = lambda x: np.sum(x.reshape(p0.shape)**2 \/ r**2, axis=1) - 1  # new points constrained to surface of ellipsoid\n    res = sp.optimize.minimize(fun, p, constraints={'type': 'eq', 'fun': con}, method='SLSQP')\n\n    return res['x'].reshape(p0.shape) + c\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_618","text":"<filename>tests\/conftest.py\nimport os\nimport pytest\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib\nmatplotlib.use(\"agg\")\nimport matplotlib.pyplot as plt\n\nfrom pytest import fail\nfrom scipy.misc import imsave, imread\n\nfrom abfs.data import Data\nfrom abfs.constants import DataConfig, BAND3, RIO_REGION\n\nTOP_LEVEL_DATA_DIR = os.path.join(os.path.dirname(__file__),\n                                  '.\/fixtures\/spacenet')\n\n@pytest.fixture\ndef config():\n    return DataConfig(TOP_LEVEL_DATA_DIR, BAND3, RIO_REGION)\n\n@pytest.fixture\ndef data(config):\n    return Data(config)\n\n@pytest.fixture\ndef sample_df():\n    return pd.DataFrame(data={\n        'group_id': [ 1,  1,  1,  2,  2,  3,  3,  4,  5,  5],\n        'value':    [56, 18, 19, 51, 15, 96, 99, 95, 66, 41]\n    })\n\n@pytest.fixture\ndef sample_image():\n    return plt.imread(os.path.join(\n        TOP_LEVEL_DATA_DIR,\n        'AOI_1_Rio\/processedData\/processedBuildingLabels\/3band',\n        '3band_AOI_1_RIO_img5792.tif'\n    ))\n\n@pytest.fixture\ndef box_mask():\n    def _box_mask(shape):\n        box_mask_height, box_mask_width = shape\n        x1 = int(box_mask_width \/ 4)\n        y1 = int(box_mask_height \/ 4)\n        x2 = x1 + int(box_mask_width \/ 2)\n        y2 = y1 + int(box_mask_height \/ 2)\n\n        box_mask = np.zeros(shape, dtype='uint8')\n        box_mask[y1:y2, x1:x2] = 1\n        return box_mask\n\n    return _box_mask\n\ndef compare_image(received, filename):\n    approved_path = f'tests\/fixtures\/{filename}.approved.png'\n    received_path = f'tests\/fixtures\/{filename}.received.png'\n    imsave(received_path, received)\n\n    if os.path.isfile(approved_path) is False:\n        fail(f'No image explicitly approved. Please verify {received_path}.')\n        return\n\n    approved_image = imread(approved_path)\n    received_image = imread(received_path)\n\n    if (approved_image != received_image).any():\n        fail(f'{received_path} != {approved_path}. Please verify.')\n    else:\n        os.remove(received_path)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_619","text":"import os\r\nimport sys\r\nimport numpy as np\r\nfrom scipy.stats import skew\r\nfrom matplotlib import pyplot as plt\r\n\r\n# Function: get_int_input()\r\n# Description: Gets integer from the user between min and max provided. Shows\r\n#              prompt to user before every input. Handles erroneous input.\r\n# Pre-Conditions: String prompt, integer minimum and maximum given to function\r\n# Post-Conditions: Returned integer between minimum and maximum\r\ndef get_int_input(prompt, min, max):\r\n    while True:\r\n        answer = min - 1\r\n        try:\r\n            answer = int(input(prompt))\r\n        except ValueError:\r\n            print(f\"Attempted input was not an integer. Please try again\")\r\n        if not (answer <= max and answer >= min):\r\n            print(f\"Input was not between {min} and {max}. Please try again\")\r\n        else:\r\n            return answer\r\n\r\ndef smart_check_int_param(param_value, param_name, min_val, max_val):\r\n    try:\r\n        param_value = int(param_value)\r\n    except:\r\n        raise ValueError(f\"Parameter {param_name} must be an integer.\")\r\n    if not (param_value <= max_val and param_value >= min_val):\r\n        raise ValueError(f\"Parameter {param_name} must be larger than {min_val-1} and smaller than {max_val+1}.\")\r\n    return param_value\r\n\r\n\r\ndef smart_make_dir(dirpath):\r\n    if not os.path.isdir(dirpath):\r\n        os.mkdir(dirpath)\r\n\r\n\r\ndef norm_dirname(dirpath, dirtype, create = False):\r\n    if dirpath == 0:\r\n        return dirpath\r\n    if not os.path.isdir(dirpath):\r\n        if create:\r\n            os.mkdir(dirpath)\r\n        else:\r\n            raise ValueError(f\"Provided {dirtype} directory '{dirpath}' doesn't exist\")\r\n    if dirpath[-1] == os.path.sep:\r\n        return dirpath[:-1]\r\n    else:\r\n        return dirpath\r\n\r\n\r\n# Function: get_files()\r\n# Description: Gets all files of '.tiff' format in a folder\r\n# Pre-Conditions: Path-like string to valid directory provided\r\n# Post-Conditions: Returns list of path-like objects to existing tiffs within dir.\r\ndef get_files(folder):\r\n    tiffs = []\r\n    root_name = \"\"\r\n    for root, dirs, files in os.walk(folder):\r\n        for f in files:\r\n            this_name = '_'.join(f.split(\"_\")[:-1])\r\n            if root_name == \"\":\r\n                root_name = this_name\r\n            elif this_name != root_name:\r\n                raise ValueError(f\"Cannot confirm all images in {folder} are from the same stack. Ensure tiff filenames are all 'imgname_zX.tiff'\")\r\n            if f.split('.')[-1] == 'tif' or f.split('.')[-1] == 'tiff':\r\n                tiffs.append(os.path.join(root, f))\r\n    if not len(tiffs):\r\n        raise ValueError(\"No tiffs found!\")\r\n    return tiffs\r\n\r\n\r\n# Function: min_max_scale()\r\n# Description: Performs min-max scaling on img object (pixel array)\r\n# Pre-Conditions: Img object provided\r\n# Post-Conditions: Return img object with pixels min-max scaled.\r\ndef min_max_scale(img):\r\n    # std_max = np.nanmean(img) + 4 * np.nanstd(img)\r\n    # img[img > std_max] = std_max\r\n    # plt.hist(img.flatten())\r\n    # plt.show()\r\n\r\n    np.seterr(all = 'raise')\r\n\r\n    minimum = img.min()\r\n    maximum = img.max()\r\n    # The formula for min-max scaling:\r\n    img = (img - minimum) \/ (maximum - minimum) if maximum - minimum != 0 else (img - minimum) \/ 1\r\n    img *= 255\r\n    if isinstance(img, np.ma.MaskedArray):\r\n        img = np.ma.getdata(img)\r\n    return img\r\n\r\ndef gauss(x, mu, sigma, A):\r\n    out = x\r\n    for idx, inp in enumerate(x):\r\n        try:\r\n            out[idx] = A * np.exp(-(inp - mu)**2 \/ 2 \/ sigma**2)\r\n        except FloatingPointError:\r\n            out[idx] = 0\r\n    return out\r\n\r\ndef bimodal(x, mu1, s1, A1, mu2, s2, A2):\r\n    return gauss(x, mu1, s1, A1) + gauss(x, mu2, s2, A2)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_620","text":"from autotabular.pipeline.components.base import AutotabularPreprocessingAlgorithm\nfrom autotabular.pipeline.constants import DENSE, INPUT, SPARSE, UNSIGNED_DATA\nfrom ConfigSpace.configuration_space import ConfigurationSpace\n\n\nclass Densifier(AutotabularPreprocessingAlgorithm):\n\n    def __init__(self, random_state=None):\n        pass\n\n    def fit(self, X, y=None):\n        self.fitted_ = True\n        return self\n\n    def transform(self, X):\n        from scipy import sparse\n        if sparse.issparse(X):\n            return X.todense().getA()\n        else:\n            return X\n\n    @staticmethod\n    def get_properties(dataset_properties=None):\n        return {\n            'shortname': 'RandomTreesEmbedding',\n            'name': 'Random Trees Embedding',\n            'handles_regression': True,\n            'handles_classification': True,\n            'handles_multiclass': True,\n            'handles_multilabel': True,\n            'handles_multioutput': True,\n            'is_deterministic': True,\n            'input': (SPARSE, UNSIGNED_DATA),\n            'output': (DENSE, INPUT)\n        }\n\n    @staticmethod\n    def get_hyperparameter_search_space(dataset_properties=None):\n        cs = ConfigurationSpace()\n        return cs\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_621","text":"'''\r\n特征工程部分：\r\n1.各特征转化为数值型特征\r\n2.异常值检测\r\n3.缺失值填充\r\n4.特征变换\r\n5.特征选择\r\n最终数据集：包含做完特征变换后的特征样本值，以及未变换前的房屋总价和房屋每平米价\r\n'''\r\nimport pymysql\r\nimport pandas as pd\r\nimport numpy as np\r\nimport category_encoders as ce\r\nimport re\r\nimport cn2an\r\nimport datetime\r\nfrom scipy.stats import skew\r\nfrom scipy import stats\r\nfrom sklearn.preprocessing import PowerTransformer\r\n\r\nconn = pymysql.connect(\r\n    host = '192.168.127.12',\r\n    user = 'root',\r\n    passwd = '<PASSWORD>',\r\n    db = 'house',\r\n    port=3306,\r\n    charset = 'utf8'\r\n)\r\n\r\ncursor01 = conn.cursor()\r\ncursor01.execute(\r\n        \"select column_name, column_comment from information_schema.columns where table_schema ='house' and table_name = 'allhouses'\")\r\nall_info = list(cursor01.fetchall())\r\nprint(all_info)\r\ndf = pd.read_sql('select * from allhouses',conn)\r\ncolumn_names = []\r\nfor i in all_info:\r\n    column_names.append(i[1])\r\ndf.columns = column_names\r\ndf1 = df.copy()\r\n\r\n#有几十个房子由于页面特殊爬取错乱\r\ndf1 = df1.dropna(subset=['装修情况'])\r\n#某些特征无用，删除\r\ndf1 = df1.drop(columns=['小区详情url','房屋年限','房子ID'],axis=1)\r\n\r\ndf1.to_excel('初始数据集.xlsx',index=None)\r\n'''\r\n(1)各特征转化为数值特征\r\n1.去除单位\r\n2.特征组合\r\n3.特征编码\r\n'''\r\n#物业费用有些是1.2至100元\/平米\/月 有些是1.5元\/平米\/月的类型，对于前者取中值，对于后者只去除单位\r\ndf1.loc[df1['小区物业费用']=='暂无信息','小区物业费用'] = np.nan #对于暂无信息的值记作空值\r\ndf1.loc[df1['小区物业费用'].notnull(),'小区物业费用']=\\\r\ndf1.loc[df1['小区物业费用'].notnull(),'小区物业费用'].apply(lambda x:x[:-6])\r\ndf1.loc[df1['小区物业费用'].notnull(),'小区物业费用']=\\\r\ndf1.loc[df1['小区物业费用'].notnull(),'小区物业费用'].apply(lambda x: (np.double(x.split('至')[0])+np.double(x.split('至')[1]))\/2 if '至' in x else x)\r\n\r\n#对于上次交易时间与挂牌时间，做衍生指标处理，为挂牌时间-上次交易时间，单位天数\r\ndf1.loc[df['上次交易']=='暂无数据','上次交易'] = np.nan #对于暂无信息的值记作空值\r\ntoday = str(datetime.datetime.now().year)+'-'+str(datetime.datetime.now().month)+'-'+str(datetime.datetime.now().day)\r\ndf1['当前时间'] = today\r\ndf1['当前时间'] = pd.to_datetime(df1['当前时间'],errors = 'coerce')\r\ndf1['上次交易'] = pd.to_datetime(df1['上次交易'],errors = 'coerce')\r\ndf1['挂牌时间'] = pd.to_datetime(df1['挂牌时间'],errors = 'coerce')\r\ndf1['挂牌时间-上次交易时间'] = ((df1['挂牌时间'] - df1['上次交易']).values\/np.timedelta64(1, 'h'))\/24\r\ndf1['当前时间-挂牌时间']=((df1['当前时间'] - df1['挂牌时间']).values\/np.timedelta64(1, 'h'))\/24\r\n#删除原指标\r\ndf1 = df1.drop(columns = ['上次交易','挂牌时间','当前时间'])\r\n\r\n#房屋用途，标签编码\r\nyongtu_mapping = {\r\n           '别墅':5,\r\n           '商业':4,\r\n           '商住两用':3,\r\n           '普通住宅':2,\r\n           '平房':1,\r\n}\r\ndf1['房屋用途'] = df1['房屋用途'].map(yongtu_mapping)\r\n\r\n#抵押信息，将信息改为有无抵押，暂无信息则改为NaN，后进行编码处理\r\ndf1.loc[(df1['抵押信息']!='无抵押')&(df1['抵押信息'].notnull()),'抵押信息']=\\\r\ndf1.loc[(df1['抵押信息']!='无抵押')&(df1['抵押信息'].notnull()),'抵押信息'].apply(lambda x:x[:3])\r\ndf1.loc[df1['抵押信息']=='暂无数','抵押信息']=np.nan\r\n\r\n#前3个特征为有序特征，如产权共有的房子会更受消费者的青睐，因此均作二值化处理\r\ndf1.loc[df1['产权所属']=='共有','产权所属']=1\r\ndf1.loc[df1['产权所属']=='非共有','产权所属']=0\r\ndf1.loc[df1['抵押信息']=='无抵押','抵押信息']=1\r\ndf1.loc[df1['抵押信息']=='有抵押','抵押信息']=0\r\ndf1.loc[df1['房本备件']=='已上传房本照片','房本备件']=1\r\ndf1.loc[df1['房本备件']=='未上传房本照片','房本备件']=0\r\n\r\n#对于交易权属，使用频数编码\r\ncount_enc = ce.CountEncoder()\r\n#Transform the features, rename the columns with the _count suffix, and join to dataframe\r\ndf1['交易权属'] = count_enc.fit_transform(df1['交易权属'])\r\n\r\n#建筑时间\r\ndf1.loc[df1['建楼时间'].notnull(),'建楼时间']=df1.loc[df1['建楼时间'].notnull(),'建楼时间'].apply(lambda x:x[:-2])\r\ndf1.loc[df1['建楼时间']=='未知','建楼时间']=np.nan\r\ndf1['建楼时间-小区建筑年代']=np.nan\r\ndf1['建楼时间-小区建筑年代']=df1.loc[df1['建楼时间'].notnull(),'建楼时间'].astype(float)-df1.loc[df1['小区建筑年代'].notnull(),'小区建筑年代'].astype(float)\r\ndf1.loc[df1['建楼时间'].notnull(),'建楼时间']=\\\r\nfloat(datetime.datetime.now().year)-(df1.loc[df1['建楼时间'].notnull(),'建楼时间'].astype(float))\r\ndf1.loc[df1['小区建筑年代'].notnull(),'小区建筑年代']=\\\r\nfloat(datetime.datetime.now().year)-(df1.loc[df1['小区建筑年代'].notnull(),'小区建筑年代'].astype(float))\r\ndf1.rename(columns={\"建楼时间\":\"建楼距今时长\", \"小区建筑年代\":\"小区建成距今时长\"},inplace=True)\r\n\r\n#面积特征\r\ndf1.loc[df1['套内面积']=='暂无数据','套内面积']=np.nan\r\ndf1.loc[df1['建筑面积'].notnull(),'建筑面积']=df1.loc[df1['建筑面积'].notnull(),'建筑面积'].apply(lambda x:x[:-1]).astype(float)\r\ndf1.loc[df1['套内面积'].notnull(),'套内面积']=df1.loc[df1['套内面积'].notnull(),'套内面积'].apply(lambda x:x[:-1]).astype(float)\r\n#衍生特征，建筑面积-套内面积=公摊面积\r\ndf1['公摊面积']=np.nan\r\ndf1['公摊面积']=df1.loc[df1['建筑面积'].notnull(),'建筑面积']-df1.loc[df1['套内面积'].notnull(),'套内面积']\r\n\r\n#梯户比例：衍生特征户数\/梯数\r\nre2 = re.compile('(.+)梯(.+)户')\r\ndef cn_extraction(x):\r\n    if x==np.nan:\r\n        return ['一','零']\r\n    ret = re2.findall(x)\r\n    if ret:\r\n        return (re2.findall(x))[0]\r\n    else:\r\n        return ['一','零']\r\ndef calculate_ratio(x):\r\n    h = cn2an.cn2an(x[1],'smart')\r\n    t = cn2an.cn2an(x[0],'smart')\r\n    r = h\/t\r\n    return r\r\ndf1.loc[df1['梯户比例'].notnull(),'梯户比例']=df1.loc[df1['梯户比例'].notnull(),'梯户比例'].apply(cn_extraction).apply(calculate_ratio)\r\n\r\n#房屋户型：衍生特征：卧室数量，客厅数量，厨房数量，卫生间数量\r\nre1 = re.compile('\\d+')\r\ntemp = df1.loc[:,'房屋户型'].apply(re1.findall)\r\ndf1['卧室数量']=df1['客厅数量']=df1['厨房数量']=df1['卫生间数量']=np.nan\r\ndf1['卧室数量'] = temp.apply(lambda x:x[0])\r\ndf1['客厅数量'] = temp.apply(lambda x:x[1])\r\ndf1['厨房数量'] = temp.apply(lambda x:x[2])\r\ndf1['卫生间数量'] = temp.apply(lambda x:x[3])\r\ndf1 = df1.drop(columns = ['房屋户型'])\r\n\r\n#所在楼层衍生特征总楼层数目\r\nre3 = re.compile('.+共(\\d+)层.+')\r\ndf1['总层数'] = df1.loc[:,'所在楼层'].apply(lambda x:re3.findall(x)[0])\r\n\r\n# 户型分间衍生以下特征\r\n# 1.客厅面积占比\r\n# 2.卧室面积占比\r\n# 3.实际使用面积\r\n# 4.落地窗数量\r\n# 5.有无储物间\r\n# 6.有无入室花园\r\n# 7.窗户数量\r\n# 8.平均卧室面积\r\n# 9.客厅、卧室、阳台朝向，采光等级\r\n\r\n#朝向以等级分级\r\n#南＞东南=西南＞东=西＞东北=西北＞北\r\nrank_direction = {\r\n    '南':5,\r\n    '东南':4,\r\n    '西南':4,\r\n    '东':3,\r\n    '西':3,\r\n    '东北':2,\r\n    '西北':2,\r\n    '北':1,\r\n    '无':None\r\n}\r\n\r\ndef change_direct(x):\r\n    for k,j in rank_direction.items():\r\n        if k in x:\r\n            return j\r\ndf1.loc[df1['户型分间']=='{}','户型分间']=np.nan\r\nlist1=[]\r\nlist2=[]\r\nlist3=[]\r\nlist4=[]\r\nlist5=[]\r\nlist6=[]\r\nlist7=[]\r\nlist8=[]\r\nlist9=[]\r\nlist10=[]\r\nlist11=[]\r\nfor item in df1.loc[df1['户型分间'].notnull(), '户型分间']:\r\n    item = eval(item)  # 转换为字典\r\n    df2 = pd.DataFrame(item)\r\n    if '储物间' in df2.columns:\r\n        list3.append(1)\r\n    else:\r\n        list3.append(0)\r\n    if '入户花园' in df2.columns:\r\n        list4.append(1)\r\n    else:\r\n        list4.append(0)\r\n    j = 0\r\n    k = 0\r\n    for i in df2.iloc[2]:\r\n        if i == '落地飘窗':\r\n            j = j + 1\r\n        if i != '无窗':\r\n            k = k + 1\r\n    list2.append(j)\r\n    list5.append(k)\r\n    df3 = df2.filter(regex='客厅')\r\n    df4 = df2.filter(regex='卧室')\r\n    df5 = df2.filter(regex='阳台')\r\n    using_area = 0\r\n    for p in df2.iloc[0]:\r\n        p = p.split('平')\r\n        p = np.double(p[0])\r\n        using_area = using_area + p\r\n    list6.append(using_area)\r\n    livingroom_sum = 0\r\n    for p in df3.iloc[0]:\r\n        p = p.split('平')\r\n        p = np.double(p[0])\r\n        livingroom_sum = livingroom_sum + p\r\n    list1.append(np.double(livingroom_sum \/ using_area))\r\n    room_sum = 0\r\n    for p in df4.iloc[0]:\r\n        p = p.split('平')\r\n        p = np.double(p[0])\r\n        room_sum = room_sum + p\r\n    list8.append(np.double(room_sum \/ using_area))\r\n    m = df4.shape[1]\r\n    if m != 0:\r\n        room_ave = room_sum \/ m\r\n    else:\r\n        room_ave = 0\r\n    list7.append(room_ave)\r\n\r\n    # 房屋朝向等级\r\n    # 客厅\r\n    try:\r\n        list9.append(change_direct(df3['客厅'][1]))\r\n    except:\r\n        list9.append(None)\r\n    # 主卧\r\n    try:\r\n        x1 = df4.iloc[1, np.argmax(df4.loc[0, :].apply(lambda x: x[:-2]).astype(float))]\r\n        list10.append(change_direct(x1))\r\n    except:\r\n        list10.append(None)\r\n    # 主阳台\r\n    try:\r\n        x1 = df5.iloc[1, np.argmax(df5.loc[0, :].apply(lambda x: x[:-2]).astype(float))]\r\n        list11.append(change_direct(x1))\r\n    except:\r\n        list11.append(None)\r\ndf1['客厅面积占比']=df1['户型分间']\r\ndf1['卧室面积占比']=df1['户型分间']\r\ndf1['平均卧室面积']=df1['户型分间']\r\ndf1['实际使用面积']=df1['户型分间']\r\ndf1['有无储物间']=df1['户型分间']\r\ndf1['有无入室花园']=df1['户型分间']\r\ndf1['窗户数量']=df1['户型分间']\r\ndf1['落地窗数量']=df1['户型分间']\r\ndf1['客厅采光程度']=df1['户型分间']\r\ndf1['主卧采光程度']=df1['户型分间']\r\ndf1['阳台采光程度']=df1['户型分间']\r\ndf1.loc[df1['客厅面积占比'].notnull(),'客厅面积占比']=list1\r\ndf1.loc[df1['落地窗数量'].notnull(),'落地窗数量']=list2\r\ndf1.loc[df1['有无储物间'].notnull(),'有无储物间']=list3\r\ndf1.loc[df1['有无入室花园'].notnull(),'有无入室花园']=list4\r\ndf1.loc[df1['窗户数量'].notnull(),'窗户数量']=list5\r\ndf1.loc[df1['实际使用面积'].notnull(),'实际使用面积']=list6\r\ndf1.loc[df1['平均卧室面积'].notnull(),'平均卧室面积']=list7\r\ndf1.loc[df1['卧室面积占比'].notnull(),'卧室面积占比']=list8\r\ndf1.loc[df1['客厅采光程度'].notnull(),'客厅采光程度']=list9\r\ndf1.loc[df1['主卧采光程度'].notnull(),'主卧采光程度']=list10\r\ndf1.loc[df1['阳台采光程度'].notnull(),'阳台采光程度']=list11\r\ndf1=df1.drop(['户型分间'],axis=1)\r\n\r\n##重要性不大，且难处理\r\ndf1=df1.drop(['小区建筑类型'],axis=1)\r\ndf1=df1.drop(['房屋朝向'],axis=1)\r\n\r\n#户型结构、建筑类型、所在楼层（为无序特征）：使用onehot编码\r\ndf1['户型结构']=df1['户型结构'].replace(\"暂无数据\",np.NAN)\r\ndf1 = pd.concat([df1, pd.get_dummies(df1.loc[:,['户型结构']])], sort=False, axis=1)\r\ndf1=df1.drop('户型结构',axis=1)\r\ndf1['建筑类型']=df1['建筑类型'].replace(\"暂无数据\",np.NAN)\r\ndf1 = pd.concat([df1, pd.get_dummies(df1.loc[:,['建筑类型']])], sort=False, axis=1)\r\ndf1=df1.drop('建筑类型',axis=1)\r\n\r\n#所在楼层\r\ndf1['所在楼层']=df1['所在楼层'].astype(str)\r\ndef rep(x):\r\n    pattern = re.compile(r'\\s\\((.*)\\)')\r\n    return pattern.sub(r'',x)\r\ndf1['所在楼层']=df1['所在楼层'].apply(rep)\r\ndf1['所在楼层']=df1['所在楼层'].replace(\"nan\",np.NAN)\r\ndf1 = pd.concat([df1, pd.get_dummies(df1.loc[:,['所在楼层']])], sort=False, axis=1)\r\ndf1=df1.drop('所在楼层',axis=1)\r\n\r\n#建筑结构、装修情况：定义等级后编码\r\ndf1['建筑结构']=df1['建筑结构'].replace(\"未知结构\",np.NAN)\r\njiegou_mapping = {\r\n           '钢结构': 6,\r\n           '钢混结构':5,\r\n           '框架结构':4,\r\n           '混合结构':3,\r\n           '砖混结构':2,\r\n           '砖木结构':1}\r\ndf1['建筑结构'] = df1['建筑结构'].map(jiegou_mapping)\r\n\r\ndf1['装修情况']=df1['装修情况'].replace(\"其他\",np.NAN)\r\nzhuangxiu_mapping={\r\n    '精装':3,\r\n    '简装':2,\r\n    '毛坯':1\r\n}\r\ndf1['装修情况'] = df1['装修情况'].map(zhuangxiu_mapping)\r\n#电梯二值化处理\r\ndf1['配备电梯']=df1['配备电梯'].replace(\"暂无数据\",1)\r\ndf1['配备电梯']=df1['配备电梯'].replace(\"NULL\",1)\r\ndf1['配备电梯']=df1['配备电梯'].replace(\"有\",1)\r\ndf1['配备电梯']=df1['配备电梯'].replace(\"无\",0)\r\n\r\n#所在广州区域\r\nlist_sorted=['天河','越秀','海珠','荔湾','白云','番禺','黄埔','南沙','顺德','增城','花都','从化','南海']\r\nmapping={'天河':12,'越秀':11,'海珠':10,'荔湾':9,'白云':8,'番禺':7,'黄埔':6,'南沙':5,'顺德':4,'增城':3,'花都':2,'从化':1,'南海':0}\r\ndf1['所在区域']=df1['所在区域'].map(mapping)\r\n\r\n'''\r\n(2)异常值检测及处理\r\n有以下处理\r\n1.特征为负数的都为异常值：小区建成距今时长、挂牌时间-上次交易时间（负数的为异常值，当作缺失值）\r\n2.小区物业费用（小区物业费用过高或过低的为异常值，当作缺失值）\r\n3.实际使用面积应该比建筑面积小，因此将实际面积大于建筑面积的部分视为异常值\r\n'''\r\n# 特征为负数的都为异常值，作为缺失值\r\ndef delete_negative(df1,label):\r\n    if(len(df1.loc[df1[label]<0,label])>0):\r\n        print('特征{0}的异常值数目为:{1}'.format(label,len(df1.loc[df1[label]<0,label])))\r\n    df1.loc[df1[label]<0,label]=np.nan\r\nfor i in df1.keys():\r\n    try:\r\n        delete_negative(df1,i)\r\n    except:\r\n        continue\r\n\r\n# 小区物业费用处理\r\ndf1['小区物业费用'] = df1['小区物业费用'].astype('float')\r\nlower_q=df1['小区物业费用'].quantile(0.25,interpolation='lower')#下四分位数\r\nhigher_q=df1['小区物业费用'].quantile(0.75,interpolation='higher')#上四分位数\r\nIQR=higher_q-lower_q\r\n#取下四分位数-3*IQR为下界，取上四分位数+3*IQR为上界\r\nLower_fence = lower_q - (IQR * 3)\r\nUpper_fence = higher_q + (IQR * 3)\r\n# 小区物业费用（过高过低当作缺失值）\r\ndf1.loc[df1['小区物业费用']<Lower_fence,'小区物业费用']=np.nan\r\ndf1.loc[df1['小区物业费用']>Upper_fence,'小区物业费用']=np.nan\r\ndf1.loc[df1['实际使用面积']>df1['建筑面积'],'实际使用面积']=np.nan\r\n\r\n'''\r\n(4)缺失值处理\r\n(1,2,3根据一定规则进行填充)\r\n1.套内面积与公摊面积\r\n2.配备电梯\r\n3.采光程度\r\n4.其余采用条件均值或条件众值进行填充\r\n'''\r\ntotal = df1.isnull().sum().sort_values(ascending=False)\r\npercent = (df1.isnull().sum()\/df1.isnull().count()).sort_values(ascending=False)\r\nmissing_data = pd.concat([total, percent], axis=1, keys=['Total','Percent'])\r\n\r\n'''\r\n相关数据填充\r\n1.套内面积与公摊面积\r\n建筑面积是无缺失的，套内面积缺失较多，导致公摊面积也缺失较多，三者之间有联系。 得\r\n房率=套内面积\/建筑面积。 \r\n一般来说，地下室(0) 60%，低层住宅（1-3）92%，多层住宅（4-9）得房率88%，高层住宅（>=10）80% \r\n根据得房率×建筑面积来填充套内面积。再用建筑面积-套内面积得到缺失的公摊面积。\r\n'''\r\n# 套内面积、公摊面积\r\ndf1[['套内面积','建筑面积','公摊面积','总层数']]=df1[['套内面积','建筑面积','公摊面积','总层数']].astype('float')\r\ncondition= (df1['套内面积'].isnull()) & (df1['总层数']==0)\r\ncondition1= (df1['套内面积'].isnull()) & (df1['总层数']<4) & (df1['总层数']>0)\r\ncondition2=(df1['套内面积'].isnull()) & (df1['总层数']<10) & (df1['总层数']>3)\r\ncondition3=(df1['套内面积'].isnull()) & (df1['总层数']>9)\r\ndf1.loc[condition,'套内面积']=df1.loc[condition,'建筑面积']*0.6\r\ndf1.loc[condition1,'套内面积']=df1.loc[condition1,'建筑面积']*0.92\r\ndf1.loc[condition2,'套内面积']=df1.loc[condition2,'建筑面积']*0.88\r\ndf1.loc[condition3,'套内面积']=df1.loc[condition3,'建筑面积']*0.80\r\ndf1.loc[df1['公摊面积'].isnull(),'公摊面积']=df1.loc[df1['公摊面积'].isnull(),'建筑面积']-df1.loc[df1['公摊面积'].isnull(),'套内面积']\r\n\r\n'''\r\n2.电梯\r\n配备电梯根据总层数来判断有无电梯，楼层大于6的视为有电梯，小于等于6的视为没有电梯。\r\n'''\r\n# 配备电梯\r\ncondition4=(df1['配备电梯'].isnull()) & (df1['总层数']<7)\r\ncondition5=(df1['配备电梯'].isnull()) & (df1['总层数']>6)\r\ndf1.loc[condition4,'配备电梯']=0\r\ndf1.loc[condition5,'配备电梯']=1\r\n\r\n'''\r\n3.采光程度\r\n三个关于采光程度的特征，以中等程度3进行填充\r\n'''\r\ndf1['客厅采光程度']=df1['客厅采光程度'].replace(np.NAN,3)\r\ndf1['主卧采光程度']=df1['主卧��光程度'].replace(np.NAN,3)\r\ndf1['阳台采光程度']=df1['阳台采光程度'].replace(np.NAN,3)\r\n\r\n'''\r\n4.其他缺失值填充\r\n'''\r\nmissing_labels=list(df1.keys())\r\n#离散型特征，使用条件众数填充，以小区ID为条件\r\ndf2 = df1[['所在区域', '小区ID', '建楼距今时长', '小区楼栋总数', '小区建成距今时长',\r\n           '建筑结构', '装修情况', '配备电梯', '交易权属', '房屋用途','产权所属', '抵押信息',\r\n           '房本备件', '挂牌时间-上次交易时间','建楼时间-小区建筑年代', '卧室数量','客厅数量',\r\n           '厨房数量', '卫生间数量', '总层数', '有无储物间', '有无入室花园', '窗户数量',\r\n           '落地窗数量', '客厅采光程度', '主卧采光程度', '阳台采光程度', '户型结构_复式', '户型结构_平层',\r\n           '户型结构_跃层', '户型结构_错层', '建筑类型_塔楼', '建筑类型_平房', '建筑类型_板塔结合', '建筑类型_板楼', '所在楼层_中楼层',\r\n           '所在楼层_低楼层', '所在楼层_地下室', '所在楼层_高楼层', '教育设施数量', '交通设施数', '购物设施数',\r\n           '生活设施数', '娱乐设施数', '医疗设施数']]\r\ncount_data =df2.groupby('小区ID').agg(lambda x: stats.mode(x)[0][0]).reset_index()\r\nmissing_labels2=['所在区域', '小区ID', '建楼距今时长', '小区楼栋总数', '小区建成距今时长',\r\n           '建筑结构', '装修情况', '配备电梯', '交易权属', '房屋用途','产权所属', '抵押信息',\r\n           '房本备件', '挂牌时间-上次交易时间','建楼时间-小区建筑年代', '卧室数量','客厅数量',\r\n           '厨房数量', '卫生间数量', '总层数', '有无储物间', '有无入室花园', '窗户数量',\r\n           '落地窗数量', '客厅采光程度', '主卧采光程度', '阳台采光程度', '户型结构_复式', '户型结构_平层',\r\n           '户型结构_跃层', '户型结构_错层', '建筑类型_塔楼', '建筑类型_平房', '建筑类型_板塔结合', '建筑类型_板楼', '所在楼层_中楼层',\r\n           '所在楼层_低楼层', '所在楼层_地下室', '所在楼层_高楼层', '教育设施数量', '交通设施数', '购物设施数',\r\n           '生活设施数', '娱乐设施数', '医疗设施数']\r\n\r\nfor i in missing_labels2:\r\n    for j in df1.loc[df1[i].isnull(),:].index:\r\n        df1.loc[j,i]=count_data.loc[count_data['小区ID']==df1.loc[j,'小区ID'],i].values[0]\r\n\r\n#未填完的用全部众数填充\r\nfor i in missing_labels2:\r\n    df1[i].fillna(df1[i].mode()[0],inplace=True)\r\n\r\nfor i in df1.columns:\r\n    try:\r\n        df1[i]=df1[i].astype('float')\r\n    except:\r\n        continue\r\n\r\n#连续特征使用条件均值，使用同个小区的均值填充\r\nmean_data = df1.groupby('小区ID').mean()\r\nfor i in missing_labels:\r\n    for j in df1.loc[df1[i].isnull(),:].index:\r\n        df1.loc[j,i]=mean_data.loc[df1.loc[j].小区ID,i]\r\n\r\n# 未填充完的特征\r\npretotal=total\r\ntotal2 = df1.isnull().sum().sort_values(ascending=False)\r\npercent = (df1.isnull().sum()\/df1.isnull().count()).sort_values(\r\n        ascending=False)\r\nmissing_data = pd.concat([total2, pretotal], axis=1, keys=['Total','PreTotal'])\r\n# 剩余特征\r\nmissing_labels=missing_data[missing_data['Total']!=0].index\r\n\r\n#剩余特征进一步使用条件均值填充，条件为所在广州区域\r\nmean_data2= df1.groupby('所在区域').mean()\r\nfor i in missing_labels:\r\n    for j in df1.loc[df1[i].isnull(),:].index:\r\n        df1.loc[j,i]=mean_data2.loc[df1.loc[j].所在区域,i]\r\n\r\n#剩余填充特征\r\npretotal=total2\r\ntotal3 = df1.isnull().sum().sort_values(ascending=False)\r\npercent = (df1.isnull().sum()\/df1.isnull().count()).sort_values(\r\n        ascending=False)\r\nmissing_data = pd.concat([total3, pretotal], axis=1, keys=['Total','PreTotal'])\r\nmissing_labels=missing_data[missing_data['Total']!=0].index\r\n\r\n# 剩余特征填完，直接用整列均值\r\nfor i in missing_labels:\r\n    df1[i].fillna(df1[i].mean(),inplace=True)\r\n\r\n#剩余填充特征\r\npretotal=total2\r\ntotal3 = df1.isnull().sum().sort_values(ascending=False)\r\npercent = (df1.isnull().sum()\/df1.isnull().count()).sort_values(\r\n        ascending=False)\r\nmissing_data = pd.concat([total3, pretotal], axis=1, keys=['Total','PreTotal'])\r\nmissing_labels=missing_data[missing_data['Total']!=0].index\r\n\r\ndf1=df1.drop(columns = ['小区ID'])\r\n\r\n'''\r\n(4)特征变换\r\n'''\r\n#对房屋总价正态变换，后面可以用inverse_transform反转\r\ndf1_1 = df1.copy()\r\npt = PowerTransformer('box-cox').fit(df1[['房屋总价']])\r\ndf1['房屋总价'] = pt.transform(df1[['房屋总价']])\r\n\r\n#对房屋每平米价正态变换，后面可以用inverse_transform反转\r\npt = PowerTransformer('box-cox').fit(df1[['房屋每平米价']])\r\ndf1['房屋每平米价'] = pt.transform(df1[['房屋每平米价']])\r\n\r\n#��续特征表\r\nlianxu = ['小区物业费用', '建筑面积', '套内面积', '梯户比例','公摊面积',\r\n          '客厅面积占比','卧室面积占比', '平均卧室面积', '实际使用面积',\r\n          '教育设施平均距离', '交通设施平均距离', '购物设施平均距离',\r\n          '生活设施平均距离', '娱乐设施平均距离', '医疗设施平均距离']\r\n\r\nskewness = df1[lianxu].apply(lambda x: skew(x))\r\nskewness.sort_values(ascending=False)\r\nskewness = skewness[abs(skewness)>0.75]\r\nskewness = list(skewness.index)\r\nskewness.append('房屋总价')\r\nskewness.append('房屋每平米价')\r\n\r\ndf_tran = df1_1.loc[:,skewness]\r\ndf_tran.to_excel('连续特征转化前数值.xlsx', index=None)\r\n\r\n#将偏度大于0.75的变量进行正态化\r\nfor i in skewness:\r\n    pt = PowerTransformer().fit(df1[[i]])\r\n    df1[i] = pt.transform(df1[[i]])\r\n\r\n'''\r\n(5)特征选择\r\n'''\r\ndef spearman(frame, features):\r\n    spr = pd.DataFrame()\r\n    spr['feature'] = features\r\n    spr['corr'] = [frame[f].corr(frame['房屋总价'], 'spearman') for f in features]\r\n    select_dict=dict(zip(spr['feature'],spr['corr']))\r\n    select_dict={k:v for k,v in select_dict.items() if abs(v)>0.1}\r\n    spr = spr.sort_values('corr')\r\n    return select_dict\r\ndf1.keys()\r\ndf2=df1.drop('房屋每平米价',1)\r\n# 筛选出相关系数绝对值大于0.1的特征\r\nselect_dict=spearman(df2, df2.columns)\r\nselect_dict.pop('房屋总价')\r\nselect_list=list(select_dict.keys())\r\nselect_data = df1[select_list]\r\nselect_labels=[]\r\ncorrmat = select_data.corr()\r\nfor i in select_list:\r\n    for j in select_list:\r\n        if abs(corrmat.loc[i,j])==1:\r\n            continue\r\n        if 0.8<abs(corrmat.loc[i,j]):\r\n            select_labels.append(i)\r\n            select_labels.append(j)\r\nselect_labels = list(set(select_labels))\r\nmax_score = 0\r\nmax_label = None\r\nfor i in select_labels:\r\n    if select_dict[i]>max_score:\r\n        max_score = select_dict[i]\r\n        max_label = i\r\nselect_labels.remove(max_label)\r\nselect_list = list(set(select_dict.keys()) - set(select_labels))\r\n\r\nselect_list.append('房屋总价')\r\nselect_list.append('房屋每平米价')\r\nif '所在区域' not in select_list:\r\n    select_list.append('所在区域')\r\n\r\ndf_final = df1[select_list]\r\nmid = df_final['所在区域']\r\ndf_final.drop(labels=['所在区域'], axis=1,inplace = True)\r\ndf_final.insert(0, '所在区域', mid)\r\n\r\nwith open('model1Name.txt','w', encoding='gbk') as file:\r\n    for c in list(df_final.keys()):\r\n        if (c == '房屋总价') or (c=='房屋每平米价'):\r\n            continue\r\n        file.write(c)\r\n        file.write(',')\r\n\r\ndf_final['当前时间-挂牌时间'] = df1['当前时间-挂牌时间']\r\n# df_j01 = df_final.loc[df_final['当前时间-挂牌时间']<365,:]\r\n# df_j01.drop(labels=['当前时间-挂牌时间'], axis=1,inplace = True)\r\n# df_j01.to_excel('建模数据1(一年内).xlsx',index=None)\r\n#\r\n# df_j02 = df_final.loc[df_final['当前时间-挂牌时间']<210,:]\r\n# df_j02.drop(labels=['当前时间-挂牌时间'], axis=1,inplace = True)\r\n# df_j02.to_excel('建模数据2(七个月内).xlsx',index=None)\r\n#\r\n# df_j03 = df_final.loc[df_final['当前时间-挂牌时间']<100,:]\r\n# df_j03.drop(labels=['当前时间-挂牌时间'], axis=1,inplace = True)\r\n# df_j03.to_excel('建模数据3(三个月内).xlsx',index=None)\r\n\r\ndf_final.drop(labels=['当前时间-挂牌时间'], axis=1,inplace = True)\r\ndf_final.to_excel('建模数据(全部数据).xlsx', index=None)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_622","text":"<reponame>prise-3d\/SIN3D\n# main imports\nimport os, sys\nimport argparse\nimport json\nimport numpy as np\nimport shutil\n\n# PNG images\nfrom PIL import Image\n\n# others import\nfrom ipfml import utils\nfrom scipy.signal import savgol_filter\n\n'''\nDisplay progress information as progress bar\n'''\ndef write_progress(progress):\n    barWidth = 180\n\n    output_str = \"[\"\n    pos = barWidth * progress\n    for i in range(barWidth):\n        if i < pos:\n           output_str = output_str + \"=\"\n        elif i == pos:\n           output_str = output_str + \">\"\n        else:\n            output_str = output_str + \" \"\n\n    output_str = output_str + \"] \" + str(int(progress * 100.0)) + \" %\\r\"\n    print(output_str)\n    sys.stdout.write(\"\\033[F\")\n\n\ndef extract_index(filepath):\n\n    return int(filepath.split('_')[-1].split('.')[0])\n\n\ndef extracts_linear_indices(images_path, n_expected=50, indices_step=20, start_at=20, smooth_arr=False):\n\n    # TODO : check this part\n    default_add = start_at - indices_step\n    \n    # extract variance for each image path\n    var_arr = []\n\n    n_counter = 0\n    n_images = len(images_path)\n\n    for p in sorted(images_path):\n        img = Image.open(p)\n        var_arr.append(np.var(img))\n\n        n_counter += 1\n        write_progress((n_counter + 1) \/ n_images)\n        \n    # normalize variance values\n    norm_arr = np.array(utils.normalize_arr_with_range(var_arr))\n    \n    if smooth_arr:\n        norm_arr = utils.normalize_arr_with_range(savgol_filter(norm_arr, 201, 3)) # window size 7, polynomial order 3\n    \n    # get expected linear step (using n_expectec output images)\n    linear_steps = utils.normalize_arr_with_range((1 - (np.arange(n_expected) \/ n_expected)))\n    \n    # get image indices from variance convergence and linear\n    # => when linear step is reached we store the index found from variance values\n    indices_found = []\n    for i in linear_steps: \n        \n        find_index = 0\n        \n        for index, y in enumerate(norm_arr):\n            if i <= y:\n                find_index = index\n\n        indices_found.append(find_index + 1)\n\n    indices = np.array(indices_found) * indices_step\n    \n    # add tricks to avoid same indice\n    # => when index is same as previous, then add number of samples expected by step \n    # Example with step of 20 : [20, 20, 20, 100, 200] => [20, 40, 60, 100, 200]\n    final_indices = []\n    for index, i in enumerate(indices):\n        value = indices[index]\n        if index > 0:\n            if i <= indices[index - 1]:\n                value = indices[index - 1] + indices_step\n                indices[index] = value\n\n        final_indices.append(value)\n        \n    return np.array(final_indices) + default_add\n\n\ndef main():\n    \"\"\"\n    main function which is ran when launching script\n    \"\"\" \n    parser = argparse.ArgumentParser(description=\"Compute new dataset scene\")\n\n    parser.add_argument('--file', type=str, help='file data extracted from `utils\/extract_stats_freq_and_min.py` script', required=True)\n    parser.add_argument('--png_folder', type=str, help='png dataset folder with scene', required=True)\n    parser.add_argument('--users', type=int, help='min number of users required per scene', required=True, default=10)\n    #parser.add_argument('--samples', type=int, help='expected samples to get for this dataset', required=True, default=10000)\n    parser.add_argument('--output', type=str, help='output image folder', required=True)\n\n    args = parser.parse_args()\n\n    p_file   = args.file\n    p_png_folder = args.png_folder\n    p_users  = args.users\n    #p_samples = args.samples\n    p_output = args.output\n\n    with open(p_file, 'r') as f:\n\n        for line in f.readlines():\n\n            data = line.split(';')\n\n            scene = data[0]\n            n_users = int(data[1])\n            min_index = int(data[2])\n\n            # remove _partX from scene name\n            scene_parts = scene.split('_')\n            del scene_parts[-1]\n            scene_name = '_'.join(scene_parts)\n\n            output_scene_dir = os.path.join(p_output, scene)\n\n            if os.path.exists(output_scene_dir):\n                print('Extraction of custom indices already done for', scene)\n                continue\n\n            if n_users >= p_users:\n                print('Extract custom indices based on minimum index for', scene)\n\n                png_folder_scene = os.path.join(p_png_folder, scene)\n\n                if not os.path.exists(png_folder_scene):\n                    print(png_folder_scene, 'png folder does not exist')\n                else:\n                    \n                    # get all rawls files\n                    png_files = [ os.path.join(png_folder_scene, p) for p in sorted(os.listdir(png_folder_scene)) ]\n\n                    # extract max samples found for this scene\n                    _, filename = os.path.split(png_files[-1])\n\n                    max_samples = extract_index(filename)\n\n                    # extract step from these files\n                    input_step = int(max_samples \/ len(png_files))\n\n                    # get indices using min index\n                    indices = extracts_linear_indices(png_files[int(min_index \/ input_step):], n_expected=50, indices_step=input_step, start_at=min_index, smooth_arr=True)\n\n                    # print('Indices found are', indices)\n                    # create output directory\n                    if not os.path.exists(output_scene_dir):\n                        os.makedirs(output_scene_dir)\n\n                    # get expected png image and move it\n                    for index in indices:\n                        \n                        str_index = str(index)\n\n                        while len(str_index) < 5:\n                            str_index = \"0\" + str_index\n\n                        image_name = scene_name + '_' + str_index + '.png'\n                        png_image_path = os.path.join(png_folder_scene, image_name)\n\n                        # create output filepath\n                        output_img_filepath = os.path.join(output_scene_dir, image_name)\n\n                        # copy expected image path\n                        shutil.copy2(png_image_path, output_img_filepath)\n            else:\n                print('Only', n_users, 'users who passed the experiment for', scene)\n            \n            print('\\n---------------------------------------------')\n    \n\n\nif __name__ == \"__main__\":\n    main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_623","text":"import pdb\n\nimport numpy as np\n\nfrom scipy.optimize import (\n    check_grad,\n    fmin_cg,\n    fmin_ncg,\n    fmin_bfgs,\n)\n\nfrom sklearn.base import (\n    BaseEstimator,\n    TransformerMixin,\n)\n\nfrom sklearn.preprocessing import (\n    StandardScaler,\n)\n\n\ndef square_dist(x1, x2=None):\n    \"\"\"If x1 is NxD and x2 is MxD (default x1), return NxM square distances.\"\"\"\n\n    if x2 is None:\n        x2 = x1\n\n    return (\n        np.sum(x1 * x1, 1)[:, np.newaxis] +\n        np.sum(x2 * x2, 1)[np.newaxis, :] -\n        np.dot(x1, (2 * x2.T))\n    )\n\n\ndef nca_cost(A, xx, yy, reg):\n    \"\"\"Neighbourhood Components Analysis: cost function and gradients\n\n        ff, gg = nca_cost(A, xx, yy)\n\n    Evaluate a linear projection from a D-dim space to a K-dim space (K<=D).\n    See Goldberger et al. (2004).\n\n    Inputs:\n        A  KxD Current linear transformation.\n        xx NxD Input data\n        yy Nx1 Corresponding labels, taken from any discrete set\n\n    Outputs:\n        ff 1x1 NCA cost function\n        gg KxD partial derivatives of ff wrt elements of A\n\n    Motivation: gradients in existing implementations, and as written in the\n    paper, have the wrong scaling with D. This implementation should scale\n    correctly for problems with many input dimensions.\n\n    Note: this function should be passed to a MINIMIZER.\n\n    \"\"\"\n\n    N, D = xx.shape\n    assert(yy.size == N)\n    assert(A.shape[1] == D)\n    K = A.shape[0]\n\n    # Cost function:\n    zz = np.dot(A, xx.T)  # KxN\n\n    # TODO Subsample part of data to compute loss on.\n    # kk = np.exp(-square_dist(zz.T, zz.T[idxs]))  # Nxn\n    # kk[idxs, np.arange(len(idxs))] = 0\n\n    ss = square_dist(zz.T)\n    np.fill_diagonal(ss, np.inf)\n    mm = np.min(ss, axis=0)\n    kk = np.exp(mm - ss)  # NxN\n    np.fill_diagonal(kk, 0)\n    Z_p = np.sum(kk, 0)  # N,\n    p_mn = kk \/ Z_p[np.newaxis, :]  # P(z_m | z_n), NxN\n    mask = yy[:, np.newaxis] == yy[np.newaxis, :]\n    p_n = np.sum(p_mn * mask, 0)  # 1xN\n    ff = - np.sum(p_n)\n\n    # Back-propagate derivatives:\n    kk_bar = - (mask - p_n[np.newaxis, :]) \/ Z_p[np.newaxis, :]  # NxN\n    ee_bar = kk * kk_bar\n    zz_bar_part = ee_bar + ee_bar.T\n    zz_bar = 2 * (np.dot(zz, zz_bar_part) - (zz * np.sum(zz_bar_part, 0)))  # KxN\n    gg = np.dot(zz_bar, xx)  # O(DKN)\n\n    if reg > 0:\n        ff = ff + reg * np.dot(A.ravel(), A.ravel())\n        gg = gg + 2 * reg * A\n\n    return ff, gg\n\n\ndef nca_cost_batch(self, A, xx, yy, idxs):\n\n    N, D = xx.shape\n    n = len(idxs)\n\n    assert(yy.size == N)\n    assert(A.shape[1] == D)\n\n    K = A.shape[0]\n\n    # Cost function:\n    zz = np.dot(A, xx.T)  # KxN\n    Z_p = np.sum(kk, 0)  # N,\n    p_mn = kk \/ Z_p[np.newaxis, :]  # P(z_m | z_n), NxN\n    mask = yy[:, np.newaxis] == yy[np.newaxis, :]\n    p_n = np.sum(p_mn * mask, 0)  # 1xN\n    ff = - np.sum(p_n)\n\n    # Back-propagate derivatives:\n    kk_bar = - (mask - p_n[np.newaxis, :]) \/ Z_p[np.newaxis, :]  # NxN\n    zz_bar_part = kk * (kk_bar + kk_bar.T)\n    zz_bar = 2 * (np.dot(zz, zz_bar_part) - (zz * sum(zz_bar_part, 0)))  # KxN\n    gg = np.dot(zz_bar, xx)  # O(DKN)\n\n    return ff, gg\n\n\nclass NCA(BaseEstimator, TransformerMixin):\n    def __init__(self, reg=0, dim=None, optimizer='cg'):\n        self.reg = reg\n        self.K = dim\n        self.standard_scaler = StandardScaler()\n\n        if optimizer in ('cg', 'conjugate_gradients'):\n            self._fit = self._fit_conjugate_gradients\n        elif optimizer in ('gd', 'gradient_descent'):\n            self._fit = self._fit_gradient_descent\n        elif optimizer in ('mb', 'mini_batches'):\n            self._fit = self._fit_mini_batches\n        else:\n            raise ValueError(\"Unknown optimizer {:s}\".format(optimizer))\n\n    def fit(self, X, y):\n\n        N, D = X.shape\n\n        if self.K is None:\n            self.K = D\n\n        self.A = np.random.randn(self.K, D) \/ np.sqrt(N)\n\n        X = self.standard_scaler.fit_transform(X)\n        return self._fit(X, y)\n\n    def _fit_gradient_descent(self, X, y):\n        # Gradient descent.\n        self.learning_rate = 0.001\n        self.error_tol = 0.001\n        self.max_iter = 1000\n\n        curr_error = None\n\n        # print(check_grad(costf, costg, 0.1 * np.random.randn(self.K * D)))\n        # idxs = list(sorted(random.sample(range(len(X)), 100)))\n\n        for it in range(self.max_iter):\n\n            f, g = nca_cost(self.A, X, y, self.reg)\n            self.A -= self.learning_rate * g\n\n            prev_error = curr_error\n            curr_error = f\n\n            print('{:4d} {:+.6f}'.format(it, curr_error))\n\n            if prev_error and np.abs(curr_error - prev_error) < self.error_tol:\n                break\n\n        return self\n\n    def _fit_conjugate_gradients(self, X, y):\n        N, D = X.shape\n\n        def costf(A):\n            f, _ = nca_cost(A.reshape([self.K, D]), X, y, self.reg)\n            return f \n\n        def costg(A):\n            _, g = nca_cost(A.reshape([self.K, D]), X, y, self.reg)\n            return g.ravel()\n\n        # print(check_grad(costf, costg, 0.1 * np.random.randn(self.K * D)))\n        self.A = fmin_cg(costf, self.A.ravel(), costg, maxiter=400)\n        self.A = self.A.reshape([self.K, D])\n        return self\n\n    def fit_transform(self, X, y):\n        self.fit(X, y)\n        return self.transform(X)\n\n    def transform(self, X):\n        return np.dot(self.standard_scaler.transform(X), self.A.T)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_612","text":"#!\/usr\/bin\/env python\n\nimport numpy as np\nimport scipy.optimize\n\n# https:\/\/pypi.python.org\/pypi\/transforms3d\nimport transforms3d\n\ndef make_transform(tx, ty, tz, rotz):\n    ''' Creates a 4x4 rigid transform matrix with\n    translation: tx, ty, tz\n    rotation: rotz radians around z axis\n    '''\n    rot = transforms3d.axangles.axangle2mat([0, 0, 1], rotz)\n    return transforms3d.affines.compose([tx, ty, tz], rot, [1, 1, 1])\n\ndef transform_points(points, tf):\n    ''' Input matrix of N points (one per column) 3xN\n    Outputs points in the same format '''\n    points_h = np.vstack((points, np.ones((1, points.shape[1]))))\n    tpoints = np.matmul(tf, points_h)\n    return tpoints[0:3, :] \/ tpoints[3, :]\n\ndef angle_between(v1, v2):\n    ''' Returns the angle in radians between vectors 'v1' and 'v2'::\n\n            >>> angle_between((1, 0, 0), (0, 1, 0))\n            1.5707963267948966\n            >>> angle_between((1, 0, 0), (1, 0, 0))\n            0.0\n            >>> angle_between((1, 0, 0), (-1, 0, 0))\n            3.141592653589793\n    '''\n    v1_u = transforms3d.utils.normalized_vector(v1)\n    v2_u = transforms3d.utils.normalized_vector(v2)\n\n    return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))\n\ndef angle_between_vectorized(v1, v2):\n    ''' Vectorized version of angle_between: v1 and v2 are 2D matrices, one vector per row.\n    Returns 1d array, one element per row\n    '''\n    v1_u = v1 \/ np.linalg.norm(v1, axis=1, keepdims=True)\n    v2_u = v2 \/ np.linalg.norm(v2, axis=1, keepdims=True)\n    dot = np.einsum(\"ij,ij->i\", v1_u, v2_u) # dot product for each row\n    return np.arccos(np.clip(dot, -1.0, 1.0))\n\ndef error_func(p, qc, qv, tx, ty, tz, rotz):\n    ''' Transform points p using tx, ty, tz, rotz.\n    For each transformed point tp, compute the angle between:\n    - the direction joining qc and tp\n    - the direction qv '''\n    tf = make_transform(tx, ty, tz, rotz)\n    tp = transform_points(p, tf)\n    return list(angle_between_vectorized(qv.T, (tp - qc).T))\n\ndef estimate_pose(p, qc, qv, x0):\n    ''' Given points in robot frame (p) and rays in human frame (qc, qv), find\n    transformation parameters from human frame to robot frame that minimize the\n    residual, using starting x0 as the initial solution '''\n\n    def f(x):\n        return np.mean(error_func(p, qc, qv, *x)) + max(0.0, np.linalg.norm(x[:3]) - 7.0)# + max(0.0, np.abs(x[2]) - 1.0)\n\n    res = scipy.optimize.minimize(f, x0)\n    maxerr = np.max(error_func(p, qc, qv, *res.x)) + max(0.0, np.linalg.norm(res.x[:3]) - 7.0)\n\n    return res, maxerr\n\ndef estimate_pose_no_constraints(p, qc, qv, x0):\n    ''' Given points in robot frame (p) and rays in human frame (qc, qv), find\n    transformation parameters from human frame to robot frame that minimize the\n    residual, using starting x0 as the initial solution '''\n\n    def f(x):\n        return np.mean(error_func(p, qc, qv, *x))\n\n    res = scipy.optimize.minimize(f, x0)\n\n    maxerr = np.max(error_func(p, qc, qv, *res.x))\n\n    return res, maxerr"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_614","text":"#! -*- coding: utf-8 -*-\n# 用Seq2Seq做小学数学应用题\n# 数据集为ape210k：https:\/\/github.com\/Chenny0808\/ape210k\n# 介绍链接：https:\/\/kexue.fm\/archives\/7809\n\nfrom __future__ import division\nimport json, re\nfrom tqdm import tqdm\nfrom bert4torch.models import build_transformer_model\nfrom bert4torch.tokenizers import Tokenizer, load_vocab\nfrom torch import nn, optim\nimport torch\nfrom torch.utils.data import DataLoader\nfrom bert4torch.snippets import sequence_padding, Callback, ListDataset\nfrom bert4torch.snippets import AutoRegressiveDecoder\nfrom sympy import Integer\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\n# 基本参数\nmaxlen = 192\nbatch_size = 16\nepochs = 100\n\n# bert配置\nconfig_path = 'F:\/Projects\/pretrain_ckpt\/bert\/[hit_torch_base]--chinese-bert-wwm-ext\/config.json'\ncheckpoint_path = 'F:\/Projects\/pretrain_ckpt\/bert\/[hit_torch_base]--chinese-bert-wwm-ext\/pytorch_model.bin'\ndict_path = 'F:\/Projects\/pretrain_ckpt\/bert\/[hit_torch_base]--chinese-bert-wwm-ext\/vocab.txt'\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\n\n# 加载并精简词表，建立分词器\ntoken_dict, keep_tokens = load_vocab(\n    dict_path=dict_path,\n    simplified=True,\n    startswith=['[PAD]', '[UNK]', '[CLS]', '[SEP]'],\n)\ntokenizer = Tokenizer(token_dict, do_lower_case=True)\n\n\ndef is_equal(a, b):\n    \"\"\"比较两个结果是否相等\n    \"\"\"\n    a = round(float(a), 6)\n    b = round(float(b), 6)\n    return a == b\n\n\ndef remove_bucket(equation):\n    \"\"\"去掉冗余的括号\n    \"\"\"\n    l_buckets, buckets = [], []\n    for i, c in enumerate(equation):\n        if c == '(':\n            l_buckets.append(i)\n        elif c == ')':\n            buckets.append((l_buckets.pop(), i))\n    eval_equation = eval(equation)\n    for l, r in buckets:\n        new_equation = '%s %s %s' % (equation[:l], equation[l + 1:r], equation[r + 1:])\n        try:\n            if is_equal(eval(new_equation.replace(' ', '')), eval_equation):\n                equation = new_equation\n        except:\n            pass\n    return equation.replace(' ', '')\n\n# 加载数据集\nclass MyDataset(ListDataset):\n    @staticmethod\n    def load_data(filename):\n        \"\"\"读取训练数据，并做一些标准化，保证equation是可以eval的\n        参考：https:\/\/kexue.fm\/archives\/7809\n        \"\"\"\n        D = []\n        for l in open(filename, 'r', encoding='utf-8'):\n            l = json.loads(l)\n            question, equation, answer = l['original_text'], l['equation'], l['ans']\n            # 处理带分数\n            question = re.sub('(\\d+)\\((\\d+\/\\d+)\\)', '(\\\\1+\\\\2)', question)\n            equation = re.sub('(\\d+)\\((\\d+\/\\d+)\\)', '(\\\\1+\\\\2)', equation)\n            answer = re.sub('(\\d+)\\((\\d+\/\\d+)\\)', '(\\\\1+\\\\2)', answer)\n            equation = re.sub('(\\d+)\\(', '\\\\1+(', equation)\n            answer = re.sub('(\\d+)\\(', '\\\\1+(', answer)\n            # 分数去括号\n            question = re.sub('\\((\\d+\/\\d+)\\)', '\\\\1', question)\n            # 处理百分数\n            equation = re.sub('([\\.\\d]+)%', '(\\\\1\/100)', equation)\n            answer = re.sub('([\\.\\d]+)%', '(\\\\1\/100)', answer)\n            # 冒号转除号、剩余百分号处理\n            equation = equation.replace(':', '\/').replace('%', '\/100')\n            answer = answer.replace(':', '\/').replace('%', '\/100')\n            if equation[:2] == 'x=':\n                equation = equation[2:]\n            try:\n                if is_equal(eval(equation), eval(answer)):\n                    D.append((question, remove_bucket(equation), answer))\n            except:\n                continue\n        return D\n\n\ndef collate_fn(batch):\n    batch_token_ids, batch_segment_ids = [], []\n    for question, equation, answer in batch:\n        token_ids, segment_ids = tokenizer.encode(question, equation, maxlen=maxlen)\n        batch_token_ids.append(token_ids)\n        batch_segment_ids.append(segment_ids)\n    batch_token_ids = torch.tensor(sequence_padding(batch_token_ids), dtype=torch.long, device=device)\n    batch_segment_ids = torch.tensor(sequence_padding(batch_segment_ids), dtype=torch.long, device=device)\n    return [batch_token_ids, batch_segment_ids], [batch_token_ids, batch_segment_ids]\n\n# 加载数据集\ntrain_dataloader = DataLoader(MyDataset('F:\/Projects\/data\/corpus\/seq2seq\/ape210k\/train.ape.json'), batch_size=batch_size, shuffle=True, collate_fn=collate_fn)\nvalid_dataset = MyDataset('F:\/Projects\/data\/corpus\/seq2seq\/ape210k\/valid.ape.json')\n# valid_dataloader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn)\n# test_dataloader = DataLoader(MyDataset('F:\/Projects\/data\/corpus\/seq2seq\/ape210k\/test.ape.json'), batch_size=batch_size, shuffle=True, collate_fn=collate_fn)\n\n\nmodel = build_transformer_model(\n    config_path,\n    checkpoint_path,\n    with_mlm='linear',\n    application='unilm',\n    keep_tokens=keep_tokens,  # 只保留keep_tokens中的字，精简原字表\n).to(device)\n\n\nclass CrossEntropyLoss(nn.CrossEntropyLoss):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n    def forward(self, outputs, target):\n        '''\n        y_pred: [btz, seq_len, vocab_size]\n        targets: y_true, y_segment\n        unilm式样，需要手动把非seq2seq部分mask掉\n        '''\n        _, y_pred = outputs\n        y_true, y_mask = target\n        y_true = y_true[:, 1:]# 目标token_ids\n        y_mask = y_mask[:, 1:]  # segment_ids，刚好指示了要预测的部分\n        y_pred = y_pred[:, :-1, :]  # 预测序列，错开一位\n        \n        y_pred = y_pred.reshape(-1, y_pred.shape[-1])\n        y_true = (y_true*y_mask).flatten()\n        return super().forward(y_pred, y_true)\nmodel.compile(loss=CrossEntropyLoss(ignore_index=0), optimizer=optim.Adam(model.parameters(), 1e-5))\n\n\nclass AutoSolve(AutoRegressiveDecoder):\n    \"\"\"seq2seq解码器\n    \"\"\"\n    @AutoRegressiveDecoder.wraps(default_rtype='logits')\n    def predict(self, inputs, output_ids, states):\n        token_ids, segment_ids = inputs\n        token_ids = torch.cat([token_ids, output_ids], 1)\n        segment_ids = torch.cat([segment_ids, torch.ones_like(output_ids, device=device)], 1)\n        _, y_pred = model.predict([token_ids, segment_ids])\n        return y_pred[:, -1, :]\n\n    def generate(self, text, topk=1):\n        token_ids, segment_ids = tokenizer.encode(text, maxlen=maxlen)\n        output_ids = self.beam_search([token_ids, segment_ids], topk=topk)  # 基于beam search\n        return tokenizer.decode(output_ids.cpu().numpy()).replace(' ', '')\n\n\nautosolve = AutoSolve(start_id=None, end_id=tokenizer._token_end_id, maxlen=64, device=device)\n\n\nclass Evaluator(Callback):\n    \"\"\"评估与保存\n    \"\"\"\n    def __init__(self):\n        self.best_acc = 0.\n\n    def on_epoch_end(self, steps, epoch, logs=None):\n        metrics = self.evaluate(valid_dataset.data[:200])  # 评测模型\n        if metrics['acc'] >= self.best_acc:\n            self.best_acc = metrics['acc']\n            # model.save_weights('.\/best_model_math.pt')  # 保存模型\n        metrics['best_acc'] = self.best_acc\n        print('valid_data:', metrics)\n        print()\n\n    def evaluate(self, data, topk=1):\n        total, right = 0.0, 0.0\n        for question, equation, answer in tqdm(data, desc='Evaluate'):\n            total += 1\n            pred_equation = autosolve.generate(question, topk)\n            try:\n                right += int(is_equal(eval(pred_equation), eval(answer)))\n            except:\n                pass\n        return {'acc': right \/ total}\n\n\nif __name__ == '__main__':\n    evaluator = Evaluator()\n    model.fit(train_dataloader, steps_per_epoch=500, epochs=epochs, callbacks=[evaluator])\nelse:\n    model.load_weights('.\/best_model.weights')"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_616","text":"##\n# \\brief Test copula rotations\nfrom __future__ import print_function, division\nfrom starvine.bvcopula.pc_base import PairCopula\nfrom starvine.bvcopula.copula_factory import Copula\nimport unittest\nimport numpy as np\nimport seaborn as sns\nfrom scipy.stats import kendalltau\nfrom six import iteritems\nimport os\npwd_ = os.getcwd()\ndataDir = pwd_ + \"\/tests\/data\/\"\nnp.random.seed(123)\n\n\nclass TestRotateGauss(unittest.TestCase):\n    def testGaussRotate(self):\n        np.random.seed(123)\n        shapes = {0: 0.7777777, 1: -0.7777777, 2: 0.7777777, 3: -0.7777777}\n        family = {'gauss': 0}\n        for rotation, shapeParam in iteritems(shapes):\n            gauss = Copula(\"gauss\", 0)\n            u, v = gauss.sample(10000, *(shapeParam,))\n            g = sns.jointplot(u, v)\n            g.savefig(\"gauss_sample_pdf_\" + str(rotation) + \".png\")\n            gauss.fittedParams = (shapeParam,)\n            c_kTau = gauss.kTau()\n            # compute rank corr coeff from resampled data\n            gauss_model = PairCopula(u, v, family=family)\n            gauss_model.copulaTournament()\n            print(gauss_model.copulaParams)\n            self.assertTrue(\"gauss\" in gauss_model.copulaModel.name)\n            # Ensure fitted shape parameter is same as original\n            self.assertAlmostEqual(shapeParam, gauss_model.copulaParams[1][0], delta=0.2)\n            # Ensure kTau is nearly the same from resampled data\n            self.assertAlmostEqual(c_kTau, gauss_model.copulaModel.kTau(), delta=0.02)\n            # fit to resampled data\n            u_model, v_model = gauss_model.copulaModel.sample(10000)\n            gauss_refit = PairCopula(u_model, v_model, family=family)\n            gauss_refit.copulaTournament()\n            u_resample, v_resample = gauss_refit.copulaModel.sample(2000)\n            self.assertAlmostEqual(c_kTau, gauss_refit.copulaModel.kTau(), delta=0.05)\n            self.assertAlmostEqual(shapeParam, gauss_refit.copulaParams[1][0], delta=0.2)\n            # plot resampled data\n            g_resample = sns.jointplot(u_resample, v_resample)\n            g_resample.savefig(\"gauss_resample_pdf_\" + str(rotation) + \".png\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_624","text":"<gh_stars>10-100\nfrom warnings import warn\nimport numpy as np\nimport pandas as pd\nfrom scipy import sparse\nfrom sklearn.metrics import pairwise_distances\nfrom sklearn.utils import as_float_array\nfrom topo.base.dists import pairwise_special_metric, SPECIAL_METRICS\nfrom topo.base.sparse import SPARSE_SPECIAL_METRICS, sparse_named_distances\n\n#from fastlapmap.similarities import fuzzy_simplicial_set_ann, cknn_graph, diffusion_harmonics\n\ndef LapEigenmap(W,\n                n_eigs=10,\n                norm_laplacian=True,\n                eigen_tol=10e-4,\n                return_evals=False):\n    \"\"\"\n    Performs [Laplacian Eigenmaps](https:\/\/www2.imm.dtu.dk\/projects\/manifold\/Papers\/Laplacian.pdf) on the input data.\n\n    ----------\n    Parameters\n    ----------\n\n    `W` : numpy.ndarray, pandas.DataFrame or scipy.sparse.csr_matrix.\n         Affinity or adjacency matrix.\n\n    `n_eigs` : int (optional, default 10).\n         Number of eigenvectors to decompose the graph Laplacian into.\n\n    `norm_laplacian` : bool (optional, default True).\n        Whether to renormalize the graph Laplacian.\n\n    `return_evals` : bool (optional, default False).\n        Whether to also return the eigenvalues in a tuple of eigenvectors, eigenvalues. Defaults to False.\n\n\n    ----------\n    Returns\n    ----------\n        * If return_evals is True :\n            A tuple of eigenvectors and eigenvalues.\n        * If return_evals is False :\n            An array of ranked eigenvectors.\n\n    \"\"\"\n\n    if isinstance(W, sparse.csr_matrix):\n        pass\n    elif isinstance(W, np.ndarray):\n        W = sparse.csr_matrix(W)\n    elif isinstance(W, pd.DataFrame):\n        W = W.to_numpy()\n        W = sparse.csr_matrix(W)\n    else:\n        return print('Data should be a numpy.ndarray,pandas.DataFrame or'\n                     'a scipy.sparse.csr_matrix for obtaining approximate nearest neighbors with \\'nmslib\\'.')\n\n    laplacian, dd = sparse.csgraph.laplacian(W, normed=norm_laplacian, return_diag=True)\n    laplacian = _set_diag(laplacian, 1, norm_laplacian)\n    laplacian *= -1\n    n_eigs = n_eigs + 1\n    evals, evecs = sparse.linalg.eigsh(laplacian, k=n_eigs, which='LM', sigma=1.0, tol=eigen_tol)\n    evecs = evecs.T[n_eigs::-1]\n    if norm_laplacian:\n        # recover u = D^-1\/2 x from the eigenvector output x\n        evecs = evecs \/ dd\n    evecs = evecs[1:n_eigs].T\n\n    if return_evals:\n        return evecs, evals\n    else:\n        return evecs\n\n\n\n\ndef _set_diag(laplacian, value, norm_laplacian):\n    \"\"\"Set the diagonal of the laplacian matrix and convert it to a\n    sparse format well suited for eigenvalue decomposition.\n    Parameters\n    ----------\n    laplacian : {ndarray, sparse matrix}\n        The graph laplacian.\n    value : float\n        The value of the diagonal.\n    norm_laplacian : bool\n        Whether the value of the diagonal should be changed or not.\n    Returns\n    -------\n    laplacian : {array, sparse matrix}\n        An array of matrix in a form that is well suited to fast\n        eigenvalue decomposition, depending on the band width of the\n        matrix.\n    \"\"\"\n    n_nodes = laplacian.shape[0]\n    # We need all entries in the diagonal to values\n    if not sparse.isspmatrix(laplacian):\n        if norm_laplacian:\n            laplacian.flat[:: n_nodes + 1] = value\n    else:\n        laplacian = laplacian.tocoo()\n        if norm_laplacian:\n            diag_idx = laplacian.row == laplacian.col\n            laplacian.data[diag_idx] = value\n        # If the matrix has a small number of diagonals (as in the\n        # case of structured matrices coming from images), the\n        # dia format might be best suited for matvec products:\n        n_diags = np.unique(laplacian.row - laplacian.col).size\n        if n_diags <= 7:\n            # 3 or less outer diagonals on each side\n            laplacian = laplacian.todia()\n        else:\n            # csr has the fastest matvec and is thus best suited to\n            # arpack\n            laplacian = laplacian.tocsr()\n    return laplacian\n\ndef spectral_decomposition(affinity_matrix, n_eigs, expand=False):\n    N = np.shape(affinity_matrix)[0]\n    D, V = sparse.linalg.eigsh(affinity_matrix, n_eigs, tol=1e-4, maxiter=(N \/\/ 10))\n    D = np.real(D)\n    V = np.real(V)\n    inds = np.argsort(D)[::-1]\n    D = D[inds]\n    V = V[:, inds]\n    # Normalize by the first diffusion component\n    for i in range(V.shape[1]):\n        V[:, i] = V[:, i] \/ np.linalg.norm(V[:, i])\n    vals = np.array(V)\n    pos = np.sum(vals > 0, axis=0)\n    residual = np.sum(vals < 0, axis=0)\n\n    if expand and len(residual) < 1:\n        # expand eigendecomposition\n        target = n_eigs + 30\n        while residual < 3:\n            while target < 3 * n_eigs:\n                print('Eigengap not found for determined number of components. Expanding eigendecomposition to '\n                      + str(target) + 'components.')\n                D, V = sparse.linalg.eigsh(affinity_matrix, target, tol=1e-4, maxiter=(N \/\/ 10))\n                D = np.real(D)\n                V = np.real(V)\n                inds = np.argsort(D)[::-1]\n                D = D[inds]\n                V = V[:, inds]\n                # Normalize by the first diffusion component\n                vals = np.array(V)\n                for i in range(V.shape[1]):\n                    vals[:, i] = vals[:, i] \/ np.linalg.norm(vals[:, i])\n                pos = np.sum(vals > 0, axis=0)\n                target = int(target * 1.6)\n                residual = np.sum(vals < 0, axis=0)\n\n            if residual < 1:\n                print('Could not find an eigengap! Consider increasing `n_neighbors` or `n_eigs` !'\n                      ' Falling back to `eigen_expansion=False`, will not attempt')\n                expand = False\n    if expand:\n        if len(residual) > 30:\n            target = n_eigs - 15\n            while len(residual) > 29:\n                D, V = sparse.linalg.eigsh(affinity_matrix, target, tol=1e-4, maxiter=(N \/\/ 10))\n                D = np.real(D)\n                V = np.real(V)\n                inds = np.argsort(D)[::-1]\n                D = D[inds]\n                V = V[:, inds]\n                vals = np.array(V)\n                for i in range(V.shape[1]):\n                    vals[:, i] = vals[:, i] \/ np.linalg.norm(vals[:, i])\n                pos = np.sum(vals > 0, axis=0)\n                residual = np.sum(vals < 0, axis=0)\n                if len(residual) < 15:\n                    break\n                else:\n                    target = pos - int(residual \/\/ 2)\n\n            if len(residual) < 1:\n                print('Could not find an eigengap! Consider increasing `n_neighbors` or `n_eigs` !'\n                      ' Falling back to `eigen_expansion=False`, will not attempt eigendecomposition expansion.')\n                expand = False\n\n    if not expand:\n        D, V = sparse.linalg.eigsh(affinity_matrix, n_eigs, tol=1e-4, maxiter=(N \/\/ 10))\n        D = np.real(D)\n        V = np.real(V)\n        inds = np.argsort(D)[::-1]\n        D = D[inds]\n        V = V[:, inds]\n\n    # Normalize by the first eigencomponent\n    for i in range(V.shape[1]):\n        V[:, i] = V[:, i] \/ np.linalg.norm(V[:, i])\n\n    # Normalize eigenvalues\n    D = D \/ D.max()\n\n    return V, D\n\n\n\ndef component_layout(\n        W,\n        n_components,\n        component_labels,\n        dim,\n        norm_laplacian=True,\n        eigen_tol=10e-4\n):\n    \"\"\"Provide a layout relating the separate connected components. This is done\n    by taking the centroid of each component and then performing a spectral embedding\n    of the centroids.\n    Parameters\n    ----------\n    W: numpy.ndarray, pandas.DataFrame or scipy.sparse.csr_matrix.\n         Affinity or adjacency matrix.\n    n_components: int\n        The number of distinct components to be layed out.\n    component_labels: array of shape (n_samples)\n        For each vertex in the graph the label of the component to\n        which the vertex belongs.\n    dim: int\n        The chosen embedding dimension.\n\n    Returns\n    -------\n    component_embedding: array of shape (n_components, dim)\n        The ``dim``-dimensional embedding of the ``n_components``-many\n        connected components.\n    \"\"\"\n\n    # cannot compute centroids from precomputed distances\n    # instead, compute centroid distances using linkage\n    distance_matrix = np.zeros((n_components, n_components), dtype=np.float64)\n    linkage = np.min\n\n    for c_i in range(n_components):\n        dm_i = W[component_labels == c_i]\n        for c_j in range(c_i + 1, n_components):\n            dist = linkage(dm_i[:, component_labels == c_j])\n            distance_matrix[c_i, c_j] = dist\n            distance_matrix[c_j, c_i] = dist\n\n    affinity_matrix = np.exp(-(distance_matrix ** 2))\n\n    component_embedding = LapEigenmap(W=affinity_matrix, n_eigs=dim, norm_laplacian=norm_laplacian, eigen_tol=eigen_tol)\n    component_embedding \/= component_embedding.max()\n\n    return component_embedding\n\n\ndef multi_component_layout(\n    graph,\n    n_components,\n    component_labels,\n    dim,\n    random_state\n):\n    \"\"\"Specialised layout algorithm for dealing with graphs with many connected components.\n    This will first find relative positions for the components by spectrally embedding\n    their centroids, then spectrally embed each individual connected component positioning\n    them according to the centroid embeddings. This provides a decent embedding of each\n    component while placing the components in good relative positions to one another.\n    Parameters\n    ----------\n    graph: sparse matrix\n        The adjacency matrix of the graph to be embedded.\n    n_components: int\n        The number of distinct components to be layed out.\n    component_labels: array of shape (n_samples)\n        For each vertex in the graph the label of the component to\n        which the vertex belongs.\n    dim: int\n        The chosen embedding dimension.\n\n    Returns\n    -------\n    embedding: array of shape (n_samples, dim)\n        The initial embedding of ``graph``.\n    \"\"\"\n\n    result = np.empty((graph.shape[0], dim), dtype=np.float32)\n\n    if n_components > 2 * dim:\n        meta_embedding = component_layout(\n            graph,\n            n_components,\n            component_labels,\n            dim,\n        )\n    else:\n        k = int(np.ceil(n_components \/ 2.0))\n        base = np.hstack([np.eye(k), np.zeros((k, dim - k))])\n        meta_embedding = np.vstack([base, -base])[:n_components]\n\n    for label in range(n_components):\n        component_graph = graph.tocsr()[component_labels == label, :].tocsc()\n        component_graph = component_graph[:, component_labels == label].tocoo()\n\n        distances = pairwise_distances([meta_embedding[label]], meta_embedding)\n        data_range = distances[distances > 0.0].min() \/ 2.0\n\n        if component_graph.shape[0] < 2 * dim:\n            result[component_labels == label] = (\n                random_state.uniform(\n                    low=-data_range,\n                    high=data_range,\n                    size=(component_graph.shape[0], dim),\n                )\n                + meta_embedding[label]\n            )\n            continue\n\n        diag_data = np.asarray(component_graph.sum(axis=0))\n        # standard Laplacian\n        # D = scipy.sparse.spdiags(diag_data, 0, graph.shape[0], graph.shape[0])\n        # L = D - graph\n        # Normalized Laplacian\n        I = sparse.identity(component_graph.shape[0], dtype=np.float64)\n        D = sparse.spdiags(\n            1.0 \/ (np.sqrt(diag_data)+10e-6),\n            0,\n            component_graph.shape[0],\n            component_graph.shape[0],\n        )\n        L = I - D * component_graph * D\n        k = dim + 1\n        num_lanczos_vectors = max(2 * k + 1, int(np.sqrt(component_graph.shape[0])))\n        try:\n            eigenvalues, eigenvectors = sparse.linalg.eigsh(\n                L,\n                k,\n                which=\"SM\",\n                ncv=num_lanczos_vectors,\n                tol=1e-4,\n                v0=np.ones(L.shape[0]),\n                maxiter=graph.shape[0] * 5,\n            )\n            order = np.argsort(eigenvalues)[1:k]\n            component_embedding = eigenvectors[:, order]\n            expansion = data_range \/ np.max(np.abs(component_embedding))\n            component_embedding *= expansion\n            result[component_labels == label] = (\n                component_embedding + meta_embedding[label]\n            )\n        except sparse.linalg.ArpackError:\n            warn(\n                \"WARNING: spectral initialisation failed! The eigenvector solver\\n\"\n                \"failed. This is likely due to too small an eigengap. Consider\\n\"\n                \"adding some noise or jitter to your data.\\n\\n\"\n                \"Falling back to random initialisation!\"\n            )\n            result[component_labels == label] = (\n                random_state.uniform(\n                    low=-data_range,\n                    high=data_range,\n                    size=(component_graph.shape[0], dim),\n                )\n                + meta_embedding[label]\n            )\n\n    return result\n\n\ndef spectral_layout(graph, dim, random_state):\n    \"\"\"Given a graph compute the spectral embedding of the graph. This is\n    simply the eigenvectors of the laplacian of the graph. Here we use the\n    normalized laplacian.\n\n    Parameters\n    ----------\n    graph: sparse matrix\n        The (weighted) adjacency matrix of the graph as a sparse matrix.\n    dim: int\n        The dimension of the space into which to embed.\n    random_state: numpy RandomState or equivalent\n        A state capable being used as a numpy random state.\n\n    Returns\n    -------\n    embedding: array of shape (n_vertices, dim)\n        The spectral embedding of the graph.\n    \"\"\"\n    n_components, labels = sparse.csgraph.connected_components(graph)\n\n    if n_components > 1:\n        return multi_component_layout(\n            graph,\n            n_components,\n            labels,\n            dim,\n            random_state,\n        )\n\n    diag_data = np.asarray(graph.sum(axis=0))\n    # standard Laplacian\n    # D = scipy.sparse.spdiags(diag_data, 0, graph.shape[0], graph.shape[0])\n    # L = D - graph\n    # Normalized Laplacian\n    I = sparse.identity(graph.shape[0], dtype=np.float64)\n    D = sparse.spdiags(\n        1.0 \/ (np.sqrt(diag_data)+10e-8), 0, graph.shape[0], graph.shape[0]\n    )\n    L = I - D * graph * D\n\n    k = dim + 1\n    num_lanczos_vectors = max(2 * k + 1, int(np.sqrt(graph.shape[0])))\n    try:\n        if L.shape[0] < 2000000:\n            eigenvalues, eigenvectors = sparse.linalg.eigsh(\n                L,\n                k,\n                which=\"SM\",\n                ncv=num_lanczos_vectors,\n                tol=1e-4,\n                v0=np.ones(L.shape[0]),\n                maxiter=graph.shape[0] * 5,\n            )\n        else:\n            eigenvalues, eigenvectors = sparse.linalg.lobpcg(\n                L, random_state.normal(size=(L.shape[0], k)), largest=False, tol=1e-8\n            )\n        order = np.argsort(eigenvalues)[1:k]\n        return eigenvectors[:, order]\n    except sparse.linalg.ArpackError:\n        warn(\n            \"WARNING: spectral initialisation failed! The eigenvector solver\\n\"\n            \"failed. This is likely due to too small an eigengap. Consider\\n\"\n            \"adding some noise or jitter to your data.\\n\\n\"\n            \"Falling back to random initialisation!\"\n        )\n        return random_state.uniform(low=-10.0, high=10.0, size=(graph.shape[0], dim))\n\n\ndef spectral_clustering(init, max_svd_restarts=30, n_iter_max=30, random_state=None, copy=True):\n    \"\"\"Search for a partition matrix (clustering) which is closest to the\n        eigenvector embedding.\n\n    Parameters\n    ----------\n    init : array-like of shape (n_samples, n_clusters)\n        The embedding space of the samples.\n    max_svd_restarts : int, default=30\n        Maximum number of attempts to restart SVD if convergence fails\n    n_iter_max : int, default=30\n        Maximum number of iterations to attempt in rotation and partition\n        matrix search if machine precision convergence is not reached\n    random_state : int, RandomState instance, default=None\n        Determines random number generation for rotation matrix initialization.\n        Use an int to make the randomness deterministic.\n        See :term:`Glossary <random_state>`.\n    copy : bool, default=True\n        Whether to copy vectors, or perform in-place normalization.\n    Returns\n    -------\n    labels : array of integers, shape: n_samples\n        The labels of the clusters.\n    References\n    ----------\n    - Multiclass spectral clustering, 2003\n      <NAME>, <NAME>\n      https:\/\/www1.icsi.berkeley.edu\/~stellayu\/publication\/doc\/2003kwayICCV.pdf\n    Notes\n    -----\n    The eigenvector embedding is used to iteratively search for the\n    closest discrete partition.  First, the eigenvector embedding is\n    normalized to the space of partition matrices. An optimal discrete\n    partition matrix closest to this normalized embedding multiplied by\n    an initial rotation is calculated.  Fixing this discrete partition\n    matrix, an optimal rotation matrix is calculated.  These two\n    calculations are performed until convergence.  The discrete partition\n    matrix is returned as the clustering solution.  Used in spectral\n    clustering, this method tends to be faster and more robust to random\n    initialization than k-means.\n    \"\"\"\n\n    from scipy.sparse import csc_matrix\n    from scipy.linalg import LinAlgError\n\n    vectors = as_float_array(init, copy=copy)\n\n    eps = np.finfo(float).eps\n    n_samples, n_components = vectors.shape\n\n    # Normalize the eigenvectors to an equal length of a vector of ones.\n    # Reorient the eigenvectors to point in the negative direction with respect\n    # to the first element.  This may have to do with constraining the\n    # eigenvectors to lie in a specific quadrant to make the discretization\n    # search easier.\n    norm_ones = np.sqrt(n_samples)\n    for i in range(vectors.shape[1]):\n        vectors[:, i] = (vectors[:, i] \/ np.linalg.norm(vectors[:, i])) \\\n                        * norm_ones\n    if vectors[0, i] != 0:\n        vectors[:, i] = -1 * vectors[:, i] * np.sign(vectors[0, i])\n\n    # Normalize the rows of the eigenvectors.  Samples should lie on the unit\n    # hypersphere centered at the origin.  This transforms the samples in the\n    # embedding space to the space of partition matrices.\n    vectors = vectors \/ np.sqrt((vectors ** 2).sum(axis=1))[:, np.newaxis]\n\n    svd_restarts = 0\n    has_converged = False\n\n    # If there is an exception we try to randomize and rerun SVD again\n    # do this max_svd_restarts times.\n\n    while (svd_restarts < max_svd_restarts) and not has_converged:\n\n        # Initialize first column of rotation matrix with a row of the\n        # eigenvectors\n        rotation = np.zeros((n_components, n_components))\n        rotation[:, 0] = vectors[random_state.randint(n_samples), :].T\n\n        # To initialize the rest of the rotation matrix, find the rows\n        # of the eigenvectors that are as orthogonal to each other as\n        # possible\n        c = np.zeros(n_samples)\n        for j in range(1, n_components):\n            # Accumulate c to ensure row is as orthogonal as possible to\n            # previous picks as well as current one\n            c += np.abs(np.dot(vectors, rotation[:, j - 1]))\n            rotation[:, j] = vectors[c.argmin(), :].T\n\n        last_objective_value = 0.0\n        n_iter = 0\n\n        while not has_converged:\n            n_iter += 1\n\n            t_discrete = np.dot(vectors, rotation)\n\n            labels = t_discrete.argmax(axis=1)\n            vectors_discrete = csc_matrix(\n                (np.ones(len(labels)), (np.arange(0, n_samples), labels)),\n                shape=(n_samples, n_components))\n\n            t_svd = vectors_discrete.T * vectors\n\n            try:\n                U, S, Vh = np.linalg.svd(t_svd)\n                svd_restarts += 1\n            except LinAlgError:\n                print(\"SVD did not converge, randomizing and trying again\")\n                break\n\n            ncut_value = 2.0 * (n_samples - S.sum())\n            if ((abs(ncut_value - last_objective_value) < eps) or\n                    (n_iter > n_iter_max)):\n                has_converged = True\n            else:\n                # otherwise calculate rotation and continue\n                last_objective_value = ncut_value\n                rotation = np.dot(Vh.T, U.T)\n\n    if not has_converged:\n        raise LinAlgError('SVD did not converge')\n    return labels"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_625","text":"<reponame>SharmaAjay19\/VideoImageColorization\nimport numpy as np\nimport os\nimport time\nimport skimage.color as color\nimport matplotlib.pyplot as plt\nimport scipy.ndimage.interpolation as sni\nimport caffe\nimport argparse\nimport cv2\nimport shutil\n\ndef parse_args():\n    parser = argparse.ArgumentParser(description='iColor: deep interactive colorization')\n    parser.add_argument('-vid_in',dest='vid_in',help='grayscale image to read in', type=str)\n    parser.add_argument('-vid_out',dest='vid_out',help='colorized image to save off', type=str)\n    parser.add_argument('--gpu', dest='gpu', help='gpu id', type=int, default=0)\n    parser.add_argument('--prototxt',dest='prototxt',help='prototxt filepath', type=str, default='.\/models\/colorization_deploy_v2.prototxt')\n    parser.add_argument('--caffemodel',dest='caffemodel',help='caffemodel filepath', type=str, default='.\/models\/colorization_release_v2.caffemodel')\n\n    args = parser.parse_args()\n    return args\n\ndef readVideoFrames(vid_path):\n\tvidcap = cv2.VideoCapture(vid_path)\n\tsuccess,image = vidcap.read()\n\tprint(\"Read video\")\n\ttempdir = os.getcwd()+\"\/video_temp\" + str(time.clock())\n\tif not os.path.exists(tempdir):\n\t\tos.makedirs(tempdir)\n\tcount = 0\n\twhile success:\n\t\tcv2.imwrite(tempdir + \"\/frame%d.jpg\" % count, image)     # save frame as JPEG file      \n\t\tsuccess,image = vidcap.read()\n\t\tcount += 1\n\tprint(\"Read %d frames\"%count)\n\treturn count, tempdir\n\ndef createVideoFromFrames(dirpath, vid_path, nframes):\n\tframe = cv2.imread(os.path.join(dirpath, \"frame0_1.jpg\"))\n\theight, width, layers = frame.shape\n\tfourcc = cv2.VideoWriter_fourcc(*'mp4v')\n\tvideo = cv2.VideoWriter(vid_path, fourcc, 20, (width,height))\n\tfor frame in range(nframes):\n\t\tvideo.write(cv2.imread(os.path.join(dirpath, \"frame%d_1.jpg\"%frame)))\n\tcv2.destroyAllWindows()\n\tvideo.release()\n\tshutil.rmtree(dirpath)\n\nif __name__ == '__main__':\n\targs = parse_args()\n\n\tcaffe.set_mode_cpu()\n\t#caffe.set_device(args.gpu)\n\n\t# Select desired model\n\tnet = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST)\n\n\t(H_in,W_in) = net.blobs['data_l'].data.shape[2:] # get input shape\n\t(H_out,W_out) = net.blobs['class8_ab'].data.shape[2:] # get output shape\n\n\tpts_in_hull = np.load('.\/resources\/pts_in_hull.npy') # load cluster centers\n\tnet.params['class8_ab'][0].data[:,:,0,0] = pts_in_hull.transpose((1,0)) # populate cluster centers as 1x1 convolution kernel\n\t# print 'Annealed-Mean Parameters populated'\n\n\tnframes, dirpath = readVideoFrames(args.vid_in)\n\tfor frame in range(nframes):\n\t\t# load the original image\n\t\timg_rgb = caffe.io.load_image(dirpath+(\"\/frame%d.jpg\"%frame))\n\n\t\timg_lab = color.rgb2lab(img_rgb) # convert image to lab color space\n\t\timg_l = img_lab[:,:,0] # pull out L channel\n\t\t(H_orig,W_orig) = img_rgb.shape[:2] # original image size\n\n\t\t# create grayscale version of image (just for displaying)\n\t\timg_lab_bw = img_lab.copy()\n\t\timg_lab_bw[:,:,1:] = 0\n\t\timg_rgb_bw = color.lab2rgb(img_lab_bw)\n\n\t\t# resize image to network input size\n\t\timg_rs = caffe.io.resize_image(img_rgb,(H_in,W_in)) # resize image to network input size\n\t\timg_lab_rs = color.rgb2lab(img_rs)\n\t\timg_l_rs = img_lab_rs[:,:,0]\n\n\t\tnet.blobs['data_l'].data[0,0,:,:] = img_l_rs-50 # subtract 50 for mean-centering\n\t\tnet.forward() # run network\n\n\t\tab_dec = net.blobs['class8_ab'].data[0,:,:,:].transpose((1,2,0)) # this is our result\n\t\tab_dec_us = sni.zoom(ab_dec,(1.*H_orig\/H_out,1.*W_orig\/W_out,1)) # upsample to match size of original image L\n\t\timg_lab_out = np.concatenate((img_l[:,:,np.newaxis],ab_dec_us),axis=2) # concatenate with original image L\n\t\timg_rgb_out = (255*np.clip(color.lab2rgb(img_lab_out),0,1)).astype('uint8') # convert back to rgb\n\n\t\tplt.imsave(dirpath+(\"\/frame%d_1.jpg\"%frame), img_rgb_out)\n\t\tprint(\"Processed %d out of %d frames\" % (frame+1, nframes))\n\tcreateVideoFromFrames(dirpath, args.vid_out, nframes)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_626","text":"from __future__ import division\n# <NAME>!\n__author__ = '<NAME>'\n\n# tpcf(dat, datR=None, randcatsize=2, bins,**kwargs)\n#\n# **kwargs for choosing geometry - metric 'flat' 'open' 'close'\n# **kwargs for choosing xi estimator - 'simple' 'ls' '...'\n# import fileios\n# from metrics.metrics import * # for pycharm remove comment - for pip installation etc. comment this line\nfrom tqdm import *\nfrom datprep import *\nimport numpy as np\nfrom metrics import *\nfrom multiprocessing import Process\nfrom multiprocessing.queues import Queue\nfrom sklearn.neighbors import BallTree\nfrom scipy.spatial import distance as dist\nimport matplotlib.pyplot as plt\n\n# pcpus = cpu_count()-1\n\n\ndef tpcf(datfile, bins, **kwargs):\n    \"\"\"Main function to calculate 2pCF. Takes multiple arguments such as randfile, maskfile, calculation estimator etc. for different geometry, cosmology models\n    Usage of the package is given in jupyter notebook \"Using correlcalc example.nb\" and in `main.py`\n\n    All the methods in correlcalc can be imported using the following command\n\n    `from correlcalc import *`\n\n    We first need to define bins (in $c\/H_0$ units) to calculate 2pCF. For e.g. to calculate correlation between 0-180Mpc in steps of 6Mpc, we say\n\n    `bins=np.arange(0.002,0.06,0.002)`\n\n    To calculate 2pCF using input data file (both ascii and fits files are supported), use `tpcf` method as follows\n\n    `correl, poserr=tpcf('\/path\/to\/datfile.dat',bins, randfile='\/path\/to\/randomfile.dat', weights='eq')`\n\n    If random file is not available or not provided, we can generate random catalog by providing the mangle mask file in `.ply` format along with specifying the size of the catalog in multiples of size of data catalog (default 2x size). To do this\n\n    `correl, poserr=tpcf('\/path\/to\/datfile.dat', bins, maskfile='\/path\/to\/maskfile.ply', weights=True, randfact=3)`\n\n    This returns `correl` and `poserr` `numpy` arrays corresponding to Two-point correlation and Poisson error\n\n    ### Keyword Arguments\n    The following keyword arguments can be included as needed\n\n    #### Data file (Mandatory)\n\n    Data file of galaxy\/quasar redshift survey must be passed as the first argument to both `tpcf` and `atpcf` methods.\n\n    **Supported filetypes**: ascii text files with columns, csv files or fits files are all supported. Most files provided by SDSS Value added catalogs should be directly usable.\n\n     **To contain**: Any type of file provided must at least have columns named **Z** (redshift), **RA** (Right Ascension), **DEC** (Declination). These column names can be in any case.\n\n     If one intends to use `weights=True` option (must to obtain accurate results) the data file must also contain radial weights with column title **radial_weight** or **WEIGHT_SYSTOT**\n\n    #### bins (Mandatory)\n\n    A numpy array with ascending values in $c\/H_0$ units must be provided as the second argument to both `tpcf` and `atpcf` methods. In case of `atpcf` it automatically creates 2D bins as `bins2d=(bins,bins)` from provided 1D `bins`\n\n    #### `randfile=` Path to random file (semi-Optional)\n\n    If not provided, `maskfile=` argument must be given `.ply` file.\n\n    **Supported filetypes**: ascii text files with columns, csv files or fits files are all supported. Most files provided by SDSS Value added catalogs should be directly usable.\n\n     **To contain**: Any type of file provided must at least have columns named **Z** (redshift), **RA** (Right Ascension), **DEC** (Declination). These column names can be in any case.\n\n     If one intends to use `weights=True` option (must to obtain accurate results) the data file must also contain radial weights with column title **radial_weight** or **WEIGHT_SYSTOT**\n\n     **Beta Testing:** Beta support for other column titles for weights is added.\n\n     Also added is calculation of weights from n(z) during random catalog generation.\n\n\n    #### `mask=` Path to mangle polygon file (semi-Optional)\n\n    If not provided, `randfile=` argument must be provided.\n\n    **Supported filetypes**: `.ply` file containing Mangle polygons describing survey geometry in the standard format. Most files provided by SDSS Value added catalogs should be directly usable.\n\n    #### `randfact=` (Optional)\n\n    Size of the random catalog in integer multiples of size of data catalog if random catalog file is not provided. Default value is `2`\n\n    #### `weights=` (Optional)\n\n    It is highly recommended to use weights argument by providing `weights=True` or `weights='eq'` to obtain accurate two-point correlation calculations. This picks up radial weights in the prescribed format (with column title **radial_weight** or **WEIGHT_SYSTOT** ) from the data and random files provided.\n\n    `weights=`eq'` sets equal weights and hence adds *+1* - This implementation is parallelized and is faster than `weights=False` implementation on most machines\n\n    If `weights=False`, by default *+1* will be added for each galaxy\/random pair found within the bin instead of adding total weight. For more details on weights and references, see http:\/\/www.sdss3.org\/dr9\/tutorials\/lss_galaxy.php\n\n    #### `geometry='flat'` (Optional)\n\n    **Available options**:\n\n    `'flat'`(default) - for flat geometry of the Universe\n\n     `'open'` - for Open Universe models like Milne\n\n     `'close'` - for Closed Universe\n\n     **Customization**\n\n     Formulae for calculation of distances between two points (Z1, RA1, DEC1) and (Z2, RA2, DEC2) is taken from *<NAME>, Correlation function in deep redshift space as a cosmological probe, The Astrophysical Journal 615 (2) (2004) 573*. Using the formulae in this paper, distances squares (to reduce additional computational time distance squares are calculated to avoid using expensive `sqrt` function every time) are computed in the `metrics.pyx` file for all the above mentioned geometries. `Cython` is chosen for implementation to obtain faster results in building `BallTree`s  calculating `cdist` and to reduce `query` time.\n\n     One can customize metric definitions as per one's need by editing this file. Also **K** (curvature parameter) in the formulae given in this reference need to be manually changed in the `metrics.pyx` for closed and open cases as per the model. After changing this compile it using `python metricsetup.py build_ext --inplace`\n\n    #### `cosmology='lcdm'` (Optional)\n\n    Used to calculate co-moving distances from redshifts.\n\n    **Available options**:\n\n    `'lcdm'` (default)- for Lambda CDM model\n\n     `'lc'` - for $R_h=ct$ and linear coasting models\n\n     **To add**: `wcdm` and other popular cosmology models soon\n\n    #### `estimator=` (Optional)\n\n    **Available options**:\n\n    `'dp'` - Davis - Peebles estimator (default - fastest)\n\n    `'ls'`- Landy - Szalay estimator\n\n    `'ph'` - Peebles- Hauser estimator\n\n    `'hew'` - Hewitt estimator\n\n    `'h'` - Hamilton estimator\n\n    For more details on estimator formulae see https:\/\/arxiv.org\/pdf\/1211.6211.pdf\n    \"\"\"\n    # Default function arguments\n    # weights = np.array([])\n    global dat\n    global datR\n    DD = DR = RD = RR = np.zeros(len(bins)-1)\n    weightsflag = True\n    useones = True\n    cosmology = 'lcdm'\n    geometry = 'flat'\n    metric = flatdistsq\n    randcatfact = 2\n    estimator = 'dp'\n    binsq = bins**2\n    randfile = None\n    maskfile = None\n\n    # Options for correl calculation estimators and cosmology models\n    elist = ['dp', 'ls', 'ph', 'hew', 'h']\n    clist = ['lcdm', 'lc'] # add wcdm\n\n    if kwargs is not None:\n        for key, value in kwargs.items():\n            # print (key, value)\n            # print (key, value)\n            if key.lower() == 'randfile':\n                randfile = value\n            elif key.lower() == 'randfact':\n                randcatfact = value\n            elif key.lower() == 'geometry':\n                if value.lower() == 'flat':\n                    geometry = 'flat'\n                    metric = flatdistsq\n                elif value.lower() == 'open':\n                    geometry = 'open'\n                    metric = opendistsq\n                elif value.lower() == 'close':\n                    geometry = 'close'\n                    metric = closedistsq\n                else:\n                    print(\"Incorrect geometry argument provided! Using flat geometry\")\n            elif key.lower() == 'estimator':\n                if value.lower() in elist:\n                    estimator = value.lower()\n                    print estimator\n                else:\n                    print(\"Incorrect estimator provided! Using 'dp' as default\")\n            elif key.lower() == 'cosmology':\n                if value.lower() in clist:\n                    cosmology = value.lower()\n                else:\n                    print(\"Incorrect Cosmology provided! Using 'lcdm' as default\")\n            elif key.lower() == 'mask':\n                maskfile = value\n            elif key.lower() == 'weights':\n                if value is True:\n                    weightsflag = True\n                    useones = False\n\n                    # fdat=readinfile(datfile,ftype='internal')\n                    # weights=1.0\/(1.0+4.0*np.array(fdat['nz']))\n                    # weights=weights\/np.mean(weights)\n                    # print (weights)\n                elif isinstance(value, str):\n                    if value.lower() == 'eq':\n                        weightsflag = True\n                        useones = True\n                else:\n                    weightsflag = False\n            else:\n                print (\"key argument `%s` not valid\" % key)\n    else:\n        print (\"Refer documentation to enter valid keyword arguments\")\n\n    print(\"Calculating Correlation function with the following parameters\")\n    print (\"data file=\")\n    print(datfile)\n    print(\"random file=\")\n    print(randfile)\n    print(\"Random catalog size factor(if random file is None)=\")\n    print(randcatfact)\n    print(\"mask\/window file=\")\n    print(maskfile)\n    print (\"Cosmology=\")\n    print(cosmology)\n    print(\"Geometry=\")\n    print(geometry)\n    print(\"Correl estimator=\")\n    print(estimator)\n    print (\"Weights=\")\n    print (weightsflag)\n    print (\"Using ones as weights?=\")\n    print (useones)\n    print(\"-----------------------------------------\")\n    # Prepare dat from data file\n    dat, weights = datprep(datfile, 'data', cosmology)\n    global Nd\n    Nd = len(dat)\n    # Nd = len(dat)\n    # print (weights)\n    # Prepare datR from random file or generate a random catalog\n    if randfile is None:\n        randcatsize = randcatfact*Nd\n        if maskfile is None:\n            print (\"Mask file compulsory. Please provide mask='maskfilepath.ply'\")\n        else:\n            # rweights = np.array([])\n            datR, rweights = randcatprep(datfile, randcatsize, maskfile, cosmology)\n            # randfile='.\/randcat.dat'\n            # datR, rweights=datprep(randfile,'random',cosmology)\n    else:\n        datR, rweights = datprep(randfile, 'random', cosmology)\n\n    # if len(weights)!=0:\n        # rfdat=readinfile(randfile,ftype='internal')\n        # rweights=1.0\/(1.0+4.0*np.array(rfdat['nz']))\n        # rweights=rweights\/np.mean(rweights)\n        # print (rweights)\n    # Nr=len(datR)\n\n    global Nr\n    Nr = len(datR)\n\n    fact = (1.0*Nr)\/Nd\n\n    # Creating module-wise global balltrees so that they don't have to be created many times.\n\n    global dbt\n    global rbt\n\n    print (\"Creating BallTree for data points using metric=\")\n    print (metric)\n    dbt = BallTree(dat, metric='pyfunc', func=metric)\n\n    print (\"Creating BallTree for random points using metric=\")\n    print (metric)\n    rbt = BallTree(datR, metric='pyfunc', func=metric)\n\n    print (\"Calculating 2pCF...\")\n    # f=(1.0*Nrd)\/N\n    # print (weights)\n    # Reference: arXiv: 1211.6211\n    if estimator == 'dp':\n        if weightsflag is False: # or len(weights) != Nd:\n            # print (weightsflag)\n            # print(len(weights))\n            # print(len(datR))\n            DD = DDcalc(dat, binsq)\n            DR = DRcalc(dat, binsq)\n            RD = RDcalc(datR, binsq)\n        else:\n            if useones is True or len(weights) != Nd:\n                weights = np.ones(Nd)\n                rweights = np.ones(Nr)\n            # if len(rweights)!=len(datR):\n            DD = DDwcalc(dat, binsq, metric, weights)\n            DR = DRwcalc(dat, datR, binsq, metric, rweights)\n            RD = RDwcalc(dat, datR, binsq, metric, weights)\n            # else:\n            #     DD=DDwcalc(dat,binsq,metric,weights)\n            #     DR=DRwcalc(dat,datR,binsq,metric,rweights)\n        print (\"Using Davis-Peebles estimator\")\n        correl = fact*(DD*2.0\/(DR+RD))-1.0\n\n    elif estimator == 'ph':\n        if weightsflag is False: # or len(weights) != Nd:\n            DD = DDcalc(dat, binsq)\n            RR = RRcalc(datR, binsq)\n        else:\n            if useones is True or len(weights) != Nd:\n                weights = np.ones(Nd)\n                rweights = np.ones(Nr)\n            DD = DDwcalc(dat, binsq, metric, weights)\n            if len(rweights) != Nr:\n                RR = RRcalc(datR, binsq)\n            else:\n                RR = RRwcalc(datR, binsq, metric, rweights)\n        print (\"Using Peebles-Hauser estimator\")\n        correl = fact**2*(DD\/RR)-1.0\n    else:\n        if weightsflag is False: # or len(weights) != Nd:\n            DD = DDcalc(dat, binsq)\n            RR = RRcalc(datR, binsq)\n            DR = DRcalc(dat, binsq)\n            RD = RDcalc(datR, binsq)\n        else:\n            if useones is True or len(weights) != Nd:\n                weights = np.ones(Nd)\n                rweights = np.ones(Nr)\n            DD = DDwcalc(dat, binsq, metric, weights)\n            DR = DRwcalc(dat, datR, binsq, metric, rweights)\n            RD = RDwcalc(dat, datR, binsq, metric, weights)\n            RR = RRwcalc(datR, binsq, metric, rweights)\n        if estimator == 'ls':\n            print (\"Using Landy-Szalay estimator\")\n            # correl = (DD-2.0*DR+RR)\/RR\n            correl = fact**2*(DD\/RR)-fact*(DR+RD)\/RR+1.0\n        elif estimator == 'hew':\n            print (\"Using Hewett estimator\")\n            correl = fact**2*(DD\/RR)-fact*0.5*(DR+RD)\/RR\n        elif estimator == 'h':\n            print (\"Using Hamilton estimator\")\n            correl = (4.0*DD*RR)\/(DR+RD)**2 - 1.0\n    correlerr = poserr(correl, DD)\n    print(\"Two-point correlation=\")\n    np.savetxt(\"DD_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", DD)\n    np.savetxt(\"DR_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", DR)\n    np.savetxt(\"RD_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", RD)\n    np.savetxt(\"RR_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", RR)\n    np.savetxt(\"bins_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", bins)\n    np.savetxt(\"tpcf_\"+str(cosmology)+\"_\"+str(geometry)+\"_\"+str(estimator)+\".txt\", (correl, correlerr))\n    print (correl, correlerr)\n    return correl, correlerr\n\n\ndef DDcalc(dat, bins):\n    print (\"Calculating DD...\\n DD=\")\n    DD = autocorr(dat, bins)\n    DD[DD == 0] = 1.0\n    # Nd = len(dat)\n    # DD = DD\/(Nd*(Nd-1.0))\n    print (DD)\n    return DD\n\n\ndef RRcalc(datR, bins):\n    print (\"Calculating RR...\\n RR=\")\n    RR = rautocorr(datR, bins)\n    RR[RR == 0] = 1.0\n    # Nr = len(datR)\n    # RR = RR\/(Nr*(Nr-1.0))\n    print (RR)\n    return RR\n\n\ndef DRcalc(dat, bins):\n    print (\"Calculating DR...\\n DR=\")\n    DR = crosscorr(dat, bins)\n    DR[DR == 0] = 1.0\n    # Nd = len(dat)\n    # Nr = len(datR)\n    # DR = DR\/(Nd*Nr)\n    print (DR\/2.0)\n    return DR\/2.0\n\ndef RDcalc(datR, bins):\n    print (\"Calculating RD...\\n RD=\")\n    RD = crosscorrd(datR, bins)\n    RD[RD == 0] = 1.0\n    # Nd = len(dat)\n    # Nr = len(datR)\n    # DR = DR\/(Nd*Nr)\n    print (RD\/2.0)\n    return RD\/2.0\n\n\ndef autocorr(dat, bins):\n    counts_DD = dbt.two_point_correlation(dat, bins)\n    DD = np.diff(counts_DD)\n    return DD\n\n\n# def autocorrp(dat, bins):\n#     pool = Pool(processes=pcpus)\n#     counts_DD = pool.map(dbt.two_point_correlation, (dat, bins))\n#     DD = np.diff(counts_DD)\n#     return DD\n\n\ndef rautocorr(datR, bins):\n    counts_RR = rbt.two_point_correlation(datR, bins)\n    RR = np.diff(counts_RR)\n    return RR\n\n\ndef crosscorr(dat, bins):\n    counts_DR = rbt.two_point_correlation(dat, bins)\n    DR = np.diff(counts_DR)\n    return 2.0*DR\n\n\ndef crosscorrd(datR, bins):\n    counts_RD = dbt.two_point_correlation(datR, bins)\n    RD = np.diff(counts_RD)\n    return 2.0*RD\n\n\ndef poserr(xi, DD):\n    print (\"Calculating Poisson error\")\n    return (1.0+xi)\/np.sqrt(DD)\n# alternatively\n# rbt=BallTree(dat,metric='pyfunc',func=metric)\n# counts_RD=rbt.two_point_correlation(dat,bins)\n\n\ndef DDwcalc(dat, bins, metric, weights):\n    print (\"Calculating DD with weights (parallelized)...\\n DD=\")\n    # DD = autocorrw(dat, bins, metric, weights)\n    # Nd = len(dat)\n    DD = multi_autocp(dat, bins, metric, weights, Nd, pcpus)\n    DD[DD == 0] = 1.0\n    # DD = DD\/(Nd*(Nd-1.0)) # factor of 2 cancels with 1\/2 that needs to be done to remove double counting of pairs\n    print (DD)\n    return DD\n\n\ndef RRwcalc(datR, bins, metric, rweights):\n    print (\"Calculating RR with weights (parallelized)...\\n RR=\")\n    # RR = autocorrw(datR, bins, metric, weights)\n    # Nr = len(datR)\n    RR = multi_autocpr(datR, bins, metric, rweights, Nr, pcpus)\n    RR[RR == 0] = 1.0\n    # RR = RR\/(Nr*(Nr-1.0))\n    print (RR)\n    return RR\n\n\ndef DRwcalc(dat, datR, bins, metric, rweights):\n    print (\"Calculating DR with weights (parallelized)...\\n DR=\")\n    # DR = crosscorrw(dat, datR, bins, metric, rweights)\n    # Nd = len(dat)\n    # Nr = len(datR)\n    # DR = multi_crosscp(dat, datR, bins, metric, rweights, Nd, pcpus)\n    DR = multi_crosscpdr(dat, datR, bins, metric, rweights, Nd, pcpus)\n    DR[DR == 0] = 1.0\n    # DR = DR\/(Nd*Nr)\n    print (DR\/2.0)\n    return DR\/2.0\n\n\ndef RDwcalc(dat, datR, bins, metric, weights):\n    print (\"Calculating RD with weights...\\n RD=\")\n    # DR = crosscorrwrd(dat, datR, bins, metric, weights)\n    # Nd = len(dat)\n    # Nr = len(datR)\n    DR = multi_crosscp(dat, datR, bins, metric, weights, Nr, pcpus)\n    DR[DR == 0] = 1.0\n    # DR = DR\/(Nd*Nr)\n    print (DR\/2.0)\n    return DR\/2.0\n\n\ndef autocorrw(dat, bins, metric, weights):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    DD = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    for i in tqdm(range(len(dat))):\n        ind = dbt.query_radius(dat[i].reshape(1, -1), binmax)\n        # wts=np.array([])\n        for j in ind:\n            # print (\"i j\")\n            # print (i, j)\n            # print (\"ind[ind>i]\")\n            # print (ind[ind>i])\n            dist0 = dist.cdist([dat[i], ], dat[j[j>i]], metric)[0]\n            DD += np.histogram(dist0, bins=bins, weights=weights[j[j>i]])[0]\n            # print (dist0,weights[j])\n    print(DD)\n    return DD\n\n\ndef crosscorrw(dat, datR, bins, metric, rweights):\n    # rbt = BallTree(datR, metric='pyfunc', func=metric)\n    DR = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    for i in tqdm(range(len(dat))):\n        ind = rbt.query_radius(dat[i].reshape(1, -1), binmax)\n        # wts=np.array([])\n        for j in ind:\n            dist0 = dist.cdist([dat[i], ], datR[j], metric)[0]\n            DR += np.histogram(dist0, bins=bins, weights=rweights[j])[0]\n            # print (dist0,weights[j])\n    return DR\n\n\ndef crosscorrwrd(dat, datR, bins, metric, weights):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    RD = np.zeros(len(bins)-1)\n    # p=multiprocessing.Pool(processes=multiprocessing.cpu_count())\n    # RD=p.map(rdcalc, range(len(datR)))\n    binmax = max(bins)\n    for i in tqdm(range(len(datR))):\n    # def rdcalc():\n        ind = dbt.query_radius(datR[i].reshape(1, -1), binmax)\n        #  wts=np.array([])\n        for j in ind:\n            dist0 = dist.cdist([datR[i], ], dat[j], metric)[0]\n            RD += np.histogram(dist0, bins=bins, weights=weights[j])[0]\n                # print (dist0,weights[j])\n            # return RD\n    print(RD)\n    return RD\n\n\ndef autocorrwp(dat, bins, metric, weights, rNd, multi=False, queue=0):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    DD = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    for i in tqdm(rNd):\n        ind = dbt.query_radius(dat[i].reshape(1, -1), binmax)\n        # wts=np.array([])\n        for j in ind:\n            # print (\"i j\")\n            # print (i, j)\n            # print (\"ind[ind>i]\")\n            # print (ind)\n            # print (ind[ind>i])\n            dist0 = dist.cdist([dat[i], ], dat[j[j>i]], metric)[0]\n            DD += np.histogram(dist0, bins=bins, weights=weights[j[j>i]])[0]\n            # print (dist0,weights[j])\n    if multi:\n        queue.put(DD)\n    else:\n        return DD\n    # print (DD)\n    return DD\n\n\ndef crosscorrwrdp(dat, datR, bins, metric, weights, rNr, multi=False, queue=0):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    RD = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    # p=multiprocessing.Pool(processes=multiprocessing.cpu_count())\n    # RD=p.map(rdcalc, range(len(datR)))\n    for i in tqdm(rNr):\n    # def rdcalc():\n        ind = dbt.query_radius(datR[i].reshape(1, -1), binmax)\n        #  wts=np.array([])\n        for j in ind:\n            dist0 = dist.cdist([datR[i], ], dat[j], metric)[0]\n            RD += np.histogram(dist0, bins=bins, weights=weights[j])[0]\n    if multi:\n        queue.put(RD)\n    else:\n        return RD\n    # print(RD)\n    return RD\n\n\ndef crosscorrwdrp(dat, datR, bins, metric, rweights, rNd, multi=False, queue=0):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    DR = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    # p=multiprocessing.Pool(processes=multiprocessing.cpu_count())\n    # RD=p.map(rdcalc, range(len(datR)))\n    for i in tqdm(rNd):\n    # def rdcalc():\n        ind = rbt.query_radius(dat[i].reshape(1, -1), binmax)\n        #  wts=np.array([])\n        for j in ind:\n            dist0 = dist.cdist([dat[i], ], datR[j], metric)[0]\n            DR += np.histogram(dist0, bins=bins, weights=rweights[j])[0]\n    if multi:\n        queue.put(DR)\n    else:\n        return DR\n    # print(RD)\n    return DR\n\ndef autocorrwpr(datR, bins, metric, rweights, rNr, multi=False, queue=0):\n    # dbt = BallTree(dat, metric='pyfunc', func=metric)\n    RR = np.zeros(len(bins)-1)\n    binmax = max(bins)\n    for i in tqdm(rNr):\n        ind = rbt.query_radius(datR[i].reshape(1, -1), binmax)\n        # print (ind)\n        # wts=np.array([])\n        for j in ind:\n            # print(\"i\")\n            # print (i)\n            # print (\"j\")\n            # print (j)\n            # print (\"j[j>i]\")\n            # print (j[j>i])\n            dist0 = dist.cdist([datR[i], ], datR[j[j>i]], metric)[0]\n            RR += np.histogram(dist0, bins=bins, weights=rweights[j[j>i]])[0]\n            # print (dist0,weights[j])\n    if multi:\n        queue.put(RR)\n    else:\n        return RR\n    # print (RR)\n    return RR\n\n\ndef multi_autocp(dat, bins, metric, weights, Nd, CORES=pcpus):\n\n    DD = np.zeros(len(bins)-1)\n    queues = [RetryQueue() for i in range(CORES)]\n    args = [(dat, bins, metric, weights, range(int(Nd*i\/CORES), int(Nd*(i+1)\/CORES)), True, queues[i]) for i in range(CORES)]\n    jobs = [Process(target=autocorrwp, args=(a)) for a in args]\n    for j in jobs: j.start()\n    for q in queues: DD += q.get()\n    for j in jobs: j.join()\n\n    return DD\n\n\ndef multi_autocpr(datR, bins, metric, rweights, Nr, CORES=pcpus):\n\n    RR = np.zeros(len(bins)-1)\n    queues = [RetryQueue() for i in range(CORES)]\n    args = [(datR, bins, metric, rweights, range(int(Nr*i\/CORES), int(Nr*(i+1)\/CORES)), True, queues[i]) for i in range(CORES)]\n    jobs = [Process(target=autocorrwpr, args=(a)) for a in args]\n    for j in jobs: j.start()\n    for q in queues: RR += q.get()\n    for j in jobs: j.join()\n\n    return RR\n\n\ndef multi_crosscp(dat, datR, bins, metric, weights, Nr, CORES=pcpus):\n\n    DR = np.zeros(len(bins)-1)\n    queues = [RetryQueue() for i in range(CORES)]\n    args = [(dat, datR, bins, metric, weights, range(int(Nr*i\/CORES), int(Nr*(i+1)\/CORES)), True, queues[i]) for i in range(CORES)]\n    jobs = [Process(target=crosscorrwrdp, args=(a)) for a in args]\n    for j in jobs: j.start()\n    for q in queues: DR += q.get()\n    for j in jobs: j.join()\n\n    return DR\n\n\ndef multi_crosscpdr(dat, datR, bins, metric, rweights, Nd, CORES=pcpus):\n\n    DR = np.zeros(len(bins)-1)\n    queues = [RetryQueue() for i in range(CORES)]\n    args = [(dat, datR, bins, metric, rweights, range(int(Nd*i\/CORES), int(Nd*(i+1)\/CORES)), True, queues[i]) for i in range(CORES)]\n    jobs = [Process(target=crosscorrwdrp, args=(a)) for a in args]\n    for j in jobs: j.start()\n    for q in queues: DR += q.get()\n    for j in jobs: j.join()\n\n    return DR\n\n\ndef retry_on_eintr(function, *args, **kw):\n    while True:\n        try:\n            return function(*args, **kw)\n        except IOError, e:\n            if e.errno == KeyboardInterrupt:\n                break\n            elif e.errno == errno.EINTR:\n                continue\n            else:\n                raise \"multiprocessing pooling queue error\", e\n\n\nclass RetryQueue(Queue):\n\n    def get(self, block=True, timeout=None):\n        return retry_on_eintr(Queue.get, self, block, timeout)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_627","text":"<gh_stars>1-10\n\"\"\"\nProcess Whole slide images and their respective annotations into .mat file as per the paper & related code from  \"HoVer-Net: Simultaneous Segmentation and Classification of Nuclei in Multi-Tissue Histology Images\"\n\n----------------------------------------------------------------------------------------------------\nEach ground truth file is stored as a .mat file, with the keys:\n'inst_map'\n'type_map'\n'inst_type'\n'inst_centroid'\n \n'inst_map' is a 1000x1000 array containing a unique integer for each individual nucleus. i.e the map ranges from 0 to N, where 0 is the background and N is the number of nuclei.\n\n'type_map' is a 1000x1000 array where each pixel value denotes the class of that pixel. The map ranges from 0 to 7, where 7 is the total number of classes in CoNSeP.\n\n\"\"\"\n\nimport os\nimport openslide\nfrom xml.dom import minidom\nimport numpy as np\nimport openslide\nfrom openslide import open_slide  \nfrom glob import glob\nimport cv2\nimport matplotlib.pyplot as plt\nimport scipy.io as sio\nfrom PIL import Image\nimport scipy\nimport scipy.ndimage\nfrom shapely.geometry import Polygon\nfrom skimage import draw\nimport xml.etree.ElementTree as ET\nimport argparse\nfrom misc.viz_utils import visualize_instances\n\ndef main(input_loc, output_loc):\n\n    # Read svs files from the desired path\n    count = 0\n    if(input_loc):\n        data_path = input_loc\n    else:\n        data_path = '\/usr\/local\/opt\/work\/hover_net_modified\/MoNuSAC' #Path to read data from\n    if(output_loc):\n        destination_path = output_loc # Path to save n-ary masks corresponding to xml files\n    else:\n        destination_path = '\/usr\/local\/opt\/work\/hover_net_modified\/'\n\n    os.chdir(destination_path)\n\n    # Create MoNuSAC folder\n    try:\n        os.mkdir(destination_path+'\/MoNuSAC_processed')\n    except OSError:\n        print (\"Creation of the mask directory %s failed\" % destination_path)\n    \n    # Create sub-folders in the same pattern as CoNSeP \n    # -- Images\n    # -- Labels\n    # -- Overlay\n    try:\n        os.mkdir(destination_path+'\/MoNuSAC_processed\/Images')\n    except OSError:\n        print (\"Creation of the mask directory %s failed\" % (destination_path + \"\\Images\"))\n    try:\n        os.mkdir(destination_path+'\/MoNuSAC_processed\/Labels')\n    except OSError:\n        print (\"Creation of the mask directory %s failed\" % (destination_path + \"\\Labels\"))\n    try:\n        os.mkdir(destination_path+'\/MoNuSAC_processed\/Overlay')\n    except OSError:\n        print (\"Creation of the mask directory %s failed\" % (destination_path + \"\\Overlay\"))\n\n    os.chdir(destination_path+'\/MoNuSAC_processed')#Create folder named as MoNuSAC_masks\n    patients = [x[0] for x in os.walk(data_path)]#Total patients in the data_path\n    print('No. of Patients: ',len(patients))\n\n    # Define Integer encoding for MoNuSAC classes (0:Background)\n    nuclei_type_dict = {\n            'Epithelial': 1, # ! Please ensure the matching ID is unique\n            'Lymphocyte': 2,\n            'Macrophage': 3,\n            'Neutrophil': 4,\n        }\n\n    for patient_loc in patients:\n        patient_name = patient_loc[len(data_path)+1:]#Patient name        \n        \"\"\"## To make patient's name directory in the destination folder\n        try:\n            os.mkdir(patient_name)\n        except OSError:\n            print (\"\\n Creation of the patient's directory %s failed\" % patient_name)\n        \"\"\"    \n        ## Read sub-images of each patient in the data path        \n        sub_images = glob(patient_loc+'\/*.svs')\n        for sub_image_loc in sub_images:\n\n            gt = 0\n            sub_image_name = sub_image_loc[len(data_path)+len(patient_name)+1:-4]        \n            print('File Name being processed:', sub_image_name)\n            \n            ## To make sub_image directory under the patient's folder\n            \"\"\"\n            sub_image = '.\/'+patient_name+'\/'+sub_image_name #Destination path\n            try:\n                os.mkdir(sub_image)\n            except OSError:\n                print (\"\\n Creation of the patient's directory %s failed\" % sub_image)\n            \"\"\"    \n            image_name = sub_image_loc\n            img = openslide.OpenSlide(image_name)\n                                    \n            # If svs image needs to save in png\n            cv2.imwrite(destination_path+'\/MoNuSAC_processed\/Images'+sub_image_name+'.png', np.array(img.read_region((0,0),0,img.level_dimensions[0])))      \n            #og_img = cv2.imread(destination_path+'\/MoNuSAC_processed\/Images'+sub_image_name+'.png')\n            #og_img = cv2.cvtColor(og_img, cv2.COLOR_BGR2RGB)\n\n            # Read xml file\n            xml_file_name  = image_name[:-4]\n            xml_file_name = xml_file_name+'.xml'\n            print('XML:',xml_file_name)\n            tree = ET.parse(xml_file_name)\n            root = tree.getroot()\n\n            n_ary_mask = np.transpose(np.zeros((img.read_region((0,0),0,img.level_dimensions[0]).size)))\n            type_map = np.transpose(np.zeros((img.read_region((0,0),0,img.level_dimensions[0]).size)))\n                          \n\n            #Generate n-ary mask for each cell-type                         \n            for k in range(len(root)):\n                label = [x.attrib['Name'] for x in root[k][0]]\n                label = label[0]\n                \n                for child in root[k]:\n                    for x in child:\n                        r = x.tag\n                        if r == 'Attribute':\n                            count = count+1\n                            print(count)\n                            label = x.attrib['Name']\n                            class_value = nuclei_type_dict[label]\n                            print(label,':',class_value)\n                            \n                            '''# Create directory for each label\n                            sub_path = sub_image+'\/'+label\n                            \n                            try:\n                                os.mkdir(sub_path)\n                            except OSError:\n                                print (\"Creation of the directory %s failed\" % label)\n                            else:\n                                print (\"Successfully created the directory %s \" % label) \n                            '''\n                            \n                        if r == 'Region':\n                            regions = []\n                            vertices = x[1]\n                            coords = np.zeros((len(vertices), 2))\n                            for i, vertex in enumerate(vertices):\n                                coords[i][0] = vertex.attrib['X']\n                                coords[i][1] = vertex.attrib['Y']        \n                            regions.append(coords)\n                            poly = Polygon(regions[0]) \n                            \n                            vertex_row_coords = regions[0][:,0]\n                            vertex_col_coords = regions[0][:,1]\n                            fill_row_coords, fill_col_coords = draw.polygon(vertex_col_coords, vertex_row_coords, n_ary_mask.shape)\n                            gt = gt+1 #Keep track of giving unique valu to each instance in an image\n                            n_ary_mask[fill_row_coords, fill_col_coords] = gt\n                            type_map[fill_row_coords, fill_col_coords] = class_value\n                            # Stack togethor the inst_map & type_map\n                            \n                            #nary_path = destination_path+'\/MoNuSAC_processed\/Labels'+sub_image_name+'_nary.tif'\n                            \n                            #overlay_path = destination_path+'\/MoNuSAC_processed\/Overlay'+sub_image_name+'.png'\n                            \n                            sio.savemat(destination_path+'\/MoNuSAC_processed\/Labels'+sub_image_name+\".mat\", {'inst_map':n_ary_mask,'class_map':type_map})\n                            #overlay_image = visualize_instances(type_map, canvas=None)\n                            #cv2.imwrite(overlay_path, overlay_image)\n                            #cv2.imwrite(class_path, type_map)       \n\n\nif __name__ == \"__main__\":\n\n    parser = argparse.ArgumentParser()\n    parser.add_argument('--input',help='MoNuSAC data location')\n    parser.add_argument('--output',help='MoNuSAC output location')\n    args = parser.parse_args()\n\n    main(args.input,args.output)\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_628","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun Nov 21 16:58:35 2021\n\n@author: pablobottero\n\"\"\"\n\nimport os\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport openpyxl\nfrom pandas.api.types import CategoricalDtype\nimport scipy.stats as stats\nimport seaborn as sns\n\nos.chdir('\/Users\/pablobottero\/github\/master\/python\/data_analysis\/tasks\/second_one\/')\n\n#Abrir fichero\nrank = pd.read_csv('billionaires_index.csv', sep=',', decimal=',')\nprint(rank.shape)\nrank\n\n#Obtener las personas de España de la lista\nrank[rank[\"Country\"] == \"Spain\"]\n\n#Crear un fichero con los 50 primeros para trabajar con ellos\nrank.head(50).to_csv(\"50b.csv\")\nbsl = pd.read_csv('50b.csv', sep=',', decimal=',') # Billionaire Sorted List\n\n#Agrupar valores por industria y país\nig = bsl['Industry'].value_counts()\ncg = bsl['Country'].value_counts()\n\nig.to_csv(\"industries.csv\")\ncg.to_csv(\"countries.csv\")\nbsl_ig = pd.read_csv('industries.csv', sep=',', decimal=',')\nbsl_cg = pd.read_csv('countries.csv', sep=',', decimal=',')\n\n#QC_done\n\n# Imprimir un gráfico con el listado de  billonarios por industria\nbsl.Industry.describe()\nplt.hist (bsl.Industry)\ni_table = pd.crosstab(index=bsl[\"Industry\"], columns=\"count\")\nn=i_table.sum()\ni_table2 = (i_table\/n)*100\nprint(i_table2)\nplt.bar((i_table.index), i_table['count'])\nplt.xlabel('Industries')\nplt.ylabel('%')\nplt.title('Figure 2. Percentaje of billionaires \\n by industry.')\nplt.savefig('grafica.svg')\nplt.show\n\n#QC_done\n\n# Imprimir un gráfico con el listado de  billonarios por pais\nbsl_cg.Country:Number.describe()\nplt.hist (bsl_cg.Country)\nc_table = pd.crosstab(index=bsl[\"Country\"], columns=\"count\")\nn=c_table.sum()\nc_table2 = (c_table\/n)*100\nprint(c_table2)\nplt.bar(c_table2.index, c_table2['count'])\nplt.xlabel('Industries')\nplt.ylabel('%')\nplt.title('Figure 1. Percentaje of billionaires \\n by industry.')\nplt.show\n\nprint(c_table.sort())\n-----------------------\n#Hacer graficos también por países\n#Analizar los porcentajes por país y por industria\n#Sacar el pocentaje de españoles en la lista completa\n#Obtener los porcentajes de ricos por país en comparación con la lista (500)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_629","text":"<reponame>reemagit\/flowcentrality\nimport pandas as pd\n#from MyPythonLibs3 import bio\nimport networkx as nx\nfrom tqdm.autonotebook import tqdm\nfrom concurrent.futures import ProcessPoolExecutor, as_completed\nimport numpy as np\nimport os\nfrom os.path import join, exists\nfrom scipy.stats import mannwhitneyu\nimport matplotlib.pyplot as plt\n\ndef create_gidmap():\n    from funcs.gidmap import GeneIDMap\n    gmap = GeneIDMap()\n    gmap.load_table('biomart', '..\/data\/gene_info_genenames.txt', col2idtype_map={'Approved symbol':'symbol','NCBI Gene ID':'entrez','Ensembl gene ID':'ensembl'})\n    #gmap.load_dict('ppi', ms.GENE_ID_CACHE_DATA)\n    return gmap\n\ngm = create_gidmap()\n\ndef read_gene_list(filepath):\n    return pd.read_csv(filepath, header=None)[0].tolist()\ndef write_gene_list(filepath, genelist):\n    pd.Series(genelist).to_csv(filepath, index=False, header=False)\ndef write_genesets_list(filepath, genesets):\n    np.savetxt(filepath, genesets, fmt='%d', delimiter='\\t')\ndef read_genesets_list(filepath):\n    return np.loadtxt(filepath, delimiter='\\t')\n\ndef read_network(filepath):\n    return nx.read_edgelist(filepath, nodetype=int, delimiter='\\t')\n\ndef read_flows(filepath):\n    return pd.read_csv(filepath,sep='\\t',index_col=0)\n\ndef read_paths(filepath):\n    with open(filepath, 'r') as f:\n        return [list(map(int,line.rstrip().split(','))) for line in f.readlines()]\ndef write_paths(filepath, paths):\n    with open(filepath, 'w') as f:\n        for path in paths:\n            f.write(','.join(map(str,path)) + '\\n')\n\ndef read_text(filepath):\n    with open(filepath, 'r') as f:\n        return [line.rstrip() for line in f.readlines()]\n\ndef write_text(filepath, lines):\n    with open(filepath, 'w') as f:\n        for line in lines:\n            f.write(line + '\\n')\n\ndef read_expr(filepath):\n    return pd.read_csv(filepath, sep='\\t',index_col='ENTREZ_GENE_ID')\n\ndef write_expr(filepath, expr):\n    expr.to_csv(filepath, sep='\\t')\n\n\ndef read_nonrectangular(filepath):\n    with open(filepath, 'r') as f:\n        return [list(map(float,line.rstrip().split(','))) for line in f.readlines()]\ndef write_nonrectangular(filepath, lines):\n    with open(filepath, 'w') as f:\n        for line in lines:\n            f.write(','.join(map(str,line)) + '\\n')\n\ndef read_config(filepath):\n    import yaml\n    with open(filepath, 'r') as stream:\n        try:\n            return yaml.safe_load(stream)\n        except yaml.YAMLError as exc:\n            print(exc)\n\ndef create_dir_if_not_exist(dirpath):\n    if not exists(dirpath):\n        os.makedirs(dirpath)\n\ndef parallel_process(function, array, n_jobs=None, use_kwargs=False, front_num=0, leave=True, mute=False):\n    \"\"\"\n        A parallel version of the map function with a progress bar.\n\n        Args:\n            array (array-like): An array to iterate over.\n            function (function): A python function to apply to the elements of array\n            n_jobs (int, default=16): The number of cores to use\n            use_kwargs (boolean, default=False): Whether to consider the elements of array as dictionaries of\n                keyword arguments to function\n            front_num (int, default=3): The number of iterations to run serially before kicking off the parallel job.\n                Useful for catching bugs\n        Returns:\n            [function(array[0]), function(array[1]), ...]\n    \"\"\"\n    bar_func = tqdm\n    if mute:\n        def identity(x, *args, **kwargs):\n            return x\n        bar_func = identity\n\n    front = []\n    #We run the first few iterations serially to catch bugs\n    if front_num > 0:\n        front = [function(**a) if use_kwargs else function(a) for a in array[:front_num]]\n    #If we set n_jobs to 1, just run a list comprehension. This is useful for benchmarking and debugging.\n    if n_jobs==1:\n        return front + [function(**a) if use_kwargs else function(a) for a in tqdm(array[front_num:])]\n    #Assemble the workers\n    with ProcessPoolExecutor(max_workers=n_jobs) as pool:\n        #Pass the elements of array into function\n        if use_kwargs:\n            futures = [pool.submit(function, **a) for a in array[front_num:]]\n        else:\n            futures = [pool.submit(function, a) for a in array[front_num:]]\n        kwargs = {\n            'total': len(futures),\n            'unit': 'it',\n            'unit_scale': True,\n            'leave': leave\n        }\n        #Print out the progress as tasks complete\n\n        for f in bar_func(as_completed(futures), **kwargs):\n            pass\n    out = []\n    #Get the results from the futures.\n    for i, future in bar_func(enumerate(futures)):\n        try:\n            out.append(future.result())\n        except Exception as e:\n            out.append(e)\n    return front + out\n\ndef pack_variables(list_var, *other_vars):\n    return [[elem]+list(other_vars) for elem in list_var]\n\ndef fisher_overlap(n_overlap, n1, n2, n_background):\n    import fisher\n    return fisher.pvalue(n_background - (n1 + n2 - n_overlap), n2 - n_overlap, n1 - n_overlap, n_overlap).right_tail\n\ndef fisher_overlap_set(set1, set2, background, check_consistency=True):\n    if check_consistency:\n        assert len(set1) == len(set(set1))\n        assert len(set2) == len(set(set2))\n        assert len(background) == len(set(background))\n        assert set(set1).issubset(set(background))\n        assert set(set2).issubset(set(background))\n    n_overlap = len(set(set1).intersection(set(set2)))\n    n1 = len(set1)\n    n2 = len(set2)\n    n_background = len(background)\n    return fisher_overlap(n_overlap=n_overlap, n1=n1, n2=n2, n_background=n_background)\n\ndef non_nan(arr):\n    arr = np.asarray(arr)\n    return arr[~np.isnan(arr)]\ndef mwpval(obs,rdm):\n    return mannwhitneyu(non_nan(obs),non_nan(rdm),alternative='greater').pvalue\n\ndef trim_text(string, maxchar=10):\n    if len(string) > maxchar:\n        return string[:maxchar-3] + '...'\n    return string\n\ndef plot_significances(data_list, pos_list = None, delta_ratio = 30, bounds=None, no_fliers=False):\n    if no_fliers:\n        def whiskmax(data):\n            iqr = np.percentile(data, 75) - np.percentile(data, 25)\n            return data[data <= np.percentile(data, 75) + 1.5 * iqr].max()\n        def whiskmin(data):\n            iqr = np.percentile(data, 75) - np.percentile(data, 25)\n            return data[data >= np.percentile(data, 25) - 1.5 * iqr].min()\n        min_ = min([whiskmin(non_nan(data)) for pair in data_list for data in pair])\n        max_ = max([whiskmax(non_nan(data)) for pair in data_list for data in pair])\n    else:\n        min_ = min([min(non_nan(data)) for pair in data_list for data in pair])\n        max_ = max([max(non_nan(data)) for pair in data_list for data in pair])\n    delta = (max_ - min_) \/ delta_ratio\n    offset = 0\n    if bounds is None:\n        bounds = [1e-10, 1e-4, 0.05]\n    bounds = [-np.inf] + bounds + [np.inf]\n    sigtexts = ['***','**','*','n.s.']\n    for pair,pos in zip(data_list, pos_list):\n        pval = mwpval(non_nan(pair[1]), non_nan(pair[0]))\n        sigtext = sigtexts[np.digitize(pval, bounds)-1]\n        x1,x2 = pos\n        y = max_+offset+delta\n        plt.plot([x1, x1, x2, x2], [y, y+delta, y+delta, y], lw=1., c='black')\n        plt.text((x1 + x2) * .5, y+delta, sigtext, ha='center', va='bottom', color='black')\n        offset += delta * 4\n    if plt.gca().get_ylim()[1] < max_ + offset + delta:\n        plt.gca().set_ylim([None, max_ + offset + 3*delta])\n\ndef plot_significances_paths(data_list, pos=None, delta_ratio = 30, no_fliers=False):\n    if pos is None:\n        pos = [1,2,3]\n    plot_significances([[data_list[1],data_list[2]], [data_list[0],data_list[2]]], [[pos[1],pos[2]],[pos[0],pos[2]]], delta_ratio = delta_ratio, no_fliers=no_fliers)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_631","text":"from scipy.fftpack import fft\nimport TicClassBgremover\nimport cv2\nimport numpy as np\nfrom PIL import Image\n\nbr=TicClassBgremover.bgremover()\ndevice='cuda'\n\nprint('start...')\nsize=256\nmodel = br.load_model(device=device)\nfimg, bimg = br.load_img(file_img='.\/dataset\/demo\/3.jpg',size=size)\nprint('mask ......')\nPILbg = br.square_pad(bimg, 0)\nPILbg = PILbg.resize((size, size), Image.ANTIALIAS)\ncap = cv2.VideoCapture(0)\n\nwhile 1:\n    ret, frame = cap.read() #读取\n    # img = cv2.cvtColor(np.asarray(frame), cv2.COLOR_RGB2BGR)\n    ff=Image.fromarray(cv2.cvtColor(frame,cv2.COLOR_BGR2RGB))\n    PILimage = br.square_pad(ff, 0)\n    PILimage = PILimage.resize((size, size), Image.ANTIALIAS)\n    \n    y=br.ai(PILimage, model, device=device)\n    pp,p=br.ai_mask(y)\n        \n    fPil,blendPil=br.ai_blend(PILimage, PILbg,pp)\n    imgp = cv2.cvtColor(np.asarray(blendPil), cv2.COLOR_RGB2BGR)\n\n    cv2.imshow(\"capture\", imgp) #显示\n    if cv2.waitKey(10) & 0xff == ord('q'): #按q退出\n        break\n    \n    \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_632","text":"import numpy as np\nfrom scipy.stats import rankdata\nfrom sklearn.base import BaseEstimator, TransformerMixin\n\nfrom julia import Julia\nJulia(compiled_modules=False)\nfrom julia import Relief as Relief_jl\nfrom skrelief.relieff import Relieff\n\n\nclass TuRF(BaseEstimator, TransformerMixin):\n    \"\"\"sklearn compatible implementation of the TuRF algorithm.\n\n    Reference:\n        <NAME> and <NAME>. Tuning ReliefF for genome-wide\n        genetic analysis. In <NAME>, <NAME>, and <NAME>.\n        Rajapakse, editors, Evolutionary Computation,Machine Learning and\n        Data Mining in Bioinformatics, pages 166–175. Springer, 2007.\n\n    Args:\n        n_features_to_select (int): number of features to select from dataset.\n        num_it (int): number of iterations.\n        rba (object): feature weighting algorithm wrapped by the VLSRelief algorithm. If equal\n        to None, the default ReliefF RBA implemented in Julia is used.\n\n    Attributes:\n        n_features_to_select (int): number of features to select from dataset.\n        num_it (int): number of iterations.\n        _rba (object): feature weighting algorithm wrapped by the TuRF algorithm.\n    \"\"\"\n   \n    def __init__(self, n_features_to_select=10, num_it=10, rba=None):\n        self.n_features_to_select = n_features_to_select\n        self.num_it = num_it\n        self._rba = rba\n\n\n    def fit(self, data, target):\n        \"\"\"\n        Rank features using TuRF feature selection algorithm\n\n        Args:\n            data (numpy.ndarray): matrix of data samples\n            target (numpy.ndarray): vector of target values of samples\n\n        Returns:\n            (object): reference to self\n        \"\"\"\n\n        # Compute feature weights and rank.\n        if self._rba is not None:\n            self.weights = Relief_jl.turf(data, target, self.num_it, self.rba_wrap)\n        else:\n            self.weights = Relief_jl.turf(data, target, self.num_it)\n        self.rank = rankdata(-self.weights, method='ordinal')\n        \n        # Return reference to self.\n        return self\n\n\n    def transform(self, data):\n        \"\"\"\n        Perform feature selection using computed feature ranks.\n\n        Args:\n            data (numpy.ndarray): matrix of data samples on which to perform feature selection.\n\n        Returns:\n            (numpy.ndarray): result of performing feature selection.\n        \"\"\"\n\n        # select n_features_to_select best features and return selected features.\n        msk = self.rank <= self.n_features_to_select  # Compute mask.\n        return data[:, msk]  # Perform feature selection.\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_633","text":"<filename>aurora\/pipelines\/time_series_helpers.py\nimport scipy.signal as ssig\n\nfrom aurora.time_series.windowing_scheme import WindowingScheme\n\n\ndef validate_sample_rate(run_ts, config):\n    if run_ts.sample_rate != config.sample_rate:\n        print(\n            f\"sample rate in run time series {run_ts.sample_rate} and \"\n            f\"processing config {config.sample_rate} do not match\"\n        )\n        raise Exception\n    return\n\n\ndef apply_prewhitening(config, run_xrts_input):\n    if config[\"prewhitening_type\"] == \"first difference\":\n        run_xrts = run_xrts_input.diff(\"time\")\n    else:\n        run_xrts = run_xrts_input\n    return run_xrts\n\n\ndef apply_recoloring(config, stft_obj):\n    if config[\"prewhitening_type\"] == \"first difference\":\n        from aurora.time_series.frequency_domain_helpers import get_fft_harmonics\n        from numpy import pi\n\n        freqs = get_fft_harmonics(config.num_samples_window, config.sample_rate)\n        prewhitening_correction = 1.0j * 2 * pi * freqs  # jw\n        stft_obj \/= prewhitening_correction\n    return stft_obj\n\n\ndef run_ts_to_stft_scipy(config, run_xrts_orig):\n    \"\"\"\n    Parameters\n    ----------\n    config\n    run_xrts\n\n    Returns\n    -------\n\n    \"\"\"\n    import xarray as xr\n\n    run_xrts = apply_prewhitening(config, run_xrts_orig)\n\n    windowing_scheme = WindowingScheme(\n        taper_family=config.taper_family,\n        num_samples_window=config.num_samples_window,\n        num_samples_overlap=config.num_samples_overlap,\n        taper_additional_args=config.taper_additional_args,\n        sample_rate=config.sample_rate,\n    )\n    # stft_obj = run_xrts.copy(deep=True)\n    stft_obj = xr.Dataset()\n    for channel_id in run_xrts.data_vars:\n        ff, tt, specgm = ssig.spectrogram(\n            run_xrts[channel_id].data,\n            fs=config.sample_rate,\n            window=windowing_scheme.taper,\n            nperseg=config.num_samples_window,\n            noverlap=config.num_samples_overlap,\n            detrend=\"linear\",\n            scaling=\"density\",\n            mode=\"complex\",\n        )\n\n        # drop Nyquist>\n        ff = ff[:-1]\n        specgm = specgm[:-1, :]\n\n        import numpy as np\n\n        specgm *= np.sqrt(2)\n\n        # make time_axis\n        tt = tt - tt[0]\n        tt *= config.sample_rate\n        time_axis = run_xrts.time.data[tt.astype(int)]\n\n        xrd = xr.DataArray(\n            specgm.T,\n            dims=[\"time\", \"frequency\"],\n            coords={\"frequency\": ff, \"time\": time_axis},\n        )\n        stft_obj.update({channel_id: xrd})\n\n    stft_obj = apply_recoloring(config, stft_obj)\n\n    return stft_obj\n\n\ndef run_ts_to_stft(config, run_xrts_orig):\n    \"\"\"\n\n    Parameters\n    ----------\n    config : ShortTimeFourierTransformConfig object\n    run_ts ; xarray.core.dataset.Dataset, normally extracted from mth5.RunTS\n\n    Returns\n    -------\n\n    \"\"\"\n    from aurora.time_series.windowed_time_series import WindowedTimeSeries\n\n    windowing_scheme = WindowingScheme(\n        taper_family=config.taper_family,\n        num_samples_window=config.num_samples_window,\n        num_samples_overlap=config.num_samples_overlap,\n        taper_additional_args=config.taper_additional_args,\n        sample_rate=config.sample_rate,\n    )\n\n    run_xrts = apply_prewhitening(config, run_xrts_orig)\n\n    windowed_obj = windowing_scheme.apply_sliding_window(\n        run_xrts, dt=1.0 \/ config.sample_rate\n    )\n    windowed_obj = WindowedTimeSeries.detrend(data=windowed_obj, detrend_type=\"linear\")\n\n    tapered_obj = windowed_obj * windowing_scheme.taper\n    # stft_obj = WindowedTimeSeries.apply_stft(data=tapered_obj,\n    #                                          sample_rate=windowing_scheme.sample_rate,\n    #                                          detrend_type=\"linear\",\n    # scale_factor=windowing_scheme.linear_spectral_density_calibration_factor)\n\n    stft_obj = windowing_scheme.apply_fft(\n        tapered_obj, detrend_type=config.extra_pre_fft_detrend_type\n    )\n    stft_obj = apply_recoloring(config, stft_obj)\n\n    return stft_obj\n\n\ndef run_ts_to_calibrated_stft(run_ts, run_obj, config, units=\"MT\"):\n    \"\"\"\n    Parameters\n    ----------\n    run_ts\n    run_obj\n    config\n    units\n\n    Returns\n    -------\n\n    \"\"\"\n    stft_obj = run_ts_to_stft(config, run_ts.dataset)\n    stft_obj = calibrate_stft_obj(stft_obj, run_obj, units=units)\n\n    return stft_obj\n\n\ndef calibrate_stft_obj(stft_obj, run_obj, units=\"MT\", channel_scale_factors=None):\n    \"\"\"\n\n    Parameters\n    ----------\n    stft_obj\n    run_obj\n    units\n    scale_factors : dict\n        keyed by channel, supports a single scalar to apply to that channels data\n        Useful for debugging.  Should not be used in production and should throw a\n        warning if it is not None\n\n    Returns\n    -------\n\n    \"\"\"\n    for channel_id in stft_obj.keys():\n        mth5_channel = run_obj.get_channel(channel_id)\n        channel_filter = mth5_channel.channel_response_filter\n        if not channel_filter.filters_list:\n            print(\"WARNING UNEXPECTED CHANNEL WITH NO FILTERS\")\n            if channel_id == \"hy\":\n                channel_filter = run_obj.get_channel(\"hx\").channel_response_filter\n        calibration_response = channel_filter.complex_response(stft_obj.frequency.data)\n        if channel_scale_factors:\n            try:\n                channel_scale_factor = channel_scale_factors[channel_id]\n            except KeyError:\n                channel_scale_factor = 1.0\n            calibration_response \/= channel_scale_factor\n        if units == \"SI\":\n            print(\"Warning: SI Units are not robustly supported issue #36\")\n\n        stft_obj[channel_id].data \/= calibration_response\n    return stft_obj\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_634","text":"import tensorflow as tf\nimport numpy as np\nimport random\nimport cv2\nimport os\nimport matplotlib.pyplot as plt\nimport pickle\nfrom scipy import misc\nimport math\n\nimport config as cfg\nfrom resnet import *\nfrom input_fn import Data\n#np.random.seed(1)\n#tf.set_random_seed(1)\n#random.seed(1)\n\nbatch_size = cfg.BATCH_SIZE\nkeep_prob = 0.8\nregular_weight = 0.001\n\ndef get_sess():\n    tf_config = tf.ConfigProto()\n    tf_config.gpu_options.allow_growth = True\n    return tf.Session(config=tf_config)\n\ndef get_img2(pic0):\n    input_pics = []\n    y_data = []\n    y_rank = []\n    for p in pic0:\n        pic_name, ppl = p\n        im = cv2.imread(os.path.join(cfg.FILE_PATH, pic_name))\n        im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)\n        im = cv2.resize(im, (cfg.IMG_SIZE, cfg.IMG_SIZE))\n        input_pics.append(im)\n        y_data.append(ppl)\n        y_rank.append(math.floor(ppl+2.5))\n        \n    input_pics = np.reshape(input_pics, (-1, cfg.IMG_SIZE, cfg.IMG_SIZE, 3))\n    y_data = np.reshape(y_data, (-1, 1))\n    y_rank = np.reshape(y_rank, (-1))\n    return input_pics, y_data, y_rank\n\ndata = Data()\n\n# Preprocessing\ninput_shape = (batch_size, cfg.IMG_SIZE, cfg.IMG_SIZE, 3)\nimgs0 = tf.placeholder(tf.uint8, shape=[batch_size, cfg.IMG_SIZE, cfg.IMG_SIZE, 3])\nbatch_imgs = []\nfor i in range(imgs0.shape[0]):\n    image = imgs0[i]\n    height = cfg.IMG_SIZE\n    width = cfg.IMG_SIZE\n    with tf.name_scope('eval_image', [image, height, width]):\n        if image.dtype != tf.float32:\n            image = tf.image.convert_image_dtype(image, dtype=tf.float32)\n        if height and width:\n            image = tf.div(image, 255.0)\n            image = tf.expand_dims(image,0)\n            if i == 0:\n                batch_imgs = image\n            else:\n                batch_imgs = tf.concat([batch_imgs, image], 0)\n        images = batch_imgs\n\n# Initialize\ny_value = tf.placeholder(dtype=tf.float32, shape=[batch_size,1])\nis_train = tf.placeholder(tf.bool, name=\"is_train\")\n\narg_scope = resnet_arg_scope(weight_decay=regular_weight,\n                     batch_norm_decay=0.9,\n                     batch_norm_epsilon=1e-5,\n                     batch_norm_scale=True,\n                     activation_fn=tf.nn.relu,\n                     use_batch_norm=True)\n                     \n# ResNet\nwith slim.arg_scope(arg_scope):\n    net, end_points = resnet_v2_50(images, is_training=is_train)\n\n# Final Conv\nwith slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d]):\n    with tf.variable_scope('Logits_out'):\n        # (12 x 12) x 2048 \n        net = slim.avg_pool2d(net, kernel_size=[4, 4], stride=4, padding='VALID', scope='AvgPool_7x7')\n        # 3 x 3 x 256\n        net = slim.conv2d(net, 1, [3, 3], activation_fn=None, padding='VALID', weights_regularizer=slim.l2_regularizer(regular_weight), scope='Last_conv')\n        # 1 x 1 x 1\n        net = tf.squeeze(net, [1, 2], name='SpatialSqueeze')\n\n# Variable To Train and Restore \ncheckpoint_exclude_scopes = \"Logits_out\"\nexclusions = []\nif checkpoint_exclude_scopes:\n    exclusions = [scope.strip() for scope in checkpoint_exclude_scopes.split(',')]\nprint (exclusions)\nvariables_to_restore = []\nvariables_to_train = []\nfor var in slim.get_model_variables():\n    excluded = False\n    print(var.op.name)\n    for exclusion in exclusions:\n        if var.op.name.startswith(exclusion):\n            excluded = True\n            variables_to_train.append(var)\n            print (\"ok\")\n            print (var.op.name)\n            break\n    if not excluded:\n        variables_to_restore.append(var)\n\n# file = '.\/output\/LOG_res_e4_pre.txt'\nepoch = 1800\nwith get_sess() as sess:\n    tf.logging.info(\"Creating the model...\")\n    sess.run(tf.global_variables_initializer())\n    saver2 = tf.train.Saver(tf.global_variables(), max_to_keep=5)\n    saver2.restore(sess, '.\/savenet\/loss_128_ave1_pre_e4\/loss_128_ave1_pre_e4-%s'%epoch)\n    \n    ############## test set in study cities #################\n    city_names = ['Beijing', 'Guangzhou', 'Shanghai', 'Harbin', 'Kunming', 'Wuhan', 'Lasa', 'Lanzhou']\n    for city_name in city_names:\n        print(city_name)\n        test_file = open('.\/output\/loss_128_ave1_pre_e4\/test_%s_%s.txt'%(epoch, city_name),'w')\n        train_city_data = data.generate_train_city_data(city_name)\n        l = len(train_city_data)\n        for k in range(l):\n            test_input_pics, test_y_data, test_name = data.obtain_train_city_data(k)\n            # test acc\n            pred = sess.run(net, feed_dict={imgs0:test_input_pics, y_value:test_y_data, is_train:False})\n\n            test_file.write(\"####### step:%d >> pic_name: %s >> real_value: %s >> pred: %s\\n\"%(k,test_name[0], test_y_data[0][0], pred[0][0]))\n            \n    ############## additional test cities ##################\n    # Shenyang, Jinan, Tianjin, Shijiazhuang, Hefei, Changsha, Nanchang, Shenzhen, Luoyang, Dalian\n    city_names = [['Shenyang',12315,12364,4170,4194]] # [[city, min_lon, max_lon, min_lat, max_lat]]\n    for city_name in city_names:\n        print(city_name)\n        test_file = open('.\/output\/loss_128_ave1_pre_e4\/test_%s_%s.txt'%(epoch, city_name[0]),'w')\n        test_city_key = data.generate_test_city_data(file='.\/data\/%s.txt'%city_name[0], lon1=city_name[1], lon2=city_name[2], lat1=city_name[3], lat2=city_name[4])\n        l = len(test_city_key)\n        for k in range(l):\n            test_input_pics, test_y_data, test_name = data.obtain_test_city_data(k)\n            \n            # test acc\n            pred = sess.run(net, feed_dict={imgs0:test_input_pics, y_value:test_y_data, is_train:False})\n            test_file.write(\"####### step:%d >> pic_name: %s >> real_value: %s >> pred: %s\\n\"%(k,test_name[0], test_y_data[0][0], pred[0][0]))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_635","text":"from scipy.signal import butter, lfilter\nimport numpy as np\nfrom librosa.core.time_frequency import mel_frequencies\nimport warnings\n\n\ndef butter_bandpass(lowcut, highcut, fs, order=3):\n    nyq = 0.5 * fs\n    low = lowcut \/ nyq\n    high = highcut \/ nyq\n    b, a = butter(order, [low, high], btype=\"band\")\n    return b, a\n\n\ndef butter_bandpass_filter(data, lowcut, highcut, fs, order=3):\n    if highcut > int(fs \/ 2):\n        warnings.warn(\"Highcut is too high for bandpass filter. Setting to nyquist\")\n        highcut = int(fs \/ 2)\n    b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n    y = lfilter(b, a, data)\n    return y\n\n\ndef window_rms(a, window_size):\n    a2 = np.power(a, 2)\n    window = np.ones(window_size) \/ float(window_size)\n    return np.sqrt(np.convolve(a2, window, \"valid\"))\n\n\ndef RMS(data, rate, rms_stride, rms_window, rms_padding, noise_thresh):\n    \"\"\"\n    Take data, run and RMS filter over it\n    \"\"\"\n\n    # we compute root mean squared over a window, where we stride by rms_stride seconds for speed\n    rms_data = window_rms(\n        data.astype(\"float32\")[:: int(rms_stride * rate)],\n        int(rate * rms_window * rms_stride),\n    )\n    rms_data = rms_data \/ np.max(rms_data)\n\n    # convolve a block filter over RMS, then threshold it, so to call everything with RMS > noise_threshold noise\n    block_filter = np.ones(int(rms_padding * rms_stride * rate))  # create our filter\n\n    # pad the data to be filtered\n    rms_threshed = np.concatenate(\n        (\n            np.zeros(int(len(block_filter) \/ 2)),\n            np.array(rms_data > noise_thresh),\n            np.zeros(int(len(block_filter) \/ 2)),\n        )\n    )\n    # convolve on our filter\n    sound_threshed = np.array(np.convolve(rms_threshed, block_filter, \"valid\") > 0)[\n        : len(rms_data)\n    ]\n\n    return rms_data, sound_threshed\n\n\nimport sys\nimport os\n\n\ndef prepare_mel_matrix(hparams, rate, return_numpy=True, GPU_backend=False):\n    \"\"\" Create mel filter\n    \"\"\"\n    # import tensorflow if needed\n    if \"tf\" not in sys.modules:\n        if not GPU_backend:\n            os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"  # see issue #152\n            os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n        import tensorflow as tf\n        tf.enable_eager_execution()\n        assert tf.executing_eagerly()\n\n    # create a filter to convolve with the spectrogram\n    mel_matrix = tf.signal.linear_to_mel_weight_matrix(\n        num_mel_bins=hparams.num_mel_bins,\n        num_spectrogram_bins=int(hparams.n_fft \/ 2) + 1,\n        sample_rate=rate,\n        lower_edge_hertz=hparams.mel_lower_edge_hertz,\n        upper_edge_hertz=hparams.mel_upper_edge_hertz,\n        dtype=tf.dtypes.float32,\n        name=None,\n    )\n\n    # gets the center frequencies of mel bands\n    mel_f = mel_frequencies(\n        n_mels=hparams.num_mel_bins + 2,\n        fmin=hparams.mel_lower_edge_hertz,\n        fmax=hparams.mel_upper_edge_hertz,\n    )\n\n    # Slaney-style mel is scaled to be approx constant energy per channel (from librosa)\n    enorm = tf.dtypes.cast(\n        tf.expand_dims(\n            tf.constant(\n                2.0\n                \/ (mel_f[2 : hparams.num_mel_bins + 2] - mel_f[: hparams.num_mel_bins])\n            ),\n            0,\n        ),\n        tf.float32,\n    )\n\n    mel_matrix = tf.multiply(mel_matrix, enorm)\n    mel_matrix = tf.divide(mel_matrix, tf.reduce_sum(mel_matrix, axis=0))\n    if return_numpy:\n        return mel_matrix.numpy()\n    else:\n        return mel_matrix\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_637","text":"#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\nimport numpy as np\n\nfrom scipy.fftpack import dct\nfrom collections import deque\n\n\nclass MFCCKaldi:\n    '''\n    TODO port Kaldi mfcc to Python. Use similar parameters as\n    in suggested in __init__ function\n    '''\n\n    def __init__(self, sourcerate=16000, framesize=512,\n                 usehamming=True, preemcoef=0.97,\n                 numchans=26, ceplifter=22, numceps=12,\n                 enormalise=True, zmeansource=True, usepower=True, usec0=True,\n                 usecmn=False, usedelta=True, useacc=True, n_last_frames=0,\n                 lofreq=125, hifreq=3800, mel_banks_only=False):\n        self.sourcerate = sourcerate\n        self.framesize = framesize\n        self.usehamming = usehamming\n        self.preemcoef = preemcoef\n        self.numchans = numchans\n        self.ceplifter = ceplifter\n        self.enormalise = enormalise\n        self.zmeansource = zmeansource\n        self.usepower = usepower\n        self.usec0 = usec0\n        self.usecmn = usecmn\n        self.usedelta = usedelta\n        self.useacc = useacc\n        self.numceps = numceps\n        self.lofreq = lofreq\n        self.hifreq = hifreq\n        self.mel_banks_only = mel_banks_only\n\n    def param(self, frame):\n        \"\"\"Compute the MFCC coefficients in a way similar to the HTK.\"\"\"\n\n\nclass MFCCFrontEnd:\n    \"\"\"This is an a CLOSE approximation of MFCC coefficients computed by the HTK.\n\n    The frame size should be a number of power of 2.\n\n    TODO: CMN is not implemented. It should normalise only teh cepstrum, not the delta or acc coefficients.\n\n    It was not tested to give exactly the same results the HTK. As a result,\n    it should not be used in conjunction with models trained on speech\n    parametrised with the HTK.\n\n    Over all it appears that this implementation of MFCC is worse than the one from the HTK.\n    On the VAD task, the HTK features score 90.8% and the this features scores only 88.7%.\n    \"\"\"\n\n    def __init__(self, sourcerate=16000, framesize=512,\n                 usehamming=True, preemcoef=0.97,\n                 numchans=26, ceplifter=22, numceps=12,\n                 enormalise=True, zmeansource=True, usepower=True, usec0=True, usecmn=False,\n                 usedelta=True, useacc=True, n_last_frames = 0,\n                 lofreq=125, hifreq=3800, mel_banks_only = False):\n        self.sourcerate = sourcerate\n        self.framesize = framesize\n        self.usehamming = usehamming\n        self.preemcoef = preemcoef\n        self.numchans = numchans\n        self.ceplifter = ceplifter\n        self.enormalise = enormalise\n        self.zmeansource = zmeansource\n        self.usepower = usepower\n        self.usec0 = usec0\n        self.usecmn = usecmn\n        self.usedelta = usedelta\n        self.useacc = useacc\n        self.numceps = numceps\n        self.lofreq = lofreq\n        self.hifreq = hifreq\n        self.mel_banks_only = mel_banks_only\n\n        self.prior = 0.0\n\n        self.n_last_frames = n_last_frames\n        self.mfcc_queue = deque(maxlen=4 + n_last_frames)\n        self.mfcc_delta_queue = deque(maxlen=4 + n_last_frames)\n\n        self.init_hamming()\n        self.init_mel_filter_bank()\n        self.init_cep_liftering_weights()\n\n    def freq_to_mel(self, freq):\n        return 1127 * np.log(1.0 + freq \/ 700.0)\n\n    def mel_to_freq(self, mel):\n        return 700 * (np.exp(mel \/ 1127) - 1.0)\n\n    def init_hamming(self):\n        self.hamming = np.hamming(self.framesize)\n\n    def init_mel_filter_bank(self):\n        \"\"\"Initialise the triangular mel freq filters.\"\"\"\n\n        minMel = self.freq_to_mel(self.lofreq)\n        maxMel = self.freq_to_mel(self.hifreq)\n\n#    print \"MM\", minMel, \"MM\", maxMel\n\n        # Create a matrix for triangular filters, one row per filter\n        filterMatrix = np.zeros((self.numchans, self.framesize \/ 2 + 1))\n\n        melRange = np.array(xrange(self.numchans + 2))\n#    print \"MR\", melRange\n\n        melCenterFilters = melRange * (maxMel - minMel) \/ (\n            self.numchans + 1) + minMel\n#    print \"MCF\", melCenterFilters\n\n        dfreq = self.sourcerate \/ self.framesize\n        # each array index represent the center of each triangular filter\n        centerIndex = np.array(\n            np.round(self.mel_to_freq(melCenterFilters) \/ dfreq), int)\n#    print \"CI\", centerIndex\n\n        for i in xrange(self.numchans):\n            start, centre, end = centerIndex[i:i + 3]\n            k1 = np.float32(centre - start)\n            k2 = np.float32(end - centre)\n            up = (np.array(xrange(start, centre)) - start) \/ k1\n            down = (end - np.array(xrange(centre, end))) \/ k2\n\n            filterMatrix[i][start:centre] = up\n            filterMatrix[i][centre:end] = down\n\n        self.mel_filter_bank = filterMatrix.transpose()\n#    print \"SMFB\", self.mel_filter_bank.shape\n\n    def init_cep_liftering_weights(self):\n        cep_lift_weights = np.zeros((self.numceps, ))\n        a = np.pi \/ self.ceplifter\n        b = self.ceplifter \/ 2.0\n        for i in range(self.numceps):\n            cep_lift_weights[i] = 1.0 + b * np.sin(i * a)\n\n        self.cep_lift_weights = cep_lift_weights\n\n    def preemphasis(self, frame):\n        out_frame = np.zeros_like(frame)\n        out_frame[0] = frame[0] - self.preemcoef * self.prior\n        for i in range(1, len(frame)):\n            out_frame[i] = frame[i] - self.preemcoef * frame[i - 1]\n\n        self.prior = frame[-1]\n\n        return out_frame\n\n    def param(self, frame):\n        \"\"\"Compute the MFCC coefficients in a way similar to the HTK.\"\"\"\n        # zero mean\n        if self.zmeansource:\n            frame = frame - np.mean(frame)\n        # preemphasis\n        frame = self.preemphasis(frame)\n        # apply hamming window\n        if self.usehamming:\n            frame = self.hamming * frame\n\n        complex_spectrum = np.fft.rfft(frame)\n#    print \"LCS\", len(complex_spectrum)\n        power_spectrum = complex_spectrum.real * complex_spectrum.real + \\\n            complex_spectrum.imag * complex_spectrum.imag\n        # compute only power spectrum if required\n        if not self.usepower:\n            power_spectrum = np.sqrt(power_spectrum)\n\n#    print \"SPS\",power_spectrum.shape\n        mel_spectrum = np.dot(power_spectrum, self.mel_filter_bank)\n        # apply mel floor\n        for i in range(len(mel_spectrum)):\n            if mel_spectrum[i] < 1.0:\n                mel_spectrum[i] = 1.0\n        mel_spectrum = np.log(mel_spectrum)\n        \n        if self.mel_banks_only:\n            mfcc = mel_spectrum\n            self.mfcc_queue.append(mel_spectrum)\n        else:\n            cepstrum = dct(mel_spectrum, type=2, norm='ortho')\n            c0 = cepstrum[0]\n            htk_cepstrum = cepstrum[1:self.numceps + 1]\n            # cepstral liftering\n            cep_lift_mfcc = self.cep_lift_weights * htk_cepstrum\n\n            if self.usec0:\n                mfcc = np.append(cep_lift_mfcc, c0)\n            else:\n                mfcc = cep_lift_mfcc\n\n            # compute delta and acceleration coefficients if requested\n            self.mfcc_queue.append(mfcc)\n\n#        print len(self.mfcc_queue)\n\n            if self.usedelta:\n#      print \"LMQ\", len(self.mfcc_queue)\n                if len(self.mfcc_queue) >= 2:\n                    delta = np.zeros_like(mfcc)\n                    for i in range(1, len(self.mfcc_queue)):\n                        delta += self.mfcc_queue[i] - self.mfcc_queue[i - 1]\n                    delta \/= len(self.mfcc_queue) - 1\n\n                    self.mfcc_delta_queue.append(delta)\n                else:\n                    delta = np.zeros_like(mfcc)\n\n            if self.useacc:\n                if len(self.mfcc_delta_queue) >= 2:\n                    acc = np.zeros_like(mfcc)\n                    for i in range(1, len(self.mfcc_delta_queue)):\n                        acc += self.mfcc_delta_queue[i] - \\\n                            self.mfcc_delta_queue[i - 1]\n                    acc \/= len(self.mfcc_delta_queue) - 1\n                else:\n                    acc = np.zeros_like(mfcc)\n\n            if self.usedelta:\n                mfcc = np.append(mfcc, delta)\n            if self.useacc:\n                mfcc = np.append(mfcc, acc)\n\n        for i in range(self.n_last_frames):\n            if len(self.mfcc_queue) > i + 1 :\n                mfcc = np.append(mfcc, self.mfcc_queue[-1-i-1])\n            else:\n                mfcc = np.append(mfcc, np.zeros_like(self.mfcc_queue[-1]))\n\n        return mfcc.astype(np.float32)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_638","text":"'''\nCalculate single-category modularity correlations with a given performance\nmetric. You can enter your own files or try our defaults! Note that\nwe recommend using csv files, as this script reads data using csv.\n'''\n\n# imports\nimport csv\nimport argparse\nfrom scipy.stats import spearmanr as sr\n\n# process command-line arguments\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--modularity_file\",\n    help = \"name of file with modularity scores, columns = categories,\"\n            + \"1st row = column headers, no row headers\",\n    default = \"data\/3_2.csv\")\nparser.add_argument(\"--metrics_file\",\n    help = \"name of file with task performance metrics, 1 column, no headers,\"\n            + \"assuming length aligns with modularity_file\",\n    default = \"movies_accuracy.csv\")\nparser.add_argument(\"--out_file\",\n    help = \"name of file to write correlation to, if desired\",\n    default = \"out.txt\")\nargs = parser.parse_args()\n\n# scores: stores modularity scores - outer key = k, inner key = level\nscores = {}\n\n# reading in modularity data\nwith open(args.modularity_file, newline = \"\") as csvfile:\n    reader = csv.reader(csvfile)\n    rows = [row for row in reader]\n    for i in range(len(rows[0])):\n        scores[rows[0][i]] = [float(score[i]) for score in rows[1:]]\n\nmetric = []\n\n# reading in performance data, assuming 1-column list w\/ no header\nwith open(args.metrics_file, \"r\") as csvfile:\n    reader = csv.reader(csvfile)\n    rows = [row for row in reader]\n    for i in range(len(rows)):\n        metric.append(float(rows[i][0]))\n\n# writes results to a file, separates columns by commas\nwith open(args.out_file, \"w\") as o:\n    o.write(\"category,correlation\\n\") # column headers\n    for cat in scores.keys():\n        o.write(cat + \",\" + str(sr(scores[cat], metric).correlation) + \"\\n\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_630","text":"<reponame>guochunhe\/Vitis-AI\n# Copyright 2019 Xilinx Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport os\nfrom skimage import io\nimport cv2\nfrom scipy.spatial.distance import cdist \nimport argparse\n\nimport torch.nn.functional as F \nfrom network.resnet18 import Resnet18\nfrom network.resnet_small import Resnetsmall\nfrom ipdb import set_trace\n\n\ndef load_reid_model(net_name, model_path):\n    '''\n    function to load my trained reid model\n    '''\n    assert net_name == 'facereid_small' or net_name == 'facereid_large'\n    if net_name == 'facereid_small': \n        net = Resnetsmall()\n    else:\n        net = Resnet18()\n\n    checkpoint = torch.load(model_path)\n    pretrain_dict = checkpoint['state_dict']\n    model_dict = net.state_dict()\n    for i in pretrain_dict:\n        if 'classifier' in i or 'fc' in i:  continue\n        net.state_dict()[i].copy_(pretrain_dict[i])\n    net = net.cuda()\n    net.eval()\n    return net \n\ndef im_preprocess(image):\n    image = np.asarray(image, np.float32)\n    image \/=255.0\n    image -= np.array([0.485, 0.456, 0.406]).reshape(1, 1, -1)\n    image \/= np.array([0.229, 0.224, 0.225]).reshape(1, 1, -1)\n    image = np.transpose(image, [2,0,1]) # data format: hwc->chw\n    return image\n\ndef parse_args():\n    parser = argparse.ArgumentParser(description='FaceReid demo')\n    parser.add_argument('--data_dir', default = '..\/data\/test_imgs\/', help='directory to test data')\n    parser.add_argument('--network', choices=['facereid_small', 'facereid_large'],\n                        help='set network, choose from [facereid_small, facereid_large] ')\n    parser.add_argument('--model_path', required=True, help='path to model')\n    args = parser.parse_args()\n    return args\n\n\nif __name__ == '__main__':\n    args = parse_args()\n    img_dir = args.data_dir\n    query = ['1.jpg']\n    gallery = ['2.jpg',\n                '3.jpg',\n                '4.jpg',\n                '5.jpg',\n                '6.jpg',\n                '7.jpg']\n    img_list = query + gallery\n\n    resize_wh = 80 if args.network == 'facereid_small' else 96\n        \n    imgs = [io.imread(os.path.join(img_dir, imgname)) for imgname in img_list]\n    imgs = np.asarray([im_preprocess(cv2.resize(p, (resize_wh, resize_wh))) for p in imgs], dtype=np.float32)\n    reid_model = load_reid_model(args.network, args.model_path)\n    print('[INFO] Load model: {}, model path: {}'.format(args.network, args.model_path))\n\n    with torch.no_grad():\n        im_var = Variable(torch.from_numpy(imgs))\n        im_var = im_var.cuda()\n        feats = F.normalize(reid_model(im_var)).cpu()\n    \n    q_feats = feats[:len(query)]\n    g_feats = feats[len(query):]\n    distmat = cdist(q_feats, g_feats)\n    print('[INFO] Query-gallery-distance matrix: \\n  ', distmat)\n        \n    for i in range(len(query)):\n        g_idx = np.where(distmat[i]==np.min(distmat[i]))[0][0]\n        print('[INFO] Link query image {} with gallery image {} as same id'.format(query[i], gallery[g_idx]))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_636","text":"import logging\nfrom fractions import Fraction\nfrom contextlib import contextmanager\nimport pexpect\nfrom crl.interactivesessions.shells.terminalclient import TerminalComm\n\n\n__copyright__ = 'Copyright (C) 2019, Nokia'\n\n\nLOGGER = logging.getLogger(__name__)\n\n\nclass LostStrComm(object):\n\n    def __init__(self, probability_of_lost, modifier=None):\n        self._count = 0\n        self._probability_of_lost = probability_of_lost\n        self._modifier = modifier or self._default_modifier\n        self._strcomm = None\n        self._write_empty = False\n        self._in_lost_context = False\n\n    @staticmethod\n    def _default_modifier(*_):\n        return b''\n\n    @contextmanager\n    def in_lost(self):\n        self._in_lost_context = True\n        try:\n            yield None\n        finally:\n            self._in_lost_context = False\n\n    def set_strcomm(self, strcomm):\n        self._strcomm = strcomm\n\n    @property\n    def comm(self):\n        return self._strcomm.comm\n\n    def write_str(self, s):\n        self._strcomm.comm.clear()\n        self._strcomm.write_str(s)\n        written = self._strcomm.comm.written\n        new_written = self._modified_s(written)\n        if new_written or self._write_empty:\n            LOGGER.debug('===== writing: %s', repr(new_written))\n            self._strcomm.comm.write_direct(new_written)\n\n    def read_str(self):\n        ret = self._strcomm.read_str()\n        modified_ret = self._modified_s(ret)\n        LOGGER.debug('==== Received: %s, is lost: %d', ret, not modified_ret)\n        LOGGER.debug('==== Modified return %s', modified_ret)\n        if not modified_ret:\n            raise pexpect.TIMEOUT('==== Message is lost: {!r}'.format(ret))\n\n        return ret\n\n    def _modified_s(self, s):\n        if self._is_msg_lost():\n            new_s = self._modifier(s)\n            LOGGER.debug('==== Msg modified, count=%s, s=%s, new_s=%s',\n                         self._count, s, repr(new_s))\n            s = new_s\n        else:\n            LOGGER.debug('==== Msg success, count=%s, %s', self._count, s)\n        return s\n\n    def _is_msg_lost(self):\n        p = Fraction(self._probability_of_lost)\n        ret = self._count % p.denominator < p.numerator and self._in_lost_context\n        self._count += 1\n        if ret:\n            LOGGER.debug('==== message LOST')\n        else:\n            LOGGER.debug('==== message SUCCESS')\n        return ret\n\n\nclass CustomTerminalComm(TerminalComm):\n    def __init__(self, *args, **kwargs):\n        super(CustomTerminalComm, self).__init__(*args, **kwargs)\n        self._written = b''\n\n    @property\n    def written(self):\n        return self._written\n\n    def clear(self):\n        self._written = b''\n\n    def _write(self, s):\n        self._written += s\n\n    def write_direct(self, s):\n        super(CustomTerminalComm, self)._write(s)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_639","text":"<filename>se-1st-phot-function.py\n# 1st photometry\n# estimate FWHM value and auto mag zp\nimport os\nimport glob\nimport astropy.io.fits as fits\nimport numpy as np\nimport subprocess\nfrom sys import flags\nfrom astropy.table import Table\nfrom astropy.stats import sigma_clip\nfrom astropy.stats import sigma_clipped_stats\nfrom astropy.stats import sigma_clipping\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport astropy.io.ascii as ascii\nfrom scipy.interpolate import UnivariateSpline\nfrom multiprocessing import Process,Pool\n\n# growth curve fit to estimate optimal aperture size\n\ndef puthdr(inim, hdrkey, hdrval, hdrcomment=''):\n\tfrom astropy.io import fits\n\thdr = fits.getheader(inim)\n\tfits.setval(inim, hdrkey, value=hdrval, comment=hdrcomment)\n\tcomment = inim+'\\t'+'('+hdrkey+'\\t'+str(hdrval)+')'\n\ndef pixelscale(i):\n\tcd11 = fits.getheader(i)['CD1_1']\n\tcd12 = fits.getheader(i)['CD1_2']\n\tcd21 = fits.getheader(i)['CD2_1']\n\tcd22 = fits.getheader(i)['CD2_2']\n\tpixscale = round(np.sqrt(cd11**2 + cd21**2) * 3600, 4)\n\tputhdr(i, 'PSCALE', round(pixscale, 3))\n\t# print('Pixel scale =', pixscale,'\\\"')\n\treturn pixscale\n\n\n# input files, config and params\nseconfigdir = '\/data7\/cschoi\/code\/cspy\/sex.config\/'\nseconfig = 'se1.sex'\nseparam = 'se1.param'\ngrowthparam = 'growth.param'\nseparam_noPSF = 'se1_noPSF.param'\nseconv = 'default.conv'\nsennw = 'default.nnw'\nDETECT_MINAREA = str(5)\nDETECT_THRESH = str(3)\nDEBLEND_NTHRESH = str(32)\nDEBLEND_MINCONT = str(0.005)\n\n\ndef segrowthcom(im, psf=False):\n\tPSCALE = pixelscale(im)\n\tfn = os.path.splitext(im)[0]\n\taper_list=[s for s in range(1,51)]\n\taper_input = ''\n\tfor i in aper_list: aper_input += '{},'.format(i,1)\n\taper_input = aper_input[:-1]\n\topt1 = seconfigdir+seconfig+' -CATALOG_TYPE ASCII_HEAD -CATALOG_NAME ' + fn+'.growth'\n\topt2=' -FILTER_NAME '+seconfigdir+seconv +' -STARNNW_NAME '+seconfigdir+sennw\n\t#opt2a = ' -PARAMETERS_NAME '+seconfigdir+separam\n\t#opt2b = ' -PARAMETERS_NAME '+seconfigdir+separam_noPSF\n\topt2b = ' -PARAMETERS_NAME '+seconfigdir+growthparam\n\topt2 = ' -FILTER_NAME '+seconfigdir+seconv + ' -STARNNW_NAME '+seconfigdir+sennw\n\topt3 = ' -DETECT_MINAREA ' + DETECT_MINAREA + ' -DETECT_THRESH '+DETECT_THRESH\n\topt4 = ' -DEBLEND_NTHRESH ' + DEBLEND_NTHRESH + \\\n\t    ' -DEBLEND_MINCONT ' + DEBLEND_MINCONT\n\topt5=' -CHECKIMAGE_TYPE NONE '\n\topt6 = ' -PHOT_APERTURES '+aper_input+' '\n\topt7 = ' -PSF_NAME '+fn+'.psf '\n\topt8 = ' -PIXEL_SCALE '+str(PSCALE)+' '\n\tsecommand = 'sex -c '+opt1+opt2+opt2b+opt3+opt4+opt5+opt6+opt8 + im\n\tprint(secommand)\n\tsexout = subprocess.getoutput(secommand)\n\tline = [s for s in sexout.split('\\n') if 'RMS' in s]\n\tskymed = float(line[0].split('Background:')[1].split('RMS:')[0])\n\tskysig= float(line[0].split('RMS:')[1].split('\/')[0])\n\tos.system(secommand)\n\treturn skymed, skysig\n\ndef fwhm_img(im,mtbl1):\n\tfwhm_img=sigma_clipped_stats(mtbl1['FWHM_IMAGE'], sigma=3, maxiters=10)\n\tfiltered_data=sigma_clip(mtbl1['FWHM_IMAGE'],sigma=3,maxiters=10)\n\tselected, nonselected= ~filtered_data.mask, filtered_data.mask\n\tprint('FWHM_IMAGE','{}'.format(round(fwhm_img[0],3)),\n\t\tlen(mtbl1[selected]),'stars from',len(mtbl1))\n\tputhdr(im, 'FWHM_PIX', round(fwhm_img[0],3), hdrcomment='FWHM PIXEL VALUE')\n\treturn round(fwhm_img[0],3)\n\ndef find_opt_aper(im):\n\tskymed, skysig=segrowthcom(im)\n\tfn=os.path.splitext(im)[0]\n\tgrowthcat=ascii.read(fn+'.growth')\n\taper = np.linspace(1,50,50)\n\t# catalog cleaning\n\tidx= np.where( (growthcat['FLAGS']==0) &\n            (growthcat['SNR_WIN']>100) &\n            (growthcat['MAGERR_AUTO']<0.1)\n        \t)\n\tmcat=growthcat[idx]\n\t# signal to noise ratio\n\tfwhm=fwhm_img(im,mcat)\n\tplt.plot(np.ones(len(mcat))*aper[0],mcat['FLUX_APER']\/mcat['FLUXERR_APER'],'k.')\n\tfor q in aper[:-1]:\n\t\tp=int(q)\n\t\tplt.plot(np.ones(len(mcat))*aper[p],mcat['FLUX_APER_'+str(p)]\/mcat['FLUXERR_APER_'+str(p)],'k.')\n\t# mean values\n\tplt.plot(aper[0],np.mean(mcat['FLUX_APER']\/mcat['FLUXERR_APER']),'bo')\n\tfor q in aper[:-1]:\n\t\tp=int(q)\n\t\tplt.plot(aper[p],np.mean(mcat['FLUX_APER_'+str(p)]\/mcat['FLUXERR_APER_'+str(p)]),'bo')\n\t# plt.plot(np.ones(len(mcat))*0,mcat['FLUX_PSF']\/mcat['FLUXERR_PSF'],'ro')\n\t# mcat['FLUX_AUTO']\/mcat['FLUXERR_AUTO']\n\t# plt.vlines(fwhm*1.5, 0,10000)\n\t# curve fitting\n\tsnrval=[0]\n\tsnrval[0]=np.mean(mcat['FLUX_APER']\/mcat['FLUXERR_APER'])\n\tfor q in aper[:-1]:\n\t\tp=int(q)\n\t\tsnrval.append(np.mean(mcat['FLUX_APER_'+str(p)]\/mcat['FLUXERR_APER_'+str(p)]))\n\tsarr=sarr=np.asarray(snrval)\n\tsarr1=sarr[~np.isnan(sarr)]\n\taper1=aper[~np.isnan(sarr)]\n\ts = UnivariateSpline(aper1, sarr1, s=1)\n\tx=np.linspace(1,50,500)\n\tys = s(x)\n\tidx_opt=np.where(ys==np.max(ys))\n\tplt.plot(x,ys)\n\tplt.vlines(x[idx_opt],0,10000)\n\tplt.title(fn+' '+'optimal ap size')\n\tplt.xlabel('aperture size (pixel)')\n\tplt.ylabel('SNR (FLUX \/ FLUX err)')\n\tplt.savefig(fn+'_growth.png')\n\tplt.close()\n\tos.system('rm '+fn+'.growth')\n\tprint('Optimal aperture',round(x[idx_opt][0],2))\n\treturn skymed, skysig, fwhm, round(x[idx_opt][0],2)\n# first maximum\ndef opt_ap_fwhm(im):\n\tskyval, skysig,fwhm,opt_ap=find_opt_aper(im)\n\tputhdr(im, 'SKYVAL', skyval,\n\t\thdrcomment='sky median value form sextractor')\n\tputhdr(im, 'SKYSIG', skysig,\n\t\thdrcomment='sky sigma value form sextractor')\n\tputhdr(im, 'FWHM_PIX', round(fwhm,3), hdrcomment='FWHM PIXEL VALUE')\n\tputhdr(im, 'OPT_AP', opt_ap, hdrcomment='Optimal aperture size')\n\treturn skyval, skysig,fwhm,opt_ap\n\n\ndef fwhm_img(im,mtbl1):\n\tfwhm_img=sigma_clipped_stats(mtbl1['FWHM_IMAGE'], sigma=3, maxiters=10)\n\tfiltered_data=sigma_clip(mtbl1['FWHM_IMAGE'],sigma=3,maxiters=10)\n\tselected, nonselected= ~filtered_data.mask, filtered_data.mask\n\tprint('FWHM_IMAGE','{}'.format(round(fwhm_img[0],3)),\n\t\tlen(mtbl1[selected]),'stars from',len(mtbl1))\n\tputhdr(im, 'FWHM_PIX', round(fwhm_img[0],3), hdrcomment='FWHM PIXEL VALUE')\n\tputhdr(im, 'NUM_FWHM', len(mtbl1[selected]), hdrcomment='Number of stars for FHWM estimate')\n\treturn round(fwhm_img[0],3)\n\n# input files, config and params\nseconfigdir ='\/data7\/cschoi\/code\/cspy\/sex.config\/'\nseconfig    ='se1.sex'\nseparam     ='se1.param'\nseparam_noPSF = 'se1_noPSF.param'\ngrowthparam = 'growth.param'\nseconv      ='default.conv'\nsennw       ='default.nnw'\nDETECT_MINAREA = str(5)\nDETECT_THRESH  = str(3)\nDEBLEND_NTHRESH = str(32)\nDEBLEND_MINCONT = str(0.005)\nlowmag=13\nhighmag=19\nfilname,filerr='R','Rerr'\nmagtypes=['MAG_AUTO', 'MAG_PSF',\n\t\t'MAG_APER','MAG_APER_1','MAG_APER_2',\n\t\t'MAG_APER_3','MAG_APER_4','MAG_APER_5','MAG_APER_6','MAG_APER_7',\n\t\t'MAG_APER_8']\nmagtype=magtypes[0]\n#refcat='..\/..\/ps1-Tonry-NGC3367.cat'\n# source extractor command\npsf=True\ndef secom(im,psf=psf):\n    #PSCALE=fits.getheader(i)['PSCALE']\n\tPSCALE=pixelscale(im)\n\tskyval, skysig,fwhm,opt_ap=opt_ap_fwhm(im)\n\taper_list,aper_list2=[3,5,7],[1.0*fwhm, 1.5*fwhm, 2.0*fwhm, 2.5*fwhm, 3.0*fwhm, opt_ap]\n\taper_input = ''\n\tfor i in aper_list: aper_input += '{},'.format(round(i\/PSCALE,1))\n\tfor i in aper_list2: aper_input += '{},'.format(round(i,1))\n\taper_input = aper_input[:-1]\n\tfn = os.path.splitext(im)[0]\n\topt1= seconfigdir+seconfig+' -CATALOG_TYPE ASCII_HEAD -CATALOG_NAME '+ fn+'.se1'\n\topt2a=' -PARAMETERS_NAME '+seconfigdir+separam\n\topt2b= ' -PARAMETERS_NAME '+seconfigdir+separam_noPSF\n\topt2=' -FILTER_NAME '+seconfigdir+seconv +' -STARNNW_NAME '+seconfigdir+sennw\n\topt3=' -DETECT_MINAREA '+ DETECT_MINAREA + ' -DETECT_THRESH '+DETECT_THRESH\n\topt4=' -DEBLEND_NTHRESH '+ DEBLEND_NTHRESH +' -DEBLEND_MINCONT '+ DEBLEND_MINCONT\n\topt5=' -CHECKIMAGE_TYPE SEGMENTATION,APERTURES ' +\\\n\t \t\t' -CHECKIMAGE_NAME '+fn+'_seg.fits'+','+fn+'_ap.fits'\n\topt5=' -CHECKIMAGE_TYPE NONE '\n\topt6=' -PHOT_APERTURES '+aper_input+' '\n\topt7=' -PSF_NAME '+fn+'.psf '\n\topt8=' -PIXEL_SCALE '+str(PSCALE)+' '\n\topt9=' -SEEING_FWHM '+str(round(PSCALE*fwhm,3))+' '\n\tif psf==True:\n\t\tsecommand= 'sex -c '+opt1+opt2+opt2a+opt3+opt4+opt5+opt6+opt7+opt8+opt9 +im\n\telse:\n\t\tsecommand= 'sex -c '+opt1+opt2+opt2b+opt3+opt4+opt5+opt6+opt8+opt9 +im\n\tprint(secommand)\n\t#sexout = subprocess.getoutput(secommand)\n\t#line = [s for s in sexout.split('\\n') if 'RMS' in s]\n\t#skymed, skysig = float(line[0].split('Background:')[1].split('RMS:')[0]), float(line[0].split('RMS:')[1].split('\/')[0])\n\tos.system(secommand)\n\treturn skyval, skysig\n\n#macthing\ndef matching(intbl, reftbl, inra, indec, refra, refdec, sep=2.0):\n    \"\"\"\n    MATCHING TWO CATALOG WITH RA, Dec COORD. WITH python\n    INPUT   :   SE catalog, SDSS catalog file name, sepertation [arcsec]\n    OUTPUT  :   MATCED CATALOG FILE & TABLE\n    \"\"\"\n    import numpy as np\n    import astropy.units as u\n    from astropy.table import Table, Column\n    from astropy.coordinates import SkyCoord\n    from astropy.io import ascii\n    incoord     = SkyCoord(inra, indec, unit=(u.deg, u.deg))\n    refcoord    = SkyCoord(refra, refdec, unit=(u.deg, u.deg))\n    #   INDEX FOR REF.TABLE\n    indx, d2d, d3d  = incoord.match_to_catalog_sky(refcoord)\n    mreftbl         = reftbl[indx]\n    mreftbl['sep']  = d2d\n    mergetbl        = intbl\n    for col in mreftbl.colnames:\n        mergetbl[col]   = mreftbl[col]\n    indx_sep        = np.where(mergetbl['sep']*3600.<sep)\n    mtbl            = mergetbl[indx_sep]\n    #mtbl.write(mergename, format='ascii', overwrite=True)\n    return mtbl\n\ndef limitmag(N, zp, aper, skysigma):\t\t\t# 3? 5?, zp, diameter [pixel], skysigma\n\timport numpy as np\n\tR           = float(aper)\/2.\t\t\t\t# to radius\n\tbraket      = N*skysigma*np.sqrt(np.pi*(R**2))\n\tupperlimit  = float(zp)-2.5*np.log10(braket)\n\treturn round(upperlimit, 3)\n\ndef starcut(mtbl,lowmag=lowmag,highmag=highmag,filname=filname,magtype=magtype):\n\tidx=np.where( (mtbl['SNR_WIN'] >10) &\n\t\t\t\t(mtbl['FLAGS'] == 0) &\n\t\t\t\t(mtbl[filname] < highmag) &\n\t\t\t\t(mtbl[filname] > lowmag) &\n\t\t\t\t(mtbl[magtype[:3]+'ERR'+magtype[3:]]<0.5)\t\t)\n\treturn mtbl[idx]\n\n#zp calculation\nmagtypes=['MAG_AUTO', 'MAG_PSF',\n\t\t'MAG_APER','MAG_APER_1','MAG_APER_2',\n\t\t'MAG_APER_3','MAG_APER_4','MAG_APER_5','MAG_APER_6','MAG_APER_7',\n\t\t'MAG_APER_8']\n\ndef zpcal(mtbl1,filname, magtype):\n    zp=mtbl1[filname]-mtbl1[magtype]\n    #zp3=sigma_clipped_stats(zp, sigma=3, maxiters=10)\n    zp2=sigma_clipped_stats(zp, sigma=2, maxiters=10)\n    print ('zp ',zp2[0], 'zp err',zp2[2])\n    filtered_data=sigma_clip(zp,sigma=2,maxiters=10)\n    selected, nonselected= ~filtered_data.mask, filtered_data.mask\n    zperrp=np.sqrt( np.sum(mtbl1[filerr][selected]**2 + \\\n\t\t\t\t\t\tmtbl1[magtype[:3]+'ERR'+magtype[3:]][selected]**2)\\\n\t\t\t\t\t\t\/ len(mtbl1) )\n    print(magtype, 'zp', '{},'.format(round(zp2[0],3)),\n\t \t'zperr', '{},'.format(round(zperrp,3)),\n\t\tlen(mtbl1[selected]),'stars from',len(mtbl1))\n    return zp2, selected,zperrp\n\ndef fwhm_img(im,mtbl1):\n\tfwhm_img=sigma_clipped_stats(mtbl1['FWHM_IMAGE'], sigma=3, maxiters=10)\n\tfiltered_data=sigma_clip(mtbl1['FWHM_IMAGE'],sigma=3,maxiters=10)\n\tselected, nonselected= ~filtered_data.mask, filtered_data.mask\n\tprint('FWHM_IMAGE','{}'.format(round(fwhm_img[0],3)),\n\t\tlen(mtbl1[selected]),'stars from',len(mtbl1))\n\tputhdr(im, 'FWHM_PIX', round(fwhm_img[0],3), hdrcomment='FWHM PIXEL VALUE')\n\treturn fwhm_img[0]\n\n'''\ndef fwhm_wcs(mtbl1):\n\tfwhm_wcs=sigma_clipped_stats(mtbl1['FWHM_WORLD'], sigma=3, maxiters=10)\n\tfiltered_data=sigma_clip(mtbl1['FWHM_WORLD'],sigma=3,maxiters=10)\n\tselected, nonselected= ~filtered_data.mask, filtered_data.mask\n\tprint('FWHM_WORLD','{},'.format(round(fwhm_wcs[0]*3600,3)),\n\t\tlen(mtbl1[selected]),'stars from',len(mtbl1))\n\treturn fwhm_wcs[0]*3600\n'''\n# 5sigma detection limit estimate for MAG_AUTO, MAG_PSF\n# error fitting polinomial\ndef UL_5sig_err(im,setbl,mtbl,mtbl1,magtype,zp2):\n\tfn=os.path.splitext(im)[0]\n\tfrom astropy.modeling import models, fitting\n\timport numpy as np\n\tmagerrtype = magtype[:3]+'ERR'+magtype[3:]\n\tif len(mtbl1) < 3:\n\t\treturn 0\n\tx,y = mtbl1[magtype],mtbl1[magerrtype]\n\t#x,y=setbl['MAG_AUTO'],setbl['MAGERR_AUTO']\n\tx,y=x[np.where(y<1)],y[np.where(y<1)]\n\t#fit_init=models.Polynomial1D(7)\n\tfit_init=models.Exponential1D()\n\tfit_t=fitting.LevMarLSQFitter()\n\t#fit_t=fitting.LinearLSQFitter()\n\tt=fit_t(fit_init,x,y)\n\tplt.plot(setbl[magtype]+zp2[0],setbl[magerrtype],'ro')\n\tplt.plot(mtbl[magtype]+zp2[0],mtbl[magerrtype],'ko')\n\tplt.plot(x+zp2[0],y,'bo')\n\tplt.xlabel('Mag')\n\tplt.ylabel('Error')\n\tplt.xlim(10,25)\n\tplt.ylim(-0.1,0.5)\n\txp=np.linspace(-20,0,20001)\n\tplt.plot(xp+zp2[0],t(xp),'--')\n\tplt.hlines(0.2,10,25)\n\tidx_min=np.where(np.abs(t(xp)-0.198) == np.min(np.abs(t(xp)-0.198)))\n\txp[idx_min]+zp2[0] #\n\tplt.vlines(xp[idx_min]+zp2[0],-0.1,0.5)\n\t# result print, file, header\n\tplt.text(12,0.4,'5 sigma Detection Limit error=0.198')\n\tplt.text(12,0.3,'5sig_UL = '+'{}'.format(round((xp[idx_min]+zp2[0])[0],3)))\n\tplt.title(fn+ ' '+ magtype+' '+'5 sig Detection Limit')\n\tplt.savefig(fn+'_'+magtype+'_'+'5sigUL.png')\n\tplt.close()\n\treturn round((xp[idx_min]+zp2[0])[0],3)\n\ndef zp_plot(mtbl1, zp2, selected, magtype, im, filname=filname, filerr=filerr):\n\tfn=os.path.splitext(im)[0]\n\tzp=mtbl1[filname]-mtbl1[magtype]\n\txr=np.linspace(np.min(mtbl1[filname]), np.max(mtbl1[filname]), len(zp))\n\tmagerrtype=magtype[:3]+'ERR'+magtype[3:]\n\tzperrp=np.sqrt( np.sum(mtbl1[filerr][selected]**2 + \\\n\t\t\t\t\t\tmtbl1[magtype[:3]+'ERR'+magtype[3:]][selected]**2)\\\n\t\t\t\t\t\t\/ len(mtbl1) )\n#\tplt.plot(mtbl1[filname],zp,'o',markersize=12)\n\tplt.errorbar(mtbl1[filname],zp,yerr=zperrp,fmt='bo',markersize=12)\n\tplt.ylim(zp2[0]-1,zp2[0]+1)\n\tplt.xlim(np.min(mtbl1[filname]),np.max(mtbl1[filname]))\n\t#plt.hlines(zp3[0],xmin=12,xmax=20,color='b')\n\tplt.hlines(zp2[0],xmin=12,xmax=20,color='r')\n\tsig2=np.ones(len(mtbl1))*zp2[2]\n\tzp2a=np.ones(len(mtbl1))*zp2[0]\n\t#plt.fill_between(xr,zp3a+sig3,zp3a-sig3,color='b',alpha=0.5)\n\tplt.fill_between(xr,zp2a+sig2,zp2a-sig2,color='yellow',alpha=0.5)\n\tplt.plot(mtbl1[filname][~selected],zp[~selected],'ro')\n\tplt.plot(mtbl1[filname][selected],zp[selected],'ko')\n\tplt.text(18,zp2[0]+0.8,magtype+' ZP '+str(round(zp2[0],3))+' err '+str(round(zp2[2],3)))\n\tplt.title(fn+', '+filname+' '+magtype)\n\tplt.ylabel('Zeropoint (AB Mag)')\n\tplt.xlabel(filname +' Reference Mag (AB)')\n\tplt.savefig(fn+'_'+filname+'_'+magtype+'_zp.png')\n\tplt.close()\n\n# fits to png with regions\ndef fitplot(im, mtbl1, magtype, selected):\n\timport matplotlib.pyplot as plt\n\tfrom astropy.wcs import WCS\n\tfrom astropy.io import fits\n\tfrom astropy.visualization import MinMaxInterval,ZScaleInterval,PercentileInterval\n\tfrom astropy.visualization import SqrtStretch,LinearStretch\n\tfrom astropy.visualization import ImageNormalize\n\timdata,imhdr=fits.getdata(im,header=True)\n\tnorm = ImageNormalize(imdata,\n\t\t\tinterval=ZScaleInterval(),\n\t\t\tstretch=LinearStretch() )\n\twcs=WCS(imhdr)\n\tfig,ax=plt.subplots()\n\tax=plt.subplot(projection=wcs)\n\tax.set_xlabel('RA')\n\tax.set_ylabel('DEC')\n\t#ax.invert_xaxis()\n\tax.set_title(im+' '+magtype)\n\tax.scatter(mtbl1[selected]['ALPHA_J2000'],mtbl1[selected]['DELTA_J2000'],\n\t\ttransform=ax.get_transform('fk5'),s=20, edgecolor='green',facecolor='none')\n\tax.scatter(mtbl1[~selected]['ALPHA_J2000'],mtbl1[~selected]['DELTA_J2000'],\n\t\ttransform=ax.get_transform('fk5'),s=20, edgecolor='red',facecolor='none')\n\timg=ax.imshow(imdata,cmap='gray',norm=norm,origin='lower')\n\tax.invert_yaxis()\n\tfig.colorbar(img)\n\tplt.savefig(os.path.splitext(im)[0]+'_'+magtype+'_FOV.png')\n\tplt.close()\n\n\n'''\n\tparam_dict={\n\t'CATALOG_NAME'     : fn+'.se1',\n\t'PARAMETERS_NAME'  : seconfigdir+'se1.param',\n\t'DETECT_MINAREA'   : DETECT_MINAREA,\n\t'DETECT_THRESH'    : DETECT_THRESH,\n\t'FILTER_NAME'      : seconfigdir+seconv,\n\t'DEBLEND_NTHRESH'  : DEBLEND_NTHRESH,\n\t'DEBLEND_MINCONT'  : DEBLEND_MINCONT,\n\t'BACK_TYPE'        : 'AUTO',\n\t'BACK_DEFAULT'     : '0.0',\n\t'BACK_SIZE'        : '64',\n\t'BACK_FILTERSIZE'  : '3',\n\t'BACKPHOTO_TYPE'   : 'LOCAL',\n\t'PHOT_APERTURES'   : aper_input,\n\t'SATUR_LEVEL'      : '60000',\n\t'GAIN'             : '1.0',\n\t'PIXEL_SCALE'      : str(PSCALE),\n\t'SEEING_FWHM'      : '1.2',\n\t'STARNNW_NAME'     :seconfigdir+sennw,\n\t'CHECKIMAGE_TYPE'  : 'SEGMENTATION,OBJECTS,BACKGROUND',\n\t'CHECKIMAGE_NAME'  : fn+'_seg.fits,'+fn+'_obj.fits,'+fn+'bg.fits',\n\t'PSF_NAME'         : fn+'.psf'\n\t}\n\toptstr=''\n\tfor i in param_dict:\n\t\t#print(' -{} {}'.format(i,param_dict[i]))\n\t\toptstr += ' -{} {}'.format(i,param_dict[i])\n\tsecom='sex -c '+seconfigdir+seconfig +' '+ im + optstr\n'''\n'''\n# Default configuration file for SExtractor 2.19.5\n# EB 2014-03-19\n#\n\n#-------------------------------- Catalog ------------------------------------\n\nCATALOG_NAME     test.cat       # name of the output catalog\nCATALOG_TYPE     ASCII_HEAD     # NONE,ASCII,ASCII_HEAD, ASCII_SKYCAT,\n                                # ASCII_VOTABLE, FITS_1.0 or FITS_LDAC\nPARAMETERS_NAME  default.param  # name of the file containing catalog contents\n\n#------------------------------- Extraction ----------------------------------\n\nDETECT_TYPE      CCD            # CCD (linear) or PHOTO (with gamma correction)\nDETECT_MINAREA   5              # min. # of pixels above threshold\nDETECT_MAXAREA   0              # max. # of pixels above threshold (0=unlimited)\nTHRESH_TYPE      RELATIVE       # threshold type: RELATIVE (in sigmas)\n                                # or ABSOLUTE (in ADUs)\nDETECT_THRESH    1.5            # <sigmas> or <threshold>,<ZP> in mag.arcsec-2\nANALYSIS_THRESH  1.5            # <sigmas> or <threshold>,<ZP> in mag.arcsec-2\n\nFILTER           Y              # apply filter for detection (Y or N)?\nFILTER_NAME      default.conv   # name of the file containing the filter\nFILTER_THRESH                   # Threshold[s] for retina filtering\n\nDEBLEND_NTHRESH  32             # Number of deblending sub-thresholds\nDEBLEND_MINCONT  0.005          # Minimum contrast parameter for deblending\n\nCLEAN            Y              # Clean spurious detections? (Y or N)?\nCLEAN_PARAM      1.0            # Cleaning efficiency\n\nMASK_TYPE        CORRECT        # type of detection MASKing: can be one of\n                                # NONE, BLANK or CORRECT\n\n#-------------------------------- WEIGHTing ----------------------------------\n\nWEIGHT_TYPE      NONE           # type of WEIGHTing: NONE, BACKGROUND,\n                                # MAP_RMS, MAP_VAR or MAP_WEIGHT\nRESCALE_WEIGHTS  Y              # Rescale input weights\/variances (Y\/N)?\nWEIGHT_IMAGE     weight.fits    # weight-map filename\nWEIGHT_GAIN      Y              # modulate gain (E\/ADU) with weights? (Y\/N)\nWEIGHT_THRESH                   # weight threshold[s] for bad pixels\n\n#-------------------------------- FLAGging -----------------------------------\n\nFLAG_IMAGE       flag.fits      # filename for an input FLAG-image\nFLAG_TYPE        OR             # flag pixel combination: OR, AND, MIN, MAX\n                                # or MOST\n\n#------------------------------ Photometry -----------------------------------\n\nPHOT_APERTURES   5              # MAG_APER aperture diameter(s) in pixels\nPHOT_AUTOPARAMS  2.5, 3.5       # MAG_AUTO parameters: <Kron_fact>,<min_radius>\nPHOT_PETROPARAMS 2.0, 3.5       # MAG_PETRO parameters: <Petrosian_fact>,\n                                # <min_radius>\nPHOT_AUTOAPERS   0.0,0.0        # <estimation>,<measurement> minimum apertures\n                                # for MAG_AUTO and MAG_PETRO\nPHOT_FLUXFRAC    0.5            # flux fraction[s] used for FLUX_RADIUS\n\nSATUR_LEVEL      50000.0        # level (in ADUs) at which arises saturation\nSATUR_KEY        SATURATE       # keyword for saturation level (in ADUs)\n\nMAG_ZEROPOINT    0.0            # magnitude zero-point\nMAG_GAMMA        4.0            # gamma of emulsion (for photographic scans)\nGAIN             0.0            # detector gain in e-\/ADU\nGAIN_KEY         GAIN           # keyword for detector gain in e-\/ADU\nPIXEL_SCALE      1.0            # size of pixel in arcsec (0=use FITS WCS info)\n\n#------------------------- Star\/Galaxy Separation ----------------------------\n\nSEEING_FWHM      1.2            # stellar FWHM in arcsec\nSTARNNW_NAME     default.nnw    # Neural-Network_Weight table filename\n\n#------------------------------ Background -----------------------------------\n\nBACK_TYPE        AUTO           # AUTO or MANUAL\nBACK_VALUE       0.0            # Default background value in MANUAL mode\nBACK_SIZE        64             # Background mesh: <size> or <width>,<height>\nBACK_FILTERSIZE  3              # Background filter: <size> or <width>,<height>\n\nBACKPHOTO_TYPE   GLOBAL         # can be GLOBAL or LOCAL\nBACKPHOTO_THICK  24             # thickness of the background LOCAL annulus\nBACK_FILTTHRESH  0.0            # Threshold above which the background-\n                                # map filter operates\n\n#------------------------------ Check Image ----------------------------------\n\nCHECKIMAGE_TYPE  NONE           # can be NONE, BACKGROUND, BACKGROUND_RMS,\n                                # MINIBACKGROUND, MINIBACK_RMS, -BACKGROUND,\n                                # FILTERED, OBJECTS, -OBJECTS, SEGMENTATION,\n                                # or APERTURES\nCHECKIMAGE_NAME  check.fits     # Filename for the check-image\n\n#--------------------- Memory (change with caution!) -------------------------\n\nMEMORY_OBJSTACK  3000           # number of objects in stack\nMEMORY_PIXSTACK  300000         # number of pixels in stack\nMEMORY_BUFSIZE   1024           # number of lines in buffer\n\n#------------------------------- ASSOCiation ---------------------------------\n\nASSOC_NAME       sky.list       # name of the ASCII file to ASSOCiate\nASSOC_DATA       2,3,4          # columns of the data to replicate (0=all)\nASSOC_PARAMS     2,3,4          # columns of xpos,ypos[,mag]\nASSOCCOORD_TYPE  PIXEL          # ASSOC coordinates: PIXEL or WORLD\nASSOC_RADIUS     2.0            # cross-matching radius (pixels)\nASSOC_TYPE       NEAREST        # ASSOCiation method: FIRST, NEAREST, MEAN,\n                                # MAG_MEAN, SUM, MAG_SUM, MIN or MAX\nASSOCSELEC_TYPE  MATCHED        # ASSOC selection type: ALL, MATCHED or -MATCHED\n\n#----------------------------- Miscellaneous ---------------------------------\n\nVERBOSE_TYPE     NORMAL         # can be QUIET, NORMAL or FULL\nHEADER_SUFFIX    .head          # Filename extension for additional headers\nWRITE_XML        N              # Write XML file (Y\/N)?\nXML_NAME         sex.xml        # Filename for XML output\nXSL_URL          file:\/\/\/usr\/share\/sextractor\/sextractor.xsl\n                                # Filename for XSL style-sheet\nNTHREADS         1              # 1 single thread\n\nFITS_UNSIGNED    N              # Treat FITS integer values as unsigned (Y\/N)?\nINTERP_MAXXLAG   16             # Max. lag along X for 0-weight interpolation\nINTERP_MAXYLAG   16             # Max. lag along Y for 0-weight interpolation\nINTERP_TYPE      ALL            # Interpolation type: NONE, VAR_ONLY or ALL\n\n#--------------------------- Experimental Stuff -----------------------------\n\nPSF_NAME         default.psf    # File containing the PSF model\nPSF_NMAX         1              # Max.number of PSFs fitted simultaneously\nPATTERN_TYPE     RINGS-HARMONIC # can RINGS-QUADPOLE, RINGS-OCTOPOLE,\n                                # RINGS-HARMONICS or GAUSS-LAGUERRE\nSOM_NAME         default.som    # File containing Self-Organizing Map weights\n'''\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_33","text":"<reponame>adam-coogan\/diffbank\nfrom itertools import product\n\nimport click\nfrom diffjeom import get_ricci_scalar\nimport jax\nimport jax.numpy as jnp\nimport matplotlib.pyplot as plt\nfrom scipy.interpolate import griddata\n\nfrom diffbank.constants import MSUN\nfrom diffbank.metric import get_g\nfrom diffbank.noise import Sn_O3a as Sn\nfrom diffbank.utils import ms_to_Mc_eta\nfrom diffbank.waveforms.twoPN_chirptimes import (\n    Amp,\n    Psi,\n    get_th_boundary_interps,\n    phys_to_th,\n)\n\nplt.style.use(\"..\/plot_style.mplstyle\")\n\n\"\"\"\nPlots the scalar curvature (Ricci scalar) for the metric for the waveform in\nhttps:\/\/arxiv.org\/abs\/gr-qc\/0604037.\n\nTo reproduce:\n\n    >>> python plot_scalar_curvature.py\n\n\"\"\"\n\n##### Frequency settings\nf_u = 512.0  # Hz\nf_l = 10.0  # Hz\nN_fbins = 1000\n#####\n\n\n@click.command()\n@click.option(\"--n-m1s\", type=int, default=200)\n@click.option(\"--n-m2s\", type=int, default=100)\n@click.option(\"--n-th0s\", type=int, default=200)\n@click.option(\"--n-th3s\", type=int, default=100)\n@click.option(\"--fig-path\", default=\"figures\/scalar-curvature.pdf\")\ndef run(n_m1s, n_m2s, n_th0s, n_th3s, fig_path):\n    fs = jnp.linspace(f_l, f_u, N_fbins)\n\n    g_fun = lambda theta: get_g(theta, Amp, Psi, fs, Sn)\n\n    # Set parameter grid\n    m_min = jnp.array(1.0) * MSUN\n    m_max = jnp.array(20.0) * MSUN\n    M_max = m_min + m_max\n    m1s = jnp.geomspace(m_min, m_max, n_m1s)\n    m2s = jnp.geomspace(m_min, m_max, n_m2s)\n    m1s, m2s = jnp.array(list(product(m1s, m2s))).T\n    m1s, m2s = m1s[m1s >= m2s], m2s[m1s >= m2s]  # remove redundant systems\n    m1s, m2s = m1s[m1s + m2s <= M_max], m2s[m1s + m2s <= M_max]\n    M_chirps, etas = ms_to_Mc_eta(jnp.stack([m1s, m2s]))\n\n    # (th0, th3) boundaries\n    (th0_min, th0_max), bound_itp_low, bound_itp_high = get_th_boundary_interps(\n        m_min, m_max, f_l\n    )\n\n    # Plotting configuration\n    vmin = -10.0\n    vmax = -7.5\n    levels = jnp.linspace(vmin, vmax, 60)\n    cbar_ticks = jnp.arange(vmin, vmax + 0.05, 0.5)\n\n    thetas = phys_to_th(jnp.stack([M_chirps, etas]), f_l).T  # type: ignore\n    Rss = jax.vmap(lambda x: get_ricci_scalar(x, g_fun))(thetas)\n\n    # Plot!\n    th0s = jnp.linspace(thetas[:, 0].min(), thetas[:, 0].max(), n_th0s)\n    th3s = jnp.linspace(thetas[:, 1].min(), thetas[:, 1].max(), n_th3s)\n\n    cs = plt.contourf(\n        th0s \/ 1e4,\n        th3s \/ 1e2,\n        jnp.clip(\n            griddata(\n                thetas[:, :2],\n                jnp.log10(jnp.abs(Rss)),\n                jnp.stack(jnp.meshgrid(th0s, th3s)).reshape([2, -1]).T,\n            ).reshape([len(th3s), len(th0s)]),\n            vmin,\n            vmax,\n        ),\n        levels=levels,\n        cmap=\"viridis\",\n    )\n    plt.colorbar(cs, label=r\"$\\log_{10}(|R|)$\", ticks=cbar_ticks)\n\n    # Mask outside boundaries\n    th0_grid = jnp.linspace(th0_min, th0_max, 200)\n    plt.fill_between(\n        th0_grid \/ 1e4,\n        bound_itp_low(th0_grid) \/ 1e2,\n        jnp.full_like(th0_grid, -1e3) \/ 1e2,\n        where=jnp.full_like(th0_grid, True),\n        color=\"w\",\n    )\n    plt.fill_between(\n        th0_grid \/ 1e4,\n        bound_itp_high(th0_grid) \/ 1e2,\n        jnp.full_like(th0_grid, 1e3) \/ 1e2,\n        where=jnp.full_like(th0_grid, True),\n        color=\"w\",\n    )\n\n    plt.xlabel(r\"$\\theta_0 \/ 10^4$\")\n    plt.ylabel(r\"$\\theta_3 \/ 10^2$\")\n    plt.xlim(0.0, 10.0)\n    plt.ylim(0.8, 8)\n    # plt.tight_layout()\n    plt.savefig(fig_path, bbox_inches=\"tight\")\n\n\nif __name__ == \"__main__\":\n    run()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_34","text":"#!\/usr\/bin\/env python3\nimport argparse\nimport array\nimport asyncio as aio\nimport base64\nimport itertools\nimport logging\nimport random\nimport statistics\nfrom abc import ABCMeta, abstractmethod\nfrom asyncio import DatagramTransport, Lock, StreamReader, StreamWriter, Task\nfrom types import TracebackType\nfrom typing import (ClassVar, Iterable, Iterator, List, Optional, Sequence,\n                    Set, SupportsFloat, Tuple, Type, Union)\n\nimport httpx\n\nDEFAULT_LISTEN_ADDRESSES = \\\n[\n\t'127.0.0.1',\n\t'::1',\n]\n\nDEFAULT_LISTEN_PORTS = \\\n[\n\t5053,\n]\n\nDEFAULT_UPSTREAMS = \\\n[\n\t'https:\/\/192.168.3.11:443\/dns-query',\n\t'https:\/\/172.16.31.10:443\/dns-query',\n\t'https:\/\/[fc00:db20:35b:7399::5]:443\/dns-query',\n\t'https:\/\/[2606:fd00:a516:7c1b:17cd:6d81:2137:bd2a:2c5b]:443\/dns-query',\n]\n\n\nasync def main(args) -> None:\n\t# Setup event loop\n\tloop = aio.get_running_loop()\n\n\t# Setup DNS resolver to cache\/forward queries and answers\n\tasync with AsyncDnsResolver(args.upstreams, AsyncDohUpstreamContext) as resolver:\n\t\ttransports = []\n\n\t\t# Setup listening transports\n\t\tfor addr in args.listen_address:\n\t\t\tfor port in args.listen_port:\n\t\t\t\t# Setup UDP server\n\t\t\t\tlogging.info('Starting UDP server listening on %s#%d' % (addr, port))\n\t\t\t\tudp, _ = await loop.create_datagram_endpoint(lambda: UdpResolverProtocol(resolver), local_addr=(addr, port))\n\t\t\t\ttransports.append(udp)\n\n\t\t\t\t# Setup TCP server\n\t\t\t\tif args.tcp:\n\t\t\t\t\tlogging.info('Starting TCP server listening on %s#%d' % (addr, port))\n\t\t\t\t\ttcp = await aio.start_server(TcpResolverProtocol(resolver).ahandle_peer, addr, port)\n\t\t\t\t\ttransports.append(tcp)\n\n\t\t# Serve forever\n\t\ttry:\n\t\t\twhile True:\n\t\t\t\tawait aio.sleep(3600)\n\t\t\t\tlogging.info(resolver.get_stats())\n\n\t\texcept (KeyboardInterrupt, SystemExit):\n\t\t\tpass\n\n\t\tlogging.info('Shutting down DNS over HTTPS forwarder')\n\n\t\twait_closers = []\n\t\tfor transport in transports:\n\t\t\ttransport.close()\n\t\t\tif hasattr(transport, 'wait_closed'):\n\t\t\t\twait_closers.append(aio.create_task(transport.wait_closed()))\n\n\t\tawait aio.wait(wait_closers)\n\n\tawait aio.sleep(0.3)\n\n\nclass AsyncDnsUpstreamContext(metaclass=ABCMeta):\n\t\"\"\"A base class used to manage upstream DNS server connections and metadata.\"\"\"\n\n\tRTT_WINDOW_SIZE: ClassVar[int] = 10\n\n\tdef __init__(self, host: str) -> None:\n\t\tself.host = host\n\t\tself.queries = 0\n\t\tself.answers = 0\n\t\tself._rtts = array.array('d', [0.0])\n\t\tself._rtts_index: Iterator[int] = itertools.cycle(range(self.RTT_WINDOW_SIZE))\n\n\tasync def __aenter__(self) -> 'AsyncDnsUpstreamContext':\n\t\treturn self\n\n\tasync def __aexit__(self,\n\t\texc_type: Optional[Type[BaseException]],\n\t\texc_val: Optional[BaseException],\n\t\texc_tb: Optional[TracebackType]) -> None:\n\t\tawait self.aclose()\n\n\t@property\n\tdef avg_rtt(self) -> float:\n\t\t\"\"\"The average rtt or latency (in seconds) for DNS requests to this upstream DNS server.\"\"\"\n\t\treturn statistics.fmean(self._rtts)\n\n\tdef add_rtt_sample(self, rtt: SupportsFloat) -> None:\n\t\t\"\"\"Add a new rtt sample to help compute the average rtt for this upstream DNS server.\"\"\"\n\t\ti = next(self._rtts_index)\n\t\tself._rtts[i:i+1] = array.array('d', [float(rtt)])\n\n\tdef get_stats(self) -> str:\n\t\t\"\"\"Returns a formatted string of statistics for this upstream server.\"\"\"\n\t\treturn f'{self.host} (rtt: {self.avg_rtt:.3f} s, queries: {self.queries}, answers: {self.answers})'\n\n\t@abstractmethod\n\tasync def aforward_query(self, query: bytes) -> bytes:\n\t\t\"\"\"Resolve a DNS query via forwarding to a upstream DNS server.\n\n\t\tParams:\n\t\t\tquery - A wireformat DNS query packet.\n\n\t\tReturns:\n\t\t\tA wireformat DNS answer packet.\n\n\t\tNotes:\n\t\t\tThis coroutine is be safely cancellable. That is, even if the\n\t\t\tcoroutine is cancelled it still leaves any internal state\n\t\t\tit uses in a consistent and usable state.\n\t\t\"\"\"\n\t\t...\n\n\t@abstractmethod\n\tasync def aclose(self) -> None:\n\t\t\"\"\"Close any open connections to the upstream DNS server.\"\"\"\n\t\t...\n\n\nclass AsyncDohUpstreamContext(AsyncDnsUpstreamContext):\n\t\"\"\"A class used to manage upstream DoH server connections and metadata.\"\"\"\n\n\tSESSION_LIMITS: ClassVar[httpx.Limits] = httpx.Limits(max_keepalive_connections=1, max_connections=3, keepalive_expiry=60.0)\n\tSESSION_TIMEOUTS: ClassVar[httpx.Timeout] = httpx.Timeout(None)\n\n\tdef __init__(self, url: str) -> None:\n\t\tsuper().__init__(url)\n\t\tself.session = httpx.AsyncClient(\n\t\t\tlimits=self.SESSION_LIMITS,\n\t\t\ttimeout=self.SESSION_TIMEOUTS,\n\t\t\theaders={'accept': 'application\/dns-message'},\n\t\t\thttp2=True)\n\n\tasync def aforward_post(self, query: bytes) -> Tuple[bytes, float]:\n\t\t\"\"\"Resolve a DNS query via forwarding to a upstream DoH server (POST).\n\n\t\tParams:\n\t\t\tquery - A wireformat DNS query packet.\n\n\t\tReturns:\n\t\t\tA wireformat DNS answer packet and rtt sample.\n\n\t\tNotes:\n\t\t\tUsing DNS over HTTPS POST format as described here:\n\t\t\thttps:\/\/datatracker.ietf.org\/doc\/html\/rfc8484\n\t\t\thttps:\/\/developers.cloudflare.com\/1.1.1.1\/dns-over-https\/wireformat\/\n\t\t\"\"\"\n\t\t# Send HTTP request to upstream DoH server and wait for the response\n\t\tresponse = await aio.shield(\n\t\t\tself.session.post(\n\t\t\t\tself.host,\n\t\t\t\theaders={'content-type': 'application\/dns-message'},\n\t\t\t\tcontent=query))\n\n\t\t# Parse HTTP response\n\t\tresponse.raise_for_status()\n\t\tanswer = response.read()\n\t\trtt = response.elapsed.total_seconds()\n\n\t\t# Return the DNS answer\n\t\treturn (answer, rtt)\n\n\tasync def aforward_get(self, query: bytes) -> Tuple[bytes, float]:\n\t\t\"\"\"Resolve a DNS query via forwarding to a upstream DoH server (GET).\n\n\t\tParams:\n\t\t\tquery - A wireformat DNS query packet.\n\n\t\tReturns:\n\t\t\tA wireformat DNS answer packet and rtt sample.\n\n\t\tNotes:\n\t\t\tUsing DNS over HTTPS GET format as described here:\n\t\t\thttps:\/\/datatracker.ietf.org\/doc\/html\/rfc8484\n\t\t\thttps:\/\/developers.cloudflare.com\/1.1.1.1\/dns-over-https\/wireformat\/\n\t\t\"\"\"\n\t\t# Encode DNS query into url\n\t\turl = ''.join([self.host, '?dns=', base64.urlsafe_b64encode(query).rstrip(b'=').decode()])\n\n\t\t# Send HTTP request to upstream DoH server and wait for the response\n\t\tresponse = await aio.shield(self.session.get(url))\n\n\t\t# Parse HTTP response\n\t\tresponse.raise_for_status()\n\t\tanswer = response.read()\n\t\trtt = response.elapsed.total_seconds()\n\n\t\t# Return the DNS answer\n\t\treturn (answer, rtt)\n\n\tasync def aforward_query(self, query: bytes) -> bytes:\n\t\tself.queries += 1\n\n\t\tquery = memoryview(query)\n\t\tqid = query[:2]\n\n\t\t# Forward the DNS query to the upstream DoH server\n\t\ttry:\n\t\t\tlogging.debug(f'Sending query {qid.hex()} to {self.host} --->')\n\t\t\tanswer, rtt = await self.aforward_post(b''.join([b'\\0' * 2, query[2:]]))\n\n\t\t\tself.add_rtt_sample(rtt)\n\t\t\tself.answers += 1\n\n\t\t\tlogging.debug(f'Receiving answer {qid.hex()} from {self.host} ({rtt}) <---')\n\t\t\treturn b''.join([qid, memoryview(answer)[2:]])\n\n\t\t# Raise connection error\n\t\texcept (httpx.NetworkError, httpx.RemoteProtocolError):\n\t\t\traise ConnectionError(f'DNS query to DoH server {self.host} failed due to network errors')\n\n\t\t# Raise abnormal HTTP status codes\n\t\texcept httpx.HTTPStatusError as exc:\n\t\t\traise ConnectionError(f'received HTTP error status from DoH server {self.host} ({exc.response.status_code})')\n\n\tasync def aclose(self) -> None:\n\t\tawait self.session.aclose()\n\n\nclass AsyncDnsResolver:\n\t\"\"\"A class that manages upstream DNS server contexts and resolves DNS queries.\"\"\"\n\n\tDEFAULT_QUERY_TIMEOUT: ClassVar[float] = 3.0\n\n\tdef __init__(self, upstreams: Iterable[str], context_class: Type[AsyncDnsUpstreamContext]) -> None:\n\t\tself._upstreams = tuple(context_class(upstream) for upstream in upstreams)\n\n\t\tif not self._upstreams:\n\t\t\traise ValueError('iterable of upstreams must have at least one entry')\n\n\tasync def __aenter__(self) -> 'AsyncDnsResolver':\n\t\treturn self\n\n\tasync def __aexit__(self,\n\t\texc_type: Optional[Type[BaseException]],\n\t\texc_val: Optional[BaseException],\n\t\texc_tb: Optional[TracebackType]) -> None:\n\t\tawait self.aclose()\n\n\t@property\n\tdef queries(self) -> int:\n\t\treturn sum(upstream.queries for upstream in self._upstreams)\n\n\t@property\n\tdef answers(self) -> int:\n\t\treturn sum(upstream.answers for upstream in self._upstreams)\n\n\t@property\n\tdef avg_rtt(self) -> float:\n\t\treturn statistics.fmean(upstream.avg_rtt for upstream in self._upstreams)\n\n\tdef get_stats(self) -> str:\n\t\t\"\"\"Returns a formatted string of statistics for this resolver.\"\"\"\n\t\treturn f'Statistics for resolver at 0x{id(self)} (avg_rtt: {self.avg_rtt:.3f} s, total_queries: {self.queries}, total_answers: {self.answers})'\n\n\tasync def aresolve(self, query: bytes, timeout: float = DEFAULT_QUERY_TIMEOUT) -> bytes:\n\t\t\"\"\"Resolve a DNS query via forwarding to upstream DNS servers.\n\n\t\tParams:\n\t\t\tquery - A wireformat DNS query packet.\n\t\t\ttimeout - The maximum amount of time (in seconds) to wait for the receipt of the DNS answer packet.\n\n\t\tReturns:\n\t\t\tA wireformat DNS answer packet.\n\t\t\"\"\"\n\t\t# Forward the DNS query and return the DNS answer\n\t\t# (perform a staggered race and accept the earliest response)\n\t\tasync def astaggered_resolution(upstreams: Sequence[AsyncDnsUpstreamContext], period: float) -> bytes:\n\t\t\tassert len(upstreams) > 0\n\n\t\t\twinner: Task = None\n\t\t\tracers: Set[Task] = set()\n\t\t\terrors: List[BaseException] = []\n\n\t\t\t# Wait for the first racer to finish and cleanup exceptions\n\t\t\tasync def await_first_racer(timeout: float = None) -> bool:\n\t\t\t\tnonlocal winner\n\t\t\t\tnonlocal racers\n\t\t\t\tnonlocal errors\n\n\t\t\t\tdone, racers = await aio.wait(racers, timeout=timeout, return_when=aio.FIRST_COMPLETED)\n\n\t\t\t\tfor racer in done:\n\t\t\t\t\t\terror = racer.exception()\n\n\t\t\t\t\t\tif error is None:\n\t\t\t\t\t\t\twinner = racer\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\terrors.append(error)\n\n\t\t\t\treturn winner is not None\n\n\t\t\ttry:\n\t\t\t\tfor upstream in upstreams:\n\t\t\t\t\tracers.add(aio.create_task(upstream.aforward_query(query)))\n\n\t\t\t\t\tif await await_first_racer(period):\n\t\t\t\t\t\treturn winner.result()\n\n\t\t\t\twhile racers:\n\t\t\t\t\tif await await_first_racer():\n\t\t\t\t\t\treturn winner.result()\n\n\t\t\tfinally:\n\t\t\t\tfor loser in racers:\n\t\t\t\t\tloser.cancel()\n\n\t\t\tdef raise_multi_error(errors: Iterable[BaseException]) -> None:\n\t\t\t\tclass MultiError(*frozenset(type(error) for error in errors)):\n\t\t\t\t\tpass\n\n\t\t\t\traise MultiError\n\n\t\t\tassert len(errors) == len(upstreams)\n\t\t\traise_multi_error(errors)\n\n\t\t# Weighted random shuffle the upstream servers by average latency\n\t\tk = len(self._upstreams)\n\t\trtts = tuple(upstream.avg_rtt for upstream in self._upstreams)\n\t\tmax_rtt = max(rtts)\n\t\tweights = (max_rtt - rtt + 0.001 for rtt in rtts)\n\t\tupstreams = random.choices(self._upstreams, weights=weights, k=k)\n\t\tperiod = (timeout \/ 2) \/ k if timeout is not None else 0.1\n\n\t\t# Forward the DNS query and return the DNS answer\n\t\ttry:\n\t\t\treturn await aio.wait_for(astaggered_resolution(upstreams, period), timeout)\n\n\t\t# Raise timeout error\n\t\texcept aio.TimeoutError:\n\t\t\traise TimeoutError(f'DNS query expired and was cancelled')\n\n\tasync def aclose(self) -> None:\n\t\t\"\"\"Close all upstream DoH server connections.\"\"\"\n\t\tfor upstream in self._upstreams:\n\t\t\tawait upstream.aclose()\n\n\nclass UdpResolverProtocol(aio.DatagramProtocol):\n\t\"\"\"Protocol for serving UDP DNS requests via a DnsResolver instance.\"\"\"\n\n\tdef __init__(self, resolver: AsyncDnsResolver) -> None:\n\t\tself.resolver = resolver\n\t\tself.buffer = []\n\t\tself.worker = None\n\n\tdef connection_made(self, transport: DatagramTransport) -> None:\n\t\tself.transport = transport\n\n\tdef datagram_received(self, data: bytes, peer: Tuple[str, int]) -> None:\n\t\tlogging.debug(f'Got UDP DNS query from {peer}')\n\n\t\t# Add query to buffer\n\t\tself.buffer.append((peer, data))\n\n\t\t# Schedule query processing task if necessary\n\t\tif self.worker is None:\n\t\t\tself.worker = aio.create_task(self.ahandle_queries())\n\n\tasync def ahandle_queries(self) -> None:\n\t\twhile self.buffer:\n\t\t\ttasks = set(aio.create_task(self.ahandle_query(peer, query)) for peer, query in self.buffer)\n\n\t\t\tdel self.buffer[:]\n\n\t\t\twhile tasks:\n\t\t\t\tdone, tasks = await aio.wait(tasks, timeout=0.05)\n\n\t\t\t\tfor task in done:\n\t\t\t\t\terror = task.exception()\n\n\t\t\t\t\tif error is None:\n\t\t\t\t\t\tpeer, answer = task.result()\n\t\t\t\t\t\tself.transport.sendto(answer, peer)\n\t\t\t\t\telse:\n\t\t\t\t\t\tlogging.warning(f'UDP DNS query resolution encountered an error - {error!r}')\n\n\t\tself.worker = None\n\n\tasync def ahandle_query(self, peer: Tuple[str, int], query: bytes) -> Tuple[Tuple[str, int], bytes]:\n\t\treturn (peer, await self.resolver.aresolve(query))\n\n\nclass TcpResolverProtocol:\n\t\"\"\"Protocol for serving TCP DNS requests via a DnsResolver instance.\"\"\"\n\n\tdef __init__(self, resolver: AsyncDnsResolver) -> None:\n\t\tself.resolver = resolver\n\n\tasync def ahandle_peer(self, reader: StreamReader, writer: StreamWriter) -> None:\n\t\t\"\"\"Read all DNS queries from the peer stream and schedule their resolution via a DnsResolver instance.\"\"\"\n\t\ttasks: Union[List[Task], Set[Task]] = []\n\t\twlock = aio.Lock()\n\n\t\tlogging.debug(f'Got TCP DNS query stream from {writer.transport.get_extra_info(\"peername\")}')\n\n\t\twhile True:\n\t\t\t# Parse a DNS query packet off of the wire\n\t\t\ttry:\n\t\t\t\tquery_size = int.from_bytes(await reader.readexactly(2), 'big')\n\t\t\t\tquery = await reader.readexactly(query_size)\n\n\t\t\t# Check if our peer has finished writing to the stream\n\t\t\texcept aio.IncompleteReadError:\n\t\t\t\tbreak\n\n\t\t\t# Schedule the processing of the query\n\t\t\ttasks.append(aio.create_task(self.ahandle_query(writer, wlock, query)))\n\n\t\t# Wait for all scheduled query processing to finish\n\t\twhile tasks:\n\t\t\tdone, tasks = await aio.wait(tasks, return_when=aio.FIRST_COMPLETED)\n\n\t\t\tfor task in done:\n\t\t\t\terror = task.exception()\n\n\t\t\t\tif error is not None:\n\t\t\t\t\tlogging.warning(f'TCP DNS query resolution encountered an error - {error!r}')\n\n\t\tif not writer.is_closing():\n\t\t\t# Indicate we are done writing to the stream\n\t\t\tif writer.can_write_eof():\n\t\t\t\twriter.write_eof()\n\n\t\t\t# Close the stream\n\t\t\twriter.close()\n\t\t\tawait writer.wait_closed()\n\n\tasync def ahandle_query(self, writer: StreamWriter, wlock: Lock, query: bytes) -> None:\n\t\t\"\"\"Resolve a DNS query and write the DNS answer to the peer stream.\"\"\"\n\t\tif writer.is_closing():\n\t\t\treturn\n\n\t\t# Resolve DNS query\n\t\tanswer = await self.resolver.aresolve(query)\n\n\t\tif writer.is_closing():\n\t\t\treturn\n\n\t\t# Create the DNS answer packet\n\t\tanswer_size = len(answer).to_bytes(2, 'big')\n\t\tanswer = b''.join([answer_size, answer])\n\n\t\t# Write the DNS answer to the peer stream\n\t\tasync with wlock:\n\t\t\tif writer.is_closing():\n\t\t\t\treturn\n\n\t\t\tawait writer.drain()\n\n\t\t\tif writer.is_closing():\n\t\t\t\treturn\n\n\t\t\twriter.write(answer)\n\n\nif __name__ == '__main__':\n\t# Handle command line arguments\n\tparser = argparse.ArgumentParser()\n\tparser.add_argument('-l', '--listen-address', nargs='+', default=DEFAULT_LISTEN_ADDRESSES,\n\t\t\t\t\t\thelp='addresses to listen on for DNS over HTTPS requests (default: %(default)s)')\n\tparser.add_argument('-p', '--listen-port', nargs='+', type=int, default=DEFAULT_LISTEN_PORTS,\n\t\t\t\t\t\thelp='ports to listen on for DNS over HTTPS requests (default: %(default)s)')\n\tparser.add_argument('-u', '--upstreams', nargs='+', default=DEFAULT_UPSTREAMS,\n\t\t\t\t\t\thelp='upstream servers to forward DNS queries and requests to (default: %(default)s)')\n\tparser.add_argument('-t', '--tcp', action='store_true', default=False,\n\t\t\t\t\t\thelp='serve TCP based queries and requests along with UDP (default: %(default)s)')\n\tparser.add_argument('-f', '--file', default=None,\n\t\t\t\t\t\thelp='file to store logging output to (default: %(default)s)')\n\tparser.add_argument('-d', '--debug', action='store_true', default=False,\n\t\t\t\t\t\thelp='enable debugging on the internal asyncio event loop (default: %(default)s)')\n\targs = parser.parse_args()\n\n\t# Setup logging\n\tlog_level = 'DEBUG' if args.debug else 'INFO'\n\tlogging.basicConfig(level=log_level, filename=args.file, filemode='w', format='(%(asctime)s)[%(levelname)s] %(message)s')\n\tlogging.info('Starting DNS over HTTPS forwarder')\n\tlogging.info('Args: %r' % (vars(args)))\n\n\taio.run(main(args), debug=args.debug)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_36","text":"\"\"\"\r\nQuestion Source:Leetcode\r\nLevel: Hard\r\nTopic: Binary search\r\nSolver: Tayyrov\r\nDate: 25.05.2022\r\n\"\"\"\r\nfrom bisect import bisect_left\r\nfrom cmath import inf\r\nfrom typing import List\r\n\r\n\r\ndef maxEnvelopes(self, envelopes: List[List[int]]) -> int:\r\n    sor = sorted(envelopes, key=lambda x: (x[0], -x[-1]))\r\n\r\n    ans = [-inf]\r\n\r\n    for _, h in sor:\r\n        idx = bisect_left(ans, h)\r\n        print(idx)\r\n        if idx == len(ans):\r\n            ans.append(h)\r\n        else:\r\n            ans[idx] = h\r\n        print(ans)\r\n    return len(ans) - 1"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_37","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\nimport pandas as pd\nimport numpy as np\nfrom scipy import interpolate\n\n# Download Task (10 MB)\n# Egger, Sebastian, et al. \"“Time is bandwidth”?\n# Narrowing the gap between subjective time perception and Quality of Experience.\"\n# Communications (ICC), 2012 IEEE International Conference on. IEEE, 2012.\nclass WebDLUtility(object):\n\n    def __init__(self, scaled=False, min_mos=1, max_mos=5):\n\n        self._scaled = scaled\n\n        self._min_mos = min_mos\n        self._max_mos = max_mos\n\n        # Create inverse by interpolation\n        x = np.linspace(0.1, 150)\n        y = list(map(self.predict, x))\n\n        self._finv = interpolate.interp1d(y, x,\n                                 fill_value=\"extrapolate\",\n                                 bounds_error=False)\n\n    def predict(self, dl):\n\n        temp_mos = self._predict_mos(dl)\n\n        if not (temp_mos >= self._min_mos and temp_mos <= self._max_mos):\n            raise Exception(\"Invalid MOS %.5f (bounds: [%.5f, %.5f]!\" % (temp_mos, self._min_mos, self._max_mos))\n\n        if self._scaled:\n            utility = np.interp(temp_mos, (self._min_mos, self._max_mos), (1, 5))\n        else:\n            utility = temp_mos\n\n        return utility\n\n    def _predict_mos(self, dl):\n        \"\"\"\n        :param dl: Download Time (s)\n        \"\"\"\n        # Restrict to range 1.0 - 5.0\n        return max(1.0, min(-1.68 * np.log(dl) + 9.61, 5.0))\n\n    def inverse(self, mos):\n\n        assert(mos >= 1.0 and mos <= 5.0)\n\n        r = self._finv(mos)\n\n        return r\n\n\nif __name__ == \"__main__\":\n\n    model = WebDLUtility()\n\n    print(model.predict(10))\n    print(model.predict(150))\n\n    import numpy as np\n    import matplotlib.pylab as plt\n\n    f, ax = plt.subplots()\n\n    x = np.linspace(0.01, 180.0)\n    y = list(map(model.predict, x))\n\n    ax.step(x, y)\n    ax.grid()\n\n    ax.set_yticks(range(1, 6))\n\n    ax.set_xlabel(\"Download Time 10MB dl (s)\")\n    ax.set_ylabel(r\"$Utility_{WEBDL}(dl)$\")\n\n    # Inverse function\n    f, ax = plt.subplots()\n\n    x = np.linspace(1, 5)\n    y = list(map(model.inverse, x))\n\n    ax.step(x, y)\n    ax.grid()\n\n    ax.set_ylabel(\"Download Time 10MB dl (s)\")\n    ax.set_xlabel(r\"$Utility_{WEBDL}(dl)$\")\n\n    f.savefig(\"utility_webdl.png\", dpi=200)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_38","text":"<filename>cobra\/evaluation\/evaluator.py\n\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as mticker\nimport seaborn as sns\n\nfrom numpy import sqrt\nfrom scipy.stats import norm\n\n# classification\nfrom sklearn.metrics import precision_score\nfrom sklearn.metrics import recall_score\nfrom sklearn.metrics import f1_score\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.metrics import roc_curve\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.metrics import roc_auc_score\nfrom sklearn.metrics import matthews_corrcoef\nfrom sklearn.exceptions import NotFittedError\n\n# regression\nfrom sklearn.metrics import mean_absolute_error\nfrom sklearn.metrics import mean_squared_error\nfrom sklearn.metrics import r2_score\n\nclass ClassificationEvaluator():\n    \"\"\"Evaluator class encapsulating classification model metrics\n    and plotting functionality.\n\n    Attributes\n    ----------\n    y_true : np.ndarray\n        True binary target data labels.\n    y_pred : np.ndarray\n        Target scores of the model.\n    confusion_matrix : np.ndarray\n        Confusion matrix computed for a particular cut-off.\n    cumulative_gains : tuple\n        Data for plotting cumulative gains curve.\n    evaluation_metrics : dict\n        Map containing various scalar evaluation metrics (precision, recall, accuracy, AUC, F1, etc.).\n    lift_at : float\n        Parameter to determine at which top level percentage the lift of the\n        model should be computed.\n    lift_curve : tuple\n        Data for plotting lift curve(s).\n    probability_cutoff : float\n        Probability cut off to convert probability scores to a binary score.\n    roc_curve : dict\n        Map containing true-positive-rate, false-positive-rate at various\n        thresholds (also incl.).\n    n_bins : int, optional\n        Defines the number of bins used to calculate the lift curve for\n        (by default 10, so deciles).\n    \"\"\"\n\n    def __init__(self,\n                 probability_cutoff: float=None,\n                 lift_at: float=0.05,\n                 n_bins: int = 10):\n\n        self.y_true = None\n        self.y_pred = None\n\n        self.lift_at = lift_at\n        self.probability_cutoff = probability_cutoff\n        self.n_bins = n_bins\n\n        # Placeholder to store fitted output\n        self.scalar_metrics = None\n        self.roc_curve = None\n        self.confusion_matrix = None\n        self.lift_curve = None\n        self.cumulative_gains = None\n\n    def fit(self, y_true: np.ndarray, y_pred: np.ndarray):\n        \"\"\"Fit the evaluator by computing the relevant evaluation metrics on\n        the inputs.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True labels.\n        y_pred : np.ndarray\n            Model scores (as probability).\n        \"\"\"\n        fpr, tpr, thresholds = roc_curve(y_true=y_true, y_score=y_pred)\n\n        # if probability_cutoff is not set, take the optimal cut-off\n        if not self.probability_cutoff:\n            self.probability_cutoff = (ClassificationEvaluator.\n                                       _compute_optimal_cutoff(fpr, tpr,\n                                                               thresholds))\n\n        # Transform probabilities to binary array using cut-off\n        y_pred_b = np.array([0 if pred <= self.probability_cutoff else 1\n                             for pred in y_pred])\n\n        # Compute the various evaluation metrics\n        self.scalar_metrics = ClassificationEvaluator._compute_scalar_metrics(\n            y_true,\n            y_pred,\n            y_pred_b,\n            self.lift_at\n        )\n\n        self.y_true = y_true\n        self.y_pred = y_pred\n\n        self.roc_curve = {\"fpr\": fpr, \"tpr\": tpr, \"thresholds\": thresholds}\n        self.confusion_matrix = confusion_matrix(y_true, y_pred_b)\n        self.lift_curve = ClassificationEvaluator._compute_lift_per_bin(y_true, y_pred, self.n_bins)\n        self.cumulative_gains = ClassificationEvaluator._compute_cumulative_gains(y_true, y_pred)\n\n    @staticmethod\n    def _compute_scalar_metrics(y_true: np.ndarray,\n                                y_pred: np.ndarray,\n                                y_pred_b: np.ndarray,\n                                lift_at: float) -> pd.Series:\n        \"\"\"Convenient function to compute various scalar performance measures\n        and return them in a pd.Series.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n        y_pred_b : np.ndarray\n            Predicted target data labels (binary).\n        lift_at : float\n            At what top level percentage the lift should be computed.\n\n        Returns\n        -------\n        pd.Series\n            Contains various performance measures of the model, being:\n                Accuracy\n                AUC\n                Precision\n                Recall\n                F1\n                Matthews correlation coefficient\n                Lift at given percentage\n        \"\"\"\n        return pd.Series({\n            \"accuracy\": accuracy_score(y_true, y_pred_b),\n            \"AUC\": roc_auc_score(y_true, y_pred),\n            \"precision\": precision_score(y_true, y_pred_b),\n            \"recall\": recall_score(y_true, y_pred_b),\n            \"F1\": f1_score(y_true, y_pred_b, average=None)[1],\n            \"matthews_corrcoef\": matthews_corrcoef(y_true, y_pred_b),\n            \"lift at {}\".format(lift_at): np.round(ClassificationEvaluator\n                                                   ._compute_lift(y_true=y_true,\n                                                                  y_pred=y_pred,\n                                                                  lift_at=lift_at), 2)\n        })\n\n    def plot_roc_curve(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Plot ROC curve of the model.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n\n        if self.roc_curve is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n            raise NotFittedError(msg.format(self.__class__.__name__))\n\n        auc = float(self.scalar_metrics.loc[\"AUC\"])\n\n        with plt.style.context(\"seaborn-whitegrid\"):\n\n            fig, ax = plt.subplots(figsize=dim)\n\n            ax.plot(self.roc_curve[\"fpr\"],\n                    self.roc_curve[\"tpr\"],\n                    color=\"cornflowerblue\", linewidth=3,\n                    label=\"ROC curve (area = {s:.3})\".format(s=auc))\n\n            ax.plot([0, 1], [0, 1], color=\"darkorange\", linewidth=3,\n                    linestyle=\"--\")\n            ax.set_xlabel(\"False Positive Rate\", fontsize=15)\n            ax.set_ylabel(\"True Positive Rate\", fontsize=15)\n            ax.legend(loc=\"lower right\")\n            ax.set_title(\"ROC curve\", fontsize=20)\n\n            if path:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n        plt.show()\n\n    def plot_confusion_matrix(self, path: str=None, dim: tuple=(12, 8),\n                              labels: list=[\"0\", \"1\"]):\n        \"\"\"Plot the confusion matrix.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        labels : list, optional\n            Optional list of labels, default \"0\" and \"1\".\n        \"\"\"\n\n        if self.confusion_matrix is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n            raise NotFittedError(msg.format(self.__class__.__name__))\n\n        fig, ax = plt.subplots(figsize=dim)\n        ax = sns.heatmap(self.confusion_matrix,\n                         annot=self.confusion_matrix.astype(str),\n                         fmt=\"s\", cmap=\"Blues\",\n                         xticklabels=labels, yticklabels=labels)\n        ax.set_title(\"Confusion matrix\", fontsize=20)\n\n        if path:\n            plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n        plt.show()\n\n    def plot_cumulative_response_curve(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Plot cumulative response curve.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n\n        if self.lift_curve is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n            raise NotFittedError(msg.format(self.__class__.__name__))\n\n        x_labels, lifts, inc_rate = self.lift_curve\n\n        lifts = np.array(lifts)*inc_rate*100\n\n        with plt.style.context(\"seaborn-ticks\"):\n            fig, ax = plt.subplots(figsize=dim)\n\n            plt.bar(x_labels[::-1], lifts, align=\"center\",\n                    color=\"cornflowerblue\")\n            plt.ylabel(\"response (%)\", fontsize=16)\n            plt.xlabel(\"decile\", fontsize=16)\n            ax.set_xticks(x_labels)\n            ax.set_xticklabels(x_labels)\n\n            plt.axhline(y=inc_rate*100, color=\"darkorange\", linestyle=\"--\",\n                        xmin=0.05, xmax=0.95, linewidth=3, label=\"Incidence\")\n\n            # Legend\n            ax.legend(loc=\"upper right\")\n\n            # Set Axis - make them pretty\n            sns.despine(ax=ax, right=True, left=True)\n\n            # Remove white lines from the second axis\n            ax.grid(False)\n\n            # Description\n            ax.set_title(\"Cumulative Response curve\", fontsize=20)\n\n            if path is not None:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n            plt.show()\n\n    def plot_lift_curve(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Plot lift per decile.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n\n        if self.lift_curve is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n            raise NotFittedError(msg.format(self.__class__.__name__))\n\n        x_labels, lifts, _ = self.lift_curve\n\n        with plt.style.context(\"seaborn-ticks\"):\n            fig, ax = plt.subplots(figsize=dim)\n\n            plt.bar(x_labels[::-1], lifts, align=\"center\",\n                    color=\"cornflowerblue\")\n            plt.ylabel(\"lift\", fontsize=16)\n            plt.xlabel(\"decile\", fontsize=16)\n            ax.set_xticks(x_labels)\n            ax.set_xticklabels(x_labels)\n\n            plt.axhline(y=1, color=\"darkorange\", linestyle=\"--\",\n                        xmin=0.05, xmax=0.95, linewidth=3, label=\"Baseline\")\n\n            # Legend\n            ax.legend(loc=\"upper right\")\n\n            # Set Axis - make them pretty\n            sns.despine(ax=ax, right=True, left=True)\n\n            # Remove white lines from the second axis\n            ax.grid(False)\n\n            # Description\n            ax.set_title(\"Cumulative Lift curve\", fontsize=20)\n\n            if path is not None:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n            plt.show()\n\n    def plot_cumulative_gains(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Plot cumulative gains per decile.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n\n        with plt.style.context(\"seaborn-whitegrid\"):\n            fig, ax = plt.subplots(figsize=dim)\n\n            ax.plot(self.cumulative_gains[0]*100, self.cumulative_gains[1]*100,\n                    color=\"cornflowerblue\", linewidth=3,\n                    label=\"cumulative gains\")\n            ax.plot(ax.get_xlim(), ax.get_ylim(), linewidth=3,\n                    ls=\"--\", color=\"darkorange\", label=\"random selection\")\n\n            ax.set_title(\"Cumulative Gains curve\", fontsize=20)\n\n            # Format axes\n            ax.set_xlim([0, 100])\n            ax.set_ylim([0, 105])\n\n            # Format ticks\n            ticks_loc_y = ax.get_yticks().tolist()\n            ax.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc_y))\n            ax.set_yticklabels([\"{:3.0f}%\".format(x) for x in ticks_loc_y])\n\n            ticks_loc_x = ax.get_xticks().tolist()\n            ax.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc_x))\n            ax.set_xticklabels([\"{:3.0f}%\".format(x) for x in ticks_loc_x])\n\n            # Legend\n            ax.legend(loc=\"lower right\")\n\n            if path is not None:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n            plt.show()\n\n    @staticmethod\n    def _find_optimal_cutoff(y_true: np.ndarray,\n                             y_pred: np.ndarray) -> float:\n        \"\"\"Find the optimal probability cut off point for a\n        classification model. Wrapper around _compute_optimal_cutoff.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n\n        Returns\n        -------\n        float\n            Optimal cut-off probability for the model.\n        \"\"\"\n        return ClassificationEvaluator._compute_optimal_cutoff(roc_curve(y_true=y_true,\n                                                                         y_score=y_pred))\n\n    @staticmethod\n    def _compute_optimal_cutoff(fpr: np.ndarray, tpr: np.ndarray,\n                                thresholds: np.ndarray) -> float:\n        \"\"\"Find the optimal probability cut-off point for a\n        classification model.\n\n        The optimal cut-off would be where TPR is high and FPR is low, hence\n        TPR - (1-FPR) should be zero or close to zero for the optimal cut-off.\n\n        Parameters\n        ----------\n        fpr : np.ndarray\n            False positive rate for various thresholds.\n        tpr : np.ndarray\n            True positive rate for various thresholds.\n        thresholds : np.ndarray\n            List of thresholds for which fpr and tpr were computed.\n\n        Returns\n        -------\n        float\n            Optimal probability cut-off point.\n        \"\"\"\n        temp = np.absolute(tpr - (1-fpr))\n\n        # index for optimal value is the one for which temp is minimal\n        optimal_index = np.where(temp == min(temp))[0]\n\n        return thresholds[optimal_index][0]\n\n    @staticmethod\n    def _compute_cumulative_gains(y_true: np.ndarray,\n                                  y_pred: np.ndarray) -> tuple:\n        \"\"\"Compute cumulative gains of the model, returns percentages and\n        gains cumulative gains curves.\n\n        Code from (https:\/\/github.com\/reiinakano\/scikit-plot\/blob\/\n                   2dd3e6a76df77edcbd724c4db25575f70abb57cb\/\n                   scikitplot\/helpers.py#L157)\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n\n        Returns\n        -------\n        tuple\n            With x-labels, and gains.\n        \"\"\"\n\n        # make y_true a boolean vector\n        y_true = (y_true == 1)\n\n        sorted_indices = np.argsort(y_pred)[::-1]\n        y_true = y_true[sorted_indices]\n        gains = np.cumsum(y_true)\n\n        percentages = np.arange(start=1, stop=len(y_true) + 1)\n\n        gains = gains \/ float(np.sum(y_true))\n        percentages = percentages \/ float(len(y_true))\n\n        gains = np.insert(gains, 0, [0])\n        percentages = np.insert(percentages, 0, [0])\n\n        return percentages, gains\n\n    @staticmethod\n    def _compute_lift_per_bin(y_true: np.ndarray,\n                              y_pred: np.ndarray,\n                              n_bins: int=10) -> tuple:\n        \"\"\"Compute lift of the model for a given number of bins, returns x-labels,\n        lifts and the target incidence to create cumulative response curves.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n        n_bins : int, optional\n            Defines the number of bins used to calculate the lift curve for\n            (by default 10, so deciles).\n\n        Returns\n        -------\n        tuple\n            Includes x-labels, lifts per decile, and target incidence.\n        \"\"\"\n\n        lifts = [ClassificationEvaluator._compute_lift(y_true=y_true,\n                                                       y_pred=y_pred,\n                                                       lift_at=perc_lift)\n                 for perc_lift in np.linspace(1\/n_bins, 1, num=n_bins, endpoint=True)]\n\n        x_labels = [len(lifts)-x for x in np.arange(0, len(lifts), 1)]\n\n        return x_labels, lifts, y_true.mean()\n\n    @staticmethod\n    def _compute_lift(y_true: np.ndarray, y_pred: np.ndarray,\n                      lift_at: float=0.05) -> float:\n        \"\"\"Calculates lift given two arrays on specified level.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n        lift_at : float, optional\n            At what top level percentage the lift should be computed.\n\n        Returns\n        -------\n        float\n            Lift of the model.\n        \"\"\"\n\n        # Make sure it is numpy array\n        y_true_ = np.array(y_true)\n        y_pred_ = np.array(y_pred)\n\n        # Make sure it has correct shape\n        y_true_ = y_true_.reshape(len(y_true_), 1)\n        y_pred_ = y_pred_.reshape(len(y_pred_), 1)\n\n        # Merge data together\n        y_data = np.hstack([y_true_, y_pred_])\n\n        # Calculate necessary variables\n        nrows = len(y_data)\n        stop = int(np.floor(nrows*lift_at))\n        avg_incidence = np.einsum(\"ij->j\", y_true_)\/float(len(y_true_))\n\n        # Sort and filter data\n        data_sorted = (y_data[y_data[:, 1].argsort()[::-1]][:stop, 0]\n                       .reshape(stop, 1))\n\n        # Calculate lift (einsum is a very fast way of summing, but needs specific shape)\n        inc_in_top_n = np.einsum(\"ij->j\", data_sorted)\/float(len(data_sorted))\n\n        lift = np.round(inc_in_top_n\/avg_incidence, 2)[0]\n\n        return lift\n\n\nclass RegressionEvaluator():\n    \"\"\"Evaluator class encapsulating regression model metrics\n    and plotting functionality.\n\n    Attributes\n    ----------\n    y_true : np.ndarray\n        True binary target data labels.\n    y_pred : np.ndarray\n        Target scores of the model.\n    scalar_metrics : dict\n        Map containing various scalar evaluation metrics (R-squared, MAE, MSE, RMSE)\n    qq : pd.Series\n        Theoretical quantiles and associated actual residuals.\n    \"\"\"\n\n    def __init__(self):\n\n        self.y_true = None\n        self.y_pred = None\n\n        # Placeholder to store fitted output\n        self.scalar_metrics = None\n        self.qq = None\n\n    def fit(self, y_true: np.ndarray, y_pred: np.ndarray):\n        \"\"\"Fit the evaluator by computing the relevant evaluation metrics on\n        the inputs.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True labels.\n        y_pred : np.ndarray\n            Model scores.\n        \"\"\"\n        # Compute the various evaluation metrics\n        self.scalar_metrics = RegressionEvaluator._compute_scalar_metrics(y_true, y_pred)\n\n        self.y_true = y_true\n        self.y_pred = y_pred\n\n        # Compute qq info\n        self.qq = RegressionEvaluator._compute_qq_residuals(y_true, y_pred)\n\n    @staticmethod\n    def _compute_scalar_metrics(y_true: np.ndarray,\n                                y_pred: np.ndarray) -> pd.Series:\n        \"\"\"Convenient function to compute various scalar performance measures\n        and return them in a pd.Series.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n\n        Returns\n        -------\n        pd.Series\n            Contains various performance measures of the model, being:\n                R-squared (coefficient of determination, usually denoted as R-squared)\n                Mean absolute error (expected value of the absolute error loss)\n                Mean squared error (expected value of the quadratic error)\n                Root mean squared error (sqrt of expected value of the quadratic error)\n        \"\"\"\n        return pd.Series({\n            \"R2\": r2_score(y_true, y_pred),\n            \"MAE\": mean_absolute_error(y_true, y_pred),\n            \"MSE\": mean_squared_error(y_true, y_pred),\n            \"RMSE\": sqrt(mean_squared_error(y_true, y_pred))\n        })\n\n    @staticmethod\n    def _compute_qq_residuals(y_true: np.ndarray,\n                              y_pred: np.ndarray) -> pd.Series:\n        \"\"\"Convenience function to compute various scalar performance measures\n        and return them in a pd.Series.\n\n        Parameters\n        ----------\n        y_true : np.ndarray\n            True binary target data labels.\n        y_pred : np.ndarray\n            Target scores of the model.\n\n        Returns\n        -------\n        pd.Series\n            Theoretical quantiles and associated actual residuals.\n        \"\"\"\n        ## also possible directly via statsmodels.api.qqplot()\n\n        n = len(y_true)\n\n        df = pd.DataFrame({\"res\": sorted((y_true - y_pred))})  # ascending order\n        m, s = df[\"res\"].mean(), df[\"res\"].std()\n\n        df[\"z_res\"] = df[\"res\"].apply(lambda x: (x-m)\/s)\n        df[\"rank\"] = df.index+1\n        df[\"percentile\"] = df[\"rank\"].apply(lambda x: x\/(n+1))  # divide by n+1 to avoid inf\n        df[\"q_theoretical\"] = norm.ppf(df[\"percentile\"])\n\n        return pd.Series({\n            \"quantiles\": df[\"q_theoretical\"].values,\n            \"residuals\": df[\"z_res\"].values,\n        })\n\n    def plot_predictions(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Plot predictions from the model against actual values.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n        if self.y_true is None and self.y_pred is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n        y_true = self.y_true\n        y_pred = self.y_pred\n\n        with plt.style.context(\"seaborn-whitegrid\"):\n\n            fig, ax = plt.subplots(figsize=dim)\n\n            x = np.arange(1, len(y_true)+1)\n\n            ax.plot(x, y_true, ls=\"--\", label=\"actuals\", color=\"darkorange\", linewidth=3)\n            ax.plot(x, y_pred, label=\"predictions\", color=\"cornflowerblue\", linewidth=3)\n\n            ax.set_xlabel(\"Index\", fontsize=15)\n            ax.set_ylabel(\"Value\", fontsize=15)\n            ax.legend(loc=\"best\")\n            ax.set_title(\"Predictions vs. Actuals\", fontsize=20)\n\n            if path:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n        plt.show()\n\n    def plot_qq(self, path: str=None, dim: tuple=(12, 8)):\n        \"\"\"Display a Q-Q plot from the standardized prediction residuals.\n\n        Parameters\n        ----------\n        path : str, optional\n            Path to store the figure.\n        dim : tuple, optional\n            Tuple with width and length of the plot.\n        \"\"\"\n\n        if self.qq is None:\n            msg = (\"This {} instance is not fitted yet. Call 'fit' with \"\n                   \"appropriate arguments before using this method.\")\n\n            raise NotFittedError(msg.format(self.__class__.__name__))\n\n        with plt.style.context(\"seaborn-whitegrid\"):\n\n            fig, ax = plt.subplots(figsize=dim)\n\n            x = self.qq[\"quantiles\"]\n            y = self.qq[\"residuals\"]\n\n            ax.plot(x, x, ls=\"--\", label=\"perfect model\", color=\"darkorange\", linewidth=3)\n            ax.plot(x, y, label=\"current model\", color=\"cornflowerblue\", linewidth=3)\n\n            ax.set_xlabel(\"Theoretical quantiles\", fontsize=15)\n            ax.set_xticks(range(int(np.floor(min(x))), int(np.ceil(max(x[x < float(\"inf\")])))+1, 1))\n\n            ax.set_ylabel(\"Standardized residuals\", fontsize=15)\n            ax.set_yticks(range(int(np.floor(min(y))), int(np.ceil(max(y[x < float(\"inf\")])))+1, 1))\n\n            ax.legend(loc=\"best\")\n            ax.set_title(\"Q-Q plot\", fontsize=20)\n\n            if path:\n                plt.savefig(path, format=\"png\", dpi=300, bbox_inches=\"tight\")\n\n        plt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_39","text":"<filename>test\/test_biplot.py<gh_stars>1-10\nimport unittest\nimport numpy as np\nimport pandas as pd\nfrom biofes.biplot import *\nfrom biofes import biplot\nfrom scipy import stats\n\nclass test_functions(unittest.TestCase):\n    def test_standardize(self):\n        A = np.random.uniform(-300,300,size=(300,30))\n        A_st = standardize(A, meth=1)\n        A_ref = (A-A.mean(axis = 0))\/A.std(axis = 0)\n        self.assertAlmostEqual(np.mean(A_ref - A_st), 0, msg='standardization error')\n    \n    def test_Factor2Binary(self):\n        target = list(np.random.randint(np.random.randint(2, 10), size = 100))\n        Z = Factor2Binary(target,Name = None)\n        \n        Z_ref = pd.get_dummies(target)\n        self.assertAlmostEqual(np.mean(Z_ref.values - Z.values), 0, msg='Factor2Binary error')\n    \n    def test_matrixsqrt(self):\n        A = np.random.randint(low = 0, high = 200, size=(300, 30))\n        d = np.random.randint(30)\n        tol = np.finfo(float).eps\n        \n        Sinv = matrixsqrt(A, d, tol, inv=True)\n        U, Sigma, VT = SVD(A, d, niter=5, state=0)\n        nz = Sigma > tol\n        Sinv_ref = U.dot(np.diag(1\/np.sqrt(Sigma[nz]))).dot(VT[nz,:])\n        self.assertAlmostEqual(np.mean(Sinv_ref - Sinv), 0, delta=1e-3, msg='matrixsqrt (inv=True) error')\n        \n        ###############################################################################\n        \n        A = np.random.randint(low = 0, high = 200, size=(300, 30))\n        d = np.random.randint(30)\n        tol = np.finfo(float).eps\n        \n        S = matrixsqrt(A, d, tol, inv=False)\n        U, Sigma, VT = SVD(A, d, niter=5, state=0)\n        nz = Sigma > tol\n        S_ref = U.dot(np.diag(np.sqrt(Sigma[nz]))).dot(VT[nz,:])\n        self.assertAlmostEqual(np.mean(S_ref - S), 0, delta=1e-3, msg='matrixsqrt (inv=False) error')\n        \n        \nclass test_biplot(unittest.TestCase):\n    def test_Classic(self):\n        n, p = np.random.randint(70,500), np.random.randint(30,50)\n        \n        A = np.random.uniform(-300,300,size=(n,p))\n        d = np.random.randint(p)\n        a = np.random.random(1)[0]\n        methods = [None, 1]\n        m = methods[np.random.randint(2)]\n        \n        data_st = standardize(A, m)\n        U, Sigma, VT = SVD(data_st, d, niter = 35, state = 0)\n        \n        EV_ref = np.power(Sigma,2)\n        Inert_ref = EV_ref\/np.sum(EV_ref) * 100\n        \n        # Contributions\n        \n        R = U.dot(np.diag(Sigma[:d]))\n        C = np.transpose(VT).dot(np.diag(Sigma[:d]))\n        \n        sf = np.sum(np.power(A,2),axis=1)\n        cf = np.zeros((n,d))\n        for k in range(0,d):\n            cf[:,k] = np.power(R[:,k],2)*100\/sf\n        \n        sc = np.sum(np.power(A, 2),axis=0)\n        cc = np.zeros((p,d))\n        for k in range(0,d):\n            cc[:,k] = np.power(C[:,k],2)*100\/sc\n        \n        # Coordinates\n\n        R = R.dot(np.diag(np.power(Sigma,a)))\n        C = C.dot(np.diag(np.power(Sigma,1-a)))\n\n        sca = np.sum(np.power(R,2))\/n\n        scb = np.sum(np.power(C,2))\/p\n        scf = np.sqrt(np.sqrt(scb\/sca))\n\n        RowCoord_ref = R*scf\n        ColCoord_ref = C\/scf\n        \n        # biplot from biofes\n        \n        BCla = biplot.Classic(data = A ,dim = d, alpha = a, method = m, niter = 35, state = 0)\n        \n        # DIMENSION TEST\n        self.assertEqual(BCla.RowCoord.shape, (n, d), msg='dimension output error (Classic Biplot)')\n        self.assertEqual(BCla.ColCoord.shape, (p, d) , msg='dimension output error (Classic Biplot)')\n        self.assertEqual(len(BCla.Inert), d, msg='dimension output error (Classic Biplot)')\n        self.assertEqual(len(BCla.EV)   , d, msg='dimension output error (Classic Biplot)')\n        \n        # INERTIA \/ EV TEST\n        try:\n            if str((EV_ref - EV).mean()) == 'nan':\n                pass\n            else:\n                self.assertAlmostEqual(np.mean(EV_ref - BCla.EV), 0, msg='EV error')\n                self.assertAlmostEqual(np.mean(Inert_ref - BCla.Inert), 0, msg='Inertia error')\n        except:\n            pass\n        \n        # CONTRIBUTIONS TEST\n        try:\n            if str((cf - BCla.RowCont).mean()) == 'nan':\n                pass\n            else:\n                els = cf.shape[0]*cf.shape[1]\n                self.assertAlmostEqual(np.mean(cf - BCla.RowCont), 0, delta=els*(1e-2), msg='Row Contributions error')\n                els = cc.shape[0]*cc.shape[1]\n                self.assertAlmostEqual(np.mean(cc - BCla.ColCont), 0, delta=els*(1e-2), msg='Column Contributions error')\n        except:\n            pass\n        \n        # COORDINATES TEST\n        self.assertAlmostEqual(np.mean(RowCoord_ref - BCla.RowCoord), 0, delta=1e-3, msg='Row Coordinates error')\n        self.assertAlmostEqual(np.mean(ColCoord_ref - BCla.ColCoord), 0, delta=1e-3, msg='Col Coordinates error')\n        \n    def test_Canonical(self):\n        n, m = np.random.randint(70,500), np.random.randint(10,50)\n        A = np.random.uniform(-300,300,size=(n,m))\n        target = list(np.random.randint(np.random.randint(2, 10), size = A.shape[0]))\n        gn = list(set(target))\n        g = len(gn)\n        d = np.random.randint(len(gn)+1, m)\n        methods = [None, 1]\n        met = methods[np.random.randint(2)]\n        \n        data_std = standardize(A, met)\n        r = np.array([len(gn) - 1, m]).min()\n        #Groups to Binary\n        Z = Factor2Binary(target)\n        ng = Z.sum(axis=0)\n        S11 = (Z.T).dot(Z).values\n        \n        Xb = np.linalg.inv(S11).dot(Z.T).dot(data_std)\n        B = (Xb.T).dot(S11).dot(Xb)\n        S = (data_std.T).dot(data_std) - B\n        Y = np.power(S11,0.5).dot(Xb).dot(matrixsqrt(S,d,inv=True))\n        \n        U, Sigma, VT = SVD(Y, d, niter = 15, state = 0)\n        \n        #Variable_Coord\n        H = matrixsqrt(S, d, inv=False).dot(np.transpose(VT[0:r,:]))\n        #Canonical_Weights\n        B = matrixsqrt(S, d, inv=True ).dot(np.transpose(VT[0:r,:]))\n        #Group_Coord\n        J = Xb.dot(B)\n        #Individual_Coord\n        V = data_std.dot(B)\n        \n        sct = np.diag((V.T).dot(V))\n        sce = np.diag((J.T).dot(S11).dot(J))\n        scr = sct -sce\n        fs = (sce\/(g - 1))\/(scr\/(n - g))\n        \n        #eigenvectors\n        vprop = Sigma[:r]\n        #Inertia\n        iner = (np.power(vprop,2)\/(np.power(vprop,2).sum()))*100\n        \n        lamb = np.power(vprop,2)\n        pill = 1\/(1 + lamb)\n        pillai = np.linalg.det(np.diag(pill))\n        glh = g - 1\n        gle = n - g\n        t = np.sqrt((np.power(glh,2) * np.power(m,2) - 4)\/(np.power(m,2) + np.power(glh,2) - 5))\n        w = gle + glh - 0.5 * (m + glh + 1)\n        df1 = m * glh\n        df2 = w * t - 0.5 * (m * glh - 2)\n        \n        # Wilks\n        Wilksf = (1 - np.power(pillai,1\/t))\/(np.power(pillai,1\/t)) * (df2\/df1)\n        Wilksp = stats.f.pdf(Wilksf, df1, df2)\n        Wilks = {'f-val': Wilksf,'p-val': Wilksp}\n        \n        # Radius\n        \n        falfau = stats.t.ppf(1 - (0.025), (n - g))\n        falfab = stats.t.ppf(1 - (0.025\/(g * m)), (n - g))\n        falfam = np.sqrt(stats.f.ppf(1 - 0.05, m, (n - g - m + 1)) * (((n - g) * m)\/(n - g - m + 1)))\n        falfac = 2.447747\n\n        UnivRad = falfau * np.diag(np.linalg.inv(np.sqrt(S11)))\/np.sqrt(n - g)\n        BonfRad = falfab * np.diag(np.linalg.inv(np.sqrt(S11)))\/np.sqrt(n - g)\n        MultRad = falfam * np.diag(np.linalg.inv(np.sqrt(S11)))\/np.sqrt(n - g)\n        ChisRad = falfac * np.diag(np.linalg.inv(np.sqrt(S11)))\/np.sqrt(n - g)\n\n        Radius = {'Uni': UnivRad,'Bonf': BonfRad, 'Mult': MultRad, 'Chis': ChisRad}\n        \n        BCan = biplot.Canonical(data = A, dim = d, GroupNames = gn, y = target, method = met, niter = 35, state = 0)\n        \n        # DIMENSION TEST\n        self.assertEqual(BCan.Ind_Coord.shape, (n, len(gn)-1), msg='dimension output error (Canonical Biplot) Ind_Coord')\n        self.assertEqual(BCan.Var_Coord.shape, (m, len(gn)-1), msg='dimension output error (Canonical Biplot) Var_Coord')\n        self.assertEqual(BCan.Group_Coord.shape, (len(gn), len(gn)-1), msg='dimension output error (Canonical Biplot) Group_Coord')\n        self.assertEqual(len(BCan.inert), len(gn)-1, msg='dimension output error (Canonical Biplot)')\n        \n        # COORDINATES TEST\n        els = H.shape[0]*H.shape[1]\n        self.assertAlmostEqual(np.mean(H - BCan.Var_Coord), 0, delta=els*(1e-2), msg='Var Coordinates error')\n        els = V.shape[0]*V.shape[1]\n        self.assertAlmostEqual(np.mean(V - BCan.Ind_Coord), 0, delta=els*(1e-2), msg='Ind Coordinates error')\n        els = J.shape[0]*J.shape[1]\n        self.assertAlmostEqual(np.mean(J - BCan.Group_Coord), 0, delta=els*(1e-2), msg='Group Coordinates error')\n        \n        # CANONICAL WEIGHTS TEST\n        els = B.shape[0]*B.shape[1]\n        self.assertAlmostEqual(np.mean(B - BCan.Can_Weights), 0, delta=els*(1e-2), msg='Canonical Weights error')\n        \n        # EV \/ INERTIA TEST\n        try:\n            if str((vprop - BCan.vprop).mean()) == 'nan':\n                pass\n            else:\n                self.assertAlmostEqual(np.mean(vprop - BCan.vprop), 0, msg='EV error')\n                self.assertAlmostEqual(np.mean(iner -  BCan.inert), 0, msg='Inertia error')\n        except:\n            pass\n        \n        # WILKS TEST\n        self.assertAlmostEqual(Wilks['f-val'] - BCan.Wilks['f-val'], 0, delta=(1e-2), msg='f-val Wilks error')\n        self.assertAlmostEqual(Wilks['p-val'] - BCan.Wilks['p-val'], 0, delta=(1e-2), msg='p-val Wilks error')\n        \n        # RADIUS\n        self.assertAlmostEqual(np.mean(Radius['Uni'] - BCan.Radius['Uni']), 0, delta=(1e-3), msg='Uni Radius error')\n        self.assertAlmostEqual(np.mean(Radius['Bonf'] - BCan.Radius['Bonf']), 0, delta=(1e-3), msg='Bonferroni Radius error')\n        self.assertAlmostEqual(np.mean(Radius['Mult'] - BCan.Radius['Mult']), 0, delta=(1e-3), msg='Mult Radius error')\n        self.assertAlmostEqual(np.mean(Radius['Chis'] - BCan.Radius['Chis']), 0, delta=(1e-3), msg='Chi-sqr Radius error')\n        \n    def test_CA(self):\n        n, p = np.random.randint(100, 500), np.random.randint(50, 90)\n        A = np.random.randint(np.random.randint(1,10), np.random.randint(30,200), (n,p))\n        dim = np.random.randint(p)\n        a = np.random.random(1)[0]\n        \n        BCA = biplot.CA(data=A, dim=dim, alpha=a ,niter=15, state=0)\n        \n        A = A \/ A.sum()\n        \n        dr = np.matrix(A.sum(axis=1))\n        dc = np.matrix(A.sum(axis=0))\n        \n        A = A - dr.T.dot(dc)\n        \n        Dr = np.diagflat(1\/np.sqrt(dr))\n        Dc = np.diagflat(1\/np.sqrt(dc))\n        A = Dr.dot(A).dot(Dc)\n        \n        U, Sigma, VT = SVD(A, dim, niter = 15, state = 0)\n        \n        d = Sigma[:np.min(A.shape)]\n        r = np.min(A.shape)\n        \n        inertia = numpy.power(d,2)*100 \/ numpy.sum(numpy.power(d,2))\n        \n        U = Dr.dot(U[:,:r])\n        V = Dc.dot(VT.T[:,:r])\n        \n        D = np.diagflat(d)\n        A = U.dot(D)\n        B = V.dot(D)\n        \n        sf = np.power(A,2).sum(axis = 1)\n        cf = np.linalg.inv(np.diagflat(sf)).dot(np.power(A,2))\n        \n        sc = np.power(B,2).sum(axis = 1)\n        cc = np.linalg.inv(np.diagflat(sc)).dot(np.power(B,2))\n        \n        A = U.dot(np.diagflat(np.power(d,a)))\n        B = V.dot(np.diagflat(np.power(d,1-a)))\n        \n        # AB\n        AB = A[:, :dim].dot(B[:, :dim].T)\n        \n        # Eigenvalues\n        eigen_values = np.power(d,2)\n        \n        # Coordinates\n        RowCoordinates = A[:, :dim]\n        ColCoordinates = B[:, :dim]\n        \n        # Contributions\n        RowContributions = cf[:, :dim] * 100\n        ColContributions = cc[:, :dim] * 100\n        \n        # INERTIA TEST\n        try:\n            if str((inertia -  BCA.inertia).mean()) == 'nan':\n                pass\n            else:\n                self.assertAlmostEqual(np.mean(inertia -  BCA.inertia), 0, msg='Inertia error')\n                self.assertAlmostEqual(np.mean(eigen_values -  BCA.eigen_values), 0, msg='eigen values error')\n        except:\n            pass\n        \n        # AB TEST\n        self.assertAlmostEqual(np.mean(AB - BCA.AB), 0, delta=(1e-2), msg='AB error')\n        \n        # COORDINATES TEST\n        els = RowCoordinates.shape[0]*RowCoordinates.shape[1]\n        self.assertAlmostEqual(np.mean(RowCoordinates - BCA.RowCoordinates), 0, delta=els*(1e-2), msg='Row Coordinates error')\n        els = ColCoordinates.shape[0]*ColCoordinates.shape[1]\n        self.assertAlmostEqual(np.mean(ColCoordinates - BCA.ColCoordinates), 0, delta=els*(1e-2), msg='Col Coordinates error')\n        \n        # CONTRIBUTIONS TEST\n        try:\n            if str((cf - BCla.RowCont).mean()) == 'nan':\n                pass\n            else:\n                els = RowContributions.shape[0]*RowContributions.shape[1]\n                self.assertAlmostEqual(np.mean(RowContributions - BCA.RowContributions), 0, delta=els*(1e-2), msg='Row Contributions error')\n                els = ColContributions.shape[0]*ColContributions.shape[1]\n                self.assertAlmostEqual(np.mean(ColContributions - BCA.ColContributions), 0, delta=els*(1e-2), msg='Column Contributions error')\n        except:\n            pass\n\nif __name__ == '__main__':\n    unittest.main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_40","text":"<filename>Little_Square.py\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Oct 25 10:43:58 2017\n\n@author: <NAME>\n\"\"\"\n\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Oct 17 06:14:39 2017\n\n@author: Salem\n\nstarting with a single square I want to see if I can add points (which I will call grey matter) to it that will make it's 4 nodes move in a desired way. \n\nAll the points will be connected, when the cost is minimized some of the spring constants will be allowed to go to zero, (2 N - 4) of them to be specific.\n\nElastic energy is minimized first, then the cost function brings this energy to zero for the desired motion.\n\nnormalizeVec, connect_all_verts, makeRigidityMat are defined in LatticeMaking\n\nMethods: \n         find_desired_square(deformationType = DispType.random, edgeType = EdgeTypes.all_connected, \n                        num_of_added_verts = NUM_OF_ADDED_VERTS, squareDisp = None)\n         \n         initialize_square(num_of_added_points)\n         \n         TODO fill this up\n\"\"\"\n\nimport numpy as np\nimport numpy.random as npr\nimport LatticeMaking\nfrom numpy import linalg as la\nfrom matplotlib import pyplot as plt\nimport scipy.optimize as op\nimport importlib\nimportlib.reload(LatticeMaking)\n\nfrom LatticeMaking import *  #custom\nfrom enum import Enum\n\nNUM_OF_ADDED_VERTS = 5;\nNUM_OF_DIMENSIONS = 2;\n\n#maximum number of trials before adding more vertices to the gray matter\nMAX_TRIALS = 30\n\n# the coupling constant for the energy gap in the cost function \nEIG_VAL_REPULSION = 1\n\n# the potential barier of the walls\nWAll_BARRIER = 1000;\n\n\n# this is the part we want to control the motion of, these vertices will be fixed.\nLITTLE_SQUARE = np.array([[0.0, 0.0], [0, 1.0] , [np.cos(0*np.pi\/13), np.sin(0*np.pi\/13)], [np.cos(0*np.pi\/13), 1 - np.sin(0*np.pi\/13)]])\n\n\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n#This enum represents the different types of deformations that you can have \n#TODO this def might fit in lattice making\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\nclass DispType(Enum):\n    random = 1\n    isotropic = 2\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n    \n\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n#this enumumerates the possible ways to connect the added vertices to each other and the square\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\nclass EdgeTypes(Enum):\n    all_connected = 1\n    all_to_square = 2\n    #square_lattice = 3\n#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n    \n#================================================================================================================================================\n# Runs the minimization procedure to return the results for the spring constants and the positions\n#================================================================================================================================================\ndef find_desired_square(deformationType = DispType.random, edgeType = EdgeTypes.all_connected, \n                        num_of_added_verts = NUM_OF_ADDED_VERTS, squareDisp = None, square_ID = None):\n    \"\"\"\n    minimizes over the spring constants and positions of the added returns the result of minimization after testing.\n    \n    deformationType: this is an option for generating the desired displacement field. This is overrided if squareDisp is given\n    There are two deformations options now:\n        DispType.random: random displacements. \n        DispType.isotropic: contraction or expansion towards the origin. \n        \n    edgeType: type of connectivity of the network\n        EdgeTypes.all_connected: everything is connected to everything.\n        EdgeTypes.all_to_square: every added points is connected to all the vertices of the square.\n        EdgeTypes.square_lattice: an additional square lattice in the interior. corresponding corners connected. \n        \n        \n    \"\"\"\n    #initialize test results so that the while loop goes at least once\n    test_result = True\n    \n    #how many times the minimization procedure ran\n    trial_num = 0\n    \n    #initialize the lattice\n    vertices, edge_array = initialize_square(edgeType, num_of_added_verts)\n    \n    num_of_verts = vertices.size\/\/2\n    num_of_edges = edge_array.size\/\/2\n    \n    #generate displacement field for the square. outside loop because we don't want to keep changing this\n    U = make_desired_disp(vertices, num_of_vertices=num_of_verts, DeformType=deformationType)\n    \n    if(squareDisp is not None):\n        U[:LITTLE_SQUARE.size - 3] = squareDisp\n        \n    \n    while (test_result):\n    \n    \n        # connectivity dependent matrices that are used to calculate the rigidity matrix\n        edgeMat1 = makeEdgeMatrix1(edge_array, numOfEdges=num_of_edges, numOfVerts=num_of_verts)\n        edgeMat2 = makeEdgeMatrix2(edge_array, numOfEdges=num_of_edges, numOfVerts=num_of_verts)\n    \n\n        #initialize var: points and spring constants\n        k0  = npr.rand(num_of_edges)\n        \n        var0 = np.hstack((vertices.flatten(), k0))\n        #the square spring constants are fixed\n        var0[2*num_of_verts:2*num_of_verts + 4] = np.ones(4)\n        \n        #minimize cost funcion\n        res = op.minimize(cost_function, var0, method='BFGS',args=(U, edgeMat1, edgeMat2, num_of_edges, num_of_verts), options={'disp': False})\n        \n        #this works if we are working with the script of Many little squares\n        if(square_ID is not None):\n            print(\"Working on square number \", square_ID)\n        trial_num += 1; print(\"Trial Number: \", trial_num, \"\\n\")\n        \n        #if this returns true then keep trying, checks if U is close to the minimum on the LITTLE_SQUARE \n        test_result = test_results(res.x, U, edgeMat1, edgeMat2, num_of_edges, num_of_verts)\n        \n        #initialize the lattice again, adds a new vertex for every max_trials trials\n        vertices, edge_array = initialize_square(edgeType, num_of_added_verts + trial_num\/\/MAX_TRIALS)\n        \n        #if the number of trials increases the maximum then add a gray matter vertex\n        if (np.mod(trial_num, MAX_TRIALS) == 0):\n            \n            #update num of verts and edges\n            num_of_verts = vertices.size\/\/2\n            num_of_edges = edge_array.size\/\/2\n            \n            # add the initial displacement for the extra vertex, it's essentialy a place holder\n            U = np.hstack((U, npr.rand(2) - 0.5))\n            \n            \n    #get the new vertices from the results\n    newVertices = res.x[:2*num_of_verts]\n    \n    #the square ones are fixed\n    newVertices[:LITTLE_SQUARE.size]  = LITTLE_SQUARE.flatten()\n    \n    newVertices = newVertices.reshape((num_of_verts, 2))\n            \n    #the resulting values of the spring constant\n    newK = (res.x[2*num_of_verts:]**2)\n    newK = newK\/np.max(newK)\n    #the square spring constants are fixed\n    newK[:4] = np.ones(4)\n    \n    \n    return [newVertices, edge_array, newK] \n    \n\n#================================================================================================================================================\n# The cost function penalizes energy of the desired displacement of the square vertices\n#================================================================================================================================================\ndef cost_function(var, disp_field, eMat1, eMat2, num_of_edges,num_of_vertices):\n    \"\"\"\n    var is the combined variables to be minimized over. It represents all the vertices and spring constants\n    var[:2*num_of_vertices] are the points \n    var[2*num_of_vertices:] are the spring constants\n    \"\"\"\n    \n    #the square positions are fixed\n    var[:LITTLE_SQUARE.size] = LITTLE_SQUARE.flatten()\n    \n    #the square spring constants are fixed\n    var[2*num_of_vertices:2*num_of_vertices + 4] = np.ones(4)\n    \n   # var[:2*num_of_vertices] are the points of the lattice\n   # var[2*num_of_vertices:] are the spring constants\n   \n    rigidityMatrix = makeRigidityMat(var[:2*num_of_vertices], edgeMat1=eMat1, edgeMat2=eMat2)[:, 3:]\n    \n    #calculate the dynamical matrix\n    DynMat = makeDynamicalMat(RigidityMat= rigidityMatrix,\n                              springK=var[2*num_of_vertices:], numOfVerts=num_of_vertices, numOfEdges=num_of_edges)\n    \n    \n    # minimize the energy subject to the constraint that the square displacements are fixed\n    res0 = op.minimize(energy, disp_field, method='Newton-CG', args=(DynMat, disp_field[:LITTLE_SQUARE.size - 3]), jac=energy_Der, \n                       hess=energy_Hess, options={'xtol': 1e-8, 'disp': False})\n    \n    \n    #lowestEigVector = normalizeVec(la.eigh(DynMat)[1][:5,0])\n    lowestEs = lowestEigenVals(DynMat)\n    \n    #Wall_Cost = WAll_BARRIER*np.heaviside(-var[LITTLE_SQUARE.size:2*num_of_vertices:2], 1) + np.sum(var[LITTLE_SQUARE.size:2*num_of_vertices:2] - 0.5)**2\n    # minimize this energy with respect to the lowest energy eigenvalue\n    return res0.fun\/lowestEs[0] + EIG_VAL_REPULSION * (lowestEs[0]\/lowestEs[1])**2 #+ np.sum(Wall_Cost)\n#================================================================================================================================================    \n\n#================================================================================================================================================\n# Initializing the lattice\n#================================================================================================================================================\ndef initialize_square(edgeType = EdgeTypes.all_connected, num_of_added_verts = NUM_OF_ADDED_VERTS):\n    \"\"\"\n    This method returns an array of position vectors (vertices) and an array of edge vectors (edge_array).\n    \n    The vertices include a square with of unit width and (num_of_added_points) extra points that are inserted at random positions in a square \n    of width = 2. The square vertices must be the first 0,1,2,3.\n    \n    Every point is connected to every other point so it generates the maximum number of edges. \n    \n    Example: initialize_square(2)\n    Out[45]: \n(array([[ 0.        ,  0.        ],\n        [ 0.        ,  1.        ],\n        [ 1.        ,  1.        ],\n        [ 1.        ,  0.        ],\n        [ 0.49850383,  0.26623088]]), array([[0, 1],\n        [0, 2],\n        [0, 3],\n        [0, 4],\n        [1, 2],\n        [1, 3],\n        [1, 4],\n        [2, 3],\n        [2, 4],\n        [3, 4]]))\n    \"\"\"\n\n    # this part I call grey matter, these are the added to the square vertices \n    gray_matter = npr.rand(num_of_added_verts, NUM_OF_DIMENSIONS)*2.0 - 0.5 \n\n    # add them together to get the entire list of vertices\n    vertices = np.vstack((LITTLE_SQUARE, gray_matter))\n    \n    if(edgeType == EdgeTypes.all_connected):\n    # make the edge array, connect all points for now\n        edge_array = connect_all_of_square(get_num_of_verts(vertices)) #connects all points of the square and gray matter. edges in definite order\n        \n    elif(edgeType == EdgeTypes.all_to_square):\n        #connect each gray matter vertex to the square vertices\n        edge_array = connect_all_to_square(num_of_added_verts)\n        \n    return vertices, edge_array\n#================================================================================================================================================\n\n#================================================================================================================================================\n# generate the displacement field wanted\n#================================================================================================================================================    \ndef make_desired_disp(vertices, DeformType = DispType.random, num_of_vertices = -1):\n    \"\"\"\n   DispType.random:     Makes a random displacement field. The first 3 degrees of freedom are assumed to \n   be zero in order to fix rotation and translation of the lattice.\n   DispType.isotropic: Every point moves towards the origin with an amount propotional to the distance from the origin\n    \"\"\"\n    if(DeformType == DispType.random):\n        \n        if(num_of_vertices < 1):\n            get_num_of_verts(vertices)\n            \n        return normalizeVec(npr.rand(2*num_of_vertices - 3)) \n    \n    elif(DeformType == DispType.isotropic):\n        return normalizeVec(vertices.flatten()[3:])\n#================================================================================================================================================     \n    \n#================================================================================================================================================\n# After setting the boundary indices to the desired values, calculates the energy using the edge matrix.\n#================================================================================================================================================\ndef energy(u, DynMat, squareDisp):\n    \"\"\"\n    Be careful about using this in different scripts, because this assumes boundary conditions when computing the energy.\n    The vertices of the squares have fixed displacements, the rest will be allowed to relax to minimum energy\n    TODO: A more general energy function that takes in the boundary conditions directly\n    \n    energy(u, DynMat, BInds = boundaryIndices): calculates the energy after setting the boundary indices to the correct values. \n    \"\"\"\n    u[:LITTLE_SQUARE.size - 3] = squareDisp #this assumes that the square vertex indices are 0,1,2,3\n    u = normalizeVec(u)\n    return 0.5*np.dot(np.dot(u.transpose(), DynMat), u)\n#================================================================================================================================================\n    \n#================================================================================================================================================\n# After setting the boundary indices to the desired values, calculates the energy gradient from the dynamical matrix.\n#================================================================================================================================================\ndef energy_Der(u, DynMat, squareDisp):\n    \"\"\"\n    Be careful about using this in different scripts, because this assumes boundary conditions when computing the energy.\n    TO DO: A more general energy function that takes in the boundary conditions directly\n    \"\"\"\n    u[:LITTLE_SQUARE.size - 3] = squareDisp\n    u = normalizeVec(u)\n    return np.dot(DynMat, u)\n#================================================================================================================================================\n    \n#================================================================================================================================================\n# After setting the boundary indices to the desired values, calculates the energy Hessian from the dynamical matrix.\n#================================================================================================================================================\ndef energy_Hess(u, DynMat,  squareDisp):\n    return DynMat\n#================================================================================================================================================  \n\n#================================================================================================================================================\n# Returns the lowest eignevalue of the dynamical matrix, exluding the rigid motions of course.\n#================================================================================================================================================\ndef lowestEigenVals(DynMat, num_of_eigs = 2):    \n    return (la.eigvalsh(0.5*DynMat)[:num_of_eigs])\n#================================================================================================================================================\n    \n#================================================================================================================================================\n# Returns the lowest eignevalue of the dynamical matrix, exluding the rigid motions of course.\n#================================================================================================================================================\ndef lowestEigenVal(DynMat):    \n    return (la.eigvalsh(0.5*DynMat)[0])\n#================================================================================================================================================\n  \n\n#================================================================================================================================================\n# Test the results of the minimization procedure\n#================================================================================================================================================\ndef test_results(new_var, disp_field, eMat1, eMat2, num_of_edges, num_of_vertices):\n    \"\"\"\n    this returns True if the dot product between the desired diplacement and the lowest eigen vector after minimization satisfies dotproduct < 0.95.\n    this will result in trying the minimization procedure again.\n    \n    var is the combined variables to be minimized over. It represents all the vertices and spring constants\n    var[:2*num_of_vertices] are the points \n    var[2*num_of_vertices:] are the spring constants\n    \"\"\"\n    \n    #the square positions are fixed\n    new_var[:LITTLE_SQUARE.size] = LITTLE_SQUARE.flatten()\n    \n   # var[:num_of_vertices] are the points of the lattice\n   # var[num_of_vertices:] are the spring constants\n   \n    rigidityMatrix = makeRigidityMat(new_var[:2*num_of_vertices], edgeMat1=eMat1, edgeMat2=eMat2)[:, 3:]\n    \n    #calculate the dynamical matrix\n    DynMat = makeDynamicalMat(RigidityMat= rigidityMatrix,\n                              springK=new_var[2*num_of_vertices:], numOfVerts=num_of_vertices, numOfEdges=num_of_edges)\n    \n    \n    # minimize the energy subject to the constraint that the square displacements are fixed\n    res0 = op.minimize(energy, disp_field, method='Newton-CG', args=(DynMat, disp_field[:LITTLE_SQUARE.size - 3]), jac=energy_Der, \n                       hess=energy_Hess, options={'xtol': 1e-8, 'disp': False})\n    \n    lowestEigVector = normalizeVec(la.eigh(DynMat)[1][:LITTLE_SQUARE.size - 3,0])\n    secondEigVector = normalizeVec(la.eigh(DynMat)[1][:LITTLE_SQUARE.size - 3,1])\n    \n    #return false if the vectors are not close enough\n    dotProduct = np.dot(lowestEigVector, normalizeVec(res0.x[:LITTLE_SQUARE.size - 3]))\n    lowestEigVector *= np.sign(dotProduct)\n    dotProduct *= np.sign(dotProduct)\n    \n    gap = (lowestEigenVals(DynMat, 2)[1] - lowestEigenVals(DynMat, 2)[0])\/lowestEigenVals(DynMat, 2)[0]\n    \n    if((dotProduct < 0.995) or gap < 4):\n        print(\"dot produce: \", dotProduct, \"\\n\")\n        print(\"square disps in lowest energy: \", normalizeVec(lowestEigVector[:LITTLE_SQUARE.size - 3]), \"\\n\")\n        print(\"square disps in desired motion: \", normalizeVec(res0.x[:LITTLE_SQUARE.size - 3]), \"\\n\")\n        print(\"eigenvalues: \", lowestEigenVals(DynMat, 5), \"\\n\")\n        print(\"gap: \", gap, \"\\n\")\n        print(\"trying again ... \\n\\n\")\n        return True;\n    \n    print(\"Number of edges: \", rigidityMatrix.shape[0], \"\\n\")\n    print(\"energy: \", energy(normalizeVec(res0.x), DynMat, disp_field[:LITTLE_SQUARE.size - 3]), \"\\n\")\n    print(\"eigenvalues: \", lowestEigenVals(DynMat, 5), \"\\n\")\n    print(\"dot produce: \", dotProduct, \"\\n\")\n    print(\"gap: \", gap, \"\\n\")\n    print(\"square disps in lowest energy: \", lowestEigVector, \"\\n\")\n    print(\"square disps in desired motion: \", normalizeVec(res0.x[:LITTLE_SQUARE.size - 3]), \"\\n\")\n    print(\"square disps in next to lowest: \", normalizeVec(secondEigVector[:LITTLE_SQUARE.size - 3]), \"\\n\")\n    \n    \n    #plotPoints(new_var[:2*num_of_vertices], num_of_vertices)\n\n    return False\n#================================================================================================================================================ \n\n\n#================================================================================================================================================\n# plots the points as a scatter plot\n#================================================================================================================================================\ndef plotPoints(flattenedPoints, num_of_verts = -1):\n    \"\"\"\n    Takes in a list of point positions which is then reshaped into a list 2-vectors.\n    A different color and size is chosen for the original square vertices.\n    \"\"\"\n    if (num_of_verts < 0):\n       num_of_verts = flattenedPoints.size\/\/2 \n    \n    #reshape the points to look like a list of vectors\n    Points = flattenedPoints.reshape(num_of_verts, 2)\n    \n    #chose the area of the square vertices to be bigger\n    area = 200*np.ones(num_of_verts)\n    area[4:] *= 0.4 \n    #also a different color for the square vertices\n    color = np.copy(area)\n    \n    \n    plt.scatter(Points[:,0], Points[:,1], s=area, c=color)\n#================================================================================================================================================\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_41","text":"<gh_stars>1-10\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\nimport sys\nimport os\nimport math\nimport numpy as np\n\nimport scipy.fftpack\nimport scipy as spy\nfrom basic_sequences import LOWPAPRs, basic_generate_c_sequence, basic_cinit_calc\n\nUL_REFERENCE_SEQUENCES_LEN = np.array([6, 12, 18, 24, 30, 36, 48, 54, 60, 72, 84, \n                                       90, 96, 108, 120, 132, 144, 150, 156, 162, 168,\n                                       180, 192, 204, 216, 228, 240, 252, 264, 270, 276, 288,\n                                       300, 312, 324, 336, 348, 360, 384, 396, 408, 432,\n                                       450, 456, 480, 486, 504, 528, 540, 552, 576, 600, 624,\n                                       648, 672, 696, 720, 750, 768, 792, 810, 816, 864,\n                                       900, 912, 960, 972, 1008, 1056, 1080, 1104, 1152, 1200, 1248,\n                                       1296, 1344, 1350, 1440, 1458, 1500, 1536, 1584, 1620, 1632])\n\nSRS_BANDWIDTH_CONFIG_TABLE = np.array([[0, \t4,\t    1,\t4,\t    1,\t   4,\t   1,\t4,\t1],\n                                    [1, \t8,\t    1,\t4,\t    2,\t   4,\t   1,\t4,\t1],\n                                    [2, \t12,\t    1,\t4,\t    3,\t   4,\t   1,\t4,\t1],\n                                    [3, \t16,\t    1,\t4,\t    4,\t   4,\t   1,\t4,\t1],\n                                    [4, \t16,\t    1,\t8,\t    2,\t   4,\t   2,\t4,\t1],\n                                    [5, \t20,\t    1,\t4,\t    5,\t   4,\t   1,\t4,\t1],\n                                    [6, \t24,\t    1,\t4,\t    6,\t   4,\t   1,\t4,\t1],\n                                    [7, \t24,\t    1,\t12,\t    2,\t   4,\t   3,\t4,\t1],\n                                    [8, \t28,\t    1,\t4,\t    7,\t   4,\t   1,\t4,\t1],\n                                    [9, \t32,\t    1,\t16,\t    2,\t   8,\t   2,\t4,\t2],\n                                    [10,\t36,\t    1,\t12,\t    3,\t   4,\t   3,\t4,\t1],\n                                    [11,\t40,\t    1,\t20,\t    2,\t   4,\t   5,\t4,\t1],\n                                    [12,\t48,\t    1,\t16,\t    3,\t   8,\t   2,\t4,\t2],\n                                    [13,\t48,\t    1,\t24,\t    2,\t   12,\t   2,\t4,\t3],\n                                    [14,\t52,\t    1,\t4,\t    13,\t   4,\t   1,\t4,\t1],\n                                    [15,\t56,\t    1,\t28,\t    2,\t   4,\t   7,\t4,\t1],\n                                    [16,\t60,\t    1,\t20,\t    3,\t   4,\t   5,\t4,\t1],\n                                    [17,\t64,\t    1,\t32,\t    2,\t   16,\t   2,\t4,\t4],\n                                    [18,\t72,\t    1,\t24,\t    3,\t   12,\t   2,\t4,\t3],\n                                    [19,\t72,\t    1,\t36,\t    2,\t   12,\t   3,\t4,\t3],\n                                    [20,\t76,\t    1,\t4,\t    19,\t   4,\t   1,\t4,\t1],\n                                    [21,\t80,\t    1,\t40, \t2,\t   20,\t   2,\t4,\t5],\n                                    [22,\t88,\t    1,\t44, \t2,\t   4,\t   11,\t4,\t1],\n                                    [23,\t96,\t    1,\t32, \t3,\t   16,\t   2,\t4,\t4],\n                                    [24,\t96,\t    1,\t48, \t2,\t   24,\t   2,\t4,\t6],\n                                    [25,\t104,\t1,\t52, \t2,\t   4,\t   13,\t4,\t1],\n                                    [26,\t112,\t1,\t56, \t2,\t   28,\t   2,\t4,\t7],\n                                    [27,\t120,\t1,\t60, \t2,\t   20,\t   3,\t4,\t5],\n                                    [28,\t120,\t1,\t40, \t3,\t   8,\t   5,\t4,\t2],\n                                    [29,\t120,\t1,\t24, \t5,\t   12,\t   2,\t4,\t3],\n                                    [30,\t128,\t1,\t64, \t2,\t   32,\t   2,\t4,\t8],\n                                    [31,\t128,\t1,\t64, \t2,\t   16,\t   4,\t4,\t4],\n                                    [32,\t128,\t1,\t16, \t8,\t   8,\t   2,\t4,\t2],\n                                    [33,\t132,\t1,\t44, \t3,\t   4,\t   11,\t4,\t1],\n                                    [34,\t136,\t1,\t68, \t2,\t   4,\t   17,\t4,\t1],\n                                    [35,\t144,\t1,\t72, \t2,\t   36,\t   2,\t4,\t9],\n                                    [36,\t144,\t1,\t48, \t3,\t   24,\t   2,\t12,\t2],\n                                    [37,\t144,\t1,\t48, \t3,\t   16,\t   3,\t4,\t4],\n                                    [38,\t144,\t1,\t16, \t9,\t   8,\t   2,\t4,\t2],\n                                    [39,\t152,\t1,\t76, \t2,\t   4,\t   19,\t4,\t1],\n                                    [40,\t160,\t1,\t80, \t2,\t   40,\t   2,\t4,\t10],\n                                    [41,\t160,\t1,\t80, \t2,\t   20,\t   4,\t4,\t5],\n                                    [42,\t160,\t1,\t32, \t5,\t   16,\t   2,\t4,\t4],\n                                    [43,\t168,\t1,\t84, \t2,\t   28,\t   3,\t4,\t7],\n                                    [44,\t176,\t1,\t88, \t2,\t   44,\t   2,\t4,\t11],\n                                    [45,\t184,\t1,\t92, \t2,\t   4,\t   23,\t4,\t1],\n                                    [46,\t192,\t1,\t96, \t2,\t   48,\t   2,\t4,\t12],\n                                    [47,\t192,\t1,\t96, \t2,\t   24,\t   4,\t4,\t6],\n                                    [48,\t192,\t1,\t64, \t3,\t   16,\t   4,\t4,\t4],\n                                    [49,\t192,\t1,\t24, \t8,\t   8,\t   3,\t4,\t2],\n                                    [50,\t208,\t1,\t104,\t2,\t   52,\t   2,\t4,\t13],\n                                    [51,\t216,\t1,\t108,\t2,\t   36,\t   3,\t4,\t9],\n                                    [52,\t224,\t1,\t112,\t2,\t   56,\t   2,\t4,\t14],\n                                    [53,\t240,\t1,\t120,\t2,\t   60,\t   2,\t4,\t15],\n                                    [54,\t240,\t1,\t80, \t3,\t   20,\t   4,\t4,\t5],\n                                    [55,\t240,\t1,\t48, \t5,\t   16,\t   3,\t8,\t2],\n                                    [56,\t240,\t1,\t24, \t10,\t   12,\t   2,\t4,\t3],\n                                    [57,\t256,\t1,\t128,\t2,\t   64,\t   2,\t4,\t16],\n                                    [58,\t256,\t1,\t128,\t2,\t   32,\t   4,\t4,\t8],\n                                    [59,\t256,\t1,\t16, \t16,\t   8,\t   2,\t4,\t2],\n                                    [60,\t264,\t1,\t132, \t2,\t   44,\t   3,\t4,\t11],\n                                    [61,\t272,\t1,\t136, \t2,\t   68,\t   2,\t4,\t17],\n                                    [62,\t272,\t1,\t68, \t4,\t   4,\t   17,\t4,\t1],\n                                    [63,\t272,\t1,\t16, \t17,\t   8,\t   2,\t4,\t2]])\n\n#\n#\n#  1. The 1st method for the SRS receiver\n#\n#\ndef srs_freq_start_pos(frame_number, slot_number, srs_config, ttis_per_subframe):\n    k_tc_p = 0\n    k_0_overbar_p = 0\n    N_b = 0\n    m_srs_b = 0\n    n_srs = 0\n    f_b = 0\n    n_b = 0;\n    k_tc_overbar = srs_config.comb_offset\n    k_tc = srs_config.comb_size\n    c_srs = srs_config.config_index\n    b_srs = srs_config.bandwidth_index\n    b_hop = srs_config.frequency_hopping\n    # \/* it adjusts the SRS allocation to align with the common resource block grid in multiples of four *\/\n    n_rrc = srs_config.frequency_position\n    n_shift = srs_config.frequency_shift\n    # Now, only repetitions = 0 is supported\n    num_repetitions = 0\n    R = 2**num_repetitions\n    t_offset = srs_config.t_offset\n    t_srs = srs_config.t_srs\n    # \/* consecutive OFDM symbols *\/\n    n_symb_srs = srs_config.num_symbols\n    l = 0;\n    \n    k_tc_p = k_tc_overbar\n    # Now, only BWP start = 0 is supported\n    k_0_p = n_shift * 12 + k_tc_p + 0\n\n    for b in range(b_srs+1):\n        n_b = 0;\n        N_b = SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2*b + 2]\n        m_srs_b = SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2*b + 1]\n\n        if (b_hop >= b_srs):\n            n_b = int(4 * n_rrc \/ m_srs_b) % N_b\n        else:\n            n_b = (4 * n_rrc \/ m_srs_b) % N_b\n\n            if (b > b_hop):\n                if (srs_config.resource_type == 0):\n                    n_srs = l \/ R;\n                else:\n                    n_srs = ((20 * frame_number + slot_number - t_offset) \/ t_srs) * (n_symb_srs \/ R) + (l \/ R)\n\n                product_n_b = 1\n                for b_prime in np.arange(b_hop+1, b_srs):\n                    product_n_b *= SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2 * b_prime + 2]\n\n                if (N_b % 2 == 1):\n                    f_b = int(N_b \/ 2) * int(n_srs \/ product_n_b)\n                else:\n                    product_n_b_b_srs = product_n_b\n                    product_n_b_b_srs *= SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2 * b_srs + 2]\n                    f_b = (N_b \/ 2) * ((n_srs % product_n_b_b_srs) \/ product_n_b) + ((n_srs % product_n_b_b_srs) \/ 2 * product_n_b)\n                n_b = int(f_b + (4 * n_rrc \/ m_srs_b)) % N_b\n        k_0_p += m_srs_b * 12 * n_b                                     \n\n    return k_0_p\n\ndef srs_scramble_data(data_in, length, c_init, data_out):\n    x = np.zeros(2, dtype=np.uint64)\n    x[0] = np.uint64(5188146772878295041)\n    x1 = x[0]\n\n    x[1] = c_init\n    x2 = x[1]\n    x2 = (x2 | ((x2 ^ (x2 >> np.uint64(1)) ^ (x2 >> np.uint64(2)) ^ (x2 >> np.uint64(3))) << np.uint64(31))) & np.uint64(0x7FFFFFFFFFFFFFF)\n    x2 = x2 ^ (((x2 >> np.uint64(28)) ^ (x2 >> np.uint64(29)) ^ (x2 >> np.uint64(30)) ^ (x2 >> np.uint64(31))) << np.uint64(59))\n\n    for i in np.arange(1, 25):\n        x1 = (x1 >> np.uint64(2)) ^ (x1 >> np.uint64(8))\n        x1 = x1 ^ (x1 << np.uint64(56)) ^ (x1 << np.uint64(62))\n        x2 = (x2 >> np.uint64(2)) ^ (x2 >> np.uint64(4)) ^ (x2 >> np.uint64(6)) ^ (x2 >> np.uint64(8))\n        x2 = x2 ^ (x2 << np.uint64(56)) ^ (x2 << np.uint64(58)) ^ (x2 << np.uint64(60)) ^ (x2 << np.uint64(62))\n\n    num = ((np.uint32(length) - np.uint32(1)) >> np.uint32(6)) + np.uint32(1)\n    out_tmp = data_out.view(dtype = np.uint64)\n    in_tmp = data_in.view(dtype = np.uint64)\n    for i in range(num):\n        x1 = (x1 >> np.uint64(2)) ^ (x1 >> np.uint64(8))\n        x1 = x1 ^ (x1 << np.uint64(56)) ^ (x1 << np.uint64(62))\n        x2 = (x2 >> np.uint64(2)) ^ (x2 >> np.uint64(4)) ^ (x2 >> np.uint64(6)) ^ (x2 >> np.uint64(8))\n        x2 = x2 ^ (x2 << np.uint64(56)) ^ (x2 << np.uint64(58)) ^ (x2 << np.uint64(60)) ^ (x2 << np.uint64(62))\n        out_tmp[i] = in_tmp[i] ^ x1 ^ x2\n        # print('TMP %lu %lu' %(out_tmp[i], in_tmp[i]))\n    out = out_tmp.view(dtype=np.uint8)\n    for i in range(length):\n        data_out[i] = out[i]\n\ndef srs_group_sequence_hopping(srs_config, symb_idx, slot_idx, m_sc_b_srs):\n    u = 0\n    v = 0\n    # generate PN sequence\n    index = 0\n    f_gh = 0\n    num_bits = 2240;\n    \n    group_or_sequence_hopping = srs_config.group_or_sequence_hopping\n    hopping_id = srs_config.sequence_id\n    \n    bit_in = np.zeros(183456, dtype=np.uint8)\n    random_seq = np.zeros(num_bits, dtype=np.uint8)\n    srs_scramble_data(bit_in, num_bits, hopping_id, random_seq)\n    \n    if (group_or_sequence_hopping.lower() == 'group_hopping'):\n        f_gh = random_seq[slot_idx * 14 + symb_idx] % 30\n    elif (group_or_sequence_hopping.lower() == 'sequence_hopping'):\n        if (m_sc_b_srs >= 6 * 12):\n            index = (slot_idx * 14 + symb_idx)\n            v = ((random_seq[index >> 3] & (1 << (index & 7))) >> (index & 7))\n    u = int(f_gh + hopping_id) % 30\n    \n    return u, v\n\ndef srs_get_cyclic_shift(point_offset, point_len, cyclic_shift_value, total_len, vec_in, vec_out):\n    for i in range(total_len):\n        vec_out[i] = 0\n    for ii in range(point_len):\n        if point_offset + ii < cyclic_shift_value :\n            t1 = (point_offset + ii + total_len - cyclic_shift_value)\n        else:\n            t1 = (point_offset + ii - cyclic_shift_value)\n        if point_offset + ii < total_len :\n            t2 = (point_offset + ii)\n        else:\n            t2 = (point_offset + ii - total_len)\n        if t2 < 0:\n            t2 = t2 + total_len\n        vec_out[t1] = vec_in[t2]\n\ndef srs_ch_estimates_proc(srs_config, grid, srs_pilot, nb_re_srs, n_ap, cycliShift, k_tc, nb_antennas_rx, nfft):\n    aarx = 0\n    n_srs_cs_max = 0\n    \n    # TS 38.211 6.4.1.4.2 Sequence generation\n    if k_tc == 4:\n        n_srs_cs_max = 12\n    elif k_tc == 2:\n        n_srs_cs_max = 8\n    else:\n        return\n    \n    min_cs_diff = n_srs_cs_max\n    n_srs_cs_i = cycliShift\n    for p_index1 in range(n_ap):\n        for p_index2 in range(n_ap):\n            cs_diff = n_srs_cs_i[p_index1] - n_srs_cs_i[p_index2]\n            if (p_index1 != p_index2) and (abs(cs_diff) < min_cs_diff):\n                min_cs_diff = abs(cs_diff)\n    \n    len_per_cs = int(nb_re_srs\/n_srs_cs_max)\n    win_size = min(12, min_cs_diff) * len_per_cs\n    rms = 32\n    peak_pos = 0\n    peak_size = int((rms * nb_re_srs * k_tc - 1) \/ nfft) + 2\n    peak_offset = 0\n    if (nb_re_srs * k_tc * 32 < nfft):\n        peak_size = max(int(win_size\/2), 3)\n    \n    # Frequency domain data\n    srs_ch_estimates_freq = np.zeros((nb_antennas_rx, nb_re_srs), dtype=complex)\n    # Time domain data\n    srs_ch_estimates_time = np.zeros((nb_antennas_rx, nb_re_srs), dtype=complex)\n    srs_vars_tmp = np.zeros(nb_re_srs, dtype=float)\n    srs_ch_estimates_time_pow = np.zeros(nb_re_srs, dtype=float)\n    srs_ch_estimates_time_pow3 = np.zeros(3 * nb_re_srs, dtype=float)\n    for aarx in range(nb_antennas_rx):\n        # Freq channel estimation, z = x * y.conj()\n        for k in range(nb_re_srs):\n            srs_ch_estimates_freq[aarx][k] = grid[aarx][k] * np.conj(srs_pilot[k])\n        \n        # Direct estimate the TA from the state of noise power has not been decreased\n        \"\"\"\n        srs_TOsum_tmp = 0\n        for k in range(nb_re_srs - 1):\n            srs_TOsum_tmp += srs_ch_estimates_freq[aarx][k] * np.conj(srs_ch_estimates_freq[aarx][k + 1])\n        srs_TOest_tmp = np.arctan2(np.imag(srs_TOsum_tmp), np.real(srs_TOsum_tmp)) \/ (2 * np.pi * k_tc)\n        \"\"\"\n\n        # IDFT to get time channel estimation\n        srs_ch_estimates_time[aarx] = nb_re_srs * spy.fft.ifft(srs_ch_estimates_freq[aarx])\n\n        # Get the time channel estimation Power and RSSI\n        for k in range(nb_re_srs):\n            srs_vars_tmp[k] = np.real(srs_ch_estimates_time[aarx][k]) * np.real(\n                srs_ch_estimates_time[aarx][k]) + np.imag(srs_ch_estimates_time[aarx][k]) * np.imag(srs_ch_estimates_time[aarx][k])\n            srs_ch_estimates_time_pow[k] += srs_vars_tmp[k]\n    srs_rssi = np.sum(srs_ch_estimates_time_pow) \/ nb_re_srs\n    \n    # 3 points sum for peak detection\n    if (nb_re_srs * k_tc * 32) < nfft:\n        for k in range(nb_re_srs):\n            srs_ch_estimates_time_pow3[nb_re_srs + k] = srs_ch_estimates_time_pow[k]\n    else:\n        # z[i] = r[i] + (x[i] + y[i])\n        for k in range(nb_re_srs - 2):\n            srs_ch_estimates_time_pow3[nb_re_srs + k + 1] = srs_ch_estimates_time_pow[k + 2] + (\n                srs_ch_estimates_time_pow[k] + srs_ch_estimates_time_pow[k + 1])\n        srs_ch_estimates_time_pow3[nb_re_srs] = srs_ch_estimates_time_pow[nb_re_srs - 1] + srs_ch_estimates_time_pow[0] + srs_ch_estimates_time_pow[1]\n        srs_ch_estimates_time_pow3[2 * nb_re_srs - 1] = srs_ch_estimates_time_pow[nb_re_srs - 2] + srs_ch_estimates_time_pow[nb_re_srs - 1] + srs_ch_estimates_time_pow[0]\n    for k in range(nb_re_srs):\n        srs_ch_estimates_time_pow3[k] = srs_ch_estimates_time_pow3[nb_re_srs + k]\n        srs_ch_estimates_time_pow3[2*nb_re_srs+k] = srs_ch_estimates_time_pow3[nb_re_srs + k]\n    \n    rssi_sum = srs_rssi\n    # Cyclicshift process : TA estimation and power calculation\n    peak_sc_sum = 0\n    srs_hpow = np.zeros(n_ap, dtype=float)\n    srs_TOest = np.zeros(n_ap, dtype=float)\n    srs_TOsum = np.zeros(n_ap, dtype=complex)\n    srs_ch_estimates_freq_pow = np.zeros((n_ap, nb_re_srs), dtype=float)\n    srs_ch_estimates = np.zeros((n_ap*nb_antennas_rx, nb_re_srs), dtype=complex)\n    srs_vars_tmp = np.zeros(nb_re_srs, dtype=complex)\n    srs_vars_tmp1 = np.zeros(nb_re_srs, dtype=float)\n    for p_index in range(n_ap):\n        offset_per_cs = int(len_per_cs * ((n_srs_cs_max - n_srs_cs_i[p_index]) % n_srs_cs_max))\n        \n        # Get peak position\n        max_pos = 0\n        max_value = srs_ch_estimates_time_pow3[nb_re_srs+ offset_per_cs - int(win_size \/ 2)]\n        for k in range(win_size+1):\n            if (srs_ch_estimates_time_pow3[nb_re_srs+ offset_per_cs - int(win_size \/ 2)+k] > max_value):\n                max_pos = k\n                max_value = srs_ch_estimates_time_pow3[nb_re_srs+ offset_per_cs - int(win_size \/ 2)+k]\n        peak_pos = max_pos + offset_per_cs - int(win_size \/ 2)\n        peak_offset = peak_pos - (int((peak_size - 1) \/ 4) + 1)\n        srs_TOest[p_index] = peak_pos - offset_per_cs\n        \n        # Remove cyclicshift\n        for aarx in range(nb_antennas_rx):\n            srs_get_cyclic_shift(peak_offset, peak_size, offset_per_cs, nb_re_srs, srs_ch_estimates_time[aarx], srs_vars_tmp)\n            \n            # get freq channel estimation\n            srs_ch_estimates[p_index * nb_antennas_rx + aarx] = spy.fft.fft(srs_vars_tmp)\n            \n            # get freq channel estimation power\n            for k in range(nb_re_srs):\n                e = srs_ch_estimates[p_index * nb_antennas_rx + aarx][k]\n                srs_vars_tmp1[k] = np.real(e) * np.real(e) + np.imag(e) * np.imag(e)\n            # Z = X + Y * h\n            for k in range(nb_re_srs):\n                h = 1.0\/(nb_re_srs * nb_re_srs)\n                srs_ch_estimates_freq_pow[p_index][k] = srs_ch_estimates_freq_pow[p_index][k] + srs_vars_tmp1[k] * h\n            \n            # if nb_re_srs * k_tc * 16 < nfft:\n            for k in range(nb_re_srs - 1):\n                srs_TOsum[p_index] += srs_ch_estimates[p_index * nb_antennas_rx + aarx][k] * np.conj(srs_ch_estimates[p_index * nb_antennas_rx + aarx][k + 1])\n\n        srs_hpow[p_index] = 0.\n        for k in range(nb_re_srs):\n            srs_hpow[p_index] += srs_ch_estimates_freq_pow[p_index][k]\n        rssi_sum -= srs_hpow[p_index]\n        peak_sc_sum += peak_size\n        # print(srs_TOsum[p_index], srs_hpow[p_index], rssi_sum, peak_sc_sum)\n\n    # Get the noise power\n    srs_noisepow = rssi_sum \/ (nb_re_srs - peak_sc_sum) \/ nb_antennas_rx\n    \n    re_per_rb = int(12 \/ k_tc)\n    nb_rb = int(nb_re_srs \/ re_per_rb)\n    srs_wideband_snr = np.zeros(n_ap, dtype=float)\n    # Get the SINR of each RB\n    for p_index in range(n_ap):\n        # All use frequency domain estimation\n        # if (nb_re_srs * k_tc * 16) < nfft:\n        srs_TOest[p_index] = np.arctan2(np.imag(srs_TOsum[p_index]), np.real(srs_TOsum[p_index])) \/ (2 * np.pi * k_tc)\n        # else:\n        #    srs_TOest[p_index] \/= (nb_re_srs * k_tc)\n        # Change the TA value into the seconds manner\n        srs_TOest[p_index] = (srs_TOest[p_index] * 4096) \/ 122.88e6\n\n        srs_wideband_snr[p_index] = 0\n        tmp_sum = 0.\n        for rb_idx in range(nb_rb):\n            tmp_sum = 0.\n            for k in range(re_per_rb):\n                tmp_sum += srs_ch_estimates_freq_pow[p_index][rb_idx * re_per_rb + k]\n            srs_wideband_snr[p_index] += (tmp_sum \/ re_per_rb \/ srs_noisepow)\n        srs_wideband_snr[p_index] \/= nb_rb\n    # Collect the results\n    print(srs_TOest)\n    print(srs_wideband_snr)\n    # The estimation of wideband SNR and TA\n    sig_est = 0.\n    ta_est = 0.\n    for srs_cs_idx in range(srs_config.num_ports):\n        sig_est += (1\/srs_config.num_ports) * srs_wideband_snr[srs_cs_idx]\n        ta_est += (1\/srs_config.num_ports) * srs_TOest[srs_cs_idx]\n    sig_est = 10.0 * math.log10(sig_est)    # dB\n    return ta_est, sig_est\n\ndef srs_demodulation(sfn_id, slot_id, sys_parameters, srs_pdu, rx_grid):\n    c_srs = srs_pdu.config_index\n    b_srs = srs_pdu.bandwidth_index\n    k_tc = srs_pdu.comb_size\n    m_srs_b = SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2 * b_srs + 1]\n    m_sc_b_srs = int(m_srs_b * 12 \/ k_tc)\n    \n    k_0_p = srs_freq_start_pos(sfn_id, slot_id, srs_pdu, 2)\n    \n    l_start = srs_pdu.start_symbol_index\n    # There are totally 14 time symbols\n    num_of_subcarriers = int(np.shape(rx_grid)[0] \/ 14)\n    start_subcarrier = l_start * num_of_subcarriers + k_0_p\n\n    m_sc_b_srs_index = 0\n    while ((UL_REFERENCE_SEQUENCES_LEN[m_sc_b_srs_index] != m_sc_b_srs) and (m_sc_b_srs_index < 84)):\n        m_sc_b_srs_index += 1\n\n    u, v = srs_group_sequence_hopping(srs_pdu, l_start, slot_id, m_sc_b_srs)\n    \n    srs_pilot = np.zeros(m_sc_b_srs, dtype=complex)\n\n    # low_p1 = LOWPAPRs(0, 0, [], 6).gen_base()\n    # low_p2 = LOWPAPRs(0, 0, [], 12).gen_base()\n    # low_p3 = LOWPAPRs(0, 0, [], 18).gen_base()\n    low_p = LOWPAPRs(u, v, [], m_sc_b_srs).gen_base()\n    for i in range(m_sc_b_srs):\n        srs_pilot[i] = low_p[i]\n\n    nb_antennas_rx = sys_parameters.rx_ants\n    rx_grid_ext = np.zeros((nb_antennas_rx, m_sc_b_srs), dtype=complex)\n    for aarx in range(nb_antennas_rx):\n        subcarrier = start_subcarrier\n        for k in range(m_sc_b_srs):\n            rx_grid_ext[aarx][k] = rx_grid[subcarrier][aarx]\n            subcarrier += k_tc\n    \n    nfft = sys_parameters.nfft\n    nrof_cyclicShift = srs_pdu.num_ports\n    cycliShift = np.zeros(nrof_cyclicShift, dtype=int)\n    SRS_antenna_port = [1000, 1001, 1002, 1003]\n    if k_tc == 4:\n        n_srs_cs_max = 12\n    elif k_tc == 2:\n        n_srs_cs_max = 8\n\n    for p_index in range(nrof_cyclicShift):\n        cycliShift[p_index] = (srs_pdu.cyclic_shift + (n_srs_cs_max * int(SRS_antenna_port[p_index] - 1000) \/ srs_pdu.num_ports)) % n_srs_cs_max\n    \n    ta_est, sig_est = srs_ch_estimates_proc(srs_pdu, rx_grid_ext, srs_pilot, m_sc_b_srs, \n                                            nrof_cyclicShift, cycliShift, k_tc, nb_antennas_rx, nfft)\n    return ta_est, sig_est\n\ndef srs_rx_proc(sfn_id, slot_id, sys_parameters, srs_pdu, rx_grid):\n    if np.size(srs_pdu) != 1:\n        print('Only support 1 SRS PDU right now !')\n        sys.exit(-1)\n    ta_est, sig_est = srs_demodulation(sfn_id, slot_id, sys_parameters, srs_pdu, rx_grid)\n    print('Estimate SRS (TA, Sigal_strength) : %.8f %.8f' % (ta_est, sig_est))\n    return ta_est, sig_est\n\n#\n#\n#  2. The 2st method for the SRS receiver\n#\n#\n\ndef srs_generate_u_v(group_or_seq_hopping, n_id, n_sf_u, l, mzc):\n    c_init = n_id\n    if group_or_seq_hopping == 'neither':\n        fgh = 0\n        v = 0\n    elif group_or_seq_hopping == 'group_hopping':\n        c_len = 8 * (14 * n_sf_u + l) + 8 + 1\n        c_seq = basic_generate_c_sequence(c_init, c_len)\n        c_seq = c_seq[-8:]\n        fgh = basic_cinit_calc(c_seq, 8)\n        v = 0\n    elif group_or_seq_hopping == 'sequence_hopping':\n        fgh = 0\n        if mzc >= 72:\n            c_len = 14 * n_sf_u + l\n            c_seq = basic_generate_c_sequence(c_init, c_len)\n            v = c_seq[-1]\n        else:\n            v = 0\n    else:\n        print('Parameters of SRS group_or_seq_hopping error !')\n        return 0, 0\n    u = (fgh + n_id) % 30\n    return u, v\n\ndef srs_baseseq_gen(slot_idx, group_or_seq_hopping, hopping_id, l, n_srs_re):\n    u, v = srs_generate_u_v(group_or_seq_hopping, hopping_id, slot_idx, l, n_srs_re)\n    low_p = LOWPAPRs(u, v, [], n_srs_re).gen_base()\n    return low_p\n\ndef srs_cyclic_shift_func(vec_input, cyclicshift):\n    vec_len = len(vec_input)\n    vec_output = np.zeros(vec_len, dtype=complex)\n    if cyclicshift > 0:\n        vec_output[0:vec_len - cyclicshift] = vec_input[cyclicshift: vec_len]\n        vec_output[vec_len - cyclicshift: vec_len] = vec_input[0: cyclicshift]\n    elif cyclicshift < 0:\n        vec_output[0: -cyclicshift] = vec_input[vec_len + cyclicshift: vec_len]\n        vec_output[-cyclicshift: vec_len] = vec_input[0: vec_len + cyclicshift]\n    else:\n        vec_output = vec_input\n    return vec_output\n\nclass SrsProc(object):\n    def __init__(self, sfn, slot, sys_parameters, srs_pdu, rx_grid):\n        \n        self.n_rx                   = sys_parameters.rx_ants\n        self.slot_idx               = slot\n        self.symb_idx               = srs_pdu.start_symbol_index\n        self.srs_parameter          = srs_pdu\n        self.rx_grid                = rx_grid\n        [self.num_rb, self.k0]      = self.srs_freq_position_calc()\n        self.n_srs_re               = int(self.num_rb * 12 \/ srs_pdu.comb_size)\n        self.n_cs_max               = 8 if srs_pdu.comb_size == 4 else 12\n        self.n_fft                  = sys_parameters.nfft\n        self.baseseq                = np.zeros((self.n_srs_re, self.srs_parameter.num_symbols), dtype=complex)\n\n        cs_win                  = int(self.n_srs_re \/ self.n_cs_max)\n        self.cyclicshift        = (self.srs_parameter.cyclic_shift + (self.n_cs_max * np.arange(self.srs_parameter.num_ports) \/ self.srs_parameter.num_ports).astype(int)) % self.n_cs_max\n        n_ports                     = len(self.cyclicshift)\n        \n        min_cs_diff = self.n_cs_max\n        for p_index1 in range(n_ports):\n            for p_index2 in range(n_ports):\n                cs_diff = self.cyclicshift[p_index1] - self.cyclicshift[p_index2]\n                if ((p_index1 != p_index2) and (abs(cs_diff) < min_cs_diff)):\n                    min_cs_diff = np.abs(cs_diff)\n\n        win_size = min(4, min_cs_diff) * cs_win;  #the win size for detecte peak\n        Rms = 32;\n        peak_size = int((Rms * self.num_rb * 12 - 1) \/ self.n_fft) + 2;  #the rms point of peak\n        if (self.num_rb * 12 * 32 < self.n_fft):\n            peak_size = int(max(win_size \/ 2, 3))\n        \n        self.cyclicshift_offset     = cs_win * ((self.n_cs_max - self.cyclicshift) % self.n_cs_max)\n        self.cyclicshift_winsize    = win_size\n        self.peak_winsize           = peak_size\n        \n        n_re = int(self.num_rb * 12 \/ self.srs_parameter.comb_size)\n        self.channel_est_freq             = np.zeros((self.n_rx, n_re), dtype=complex)\n        self.channel_est_time             = np.zeros((self.n_rx, n_re), dtype=complex)\n        self.channel_pow_time             = np.zeros(n_re, dtype = float)\n        self.channel_pow3_time            = np.zeros(n_re, dtype = float)\n        self.channel_est_cyclicshift      = np.zeros((self.n_rx, n_ports, n_re), dtype=complex)\n        self.channel_pow_freq             = np.zeros((n_ports, n_re), dtype = float)\n        \n        self.ta_est             = np.zeros(n_ports, dtype = float)\n        self.rssi               = 0\n        self.noise_pow_est      = 0\n        self.signal_pow_est     = np.zeros(n_ports, dtype = float)\n        self.sinr_est           = np.zeros(n_ports, dtype = float)\n        self.sig_est            = np.zeros(n_ports, dtype = float)\n        \n    def srs_baseseq_gen(self):\n        \n        sequence_id = self.srs_parameter.sequence_id\n        group_or_sequence_hopping = self.srs_parameter.group_or_sequence_hopping\n        \n        for symb_idx in range(self.srs_parameter.num_symbols):\n            l = symb_idx + self.srs_parameter.start_symbol_index\n            self.baseseq[:, symb_idx] = srs_baseseq_gen(self.slot_idx, group_or_sequence_hopping, sequence_id, l, self.n_srs_re)\n        \n        print('srs_baseseq_gen Done')\n\n\n    def srs_channel_ls_est(self):\n\n        n_rx        = self.n_rx\n        \n        point_offset =  int(self.symb_idx * 3276 + self.k0)\n        \n        for symb_idx in range(self.srs_parameter.num_symbols):         \n            for rx_idx in range(n_rx): # extract srs re and ls est\n                srs_extract = self.rx_grid[point_offset : point_offset + self.num_rb * 12 : self.srs_parameter.comb_size, rx_idx]\n                self.channel_est_freq[rx_idx, :]  = srs_extract \/ self.baseseq[:, symb_idx]\n                  \n        print('srs_channel_ls_est Done')\n    \n    def srs_channel_idft(self):\n        \n        n_rx        = self.n_rx\n        n_re        = self.num_rb * 12 \/ self.srs_parameter.comb_size\n                      \n        for rx_idx in range(n_rx): # extract srs re and ls est\n            channel_idft = spy.fft.ifft(self.channel_est_freq[rx_idx, :]) * n_re\n            self.channel_est_time[rx_idx, :]  = channel_idft\n            self.channel_pow_time += np.real(channel_idft * np.conj(channel_idft))\n        \n        if (n_re * 32 < self.n_fft):\n            self.channel_pow3_time = self.channel_pow_time\n        else:\n            for ii in np.array([-1, 0, 1]):\n                self.channel_pow3_time = self.channel_pow3_time + srs_cyclic_shift_func(self.channel_pow_time, ii)\n        self.rssi  = sum(self.channel_pow_time) \/ n_re\n        \n        # plt.plot(self.channel_pow_time)\n       \n        print('srs_channel_idft Done')\n        \n    def srs_channel_cyclicshift_proc(self):\n        \n        n_rx        = self.n_rx\n        n_srs_re = int(self.num_rb * 12 \/ self.srs_parameter.comb_size)\n        \n        pow_diff = self.rssi\n        peak_sc_sum = 0\n        for cs_idx in range(len(self.cyclicshift)):\n            for rx_idx in range(n_rx):\n                h_tmp = srs_cyclic_shift_func(self.channel_est_time[rx_idx, :], self.cyclicshift_offset[cs_idx])\n                pow_tmp = srs_cyclic_shift_func(self.channel_pow3_time, self.cyclicshift_offset[cs_idx])\n                \n                pow_cyclicshift = np.zeros(n_srs_re, dtype = float)\n                pow_cyclicshift[0: int(self.cyclicshift_winsize\/2)] = np.real(pow_tmp[0: int(self.cyclicshift_winsize\/2)])\n                pow_cyclicshift[n_srs_re - int(self.cyclicshift_winsize\/2) : n_srs_re] = np.real(pow_tmp[n_srs_re - int(self.cyclicshift_winsize\/2) : n_srs_re])\n                \n                max_index = np.where(pow_cyclicshift == np.max(pow_cyclicshift))\n                peak_pos = max_index[0][0]\n                \n                # get ta est\n                if peak_pos <= self.cyclicshift_winsize:\n                    self.ta_est[cs_idx] = peak_pos\n                else:\n                    self.ta_est[cs_idx] = peak_pos - n_srs_re\n                \n                peak_offset = int(peak_pos - ((self.peak_winsize - 1) \/ 4 + 1));\n                channel_time_cyclicshift = np.zeros(n_srs_re, dtype=complex)\n                for ii in range(self.peak_winsize):\n                    point_idx = peak_offset + ii\n                    if (point_idx < 0):\n                        point_idx += n_srs_re\n                    # Add the cyclic shift for the right boundary, <NAME>, 2021.7.28\n                    elif point_idx >= n_srs_re:\n                        point_idx -= n_srs_re\n                    channel_time_cyclicshift[point_idx] = h_tmp[point_idx]\n                    \n                channel_dft = spy.fft.fft(channel_time_cyclicshift)\n                \n                self.channel_pow_freq[cs_idx, :] += np.real(channel_dft * np.conj(channel_dft)) \/ n_srs_re\n \n                self.channel_est_cyclicshift[rx_idx, cs_idx, :] = channel_dft\n            \n            self.signal_pow_est[cs_idx] = sum(self.channel_pow_freq[cs_idx])\/n_srs_re\n            pow_diff -= self.signal_pow_est[cs_idx]\n            peak_sc_sum += self.peak_winsize;\n        \n        self.noise_pow_est = pow_diff \/ (n_srs_re - peak_sc_sum) \/ n_rx\n        \n        print('srs_channel_cyclicshift_proc Done')\n\n    def srs_channel_sinr_est(self):\n        n_srs_re = int(self.num_rb * 12 \/ self.srs_parameter.comb_size)\n\n        sig_est = 0.\n        for cs_idx in range(len(self.cyclicshift)):\n            self.sinr_est[cs_idx] = 10* np.log10(self.signal_pow_est[cs_idx] \/ n_srs_re \/ self.noise_pow_est)\n            self.sig_est[cs_idx] = 10* np.log10(self.signal_pow_est[cs_idx] \/ n_srs_re)\n            print('Signal (dB) estimated is = %.6f' % (self.sig_est[cs_idx]))\n            sig_est += (1\/len(self.cyclicshift)) * self.signal_pow_est[cs_idx] \/ n_srs_re \/ self.noise_pow_est\n\n        sig_est = 10.0 * math.log10(sig_est)    # dB\n        print('srs_channel_sinr_est Done')\n        return sig_est\n\n    def srs_freq_position_calc(self):\n        c_srs = self.srs_parameter.config_index\n        b_srs = self.srs_parameter.bandwidth_index\n        comb_size = self.srs_parameter.comb_size\n        comb_offset = self.srs_parameter.comb_offset\n        n_shift = self.srs_parameter.frequency_shift\n        n_rrc = self.srs_parameter.frequency_position\n        N_rb_sc = 12\n\n        m_srs = SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2 * b_srs + 1]\n        N = SRS_BANDWIDTH_CONFIG_TABLE[c_srs][2 * b_srs + 2]\n\n        k0_bar = n_shift * N_rb_sc + comb_offset\n        k0 = k0_bar\n        for b in range(b_srs):\n            n_b = np.floor(4 * n_rrc \/ m_srs) % N # only freq hopping disable\n            k0 +=  n_shift + m_srs * comb_size * n_b\n        return [m_srs, k0]\n\ndef srs_rx_proc2(sfn_id, slot_id, sys_parameters, srs_pdu, rx_grid):\n    # Initialization\n    srs_proc = SrsProc(sfn_id, slot_id, sys_parameters, srs_pdu, rx_grid)\n    # Perform the receiver operation\n    srs_proc.srs_baseseq_gen()\n    srs_proc.srs_channel_ls_est()\n    srs_proc.srs_channel_idft()\n    srs_proc.srs_channel_cyclicshift_proc()\n    # Set the estimated SINR\n    sig_est = srs_proc.srs_channel_sinr_est()\n    return sig_est\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_42","text":"<gh_stars>1-10\nfrom scipy.signal import sawtooth\n\nfrom biofeedback_cube.config import HEIGHT, WIDTH\nfrom ..hydra import hydra\n\n\ndef larson(grid, t):\n    strip_height = 10\n    y1 = HEIGHT \/\/ 2 - strip_height \/\/ 2\n    y2 = y1 + strip_height\n    f = 10.0 * hydra.f\n    x = (sawtooth(f*t, width=0.5) + 1) \/ 2\n    xw = int(x * (WIDTH))\n    grid[y1:y2, xw, :] = (1, 0, 1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_43","text":"<reponame>zhengsizehrb\/opensim-moco\n# -------------------------------------------------------------------------- #\n# OpenSim Muscollo: plot_casadi_sparsity.py                                  #\n# -------------------------------------------------------------------------- #\n# Copyright (c) 2018 Stanford University and the Authors                     #\n#                                                                            #\n# Author(s): <NAME>                                              #\n#                                                                            #\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may    #\n# not use this file except in compliance with the License. You may obtain a  #\n# copy of the License at http:\/\/www.apache.org\/licenses\/LICENSE-2.0          #\n#                                                                            #\n# Unless required by applicable law or agreed to in writing, software        #\n# distributed under the License is distributed on an \"AS IS\" BASIS,          #\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #\n# See the License for the specific language governing permissions and        #\n# limitations under the License.                                             #\n# -------------------------------------------------------------------------- #\nimport scipy.sparse\nimport pandas as pd\nimport sys\nimport numpy as np\nimport pylab as pl\n\ndf = pd.read_csv(sys.argv[1], skiprows=2, sep=' ',\n                 names=['row_indices', 'column_indices'])\n\nwith open(sys.argv[1]) as f:\n    # The first line is a comment.\n    f.readline()\n    # The second line contains the number of row, columns, and nonzeroes.\n    line1 = f.readline()\n    numbers = line1.split(' ')\n    num_rows = int(numbers[0])\n    num_cols = int(numbers[1])\n\nspmat = scipy.sparse.coo_matrix((np.ones_like(df.index),\n        (df['row_indices'] - 1, df['column_indices'] - 1)),\n        shape=(num_rows, num_cols))\npl.spy(spmat, markersize=2, markeredgecolor='k', marker='.')\npl.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_44","text":"<filename>data\/plots\/src\/plot_2D_electrochem.py<gh_stars>0\nfrom utils import *\nimport numpy\nimport matplotlib.pyplot as plt\nimport os, os.path\nfrom scipy.constants import k, e, electron_volt, epsilon_0\n\n\npixels = (512, 512)\n\nquantities = (\"V\", \"c_p\", \"c_n\", \"zflux_cp\", \"zflux_cn\")\nunits = (\"V\", \"mol\/L\", \"mol\/L\", \"mol\/(m$^{2}$*s)\", \"mol\/(m$^{2}$*s)\")\n\nVg_all = [0.001, 0.025, 0.05, 0.1, 0.15, 0.2] + list(numpy.arange(0.25, 1.35, 0.1))\n\nfile_template = \"{0}.npy\"\n\nconcentrations = (0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1)\n\nratio_conc = 10**3\n\n# get the index of column in the new matrix\ndef get_col_index(Vg, quantity):\n    idx_V = Vg_all.index(Vg)\n    idx_quant = quantities.index(quantity)\n    len_quant = len(quantities)\n    return 2 + len_quant * idx_V + idx_quant\n\n\n\n\nout_path = \"..\/result\/concentration\/2D\/\"\nplot_path = \"..\/plot\/concentration\"\n\n# Vg_plot = (0.001, 0.15)\nVg_plot = (0.15,)\n\npairs = [(\"c_p\", 1), (\"c_n\", -1)]\nT = 300\n\n\nplt.style.use(\"science\")\n\nfor conc in [0.001]:\n    file_name = os.path.join(out_path, file_template.format(conc))\n    data = get_data(file_name)  # already in nm\n    X = data[:, 0].reshape(*pixels); Y = data[:, 1].reshape(*pixels)\n    x = data[:, 0]; y = data[:, 1]\n    # cond = numpy.where(x)\n    # print(X[1, 1], Y[1, 1])\n    for quant, z in pairs:\n        for Vg in Vg_plot:\n            print(get_col_index(Vg, quant))\n            c = data[:, get_col_index(Vg, quant)]\n            c[numpy.isnan(c)] = 0\n            print(numpy.max(c), numpy.min(c))\n            v = numpy.nan_to_num(data[:, get_col_index(Vg, \"V\")])\n            v0 = numpy.mean(v[y>19.0])\n            mu = (k * T * numpy.log(c \/ (conc * ratio_conc)) + z * e * v) \/ electron_volt\n            # mu = (z * e * v) \/ electron_volt\n            mu = (k * T * numpy.log(c \/ (conc * ratio_conc))) \/ electron_volt\n            mu0 = numpy.mean(mu[y>19.5])\n            mu = mu - mu0\n            D = mu.reshape(*pixels)\n            D[numpy.isinf(D)] = 0\n            print(numpy.max(D), numpy.min(D))\n            plt.cla()\n            fig = plt.figure(figsize=(2.8, 2.8))\n            ax = fig.add_subplot(111)\n            # if z > 0:\n                # vmin = -0.10; vmax = 0.01\n            # else:\n                # vmin = 0.008; vmax = 0.011\n            mesh = plot_data(ax, X, Y, D)\n            mesh.set_cmap(\"jet\")\n            ax.set_title(\"{0} mol\/L-{1} V-{2}\".format(conc,\n                                                            Vg,\n                                                            quant\n            ))\n            ax.set_xlabel(\"$r$ (nm)\")\n            ax.set_ylabel(\"$z$ (nm)\")\n            add_graphene(ax, R_p=10)\n            fig.colorbar(mesh, fraction=0.03)\n            fig.tight_layout()\n            outfile = os.path.join(plot_path,\n                                     \"mu-{0}-{1}-{2}.svg\".format(conc,\n                                                              Vg,\n                                                              quant))\n            print(outfile)\n            fig.savefig(outfile)\n            \n    \n    \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_45","text":"import numpy as np\r\nimport pandas as pd # added pandas module for v 0.0.5 (needed when features=3, visualize=True)\r\nfrom sklearn.cluster import KMeans\r\nfrom scipy.spatial.distance import cdist \r\nimport matplotlib.pyplot as plt\r\nfrom mpl_toolkits import mplot3d\r\nimport seaborn as sns\r\nimport warnings #v0.0.6 added warnings\r\n\r\nclass Optimal():\r\n    \r\n    \"\"\"\r\n    To find optimal number of clusters using different optimal clustering algorithms\r\n    *citation*\r\n    *parameters*\r\n    *methods*\r\n    *example*\r\n    \"\"\"\r\n    \r\n    opti_df = None\r\n    \r\n    def __init__(\r\n        self,\r\n        kmeans_kwargs: dict = None\r\n    ):\r\n        \"\"\"\r\n        *description*\r\n        *citation*\r\n        *parameters*\r\n        *methods*\r\n        *example*\r\n        \"\"\"\r\n        self.kmeans_kwargs = kmeans_kwargs\r\n    \r\n    def elbow(self,df,upper=15,display=False,visualize=False,function='inertia',method='angle',sq_er=1):\r\n        \"\"\"\r\n        *description*\r\n        *citation*\r\n        *parameters*\r\n        *methods*\r\n        *example*\r\n        \"\"\"\r\n        lower=1\r\n        inertia = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            if function=='inertia':\r\n                inertia.append(cls.inertia_)\r\n            elif function=='distortion':\r\n                inertia.append(sum(np.min(cdist(df, cls.cluster_centers_, \r\n                          'euclidean'),axis=1)) \/ df.shape[0])\r\n            else:\r\n                raise ValueError('function should be \"inertia\" or \"distortion\"')\r\n        inertia = np.array(inertia)\/(np.array(inertia)).max()*14 #v0.0.6 changed to fixed number of 14 (elbow)\r\n        slopes = [inertia[0]-inertia[1]]\r\n        for i in range(len(inertia)-1):\r\n            slopes.append(-(inertia[i+1]-inertia[i]))\r\n        angles = []\r\n        for i in range(len(slopes)-1):\r\n            angles.append(np.degrees(np.arctan((slopes[i]-slopes[i+1])\/(1+slopes[i]*slopes[i+1]))))\r\n        if display==True:\r\n            plt.plot(K, inertia, 'bx-') \r\n            plt.xlabel('Values of K') \r\n            plt.ylabel(function) \r\n            plt.title('The Elbow Method using '+function) \r\n            plt.show()\r\n        extra=''\r\n        if method == 'angle':\r\n            optimal = np.array(angles).argmax()+1\r\n            confidence = round(np.array(angles).max()\/90*100,2)\r\n            if confidence<=50:\r\n                extra=' with Confidence:'+str(confidence)+'%.'+' Try using elbow_kf, gap_stat_se or other methods, or change the method parameter to \"lin\"'\r\n        elif method == 'lin': #v0.0.6 changed method for lin\r\n            flag=False\r\n            for i in range(len(slopes)-1):\r\n                if (sum([(slopes[i]-slopes[j])**2 for j in range(i+1,len(slopes))]))<=sq_er:\r\n                    optimal = i\r\n                    flag=True\r\n                    break\r\n            if flag==False:\r\n                optimal=upper-1\r\n                warnings.warn(\"Optimal cluster value did not satisfy sq_er condition. Try increasing value of parameter upper for a better result\")\r\n        else:\r\n            raise ValueError('method should be \"angle\" or \"lin\"')\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')#v0.0.6, changed ValueError to warning\r\n        print('Optimal number of clusters is: ',str(optimal),extra) # raised ValueErrors for fail cases v 0.0.5\r\n        return optimal \r\n    \r\n    def elbow_kf(self,df,upper=15,display=False,visualize=False,function='inertia',se_weight=1.5):#v0.0.6 added elbow_kf method\r\n        \"\"\"\r\n        *description*\r\n        *citation*\r\n        *parameters*\r\n        *methods*\r\n        *example*\r\n        \"\"\"\r\n        lower=1\r\n        inertia = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            if function=='inertia':\r\n                inertia.append(cls.inertia_)\r\n            elif function=='distortion':\r\n                inertia.append(sum(np.min(cdist(df, cls.cluster_centers_, \r\n                          'euclidean'),axis=1)) \/ df.shape[0])\r\n            else:\r\n                raise ValueError('function should be \"inertia\" or \"distortion\"')\r\n        inertia = np.array(inertia)\/(np.array(inertia)).max()*14\r\n        slopes = [inertia[0]-inertia[1]]\r\n        for i in range(len(inertia)-1):\r\n            slopes.append(-(inertia[i+1]-inertia[i]))\r\n        if display==True:\r\n            plt.plot(K, inertia, 'bx-') \r\n            plt.xlabel('Values of K') \r\n            plt.ylabel(function) \r\n            plt.title('The Elbow Method using '+function) \r\n            plt.show()\r\n        means = []\r\n        sds = []\r\n        for i in range(len(slopes)-1):\r\n            means.append(np.mean(np.array(slopes[i:i+3 if i+3<len(slopes) else (i+2 if i+2<len(slopes) else i+1)])))\r\n            sds.append(np.std(np.array(slopes[i:i+3 if i+3<len(slopes) else (i+2 if i+2<len(slopes) else i+1)])))\r\n        flag=False\r\n        while(not flag):\r\n            diffs = [x[0]-se_weight*x[1]>0 for x in zip(means,sds)]\r\n            optimal = (len(diffs) - list(reversed(diffs)).index(False)) if False in diffs else -1\r\n            if optimal==-1:\r\n                se_weight+=0.5\r\n                if se_weight>15:#v0.0.6 TODO: find a better way to check this fail case\r\n                    warnings.warn('Optimal cluster not found even with high se_weight, try increasing upper parameter')\r\n                    return -1\r\n            else:\r\n                flag=True\r\n        k_factor = (round(diffs[0:optimal].count(False)\/len(diffs[0:optimal]),2))\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')#v0.0.6, changed ValueError to warning\r\n        extra = '' if k_factor>=0.60 else 'Lesser k_factor may be due to overlapping clusters, try increasing the se_weight parameter to '+str(se_weight+0.5)\r\n        print('Optimal number of clusters is: ',str(optimal),' with k_factor:',str(k_factor),'.',extra)\r\n        return optimal\r\n    \r\n    def silhouette(self,df,lower=2,upper=15,display=False,visualize=False):#v0.0.6 added slihouette method\r\n        from sklearn.metrics import silhouette_score\r\n        scores = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            scores.append(silhouette_score(df,cls_assignment))\r\n        if display==True:\r\n            plt.plot(K, scores, 'bx-') \r\n            plt.xlabel('Values of K') \r\n            plt.ylabel('silhouette_score') \r\n            plt.title('Silhouette Analysis') \r\n            plt.show()\r\n        optimal = K[scores.index(sorted(scores,reverse=True)[0])]\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')#v0.0.6, changed ValueError to warning\r\n        print('Optimal number of clusters is: ',str(optimal))\r\n        return optimal\r\n    \r\n    def gap_stat(self,df,B=5,lower=1,upper=15,display=False,visualize=False):#v0.0.6 added gap_stat method\r\n        if B*len(df)*upper>3000:\r\n            warnings.warn('Many cases to check, may take some time')\r\n        gaps = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            W_star = []\r\n            for k in range(B):\r\n                sample = np.random.random_sample(size=df.shape)\r\n                W_star.append(KMeans(i).fit(sample).inertia_)\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            W = cls.inertia_\r\n            gaps.append(np.mean(np.log(W_star)) - np.log(W))\r\n        if display==True:\r\n            plt.plot(K, gaps, 'bx-') \r\n            plt.xlabel('Values of K') \r\n            plt.ylabel('Gaps') \r\n            plt.title('Gaps Statistic Analysis') \r\n            plt.show()\r\n        optimal = np.array(gaps).argmax()+1\r\n        if optimal==len(gaps):\r\n            warnings.warn('Try increasing upper parameter for a better result.')\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')#v0.0.6, changed ValueError to warning\r\n        return optimal\r\n    \r\n    def gap_stat_se(self,df,B=5,lower=1,upper=15,display=False,visualize=False,se_weight=1):\r\n        import math\r\n        if B*len(df)*upper>3000:\r\n            warnings.warn('Many cases to check, may take some time')\r\n        gaps = []\r\n        s = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            W_star = []\r\n            for k in range(B):\r\n                sample = np.random.random_sample(size=df.shape)\r\n                W_star.append(KMeans(i).fit(sample).inertia_)\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            W = cls.inertia_\r\n            gaps.append(np.mean(np.log(W_star)) - np.log(W))\r\n            sd = np.std(np.log(W_star))\r\n            s.append(math.sqrt(1+(1\/B))*sd)\r\n        if display==True:\r\n            plt.plot(K, gaps, 'bx-',label='gaps') \r\n            diff = np.append((np.array(gaps)-se_weight*np.array(s))[1:],(np.array(gaps)-se_weight*np.array(s))[-1:])\r\n            plt.plot(K, diff, 'rx-',label='diff')\r\n            plt.xlabel('Values of K') \r\n            plt.ylabel('Gaps') \r\n            plt.legend()\r\n            plt.title('Gaps Statistic Analysis') \r\n            plt.show()\r\n        flag = False\r\n        for i in range(0,len(gaps)-1):\r\n            if (gaps[i]>=gaps[i+1]-se_weight*s[i+1]):\r\n                optimal = i+1\r\n                flag = True\r\n                break\r\n        if flag==False:\r\n            warnings.warn('Could not find an optimal point using this method, optimal cluster returned is from gap_stat method. Try increasing upper parameter')\r\n            optimal = np.array(gaps).argmax()+1#v0.0.6 added fail check for gap_stat_se\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')\r\n        return optimal\r\n    \r\n    def gap_stat_wolog(self,df,B=5,upper=15,display=False,visualize=False,method='lin',se_weight=1,sq_er=1):\r\n        if B*len(df)*upper>3000:\r\n            warnings.warn('Many cases to check, may take some time')\r\n        lower = 1\r\n        gaps = []\r\n        K=range(lower,upper)\r\n        for i in K:\r\n            W_star = []\r\n            for k in range(B):\r\n                sample = np.random.random_sample(size=df.shape)\r\n                W_star.append(KMeans(i).fit(sample).inertia_)\r\n            cls = KMeans(n_clusters=i,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=i)\r\n            cls_assignment = cls.fit_predict(df)\r\n            W = cls.inertia_\r\n            gaps.append(np.mean((W_star)) - (W))\r\n        gaps = (np.array(gaps)-np.array(gaps).min())\/(np.array(gaps).max()-np.array(gaps).min())*14#v0.0.6 changed to fixed number of 14 (elbow)\r\n        slopes = [gaps[0]-gaps[1]]\r\n        for i in range(len(gaps)-1):\r\n            slopes.append((gaps[i+1]-gaps[i]))\r\n        if method=='angle':\r\n            angles = []\r\n            for i in range(len(slopes)-1):\r\n                angles.append(np.degrees(np.arctan((slopes[i]-slopes[i+1])\/(1+slopes[i]*slopes[i+1]))))\r\n            optimal = np.array(angles).argmax()+1\r\n        elif method=='lin':#v0.0.6 changed algo for lin method for gap_stat_wolog\r\n            flag=False\r\n            for i in range(len(slopes)-1):\r\n                if (sum([(slopes[i]-slopes[j])**2 for j in range(i+1,len(slopes))]))<=sq_er:\r\n                    optimal = i\r\n                    flag=True\r\n                    break\r\n            if flag==False:\r\n                optimal=upper-1\r\n                warnings.warn(\"Optimal cluster value did not satisfy sq_er condition. Try increasing value of parameter upper for a better result\")\r\n        elif method=='max':\r\n            optimal = np.array(gaps).argmax()+1\r\n        else:\r\n            raise ValueError('method should be \"lin\",\"angle\" or \"max\"')\r\n        if display==True:\r\n            plt.plot(K, gaps, 'bx-') \r\n            plt.xlabel('Values of K') \r\n            plt.ylabel('Gaps') \r\n            plt.title('Gaps Statistic Analysis') \r\n            plt.show()\r\n        if visualize==True:\r\n            x = self._visualization(df,optimal) \r\n            if x=='fail':\r\n                warnings.warn('Could not visualize: Number of columns of the DataFrame should be between 1 and 3 for visualization')\r\n        return optimal\r\n\r\n    def _visualization(self,df,optimal):#v0.0.6 made visualization method a class method\r\n        \"\"\"\r\n        *description*\r\n        *citation*\r\n        *parameters*\r\n        *methods*\r\n        *example*\r\n        \"\"\"\r\n        cls = KMeans(n_clusters=optimal,**self.kmeans_kwargs) if self.kmeans_kwargs is not None else KMeans(n_clusters=optimal)\r\n        cls_assignment = cls.fit_predict(df)\r\n        if len(df.columns) == 1:\r\n            col_name = df.columns[0]\r\n            sns.stripplot(data = df,x=['']*len(df),y=col_name,hue=cls_assignment)\r\n            plt.title('Clustering with '+str(optimal)+' clusters')\r\n            plt.show()\r\n        elif len(df.columns)==2:\r\n            col_name1 = df.columns[0]\r\n            col_name2 = df.columns[1]\r\n            sns.scatterplot(data=df,x=col_name1,y=col_name2,hue=cls_assignment,palette='Set1')\r\n            plt.title('Clustering with '+str(optimal)+' clusters')\r\n            plt.show()\r\n        elif len(df.columns)==3:\r\n            fig = plt.figure()\r\n            ax = plt.axes(projection=\"3d\")\r\n            col_name1 = df.columns[0]\r\n            col_name2 = df.columns[1]\r\n            col_name3 = df.columns[2]\r\n            ax.scatter3D(xs=df[col_name1],ys=df[col_name2],zs=df[col_name3],c=pd.Series(cls_assignment))\r\n            plt.title('Clustering with '+str(optimal)+' clusters')\r\n            plt.show()\r\n        else:\r\n            return 'fail'\r\n    \r\n    \r\n        #TODO: add documentation\r\n        #TODO: add checks for upper,lower, other params\r\n        #TODO: for optimal cluster of 1\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_46","text":"<gh_stars>0\nimport math\nimport numpy as np\nfrom scipy import special\nimport atmosphere\n\ndef variance(r0=None,L0=None,atmosphere=None):\n    if atmosphere is not None:\n        r0 = atmosphere.r0\n        L0 = atmosphere.L0\n    L0r0ratio= (L0\/r0)**(5.\/3)\n    return (24*math.gamma(6.\/5)\/5.)**(5.\/6)* \\\n        (math.gamma(11.\/6)*math.gamma(5.\/6)\/(2.*math.pi**(8.\/3)))*L0r0ratio\n\ndef covariance(rho,r0=None,L0=None,atmosphere=None):\n    if atmosphere is not None:\n        r0 = atmosphere.r0\n        L0 = atmosphere.L0\n    rho = np.array(rho)\n    L0r0ratio= (L0\/r0)**(5.\/3)\n    cst      = (24.*math.gamma(6.\/5)\/5.)**(5.\/6)* \\\n               (math.gamma(11.\/6)\/(2.**(5.\/6)*math.pi**(8.\/3)))* \\\n                L0r0ratio\n    out = np.zeros_like(rho)\n    for k in range(rho.size):\n        if rho[k]==0:\n            out[k] = (24.*math.gamma(6.\/5)\/5)**(5.\/6)* \\\n                     (math.gamma(11.\/6)*math.gamma(5.\/6)\/(2.*math.pi**(8.\/3)))*L0r0ratio\n        else:\n            u  = 2.*math.pi*rho[k]\/L0;\n            out[k] = cst*u**(5.\/6)*special.kv(5.\/6,u)\n    return out\n\ndef structure_function(rho,r0=None,L0=None,atmosphere=None):\n    return 2*(variance(r0=r0,L0=L0,atmosphere=atmosphere) - covariance(rho,r0=r0,L0=L0,atmosphere=atmosphere))\n\n    \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_47","text":"#!\/usr\/bin\/python3\n'''Advent of Code 2018 Day 23 solution'''\n\nimport re\nfrom statistics import median\nfrom typing import List, Tuple, TextIO\n\nNanobot = Tuple[int, int, int, int]\nInput = List[Nanobot]\nPoint = Tuple[Nanobot, int]\n\ndef taxicabdistance(a: Nanobot, b: Nanobot) -> int:\n    '''Calculate Taxi Cab (Manhattan) distance between two pairs of coordinates'''\n    return abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2])\n\ndef runpart1(inputs: Input) -> int:\n    '''Solve part 1'''\n    inputs.sort(key=lambda x: x[3], reverse=True)\n    strongest = inputs[0]\n\n    inrange = [n for n in inputs if taxicabdistance(n, strongest) <= strongest[3]]\n    return len(inrange)\n\ndef runpart2(inputs: Input) -> int:\n    '''Solve part 2'''\n    # This deserves some explanation. Frankly, I'm amazed it worked first time. We take the median\n    # of the input coordinates as a starting point, and move towards the best point in terms of\n    # Nanobots in range, using distance from the origin (Our location) as tie break. We cast the\n    # net very wide (searching current location +\/- 10,000 initially) and gradually narrow that\n    # down until we find the best point. Large initial net seems to be the key to not getting\n    # caught in a local maximum, but the numbers might neet tweaking for other input data sets.\n    x = int(median([a[0] for a in inputs]))\n    y = int(median([a[1] for a in inputs]))\n    z = int(median([a[2] for a in inputs]))\n\n    # Size of initial scan area\n    diff = 100000\n\n    while True:\n        box: List[Point] = [] # List of points we've checked\n\n        # Check each point in turn and record nanobots in range.\n        for a in [x-diff, x, x+diff]:\n            for b in [y-diff, y, y+diff]:\n                for c in [z-diff, z, z+diff]:\n                    d: Nanobot = (a, b, c, 0)\n                    inrange: int = len([n for n in inputs if taxicabdistance(n, d) <= n[3]])\n                    box.append((d, inrange))\n\n        # Get the best count of bots in range found during our checks\n        box.sort(key=lambda bot: bot[1], reverse=True)\n        best: int = box[0][1]\n\n        # Get valid successors (Any point that equals the best count)\n        valid: List[Point] = [n for n in box if n[1] == best]\n\n        # Now find the best point (Closest to origin that is also valid)\n        valid.sort(key=lambda p: abs(p[0][0] + abs(p[0][1]) + abs(p[0][2])))\n        # If the current point is our best point...\n        if (valid[0][0][0], valid[0][0][1], valid[0][0][2]) == (x, y, z):\n            if diff == 1:\n                # ...return the distance from the origin if we're already at minimum net size...\n                return abs(x) + abs(y) + abs(z)\n            # ...otherwise, shrink the net.\n            diff = int(diff \/ 10)\n\n        # Update the current point\n        x = valid[0][0][0]\n        y = valid[0][0][1]\n        z = valid[0][0][2]\n\ndef readinputdata(f: TextIO) -> Input:\n    '''Read input data from the given file handle into inputs'''\n    inputs: Input = []\n\n    m = re.compile(r'pos=<([-\\d]+),([-\\d]+),([-\\d]+)>, r=([-\\d]+)')\n    for line in f.readlines():\n        result = m.match(line)\n        if result is not None:\n            inputs.append((int(result.group(1)), int(result.group(2)),\n                           int(result.group(3)), int(result.group(4))))\n\n    return inputs\n\ndef run() -> Tuple[int, int]:\n    '''Main'''\n    with open('inputs\/day23.txt', 'r') as f:\n        inputs = readinputdata(f)\n\n    return(runpart1(inputs), runpart2(inputs))\n\nif __name__ == '__main__':\n    print(run())\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_32","text":"<gh_stars>0\nimport os\nimport pickle\nfrom time import time\n\nimport cv2\nimport numpy as np\nfrom keras.preprocessing.image import (ImageDataGenerator, array_to_img,\n                                       img_to_array, load_img)\nfrom scipy.stats import itemfreq\nfrom skimage.feature import local_binary_pattern\nfrom sklearn.cross_validation import train_test_split\nfrom sklearn.decomposition import (MiniBatchDictionaryLearning, SparseCoder,\n                                   dict_learning, sparse_encode)\nfrom sklearn.metrics import classification_report\nfrom sklearn.preprocessing import normalize\nfrom sklearn.svm import SVC, LinearSVC\nfrom tqdm import tqdm\n\n\n\nbleeding_images_path = \"\"\n\nnormal_images_path = \"\"\n\nimage_name = []\nfor filename in os.listdir(bleeding_images_path):\n    if(filename != '.ipynb_checkpoints'):\n        image_name.append(os.path.join(bleeding_images_path, filename))\nfor filename in os.listdir(normal_images_path = \"\"):\n    if(filename != '.ipynb_checkpoints'):\n        image_name.append(os.path.join(normal_images_path, filename))\n\nY = np.append(np.ones(456), np.zeros(456))\nY = Y.reshape(len(image_name), 1)\n\nX_train, X_test, y_train, y_test = train_test_split(image_name, Y, test_size=0.30, random_state=42)\n\n\nprint('finding the descriptors.........')\nt0 = time()\n\nkeypoints_count_train = []\ndescriptors = []\nfor img_path in tqdm(X_train):\n    img = cv2.imread(img_path)\n    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n    sift = cv2.xfeatures2d.SIFT_create()\n    kp, des = sift.detectAndCompute(gray,None)\n    keypoints_count_train.append(len(kp))\n    descriptors.append(des)\n    \ndescriptors = np.concatenate(descriptors, axis=0)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('descriptors.shape : ', descriptors.shape)\n\nprint('finding the test_descriptors..........')\n\nt0 = time()\n\nkeypoints_count_test = []\ntest_descriptors = []\n\nfor img_path in X_test:\n    img = cv2.imread(img_path)\n    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n    sift = cv2.xfeatures2d.SIFT_create()\n    kp, des = sift.detectAndCompute(gray,None)\n    keypoints_count_test.append(len(kp))\n    test_descriptors.append(des)\n    \ntest_descriptors = np.concatenate(test_descriptors, axis=0)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('test_descriptors.shape : ', test_descriptors.shape)\n\n\nprint('Learning the dictionary...')\nt0 = time()\ndico = MiniBatchDictionaryLearning(n_components=100, batch_size=10, alpha=1, n_iter=250)\ndictionary = dico.fit(descriptors).components_\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('dictionary.shape : ', dictionary.shape)\n\nprint('finding the X_train_sparse_code..........')\n\nt0 = time()\ndico.set_params(transform_algorithm='omp')\nX_train_sparse_code = dico.transform(descriptors)\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('X_train_sparse_code.shape : ', X_train_sparse_code.shape)\n\nprint('finding the X_test_sparse_code..........')\n\nt0 = time()\ndico.set_params(transform_algorithm='omp')\nX_test_sparse_code = dico.transform(test_descriptors)\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('X_test_sparse_code.shape : ', X_test_sparse_code.shape)\n\n\nwith open('descriptors', 'wb') as f:\n    pickle.dump(descriptors, f)\n    \nwith open('test_descriptors', 'wb') as f:\n    pickle.dump(test_descriptors, f)\n\nwith open('X_train_sparse_code', 'wb') as f:\n    pickle.dump(X_train_sparse_code, f)\n\nwith open('X_test_sparse_code', 'wb') as f:\n    pickle.dump(X_test_sparse_code, f)\n\nwith open('dictionary', 'wb') as f:\n    pickle.dump(dictionary, f)\n    \nwith open('Dataset', 'wb') as f:\n    pickle.dump([X_train, X_test, y_train, y_test], f)\n    \nprint(\"...................saved all variables.............\")\n\n\nfinal_vectors_list_train = []\nt0 = time()\n\nlast_keypoints_count_train = 0\n\nfor keypoints_count in keypoints_count_train:\n    vector = np.amax(X_train_sparse_code[last_keypoints_count_train : keypoints_count + last_keypoints_count_train], axis = 0)\n    final_vectors_list_train.append(vector)\n    \n    last_keypoints_count_train += keypoints_count\n    \nfinal_vectors_list_train = np.array(final_vectors_list_train)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nfinal_vectors_list_test = []\nt0 = time()\n\nlast_keypoints_count_test = 0\n\nfor keypoints_count in keypoints_count_test:\n    vector = np.amax(X_test_sparse_code[last_keypoints_count_test : keypoints_count + last_keypoints_count_test], axis = 0)\n    final_vectors_list_test.append(vector)\n    \n    last_keypoints_count_test += keypoints_count\n    \nfinal_vectors_list_test = np.array(final_vectors_list_test)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nfinal_vectors_list_train.shape\n\nfinal_vectors_list_test.shape\n\nfinal_vectors_list_test\n\n\nclf = LinearSVC()\nclf.fit(final_vectors_list_train, y_train)\npredictions = clf.predict(final_vectors_list_test)\n\nprint(classification_report(y_test, predictions))\n\n\nwith open('X_train_sparse_code_2', 'rb') as f:\n    # Python 3: open(..., 'rb')\n    X_train_sparse_code = pickle.load(f)\n    \nwith open('X_test_sparse_code_2', 'rb') as f:\n    # Python 3: open(..., 'rb')\n    X_test_sparse_code = pickle.load(f)\n\nwith open('Dataset_2', 'rb') as f:# Python 3: open(..., 'rb')\n     X_train, X_test, y_train, y_test = pickle.load(f)\n\n\nprint('finding the descriptors.........')\nt0 = time()\n\nkeypoints_count_train = []\ndescriptors = []\nfor img_path in tqdm(X_train):\n    img = cv2.imread(img_path)\n    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n    sift = cv2.xfeatures2d.SIFT_create()\n    kp, des = sift.detectAndCompute(gray,None)\n    keypoints_count_train.append(len(kp))\n    descriptors.append(des)\n    \ndescriptors = np.concatenate(descriptors, axis=0)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('finding the test_descriptors..........')\n\nt0 = time()\n\nkeypoints_count_test = []\ntest_descriptors = []\n\nfor img_path in tqdm(X_test):\n    img = cv2.imread(img_path)\n    gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n    sift = cv2.xfeatures2d.SIFT_create()\n    kp, des = sift.detectAndCompute(gray,None)\n    keypoints_count_test.append(len(kp))\n    test_descriptors.append(des)\n    \ntest_descriptors = np.concatenate(test_descriptors, axis=0)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nwith open('keypoints_count_train_2', 'wb') as f:\n    pickle.dump(keypoints_count_train, f)\n\nwith open('keypoints_count_test_2', 'wb') as f:\n    pickle.dump(keypoints_count_test, f)\n    \nfinal_vectors_list_train = []\nt0 = time()\n\nlast_keypoints_count_train = 0\n\nfor keypoints_count in tqdm(keypoints_count_train):\n    vector = np.amax(X_train_sparse_code[last_keypoints_count_train : keypoints_count + last_keypoints_count_train], axis = 0)\n    final_vectors_list_train.append(vector)\n    \n    last_keypoints_count_train += keypoints_count\n    \nfinal_vectors_list_train = np.array(final_vectors_list_train)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('final_vectors_list_train.shape : ', final_vectors_list_train.shape)\n\nfinal_vectors_list_test = []\nt0 = time()\n\nlast_keypoints_count_test = 0\n\nfor keypoints_count in tqdm(keypoints_count_test):\n    vector = np.amax(X_test_sparse_code[last_keypoints_count_test : keypoints_count + last_keypoints_count_test], axis = 0)\n    final_vectors_list_test.append(vector)\n    \n    last_keypoints_count_test += keypoints_count\n    \nfinal_vectors_list_test = np.array(final_vectors_list_test)\n\ndt = time() - t0\nprint('done in %.2fs.' % dt)\n\nprint('final_vectors_list_test.shape : ', final_vectors_list_test.shape)\n\nwith open('final_vectors_list_train_2', 'wb') as f:\n    pickle.dump(final_vectors_list_test, f)\n\nwith open('final_vectors_list_train_2', 'wb') as f:\n    pickle.dump(final_vectors_list_test, f)\n\n\nclf = LinearSVC(C=0.001, loss='hinge', penalty='l2')\nclf.fit(final_vectors_list_train, y_train)\npredictions = clf.predict(final_vectors_list_test)\n\nprint(classification_report(y_test, predictions))\n\nclf_2 = SVC(C=10.0, kernel='rbf', gamma=0.00001)\n\nclf_2.fit(final_vectors_list_train, y_train)\npredictions_2 = clf_2.predict(final_vectors_list_test)\n\nprint(classification_report(y_test, predictions_2))\n\n\nradius = 3\nno_points = 8 * radius\n\nlbp_features_train = []\n\nfor img_path in tqdm(X_train):\n    im = cv2.imread(img_path)\n    im_gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)\n    lbp = local_binary_pattern(im_gray, no_points, radius, method='uniform')\n    x = itemfreq(lbp.ravel())\n    hist = x[:, 1] \/ sum(x[:, 1])\n    lbp_features_train.append(hist)\n    \nlbp_features_train = np.array(lbp_features_train)\nlbp_features_train.shape\n\nX_train_lbp = np.concatenate((final_vectors_list_train, lbp_features_train), axis = 1)\nX_train_lbp.shape\n\nlbp_features_test = []\n\nfor img_path in tqdm(X_test):\n    im = cv2.imread(img_path)\n    im_gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)\n    lbp = local_binary_pattern(im_gray, no_points, radius, method='uniform')\n    x = itemfreq(lbp.ravel())\n    hist = x[:, 1] \/ sum(x[:, 1])\n    lbp_features_test.append(hist)\n    \nX_test_lbp = np.concatenate((final_vectors_list_test, lbp_features_test), axis = 1)\nX_test_lbp.shape\n\nclf_3 = SVC(C=1.0, kernel='rbf', gamma=0.00001)\n\nclf_3.fit(X_train_lbp, y_train)\npredictions_3 = clf_3.predict(X_test_lbp)\n\nprint(classification_report(y_test, predictions_3))\n\nfinal_vectors_list_train.shape\n\nwith open('X_train_lbp', 'wb') as f:\n    pickle.dump(X_train_lbp, f)\n\nwith open('X_test_lbp', 'wb') as f:\n    pickle.dump(X_test_lbp, f)\n    \nwith open('lbp_features_train', 'wb') as f:\n    pickle.dump(lbp_features_train, f)\n    \nwith open('lbp_features_test', 'wb') as f:\n    pickle.dump(lbp_features_test, f)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_35","text":"from math import sin, cos\nfrom scipy.integrate import quad\nfrom scipy.optimize import minimize\n\n# This is based on the tutorial found here: https:\/\/tinyurl.com\/92dwh52\n# This sample code will likely be useful: https:\/\/tinyurl.com\/4br894dt\n\nclass PathGenerator:\n    def __init__(self, start_x, start_y, start_theta, start_curvature, \n                        goal_x, goal_y, goal_theta, goal_curvature,\n                        alpha=15, beta=25, gamma=35, kmax=0.5):\n        \"\"\" Takes start and end coordinates, heading, and curvature, \n        returns a curve that connects them. Alpha, beta, and gamma\n        scale our soft constraints for x, y, and theta. For example,\n        if we want our curve endpoint to be constrained very tightly \n        to our goal conditions, we make these large. If we are okay with\n        a bit of error, we make these small. Kmax determinines the\n        max sharpness of a turn. If we want a very smooth ride, we make this\n        small, if we are okay with sharp turns, we make this large.\"\"\"\n        \n        # Start conditions\n        self.x0, self.y0 = start_x, start_y\n        self.t0, self.k0 = start_theta, start_curvature\n        # End conditions\n        self.xf, self.yf = goal_x, goal_y\n        self.tf, self.kf = goal_theta, goal_curvature\n        # Constraints\n        self.alpha, self.beta, self.gamma, self.kmax = alpha, beta, gamma, kmax\n\n        # We break the curve into 3 equal sections\n        # We are solving for p1, p2, p4 (p0 & p3 are constant)\n        # self.p0 = self.k0           # Starting point of curve\n        # self.p1 = \"1\/3 down curve\"  # 1\/3 down curve\n        # self.p2 = \"2\/3 down curve\"  # 2\/3 down curve\n        # self.p3 = self.kf           # Ending point of curve\n        # self.p4 = \"Length of curve\" # Length of curve\n        self.p0 = self.k0\n        self.p1 = 1.\/3.\n        self.p2 = 2.\/3.\n        self.p3 = self.kf\n        self.p4 = 1.\n\n        # Constraints for the optimization problem\n        self.bound_p1 = [-1*self.kmax, self.kmax]    # p1's constraint\n        self.bound_p2 = [-1*self.kmax, self.kmax]    # p2's constraint\n        self.bounds = [self.bound_p1, self.bound_p2]\n\n        # TODO: optimize self.objective_function\n        # path_raw = \"Optimization of self.objective_function() for params p1, p2, p4\"\n        # Pseudocode layout?: optimize(self.objective_function, params=[self.p1, self.p2, self.p4], bounds=self.bounds)\n        x_0 = [self.p1, self.p2, self.p4]  # initial guess\n        print('initial guess')\n        print(self.objective_function(x_0))\n        output_params = minimize(self.objective_function, x_0)\n        print(output_params)\n        # path = \"The path above, but mapping the p values back to spiral parameters\"\n        self.p1 = output_params['x'][0]\n        self.p2 = output_params['x'][1]\n        self.p4 = output_params['x'][2]\n        \n        self.a_list = [self.a0_map(), self.a1_map(self.p1, self.p2, self.p4), self.a2_map(self.p1, self.p2, self.p4), self.a3_map(self.p1, self.p2, self.p4)]\n\n        # Sample the curve to get our points\n        s_i = 0\n        self.interval = 0.25\n        self.t_list = []\n        self.k_list = []\n        \n        # get theta(s) and k(s) for all 's' with step size 'self.interval'\n        while s_i <= self.p4:\n            k_list.append(self.final_spiral(s_i))\n            t_list.append(self.final_theta(s_i))\n            s_i += self.interval\n\n        # use our theta(s) values to find x(s) and y(s) values with trapezoid rule\n        # the index 's' values should align with t_list and k_list (might be off by 1)\n        x_list = self.x_trapezoidal()\n        x_list.insert(0, self.x0)\n        x_list.insert(-1, self.xf)\n        \n        y_list = self.y_trapezoidal()\n        y_list.insert(0, self.y0)\n        y_list.insert(-1, self.yf)\n        \n        self.path = [x_list, y_list, t_list, k_list]\n\n        # information of our s values, if helpful\n        self.s_info = {'min': 0, 'max':s_i, 'interval':self.interval}\n\n    def final_spiral(self, s):\n        \"\"\" Our final k(s) equation \"\"\"\n        return self.a_list[3]*s**3 + self.a_list[2]*s**2 + self.a_list[1]*s + self.a_list[0]\n\n    def final_theta(self, s):\n        \"\"\" Our final theta(s) equation \"\"\"\n        return self.t0 + self.a_list[3]\/4*s**4 + self.a_list[2]\/3*s**3 + self.a_list[1]\/2*s**2 + a_list[0]*s\n\n    def x_trapezoidal(self):\n        \"\"\" Uses the trapezoidal rule to estimate x. \n        x = x0 + (cos(s)+cos(s+interval))*interval\/2\n        We use indeces to access our precomputed cos(s) values\n        spaced out by our interval (hence the index approach)\"\"\"\n        x_list = []\n        # Calculates values up to the second to last index\n        for s_i in range(len(self.t_list)-2):\n            x_s = self.x0 + (1\/2)*(cos(self.t_list[s_i])+cos(self.t_list[s_i+1]))*self.interval\n            x_list.append(x_s)\n        return x_list[]\n\n    def y_trapezoidal(self):\n        \"\"\" Uses the trapezoidal rule to estimate y. \n        y = y0 + (sin(s)+sin(s+interval))*interval\/2\n        We use indeces to access our precomputed sin(s) values\n        spaced out by our interval (hence the index approach)\"\"\"\n        y_list = []\n        # Calculates values up to the second to last index\n        for s_i in range(len(self.t_list)-2):\n            y_s = self.y0 + (1\/2)*(sin(self.t_list[s_i])+sin(self.t_list[s_i+1]))*self.interval\n            y_list.append(y_s)\n        return y_list[]\n\n    def objective_function(self, x):\n        \"\"\" the parameters to optimize are p1, p2, and p4 \"\"\"\n        p1 = x[0]\n        p2 = x[1]\n        p4 = x[2]\n\n        # objective function needs to return a scalar value for scipy.optimize to work - Nicole\n        result = self.f_be(p1, p2, p4) + self.x_soft(p1, p2, p4) + self.y_soft(p1, p2, p4) + self.theta_soft(p1, p2, p4)\n        return result[0]\n\n    def k_s(self, s, p1, p2, p4):\n        \"\"\" Our cubic spiral equation. Not sure if we need this \"\"\"\n        return self.a3_map(p1, p2, p4)*s**3 + self.a2_map(p1, p2, p4)*s**2 + self.a1_map(p1, p2, p4)*s + self.a0_map()\n\n    def f_be_integrand(self, s, a0, a1, a2, a3):\n        \"\"\" Integrand to use with f_be() \n        This is our cubic spiral equation squared \n        integrated for variable 's' from 0 to p4\"\"\"\n        return (a3*s**3 + a2*s**2 + a1*s + a0)**2\n    \n    def f_be(self, p1, p2, p4):\n        \"\"\" Unconstrained objective function, using the quad integral solver\n        from SciPy on our objective_integrand (variable 's') \n        from 0 to curve length p4, using coefficients a0, a1, a2, and a3 \"\"\"\n        spiral_vals = (self.a0_map(), self.a1_map(p1, p2, p4), self.a2_map(p1, p2, p4), self.a3_map(p1, p2, p4))\n        return quad(self.f_be_integrand, 0, p4, args=spiral_vals)\n\n    def x_soft(self, p1, p2, p4):\n        \"\"\" Soft inequality constraints, allows a small\n        margin of error between goal point and final point\n        in the curve. Scaled by alpha. \"\"\"\n        s = p4\n        return self.alpha*(self.x_s(s, p1, p2, p4) - self.xf)\n\n    def y_soft(self, p1, p2, p4):\n        \"\"\" Soft inequality constraints, allows a small\n        margin of error between goal point and final point\n        in the curve. Scaled by beta. \"\"\"\n        s = p4\n        return self.beta*(self.y_s(s, p1, p2, p4) - self.yf)\n\n    def theta_soft(self, p1, p2, p4):\n        \"\"\" Soft inequality constraints, allows a small\n        margin of error between goal point and final point\n        in the curve. Scaled by gamma. \"\"\"\n        s = p4\n        return self.gamma*(self.theta_s(s, p1, p2, p4) - self.tf)\n\n    def x_s(self, s, p1, p2, p4):\n        \"\"\" Estimates x value at location 's' along curve\n        using Simpson's rule (divide domain into n=8 sections) \"\"\"\n        n0 = cos(self.theta_s(0, p1, p2, p4))\n        n1 = 4*cos(self.theta_s(1*s\/8, p1, p2, p4))\n        n2 = 2*cos(self.theta_s(2*s\/8, p1, p2, p4))\n        n3 = 4*cos(self.theta_s(3*s\/8, p1, p2, p4))\n        n4 = 2*cos(self.theta_s(4*s\/8, p1, p2, p4))\n        n5 = 4*cos(self.theta_s(5*s\/8, p1, p2, p4))\n        n6 = 2*cos(self.theta_s(6*s\/8, p1, p2, p4))\n        n7 = 4*cos(self.theta_s(7*s\/8, p1, p2, p4))\n        n8 = cos(self.theta_s(s, p1, p2, p4))\n        n_sum = n0+n1+n2+n3+n4+n5+n6+n7+n8\n        return self.x0 + (s\/24)*(n_sum)\n\n    def y_s(self, s, p1, p2, p4):\n        \"\"\" Estimates y value at location 's' along curve\n        using Simpson's rule (divide domain into n=8 sections) \"\"\"\n        n0 = sin(self.theta_s(0, p1, p2, p4))\n        n1 = 4*sin(self.theta_s(1*s\/8, p1, p2, p4))\n        n2 = 2*sin(self.theta_s(2*s\/8, p1, p2, p4))\n        n3 = 4*sin(self.theta_s(3*s\/8, p1, p2, p4))\n        n4 = 2*sin(self.theta_s(4*s\/8, p1, p2, p4))\n        n5 = 4*sin(self.theta_s(5*s\/8, p1, p2, p4))\n        n6 = 2*sin(self.theta_s(6*s\/8, p1, p2, p4))\n        n7 = 4*sin(self.theta_s(7*s\/8, p1, p2, p4))\n        n8 = sin(self.theta_s(s, p1, p2, p4))\n        n_sum = n0+n1+n2+n3+n4+n5+n6+n7+n8\n        return self.y0 + (s\/24)*(n_sum)\n\n    def theta_s(self, s, p1, p2, p4):\n        \"\"\" Finds theta value at location 's' along curve \"\"\"\n        s4 = self.a3_map(p1, p2, p4) * s**4 \/ 4\n        s3 = self.a2_map(p1, p2, p4) * s**3 \/ 3\n        s2 = self.a1_map(p1, p2, p4) * s**2 \/ 2\n        s1 = self.a0_map() * s\n        return self.t0+s4+s3+s2+s1\n\n    def a0_map(self):\n        \"\"\" Map between optimization params and spiral coefficients. \"\"\"\n        return self.p0\n\n    def a1_map(self, p1, p2, p4):\n        \"\"\" Map between optimization params and spiral coefficients. \"\"\"\n        num = -1*(11*self.p0\/2 - 9*p1 + 9*p2\/2 - self.p3)\n        denom = p4\n        return num\/denom\n\n    def a2_map(self, p1, p2, p4):\n        \"\"\" Map between optimization params and spiral coefficients. \"\"\"\n        num = 9*self.p0 - 45*p1\/2 + 18*p2 - 9*self.p3\/2\n        denom = p4**2\n        return num\/denom\n\n    def a3_map(self, p1, p2, p4):\n        \"\"\" Map between optimization params and spiral coefficients. \"\"\"\n        num = -1*(9*self.p0\/2 - 27*p1\/2 + 27*p2\/2 - 9*self.p3\/2)\n        denom = p4**3\n        return num\/denom\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_96","text":"#\n# (c) FFRI Security, Inc., 2020-2021 \/ Author: FFRI Security, Inc.\n#\n\nfrom enum import Enum\nfrom statistics import mean\nfrom typing import Any, DefaultDict, Dict, List, Optional, Tuple, Union\n\nimport lief\nimport numpy as np\nfrom bs4 import BeautifulSoup\n\nfrom .exceptions import NotSupported\nfrom .feature_extractor import FeatureExtractor\nfrom .utils import (\n    make_defaultdict_from_dict_elem,\n    make_onehot_dict_from_bitflag,\n    make_onehot_from_str_keys,\n    vectorize_selected_features,\n    vectorize_with_feature_hasher,\n    ver_str_to_int,\n)\n\n\nclass DosHeaderFeatureExtractor(FeatureExtractor):\n    feature_name = \"dos_header\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n\nclass RichHeaderFeatureExtractor(FeatureExtractor):\n    feature_name = \"rich_header\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        rich_header = make_defaultdict_from_dict_elem(\n            raw_json, self.feature_name\n        )\n\n        if rich_header[\"entries\"]:\n            # list of (comp.id, count)\n            entries: Optional[List[Tuple[str, int]]] = [\n                (\n                    f'{entry[\"id\"]:04x}{entry[\"build_id\"]:04x}',\n                    entry[\"count\"],\n                )\n                for entry in rich_header[\"entries\"]\n            ]\n        else:\n            entries = None\n\n        return {\n            \"key\": rich_header[\"key\"],\n            \"entries\": entries,\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\"key\", \"entries\"]\n        post_process_funcs = {\n            \"entries\": lambda x: vectorize_with_feature_hasher(x, 50),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass HeaderFeatureExtractor(FeatureExtractor):\n    feature_name = \"header\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def machine_to_onehot(machine: str) -> Dict[str, int]:\n        encoded_data = {\n            \"INVALID\": 0,\n            \"UNKNOWN\": 0,\n            \"AMD64\": 0,\n            \"ARM\": 0,\n            \"ARM64\": 0,\n            \"I386\": 0,\n            \"OTHER\": 0,\n        }\n        if machine in encoded_data.keys():\n            encoded_data[machine] = 1\n        else:\n            encoded_data[\"OTHER\"] = 1\n        return encoded_data\n\n    @staticmethod\n    def characteristics_to_onehot(chracteristics: int) -> Dict[str, int]:\n        return make_onehot_dict_from_bitflag(\n            [\n                \"RELOCS_STRIPPED\",\n                \"EXECUTABLE_IMAGE\",\n                \"LINE_NUMS_STRIPPED\",\n                \"LOCAL_SYMS_STRIPPED\",\n                \"AGGRESSIVE_WS_TRIM\",\n                \"LARGE_ADDRESS_AWARE\",\n                \"BYTES_REVERSED_LO\",\n                \"CHARA_32BIT_MACHINE\",\n                \"DEBUG_STRIPPED\",\n                \"REMOVABLE_RUN_FROM_SWAP\",\n                \"NET_RUN_FROM_SWAP\",\n                \"SYSTEM\",\n                \"DLL\",\n                \"UP_SYSTEM_ONLY\",\n                \"BYTES_REVERSED_HI\",\n            ],\n            chracteristics,\n            lief.PE.HEADER_CHARACTERISTICS,\n        )\n\n    def extract_raw_features(\n        self, raw_json: dict\n    ) -> Dict[str, Union[int, Dict[str, int]]]:\n        header = raw_json[self.feature_name]\n        return {\n            \"signature\": header[\"signature\"],\n            \"machine\": self.machine_to_onehot(header[\"machine\"]),\n            \"numberof_sections\": header[\"numberof_sections\"],\n            \"time_date_stamp\": header[\"time_date_stamp\"],\n            \"numberof_symbols\": header[\"numberof_symbols\"],\n            \"pointerto_symbol_table\": header[\"pointerto_symbol_table\"],\n            \"sizeof_optional_header\": header[\"sizeof_optional_header\"],\n            \"characteristics\": self.characteristics_to_onehot(\n                header[\"characteristics\"]\n            ),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"signature\",\n            \"machine\",\n            \"numberof_sections\",\n            \"time_date_stamp\",\n            \"numberof_symbols\",\n            \"time_date_stamp\",\n            \"numberof_symbols\",\n            \"pointerto_symbol_table\",\n            \"sizeof_optional_header\",\n            \"characteristics\",\n        ]\n        post_process_funcs = {\n            \"machine\": lambda x: list(x.values()),\n            \"characteristics\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\n# NOTE: https:\/\/docs.microsoft.com\/en-us\/windows\/win32\/debug\/pe-format#dll-characteristics\nclass DllCharacteristics(Enum):\n    IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA = 0x0020\n    IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040\n    IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = 0x0080\n    IMAGE_DLLCHARACTERISTICS_NX_COMPAT = 0x0100\n    IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = 0x0200\n    IMAGE_DLLCHARACTERISTICS_NO_SEH = 0x0400\n    IMAGE_DLLCHARACTERISTICS_NO_BIND = 0x0800\n    IMAGE_DLLCHARACTERISTICS_APPCONTAINER = 0x1000\n    IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = 0x2000\n    IMAGE_DLLCHARACTERISTICS_GUARD_CF = 0x4000\n    IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = 0x8000\n\n\nclass OptionalHeaderFeatureExtractor(FeatureExtractor):\n    feature_name = \"optional_header\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def subsystem_to_onehot(subsystem: str) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"UNKNOWN\",\n                \"NATIVE\",\n                \"WINDOWS_GUI\",\n                \"WINDOWS_CUI\",\n                \"OS2_CUI\",\n                \"POSIX_CUI\",\n                \"NATIVE_WINDOWS\",\n                \"WINDOWS_CE_GUI\",\n                \"EFI_APPLICATION\",\n                \"EFI_BOOT_SERVICE_DRIVER\",\n                \"EFI_RUNTIME_DRIVER\",\n                \"EFI_ROM\",\n                \"XBOX\",\n                \"WINDOWS_BOOT_APPLICATION\",\n                \"Out of range\",\n            ],\n            subsystem,\n        )\n\n    @staticmethod\n    def dll_characteristics_to_onehot(\n        dll_characteristics: int,\n    ) -> Dict[str, int]:\n        encoded_data = {\n            str(k): int((dll_characteristics & k.value) != 0)\n            for k in DllCharacteristics\n        }\n        return encoded_data\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        optional_header = make_defaultdict_from_dict_elem(\n            raw_json, self.feature_name\n        )\n        return {\n            \"magic\": int(optional_header[\"magic\"] == \"PE32\"),\n            \"major_linker_version\": optional_header[\"major_linker_version\"],\n            \"minor_linker_version\": optional_header[\"minor_linker_version\"],\n            \"sizeof_code\": optional_header[\"sizeof_code\"],\n            \"sizeof_initialized_data\": optional_header[\n                \"sizeof_initialized_data\"\n            ],\n            \"sizeof_uninitialized_data\": optional_header[\n                \"sizeof_uninitialized_data\"\n            ],\n            \"addressof_entrypoint\": optional_header[\"addressof_entrypoint\"],\n            \"baseof_code\": optional_header[\"baseof_code\"],\n            \"baseof_data\": optional_header[\"baseof_data\"],\n            \"imagebase\": optional_header[\"imagebase\"],\n            \"section_alignment\": optional_header[\"section_alignment\"],\n            \"file_alignment\": optional_header[\"file_alignment\"],\n            \"major_operating_system_version\": optional_header[\n                \"major_operating_system_version\"\n            ],\n            \"minor_operating_system_version\": optional_header[\n                \"minor_operating_system_version\"\n            ],\n            \"major_image_version\": optional_header[\"major_image_version\"],\n            \"minor_image_version\": optional_header[\"minor_image_version\"],\n            \"major_subsystem_version\": optional_header[\n                \"major_subsystem_version\"\n            ],\n            \"minor_subsystem_version\": optional_header[\n                \"minor_subsystem_version\"\n            ],\n            \"win32_version_value\": optional_header[\"win32_version_value\"],\n            \"sizeof_image\": optional_header[\"sizeof_image\"],\n            \"sizeof_headers\": optional_header[\"sizeof_headers\"],\n            \"checksum\": optional_header[\"checksum\"],\n            \"sizeof_stack_reserve\": optional_header[\"sizeof_stack_reserve\"],\n            \"sizeof_stack_commit\": optional_header[\"sizeof_stack_commit\"],\n            \"sizeof_heap_reserve\": optional_header[\"sizeof_heap_reserve\"],\n            \"sizeof_heap_commit\": optional_header[\"sizeof_heap_commit\"],\n            \"loader_flags\": optional_header[\"loader_flags\"],\n            \"numberof_rva_and_size\": optional_header[\"numberof_rva_and_size\"],\n            \"subsystem\": self.subsystem_to_onehot(optional_header[\"subsystem\"]),\n            \"dll_characteristics\": self.dll_characteristics_to_onehot(\n                optional_header[\"dll_characteristics\"]\n            ),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"major_linker_version\",\n            \"minor_linker_version\",\n            \"sizeof_code\",\n            \"sizeof_initialized_data\",\n            \"sizeof_uninitialized_data\",\n            \"addressof_entrypoint\",\n            \"baseof_code\",\n            \"baseof_data\",\n            \"imagebase\",\n            \"section_alignment\",\n            \"file_alignment\",\n            \"major_operating_system_version\",\n            \"minor_operating_system_version\",\n            \"major_image_version\",\n            \"minor_image_version\",\n            \"major_subsystem_version\",\n            \"minor_subsystem_version\",\n            \"win32_version_value\",\n            \"sizeof_image\",\n            \"sizeof_headers\",\n            \"checksum\",\n            \"sizeof_stack_reserve\",\n            \"sizeof_stack_commit\",\n            \"sizeof_heap_reserve\",\n            \"sizeof_heap_commit\",\n            \"loader_flags\",\n            \"numberof_rva_and_size\",\n            \"subsystem\",\n            \"dll_characteristics\",\n        ]\n        post_process_funcs = {\n            \"subsystem\": lambda x: list(x.values()),\n            \"dll_characteristics\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass DataDirectoriesFeatureExtractor(FeatureExtractor):\n    feature_name = \"data_directories\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def pair_with_section_type(\n        data_directories: Optional[List[dict]], record_name: str\n    ) -> Optional[List[Tuple[str, int]]]:\n        if data_directories:\n            return [\n                (data_directory[\"type\"], data_directory[record_name])\n                for data_directory in data_directories\n            ]\n        else:\n            return None\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        data_directories = (\n            raw_json[self.feature_name]\n            if self.feature_name in raw_json.keys()\n            else None\n        )\n        if data_directories:\n            section: Optional[List[Optional[str]]] = [\n                data_directory[\"section\"]\n                if \"section\" in data_directory.keys()\n                else None\n                for data_directory in data_directories\n            ]\n        else:\n            section = None\n\n        return {\n            \"RVA\": self.pair_with_section_type(data_directories, \"RVA\"),\n            \"size\": self.pair_with_section_type(data_directories, \"size\"),\n            \"section\": section,\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\"RVA\", \"size\", \"section\"]\n        post_process_funcs = {\n            \"RVA\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"size\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"section\": lambda x: vectorize_with_feature_hasher(\n                list(filter(lambda y: y is not None, x)) if x else None, 20\n            ),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass SectionsFeatureExtractor(FeatureExtractor):\n    feature_name = \"sections\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def pair_with_section_name(\n        sections: Optional[List[dict]], record_name: str\n    ) -> Optional[List[Tuple[str, int]]]:\n        if sections:\n            return [\n                (section[\"name\"], section[record_name]) for section in sections\n            ]\n        else:\n            return None\n\n    # TODO: Reconsider the way to vectorize section characteristics\n    @staticmethod\n    def vectorize_characteristics(\n        sections: Optional[List[dict]],\n    ) -> Dict[str, int]:\n        encoded_data = {\n            \"TYPE_NO_PAD\": 0,\n            \"CNT_CODE\": 0,\n            \"CNT_INITIALIZED_DATA\": 0,\n            \"CNT_UNINITIALIZED_DATA\": 0,\n            \"LNK_OTHER\": 0,\n            \"LNK_INFO\": 0,\n            \"LNK_REMOVE\": 0,\n            \"LNK_COMDAT\": 0,\n            \"GPREL\": 0,\n            \"MEM_PURGEABLE\": 0,\n            \"MEM_16BIT\": 0,\n            \"MEM_LOCKED\": 0,\n            \"MEM_PRELOAD\": 0,\n            \"ALIGN_1BYTES\": 0,\n            \"ALIGN_2BYTES\": 0,\n            \"ALIGN_4BYTES\": 0,\n            \"ALIGN_8BYTES\": 0,\n            \"ALIGN_16BYTES\": 0,\n            \"ALIGN_32BYTES\": 0,\n            \"ALIGN_64BYTES\": 0,\n            \"ALIGN_128BYTES\": 0,\n            \"ALIGN_256BYTES\": 0,\n            \"ALIGN_512BYTES\": 0,\n            \"ALIGN_1024BYTES\": 0,\n            \"ALIGN_2048BYTES\": 0,\n            \"ALIGN_4096BYTES\": 0,\n            \"ALIGN_8192BYTES\": 0,\n            \"LNK_NRELOC_OVFL\": 0,\n            \"MEM_DISCARDABLE\": 0,\n            \"MEM_NOT_CACHED\": 0,\n            \"MEM_NOT_PAGED\": 0,\n            \"MEM_SHARED\": 0,\n            \"MEM_EXECUTE\": 0,\n            \"MEM_READ\": 0,\n            \"MEM_WRITE\": 0,\n        }\n        if sections:\n            for section in sections:\n                for characteristic in section[\"characteristics\"]:\n                    encoded_data[characteristic] += 1\n        return encoded_data\n\n    # TODO: Reconsider the way to vectorize section types\n    @staticmethod\n    def vectorize_types(sections: Optional[List[dict]]) -> Dict[str, int]:\n        encoded_data = {\n            \"TEXT\": 0,\n            \"TLS_\": 0,\n            \"IDATA\": 0,\n            \"DATA\": 0,\n            \"BSS\": 0,\n            \"RESOURCE\": 0,\n            \"RELOCATION\": 0,\n            \"EXPORT\": 0,\n            \"DEBUG\": 0,\n            \"UNKNOWN\": 0,\n            \"Out of range\": 0,\n        }\n        if sections:\n            for section in sections:\n                for type_ in section[\"types\"]:\n                    encoded_data[type_] += 1\n        return encoded_data\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        sections = (\n            raw_json[self.feature_name]\n            if self.feature_name in raw_json.keys()\n            else None\n        )\n        return {\n            \"pointerto_relocation\": self.pair_with_section_name(\n                sections, \"pointerto_relocation\"\n            ),\n            \"pointerto_line_numbers\": self.pair_with_section_name(\n                sections, \"pointerto_line_numbers\"\n            ),\n            \"numberof_relocations\": self.pair_with_section_name(\n                sections, \"numberof_relocations\"\n            ),\n            \"numberof_line_numbers\": self.pair_with_section_name(\n                sections, \"numberof_line_numbers\"\n            ),\n            \"entropy\": self.pair_with_section_name(sections, \"entropy\"),\n            \"characteristics\": self.vectorize_characteristics(sections),\n            \"types\": self.vectorize_types(sections),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"pointerto_relocation\",\n            \"pointerto_line_numbers\",\n            \"numberof_relocations\",\n            \"numberof_line_numbers\",\n            \"characteristics\",\n            \"entropy\",\n            \"types\",\n        ]\n        post_process_funcs = {\n            \"pointerto_relocation\": lambda x: vectorize_with_feature_hasher(\n                x, 50\n            ),\n            \"pointerto_line_numbers\": lambda x: vectorize_with_feature_hasher(\n                x, 50\n            ),\n            \"numberof_relocations\": lambda x: vectorize_with_feature_hasher(\n                x, 50\n            ),\n            \"numberof_line_numbers\": lambda x: vectorize_with_feature_hasher(\n                x, 50\n            ),\n            \"entropy\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"characteristics\": lambda x: list(x.values()),\n            \"types\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass RelocationsFeatureExtractor(FeatureExtractor):\n    feature_name = \"relocations\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def flatten_relocation_entries(\n        relocations: Optional[List[dict]],\n    ) -> List[Tuple[int, str]]:\n        flattened_entries = list()\n        if relocations:\n            for relocation in relocations:\n                virtual_address = relocation[\"virtual_address\"]\n                for entry in relocation[\"entries\"]:\n                    flattened_entries.append(\n                        ((virtual_address + entry[\"position\"], entry[\"type\"]))\n                    )\n        return flattened_entries\n\n    def count_relocation_types(\n        self, flattend_entries: Optional[List[Tuple[int, str]]]\n    ) -> List[int]:\n        buckets = {\n            \"ABSOLUTE\": 0,\n            \"HIGH\": 0,\n            \"LOW\": 0,\n            \"HIGHLOW\": 0,\n            \"HIGHADJ\": 0,\n            \"MIPS_JMPADDR | ARM_MOV32A | ARM_MOV32 | RISCV_HI20\": 0,\n            \"SECTION\": 0,\n            \"REL | ARM_MOV32T | THUMB_MOV32 | RISCV_LOW12I\": 0,\n            \"RISCV_LOW12S\": 0,\n            \"DIR64\": 0,\n            \"HIGH3ADJ\": 0,\n            \"Out of range\": 0,\n            \"MIPS_JMPADDR16 | IA64_IMM64\": 0,\n        }\n        # NOTE: https:\/\/github.com\/lief-project\/LIEF\/commit\/38f48a6e12f6cd46a657a4f354686333e8df4140\n        if self.ver == 2020:\n            buckets.pop(\"MIPS_JMPADDR16 | IA64_IMM64\")\n            buckets[\"MIPS_JMPADDR16 | IA64_DIR64\"] = 0\n\n        if flattend_entries:\n            for _, type_ in flattend_entries:\n                buckets[type_] += 1\n        return list(buckets.values())\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        relocations = (\n            raw_json[self.feature_name]\n            if self.feature_name in raw_json.keys()\n            else None\n        )\n        return {\n            \"flattened_entries\": self.flatten_relocation_entries(relocations)\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\"flattened_entries\"]\n        post_process_funcs = {\n            \"flattened_entries\": lambda x: self.count_relocation_types(x),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass TlsFeatureExtractor(FeatureExtractor):\n    feature_name = \"tls\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def characteristics_to_onehot(\n        characteristics: Optional[int],\n    ) -> Dict[str, int]:\n        if characteristics:\n            characteristics_str: Optional[str] = str(\n                lief.PE.SECTION_CHARACTERISTICS(characteristics & 0xF00000)\n            )\n            has_extra_bits = int((characteristics & 0xFF0FFFFF) != 0)\n        else:\n            characteristics_str = None\n            has_extra_bits = 0\n        encoded_data = make_onehot_from_str_keys(\n            [\n                \"SECTION_CHARACTERISTICS.ALIGN_1BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_2BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_4BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_8BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_16BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_32BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_64BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_128BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_256BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_512BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_1024BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_2048BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_4096BYTES\",\n                \"SECTION_CHARACTERISTICS.ALIGN_8192BYTES\",\n                \"SECTION_CHARACTERISTICS.???\",\n            ],\n            characteristics_str,\n        )\n        encoded_data[\"has_extra_bits\"] = has_extra_bits\n        return encoded_data\n\n    @staticmethod\n    def data_directory_to_onehot(\n        data_directory: Optional[str],\n    ) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"EXPORT_TABLE\",\n                \"IMPORT_TABLE\",\n                \"RESOURCE_TABLE\",\n                \"EXCEPTION_TABLE\",\n                \"CERTIFICATE_TABLE\",\n                \"BASE_RELOCATION_TABLE\",\n                \"DEBUG\",\n                \"ARCHITECTURE\",\n                \"GLOBAL_PTR\",\n                \"TLS_TABLE\",\n                \"LOAD_CONFIG_TABLE\",\n                \"BOUND_IMPORT\",\n                \"IAT\",\n                \"DELAY_IMPORT_DESCRIPTOR\",\n                \"CLR_RUNTIME_HEADER\",\n            ],\n            data_directory,\n        )\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        tls = make_defaultdict_from_dict_elem(raw_json, self.feature_name)\n        return {\n            \"callbacks\": int(\n                bool(tls[\"callbacks\"])\n            ),  # NOTE: Tls callback functions exists or not\n            \"addressof_raw_data\": int(bool(tls[\"addressof_raw_data\"])),\n            \"addressof_index\": tls[\"addressof_index\"],\n            \"addressof_callbacks\": tls[\"addressof_callbacks\"],\n            \"sizoeof_zero_fill\": tls[\"sizeof_zero_fill\"],\n            \"characteristics\": self.characteristics_to_onehot(\n                tls[\"characteristics\"]\n            ),\n            \"data_directory\": self.data_directory_to_onehot(\n                tls[\"data_directory\"]\n            ),\n            \"section\": tls[\"section\"],\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"callbacks\",\n            \"addressof_raw_data\",\n            \"addressof_index\",\n            \"addressof_callbacks\",\n            \"sizoeof_zero_fill\",\n            \"characteristics\",\n            \"data_directory\",\n        ]\n        post_process_funcs = {\n            \"characteristics\": lambda x: list(x.values()),\n            \"data_directory\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass ExportFeatureExtractor(FeatureExtractor):\n    feature_name = \"export\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def make_export_apis(\n        entries: Optional[List[dict]], name: Optional[str]\n    ) -> Optional[List[str]]:\n        if entries is None or name is None:\n            return None\n        export_apis: List[str] = list()\n        for entry in entries:\n            if \"forward_information\" in entry.keys():\n                api_name = \"{}:{}\".format(\n                    entry[\"forward_information\"][\"library\"],\n                    entry[\"forward_information\"][\"function\"],\n                )\n            else:\n                api_name = \"{}:{}\".format(name, entry[\"name\"])\n            export_apis.append(api_name)\n        return export_apis\n\n    @staticmethod\n    def pair_with_export_api(\n        entries: Optional[List[dict]],\n        export_apis: Optional[List[str]],\n        record_name: str,\n    ) -> Optional[List[Tuple[str, int]]]:\n        if export_apis is not None and entries is not None:\n            return [\n                (export_api, entry[record_name])\n                for export_api, entry in zip(export_apis, entries)\n            ]\n        else:\n            return None\n\n    def extract_raw_features_from_entries(\n        self, entries: Optional[List[dict]], export_apis: Optional[List[str]]\n    ) -> dict:\n        prefix = \"entries\"\n        return {\n            f\"{prefix}_ordinal\": self.pair_with_export_api(\n                entries, export_apis, \"ordinal\"\n            ),\n            f\"{prefix}_address\": self.pair_with_export_api(\n                entries, export_apis, \"address\"\n            ),\n            f\"{prefix}_is_extern\": self.pair_with_export_api(\n                entries, export_apis, \"is_extern\"\n            ),\n        }\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        export = make_defaultdict_from_dict_elem(raw_json, self.feature_name)\n        entries = export[\"entries\"]\n        export_apis = self.make_export_apis(entries, export[\"name\"])\n        return {\n            \"export_flags\": export[\"export_flags\"],\n            \"timestamp\": export[\"timestamp\"],\n            \"major_version\": export[\"major_version\"],\n            \"minor_version\": export[\"minor_version\"],\n            \"ordinal_base\": export[\"ordinal_base\"],\n            \"name\": export[\"name\"],\n            **self.extract_raw_features_from_entries(entries, export_apis),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        selected_features = [\n            \"export_flags\",\n            \"timestamp\",\n            \"major_version\",\n            \"minor_version\",\n            \"ordinal_base\",\n            \"entries_ordinal\",\n            \"entries_address\",\n            \"entries_is_extern\",\n        ]\n        post_process_funcs = {\n            \"entries_ordinal\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"entries_address\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"entries_is_extern\": lambda x: vectorize_with_feature_hasher(x, 50),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            selected_features,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass DebugFeatureExtractor(FeatureExtractor):\n    feature_name = \"debug\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    # TODO: vectorize debug feature\n    # def extract_raw_features(self, raw_json: dict) -> dict:\n    #     debug = _make_defaultdict_from_dict(raw_json, self.feature_name)\n    #     raw_features = dict()\n    #     return raw_features\n\n\nclass ImportsFeatureExtractor(FeatureExtractor):\n    feature_name = \"imports\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def pair_with_import_dlls(\n        imports: Optional[List[dict]], record_name: str\n    ) -> Optional[List[Tuple[str, int]]]:\n        if imports:\n            return [\n                (import_[\"name\"], import_[record_name]) for import_ in imports\n            ]\n        else:\n            return None\n\n    @staticmethod\n    def pair_with_import_apis(\n        imports: Optional[List[dict]], record_name: str\n    ) -> Optional[List[Tuple[str, int]]]:\n        if imports is None:\n            return None\n        result: List[Tuple[str, int]] = list()\n        for import_ in imports:\n            dll_name = import_[\"name\"]\n            for entry in import_[\"entries\"]:\n                result.append(\n                    (\n                        f\"{dll_name}:{ImportsFeatureExtractor.get_api_name(entry)}\",\n                        entry[record_name],\n                    )\n                )\n        return result\n\n    @staticmethod\n    def get_api_name(entry: dict) -> str:\n        if \"name\" in entry.keys():\n            return entry[\"name\"]\n        else:\n            return f'ord{entry[\"ordinal\"]}'\n\n    @staticmethod\n    def flatten_api_entries(\n        imports: Optional[List[dict]],\n    ) -> Optional[List[str]]:\n        if imports is None:\n            return None\n        return [\n            f'{import_[\"name\"]}:{ImportsFeatureExtractor.get_api_name(entry)}'\n            for import_ in imports\n            for entry in import_[\"entries\"]\n        ]\n\n    @staticmethod\n    def flatten_dll_entries(\n        imports: Optional[List[dict]],\n    ) -> Optional[List[str]]:\n        if imports is None:\n            return None\n        return [import_[\"name\"] for import_ in imports]\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        imports = (\n            raw_json[self.feature_name]\n            if self.feature_name in raw_json.keys()\n            else None\n        )\n        return {\n            \"dll_names\": self.flatten_dll_entries(imports),\n            \"api_names\": self.flatten_api_entries(imports),\n            \"forwarder_chain\": self.pair_with_import_dlls(\n                imports, \"forwarder_chain\"\n            ),\n            \"timedatestamp\": self.pair_with_import_dlls(\n                imports, \"timedatestamp\"\n            ),\n            \"import_address_table_rva\": self.pair_with_import_dlls(\n                imports, \"import_address_table_rva\"\n            ),\n            \"iat_address\": self.pair_with_import_apis(imports, \"iat_address\"),\n            \"data\": self.pair_with_import_apis(imports, \"data\"),\n            \"hint\": self.pair_with_import_apis(imports, \"hint\"),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"dll_names\",\n            \"api_names\",\n            \"forwarder_chain\",\n            \"timedatestamp\",\n            \"import_address_table_rva\",\n            \"iat_address\",\n            \"data\",\n            \"hint\",\n        ]\n        post_process_funcs = {\n            \"dll_names\": lambda x: vectorize_with_feature_hasher(x, 100),\n            \"api_names\": lambda x: vectorize_with_feature_hasher(x, 500),\n            \"forwarder_chain\": lambda x: vectorize_with_feature_hasher(x, 100),\n            \"timedatestamp\": lambda x: vectorize_with_feature_hasher(x, 100),\n            \"import_address_table_rva\": lambda x: vectorize_with_feature_hasher(\n                x, 100\n            ),\n            \"iat_address\": lambda x: vectorize_with_feature_hasher(x, 100),\n            \"data\": lambda x: vectorize_with_feature_hasher(x, 100),\n            \"hint\": lambda x: vectorize_with_feature_hasher(x, 100),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\n# NOTE: In LIEF 0.11 or later, dict structure of resources_tree is different from 0.10.1 one.\n# TODO: When updating LIEF version 0.10.1 to 0.11, the extract_raw_features should be modified.\nclass ResourcesTreeFeatureExtractor(FeatureExtractor):\n    feature_name = \"resources_tree\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        resources_tree = make_defaultdict_from_dict_elem(\n            raw_json, self.feature_name\n        )\n        return {\n            \"characteristics\": resources_tree[\"characteristics\"],\n            \"major_version\": resources_tree[\"major_version\"],\n            \"minor_version\": resources_tree[\"minor_version\"],\n            \"numberof_id_entries\": resources_tree[\"numberof_id_entries\"],\n            \"numberof_name_entries\": resources_tree[\"numberof_name_entries\"],\n            \"time_date_stamp\": resources_tree[\"time_date_stamp\"],\n        }\n\n\nclass ResourcesManagerFeatureExtractor(FeatureExtractor):\n    feature_name = \"resources_manager\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def fixed_version_file_flags_to_onehot(\n        file_flags: Optional[int],\n    ) -> Dict[str, int]:\n        return make_onehot_dict_from_bitflag(\n            [\n                \"DEBUG\",\n                \"INFOINFERRED\",\n                \"PATCHED\",\n                \"PRERELEASE\",\n                \"PRIVATEBUILD\",\n                \"SPECIALBUILD\",\n            ],\n            file_flags,\n            lief.PE.FIXED_VERSION_FILE_FLAGS,\n        )\n\n    @staticmethod\n    def fixed_version_os_to_onehot(version_os: Optional[str]) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"DOS\",\n                \"DOS_WINDOWS16\",\n                \"DOS_WINDOWS32\",\n                \"NT\",\n                \"NT_WINDOWS32\",\n                \"OS216\",\n                \"OS216_PM16\",\n                \"OS232\",\n                \"OS232_PM32\",\n                \"PM16\",\n                \"PM32\",\n                \"UNKNOWN\",\n                \"WINDOWS16\",\n                \"WINDOWS32\",\n                \"Out of range\",\n            ],\n            version_os,\n        )\n\n    @staticmethod\n    def fixed_version_file_type_to_onehot(\n        file_type: Optional[str],\n    ) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"APP\",\n                \"DLL\",\n                \"DRV\",\n                \"FONT\",\n                \"STATIC_LIB\",\n                \"VXD\",\n                \"UNKNOWN\",\n                \"Out of range\",\n            ],\n            file_type,\n        )\n\n    @staticmethod\n    def fixed_version_file_subtype_to_onehot(\n        file_subtype: Optional[str],\n    ) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"DRV_COMM\",\n                \"DRV_DISPLAY\",\n                \"DRV_INSTALLABLE\",\n                \"DRV_KEYBOARD\",\n                \"DRV_LANGUAGE\",\n                \"DRV_MOUSE\",\n                \"DRV_NETWORK\",\n                \"DRV_PRINTER\",\n                \"DRV_SOUND\",\n                \"DRV_SYSTEM\",\n                \"DRV_VERSIONED_PRINTER\",\n                \"UNKNOWN\",\n                \"Out of range\",\n            ],\n            file_subtype,\n        )\n\n    @staticmethod\n    def extract_raw_features_from_html(html: List[str]) -> dict:\n        prefix = \"html\"\n\n        def is_html(e: str) -> bool:\n            try:\n                return bool(BeautifulSoup(e, \"html.parser\").find())\n            except Exception:\n                return False\n\n        number_of_non_htmls = sum(is_html(e) for e in html)\n        return {\n            f\"{prefix}_avg_len\": mean(len(e) for e in html) if html else 0,\n            f\"{prefix}_number_of_non_htmls\": number_of_non_htmls if html else 0,\n        }\n\n    @staticmethod\n    def extract_raw_features_from_version(\n        version: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"version\"\n        return {\n            f\"{prefix}_type\": version[\"type\"],\n            # NOTE: should be VS_VERSION_INFO, but other strings might come\n            f\"{prefix}_key\": int(version[\"key\"] == \"VS_VERSION_INFO\"),\n        }\n\n    def extract_raw_features_from_fixed_file_info(\n        self, fixed_file_info: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"version\"\n        cprefix = \"fixed_file_info\"\n        return {\n            f\"{prefix}_{cprefix}_signature\": fixed_file_info[\"signature\"],\n            f\"{prefix}_{cprefix}_struct_version\": fixed_file_info[\n                \"struct_version\"\n            ],\n            f\"{prefix}_{cprefix}_file_version_MS\": fixed_file_info[\n                \"file_version_MS\"\n            ],\n            f\"{prefix}_{cprefix}_file_version_LS\": fixed_file_info[\n                \"file_version_LS\"\n            ],\n            f\"{prefix}_{cprefix}_file_flags_mask\": self.fixed_version_file_flags_to_onehot(\n                fixed_file_info[\"file_flags_mask\"]\n            ),\n            f\"{prefix}_{cprefix}_file_flags\": self.fixed_version_file_flags_to_onehot(\n                fixed_file_info[\"file_flags\"]\n            ),\n            f\"{prefix}_{cprefix}_file_os\": self.fixed_version_os_to_onehot(\n                fixed_file_info[\"file_os\"]\n            ),\n            f\"{prefix}_{cprefix}_file_type\": self.fixed_version_file_type_to_onehot(\n                fixed_file_info[\"file_type\"]\n            ),\n            f\"{prefix}_{cprefix}_file_subtype\": self.fixed_version_file_subtype_to_onehot(\n                fixed_file_info[\"file_subtype\"]\n            ),\n            f\"{prefix}_{cprefix}_file_date_MS\": fixed_file_info[\"file_date_MS\"],\n            f\"{prefix}_{cprefix}_file_date_LS\": fixed_file_info[\"file_date_LS\"],\n        }\n\n    def extract_raw_features_from_string_file_info(\n        self, string_file_info: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"version\"\n        cprefix = \"string_file_info\"\n        # TODO: convert langcode_items array to feature vector\n        # langcode_items = _make_defaultdict_from_dict(string_file_info, \"lang_code_item\")\n\n        return {\n            f\"{prefix}_{cprefix}_type\": string_file_info[\"type\"],\n            f\"{prefix}_{cprefix}_key\": int(\n                string_file_info[\"key\"] == \"StringFileInfo\"\n            ),\n        }\n\n    def extract_raw_features_from_var_file_info(\n        self, var_file_info: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"version\"\n        cprefix = \"var_file_info\"\n\n        return {\n            f\"{prefix}_{cprefix}_type\": var_file_info[\"type\"],\n            f\"{prefix}_{cprefix}_key\": int(\n                var_file_info[\"key\"] == \"VarFileInfo\"\n            ),\n            # f\"{prefix}_{cprefix}_translations\": self.translations_to_featurevector(var_file_info[\"translations\"])\n        }\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        resources_manager = make_defaultdict_from_dict_elem(\n            raw_json, self.feature_name\n        )\n        version = make_defaultdict_from_dict_elem(resources_manager, \"version\")\n        raw_features = {\n            # NOTE: extracted but not converted to feature vector\n            # TODO: should parse manifest XML file\n            \"manifest\": resources_manager[\"manifest\"],\n            **self.extract_raw_features_from_version(version),\n            **self.extract_raw_features_from_fixed_file_info(\n                make_defaultdict_from_dict_elem(version, \"fixed_file_info\")\n            ),\n            **self.extract_raw_features_from_string_file_info(\n                make_defaultdict_from_dict_elem(version, \"string_file_info\")\n            ),\n            **self.extract_raw_features_from_var_file_info(\n                make_defaultdict_from_dict_elem(version, \"var_file_info\")\n            ),\n        }\n        if self.ver >= 2021:\n            raw_features.update(\n                self.extract_raw_features_from_html(\n                    resources_manager[\"html\"]\n                    if \"html\" in resources_manager.keys()\n                    else []\n                )\n            )\n            raw_features[\"has_string_table\"] = (\n                \"string_table\" in resources_manager.keys()\n            )\n            raw_features[\"has_icons\"] = \"icons\" in resources_manager.keys()\n            raw_features[\"has_dialogs\"] = \"dialogs\" in resources_manager.keys()\n            raw_features[\"has_accelerator\"] = (\n                \"accelerator\" in resources_manager.keys()\n            )\n        return raw_features\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"version_type\",\n            \"version_key\",\n            \"version_fixed_file_info_signature\",\n            \"version_fixed_file_info_struct_version\",\n            \"version_fixed_file_info_file_version_MS\",\n            \"version_fixed_file_info_file_version_LS\",\n            \"version_fixed_file_info_file_flags_mask\",\n            \"version_fixed_file_info_file_flags\",\n            \"version_fixed_file_info_file_os\",\n            \"version_fixed_file_info_file_type\",\n            \"version_fixed_file_info_file_subtype\",\n            \"version_fixed_file_info_file_date_MS\",\n            \"version_fixed_file_info_file_date_LS\",\n            \"version_string_file_info_type\",\n            \"version_string_file_info_key\",\n            \"version_var_file_info_type\",\n            \"version_var_file_info_key\",\n        ]\n        if self.ver >= 2021:\n            features_selected.append(\"html_avg_len\")\n            features_selected.append(\"html_number_of_non_htmls\")\n            features_selected.append(\"has_string_table\")\n            features_selected.append(\"has_icons\")\n            features_selected.append(\"has_dialogs\")\n            features_selected.append(\"has_accelerator\")\n        post_process_funcs = {\n            \"version_fixed_file_info_file_flags_mask\": lambda x: list(\n                x.values()\n            ),\n            \"version_fixed_file_info_file_flags\": lambda x: list(x.values()),\n            \"version_fixed_file_info_file_os\": lambda x: list(x.values()),\n            \"version_fixed_file_info_file_type\": lambda x: list(x.values()),\n            \"version_fixed_file_info_file_subtype\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass SignatureFeatureExtractor(FeatureExtractor):\n    feature_name = \"signature\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n        if self.ver >= 2021:\n            self.feature_name = \"signatures\"\n\n    # TODO: should be implemented\n    # @staticmethod\n    # def crts_to_feature_vector(crts):\n    #     pass\n\n    def extract_raw_features_from_content_info(\n        self, content_info: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"content_info\"\n        return {\n            f\"{prefix}_content_type\": content_info[\"content_type\"],\n            f\"{prefix}_digest_algorithm\": content_info[\"digest_algorithm\"],\n            f\"{prefix}_type\": content_info[\"type\"],\n        }\n\n    def extract_raw_features_from_signer_info(\n        self, signer_info: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"signer_info\"\n        return {\n            f\"{prefix}_version\": signer_info[\"version\"],\n            f\"{prefix}_digest_algorithm\": signer_info[\"digest_algorithm\"],\n            f\"{prefix}_signature_algorithm\": signer_info[\"signature_algorithm\"],\n        }\n\n    def extract_raw_features_from_authenticated_attributres(\n        self, authenticated_attributes: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"signer_info\"\n        cprefix = \"authenticated_attributes\"\n        return {\n            f\"{prefix}_{cprefix}_content_type\": authenticated_attributes[\n                \"content_type\"\n            ],\n            f\"{prefix}_{cprefix}_program_name\": authenticated_attributes[\n                \"program_name\"\n            ],\n            f\"{prefix}_{cprefix}_url\": authenticated_attributes[\"url\"],\n            f\"{prefix}_{cprefix}_message_digest\": authenticated_attributes[\n                \"message_digest\"\n            ],\n        }\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        if self.ver == 2020:\n            signature = make_defaultdict_from_dict_elem(\n                raw_json, self.feature_name\n            )\n            signer_info = make_defaultdict_from_dict_elem(\n                signature, \"signer_info\"\n            )\n            return {\n                \"version\": signature[\"version\"],\n                # NOTE: extracted but not converted to feature vector\n                **self.extract_raw_features_from_content_info(\n                    make_defaultdict_from_dict_elem(signature, \"content_info\")\n                ),\n                # NOTE: extracted but not converted to feature vector\n                **self.extract_raw_features_from_signer_info(signer_info),\n                # NOTE: extracted but not converted to feature vector\n                **self.extract_raw_features_from_authenticated_attributres(\n                    make_defaultdict_from_dict_elem(\n                        signer_info, \"authenticated_attributes\"\n                    )\n                ),\n                # NOTE: extracted but not converted to feature vector\n                \"signer_info_issuer\": signer_info[\"issuer\"],\n                # TODO: make feature vector from certificates array\n                \"certificates\": signature[\"certificates\"],\n            }\n        elif self.ver == 2021:\n            # TODO: extract other properties contained in raw_json[\"signatures\"]\n            return {\n                \"number_of_signatures\": len(raw_json[\"signatures\"])\n                if \"signatures\" in raw_json.keys()\n                else 0\n            }\n        else:\n            raise NotSupported(self.ver, self.__class__.__name__)\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        if self.ver == 2020:\n            features_selected = [\"version\"]\n            return vectorize_selected_features(\n                raw_features, features_selected, {}, self.feature_name\n            )\n        elif self.ver == 2021:\n            features_selected = [\"number_of_signatures\"]\n            return vectorize_selected_features(\n                raw_features, features_selected, {}, self.feature_name\n            )\n        else:\n            raise NotSupported(self.ver, self.__class__.__name__)\n\n\nclass SymbolsFeatureExtractor(FeatureExtractor):\n    feature_name = \"symbols\"\n\n    @staticmethod\n    def make_base_type_hist() -> Dict[str, int]:\n        return {\n            \"NULL\": 0,\n            \"VOID\": 0,\n            \"CHAR\": 0,\n            \"SHORT\": 0,\n            \"INT\": 0,\n            \"LONG\": 0,\n            \"FLOAT\": 0,\n            \"DOUBLE\": 0,\n            \"STRUCT\": 0,\n            \"UNION\": 0,\n            \"ENUM\": 0,\n            \"MOE\": 0,\n            \"BYTE\": 0,\n            \"WORD\": 0,\n            \"UINT\": 0,\n            \"DWORD\": 0,\n            \"Out of range\": 0,\n        }\n\n    @staticmethod\n    def make_complex_type_hist() -> Dict[str, int]:\n        return {\n            \"NULL\": 0,\n            \"POINTER\": 0,\n            \"FUNCTION\": 0,\n            \"ARRAY\": 0,\n            \"COMPLEX_TYPE_SHIFT\": 0,\n            \"Out of range\": 0,\n        }\n\n    @staticmethod\n    def make_storage_class_hist() -> Dict[str, int]:\n        return {\n            \"END_OF_FUNCTION\": 0,\n            \"NULL\": 0,\n            \"AUTOMATIC\": 0,\n            \"EXTERNAL\": 0,\n            \"STATIC\": 0,\n            \"REGISTER\": 0,\n            \"EXTERNAL_DEF\": 0,\n            \"LABEL\": 0,\n            \"UNDEFINED_LABEL\": 0,\n            \"MEMBER_OF_STRUCT\": 0,\n            \"UNION_TAG\": 0,\n            \"TYPE_DEFINITION\": 0,\n            \"UDEFINED_STATIC\": 0,\n            \"ENUM_TAG\": 0,\n            \"MEMBER_OF_ENUM\": 0,\n            \"REGISTER_PARAM\": 0,\n            \"BIT_FIELD\": 0,\n            \"BLOCK\": 0,\n            \"FUNCTION\": 0,\n            \"END_OF_STRUCT\": 0,\n            \"FILE\": 0,\n            \"SECTION\": 0,\n            \"WEAK_EXTERNAL\": 0,\n            \"CLR_TOKEN\": 0,\n            \"Out of range\": 0,\n        }\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        if self.ver == 2020:\n            raise NotSupported(self.ver, self.__class__.__name__)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def pair_with_symbol_name(\n        symbols: List[dict], record_name: str\n    ) -> List[Tuple[str, int]]:\n        return [(symbol[\"name\"], symbol[record_name]) for symbol in symbols]\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        if self.feature_name in raw_json.keys():\n            symbols = raw_json[self.feature_name]\n        else:\n            symbols = list()\n\n        base_type_hist = self.make_base_type_hist()\n        complex_type_hist = self.make_complex_type_hist()\n        storage_class_hist = self.make_storage_class_hist()\n\n        for symbol in symbols:\n            base_type_hist[symbol[\"base_type\"]] += 1\n            complex_type_hist[symbol[\"complex_type\"]] += 1\n            storage_class_hist[symbol[\"storage_class\"]] += 1\n\n        return {\n            \"base_type\": base_type_hist,\n            \"complex_type\": complex_type_hist,\n            \"storage_class\": storage_class_hist,\n            \"numberof_aux_symbols\": self.pair_with_symbol_name(\n                symbols, \"numberof_aux_symbols\"\n            ),\n            \"section_number\": self.pair_with_symbol_name(\n                symbols, \"section_number\"\n            ),\n            \"size\": self.pair_with_symbol_name(symbols, \"size\"),\n            \"value\": self.pair_with_symbol_name(symbols, \"value\"),\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"base_type\",\n            \"complex_type\",\n            \"storage_class\",\n            \"numberof_aux_symbols\",\n            \"section_number\",\n            \"size\",\n            \"value\",\n        ]\n        post_process_funcs = {\n            \"base_type\": lambda x: list(x.values()),\n            \"complex_type\": lambda x: list(x.values()),\n            \"storage_class\": lambda x: list(x.values()),\n            \"numberof_aux_symbols\": lambda x: vectorize_with_feature_hasher(\n                x, 50\n            ),\n            \"section_number\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"size\": lambda x: vectorize_with_feature_hasher(x, 50),\n            \"value\": lambda x: vectorize_with_feature_hasher(x, 50),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\n# NOTE: https:\/\/docs.microsoft.com\/en-us\/windows\/win32\/api\/heapapi\/nf-heapapi-heapcreate#parameters\nclass ProcessHeapFlags(Enum):\n    HEAP_CREATE_ENABLE_EXECUTE = 0x00040000\n    HEAP_GENERATE_EXCEPTIONS = 0x00000004\n    HEAP_NO_SERIALIZE = 0x00000001\n\n\nclass LoadConfigurationFeatureExtractor(FeatureExtractor):\n    feature_name: str = \"load_configuration\"\n\n    def __init__(self, ver: str) -> None:\n        self.ver = ver_str_to_int(ver)\n        super(FeatureExtractor, self).__init__()\n\n    @staticmethod\n    def version_to_onehot(ver: Optional[str]) -> Dict[str, int]:\n        return make_onehot_from_str_keys(\n            [\n                \"UNKNOWN\",\n                \"SEH\",\n                \"WIN_8_1\",\n                \"WIN10_0_9879\",\n                \"WIN10_0_14286\",\n                \"WIN10_0_14383\",\n                \"WIN10_0_14901\",\n                \"WIN10_0_15002\",\n                \"WIN10_0_16237\",\n            ],\n            ver,\n        )\n\n    @staticmethod\n    def process_heap_flags_to_onehot(phf: Optional[int]) -> Dict[str, int]:\n        encoded_data = {str(k): 0 for k in ProcessHeapFlags}\n        if phf:\n            for k in ProcessHeapFlags:\n                if (phf & k.value) != 0:\n                    encoded_data[str(k)] = 1\n        return encoded_data\n\n    def extract_raw_features_from_code_integrity(\n        self, code_integrity: DefaultDict[str, Any]\n    ) -> dict:\n        prefix = \"code_integrity\"\n        return {\n            f\"{prefix}_flags\": code_integrity[\"flags\"],\n            f\"{prefix}_catalog\": code_integrity[\"catalog\"],\n            f\"{prefix}_catalog_offset\": code_integrity[\"catalog_offset\"],\n            f\"{prefix}_reserved\": code_integrity[\"reserved\"],\n        }\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        load_configuration = make_defaultdict_from_dict_elem(\n            raw_json, self.feature_name\n        )\n\n        return {\n            \"version\": self.version_to_onehot(load_configuration[\"version\"]),\n            \"characteristics\": load_configuration[\"characteristics\"],\n            \"timedatestamp\": load_configuration[\"timedatestamp\"],\n            \"major_version\": load_configuration[\"major_version\"],\n            \"minor_version\": load_configuration[\"minor_version\"],\n            \"global_flags_clear\": load_configuration[\"global_flags_clear\"],\n            \"global_flags_set\": load_configuration[\"global_flags_set\"],\n            \"critical_section_default_timeout\": load_configuration[\n                \"critical_section_default_timeout\"\n            ],\n            \"decommit_free_block_threshold\": load_configuration[\n                \"decommit_free_block_threshold\"\n            ],\n            \"decommit_total_free_threshold\": load_configuration[\n                \"decommit_total_free_threshold\"\n            ],\n            \"lock_prefix_table\": load_configuration[\"lock_prefix_table\"],\n            \"maximum_allocation_size\": load_configuration[\n                \"maximum_allocation_size\"\n            ],\n            \"virtual_memory_threshold\": load_configuration[\n                \"virtual_memory_threshold\"\n            ],\n            \"process_affinity_mask\": load_configuration[\n                \"process_affinity_mask\"\n            ],\n            \"process_heap_flags\": self.process_heap_flags_to_onehot(\n                load_configuration[\"process_heap_flags\"]\n            ),\n            \"csd_version\": load_configuration[\"csd_version\"],\n            \"reserved1\": load_configuration[\"reserved1\"],\n            \"security_cookie\": load_configuration[\"security_cookie\"],\n            \"se_handler_table\": load_configuration[\"se_handler_table\"],\n            \"se_handler_count\": load_configuration[\"se_handler_count\"],\n            \"guard_cf_check_function_pointer\": load_configuration[\n                \"guard_cf_check_function_pointer\"\n            ],\n            \"guard_cf_dispatch_function_pointer\": load_configuration[\n                \"guard_cf_dispatch_function_pointer\"\n            ],\n            \"guard_cf_function_table\": load_configuration[\n                \"guard_cf_function_table\"\n            ],\n            \"guard_cf_function_count\": load_configuration[\n                \"guard_cf_function_count\"\n            ],\n            \"guard_flags\": load_configuration[\"guard_flags\"],\n            **self.extract_raw_features_from_code_integrity(\n                make_defaultdict_from_dict_elem(\n                    load_configuration, \"code_integrity\"\n                )\n            ),\n            \"guard_address_taken_iat_entry_table\": load_configuration[\n                \"guard_address_taken_iat_entry_table\"\n            ],\n            \"guard_address_taken_iat_entry_count\": load_configuration[\n                \"guard_address_taken_iat_entry_count\"\n            ],\n            \"guard_long_jump_target_table\": load_configuration[\n                \"guard_long_jump_target_table\"\n            ],\n            \"guard_long_jump_target_count\": load_configuration[\n                \"guard_long_jump_target_count\"\n            ],\n            \"dynamic_value_reloc_table\": load_configuration[\n                \"dynamic_value_reloc_table\"\n            ],\n            \"hybrid_metadata_pointer\": load_configuration[\n                \"hybrid_metadata_pointer\"\n            ],\n            \"guard_rf_failure_routine\": load_configuration[\n                \"guard_rf_failure_routine\"\n            ],\n            \"guard_rf_failure_routine_function_pointer\": load_configuration[\n                \"guard_rf_failure_routine_function_pointer\"\n            ],\n            \"dynamic_value_reloctable_offset\": load_configuration[\n                \"dynamic_value_reloctable_offset\"\n            ],\n            \"dynamic_value_reloctable_section\": load_configuration[\n                \"dynamic_value_reloctable_section\"\n            ],\n            \"reserved2\": load_configuration[\"reserved2\"],\n            \"guard_rf_verify_stackpointer_function_pointer\": load_configuration[\n                \"guard_rf_verify_stackpointer_function_pointer\"\n            ],\n            \"hotpatch_table_offset\": load_configuration[\n                \"hotpatch_table_offset\"\n            ],\n            \"reserved3\": load_configuration[\"reserved3\"],\n            \"addressof_unicode_string\": load_configuration[\n                \"addressof_unicode_string\"\n            ],\n        }\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        features_selected = [\n            \"version\",\n            \"characteristics\",\n            \"timedatestamp\",\n            \"major_version\",\n            \"minor_version\",\n            \"minor_version\",\n            \"global_flags_clear\",\n            \"global_flags_set\",\n            \"critical_section_default_timeout\",\n            \"decommit_free_block_threshold\",\n            \"decommit_total_free_threshold\",\n            \"lock_prefix_table\",\n            \"maximum_allocation_size\",\n            \"virtual_memory_threshold\",\n            \"process_affinity_mask\",\n            \"process_heap_flags\",\n            \"csd_version\",\n            \"reserved1\",\n            \"security_cookie\",\n            \"se_handler_table\",\n            \"se_handler_count\",\n            \"guard_cf_check_function_pointer\",\n            \"guard_cf_dispatch_function_pointer\",\n            \"guard_cf_function_table\",\n            \"guard_cf_function_count\",\n            \"guard_flags\",\n            \"code_integrity_flags\",\n            \"code_integrity_catalog\",\n            \"code_integrity_catalog_offset\",\n            \"code_integrity_reserved\",\n            \"guard_address_taken_iat_entry_table\",\n            \"guard_address_taken_iat_entry_count\",\n            \"guard_long_jump_target_table\",\n            \"guard_long_jump_target_count\",\n            \"dynamic_value_reloc_table\",\n            \"hybrid_metadata_pointer\",\n            \"guard_rf_failure_routine\",\n            \"guard_rf_failure_routine_function_pointer\",\n            \"dynamic_value_reloctable_offset\",\n            \"dynamic_value_reloctable_section\",\n            \"reserved2\",\n            \"guard_rf_verify_stackpointer_function_pointer\",\n            \"hotpatch_table_offset\",\n            \"reserved3\",\n            \"addressof_unicode_string\",\n        ]\n        post_process_funcs = {\n            \"version\": lambda x: list(x.values()),\n            \"process_heap_flags\": lambda x: list(x.values()),\n        }\n        return vectorize_selected_features(\n            raw_features,\n            features_selected,\n            post_process_funcs,\n            self.feature_name,\n        )\n\n\nclass LiefFeatureExtractor(FeatureExtractor):\n    feature_name = \"lief\"\n\n    def __init__(self, ver: str) -> None:\n        super(FeatureExtractor, self).__init__()\n        self.ver = ver_str_to_int(ver)\n        self.extractors = [\n            DosHeaderFeatureExtractor(ver),\n            RichHeaderFeatureExtractor(ver),\n            HeaderFeatureExtractor(ver),\n            OptionalHeaderFeatureExtractor(ver),\n            DataDirectoriesFeatureExtractor(ver),\n            SectionsFeatureExtractor(ver),\n            RelocationsFeatureExtractor(ver),\n            TlsFeatureExtractor(ver),\n            ExportFeatureExtractor(ver),\n            # DebugFeatureExtractor(ver), # DebugFeature is currently not supported\n            ImportsFeatureExtractor(ver),\n            ResourcesTreeFeatureExtractor(ver),\n            ResourcesManagerFeatureExtractor(ver),\n            SignatureFeatureExtractor(ver),\n            LoadConfigurationFeatureExtractor(ver),\n        ]\n        if self.ver >= 2021:\n            self.extractors.append(SymbolsFeatureExtractor(ver))\n\n    def extract_raw_features(self, raw_json: dict) -> dict:\n        raw_features = {\n            extractor.feature_name: extractor.extract_raw_features(raw_json)\n            for extractor in self.extractors\n        }\n        # NOTE: top-level defined features\n        raw_features[\"entrypoint\"] = raw_json[\"entrypoint\"]\n        raw_features[\"virtual_size\"] = raw_json[\"virtual_size\"]\n        return raw_features\n\n    def vectorize_features(\n        self, raw_features: dict\n    ) -> Tuple[List[str], np.ndarray]:\n        columns: List[str] = [\"entrypoint\", \"virtual_size\"]\n        vectors: List[np.ndarray] = [\n            raw_features[\"entrypoint\"],\n            raw_features[\"virtual_size\"],\n        ]\n        for extractor in self.extractors:\n            column, vector = extractor.vectorize_features(\n                raw_features[extractor.feature_name]\n            )\n            columns += column\n            vectors.append(vector)\n        return columns, np.hstack(vectors)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_97","text":"'''\nCreated on Mar 20, 2014\n\n@author: flurin, quentin\n'''\nimport numpy as np\nimport scipy.sparse as sps\nimport DNL\nimport os.path\nimport warnings\n\n\nclass Assignment:\n    '''\n    This class computes or loads the assigment matrices. If they have already been calculated, then they area\n    simply loaded. This part can take some time if the matrices must be calculated from scratch.\n    '''\n    def __init__(self, estim_param, network):\n        '''\n        Constructor\n        '''\n        # create precomputed directory if it does not exist\n        if not os.path.exists(estim_param.path_precomp):\n            os.makedirs(estim_param.path_precomp)\n\n        '''-----------------------------------------------------------------------------------------------------------------\n                            Loads the link flow assignment matrix if is exists, otherwise calculates it\n        -----------------------------------------------------------------------------------------------------------------'''\n        if os.path.isfile(estim_param.path_precomputed_asg + \"_linkFlowAssgn_data.csv\") and estim_param.forceRecompAssgnment is False:\n            print \"Loading pre-computed flow assignment matrix\",\n            data = np.loadtxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_data.csv\", delimiter=\",\")\n            indices = np.loadtxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_indices.csv\", dtype='int_', delimiter=\",\")\n            indptr = np.loadtxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_indptr.csv\", dtype='int_', delimiter=\",\")\n            self.linkFlowAssgn = sps.csr_matrix((data, indices, indptr)).todense()\n        else:\n            print \"Computing flow assignment matrix\",\n            self.linkFlowAssgn = np.asmatrix(DNL.compute_assg_mat(network, estim_param))\n            linkFlowAssgn_csr = sps.csr_matrix(self.linkFlowAssgn)\n            np.savetxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_data.csv\", linkFlowAssgn_csr.data, delimiter=\",\")\n            np.savetxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_indices.csv\", linkFlowAssgn_csr.indices, fmt='%i', delimiter=\",\")\n            np.savetxt(estim_param.path_precomputed_asg + \"_linkFlowAssgn_indptr.csv\", linkFlowAssgn_csr.indptr, fmt='%i', delimiter=\",\")\n        \n        self.linkFlowAssgn_prime = DNL.build_flow_assg_mat(self.linkFlowAssgn, network, estim_param, network.edges_ASE_dict)\n        self.subRouteAssgn_prime = DNL.build_ODflow_assg_mat(self.linkFlowAssgn, network, estim_param, network.subroutes_VS_dict)\n        self.accAssgn_prime = DNL.build_flow_assg_mat(self.linkFlowAssgn, network, estim_param, network.edges_TINF_dict)\n        estim_param.print_incr_runtime()\n\n        '''-----------------------------------------------------------------------------------------------------------------\n                         Loads the occupation flow assignment matrix if is exists, otherwise calculates it\n        -----------------------------------------------------------------------------------------------------------------'''\n        if os.path.isfile(estim_param.path_precomputed_asg + \"_acc_data.csv\") and estim_param.forceRecompAssgnment is False:\n            print \"Loading pre-computed accumulation assignment matrix\",\n            data = np.loadtxt(estim_param.path_precomputed_asg + \"_acc_data.csv\", delimiter=\",\")\n            indices = np.loadtxt(estim_param.path_precomputed_asg + \"_acc_indices.csv\", dtype='int_', delimiter=\",\")\n            indptr = np.loadtxt(estim_param.path_precomputed_asg + \"_acc_indptr.csv\", dtype='int_', delimiter=\",\")\n            self.acc = sps.csr_matrix((data, indices, indptr)).todense()\n            #print \"Occupation assignment matrix accumulation loaded.\"\n        else:\n            print \"Computing accumulation assignment matrix\",\n            with warnings.catch_warnings():\n                warnings.simplefilter(\"ignore\")  # Prevent some annoying numerical warnings from appearing\n                self.acc = np.asmatrix(DNL.compute_assg_mat_accumulation(network, estim_param))\n            acc_csr = sps.csr_matrix(self.acc)\n            np.savetxt(estim_param.path_precomputed_asg + \"_acc_data.csv\", acc_csr.data, delimiter=\",\")\n            np.savetxt(estim_param.path_precomputed_asg + \"_acc_indices.csv\", acc_csr.indices, fmt='%i', delimiter=\",\")\n            np.savetxt(estim_param.path_precomputed_asg + \"_acc_indptr.csv\", acc_csr.indptr, fmt='%i', delimiter=\",\")\n        estim_param.print_incr_runtime()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_99","text":"<filename>antenna_pattern\/rectify_timing_offsets.py\n\"\"\"\nMethods for rectifying for overflows and timing offsets in GNU Radio samples.\n\nDescribed in https:\/\/www.la1k.no\/?p=3152.\n\"\"\"\n\nfrom combine_samples_and_angles import read_gnuradio_header_element, load_gnuradio_samples\nfrom frequency_analysis import get_center_frequency_and_samplerate\nimport os\nimport numpy as np\nfrom scipy.interpolate import interp1d\n\ndef get_timestamps_from_header(gnuradio_hdr_file):\n    \"\"\"\n    Parse GNU Radio header file for timestamp tags.\n\n    Parameters\n    ----------\n    gnuradio_hdr_file: str\n        Path to GNU Radio header file\n\n    Returns\n    -------\n    timestamps: ndarray\n        List over timestamps\n    num_items: ndarray\n        List over number of items for which the timestamps are valid\n    \"\"\"\n\n    handle = open(gnuradio_hdr_file)\n\n    #get number of header elements contained in header file\n    _, element_size = read_gnuradio_header_element(handle)\n    handle.seek(0, 0)\n\n    header_size = os.path.getsize(gnuradio_hdr_file)\n    num_elements = header_size\/element_size\n\n    #get all header information\n    timestamps = np.zeros(num_elements)\n    samplerates = np.zeros(num_elements)\n    num_items = np.zeros(num_elements)\n    num_read = 0\n\n    for i in np.arange(0, num_elements):\n        info, element_size = read_gnuradio_header_element(handle)\n        if element_size == 0:\n            break\n\n        num_read += element_size\n        handle.seek(num_read, 0)\n\n        timestamps[i] = info['rx_time']\n        num_items[i] = info['nitems']\n\n    return timestamps, num_items\n\ndef copy_first_part_of_header(filename_in, filename_out):\n    \"\"\"\n    Copy first part of header file to a new header file.\n\n    Parameters\n    ----------\n    filename_in: str\n        Input filename. Input header is assumed to be filename_in.hdr.\n    filename_out: str\n        Output filename. Output header is assumed to be filename_out.hdr.\n    \"\"\"\n    header_file_out = open(filename_out + '.hdr', 'w')\n    header_file_in = open(filename_in + '.hdr')\n    _, header_size = read_gnuradio_header_element(header_file_in)\n    header_file_in.seek(0)\n    header_data = header_file_in.read(header_size)\n\n    header_file_out.write(header_data)\n\ndef fill_overflows(filename_in, filename_out):\n    \"\"\"\n    Takes in a GNU Radio meta file sink file and fills places with overflows\n    with a number of samples corresponding to the missing samples during the\n    overflow in order to rectify somewhat for the timing issues.\n\n    Parameters\n    ----------\n    filename_in: str\n        Input filename\n    filename_out: str\n        Output filename for writing the filled samples. Will also produce a\n        header file, containing the first header element of the original file.\n    \"\"\"\n\n    timestamps, num_items = get_timestamps_from_header(filename_in + '.hdr')\n    f_c, f_s = get_center_frequency_and_samplerate(filename_in)\n    _, data = load_gnuradio_samples(filename_in, return_full_timestamps=False)\n\n    #calculate missing samples\n    expected_samples = np.diff(timestamps)*f_s\n    missing_samples = expected_samples - num_items[0:-1]\n    missing_samples = np.round(missing_samples).astype(int)\n\n    #find indices where there is overflow problems\n    problem_samples = np.arange(0, len(missing_samples))[missing_samples > 0]\n    sample_counter = np.cumsum(num_items).astype(int)\n\n    #fill missing samples, write to new file\n    out_file = open(filename_out, 'w')\n    prev_problem = 0\n    for problem_sample in problem_samples:\n        #contiguous part of the data\n        out_file.write(data[sample_counter[prev_problem]:sample_counter[problem_sample]].tobytes())\n\n        #add a number of samples corresponding to the number of missing samples, interpolated between the current and next sample\n        interpolated_samples = np.repeat(interp1d([0, 1], [data[problem_sample], data[problem_sample+1]])(0.5), missing_samples[problem_sample]).astype(np.complex64)\n\n        out_file.write(interpolated_samples.tobytes())\n\n        prev_problem = problem_sample\n\n    #write out last part of the data\n    out_file.write(data[sample_counter[problem_sample]:].tobytes())\n\n    #write header\n    copy_first_part_of_header(filename_in, filename_out)\n\nimport sys\nif __name__ == \"__main__\":\n    if len(sys.argv) <= 2:\n        print(\"Rectifies for overflows in GNU Radio meta file sink files by filling in the missing samples.\\n\")\n        print(\"Usage: \" + sys.argv[0] + \" input_filename output_filename\")\n    else:\n        fill_overflows(sys.argv[1], sys.argv[2])\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_100","text":"<reponame>code-cullison\/pyaspect\nimport os\nimport glob\nimport copy\nimport datetime\nimport importlib\n\nimport numpy as np\nimport pandas as pd\n\nfrom scipy import signal\n\nfrom pyaspect.specfemio.headers import RecordHeader\nfrom pyaspect.specfemio.read import _read_headers\nfrom pyaspect.specfemio.headers import CMTSolutionHeader\nfrom pyaspect.specfemio.headers import StationHeader\n\n#TODO this is the actual record. I need the header, then make record.py\nclass Record(RecordHeader):\n\n    class _TraceData(object):\n        \n        class _XYZ(object):\n\n            def __init__(self,ex,ny,z):\n\n                self.ex = ex\n                self.ny = ny\n                self.z  = z\n\n            def __str__(self):\n                out_str  = f'Component E\/X:\\n{self.ex}\\n\\n'\n                out_str += f'Component N\/Y:\\n{self.ny}\\n\\n'\n                out_str += f'Component Z:\\n{self.z}'\n                return out_str\n\n            def __repr__(self):\n                out_str  = f'Component E\/X:\\n{self.ex.__repr__()}\\n\\n'\n                out_str += f'Component N\/Y:\\n{self.ny.__repr__()}\\n\\n'\n                out_str += f'Component Z:\\n{self.z.__repr__()}'\n                return out_str\n\n\n        def __init__(self,data_df):\n            \n            self.df_x = data_df['comp_EX']\n            self.df_y = data_df['comp_NY']\n            self.df_z = data_df['comp_Z']\n\n\n        def __getitem__(self,islice):\n            return self._XYZ(self.df_x.loc[islice],self.df_y.loc[islice],self.df_z.loc[islice])\n\n        def __str__(self):\n            out_str  = f'Component E\/X:\\n{self.df_x}\\n\\n'\n            out_str += f'Component N\/Y:\\n{self.df_y}\\n\\n'\n            out_str += f'Component Z:\\n{self.df_z}'\n            return out_str\n\n        def __repr__(self):\n            out_str  = f'Component E\/X:\\n{self.df_x.__repr__()}\\n\\n'\n            out_str += f'Component N\/Y:\\n{self.df_y.__repr__()}\\n\\n'\n            out_str += f'Component Z:\\n{self.df_z.__repr__()}'\n            return out_str\n\n    @classmethod\n    def from_header_and_data(cls,rheader,data_df):\n        '''\n        Alternative constructor StationHeader\n\n        This constructor takes two requried arguments, a RecordHeader\n        and a DataFrame with the data and indexed the same as\n        the solutions and stations dataframes in the Record header\n\n        :pyaspect:specfemio:headers:RecordHeader\n        :pandas:DataFrame\n\n        * ``rheader``\n        * ``data_df``\n        '''\n\n        if not isinstance(rheader,RecordHeader):\n            raise TypeError(f'arg: \\'rheader\\' must be of type RecordHeader')\n\n        if not isinstance(data_df,pd.DataFrame):\n            raise TypeError(f'arg: \\'data_df\\' must be of type pandas.DataFrame')\n\n        return Record('None',dtype='b',rheader=rheader,data_df=data_df)\n        \n            \n\n    def __init__(self,header_fqp,dtype='b',rheader=None,data_df=None):\n\n        if not isinstance(rheader,RecordHeader):\n            rheader = _read_headers(header_fqp)\n        else:\n            if not isinstance(data_df,pd.DataFrame):\n                raise ArgumentError('data_df must be provided')\n\n        super(Record,self).__init__(name=rheader.name,\n                                    solutions_h=rheader.get_solutions_header_list(),\n                                    stations_h=rheader.get_stations_header_list(),\n                                    proj_id=rheader.proj_id,\n                                    rid=rheader.rid,\n                                    iter_id=rheader.iter_id,\n                                    is_reciprocal=rheader.is_reciprocal)\n\n        self['header_path'] = os.path.dirname(header_fqp)\n        \n        if not isinstance(data_df,pd.DataFrame):\n            self._load_data(dtype=dtype)\n        else:\n            self['data_df'] = data_df\n            \n        \n        if not self._check_dfs_are_ok():\n            raise Exception('pd.DataFrame indices do not match')\n            \n\n    def __str__(self):\n        out_str  = f'{super(Record, self).__str__()}\\n\\n'\n        out_str += f'Data:\\n {self.data_df}'\n        return out_str\n    \n    def __repr__(self):\n        out_str  = f'{super(Record, self).__repr__()}\\n\\n'\n        out_str += f'Data:\\n {self.data_df.__repr__()}'\n        return out_str\n\n    def __getitem__(self, kslice):\n        \n        if not isinstance(kslice, str):\n            dslice = super(Record, self)._get_df_slice_index(kslice,self.data_df,is_stations=True)\n            c_data_df = self.data_df.reset_index()[dslice]\n            c_rheader = super(Record, self).__getitem__(kslice)\n            return Record(rheader=c_rheader,data_df=c_data_df)\n        else:\n            return super(Record, self).__getitem__(kslice)\n    \n    def _read_specfem_bin_trace(self,fpath,dtype=np.float32):\n        return np.fromfile(fpath, dtype=dtype)\n\n    def _load_data(self,dtype='b',sl=slice(None,None,None),scale=1.0,rfunc=None):\n\n        if dtype != 'b' and _rfunc == None:\n            raise Exception('can only read binary type data for the time being')\n            \n        #FIXME: add read ascii\n        read_func = self._read_specfem_bin_trace\n        if rfunc != None:\n            read_func = rfunc\n\n        l_data = []\n        for eidx, edf in self.stations_df.groupby(level='eid'):\n            for sidx, sdf in edf.groupby(level='sid'):\n                for tidx, tdf in sdf.groupby(level='trid'):\n                    for gidx, gdf in tdf.groupby(level='gid'):\n                        fp_prefix = gdf.loc[(eidx,sidx,tidx,gidx),\"data_fqdn\"]\n                        fp = os.path.join(self.header_path,fp_prefix)\n                        match_fp = fp + '.*X[XYZEN].sem*'\n                        data_dict = {'eid':eidx,'sid':sidx,'trid':tidx,'gid':gidx}\n                        for filepath in glob.glob(match_fp):\n                            comp = filepath.split('.')[-2][-1]\n                            if comp == 'X' or comp == 'E':\n                                data_dict['comp_EX'] = scale*read_func(filepath)\n                            elif comp == 'Y' or comp == 'N':\n                                data_dict['comp_NY'] = scale*read_func(filepath)\n                            elif comp == 'Z':\n                                data_dict['comp_Z'] = scale*read_func(filepath)\n                            else:\n                                raise Exception(f'Could not find component: \"{comp}\"')\n                                \n                        l_data.append(data_dict)\n                            \n        self['data_df'] = pd.DataFrame.from_records(l_data, index=self['default_stat_midx'])\n\n        \n    def _check_dfs_are_ok(self):\n        \n        data_idx = self.data_df.index\n        solu_idx = self.solutions_df.index\n        stat_idx = self.stations_df.index\n        stat_2_solu_idx = self.stations_df.reset_index().set_index(['eid','sid']).index\n\n        return all(data_idx == stat_idx) and all(solu_idx == stat_2_solu_idx.unique())\n        \n        \n    @property\n    def data(self):\n        return self._TraceData(self.data_df)\n        \n    @property\n    def data_df(self):\n        return self['data_df']\n    \n    @property\n    def component_names(self):\n        return ['comp_EX','comp_NY','comp_Z']\n\n\n\ndef make_recip_cmt_record_from_rgf(recip_record,rgf_cmt_data_df,mt_dict):\n\n    solu_df = recip_record.solutions_df\n    stat_df = recip_record.stations_df\n    l_recip_cmtsolutions = []\n    l_recip_cmtstations  = []\n    proj_id = recip_record.proj_id\n    for eidx, edf in rgf_cmt_data_df.groupby(level='eid'):\n        eid    = eidx\n        mt     = mt_dict[eid]\n        print(f'mt[{eid}]:\\n{mt.m6_up_south_east()}')\n        for tidx, tdf in edf.groupby(level='trid'):\n            date      = datetime.datetime.now()\n            lon_xc    = solu_df.loc[(eidx,0),'lon_xc']\n            lat_yc    = solu_df.loc[(eidx,0),'lat_yc']\n            depth     = solu_df.loc[(eidx,0),'depth']\n            elevation = 0.\n            network   = stat_df.loc[(tidx,0,eidx,0),'network']\n            stat_header = StationHeader(name=f'Reciprocal-Station:{tidx}',\n                                        lat_yc=lat_yc,\n                                        lon_xc=lon_xc,\n                                        depth=depth,\n                                        elevation=elevation,\n                                        network=network,\n                                        proj_id=proj_id,\n                                        eid=eid,\n                                        sid=0,\n                                        trid=tidx,\n                                        gid=0)\n            l_recip_cmtstations.append(stat_header)\n            cmt_lon_xc    = stat_df.loc[(tidx,0,eidx,0),'lon_xc']\n            cmt_lat_yc    = stat_df.loc[(tidx,0,eidx,0),'lat_yc']\n            cmt_depth     = stat_df.loc[(tidx,0,eidx,0),'depth']\n\n        cmt_header = CMTSolutionHeader(ename=f'Reciprocal-CMT:{eid}',\n                                       lat_yc=cmt_lat_yc,\n                                       lon_xc=cmt_lon_xc,\n                                       depth=cmt_depth,\n                                       tshift=0,\n                                       date=date,\n                                       hdur=0,\n                                       mt=mt,\n                                       proj_id=proj_id,\n                                       eid=eid,\n                                       sid=0)\n\n        l_recip_cmtsolutions.append(cmt_header)\n\n    record_h = RecordHeader(name=f'Reciprocal of:{recip_record.name}',\n                            solutions_h=l_recip_cmtsolutions,\n                            stations_h=l_recip_cmtstations,\n                            proj_id=proj_id,\n                            rid=recip_record.rid,\n                            iter_id=recip_record.iter_id,\n                            is_reciprocal=False)\n    \n    return Record.from_header_and_data(record_h,rgf_cmt_data_df)\n\n\n\ndef make_cmt_data_from_rgf(rgf_df,mt_dict,force_stf,cmt_stf):\n\n    comp_dict = {'comp_EX':0,'comp_NY':1,'comp_Z':2}\n\n    rgf_events = list(rgf_df.index.get_level_values('eid').unique())\n    #print(f'rgf_events: {rgf_events}')\n    mt_events  = list(mt_dict.keys())\n    #print(f'mt_events: {mt_events}')\n    #print(f'all: {rgf_events == mt_events}')\n\n    if not rgf_events == mt_events:\n        raise Exception('RGF-events do not match MomentTensors-events')\n\n    l_recip_cmt_traces = []\n    for eidx, edf in rgf_df.groupby(level='eid'):\n\n        mw = mt_dict[eidx].magnitude\n        m0 = mt_dict[eidx].moment\n        mt_arr = mt_dict[eidx].m6_up_south_east()\n\n        wzz =  mt_arr[0] #mrr\n        wyy =  mt_arr[1] #mtt\n        wxx =  mt_arr[2] #mpp\n        wyz = -mt_arr[3] #mrt\n        wxz =  mt_arr[4] #mrp\n        wxy = -mt_arr[5] #mtp\n\n\n        for tidx, tdf in edf.groupby(level='trid'):\n            d_recip_cmt = {'eid':eidx,'sid':0,'trid':tidx,'gid':0}\n            for comp_key in comp_dict.keys():\n                ic = comp_dict[comp_key]\n\n                composite_trace  = wxx*1*rgf_df.loc[(eidx,tidx, 0,ic, 0),'data'] #Matrix: Mee\n                composite_trace += wyy*1*rgf_df.loc[(eidx,tidx, 1,ic, 1),'data'] #Matrix: Mnn\n                composite_trace += wzz*1*rgf_df.loc[(eidx,tidx, 2,ic, 2),'data'] #Matrix: Mzz\n\n                #Matrix: M1\/Mxy\n                composite_trace += wxy*1*rgf_df.loc[(eidx,tidx, 1,ic, 0),'data']\n                composite_trace += wxy*1*rgf_df.loc[(eidx,tidx, 0,ic, 1),'data']\n\n                #Matrix: M2\/Mxz\n                composite_trace += wxz*1*rgf_df.loc[(eidx,tidx, 0,ic, 2),'data']\n                composite_trace += wxz*1*rgf_df.loc[(eidx,tidx, 2,ic, 0),'data']\n\n                #Matrix: M3\/Myz\n                composite_trace += wyz*1*rgf_df.loc[(eidx,tidx, 1,ic, 2),'data']\n                composite_trace += wyz*1*rgf_df.loc[(eidx,tidx, 2,ic, 1),'data']\n\n\n                #deconvolve and then convolved\n                deconv = 1.0\/force_stf[0]\n                scaled_trace = deconv*np.convolve(composite_trace,cmt_stf)[:len(cmt_stf)]\n\n                # convert back to single precision\n                scaled_trace = scaled_trace.astype(np.float32)\n\n                #add trace index to trace map dictionary\n                d_recip_cmt[comp_key] = scaled_trace\n\n            # add the mapped dictionary to a list so that it can be converted to a pd.DataFrame\n            l_recip_cmt_traces.append(d_recip_cmt)\n\n    return pd.DataFrame.from_records(l_recip_cmt_traces, index=('eid','sid','trid','gid'))\n\n\n\ndef make_rgf_data(record,fl,fh,fs):\n\n    comp_dict = {'comp_EX':0,'comp_NY':1,'comp_Z':2}\n    coord_dict = {0:'lon_xc',1:'lat_yc',2:'depth'}\n    sos = signal.butter(3, [fl,fh], 'bp', fs=fs, output='sos')\n\n    l_rgf_traces = []\n    m_df = pd.merge(record.stations_df,record.data_df,on=['eid','sid','trid','gid'])\n    for eidx, edf in m_df.groupby(level='eid'):\n        for sidx, sdf in edf.groupby(level='sid'):\n            for tidx, tdf in sdf.groupby(level='trid'):\n                for comp_key in comp_dict.keys():\n                    ie = tidx\n                    ig = eidx\n                    fi = sidx\n                    for di in range(3):\n                        rgf_dict = {'eid':tidx,'trid':eidx,'fid':sidx}\n                        rgf_dict['cid'] = comp_dict[comp_key]\n                        coord_key = coord_dict[di]\n                        rgf_dict['did'] = di\n                        ip1 = di+1     #coord + h\n                        im1 = ip1 + 3  #coord - h\n                        if di == 2:\n                            tm1 = ip1\n                            ip1 = im1\n                            im1 = tm1\n                        rgf_dict['data'] = calulate_spacial_derivative(m_df,\n                                                                       eidx,\n                                                                       sidx,\n                                                                       tidx,\n                                                                       ip1,\n                                                                       im1,\n                                                                       sos,\n                                                                       comp_key,\n                                                                       coord_key)\n\n                        rgf_dict['component'] = comp_key\n                        l_rgf_traces.append(rgf_dict)\n\n    return pd.DataFrame.from_records(l_rgf_traces, index=('eid','trid','cid','fid','did'))\n\n\n# make_rgf_data is poor choice of name, but some research code needs that\n# function name\ndef calc_dataframe_rgf(record,fl,fh,fs):\n    return make_rgf_data(record,fl,fh,fs)\n\n\ndef calulate_spacial_derivative(tdf,eidx,sidx,tidx,g_p1,g_m1,sos,comp_key,coord_key):\n    gidx_0  = pd.IndexSlice[eidx,sidx,tidx,0]\n    gidx_p1 = pd.IndexSlice[eidx,sidx,tidx,g_p1]\n    gidx_m1 = pd.IndexSlice[eidx,sidx,tidx,g_m1]\n    df_0    = tdf.loc[gidx_0]\n    df_p1   = tdf.loc[gidx_p1]\n    df_m1   = tdf.loc[gidx_m1]\n    data_p1 = signal.sosfilt(sos, df_p1[comp_key].astype(np.float64))\n    data_m1 = signal.sosfilt(sos, df_m1[comp_key].astype(np.float64))\n    c_p1    = df_p1[coord_key]\n    c_m1    = df_m1[coord_key]\n    c_0     = df_0[coord_key]\n    delta   = 0.5*(c_p1 - c_m1)\n    h       = 2.0*np.abs(delta)\n    c       = c_m1 + delta\n\n    assert h != 0\n    assert c_0-c == 0\n\n    h_scale  = 1\/h\n    mt_trace = h_scale*(data_p1 - data_m1)\n\n    return mt_trace\n\ndef calc_series_composite_recip_cmt_trace(eid,trid,mt_arr,rgf_df,force_stf,cmt_stf):\n\n    comp_dict = {'comp_EX':0,'comp_NY':1,'comp_Z':2}\n\n    wzz =  mt_arr[0] #mrr\n    wyy =  mt_arr[1] #mtt\n    wxx =  mt_arr[2] #mpp\n    wyz = -mt_arr[3] #mrt\n    wxz =  mt_arr[4] #mrp\n    wxy = -mt_arr[5] #mtp\n\n    cmt_trace_dict = {'eid':eid, 'trid':trid}\n    for comp_key in comp_dict.keys():\n        ic = comp_dict[comp_key]\n\n        composite_trace  = wxx*rgf_df.loc[(eid,trid,0,ic, 0),'data'].copy() #Matrix: Mee\n        composite_trace += wyy*rgf_df.loc[(eid,trid,1,ic, 1),'data'] #Matrix: Mnn\n        composite_trace += wzz*rgf_df.loc[(eid,trid,2,ic, 2),'data'] #Matrix: Mzz\n\n        #Matrix: M1\/Mxy\n        composite_trace += wxy*rgf_df.loc[(eid,trid,1,ic, 0),'data']\n        composite_trace += wxy*rgf_df.loc[(eid,trid,0,ic, 1),'data']\n\n        #Matrix: M2\/Mxz\n        composite_trace += wxz*rgf_df.loc[(eid,trid,0,ic, 2),'data']\n        composite_trace += wxz*rgf_df.loc[(eid,trid,2,ic, 0),'data']\n\n        #Matrix: M3\/Myz\n        composite_trace += wyz*rgf_df.loc[(eid,trid,1,ic, 2),'data']\n        composite_trace += wyz*rgf_df.loc[(eid,trid,2,ic, 1),'data']\n\n\n        #deconvolve and then convolved\n        deconv = 1.0\/force_stf[0]\n        scaled_trace = deconv*np.convolve(composite_trace.astype(np.float64),cmt_stf.astype(np.float64))[:len(cmt_stf)]\n\n        # convert back to single precision\n        cmt_trace_dict[comp_key] = scaled_trace.astype(np.float32)\n\n    return pd.Series(cmt_trace_dict)\n\ndef calc_dataframe_composite_recipt_cmt_traces_for_one_event(eid,mt,rgf_df,force_stf,cmt_stf):\n\n    mt_arr = mt.m6_up_south_east()\n\n    edf = None\n    ntr = rgf_df.index.get_level_values('trid').nunique()\n    for tidx in range(ntr):\n\n        tseries = calc_series_composite_recip_cmt_trace(eid,tidx,mt_arr,rgf_df,force_stf,cmt_stf)\n        edf = pd.concat([edf,tseries.to_frame().T])\n\n    edf.set_index(['eid','trid'],inplace=True)\n    return edf\n\n\ndef calc_dataframe_composite_recipt_cmt_for_all_events(rgf_df,mt_dict,force_stf,cmt_stf):\n\n    comp_dict = {'comp_EX':0,'comp_NY':1,'comp_Z':2}\n\n    rgf_events = list(rgf_df.index.get_level_values('eid').unique())\n    mt_events  = list(mt_dict.keys())\n\n    if not rgf_events == mt_events:\n        raise Exception('RGF-events do not match MomentTensors-events')\n\n    rdf = None\n    ne = rgf_df.index.get_level_values('eid').nunique()\n    for eidx in range(ne):\n\n        df = calc_dataframe_composite_recipt_cmt_traces_for_one_event(eidx,mt_dict[eidx],rgf_df,force_stf,cmt_stf)\n        rdf = pd.concat([rdf,df])\n\n    return rdf\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_101","text":"#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\nimport pandas as pd\nfrom datetime import datetime, timedelta\nimport numpy as np\nfrom scipy.stats import pearsonr\nimport matplotlib.font_manager as fm\nimport netCDF4 as nc\nfrom netCDF4 import Dataset\nimport os\nfrom pyproj import Proj\nimport ast\n\n#------------------------------------------------------------------------------\n# Motivación codigo -----------------------------------------------------------\n\"\"\"\nCodigo para el reconociemto de las variables de Porfundidad optica de las nubes de lat_GOES.\nLos datos son leidos desde el disco duro por si volumen.\n\"\"\"\n\n\npath_directory = \"\/media\/nacorreasa\/NATHALIA\/Productos\/CODDF\/\"\n\npath_save = '\/home\/nacorreasa\/Maestria\/Datos_Tesis\/GOES\/GOES_COD\/'\nresolucion = '2 km'\nfec_ini = '2020-01-01'\nfec_fin = '2020-01-12'\nModo = '6'\n\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n                                        # No cambiar nada en adelante\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n\n\n##-----------------------------FUNCIONES PARA BUSCAR LOS ARCHIVOS---------------------------------##\nimport datetime as dt\nfi  = dt.datetime.strptime(fec_ini, '%Y-%m-%d')\nff  = dt.datetime.strptime(fec_fin, '%Y-%m-%d')\n\ndef retorna_fecha_hora_info(ruta):\n    #try:\n    #    fecha = ruta[ruta.find('c2019')+1:ruta.find('c2019')+12]\n    #except:\n    fecha = ruta[ruta.find('c2020')+1:ruta.find('c2020')+12]\n    fecha = dt.datetime.strptime(fecha, '%Y%j%H%M')\n    fecha_utc = fecha.strftime('%Y\/%m\/%d\/ %H:%M')\n    fecha_local = fecha - dt.timedelta(hours=5)\n    fecha_local = fecha_local.strftime('%Y\/%m\/%d %H:%M')\n    fecha_path = fecha.strftime('%Y%m%d')\n    fecha = fecha.strftime('%Y%m%d%H%M')\n    return fecha_utc, fecha_path, fecha , fecha_local\n\n\ndef daterange(start_date, end_date):                                  ## PARA LA SELECCION DE LAS CARPETAS DE INTERES\n    delta = timedelta(days=1)\n    while start_date <= end_date:\n        yield start_date\n        start_date += delta\n\nFolders = []\nfor single_date in daterange(fi, ff):\n    Folders.append(single_date.date().strftime('%Y%m%d') )\n\n\ndef Listador(directorio, inicio, final):\n    lf = []\n    lista = os.listdir(directorio)\n    for i in lista:\n        if i.startswith(inicio) and i.endswith(final):\n            lf.append(i)\n    return lf\n\narchivos = []\nmissing_folders = []\nfor folder in Folders:\n    if os.path.exists(path_directory+folder) == True:\n        dias =  Listador(path_directory+folder, 'CG_ABI-L2-CODDF-M'+Modo+'_G16', '.nc')\n        dias.sort()\n        for hora in dias:\n            archivos.append(folder+'\/'+hora)\n    elif os.path.exists(path_directory+folder) == False:\n        print ('hay q crear la carpeta: ' + folder)\n        missing_folders.append(folder)\n        #os.system('mkdir ' + path_directory+folder+'\/')\n        pass\n\narchivos.sort()\n##-----------------------------------FUNCION PARA CREAR LAS CARPETAS FALTNATES------------------------------------#\nfor folder in Folders:\n    os.system('mkdir -p ' + path_save + folder )\n##-----------------------------------FUNCIONES PARA RECORTAR------------------------------------#\n\ndef find_nearest(array, value):                              ## PARA ENCONTRAR LA CASILLA MAS CERCANA\n    idx = (abs(array-value)).argmin()\n    return array[idx], idx\n\ndef Posiciones(archivo, limites_zona):                        ## RELACIONAR ESAS CASILLAS CON LAS LATITUDES REQUERIDAS\n    archivo = nc.Dataset(archivo)\n    h = archivo.variables['goes_imager_projection'].perspective_point_height\n    x = archivo.variables['x'][:]\n    y = archivo.variables['y'][:]\n    lon_0 = archivo.variables['goes_imager_projection'].longitude_of_projection_origin\n    lat_0 = archivo.variables['goes_imager_projection'].latitude_of_projection_origin\n    sat_sweep = archivo.variables['goes_imager_projection'].sweep_angle_axis\n    archivo.close()\n    x = x * h\n    y = y * h\n    p = Proj(proj='geos', h=h, lon_0=lon_0, swee=sat_sweep)\n    xx, yy = np.meshgrid(x, y)\n    print (xx, yy)\n\n    lons, lats = p(xx[:, :], yy[:, :], inverse=True)\n    lons = np.ma.array(lons)\n    lons[lons == 1.00000000e+30] = np.ma.masked\n    lats = np.ma.array(lats)\n    lats[lats == 1.00000000e+30] = np.ma.masked\n\n    mid = int(np.shape(lons)[0]\/2)\n    lon_O = find_nearest(lons[mid, :], limites_zona[0])[1]\n    lon_E = find_nearest(lons[mid, :], limites_zona[1])[1]\n    lat_N = find_nearest(lats[:, mid], limites_zona[2])[1]\n    lat_S = find_nearest(lats[:, mid], limites_zona[3])[1]\n    return lons, lats, lon_O, lon_E, lat_N, lat_S\n\ndef Obtiene_Lon_Lat_COD(ruta, dicc):                       ## PARA OBTENER LA INFORMACION ACOTADA A LA REGION DE INTERES\n    limites_zona = dicc\n    archivo = nc.Dataset(ruta)\n\n\n    h = archivo.variables['goes_imager_projection'].perspective_point_height\n    x = archivo.variables['x'][limites_zona[0]:limites_zona[1]]\n    y = archivo.variables['y'][limites_zona[2]:limites_zona[3]]\n    lon_0 = archivo.variables['goes_imager_projection'].longitude_of_projection_origin\n    lat_0 = archivo.variables['goes_imager_projection'].latitude_of_projection_origin\n    sat_sweep = archivo.variables['goes_imager_projection'].sweep_angle_axis\n    #d = (archivo.variables['earth_sun_distance_anomaly_in_AU'][:])**2\n    #esun = archivo.variables['esun'][:]\n\n    COD = archivo.variables[\"COD\"][limites_zona[2]:limites_zona[3], limites_zona[0]:limites_zona[1]]\n    archivo.close()\n    x = x * h\n    y = y * h\n    p = Proj(proj='geos', h=h, lon_0=lon_0, swee=sat_sweep)\n    xx, yy = np.meshgrid(x,y)\n    lons, lats = p(xx, yy, inverse=True)\n    lons = np.ma.array(lons)\n    lons[lons == 1.00000000e+30] = np.ma.masked\n    lats = np.ma.array(lats)\n    lats[lats == 1.00000000e+30] = np.ma.masked\n\n    return lons, lats, COD\n\ndef LimitesZonas(resolucion, zonas, path_CH):                                   ## PARA OBTENER LA LISTA CON LOS LIMITES DE LA ZONA\n\n    if resolucion == 0.5:\n        for i in zonas.keys():\n            lons, lats, lon_O, lon_E, lat_N, lat_S = Posiciones(path_CH, zonas[i])\n            print (u\"Posiciones dada una resolución espacial de 0.5 km\")\n            print (\"Para la zona \" + i + '\\n'\n                   u\"La posición para la longitud occidental es : \" + str(lon_O-1) + '\\n' +\n                   u\"La posición para la longitud oriental es : \" + str(lon_E) + '\\n' +\n                   u\"La posición para la latitud norte es : \" + str(lat_N-1) + '\\n' +\n                   u\"La posición para la latitud sur es : \" + str(lat_S) +'\\n' +\n                   u\"inclúyalas así en el diccionario de posiciones:\"  + '\\n'\n                   u\"[\" + str(lon_O-1) + ',' + str(lon_E) + ',' + str(lat_N-1) + ',' + str(lat_S) + \"]\")\n        DiccionarioPos =   u\"[\" + str(lon_O-1) + ',' + str(lon_E) + ',' + str(lat_N-1) + ',' + str(lat_S) + \"]\"\n        DiccionarioPos = ast.literal_eval(DiccionarioPos)\n    elif resolucion == 1:\n        for i in zonas.keys():\n            lons, lats, lon_O, lon_E, lat_N, lat_S = Posiciones(path_CH, zonas[i])\n            print (u\"Posiciones dada una resolución espacial de 1 km\")\n            print (\"Para la zona \" + i + '\\n'\n                                         u\"La posición para la longitud occidental es : \" + str(lon_O - 1) + '\\n' +\n                   u\"La posición para la longitud oriental es : \" + str(lon_E) + '\\n' +\n                   u\"La posición para la latitud norte es : \" + str(lat_N - 1) + '\\n' +\n                   u\"La posición para la latitud sur es : \" + str(lat_S) + '\\n' +\n                   u\"inclúyalas así en el diccionario de posiciones:\" + '\\n'\n                                                                        u\"[\" + str(lon_O - 1) + ',' + str(\n                lon_E) + ',' + str(lat_N - 1) + ',' + str(lat_S) + \"]\")\n        DiccionarioPos =   u\"[\" + str(lon_O-1) + ',' + str(lon_E) + ',' + str(lat_N-1) + ',' + str(lat_S) + \"]\"\n        DiccionarioPos = ast.literal_eval(DiccionarioPos)\n    elif resolucion == 2:\n        for i in zonas.keys():\n            lons, lats, lon_O, lon_E, lat_N, lat_S = Posiciones(path_CH, zonas[i])\n            print (u\"Posiciones dada una resolución espacial de 2 km\")\n            print (\"Para la zona \" + i + '\\n'\n                   u\"La posición para la longitud occidental es : \" + str(lon_O-1) + '\\n' +\n                   u\"La posición para la longitud oriental es : \" + str(lon_E) + '\\n' +\n                   u\"La posición para la latitud norte es : \" + str(lat_N-1) + '\\n' +\n                   u\"La posición para la latitud sur es : \" + str(lat_S) +'\\n' +\n                   u\"inclúyalas así en el diccionario de posiciones:\"  + '\\n'\n                   u\"[\" + str(lon_O-1) + ',' + str(lon_E) + ',' + str(lat_N-1) + ',' + str(lat_S) + \"]\")\n        DiccionarioPos =   u\"[\" + str(lon_O-1) + ',' + str(lon_E) + ',' + str(lat_N-1) + ',' + str(lat_S) + \"]\"\n        DiccionarioPos = ast.literal_eval(DiccionarioPos)\n    return DiccionarioPos\n\n\n##-----------DELIMITAR LA ZONA  EN COORDENADAS CARTESIANAS Y CREAR  VARIABLES-----------#\n\n## Coordenadas cartecianas de la zona de interés\nlatu = 6.5900\nlatd = 5.9300\nlono = -75.85\nlone = -75.07\n\nzonas = {'Valle_de_Aburra': [-75.85, -75.07, 6.5900,  5.9300]}\n\n## Ejecutar las funciones para tener la banda acotada a la región de interés y sus latitudes y longitudes\n\nlimzon = LimitesZonas(2, zonas, path_directory+archivos[0])\nif resolucion == '1 km':\n    limzon = [5328, 5416, 4698, 4771]\nelif resolucion == '0.5 km':\n    limzon = [10658, 10832, 9397, 9542]\nelif resolucion == '2 km':\n    limzon = [770, 815, 717, 754]\n\nlons, lats, rad = Obtiene_Lon_Lat_COD(path_directory+ archivos[0], limzon)\n\n\n## Iniciar variables\nntime    = 1\nnlat     = np.shape(lats)[0]\nnlon     = np.shape(lons)[1]\nnrad     = np.shape(rad)\n\ndef Obtener_fecha_hora_de_Archvos (path_directory, archivos):\n    local_hour = []\n    local_date_str = []\n    for i in range(len(archivos)):\n        fecha_utc, fecha_path, fecha, fecha_local = retorna_fecha_hora_info(path_directory + archivos[i])\n        local_hour.append(dt.datetime.strptime(fecha_local, '%Y\/%m\/%d %H:%M'))\n        local_date_str.append(fecha_local)\n    return local_date_str, local_hour\n\ndef retorna_scalefactor_y_addoffset_latlon(dataset,bits):         ## Nor maliza los valores de las variables\n    import numpy as np\n    max_o = np.max(dataset)\n    min_o = np.min(dataset)\n    scale_factor = (max_o - min_o) \/ (2**bits)\n    add_offset = min_o\n    return scale_factor, add_offset\n\nfechas, time = Obtener_fecha_hora_de_Archvos (path_directory, archivos)\n\ncdftime = 'hours since 2018-01-01 00:00:0.0'\ndate    = nc.date2num(time, units = cdftime)\n\n\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n                                        # Crear cada netCDF\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n# =*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n\nfor i  in range(len(archivos)):\n    ## Varibales temporales\n    lons_temp, lats_temp, COD_temp = Obtiene_Lon_Lat_COD(path_directory+archivos[i], limzon)\n\n    COD = np.zeros((1, np.shape(COD_temp)[0], np.shape(COD_temp)[1]))\n    COD[:, :, :] = COD_temp[:, :]\n\n    ## Crear el nuevo archivo nc\n    nw = Dataset(path_save + archivos[i], 'w', format='NETCDF4')\n\n    ## Definir dimensiones locativas\n    ncdim_lat = nw.createDimension('nlat', nlat)\n    ncdim_lon = nw.createDimension('nlon', nlon)\n    ncdim_time = nw.createDimension('ntime', ntime)\n\n    # Crear variables locativas\n    ncvar_lat = nw.createVariable('lat', 'f8', ('nlat', 'nlon'), zlib=True, complevel=9)\n    ncvar_lon = nw.createVariable('lon', 'f8', ('nlat', 'nlon'), zlib=True, complevel=9)\n    ncvar_time = nw.createVariable('time', 'f8', ('ntime',))\n\n    ncvar_COD = nw.createVariable('COD', 'f8', ('ntime', 'nlat', 'nlon'), zlib=True, complevel=9)\n\n    print ('netCDF variables created')\n\n    ## Agregar unidades a las variables\n    ncvar_lat.units = 'Degrees north'\n    ncvar_lon.units = 'Degrees east'\n    ncvar_time.units = 'Hours since 2018-01-01'\n\n    ncvar_COD.units = 'dimensionless'\n\n    try:\n        ## Factores de escala\n        ncvar_lon.scale_factor, ncvar_lon.add_offset = retorna_scalefactor_y_addoffset_latlon(lons, 11)\n        ncvar_lat.scale_factor, ncvar_lat.add_offset = retorna_scalefactor_y_addoffset_latlon(lats, 11)\n        ncvar_lat.scale_factor, ncvar_lat.add_offset = retorna_scalefactor_y_addoffset_latlon(COD, 11)\n    except ValueError:\n        pass\n\n    ## Agregar nombres largos\n    ncvar_lat.longname = 'Array of latitude values at the center of the grid box'\n    ncvar_lon.longname = 'Array of longitude values at the center of the grid box'\n    ncvar_time.longname = 'Hours since 2018-01-01'\n    ncvar_COD.longname = 'COD'\n\n    nw.title = archivos[i][12:]\n\n\n    nw.spatial_resolution = resolucion\n\n    nw.metadatos = \"https:\/\/www.goes-r.gov\/multimedia\/dataAndImageryImagesGoes-16.html\"\n\n    # Agregar los datos al archivo\n    ncvar_time[:] = date[i]\n    ncvar_lat[:, :] = lats.data\n    ncvar_lon[:, :] = lons.data\n\n    print ('******************************************')\n    print ('    writing variables in netCDF file ')\n    print ('******************************************')\n    ncvar_COD[:, :, :] = COD\n\n    # Si no cierra el archivo es como dejar la BD abierta... se lo tira!\n    nw.close()\n\nprint ('Hemos terminado')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_102","text":"<reponame>xiameng552180\/Intervention\nfrom scipy.stats import chi2_contingency\nfrom scipy.stats import chi2\n\n# Game on 327\n#          Ctrl, V1, V2, V3\n# Game       15   5   8  10\n# Not Game   55  37  41  33\n\n# Game on 544\n#          Ctrl, V1, V2, V3\n# Game       9   3   3  6\n# Not Game   30  34  41  32         \ntable = [[15, 5, 8, 10],\n         [70-15, 42-5, 49-8, 43-10]]\n\ntable1 = [[9, 3, 3, 6], [30, 34, 41, 32]]\nstat, p, dof, expected = chi2_contingency(table1)\nprint('* Degree of Freedom: %d' % dof)\n\n# 解释结果\nprob = 0.95\ncritical = chi2.ppf(prob, dof)\nprint('* Accept Probability = %.3f' % prob)\nprint('* Critical = %.3f' % critical)\n\nprint('* Interpretation as follows:')\nprint('- Chi^2 = %.3f' % stat)\nprint('- P-val = %.3f' % p)\nif abs(stat) >= critical:\n    print('- Dependent (reject H0)')\nelse:\n    print('- Independent (fail to reject H0)')\n\nalpha = 1.0 - prob\nif p <= alpha:\n    print('- p-value(%.2f) <= %.2f, dependent (reject H0)' % (p, alpha))\nelse:\n    print('- p-value(%.2f) > %.2f, independent (fail to reject H0)' % (p, alpha))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_103","text":"<filename>dataloaders\/ofos.py\nfrom torch.utils.data import Dataset, ConcatDataset\nfrom torch.utils.data.dataloader import DataLoader\nfrom torch.utils.data.sampler import RandomSampler, SequentialSampler\nfrom madmom.audio.signal import FramedSignal\nimport madmom.audio.spectrogram as mmspec\nfrom madmom.io import midi\nfrom scipy.ndimage.filters import maximum_filter1d\nfrom copy import deepcopy\nimport numpy as np\nimport joblib\nimport torch\nimport utils\nimport os\nimport csv\nimport warnings\n\n\nmemory = joblib.memory.Memory('.\/joblib_cache', mmap_mode='r', verbose=1)\n\n\ndef get_y_from_file(midifile, n_frames, audio_options):\n    with warnings.catch_warnings():\n        warnings.simplefilter('ignore')\n\n        pattern = midi.MIDIFile(midifile)\n        dt = float(audio_options['hop_size']) \/ float(audio_options['sample_rate'])\n\n        y_onsets = np.zeros((n_frames, 88), dtype=np.uint8)\n        y_frames = np.zeros((n_frames, 88), dtype=np.uint8)\n        y_offsets = np.zeros((n_frames, 88), dtype=np.uint8)\n\n        for onset, _pitch, duration, velocity, _channel in pattern.sustained_notes:\n            pitch = int(_pitch)\n            label = pitch - 21\n\n            note_start = int(np.round(onset \/ dt))\n            note_end = int(np.round((onset + duration) \/ dt))\n\n            # some of the midi-files have onsets\/offsets larger\n            # than n_frames. they were manually checked, and it's\n            # actually not an issue at all.\n            # see data-preparation\/maestro-inconsistencies\/* for\n            # scripts that perform visual inspection!\n            if note_start < n_frames:\n                if note_end >= n_frames:\n                    # print('weird_offset', midifile)\n                    note_end = n_frames - 1\n\n                y_onsets[note_start, label] = 1\n                y_frames[note_start:note_end + 1, label] = 1\n                y_offsets[note_end, label] = 1\n            else:\n                # print('weird_onset', midifile)\n                pass\n\n        return y_onsets, y_frames, y_offsets\n\n\ndef get_existing_filename(filename, suffixes):\n    for suffix in suffixes:\n        if os.path.exists(filename + suffix):\n            return filename + suffix\n\n    raise ValueError('provided filename \"{}\" does not exist with any of the endings {}'.format(filename, suffixes))\n\n\n@memory.cache\ndef get_xy_from_file(audio_filename, midi_filename, _audio_options):\n    spec_type, audio_options = utils.canonicalize_audio_options(_audio_options, mmspec)\n    x = np.array(spec_type(audio_filename, **audio_options))\n    y_onsets, y_frames, y_offsets = get_y_from_file(midi_filename, len(x), audio_options)\n\n    return x, y_onsets, y_frames, y_offsets\n\n\ndef get_xy_from_file_subsampled(audio_filename, midi_filename, audio_options, start_end):\n    x, y_onsets, y_frames, y_offsets = get_xy_from_file(\n        audio_filename,\n        midi_filename,\n        audio_options\n    )\n    if start_end is None:\n        return x, y_onsets, y_frames, y_offsets\n    else:\n        start, end = start_end\n        return x[start:end], y_onsets[start:end], y_frames[start:end], y_offsets[start:end]\n\n\n# maxfilter in temporal direction\ndef widen(x, w):\n    if w % 2 == 0:\n        raise RuntimeError('unsupported')\n\n    return maximum_filter1d(x, w, axis=0, mode='constant', cval=0, origin=0)\n\n\ndef suppress_offets(y_onsets, y_offsets):\n    # everywhere where onsets and offsets DO NOT occur simultaenously,\n    # (y_onsets != y_offsets) will be False\n    # only where onsets and offsets DO NOT overlap, it'll be True\n    return (y_onsets != y_offsets) * 1\n\n\nclass OneSequenceDataset(Dataset):\n    def __init__(self,\n                 audio_filename,\n                 midi_filename,\n                 input_context,\n                 target_maxfilter,\n                 audio_options,\n                 start_end=None,\n                 offset_suppression=None):\n        self.metadata = dict(\n            audio_filename=audio_filename,\n            midi_filename=midi_filename\n        )\n        self.audio_options = deepcopy(audio_options)\n\n        x, y_onsets, y_frames, y_offsets = get_xy_from_file_subsampled(\n            self.metadata['audio_filename'],\n            self.metadata['midi_filename'],\n            self.audio_options,\n            start_end\n        )\n\n        self.y_onsets = widen(y_onsets, target_maxfilter['y_onsets'])\n        self.y_frames = widen(y_frames, target_maxfilter['y_frames'])\n\n        if offset_suppression is not None:\n            # this gets passed the widened *onsets* already\n            y_offsets = suppress_offets(y_onsets, y_offsets)\n\n        # widen *after* suppression\n        self.y_offsets = widen(y_offsets, target_maxfilter['y_offsets'])\n\n        self.x = FramedSignal(\n            x,\n            frame_size=input_context['frame_size'],\n            hop_size=input_context['hop_size'],\n            origin=input_context['origin'],\n        )\n        if (len(self.x) != len(self.y_onsets) or\n           len(self.x) != len(self.y_frames) or\n           len(self.x) != len(self.y_offsets)):\n            raise RuntimeError('x and y do not have the same length.')\n\n    def __getitem__(self, index):\n        _, w, h = self.x.shape\n        return dict(\n            x=torch.FloatTensor(self.x[index].reshape(1, w, h)),\n            y_onsets=torch.FloatTensor(self.y_onsets[index]),\n            y_frames=torch.FloatTensor(self.y_frames[index]),\n            y_offsets=torch.FloatTensor(self.y_offsets[index])\n        )\n\n    def __len__(self):\n        return len(self.x)\n\n\ndef get_dataset_individually(base_directory, metadata_filename, split, input_context, target_maxfilter, audio_options, start_end=None, offset_suppression=None):\n\n    fieldnames = [\n        'canonical_composer',\n        'canonical_title',\n        'split',\n        'year',\n        'midi_filename',\n        'audio_filename',\n        'duration'\n    ]\n\n    class magenta_dialect(csv.Dialect):\n        delimiter = ','\n        quotechar = '\"'\n        doublequote = True\n        skipinitialspace = True\n        lineterminator = '\\n'\n        quoting = csv.QUOTE_MINIMAL\n    csv.register_dialect('magenta', magenta_dialect)\n\n    sequences = []\n    with open(metadata_filename, 'r') as metadata_file:\n        csvreader = csv.DictReader(metadata_file, fieldnames=fieldnames, dialect='magenta')\n        for row in csvreader:\n            if row['split'] == split:\n                sequences.append(OneSequenceDataset(\n                    os.path.join(base_directory, row['audio_filename']),\n                    os.path.join(base_directory, row['midi_filename']),\n                    input_context,\n                    target_maxfilter,\n                    audio_options,\n                    start_end,\n                    offset_suppression\n                ))\n    return sequences\n\n\ndef get_dataset(*args, **kwargs):\n    dataset = ConcatDataset(get_dataset_individually(*args, **kwargs))\n    print('len(dataset)', len(dataset))\n    return dataset\n\n\ndef get_loaders(config):\n    lcs = config['modules']['dataloader']['args']\n    loaders = dict()\n    for key, lc in lcs.items():\n        individual_files = lc.get('individual_files', False)\n        if individual_files:\n            sequences = get_dataset_individually(\n                base_directory=lc['base_directory'],\n                metadata_filename=lc['metadata_filename'],\n                split=lc['split'],\n                input_context=config['modules']['dataloader']['input_context'],\n                target_maxfilter=config['modules']['dataloader']['target_maxfilter'],\n                audio_options=config['audio_options'],\n                start_end=config['modules']['dataloader'].get('start_end', None),\n                offset_suppression=config['modules']['dataloader'].get('offset_suppression', None)\n            )\n            individual_loaders = []\n            for sequence in sequences:\n                if lc['sampler'] == 'RandomSampler':\n                    sampler = RandomSampler(sequence)\n                elif lc['sampler'] == 'SequentialSampler':\n                    sampler = SequentialSampler(sequence)\n                elif lc['sampler'] == 'ChunkedRandomSampler':\n                    sampler = utils.ChunkedRandomSampler(sequence, lc['chunk_size'])\n\n                individual_loader = DataLoader(\n                    sequence,\n                    batch_size=config['batchsize'],\n                    sampler=sampler,\n                    num_workers=lc.get('num_workers', 0),\n                    pin_memory=lc.get('pin_memory', False)\n                )\n                individual_loaders.append(individual_loader)\n            loaders[key] = individual_loaders\n        else:\n            sequences = get_dataset(\n                base_directory=lc['base_directory'],\n                metadata_filename=lc['metadata_filename'],\n                split=lc['split'],\n                input_context=config['modules']['dataloader']['input_context'],\n                target_maxfilter=config['modules']['dataloader']['target_maxfilter'],\n                audio_options=config['audio_options'],\n                start_end=config['modules']['dataloader'].get('start_end', None),\n                offset_suppression=config['modules']['dataloader'].get('offset_suppression', None)\n            )\n\n            if lc['sampler'] == 'RandomSampler':\n                sampler = RandomSampler(sequences)\n            elif lc['sampler'] == 'SequentialSampler':\n                sampler = SequentialSampler(sequences)\n            elif lc['sampler'] == 'ChunkedRandomSampler':\n                sampler = utils.ChunkedRandomSampler(sequences, lc['chunk_size'])\n\n            loader = DataLoader(\n                sequences,\n                batch_size=config['batchsize'],\n                sampler=sampler,\n                num_workers=lc.get('num_workers', 0),\n                pin_memory=lc.get('pin_memory', False)\n            )\n\n            loaders[key] = loader\n    return loaders\n\n\ndef main():\n    context = dict(\n        frame_size=5,\n        hop_size=1,\n        origin='center'\n    )\n\n    target_maxfilter = dict(\n        y_onsets=3,\n        y_frames=1,\n        y_offsets=3\n    )\n\n    audio_options = dict(\n        spectrogram_type='LogarithmicFilteredSpectrogram',\n        filterbank='LogarithmicFilterbank',\n        sample_rate=44100,\n        num_channels=1,\n        frame_size=2048,\n        hop_size=1024\n    )\n\n    sequences = get_dataset(\n        base_directory='.\/data\/maestro\/maestro-v1.0.0\/',\n        metadata_filename='.\/data\/maestro\/maestro-v1.0.0\/maestro-v1.0.0.csv',\n        split='train',\n        input_context=context,\n        target_maxfilter=target_maxfilter,\n        audio_options=audio_options\n    )\n    print('len(sequences)', len(sequences))\n\n    loader = DataLoader(\n        sequences,\n        batch_size=128,\n        shuffle=False,\n        sampler=SequentialSampler(sequences),\n        drop_last=False\n    )\n\n    import matplotlib.pyplot as plt\n\n    batch = next(iter(loader))\n    x = batch['x'].numpy()[:, 0, 2, :]\n    y_onsets = batch['y_onsets'].numpy()\n    y_frames = batch['y_frames'].numpy()\n    y_offsets = batch['y_offsets'].numpy()\n\n    fig, axes = plt.subplots(nrows=4, sharex=True, sharey=True)\n\n    axes[0].set_title('x')\n    axes[1].set_title('y_onsets')\n    axes[2].set_title('y_frames')\n    axes[3].set_title('y_offsets')\n\n    axes[0].imshow(x.T, origin='lower')\n    axes[1].imshow(y_onsets.T, cmap='gray_r', origin='lower')\n    axes[2].imshow(y_frames.T, cmap='gray_r', origin='lower')\n    axes[3].imshow(y_offsets.T, cmap='gray_r', origin='lower')\n    plt.show()\n\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_104","text":"<reponame>rcw175\/fittatoreJ\nfrom numpy import*\nfrom scipy import optimize, misc\nfrom matplotlib.pyplot import *\n%matplotlib inline\nimport pandas as pd\n\ndef fittatoreJ(fu, x, y, dx, dy, init, labels, ran=False, doppio=False):\n    '''\n    labels = {'x':, 'y':, 'file':}\n    fu(x, *par)\n    '''\n    if ran==False:\n        a,b = 0, x.size\n    else:\n        a,b = ran\n    par, dev = optimize.curve_fit(fu, x[a:b], y[a:b], sigma=dy[a:b], p0=init, absolute_sigma=True)\n    par = par; dev = diag(dev)\n    if doppio==True:\n        dyi = sqrt(dy[a:b]**2 + misc.derivative(fu, x[a:b], args=par, dx=0.0001)**2*1**2)\n        par, dev = optimize.curve_fit(fu, x[a:b], y[a:b], sigma=dyi, p0=init, absolute_sigma=True)\n        par = par; dev = diag(dev)\n    X2 = {'obs':sum((y[a:b]-fu(x[a:b],*par))**2\/dy[a:b]**2), 'exp':x[a:b].size-par.size}\n    N=0\n    figure(N)\n    errorbar(x[a:b],y[a:b],yerr=dy[a:b],xerr=dx[a:b], fmt=',', capsize=3)\n    plot(linspace(min(x[a:b]), max(x[a:b]),10000), fu(linspace(min(x[a:b]), max(x[a:b]),10000), *par), ',')\n    xlabel(labels['x'])\n    ylabel(labels['y'])\n    savefig('figs\/'+labels['file']+'.pdf')\n    savefig('figs\/'+labels['file']+'.png')\n    \n    figure(N+100)\n    plot((y[a:b]-fu(x[a:b],*par))\/dy[a:b], '.')\n    plot(array([0,b-a]), array([0,0]))\n    ylabel('Residui')\n    savefig('figs\/'+labels['file']+'_res.pdf')\n    savefig('figs\/'+labels['file']+'_res.png')\n    \n    return (array([par,dev]).T, X2)\n\ndef mediapesata(x,dx):\n    return(sum(x\/dx**2)\/sum(1\/dx**2), sqrt(1\/sum(1\/dx**2)))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_105","text":"<reponame>andr-kun\/vireo<gh_stars>0\nimport itertools\nimport numpy as np\nfrom scipy.stats import entropy\nfrom scipy.special import logsumexp, digamma, betaln\nfrom .vireo_base import normalize, loglik_amplify, beta_entropy, get_binom_coeff\n\n__docformat__ = \"restructuredtext en\"\n\n__all__ = ['Vireo', 'add_doublet_theta', 'add_doublet_GT']\n\n\nclass Vireo():\n    \"\"\"Viroe model: Variational Inference for reconstruction of ensemble origin\n\n    The prior can be set via set_prior() before fitting the model.\n\n    Key properties\n    --------------\n    beta_mu: numpy array (1, n_GT) or (n_var, n_GT)\n        Beta mean parameter of theta's posterior\n    beta_sum: numpy array (1, n_GT) or (n_var, n_GT), same as beta_mu\n        Beta concetration parameter of theta's posterior\n    ID_prob: numpy array (n_cell, n_donor)\n        Posterior cell assignment probability to each donor\n    GT_prob: numpy array (n_var, n_donor, n_GT)\n        Posterior genotype probability per variant per donor\n    \"\"\"\n    def __init__(self, n_cell, n_var, n_donor, n_GT=3, learn_GT=True,  \n        learn_theta=True, ASE_mode=False, fix_beta_sum=False, \n        beta_mu_init=None, beta_sum_init=None, ID_prob_init=None, \n        GT_prob_init=None):\n        \"\"\"Initialise Vireo model\n\n        Note, multiple initializations are highly recomended to avoid local \n        optima.\n        \n        Parameters\n        ----------\n        n_cell : int. \n            Number of cells\n        n_var : int. \n            Number of variants\n        n_donor : int. \n            Number of donors\n        n_GT : int. \n            Number of genotype categories\n        learn_GT: bool. \n            Whether updating `GT_prob`; otherwise using the initial\n        ASE_mode: bool. \n            Whether setting allelic ratio `theta` to be variant specific\n        fix_beta_sum: bool. \n            Whether fixing the concetration parameter of theta's posterior\n        beta_mu_init: numpy array (1, n_GT) or (n_var, n_GT)\n            Initial value of beta_mu, the mean parameter of theta\n        beta_sum_init: numpy array (1, n_GT) or (n_var, n_GT), same as beta_mu\n            Initial value of beta_sum, the concetration parameter of theta\n        ID_prob_init: numpy array (n_cell, n_donor)\n            Initial value of ID_prob, cell assignment probability to each donor\n        GT_prob_init: numpy array (n_var, n_donor, n_GT)\n            Initial value of GT_prob, genotype probability per variant and donor\n        \"\"\"\n        self.n_GT = n_GT\n        self.n_var = n_var\n        self.n_cell = n_cell\n        self.n_donor = n_donor\n        self.learn_GT = learn_GT\n        self.ASE_mode = ASE_mode\n        self.learn_theta = learn_theta\n        self.fix_beta_sum = fix_beta_sum\n        \n        theta_len = n_var if ASE_mode else 1\n        \n        # initial key parameters\n        if beta_mu_init is not None:\n            self.beta_mu = beta_mu_init\n        else:\n            self.beta_mu = (np.ones((theta_len, n_GT)) * \n                np.linspace(0.01, 0.99, n_GT).reshape(1, -1))\n\n        if beta_sum_init is not None:\n            self.beta_sum = beta_sum_init\n        else:\n            self.beta_sum = np.ones((theta_len, n_GT)) * 50\n\n        if ID_prob_init is not None:\n            self.ID_prob = normalize(ID_prob_init, axis=1)\n        else:\n            self.ID_prob = normalize(np.random.rand(n_cell, n_donor))\n\n        if GT_prob_init is not None:\n            self.GT_prob = normalize(GT_prob_init)\n        else:        \n            self.GT_prob = normalize(np.random.rand(n_var, n_donor, n_GT))\n\n        self.ELBO_ = np.zeros((0))\n        self.set_prior()\n    \n    def set_prior(self, GT_prior=None, ID_prior=None, beta_mu_prior=None, \n        beta_sum_prior=None, min_GP=0.00001):\n        \"\"\"Set prior for key variables: theta, GT_prob and ID_prob.\n        The priors are in the same shape as its according variables.\n\n        min_GP: float. Minimun genotype probability in GT_prior.\n        \"\"\"\n        if beta_mu_prior is None:\n            beta_mu_prior = np.expand_dims(\n                np.linspace(0.01, 0.99, self.beta_mu.shape[1]), axis=0)\n        if beta_sum_prior is None:\n            beta_sum_prior = np.ones(beta_mu_prior.shape) * 50.0\n        self.theta_s1_prior = beta_mu_prior * beta_sum_prior\n        self.theta_s2_prior = (1 - beta_mu_prior) * beta_sum_prior\n\n        if ID_prior is not None:\n            if len(ID_prior.shape) == 1:\n                ID_prior = np.expand_dims(ID_prior, axis=0)\n            self.ID_prior = ID_prior\n        else:\n            self.ID_prior = normalize(np.ones(self.ID_prob.shape))\n\n        if GT_prior is not None:\n            if len(GT_prior.shape) == 2:\n                GT_prior = np.expand_dims(GT_prior, axis=0)\n            GT_prior[GT_prior < min_GP] = min_GP\n            GT_prior[GT_prior > 1 - min_GP] = 1 - min_GP\n            GT_prior = normalize(GT_prior)\n            self.GT_prior = GT_prior\n        else:        \n            self.GT_prior = normalize(np.ones(self.GT_prob.shape))\n\n    @property\n    def theta_s1(self):\n        \"\"\"Beta concetration1 parameter for theta posterior\"\"\"\n        return self.beta_mu * self.beta_sum\n\n    @property\n    def theta_s2(self):\n        \"\"\"Beta concetration2 parameter for theta posterior\"\"\"\n        return (1 - self.beta_mu) * self.beta_sum\n\n    @property \n    def digamma1_(self):\n        \"\"\"Digamma of Beta concetration1 parameter\"\"\"\n        return np.expand_dims(digamma(self.theta_s1), 1)\n\n    @property \n    def digamma2_(self):\n        \"\"\"Digamma of Beta concetration2 parameter\"\"\"\n        return np.expand_dims(digamma(self.theta_s2), 1)\n\n    @property \n    def digammas_(self):\n        \"\"\"Digamma of Beta concetration summary parameter\"\"\"\n        return np.expand_dims(digamma(self.theta_s1 + self.theta_s2), 1)\n\n\n    def update_theta_size(self, AD, DP):\n        \"\"\"Coordinate ascent for updating theta posterior parameters\n        \"\"\"\n        BD = DP - AD\n        S1_gt = AD * self.ID_prob  #(n_var, n_donor)\n        S2_gt = BD * self.ID_prob  #(n_var, n_donor)\n        \n        _theta_s1 = np.zeros(self.beta_mu.shape)\n        _theta_s2 = np.zeros(self.beta_mu.shape)\n        _theta_s1 += self.theta_s1_prior.copy()\n        _theta_s2 += self.theta_s2_prior.copy()\n        for ig in range(self.n_GT):\n            _axis = 1 if self.ASE_mode else None\n            _theta_s1[:, ig:(ig+1)] += np.sum(\n                S1_gt * self.GT_prob[:, :, ig], axis=_axis, keepdims=True)\n            _theta_s2[:, ig:(ig+1)] += np.sum(\n                S2_gt * self.GT_prob[:, :, ig], axis=_axis, keepdims=True)\n        \n        self.beta_mu = _theta_s1 \/ (_theta_s1 + _theta_s2)\n        if self.fix_beta_sum == False:\n            self.beta_sum = _theta_s1 + _theta_s2\n\n    def update_ID_prob(self, AD, DP):\n        \"\"\"Coordinate ascent for updating assignment probability\n        \"\"\"\n        BD = DP - AD\n        logLik_ID = np.zeros((AD.shape[1], self.n_donor))\n        for ig in range(self.n_GT):\n            S1 = AD.transpose() * (self.GT_prob[:, :, ig] * self.digamma1_[:, :, ig])\n            S2 = BD.transpose() * (self.GT_prob[:, :, ig] * self.digamma2_[:, :, ig])\n            SS = DP.transpose() * (self.GT_prob[:, :, ig] * self.digammas_[:, :, ig])\n            logLik_ID += (S1 + S2 - SS)\n        \n        self.ID_prob = normalize(np.exp(loglik_amplify(\n            logLik_ID + np.log(self.ID_prior))))\n        \n        return logLik_ID\n                \n\n    def update_GT_prob(self, AD, DP):\n        \"\"\"Coordinate ascent for updating genotype probability\n        \"\"\"\n        S1_gt = AD * self.ID_prob\n        SS_gt = DP * self.ID_prob\n        S2_gt = SS_gt - S1_gt\n        \n        logLik_GT = np.zeros(self.GT_prior.shape)\n        for ig in range(self.n_GT):\n            logLik_GT[:, :, ig] = (\n                S1_gt * self.digamma1_[:, :, ig] + \n                S2_gt * self.digamma2_[:, :, ig] - \n                SS_gt * self.digammas_[:, :, ig])\n\n        self.GT_prob = normalize(np.exp(loglik_amplify(\n            logLik_GT + np.log(self.GT_prior))))\n        \n        \n    def get_ELBO(self, logLik_ID, AD=None, DP=None):\n        \"\"\"Calculating variational evidence lower bound with current parameters\n\n        logLik_ID: numpy array (n_cell, n_donor), the output from update_ID_prob\n        \"\"\"\n        if logLik_ID is None:\n            BD = DP - AD\n            logLik_ID = np.zeros((AD.shape[1], self.n_donor))\n            for ig in range(self.n_GT):\n                S1 = AD.transpose() * (self.GT_prob[:, :, ig] * self.digamma1_[:, :, ig])\n                S2 = BD.transpose() * (self.GT_prob[:, :, ig] * self.digamma2_[:, :, ig])\n                SS = DP.transpose() * (self.GT_prob[:, :, ig] * self.digammas_[:, :, ig])\n                logLik_ID += (S1 + S2 - SS)\n\n        LB_p = np.sum(logLik_ID * self.ID_prob)\n        KL_ID = -np.sum(entropy(self.ID_prob, self.ID_prior, axis=-1))\n        KL_GT = -np.sum(entropy(self.GT_prob, self.GT_prior, axis=-1))\n        KL_theta = -beta_entropy(\n            np.append(\n                np.expand_dims(self.theta_s1, 1), \n                np.expand_dims(self.theta_s2, 1), axis = 1),\n            np.append(\n                np.expand_dims(self.theta_s1_prior, 1), \n                np.expand_dims(self.theta_s2_prior, 1), axis = 1))\n        \n        # print(LB_p, KL_ID, KL_GT, KL_theta)\n        return LB_p - KL_ID - KL_GT - KL_theta\n\n\n    def fit(self, AD, DP, max_iter=200, min_iter=5, epsilon_conv=1e-2,\n        delay_fit_theta=0, verbose=False):\n        \"\"\"Fit Vireo model with coordinate ascent\n\n        Parameters\n        ----------\n        AD : scipy.sparse.csc_matrix (n_var, n_cell)\n            Sparse count matrix for alternative allele\n        DP : scipy.sparse.csc_matrix (n_var, n_cell)\n            Sparse count matrix for depths, alternative + refeerence alleles\n        max_iter : int\n            Maximum number of iterations\n        min_iter :\n            Minimum number of iterations\n        epsilon_conv : float\n            Threshold for detecting convergence\n        delay_fit_theta : int\n            Number of steps to delay updating theta. This can be very useful \n            for common genetics when there is good prior on allelic ratio.\n        verbose : bool\n            Whether print out log info\n        \"\"\"\n        _binom_coeff = np.sum(get_binom_coeff(AD, DP))\n        ELBO = np.zeros(max_iter)\n        for it in range(max_iter):\n            if self.learn_theta and it >= delay_fit_theta:\n                self.update_theta_size(AD, DP)\n            if self.learn_GT:\n                self.update_GT_prob(AD, DP)\n\n            _logLik_ID = self.update_ID_prob(AD, DP)\n            ELBO[it] = self.get_ELBO(_logLik_ID) + _binom_coeff\n\n            if it > min_iter:\n                if ELBO[it] < ELBO[it - 1]:\n                    if verbose:\n                        print(\"Warning: Lower bound decreases!\\n\")\n                elif it == max_iter - 1:\n                    if verbose:\n                        print(\"Warning: VB did not converge!\\n\")\n                elif ELBO[it] - ELBO[it - 1] < epsilon_conv:\n                    break\n        self.ELBO_ = np.append(self.ELBO_, ELBO[:it])\n\n\n    def predict_doublet(self, AD, DP, update_GT=True, update_ID=True, \n        doublet_rate_prior=None):\n        \"\"\"Predict doublet with fitted Vireo model\n\n        Parameters\n        ----------\n        AD : scipy.sparse.csc_matrix (n_var, n_cell)\n            Sparse count matrix for alternative allele\n        DP : scipy.sparse.csc_matrix (n_var, n_cell)\n            Sparse count matrix for depths, alternative + refeerence alleles\n        update_GT : bool\n            Whether updating GT_prob after removing doublet_prob\n        update_GT : bool\n            Whether updating ID_prob by removing doublet_prob\n        doublet_rate_prior : float\n            Prior value of doublet rate\n\n        Returns\n        -------\n        A tuple of two numpy arrays (doublet_prob, ID_prob)\n\n        doublet_prob : numpy array (n_cell, n_donor * (n_donor - 1) \/ 2)\n            Assignment probability of a cells to any doublet (donor pair)\n        ID_prob : numpy array (n_cell, n_donor)\n            updated ID_prob by removing doublet_prob\n        \"\"\"\n        GT_both = add_doublet_GT(self.GT_prob)\n        beta_mu_both, beta_sum_both = add_doublet_theta(self.beta_mu, \n                                                        self.beta_sum)\n\n        n_doublet_pair = GT_both.shape[1] - self.GT_prob.shape[1]\n        if doublet_rate_prior is None:\n            doublet_rate_prior = min(0.5, AD.shape[1] \/ 100000)\n            \n        ID_prior_both = np.append(\n            self.ID_prior * (1 - doublet_rate_prior), \n            np.ones((self.n_cell, n_doublet_pair)) \/ n_doublet_pair * \n            doublet_rate_prior, axis=1)\n\n        # Calculate assignment probability (same as update_ID_prob())\n        BD = DP - AD\n        logLik_ID = np.zeros((AD.shape[1], GT_both.shape[1]))\n        _digamma1 = np.expand_dims(digamma(beta_sum_both * beta_mu_both), 1)\n        _digamma2 = np.expand_dims(digamma(beta_sum_both * (1 - beta_mu_both)), 1)\n        _digammas = np.expand_dims(digamma(beta_sum_both), 1)\n        for ig in range(GT_both.shape[2]):\n            S1 = AD.transpose() * (GT_both[:, :, ig] * _digamma1[:, :, ig])\n            S2 = BD.transpose() * (GT_both[:, :, ig] * _digamma2[:, :, ig])\n            SS = DP.transpose() * (GT_both[:, :, ig] * _digammas[:, :, ig])\n            logLik_ID += (S1 + S2 - SS)\n\n        ID_prob_both = normalize(np.exp(loglik_amplify(\n            logLik_ID + np.log(ID_prior_both))))\n\n        if update_ID:\n            self.ID_prob = ID_prob_both[:, :self.n_donor]\n\n        if update_GT:\n            if update_ID:\n                self.update_GT_prob(AD, DP)\n            else:\n                print(\"For update_GT, please turn on update_ID.\")\n        \n        return ID_prob_both[:, self.n_donor:], ID_prob_both[:, :self.n_donor]\n\n\n    def predit_ambient(self):\n        \"\"\"Predict fraction of ambient RNA contaimination.\n        \n        Not implemented yet.\n        \"\"\"\n        print(\"Not implemented yet.\")\n\n\ndef add_doublet_theta(beta_mu, beta_sum):\n    \"\"\"\n    calculate theta for doublet genotype: GT=0&1, GT=0&2, and GT=1&2 by\n    averaging thire beta paramters\n    \n    Example\n    -------\n    add_doublet_theta(np.array([[0.01, 0.5, 0.99]]), np.array([[30, 6, 30]]))\n    \"\"\"\n    # TODO: support reduced GT for relatives\n    combn_iter = itertools.combinations(range(beta_mu.shape[1]), 2)\n    db_idx = np.array([x for x in combn_iter])\n\n    beta_mu_db = (beta_mu[:, db_idx[:, 0]] + beta_mu[:, db_idx[:, 1]]) \/ 2.0\n    beta_sum_db = np.sqrt(beta_sum[:, db_idx[:, 0]] * beta_sum[:, db_idx[:, 1]])\n\n    return (np.append(beta_mu, beta_mu_db, axis=-1), \n            np.append(beta_sum, beta_sum_db, axis=-1))\n\n\ndef add_doublet_GT(GT_prob):\n    \"\"\"\n    Add doublet genotype by summarizing their probability:\n    New GT has five categories: 0, 1, 2, 1.5, 2.5\n    TODO: New GT has six categories: 0, 1, 2, 0_1, 0_2, 1_2\n    \"\"\"\n    combn_iter = itertools.combinations(range(GT_prob.shape[2]), 2)\n    gt_idx = np.array([x for x in combn_iter]) # GT combination\n    g_idx1 = gt_idx[:, 0]\n    g_idx2 = gt_idx[:, 1]\n\n    combn_iter = itertools.combinations(range(GT_prob.shape[1]), 2)\n    sp_idx = np.array([x for x in combn_iter]) # sample combination\n    s_idx1 = sp_idx[:, 0]\n    s_idx2 = sp_idx[:, 1]\n    \n    ## GT_prob has three genotypes: 0, 1, 2;\n    n_gt = GT_prob.shape[2]\n    GT_prob2 = np.zeros((GT_prob.shape[0], sp_idx.shape[0],\n                         n_gt + gt_idx.shape[0]))\n\n    GT_prob2[:, :, :n_gt] = (GT_prob[:, s_idx1, :] * \n                             GT_prob[:, s_idx2, :])\n    GT_prob2[:, :, n_gt:] = (GT_prob[:, s_idx1, :][:, :, g_idx1] * \n                             GT_prob[:, s_idx2, :][:, :, g_idx2] +\n                             GT_prob[:, s_idx1, :][:, :, g_idx2] * \n                             GT_prob[:, s_idx2, :][:, :, g_idx1])\n    \n    GT_prob2 = normalize(GT_prob2, axis=2)\n    GT_prob1 = np.append(GT_prob, \n        np.zeros((GT_prob.shape[0], GT_prob.shape[1], gt_idx.shape[0])), axis=2)\n    return np.append(GT_prob1, GT_prob2, axis=1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_106","text":"<gh_stars>1-10\nfrom .gen_random_input import generate_and_save_test_case, generate_input_pair\nfrom . import run_algorithm\nimport multiprocessing\nimport numpy as np\nimport argparse\nimport csv\nimport random\nfrom tqdm import tqdm\nfrom copy import deepcopy\nfrom pathlib import Path\nimport shutil\nimport json\nimport sys\nimport time\nimport shlex\nfrom scipy.stats import binom\nimport bisect\nfrom subprocess import TimeoutExpired\nimport math\n\ndefault_bench_dir = Path(__file__).parent \/ \"..\/test_cases\/temp_bench\"\nflush_every_seconds = 5\n\nparser = argparse.ArgumentParser(\n    description=\"Benchmark our diff algorithm with random test cases\"\n)\nsubparsers = parser.add_subparsers(title=\"subcommands\")\nparser_prepare = subparsers.add_parser(\"prepare\")\nparser_plan_batch = subparsers.add_parser(\"plan-batch\")\nparser_run = subparsers.add_parser(\"run\")\n\nparser_prepare.add_argument(\n    \"--min-file-size\",\n    type=int,\n    default=1,\n    help=\"minimum length of a single generated input sequence\",\n)\nparser_prepare.add_argument(\n    \"--max-file-size\",\n    type=int,\n    default=5000,\n    help=\"maximum length of a single generated input sequence\",\n)\nparser_prepare.add_argument(\n    \"--target-file-size-steps\",\n    type=int,\n    default=10,\n    help=\"number of different file sizes to try while keeping all other parameters fixed\",\n)\nparser_prepare.add_argument(\n    \"--max-change-strength\",\n    type=float,\n    default=1,\n    help=\"maximum change strength\",\n)\nparser_prepare.add_argument(\n    \"--target-change-strength-steps\",\n    type=int,\n    default=5,\n    help=\"number of different change strengths to try while keeping all other parameters fixed\",\n)\nparser_prepare.add_argument(\n    \"--only-change-strength\",\n    type=float,\n    default=None,\n    help=\"only change strength to benchmark with (--target-change-strength-steps must be 1 to use this option)\",\n)\nparser_prepare.add_argument(\n    \"--target-chunkiness-steps\",\n    type=int,\n    default=3,\n    help=\"number of different chunkiness levels to try while keeping all other parameters fixed\",\n)\nparser_prepare.add_argument(\n    \"--generation-strategies\",\n    type=str,\n    default=\"independent,add,remove,addremove\",\n    help=\"comma separated list of strategies for generating inputs\",\n)\nparser_prepare.add_argument(\n    \"--num-regens\",\n    type=int,\n    default=3,\n    help=\"number of times to re-generate an input using the same config\",\n)\nparser_prepare.add_argument(\n    \"--output-dir\",\n    type=Path,\n    default=default_bench_dir,\n    help=\"path to directory where to write the generated inputs for benchmarking\",\n)\n\nparser_plan_batch.add_argument(\n    \"--output-dir\",\n    type=Path,\n    required=True,\n    help=\"path to directory where to write the benchmark results as multiple CSV files\",\n)\nparser_plan_batch.add_argument(\n    \"--job-start-command-format\",\n    default=r\"bsub -n %procs% -R 'select[model==EPYC_7742]' -R 'rusage[mem=512]' -R 'span[ptile=128]' %command%\",\n    help=r\"command for starting a single batch job. %procs% and %command% will be replaced.\",\n)\nparser_plan_batch.add_argument(\n    \"--paths-relative-to\",\n    type=Path,\n    default=Path.cwd(),\n    help=\"refer to programs and files using paths relative to the supplied path\",\n)\nparser_plan_batch.add_argument(\n    \"--mpi-procs\",\n    type=int,\n    nargs=\"+\",\n    required=True,\n    help=\"number of processes to run our distributed algorithm with. If multiple (space separated) numbers are supplied, every MPI program is benchmarked for each.\",\n)\n\nparser_run.add_argument(\n    \"--output-csv\",\n    type=Path,\n    required=True,\n    help=\"path where to write the benchmark results as a CSV file\",\n)\nparser_run.add_argument(\n    \"--no-progress-bar\",\n    default=False,\n    action=\"store_true\",\n    help=\"hide the progress bar\",\n)\nparser_run.add_argument(\n    \"--no-direct-mpi-procs-limit\",\n    default=False,\n    action=\"store_true\",\n    help=\"don't pass -np to MPI run. Instead just assume that the number of processes is being limited to --mpi-procs somehow externally (eg. by a batch system). --mpi-procs is then effectively only written to the output CSV.\",\n)\nparser_run.add_argument(\n    \"--mpi-procs\",\n    type=int,\n    nargs=\"+\",\n    default=[None],\n    help=\"number of processes to run our distributed algorithm with. If multiple (space separated) numbers are supplied, every MPI program is benchmarked for each.\",\n)\n\nplan_batch_run_shared_args = set()\n\n\ndef add_plan_batch_run_shared_argument(arg_name, *args, **kwargs):\n    assert arg_name.startswith(\"--\")\n    arg_name_snake = arg_name[2:].replace(\"-\", \"_\")\n    plan_batch_run_shared_args.add(arg_name_snake)\n    for p in parser_plan_batch, parser_run:\n        p.add_argument(arg_name, *args, **kwargs)\n\n\nadd_plan_batch_run_shared_argument(\n    \"--input-dir\",\n    type=Path,\n    default=default_bench_dir,\n    help=\"path to directory where to read the generated inputs for benchmarking\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--limit-programs\",\n    type=str,\n    help=\"comma separated list of programs to benchmark\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--auto-repetitions\",\n    default=False,\n    action=\"store_true\",\n    help=\"Determine number of repetions automatically based on the confidence interval around the median\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--min-repetitions\",\n    type=int,\n    default=5,\n    help=\"minimum number of times to re-run each diff program with exactly the same input, without --auto-repetitions it is the actual number of repetitions\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--max-repetitions\",\n    type=int,\n    default=50,\n    help=\"maximum number of times to re-run each diff program with exactly the same input, only active if --auto-repetitions is given\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--max-median-error\",\n    type=float,\n    default=0.05,\n    help=\"maximal relative error of the median in the confidence interval, only active if --auto-repetitions is given\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--mpi-timeout-seconds\",\n    type=float,\n    default=60,\n    help=\"when running an MPI algorithm, stop if it takes longer than this number of seconds for a single input\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--skip-estimated-timeouts\",\n    default=False,\n    action=\"store_true\",\n    help=\"Enable skipping of larger input sizes if a smaller size already timed out with the same diff program configuration\\n\"\n    + \"Should only be used with test cases with roughly the same number of edits relative to the file size (i.e. independent test cases)\",\n)\nadd_plan_batch_run_shared_argument(\n    \"--verbose\",\n    default=False,\n    action=\"store_true\",\n    help=\"print detailed information when running each benchmark\",\n)\n\nconfidence_level = 0.95\nmin_repetitions_for_confidence = (\n    6  # 6 for confidence level = 0.95, 8 for confidence level = 0.99\n)\n\n\nclass CSVOutputWriter:\n    def __init__(self, file):\n        self._file = file\n        self._writer = None\n\n    def write_row(self, data: dict):\n        if self._writer is None:\n            self._writer = csv.DictWriter(self._file, data.keys())\n            self._writer.writeheader()\n        self._writer.writerow(data)\n\n\nclass NpEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, np.integer):\n            return int(obj)\n        elif isinstance(obj, np.floating):\n            return float(obj)\n        elif isinstance(obj, np.ndarray):\n            return obj.tolist()\n        else:\n            return super(NpEncoder, self).default(obj)\n\n\nclass NoopProgressBar:\n    def update(*args, **kwargs):\n        pass\n\n    def close(*args, **kwargs):\n        pass\n\n\ndef get_diff_programs_for_args(args):\n    diff_programs = run_algorithm.sequential_diff_programs.copy()\n    for program_template in run_algorithm.mpi_diff_programs:\n        for mpi_procs in args.mpi_procs:\n            program = deepcopy(program_template)\n            assert \"extra_fields\" not in \"program\"\n            program[\"extra_fields\"] = {\n                \"mpi_procs\": mpi_procs,\n                \"timeout_seconds\": args.mpi_timeout_seconds,\n            }\n            diff_programs.append(program)\n\n    if args.limit_programs is not None:\n        diff_programs = run_algorithm.limit_diff_programs(\n            diff_programs,\n            args.limit_programs,\n            \"unknown program names passed to --limit-programs\",\n        )\n\n    return diff_programs\n\n\ndef get_generation_strategies_for_args(args):\n    all_generation_strategies = {\"independent\", \"add\", \"remove\", \"addremove\"}\n    selected_generation_strategies = {\n        s.strip() for s in args.generation_strategies.strip().split(\",\")\n    }\n    unsupported_generation_strategies = (\n        selected_generation_strategies - all_generation_strategies\n    )\n    if unsupported_generation_strategies:\n        raise ValueError(\n            f\"unsupported values for --generation-strategies: {', '.join(sorted(unsupported_generation_strategies))}\"\n        )\n    return sorted(selected_generation_strategies)\n\n\ndef prepare_benchmark(args):\n    file_size_steps = np.linspace(\n        args.min_file_size, args.max_file_size, args.target_file_size_steps\n    )\n    file_size_steps = np.unique(np.floor(file_size_steps).astype(int))\n\n    if args.only_change_strength is not None:\n        assert args.target_change_strength_steps == 1\n        change_strength_steps = np.array([args.only_change_strength])\n    else:\n        change_strength_steps = np.linspace(\n            0, args.max_change_strength, args.target_change_strength_steps + 1\n        )[1:]\n\n    chunkiness_steps = np.linspace(0, 1, args.target_chunkiness_steps)\n\n    generation_strategies = get_generation_strategies_for_args(args)\n\n    all_generation_configs = []\n    for file_size in file_size_steps:\n        for generation_strategy in generation_strategies:\n            if generation_strategy == \"independent\":\n                generation_config = {\n                    \"strategy\": generation_strategy,\n                    \"length_1\": file_size,\n                    \"change_strength\": 1,\n                    \"chunkiness\": 0,\n                    \"distribution\": \"zipf\",\n                }\n                all_generation_configs.append(generation_config)\n\n            else:\n                for change_strength in change_strength_steps:\n                    for chunkiness in chunkiness_steps:\n                        generation_config = {\n                            \"strategy\": generation_strategy,\n                            \"length_1\": file_size,\n                            \"change_strength\": change_strength,\n                            \"chunkiness\": chunkiness,\n                            \"distribution\": \"zipf\",\n                        }\n                        all_generation_configs.append(generation_config)\n\n    print(f\"{len(all_generation_configs)} unique test cases\")\n\n    shuffled_generation_configs = list(\n        {\"i\": i, \"config\": c} for i, c in enumerate(all_generation_configs)\n    )\n    random.shuffle(shuffled_generation_configs)\n\n    shutil.rmtree(args.output_dir, ignore_errors=True)\n    args.output_dir.mkdir()\n    with (args.output_dir \/ \"index.json\").open(\"w\", encoding=\"utf-8\") as f:\n        json.dump(\n            {\n                \"shuffled_generation_configs\": shuffled_generation_configs,\n                \"num_regens\": args.num_regens,\n            },\n            f,\n            cls=NpEncoder,\n        )\n\n    assert args.num_regens >= 1\n    gen_combination_factors = [len(all_generation_configs), args.num_regens]\n    total_gen_combinations = np.prod(gen_combination_factors)\n    print(\n        f'{\" * \".join(str(v) for v in gen_combination_factors)} = {total_gen_combinations} total input file pairs'\n    )\n\n    progress_bar = tqdm(total=total_gen_combinations)\n    for entry in shuffled_generation_configs:\n        for regen_i in range(args.num_regens):\n            test_case_dir = args.output_dir \/ f\"config-{entry['i']}-regen-{regen_i}\"\n            test_case_dir.mkdir()\n            for i, values in enumerate(generate_input_pair(**entry[\"config\"])):\n                with (test_case_dir \/ f\"in_{i + 1}.txt\").open(\n                    \"w\", encoding=\"utf8\"\n                ) as f:\n                    for v in values:\n                        f.write(f\"{v}\\n\")\n            progress_bar.update()\n\n    progress_bar.close()\n\n\ndef plan_batch_benchmark(args):\n    diff_programs = get_diff_programs_for_args(args)\n\n    assert r\"%procs%\" in args.job_start_command_format\n    assert r\"%command%\" in args.job_start_command_format\n\n    def path_to_str(p):\n        return str(p.resolve().relative_to(args.paths_relative_to.absolute()))\n\n    def join_command(split_command):\n        return \" \".join(shlex.quote(arg) for arg in split_command)\n\n    job_start_commands = []\n    for program in diff_programs:\n        mpi_procs = program.get(\"extra_fields\", {}).get(\"mpi_procs\", None)\n        batch_procs = 1 if mpi_procs is None else mpi_procs\n        assert isinstance(batch_procs, int)\n\n        bench_command = [\n            \"python\",\n            \"-m\",\n            \"scripts.bench_algorithm\",\n            \"run\",\n            \"--limit-programs\",\n            program[\"name\"],\n            \"--input-dir\",\n            path_to_str(args.input_dir),\n            \"--mpi-timeout-seconds\",\n            str(args.mpi_timeout_seconds),\n            \"--min-repetitions\",\n            str(args.min_repetitions),\n            \"--max-repetitions\",\n            str(args.max_repetitions),\n            \"--max-median-error\",\n            str(args.max_median_error),\n            \"--output-csv\",\n            path_to_str(args.output_dir \/ f'{program[\"name\"]}_{batch_procs}.csv'),\n        ]\n\n        if mpi_procs is not None:\n            bench_command += [\n                \"--mpi-procs\",\n                str(mpi_procs),\n            ]\n\n        if args.auto_repetitions:\n            bench_command += [\"--auto-repetitions\"]\n\n        if args.skip_estimated_timeouts:\n            bench_command += [\"--skip-estimated-timeouts\"]\n\n        if args.verbose:\n            bench_command.append(\"--verbose\")\n\n        # use fullnodes -> make batch_procs multiple of 128\n        batch_procs = -(-batch_procs \/\/ 128) * 128\n\n        job_start_command = args.job_start_command_format.replace(\n            r\"%procs%\",\n            str(batch_procs),\n        ).replace(\n            r\"%command%\",\n            shlex.quote(join_command(bench_command)),\n        )\n\n        job_start_commands.append(job_start_command)\n\n    print(join_command([\"mkdir\", \"-p\", path_to_str(args.output_dir)]))\n    for job_start_command in job_start_commands:\n        print(job_start_command)\n\n\ndef run_benchmark(args):\n    def verbose_print(*a, **kw):\n        if args.verbose:\n            print(*a, **kw)\n\n    diff_programs = get_diff_programs_for_args(args)\n\n    all_diff_program_extra_fields = sorted(\n        {k for p in diff_programs for k in p.get(\"extra_fields\", {}).keys()}\n    )\n    print(f\"{len(diff_programs)} diff programs\")\n\n    try:\n        with (args.input_dir \/ \"index.json\").open(\"r\", encoding=\"utf-8\") as f:\n            benchmark_input_index = json.load(f)\n    except Exception:\n        print('Failed to load benchmark inputs. Did you run \"prepare\"?')\n        raise\n    shuffled_generation_configs = benchmark_input_index[\"shuffled_generation_configs\"]\n    num_regens = benchmark_input_index[\"num_regens\"]\n    assert num_regens >= 1\n\n    test_combination_factors = [\n        len(shuffled_generation_configs),\n        num_regens,\n        len(diff_programs),\n        # don't count number of repetitions, because it is possibly dynamic\n    ]\n    total_test_combinations = np.prod(test_combination_factors)\n    print(\n        f'{\" * \".join(str(v) for v in test_combination_factors)} = {total_test_combinations} total test combinations'\n    )\n\n    csv_output_file = open(args.output_csv, \"w\", newline=\"\")\n    csv_output_writer = CSVOutputWriter(csv_output_file)\n\n    def get_extra_file_path(suffix):\n        name = \".\".join(args.output_csv.name.split(\".\")[:-1]) + suffix\n        return args.output_csv.parent \/ name\n\n    failed_file_path = get_extra_file_path(\"-FAILED.txt\")\n    failed_file = open(failed_file_path, \"w\")\n\n    if args.auto_repetitions:\n        num_repetitions = args.max_repetitions\n    else:\n        num_repetitions = args.min_repetitions\n\n    if args.no_progress_bar:\n        progress_bar = NoopProgressBar()\n    else:\n        progress_bar = tqdm(total=total_test_combinations, smoothing=0)\n\n    if args.skip_estimated_timeouts:\n        # record smallest input length with timeout per diff_program to skip larger test cases\n        smallest_timeout = {}\n\n    last_flush_time = time.monotonic()\n    break_flag = False\n    some_benchmarks_failed = False\n    for _entry in shuffled_generation_configs:\n        generation_config_i = _entry[\"i\"]\n        generation_config = _entry[\"config\"]\n\n        for regen_i in range(num_regens):\n            verbose_print(\"generation_config\", generation_config)\n            test_case_dir = (\n                args.input_dir \/ f\"config-{generation_config_i}-regen-{regen_i}\"\n            )\n\n            for diff_program in diff_programs:\n\n                diff_prog_full_name = (\n                    diff_program[\"name\"]\n                    + \"_\"\n                    + str(diff_program.get(\"extra_fields\", {}).get(\"mpi_procs\", 1))\n                )\n\n                if (\n                    args.skip_estimated_timeouts\n                    and diff_prog_full_name in smallest_timeout\n                    and generation_config[\"length_1\"]\n                    >= smallest_timeout[diff_prog_full_name]\n                ):\n                    some_benchmarks_failed = True\n                    print(diff_prog_full_name + \"\\t\", file=failed_file, end=\"\")\n                    print(generation_config, file=failed_file, end=\"\")\n                    print(\n                        f\"\\t skipped due to estimated timeout, since length_1 {generation_config['length_1']} >= {smallest_timeout[diff_prog_full_name]}\",\n                        file=failed_file,\n                    )\n                    progress_bar.update()\n                    continue\n\n                # sorted list of measurements\n                micros_until_len_res = []\n                check_interval = min_repetitions_for_confidence - 1\n\n                for repetition_i in range(num_repetitions):\n                    if time.monotonic() - last_flush_time > flush_every_seconds:\n                        csv_output_file.flush()\n                        failed_file.flush()\n                        last_flush_time = time.monotonic()\n\n                    verbose_print(\"  diff_program\", diff_program[\"name\"])\n\n                    extra_fields_for_output = {\n                        k: diff_program.get(\"extra_fields\", {}).get(k, \"\")\n                        for k in all_diff_program_extra_fields\n                    }\n\n                    extra_fields_for_run = deepcopy(\n                        diff_program.get(\"extra_fields\", {})\n                    )\n                    if (\n                        args.no_direct_mpi_procs_limit\n                        and \"mpi_procs\" in extra_fields_for_run\n                    ):\n                        extra_fields_for_run[\"mpi_procs\"] = None\n\n                    try:\n                        program_result = diff_program[\"run\"](\n                            test_case_dir \/ \"in_1.txt\",\n                            test_case_dir \/ \"in_2.txt\",\n                            extra_fields_for_run,\n                        )\n                        verbose_print(\n                            \"    micros_until_len\", program_result.micros_until_len\n                        )\n                    except KeyboardInterrupt:  # exit the benchmark\n                        break_flag = True\n                        break\n                    except TimeoutExpired as te:\n                        some_benchmarks_failed = True\n                        print(diff_prog_full_name + \"\\t\", file=failed_file, end=\"\")\n                        print(generation_config, file=failed_file, end=\"\")\n                        print(\"\\t\" + repr(te), file=failed_file)\n                        if args.auto_repetitions:\n                            timeout_micros = te.timeout * 1e6  # seconds to microseconds\n                            if (\n                                repetition_i >= 5\n                                and micros_until_len_res[0] == timeout_micros\n                            ):\n                                if args.skip_estimated_timeouts:\n                                    smallest_timeout[\n                                        diff_prog_full_name\n                                    ] = generation_config[\"length_1\"]\n                                break  # if five iterations timed out -> assume all will timeout, don't try again\n                            micros_until_len_res.append(timeout_micros)\n                        else:\n                            if args.skip_estimated_timeouts:\n                                smallest_timeout[\n                                    diff_prog_full_name\n                                ] = generation_config[\"length_1\"]\n                        continue\n                    except Exception as e:  # catch all\n                        some_benchmarks_failed = True\n                        print(diff_prog_full_name + \"\\t\", file=failed_file, end=\"\")\n                        print(generation_config, file=failed_file, end=\"\")\n                        print(\"\\t\" + repr(e), file=failed_file)\n                        break  # assumption: will always fail with these exceptions -> no need to run all repetitions\n\n                    output_data = {\n                        \"generation_config_i\": generation_config_i,\n                        **{f\"input_{k}\": v for k, v in generation_config.items()},\n                        \"regen_i\": regen_i,\n                        \"repetition_i\": repetition_i,\n                        \"diff_program\": diff_program[\"name\"],\n                        **extra_fields_for_output,\n                        \"mpi_comm_world\": getattr(program_result, \"mpi_comm_world\", 1),\n                        \"micros_input\": program_result.micros_input,\n                        \"micros_precompute\": program_result.micros_precompute,\n                        \"micros_until_len\": program_result.micros_until_len,\n                        \"micros_edit_script\": program_result.micros_edit_script,\n                        \"min_edit_length\": program_result.min_edit_length,\n                    }\n\n                    csv_output_writer.write_row(output_data)\n\n                    if args.auto_repetitions:\n                        bisect.insort(\n                            micros_until_len_res, program_result.micros_until_len\n                        )\n\n                        if (\n                            repetition_i >= args.min_repetitions\n                            and repetition_i % check_interval == 0\n                        ) or repetition_i == num_repetitions - 1:  # reached the last iteration\n                            # check if required confidence interval is reached\n                            if repetition_i % 2 == 0:  # odd number of results\n                                current_median = micros_until_len_res[repetition_i \/\/ 2]\n                            else:\n                                current_median = (\n                                    micros_until_len_res[(repetition_i - 1) \/\/ 2]\n                                    + micros_until_len_res[(repetition_i + 1) \/\/ 2]\n                                ) \/ 2\n\n                            # check about every 20 ms = 20'000 microseconds  (overhead is about 1 ms)  => max 5% overhead\n                            check_interval = math.ceil(20000 \/ current_median)\n\n                            lower_idx, upper_idx = binom.interval(\n                                confidence_level, repetition_i + 1, 0.5\n                            )\n                            # to get correct indices in python (Boudec paper Appendix A - 1)\n                            lower_idx -= 1\n                            # sometimes the interval is a little bit wider than in the Boudec paper, but this just means more confidence\n\n                            if (\n                                micros_until_len_res[int(lower_idx)]\n                                >= (1 - args.max_median_error) * current_median\n                                and micros_until_len_res[int(upper_idx)]\n                                <= (1 + args.max_median_error) * current_median\n                            ):\n                                break\n\n                            if repetition_i == num_repetitions - 1:\n                                # failed to reach required confidence\n                                some_benchmarks_failed = True\n                                print(\n                                    diff_prog_full_name + \"\\t\",\n                                    file=failed_file,\n                                    end=\"\",\n                                )\n                                print(generation_config, file=failed_file, end=\"\")\n                                print(\n                                    \"\\t\"\n                                    + f\"Failed to reach required confidence after {num_repetitions} repetitions; \"\n                                    + f\"current median: {current_median}, left end of CI: {micros_until_len_res[int(lower_idx)]}, right end of CI: {micros_until_len_res[int(upper_idx)]}\",\n                                    file=failed_file,\n                                )\n\n                progress_bar.update()\n\n                if break_flag:\n                    break\n            if break_flag:\n                break\n        if break_flag:\n            break\n\n    progress_bar.close()\n    csv_output_file.close()\n    failed_file.close()\n\n    if not some_benchmarks_failed:\n        failed_file_path.unlink()\n\n\nparser_prepare.set_defaults(func=prepare_benchmark)\nparser_run.set_defaults(func=run_benchmark)\nparser_plan_batch.set_defaults(func=plan_batch_benchmark)\n\nif __name__ == \"__main__\":\n    if len(sys.argv) == 1:\n        print(\"subcommand is required\")\n        parser.print_usage()\n        exit(1)\n    args = parser.parse_args()\n    args.func(args)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_107","text":"<reponame>zekearneodo\/ceciestunepipe<filename>ceciestunepipe\/util\/spikeextractors\/preprocess.py\nimport numpy as np\nimport pandas as pd\nimport logging\n\nfrom scipy.io import wavfile\nfrom ceciestunepipe.file import bcistructure as et\n\nfrom ceciestunepipe.util import sglxutil as sglu\nfrom ceciestunepipe.util import rigutil as ru\nfrom ceciestunepipe.util.spikeextractors.extractors.spikeglxrecordingextractor import spikeglxrecordingextractor as sglex\n\nlogger = logging.getLogger('ceciestunepipe.util.spikeextractors.preprocess')\n\ndef load_sglx_recordings(exp_struct: dict, epoch:str) -> tuple:\n    # get the folders\n    # make a pandas of the files\n    # read into spikextractors\n    # get the rig parameters\n    # extract the wav channels of the nidaq signals (mics, syn)\n\n    sgl_folders, sgl_files = sglu.sgl_file_struct(exp_struct['folders']['sglx'])\n    #logger.info('loading files {}'.format(sgl_files))\n    files_pd = pd.DataFrame(sgl_files)\n\n    i_run = 0 #spikeglx epochs have the one run, this is for later\n    run_meta_files = {k: v[i_run] for k, v in sgl_files.items()}\n    run_recordings = {k: sglex.SpikeGLXRecordingExtractor(sglu.get_data_meta_path(v)[0]) for k, v in run_meta_files.items()}\n    rig_dict = ru.get_rig_par(exp_struct)\n\n    return run_recordings, run_meta_files, files_pd, rig_dict \n\ndef extract_nidq_channels(sess_par, run_recs_dict, rig_dict, chan_name_list, chan_type='adc') -> np.array:\n    # get the channels id, numbers for the mic_list\n    chan_n_list = [int(ru.lookup_signal(rig_dict, n)[1].split('-')[-1]) for n in chan_name_list]\n    \n    if chan_type=='adc':\n        stream = run_recs_dict['nidq'].get_traces(channel_ids=chan_n_list)\n    elif chan_type=='ttl':\n        stream = run_recs_dict['nidq'].get_ttl_traces()[chan_n_list, :]\n    else:\n        raise NotImplementedError('dont know how to deal with {} channels'.format(chan_type))\n    \n    return stream\n\ndef save_wav(stream: np.array, s_f: np.float, wav_path: str) -> int:\n    \n    wav_s_f = int(round(s_f\/1000))*1000\n    logger.info('sampling rate {}'.format(wav_s_f))\n    \n    # write to wav\n    logger.info('saving {}-shaped array as wav in {}'.format(stream.shape, wav_path))\n    os.makedirs(os.path.split(wav_path)[0], exist_ok=True)\n    wavfile.write(wav_path, wav_s_f, stream.T)\n    \n    ## also save as numpy\n    npy_path = wav_path.split('.')[0] + '.npy'\n    logger.info('saving {}-shaped array as npy in {}'.format(stream.shape, npy_path))\n    np.save(npy_path, stream.T)\n    return wav_s_f\n\ndef chans_to_wav(recording_extractor, chan_list: list, wav_path:str) -> int:\n    # get the stream\n    data_stream = recording_extractor.get_traces(channel_ids=chan_list)\n    # make sure folder exists\n    logger.info('saving {}-shaped array as wav in {}'.format(data_stream.shape, wav_path))\n    os.makedirs(os.path.split(wav_path)[0], exist_ok=True)\n    # write it\n    s_f = int(round(recording_extractor.get_sampling_frequency()\/1000))*1000\n    logger.info('sampling rate {}'.format(s_f))\n    wavfile.write(wav_path, s_f, data_stream.T)\n    \n    ## also save as numpy\n    npy_path = wav_path.split('.')[0] + '.npy'\n    logger.info('saving {}-shaped array as npy in {}'.format(data_stream.shape, npy_path))\n    np.save(npy_path, data_stream.T)\n    return s_f"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_108","text":"<gh_stars>0\nimport numpy as np\nfrom scipy.io import mmread\n\ndef is_pos_def(x):\n    \"\"\"check if a matrix is symmetric positive definite\"\"\"\n    return np.all(np.linalg.eigvals(x) > 0)\n\ndef check_symmetric(x, tol=1e-8):\n    return np.all(np.abs(x-x.T) < tol)\n\ndef precon(A):\n    M_inv = np.diag(np.diag(A))\n    for i in range(A.shape[0]):\n        M_inv[i,i] = 1.0 \/ A[i,i]    \n    return M_inv\n\nA = mmread('\/home\/anaxsouza\/Documents\/GitHub\/coc757_Trabalho_05\/bcsstk16.mtx').todense()\nb = np.ones((A.shape[0], 1))\nx = np.ones((A.shape[0], 1))\nM_inv = precon(A)\ni_max = 20000\nepsilon = np.finfo(float).eps\n\ni = 0\nr = b - A @ x\nz = M_inv @ r\ndelta = z.T @ r\ndelta_0 = delta\n\n#if (is_pos_def(A) == False) | (check_symmetric(A) == False):\n    #raise ValueError('Matrix A needs to be symmetric positive definite (SPD)')\nwhile (i < i_max) and (delta > (epsilon ** 2)*delta_0):\n    q = A @ z\n    alpha = delta\/(z.T @ q)\n    alpha = alpha.item()\n    x = x + alpha * z\n    if (i % 50 == 0):\n        print(i)        \n        r = b - A @ x\n    else:\n        r = r - alpha * q\n    z = M_inv @ r\n    delta = z.T @ r\n    i += 1\nprint('\\ni:\\n',i)\nprint('\\nx:')\nprint(x)\nprint(x.shape)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_109","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Jan 26 12:23:55 2019\n\n@author: jxf\n\n\"\"\"\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport datetime\n#has incomplete data. 999 points are NaN\ndef read_file(fname):\n    with open(fname, \"r\") as f:\n        try:\n            line1= f.readline().split()\n        except Exception as e:\n            raise Exception(\"problem reading first line of file %s\"%fname) from e\n        if line1[0] not in (\"YY\",\"#YY\",\"YYYY\"):\n            raise Exception(\"bad header line 1 for file %s: '%s'\"%(fname,line1))\n        try:\n            line2= f.readline().split()\n        except Exception as e:\n            raise Exception(\"problem reading second line of file %s\"%fname) from e\n        try:\n            int(line2[0])\n            has_second_header= False\n            header= 0\n        except ValueError:\n            if line2[0]in (\"#yy\",\"#yr\"):\n                has_second_header=True\n                header=[0,1]\n            else:\n                raise Exception(\"unexpected second header in file %s\"%fname)\n \n    #this gives it a second header\n    df= pd.read_csv(fname, sep='\\s+', header= header)#allows you to read the file\n    if has_second_header:\n        df.columns = [h1 for (h1, h2) in df.columns]\n    def mkyear(v):\n        v = int(v)\n        if v<100:\n            return 1900 + v\n        else:\n            return v\n    if 'mm' in df.columns:\n        df['timestamp']=df.apply(lambda s:datetime.datetime(mkyear(s[0]), int(s[1]), int(s[2]), int(s[3]), int(s[4])),\n                                 axis=1)\n    else:\n        df['timestamp']=df.apply(lambda s:datetime.datetime(mkyear(s[0]), int(s[1]), int(s[2]), int(s[3]), 0),\n                                 axis=1)        \n    df['ATMP'] = df['ATMP'].apply(lambda v:np.NaN if v>100 else v) # 999 is used to indicate no data available\n    df['WTMP'] = df['WTMP'].apply(lambda v:np.NaN if v>100 else v) # 999 is used to indicate no data available  \n    print(\"%s has %d entries\" % (fname, len(df)))\n    return df\n\ndef build_median_df(df, base_col, year,\n                    index=['01-Jan', '02-Feb', '03-Mar', '04-Apr', '05-May', '06-Jun',\n                           '07-Jul', '08-Aug', '09-Sep', '10-Oct', '11-Nov', '12-Dec']):\n    if 'YY' in df.columns:\n        df = df[(df['YY']==year) | (df['YY']==(year-1900))].copy()\n    elif '#YY' in df.columns:\n        df = df[df['#YY']==year].copy()\n    elif 'YYYY' in df.columns:\n        df = df[df['YYYY']==year].copy()\n    else:\n        assert 0, \"Did not find a year column in %s for %s\" % (df.columns, year)\n    grouped=df.groupby(pd.Grouper(key = \"timestamp\", freq=\"M\")).agg({base_col:['median']})\n    grouped.columns=['%s %s median'%(year, base_col)]\n    grouped['month'] = index\n    grouped.set_index('month', drop=True, inplace=True)\n    return grouped\n\ndef load_preprocessed_file(buoyno):\n        filename=\"..\/intermediate-data\/processed_%s.csv.gz\"%buoyno\n        return pd.read_csv(filename,parse_dates=[\"timestamp\"],\n               index_col=\"timestamp\", usecols=[\"ATMP\",\"WTMP\",\"timestamp\"],header=0)\n        \ndef get_monthly_averages(df):\n    monthly=df.resample(\"M\").mean()\n    monthly.index = [pd.Period(str(ts)[0:7]) for ts in monthly.index]\n    return monthly\n\nMONTH_NAMES = {1:'Jan', 2:'Feb', 3:'Mar', 4:'Apr', 5:'May', 6:'Jun',\n               7:'Jul', 8:'Aug', 9:'Sep', 10:'Oct', 11:'Nov', 12:'Dec'}\ndef monthly_computation(monthly, monthno, field):\n    mask = monthly.index.map(lambda x:x.month)==monthno\n    anomaly = monthly[mask][field] - (monthly[mask][field].mean())\n    anomaly.index = [pd.Period(year=int(str(ym)[0:4]), freq='Y')\n                     for ym in anomaly.index]\n    return anomaly.rename(MONTH_NAMES[monthno])\n\n\ndef compute_anomalies(monthly, field):\n    return pd.DataFrame([monthly_computation(monthly, m, field)\n                         for m in range(1, 13)])\n        \ndef plot_anomaly_graph(buoyno, temptype, anomalies):\n    yearly_means = anomalies.mean()\n    import scipy.stats\n    slope, intercept, r_value, p_value, std_err = scipy.stats.linregress([i for (i, y) in enumerate(yearly_means.index)], yearly_means)\n    fit_type = 'least squares fit'\n    if np.isnan(slope):\n        # If we cannot infer a straight line, just connect the endpoints\n        print(\"Unable to fit a line\")\n        first_year = yearly_means.index[0]\n        last_year = yearly_means.index[-1]\n        print(\"Creating a line just using the endpoint years (%s, %s)\" %\n              (first_year, last_year))\n        (slope, intercept) = np.polyfit([0, last_year-first_year], [yearly_means[0], yearly_means[-1]], 1)\n        fit_type = 'endpoint fit'\n    values = [i*slope+intercept for i in range(len(yearly_means.index))]\n    linear_series = pd.Series(data=values, index=yearly_means.index, name='linear fit')\n    pd.DataFrame({'yearly anomaly':yearly_means, fit_type:linear_series}).plot(figsize=(12,10));\n    plt.scatter(yearly_means.index, yearly_means)\n    plt.title('Yearly mean anomaly %s temperature for buoy %s (slope=%0.2f degrees\/decade)' % \n              (temptype, buoyno, slope*10));\n    plt.ylabel('Degrees C');\n    plt.savefig('..\/results\/%s-%stemp-anomly.pdf' % (buoyno, temptype))\n    plt.savefig('..\/results\/%s-%stemp-anomly.png' % (buoyno, temptype))\n    return slope*10 # the temp anomaly change per decade in degrees C    \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_111","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Jun 10 07:15:59 2020\n\n @author: <NAME>\n\n\nDescription: Code for testing different datasets (It is all in the noise) and ISO NE\nwith different multitask GP configurations from the original code of KronSum\n\n \"\"\"\n\n\n\n\nimport math\nimport sys\nimport numpy as np\nimport numpy.matlib\nimport time\nimport scipy as SP\nimport os\nimport torch\nimport gpytorch\nfrom matplotlib import pyplot as plt\nimport pathlib as Path\nfrom os import listdir\nimport pandas as pd\n#from  histogram_errors import  histogram_errors\n\nProjectPath = Path.Path.cwd()\nutilsPath = Path.Path.joinpath(ProjectPath,\"utils\")\nprobsUtilsPath = Path.Path.joinpath(ProjectPath,\"Prob-utils\")\nResultsPath = Path.Path.joinpath(ProjectPath,\"Results\")\n\n\nUTIL_DIR = utilsPath\nsys.path.append(\n    str(UTIL_DIR)\n)\n\nUTIL_DIR_GEN = probsUtilsPath\nsys.path.append(\n    str(UTIL_DIR_GEN)\n)\n\nRESULTS_DIR_GEN = ResultsPath\nsys.path.append(\n    str(RESULTS_DIR_GEN)\n)\n\nfrom EvaluateConfidenceIntervals import EvaluateConfidenceIntervals\nfrom StandarizeData import StandarizeData\nfrom DeStandarizeData import DeStandarizeData\nfrom MAPE import MAPE\nfrom GP24I_v4 import GP24I\nfrom GPind import GPind\nfrom GPind_ori import GPind_ori\nfrom predGPind_ori import predGPind_ori\nfrom GPind_lap import GPind_lap\nfrom predGPK import predGPK\nfrom predGPind_lap import predGPind_lap\nfrom GPKtorch import GPKtorch\nfrom predGPind import predGPind\nfrom load_obj import load_obj\nfrom save_obj import save_obj\nfrom sklearn.metrics import r2_score\nfrom data_to_torch import data_to_torch\nfrom norm2laplace import norm2laplace\nfrom EvaluateConfidenceIntervals_Laplace import EvaluateConfidenceIntervals_Laplace\nfrom outliers_removal import outliers_removal\nfrom load_configuration import load_configuration\nfrom load_configuration_job_array import load_configuration_job_array\nfrom print_configuration import print_configuration\nfrom correcting_factor_cov import correcting_factor_cov\nfrom correcting_factor_cov_gamma import correcting_factor_cov_gamma\nfrom predictive_variance_white import predictive_variance_white\nfrom  print_extra_methods import  print_extra_methods\nfrom GP24I_v4 import GP24I\nfrom GPMT import GPMT\nfrom to_torch import to_torch\nfrom predGPMT import predGPMT\nfrom print_results_ic import print_results_ic\n# #Load Power Load Data =========================================================\n# #==============================================================================\nmethod = \"NMF\"  # Full\nmethodfile = 'NMF'\nkernel_type = \"rbf\"\nforecast_method = \"gpmt\" # gp_ind_ori\/gp_ind\/gpk\/gp_ind_laplace\/gpmt\noption_lv = \"gp_ind_ori\" # gp_ind_ori\/gpmt\n\nEXPERIMENT = 3  # This has to do with the verion of the NMF generated\nTaskNumber = 24\nStand = True\n#folder_data_name = \"Exp_\"+str(EXPERIMENT)\nfolder_data_name = \"BuenosResNMF\"\n#LOCATIONS = ['ME','CT','NH','RI','NEMASSBOST','SEMASS','VT','WCMASS']\n\ndatapath = Path.Path.joinpath(ProjectPath,\"Data\",folder_data_name)\n#datapath = Path.Path.joinpath(ProjectPath,\"Data\",folder_data_name,\"NMF\")\nDATAPATH = str(datapath)\nonlyfilesALL = [f for f in listdir(DATAPATH) if f.endswith('.pkl')]\n\n#[onlyfiles,opt_parameters,forecast_method] = load_configuration(sys.argv,onlyfilesALL,forecast_method)    \n[onlyfiles,opt_parameters, forecast_method, option_lv,location,lr1,trainsize] = load_configuration_job_array(sys.argv,onlyfilesALL)\nif forecast_method == \"gpk\":\n    name_forecast_method = forecast_method +\"_\" +option_lv\nelse:\n    name_forecast_method = forecast_method\n\ngpytorch.settings.max_cg_iterations._set_value(10000)\n\n\nRESULTS = {}\nfor archivo in range(len(onlyfiles)):\n    Results = {'R224': [],'mapes':[],'mapemedio':[],'training_time':[],'test_time':[],\n               'Ypred':[],'Vpred':[],'likelihood':[],'ICs':[],'ICs_lap1':[],'ICs_lap2':[],'gpk':[]}\n\n   \n    # LOAD DATA================================================================\n    file_name = onlyfiles[archivo]\n    file_path = Path.Path.joinpath(datapath,file_name)\n    FILE_PATH = str(file_path)\n    DATA = load_obj(FILE_PATH)\n    DATA = data_to_torch(DATA)\n    print(FILE_PATH)\n    \n\n    XTrain = DATA['X_Train_Val'].T    # N x F ### torch.from_numpy\n    YTrain = DATA['Y_Train_Val']           \n    XTest = DATA['X_Test'].T           # N x F           \n    YTest = DATA['Y_Test']           # N x K             \n    YTest_24 = DATA['Y_Test_24']     # N x T         \n    YTrain_24 = DATA['Y_Train_Val_24']     \n    TaskNumber = np.size(DATA['Wtrain_load'],1)\n    WTrain = to_torch(DATA['Wtrain_load'])\n    Stds_train_load = DATA['Stds_train_load']\n    Ntest = np.size(YTest_24,0)\n    Ntrain = np.size(YTrain_24,0)\n\n    #[XTrain,XTest,YTrain_24,YTest_24] = outliers_removal(XTrain,XTest,YTrain_24,YTest_24)\n    \n\n    # nn = 10\n    # YTrain_24_std = np.divide(YTrain_24,np.matlib.repmat(Stds_train_load.T,Ntrain,1))\n    # YTrain24M  = YTrain_24[0:nn,:]\n    # YTrainstd24M  = YTrain_24_std[0:nn,:]\n    # XTrainM = XTrain[0:nn,:]\n    # YTrainM = YTrain[0:nn,:]\n    # XTrain  = XTrainM\n    # YTrain = YTrainM\n    # YTrain_24 = YTrain24M\n    # YTrain_24_std = YTrainstd24M  \n\n    # NORMATLIZATION================================================================\n    \n    if forecast_method == \"gpk\":\n        [XTrain_S, YTrain_K_S , XTest_S, YTest_K_S,scalerX, scalerY_K]=StandarizeData(XTrain,YTrain, XTest,YTest,Standarize = Stand) \n    else:\n        [XTrain_S, YTrain_24_S , XTest_S, YTest_24_S,scalerX, scalerY_24]=StandarizeData(XTrain,YTrain_24, XTest,YTest_24,Standarize = Stand)\n\n    start = time.time()\n    # TRAINING================================================================\n    #==========================================================================\n    if forecast_method == \"gp_ind_ori\": \n        [M,L,RESULTS,model,like] = GPind_ori(XTrain_S,YTrain_24_S,24,kernel_type,opt_parameters)\n    #elif forecast_method == \"gpk\": \n    end = time.time() \n    training_time = end-start\n    #=========================================================================\n    if forecast_method == \"gpk\": \n        K = YTrain.size(1)\n        [M,L,RESULTS,model,like,ind_val] = GPKtorch(XTrain_S,YTrain_K_S,WTrain,K,kernel_type,option_lv,opt_parameters)\n        \n        #kernel =  C(10, (0.1, 200))*RBF(10, (10,200)) +C(1e-1, (1e-7, 10))  + WhiteKernel(noise_level=1e-3, noise_level_bounds=(1e-8, 1))\n        #[YPredictedS_24gpS, VPredictedS_24gpS,model,Opt_alpha, IC1, IC2, Errors, R2s, MAPEs,VarsALL,Errors_train,R2strain,Error2Validation,ErrorValidation,NoiseParameters,YvalsOpt,Y_predValsOpt,Covpredicted_Best,training_time,val_time,test_time] = GP24I(XTrainS,YTrainS,XTestS,kernel,TaskNumber,Alphas)   \n    end = time.time() \n    training_time = end-start\n    #==========================================================================\n    if forecast_method == \"gpmt\": \n        K = YTrain.size(1)\n        [M,L,RESULTS,model,like,_,_] = GPMT(XTrain,YTrain_24,24,kernel_type,opt_parameters)\n    end = time.time() \n    # TESTING==================================================================\n    #==========================================================================\n    start = time.time()  \n    if forecast_method == \"gp_ind_ori\": \n        [YPredicted_24gp_S,VPredicted_24gp_S] = predGPind_ori(XTest_S,like,model)\n    end = time.time() \n    testing_time = end-start\n    #=========================================================================\n    if forecast_method == \"gpk\": \n        [YPredictedS_KgpS,VPredicted_Kgp_S] = predGPind_ori(XTest_S,like,model)\n        [_, YPredicted_24gp_K,VPredicted_24gp_K]=DeStandarizeData(YTest_K_S,YPredictedS_KgpS,scalerY_K,VPredicted_Kgp_S,Standarize = Stand)\n        #YPredictedS_KgpS,VPredicted_Kgp_S] = predGPK(YPredicted_24gp_K,VPredicted_Kgp_S,WTrain,Stds_train_load = Stds_train_load)\n    end = time.time() \n    testing_time = end-start\n    if forecast_method == \"gpmt\": \n        [YPredicted_24gp_S,VPredicted_24gp_S] = predGPMT(XTest_S,like,model)\n        [_, YPredicted_24gp_K,VPredicted_24gp_K]=DeStandarizeData(YTest_24_S,YPredicted_24gp_S,scalerY_24,VPredicted_24gp_S,Standarize = Stand)\n        #YPredictedS_KgpS,VPredicted_Kgp_S] = predGPK(YPredicted_24gp_K,VPredicted_Kgp_S,WTrain,Stds_train_load = Stds_train_load)\n    end = time.time() \n    testing_time = end-start\n    #=========================================================================\n\n#==============================================================================\n#==============================================================================\n#==============================================================================\n    print_configuration(file_name,name_forecast_method,kernel_type,EXPERIMENT,Stand,folder_data_name)\n    if forecast_method == \"gpk\": \n        # TRANSFORMATION====\n        S2norm = torch.pow(Stds_train_load,2)\n        Snorm = Stds_train_load.T.repeat(Ntest,1)\n        Snorm_tr  = Stds_train_load.T.repeat(Ntrain,1)\n        #ErrorValidation_std_P = torch.stack(RESULTS['ValidationPredictiveErrors'],dim =1)\n        YPredicted_24gp = (YPredicted_24gp_K@WTrain.T)*Snorm\n        VPredicted_24gp = torch.zeros((Ntest,24))\n        # if 'ValidationErrors' in RESULTS:\n        #     ErrorValidation_std = torch.stack(RESULTS['ValidationErrors'],dim =1)\n        #     Nval = ErrorValidation_std.size(0)\n        #     Snorm_val = Stds_train_load.T.repeat(Nval,1)\n        #     NoiseEstimation_Variance3  = torch.var((ErrorValidation_std@WTrain.T)*Snorm_val,axis=0) \n        #     ind_a = np.random.permutation(range(0,Ntrain))[0:100]\n        #     a = correcting_factor_cov(model,WTrain,YTrain_24[ind_a,:],XTrain_S[ind_a,:],option_lv,scalerY_K,NoiseEstimation_Variance3,Stds_train_load )\n        #     a_gamma = correcting_factor_cov_gamma(model,WTrain,YTrain_24[ind_a,:],XTrain_S[ind_a,:],option_lv,scalerY_K,NoiseEstimation_Variance3,Stds_train_load )\n        #     for ss in range(0,Ntest):\n        #         VPredicted_24gp[ss,:] = (torch.diag(WTrain@torch.diag(VPredicted_24gp_K[ss,:])@WTrain.T)*(S2norm.ravel())  +  NoiseEstimation_Variance3)*a\n        #     VPredicted_24gp_white = predictive_variance_white(VPredicted_24gp_K,WTrain,NoiseEstimation_Variance3,S2norm)\n        print_extra_methods(Stds_train_load,Ntest,Ntrain,WTrain,YTrain_24,YTest_24,XTrain_S,YPredicted_24gp_K,VPredicted_24gp_K,option_lv,scalerY_K,RESULTS,model,DATA)\n    elif forecast_method == \"gp_ind_ori\":\n        [_, YPredicted_24gp,VPredicted_24gp] = DeStandarizeData(YTest_24_S,YPredicted_24gp_S,scalerY_24,VPredicted_24gp_S,Standarize = Stand)\n        [ICs,ICs_lap1,ICs_lap2] = print_results_ic(YPredicted_24gp,YTest_24,VPredicted_24gp,\"gp_ind_ori\")\n    elif forecast_method == \"gpmt\":\n        [_, YPredicted_24gp,VPredicted_24gp] = DeStandarizeData(YTest_24_S,YPredicted_24gp_S,scalerY_24,VPredicted_24gp_S,Standarize = Stand)\n        [ICs,ICs_lap1,ICs_lap2] = print_results_ic(YPredicted_24gp,YTest_24,VPredicted_24gp,\"gpmt\")\n    # METRICS==================================================================\n    \n    #histogram_errors(\"\",YPredicted_24gp,YTest_24,VPredicted_24gp)\n\n    mapes= MAPE(YTest_24,YPredicted_24gp)\n    mapemedio = torch.mean(mapes)\n\n    NTest = np.size(YTest_24,0)\n    R2_all = np.zeros((NTest,1))\n     \n    for samp in range(0,NTest):\n        R2_all[samp,0] = r2_score(YTest_24[samp,:],YPredicted_24gp[samp,:])\n    r2_24gp  = np.mean(R2_all)\n     \n    # PRINT===================================================================\n\n    print('Mape Medio 24GPs indep   ', mapemedio )\n    print('R2 24GPs i:    ',r2_24gp)\n    \n    if 'ValidationErrors' in RESULTS:\n        Lval = RESULTS['ValidationErrors']\n        Lval_tasks = [torch.mean(x) for x in Lval]\n        Lval_mean = torch.mean(torch.tensor(Lval_tasks))\n        print('Mean validation loss ',Lval_mean)\n    \n    print('Training time:   ', training_time )\n    print('Test time:   ',  testing_time)\n    #==========================================================================\n    Results['R224'] = r2_24gp\n    Results['mapes'] = mapes\n    Results['mapemedio'] = mapemedio \n    Results['training_time'] =   training_time\n    Results['test_time'] = testing_time\n    Results['Ypred'] = YPredicted_24gp\n    Results['Vpred'] = VPredicted_24gp\n    Results['likelihood'] = like\n    #Results['ICs'] = ICs\n    #Results['ICs_lap1'] = ICs_lap1\n    #Results['ICs_lap2'] = ICs_lap2\n    \n    if forecast_method == \"gpk\":\n        Results['Wtrain'] = WTrain\n    RESULTS[archivo] = Results\n    \n    file_name = \"Exp_\"+str(EXPERIMENT)+\"_lr_\"+str(lr1)+\"+_trainsize_\"+str(trainsize)+\"_loc_\"+location\n    if 'INFO' in locals():\n        file_name = \"Exp_\"+str(EXPERIMENT)+\"_lr_\"+str(lr1)+\"+_trainsize_\"+str(trainsize)+\"_loc_\"+location\n    file_results = Path.Path.joinpath(ResultsPath,file_name+\"_results\")\n    file_model = Path.Path.joinpath(ResultsPath,file_name+\"_model\")\n    file_data = Path.Path.joinpath(ResultsPath,file_name+\"_data\")\n    save_obj(RESULTS, file_results.as_posix())\n    save_obj(model, file_model.as_posix())\n    save_obj(DATA, file_data.as_posix())\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_98","text":"<filename>code\/sentence_embedding_with_bert_ranking.py\n'''\nRank the entities based on the sentence similary\n\nSteps\n\n1. Load sentence embedding first >> DONE\n2. Read the settings file and process it  >> DONE  \n3. Do embedding of question q >> TRIVIAL\n4. Do embedding of sentences containing the entities >> WIP\n5. Do coreference resolution \n6. Save the file  >> TRIVIAL\n\n'''\n\n'''\nStep 1: Load sentence embeddings\n'''\n# import basic libraries\n\n\nfrom random import randint\nimport numpy as np\nimport torch\nimport scipy\nimport json\nimport unicodedata\n\ndef remove_accented_chars(text):\n    text = unicodedata.normalize('NFKD', text).encode(\n        'ascii', 'ignore').decode('utf-8', 'ignore')\n    return text\n\n\n# Load model\nfrom sentence_transformers import SentenceTransformer\nmodel = SentenceTransformer('bert-base-nli-mean-tokens')\n\n\n\n\ndef cosine(u, v):\n    return np.dot(u, v) \/ (np.linalg.norm(u) * np.linalg.norm(v))\n\n\nprint(cosine(model.encode(['the cat eats.'])[0], model.encode(['the cat drinks.'])[0]))\n\n\n\"\"\"\nRead the entities and settings file\n\n\"\"\"\nimport yaml\nconfig_file_name = 'configure.yml'\n\n# defined it here too\nwith open(config_file_name) as config_file:\n    config_file_values = yaml.load(config_file)\n\n# Get Entitites for each question\n\nqid = config_file_values[\"qid\"]\nquesType = config_file_values[\"quesType\"]\nquesPathStart = config_file_values[\"quesPathStart\"]\ncorpusPathStart = config_file_values[\"copusPathStart\"]\nresultPathStart = config_file_values[\"resultPathStart\"]\nsamplingType = config_file_values[\"samplingType\"]\n\nfrom extract_entities import get_named_entities, get_named_entities_with_sentence\nfrom pprint import pprint\nfrom common import get_corpus_path, get_question_and_gold_answer\nimport pickle\nimport json\nimport sys\nimport en_core_web_sm\nnlp = en_core_web_sm.load()\nnlp.max_length = 1030000\n\n# Get Question type from dump file\nmap_qid_qtype_pair = {}\ninput_file_name = \"results\/quesType_finetune_\" + quesType \nwith open(input_file_name, 'r') as input_file:\n    lines = input_file.readlines() \n\nfor line in lines:\n    question_id = line.split(\"\\t\")[0]\n    spacy_tag_ques_type = line.split(\"\\t\")[2]\n    map_qid_qtype_pair[question_id] =  spacy_tag_ques_type\n\n#print(map_qid_qtype_pair)\n\n# result file map for qid and top ranked entities\nresult_file_qid_answers = {}\n\nfor i in range(150):\n    i = 121\n    ques_id = int(qid) + i\n    question, answer, ques_exact_id = get_question_and_gold_answer( ques_id, quesType, quesPathStart)\n   \n    #if i == 121:\n    #    continue\n    # hack:  ques_id looks like cqw-150-q001, corpus id 001, extract from this\n    corpus_ques_id = ques_exact_id.split('-')[2][1:]\n    print(corpus_ques_id)\n\n    corpus_path = get_corpus_path(corpus_ques_id, quesType, corpusPathStart, samplingType)\n    #tags = get_named_entities(ques_id, quesType, quesPathStart, corpus_path)\n    tags, ent_sentence_map = get_named_entities_with_sentence(ques_id, quesType, quesPathStart, corpus_path)\n\n    #pprint(tags)\n    \n    # convert the tags into list (ordered way)\n    tags_list = sorted(tags.items(), key=lambda pair: pair[1], reverse=True)\n    \"\"\"\n    output_file_name = \"results\/all_named_entities_\" + quesType\n    question, answer, ques_exact_id = get_question_and_gold_answer( ques_id, quesType, quesPathStart)\n    with open( output_file_name , 'a+') as output:\n        output.write(question + \"\\t\" + ques_exact_id + \"\\n\")\n        output.write(\"Gold Answer : \"+ \" | \".join(answer) + \"\\n\")\n        output.write(\" \\n \".join(map(str, tags_list)))\n        output.write(\"\\n\")\n        \n    \"\"\"\n    # Filter questions based on type\n    \n    spacy_tags_ques_type_list = map_qid_qtype_pair[ques_exact_id].split(\" | \")\n\n    #filtered_tag_list = [tag_items for tag_items in tags_list if tags_list[0] in spacy_tags_ques_type_list]\n    \n    # filter the tags based on the question type tag \n    filtered_tag_list = []\n    for tag_items in tags_list:\n        ent, tag = tag_items[0] \n        if(tag in spacy_tags_ques_type_list):\n            filtered_tag_list.append(tag_items)\n    \"\"\"\n    output_file_name = \"results\/filtered_named_entities_\" + quesType\n    with open( output_file_name , 'a+') as output:\n        output.write(question + \"\\t\" + ques_exact_id + \"\\n\")\n        output.write(\"Gold Answer : \"+ \" | \".join(answer) + \"\\n\")\n        output.write(\" \\n \".join(map(str, filtered_tag_list)))\n        output.write(\"\\n\")\n    #print(filtered_tag_list)\n    \"\"\"\n    #print(\"Filtered Tag List : \")\n    #print(filtered_tag_list)\n    doc_content = []\n\n    # Old Code extracting sentences\n    \"\"\"\n    for tag_items in filtered_tag_list:\n        ent, tag = tag_items[0]\n        \n        max_cosine_value = -1\n        sentences = []\n        str_sent = \"\"\n        #print(doc_content[i])\n        for i in range(0, 10): \n            sentences += get_sentence_from_entity((doc_content[i]), (ent), tag)\n        #print(sentences)\n        for sentence in sentences:\n            #print(sentence)\n            #print(sentence , cosine(model.encode([str.lower(question)])[0], model.encode([str(sentence)])[0]))\n            cosine_value = cosine(model.encode([str.lower(question)])[0], model.encode([str(sentence)])[0])\n            if cosine_value > max_cosine_value :\n                max_cosine_value = cosine_value\n                str_sent = str(sentence)\n\n        print(str_sent, max_cosine_value, ent, tag)\n    \"\"\"\n\n    result_list = []\n    # run for top k filtered tag list \n    topK_cut_off = 100\n    tag_count = 0\n    emb_len = 768 \n    for tag_items in filtered_tag_list:\n        tuple_val = tag_items[0]\n        max_cosine_value = -1 \n        str_sent = \"\"\n        #print(ent_sentence_map[tuple_val])\n        sentence_list = ent_sentence_map[tuple_val]\n        #for sentence in sentence_list:\n        #print(sentence_list)\n        #print(\"Sentence len: \", len(sentence_list))\n        sentence_embeddings  = model.encode(sentence_list)\n        #print(\"sent emb len\", len(sentence_embeddings))\n        #print(\"Sentence Shape : \", sentence_embeddings[0].shape)\n\n        ques_embedding = model.encode(question)\n         \n        #print(\"Ques shape: \", ques_embedding[0].shape)\n        #print(len(ques_embedding))\n        #sys.exit(1)\n        \"\"\"\n        for sentence, embedding in zip(sentence_list, sentence_embeddings):\n            print(\"Sentence:\", sentence)\n            print(\"Embedding:\", embedding)\n            print(\"\")\n        \"\"\"\n        #print(ques_embedding.shape)\n\n        sentence_embeddings  = np.stack(sentence_embeddings, axis = 0)\n        #print(type(sentence_embeddings))\n        #print(sentence_embeddings.shape)\n        ques_embedding = ques_embedding[0].reshape(emb_len, 1).transpose()\n        \n        #print(\"Ques shape: \", ques_embedding[0].shape)\n        #print(sentence_embeddings.shape)\n        #print(ques_embedding.shape)\n        cosine_value = scipy.spatial.distance.cdist(ques_embedding, sentence_embeddings, \"cosine\")\n        cosine_sim = 1 - cosine_value\n        #print(cosine_sim)\n        max_cosine_value = cosine_sim.max()\n        #cosine_value = cosine(model.encode([str.lower(question)])[0], model.encode([str.lower(sentence)])[0])\n            #if cosine_value > max_cosine_value :\n            #    max_cosine_value = cosine_value\n            #    str_sent = str(sentence)\n        #max_cosine_value = 1\n        #sys.exit(1)\n\n        if max_cosine_value != -1 :\n            doc_freq = tag_items[1]\n            doc_number = 10\n            score_tag_tuple = ((doc_freq \/ doc_number)* max_cosine_value,tuple_val)\n            result_list.append(score_tag_tuple)\n        #print(str_sent, max_cosine_value, tuple_val)  # print the max score of sentence and tuples\n        \n        tag_count += 1\n        if tag_count >= topK_cut_off:  # run for top k entities, change topk_cut_off if we want to include more\n            break\n    result_list = sorted(result_list, key=lambda x: x[0], reverse = True) # sort the list based on cosine values\n    \n    #exit(1)\n\n    rank_map = {}\n    top_scored_result = []\n    temp = []\n\n    for tag_items in result_list:\n        value = tag_items[0]\n        if value not in rank_map:\n            rank_map[value] = 1\n            if len(temp) != 0:\n                top_scored_result.append(\" | \".join(temp))\n                temp.clear()\n        if len(rank_map) >5:\n            break\n    \n        ent, tag = tag_items[1]\n        temp.append(str(ent))\n    \n    result_file_qid_answers[ques_exact_id] = top_scored_result\n    #print((result_file_qid_answers))\n    #exit(1)\n    if i %10 == 0:\n        print(\"Processed %d queries\" % i)\n\n    \"\"\"\n    top_scored_result = []\n    rank = 1\n    rank_map = {}\n    temp = []\n\n    for tag_items in filtered_tag_list:\n        value = tag_items[1]\n        #print(value)\n        #exit(1)    \n        \n        if value not in rank_map :\n            rank_map[value] = 1\n            if len(temp)!= 0 : \n                top_scored_result.append(\" | \".join(temp))\n                temp.clear()\n\n        if len(rank_map) > 5 :\n            break\n\n        ent, tag = tag_items[0] \n        temp.append(str.lower(ent))\n        \n    result_file_qid_answers[ques_exact_id] = top_scored_result\n    #print(len(result_file_qid_answers))\n    #exit(1)    \n        # get the only top scored named entities\n\"\"\"    \n    break\n# Remaining entities rank them based on some order\njson_object = json.dumps(result_file_qid_answers, indent = 4)\n\n\nwith open(resultPathStart + samplingType + \"_part_\" + quesType + \".json\" , \"w+\") as outfile: \n    outfile.write(json_object)\n# TODO : incorporate context while ranking\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_110","text":"from copy import deepcopy\nimport logging\nfrom math import floor\nimport os\nfrom os.path import join as pjoin\nimport warnings\nfrom warnings import warn\n\nimport numpy as np\n\nimport nibabel as nib\n\nfrom mayavi import mlab\nfrom mayavi.tools.mlab_scene_model import MlabSceneModel\nfrom mayavi.core import lut_manager\nfrom mayavi.core.scene import Scene\nfrom mayavi.core.ui.api import SceneEditor\nfrom mayavi.core.ui.mayavi_scene import MayaviScene\nfrom traits.api import (HasTraits, Range, Int, Float,\n                        Bool, Enum, on_trait_change, Instance)\nfrom tvtk.api import tvtk\nfrom pyface.api import GUI\nfrom traitsui.api import View, Item, Group, VGroup, HGroup, VSplit, HSplit\n\nfrom . import utils, io\nfrom .utils import (Surface, verbose, create_color_lut, _get_subjects_dir,\n                    string_types, threshold_filter, _check_units)\n\n\nlogger = logging.getLogger('surfer')\n\n\nlh_viewdict = {'lateral': {'v': (180., 90.), 'r': 90.},\n               'medial': {'v': (0., 90.), 'r': -90.},\n               'rostral': {'v': (90., 90.), 'r': -180.},\n               'caudal': {'v': (270., 90.), 'r': 0.},\n               'dorsal': {'v': (180., 0.), 'r': 90.},\n               'ventral': {'v': (180., 180.), 'r': 90.},\n               'frontal': {'v': (120., 80.), 'r': 106.739},\n               'parietal': {'v': (-120., 60.), 'r': 49.106}}\nrh_viewdict = {'lateral': {'v': (180., -90.), 'r': -90.},\n               'medial': {'v': (0., -90.), 'r': 90.},\n               'rostral': {'v': (-90., -90.), 'r': 180.},\n               'caudal': {'v': (90., -90.), 'r': 0.},\n               'dorsal': {'v': (180., 0.), 'r': 90.},\n               'ventral': {'v': (180., 180.), 'r': 90.},\n               'frontal': {'v': (60., 80.), 'r': -106.739},\n               'parietal': {'v': (-60., 60.), 'r': -49.106}}\nviewdicts = dict(lh=lh_viewdict, rh=rh_viewdict)\n\n\ndef make_montage(filename, fnames, orientation='h', colorbar=None,\n                 border_size=15):\n    \"\"\"Save montage of current figure\n\n    Parameters\n    ----------\n    filename : str\n        The name of the file, e.g, 'montage.png'. If None, the image\n        will not be saved.\n    fnames : list of str | list of array\n        The images to make the montage of. Can be a list of filenames\n        or a list of image data arrays.\n    orientation : 'h' | 'v' | list\n        The orientation of the montage: horizontal, vertical, or a nested\n        list of int (indexes into fnames).\n    colorbar : None | list of int\n        If None remove colorbars, else keep the ones whose index\n        is present.\n    border_size : int\n        The size of the border to keep.\n\n    Returns\n    -------\n    out : array\n        The montage image data array.\n    \"\"\"\n    try:\n        import Image\n    except (ValueError, ImportError):\n        from PIL import Image\n    from scipy import ndimage\n    # This line is only necessary to overcome a PIL bug, see:\n    #     http:\/\/stackoverflow.com\/questions\/10854903\/what-is-causing-\n    #          dimension-dependent-attributeerror-in-pil-fromarray-function\n    fnames = [f if isinstance(f, string_types) else f.copy() for f in fnames]\n    if isinstance(fnames[0], string_types):\n        images = list(map(Image.open, fnames))\n    else:\n        images = list(map(Image.fromarray, fnames))\n    # get bounding box for cropping\n    boxes = []\n    for ix, im in enumerate(images):\n        # sum the RGB dimension so we do not miss G or B-only pieces\n        gray = np.sum(np.array(im), axis=-1)\n        gray[gray == gray[0, 0]] = 0  # hack for find_objects that wants 0\n        if np.all(gray == 0):\n            raise ValueError(\"Empty image (all pixels have the same color).\")\n        labels, n_labels = ndimage.label(gray.astype(np.float))\n        slices = ndimage.find_objects(labels, n_labels)  # slice roi\n        if colorbar is not None and ix in colorbar:\n            # we need all pieces so let's compose them into single min\/max\n            slices_a = np.array([[[xy.start, xy.stop] for xy in s]\n                                 for s in slices])\n            # TODO: ideally gaps could be deduced and cut out with\n            #       consideration of border_size\n            # so we need mins on 0th and maxs on 1th of 1-nd dimension\n            mins = np.min(slices_a[:, :, 0], axis=0)\n            maxs = np.max(slices_a[:, :, 1], axis=0)\n            s = (slice(mins[0], maxs[0]), slice(mins[1], maxs[1]))\n        else:\n            # we need just the first piece\n            s = slices[0]\n        # box = (left, top, width, height)\n        boxes.append([s[1].start - border_size, s[0].start - border_size,\n                      s[1].stop + border_size, s[0].stop + border_size])\n    # convert orientation to nested list of int\n    if orientation == 'h':\n        orientation = [range(len(images))]\n    elif orientation == 'v':\n        orientation = [[i] for i in range(len(images))]\n    # find bounding box\n    n_rows = len(orientation)\n    n_cols = max(len(row) for row in orientation)\n    if n_rows > 1:\n        min_left = min(box[0] for box in boxes)\n        max_width = max(box[2] for box in boxes)\n        for box in boxes:\n            box[0] = min_left\n            box[2] = max_width\n    if n_cols > 1:\n        min_top = min(box[1] for box in boxes)\n        max_height = max(box[3] for box in boxes)\n        for box in boxes:\n            box[1] = min_top\n            box[3] = max_height\n    # crop images\n    cropped_images = []\n    for im, box in zip(images, boxes):\n        cropped_images.append(im.crop(box))\n    images = cropped_images\n    # Get full image size\n    row_w = [sum(images[i].size[0] for i in row) for row in orientation]\n    row_h = [max(images[i].size[1] for i in row) for row in orientation]\n    out_w = max(row_w)\n    out_h = sum(row_h)\n    # compose image\n    new = Image.new(\"RGBA\", (out_w, out_h))\n    y = 0\n    for row, h in zip(orientation, row_h):\n        x = 0\n        for i in row:\n            im = images[i]\n            pos = (x, y)\n            new.paste(im, pos)\n            x += im.size[0]\n        y += h\n    if filename is not None:\n        new.save(filename)\n    return np.array(new)\n\n\ndef _prepare_data(data):\n    \"\"\"Ensure data is float64 and has proper endianness.\n\n    Note: this is largely aimed at working around a Mayavi bug.\n\n    \"\"\"\n    data = data.copy()\n    data = data.astype(np.float64)\n    if data.dtype.byteorder == '>':\n        data.byteswap(True)\n    return data\n\n\ndef _force_render(figures):\n    \"\"\"Ensure plots are updated before properties are used\"\"\"\n    if not isinstance(figures, list):\n        figures = [[figures]]\n    _gui = GUI()\n    orig_val = _gui.busy\n    _gui.set_busy(busy=True)\n    _gui.process_events()\n    for ff in figures:\n        for f in ff:\n            f.render()\n            mlab.draw(figure=f)\n    _gui.set_busy(busy=orig_val)\n    _gui.process_events()\n\n\ndef _make_viewer(figure, n_row, n_col, title, scene_size, offscreen,\n                 interaction='trackball'):\n    \"\"\"Triage viewer creation\n\n    If n_row == n_col == 1, then we can use a Mayavi figure, which\n    generally guarantees that things will be drawn before control\n    is returned to the command line. With the multi-view, TraitsUI\n    unfortunately has no such support, so we only use it if needed.\n    \"\"\"\n    if figure is None:\n        # spawn scenes\n        h, w = scene_size\n        if offscreen == 'auto':\n            offscreen = mlab.options.offscreen\n        if offscreen:\n            orig_val = mlab.options.offscreen\n            try:\n                mlab.options.offscreen = True\n                with warnings.catch_warnings(record=True):  # traits\n                    figures = [[mlab.figure(size=(w \/ n_col, h \/ n_row))\n                                for _ in range(n_col)] for __ in range(n_row)]\n            finally:\n                mlab.options.offscreen = orig_val\n            _v = None\n        else:\n            # Triage: don't make TraitsUI if we don't have to\n            if n_row == 1 and n_col == 1:\n                with warnings.catch_warnings(record=True):  # traits\n                    figure = mlab.figure(title, size=(w, h))\n                mlab.clf(figure)\n                figures = [[figure]]\n                _v = None\n            else:\n                window = _MlabGenerator(n_row, n_col, w, h, title)\n                figures, _v = window._get_figs_view()\n            if interaction == 'terrain':  # \"trackball\" is default\n                for figure in figures:\n                    for f in figure:\n                        f.scene.interactor.interactor_style = \\\n                            tvtk.InteractorStyleTerrain()\n            for figure in figures:\n                for f in figure:\n                    # on a non-testing backend, and using modern VTK\/Mayavi\n                    if hasattr(getattr(f.scene, 'renderer', None), 'use_fxaa'):\n                        f.scene.renderer.use_fxaa = True\n    else:\n        if isinstance(figure, int):  # use figure with specified id\n            figure = [mlab.figure(figure, size=scene_size)]\n        elif isinstance(figure, tuple):\n            figure = list(figure)\n        elif not isinstance(figure, list):\n            figure = [figure]\n        if not all(isinstance(f, Scene) for f in figure):\n            raise TypeError('figure must be a mayavi scene or list of scenes')\n        if not len(figure) == n_row * n_col:\n            raise ValueError('For the requested view, figure must be a '\n                             'list or tuple with exactly %i elements, '\n                             'not %i' % (n_row * n_col, len(figure)))\n        _v = None\n        figures = [figure[slice(ri * n_col, (ri + 1) * n_col)]\n                   for ri in range(n_row)]\n    return figures, _v\n\n\nclass _MlabGenerator(HasTraits):\n    \"\"\"TraitsUI mlab figure generator\"\"\"\n    view = Instance(View)\n\n    def __init__(self, n_row, n_col, width, height, title, **traits):\n        HasTraits.__init__(self, **traits)\n        self.mlab_names = []\n        self.n_row = n_row\n        self.n_col = n_col\n        self.width = width\n        self.height = height\n        for fi in range(n_row * n_col):\n            name = 'mlab_view%03g' % fi\n            self.mlab_names.append(name)\n            self.add_trait(name, Instance(MlabSceneModel, ()))\n        self.view = self._get_gen_view()\n        self._v = self.edit_traits(view=self.view)\n        self._v.title = title\n\n    def _get_figs_view(self):\n        figures = []\n        ind = 0\n        for ri in range(self.n_row):\n            rfigs = []\n            for ci in range(self.n_col):\n                x = getattr(self, self.mlab_names[ind])\n                rfigs.append(x.mayavi_scene)\n                ind += 1\n            figures.append(rfigs)\n        return figures, self._v\n\n    def _get_gen_view(self):\n        ind = 0\n        va = []\n        for ri in range(self.n_row):\n            ha = []\n            for ci in range(self.n_col):\n                ha += [Item(name=self.mlab_names[ind], style='custom',\n                            resizable=True, show_label=False,\n                            editor=SceneEditor(scene_class=MayaviScene))]\n                ind += 1\n            va += [HGroup(*ha)]\n        view = View(VGroup(*va), resizable=True,\n                    height=self.height, width=self.width)\n        return view\n\n\nclass Brain(object):\n    \"\"\"Class for visualizing a brain using multiple views in mlab\n\n    Parameters\n    ----------\n    subject_id : str\n        subject name in Freesurfer subjects dir\n    hemi : str\n        hemisphere id (ie 'lh', 'rh', 'both', or 'split'). In the case\n        of 'both', both hemispheres are shown in the same window.\n        In the case of 'split' hemispheres are displayed side-by-side\n        in different viewing panes.\n    surf : str\n        freesurfer surface mesh name (ie 'white', 'inflated', etc.)\n    title : str\n        title for the window\n    cortex : str, tuple, dict, or None\n        Specifies how the cortical surface is rendered. Options:\n\n            1. The name of one of the preset cortex styles:\n               ``'classic'`` (default), ``'high_contrast'``,\n               ``'low_contrast'``, or ``'bone'``.\n            2. A color-like argument to render the cortex as a single\n               color, e.g. ``'red'`` or ``(0.1, 0.4, 1.)``. Setting\n               this to ``None`` is equivalent to ``(0.5, 0.5, 0.5)``.\n            3. The name of a colormap used to render binarized\n               curvature values, e.g., ``Grays``.\n            4. A list of colors used to render binarized curvature\n               values. Only the first and last colors are used. E.g.,\n               ['red', 'blue'] or [(1, 0, 0), (0, 0, 1)].\n            5. A container with four entries for colormap (string\n               specifiying the name of a colormap), vmin (float\n               specifying the minimum value for the colormap), vmax\n               (float specifying the maximum value for the colormap),\n               and reverse (bool specifying whether the colormap\n               should be reversed. E.g., ``('Greys', -1, 2, False)``.\n            6. A dict of keyword arguments that is passed on to the\n               call to surface.\n    alpha : float in [0, 1]\n        Alpha level to control opacity of the cortical surface.\n    size : float or pair of floats\n        the size of the window, in pixels. can be one number to specify\n        a square window, or the (width, height) of a rectangular window.\n    background : matplotlib color\n        Color of the background.\n    foreground : matplotlib color\n        Color of the foreground (will be used for colorbars and text).\n        None (default) will use black or white depending on the value\n        of ``background``.\n    figure : list of mayavi.core.scene.Scene | None | int\n        If None (default), a new window will be created with the appropriate\n        views. For single view plots, the figure can be specified as int to\n        retrieve the corresponding Mayavi window.\n    subjects_dir : str | None\n        If not None, this directory will be used as the subjects directory\n        instead of the value set using the SUBJECTS_DIR environment\n        variable.\n    views : list | str\n        views to use\n    offset : bool\n        If True, aligs origin with medial wall. Useful for viewing inflated\n        surface where hemispheres typically overlap (Default: True)\n    show_toolbar : bool\n        If True, toolbars will be shown for each view.\n    offscreen : bool | str\n        If True, rendering will be done offscreen (not shown). Useful\n        mostly for generating images or screenshots, but can be buggy.\n        Use at your own risk. Can be \"auto\" (default) to use\n        ``mlab.options.offscreen``.\n    interaction : str\n        Can be \"trackball\" (default) or \"terrain\", i.e. a turntable-style\n        camera.\n    units : str\n        Can be 'm' or 'mm' (default).\n\n    Attributes\n    ----------\n    annot : list\n        List of annotations.\n    brains : list\n        List of the underlying brain instances.\n    contour : list\n        List of the contours.\n    foci : foci\n        The foci.\n    labels : dict\n        The labels.\n    overlays : dict\n        The overlays.\n    texts : dict\n        The text objects.\n    \"\"\"\n\n    def __init__(self, subject_id, hemi, surf, title=None,\n                 cortex=\"classic\", alpha=1.0, size=800, background=\"black\",\n                 foreground=None, figure=None, subjects_dir=None,\n                 views=['lat'], offset=True, show_toolbar=False,\n                 offscreen='auto', interaction='trackball', units='mm'):\n\n        if not isinstance(interaction, string_types) or \\\n                interaction not in ('trackball', 'terrain'):\n            raise ValueError('interaction must be \"trackball\" or \"terrain\", '\n                             'got \"%s\"' % (interaction,))\n        self._units = _check_units(units)\n        col_dict = dict(lh=1, rh=1, both=1, split=2)\n        n_col = col_dict[hemi]\n        if hemi not in col_dict.keys():\n            raise ValueError('hemi must be one of [%s], not %s'\n                             % (', '.join(col_dict.keys()), hemi))\n        # Get the subjects directory from parameter or env. var\n        subjects_dir = _get_subjects_dir(subjects_dir=subjects_dir)\n\n        self._hemi = hemi\n        if title is None:\n            title = subject_id\n        self.subject_id = subject_id\n\n        if not isinstance(views, list):\n            views = [views]\n        n_row = len(views)\n\n        # load geometry for one or both hemispheres as necessary\n        offset = None if (not offset or hemi != 'both') else 0.0\n        self.geo = dict()\n        if hemi in ['split', 'both']:\n            geo_hemis = ['lh', 'rh']\n        elif hemi == 'lh':\n            geo_hemis = ['lh']\n        elif hemi == 'rh':\n            geo_hemis = ['rh']\n        else:\n            raise ValueError('bad hemi value')\n        geo_kwargs, geo_reverse, geo_curv = self._get_geo_params(cortex, alpha)\n        for h in geo_hemis:\n            # Initialize a Surface object as the geometry\n            geo = Surface(subject_id, h, surf, subjects_dir, offset,\n                          units=self._units)\n            # Load in the geometry and (maybe) curvature\n            geo.load_geometry()\n            if geo_curv:\n                geo.load_curvature()\n            self.geo[h] = geo\n\n        # deal with making figures\n        self._set_window_properties(size, background, foreground)\n        del background, foreground\n        figures, _v = _make_viewer(figure, n_row, n_col, title,\n                                   self._scene_size, offscreen,\n                                   interaction)\n        self._figures = figures\n        self._v = _v\n        self._window_backend = 'Mayavi' if self._v is None else 'TraitsUI'\n        for ff in self._figures:\n            for f in ff:\n                if f.scene is not None:\n                    f.scene.background = self._bg_color\n                    f.scene.foreground = self._fg_color\n\n        # force rendering so scene.lights exists\n        _force_render(self._figures)\n        self.toggle_toolbars(show_toolbar)\n        _force_render(self._figures)\n        self._toggle_render(False)\n\n        # fill figures with brains\n        kwargs = dict(geo_curv=geo_curv, geo_kwargs=geo_kwargs,\n                      geo_reverse=geo_reverse, subjects_dir=subjects_dir,\n                      bg_color=self._bg_color, fg_color=self._fg_color)\n        brains = []\n        brain_matrix = []\n        for ri, view in enumerate(views):\n            brain_row = []\n            for hi, h in enumerate(['lh', 'rh']):\n                if not (hemi in ['lh', 'rh'] and h != hemi):\n                    ci = hi if hemi == 'split' else 0\n                    kwargs['hemi'] = h\n                    kwargs['geo'] = self.geo[h]\n                    kwargs['figure'] = figures[ri][ci]\n                    kwargs['backend'] = self._window_backend\n                    brain = _Hemisphere(subject_id, **kwargs)\n                    brain.show_view(view)\n                    brains += [dict(row=ri, col=ci, brain=brain, hemi=h)]\n                    brain_row += [brain]\n            brain_matrix += [brain_row]\n        self._toggle_render(True)\n        self._original_views = views\n        self._brain_list = brains\n        for brain in self._brain_list:\n            brain['brain']._orient_lights()\n        self.brains = [b['brain'] for b in brains]\n        self.brain_matrix = np.array(brain_matrix)\n        self.subjects_dir = subjects_dir\n        self.surf = surf\n        # Initialize the overlay and label dictionaries\n        self.foci_dict = dict()\n        self._label_dicts = dict()\n        self.overlays_dict = dict()\n        self.contour_list = []\n        self.morphometry_list = []\n        self.annot_list = []\n        self._data_dicts = dict(lh=[], rh=[])\n        # note that texts gets treated differently\n        self.texts_dict = dict()\n        self._times = None\n        self.n_times = None\n\n    @property\n    def data_dict(self):\n        \"\"\"For backwards compatibility\"\"\"\n        lh_list = self._data_dicts['lh']\n        rh_list = self._data_dicts['rh']\n        return dict(lh=lh_list[-1] if lh_list else None,\n                    rh=rh_list[-1] if rh_list else None)\n\n    @property\n    def labels_dict(self):\n        \"\"\"For backwards compatibility\"\"\"\n        return {key: data['surfaces'] for key, data in\n                self._label_dicts.items()}\n\n    ###########################################################################\n    # HELPERS\n    def _toggle_render(self, state, views=None):\n        \"\"\"Turn rendering on (True) or off (False)\"\"\"\n        figs = [fig for fig_row in self._figures for fig in fig_row]\n        if views is None:\n            views = [None] * len(figs)\n        for vi, (_f, view) in enumerate(zip(figs, views)):\n            # Testing backend doesn't have these options\n            if mlab.options.backend == 'test':\n                continue\n\n            if state is False and view is None:\n                views[vi] = (mlab.view(figure=_f), mlab.roll(figure=_f),\n                             _f.scene.camera.parallel_scale\n                             if _f.scene is not None else False)\n\n            if _f.scene is not None:\n                _f.scene.disable_render = not state\n\n            if state is True and view is not None and _f.scene is not None:\n                mlab.draw(figure=_f)\n                with warnings.catch_warnings(record=True):  # traits focalpoint\n                    mlab.view(*view[0], figure=_f)\n                    mlab.roll(view[1], figure=_f)\n        # let's do the ugly force draw\n        if state is True:\n            _force_render(self._figures)\n        return views\n\n    def _set_window_properties(self, size, background, foreground):\n        \"\"\"Set window properties that are used elsewhere.\"\"\"\n        # old option \"size\" sets both width and height\n        from matplotlib.colors import colorConverter\n        try:\n            width, height = size\n        except (TypeError, ValueError):\n            width, height = size, size\n        self._scene_size = height, width\n        self._bg_color = colorConverter.to_rgb(background)\n        if foreground is None:\n            foreground = 'w' if sum(self._bg_color) < 2 else 'k'\n        self._fg_color = colorConverter.to_rgb(foreground)\n\n    def _get_geo_params(self, cortex, alpha=1.0):\n        \"\"\"Return keyword arguments and other parameters for surface\n        rendering.\n\n        Parameters\n        ----------\n        cortex : {str, tuple, dict, None}\n            Can be set to: (1) the name of one of the preset cortex\n            styles ('classic', 'high_contrast', 'low_contrast', or\n            'bone'), (2) the name of a colormap, (3) a tuple with\n            four entries for (colormap, vmin, vmax, reverse)\n            indicating the name of the colormap, the min and max\n            values respectively and whether or not the colormap should\n            be reversed, (4) a valid color specification (such as a\n            3-tuple with RGB values or a valid color name), or (5) a\n            dictionary of keyword arguments that is passed on to the\n            call to surface. If set to None, color is set to (0.5,\n            0.5, 0.5).\n        alpha : float in [0, 1]\n            Alpha level to control opacity of the cortical surface.\n\n        Returns\n        -------\n        kwargs : dict\n            Dictionary with keyword arguments to be used for surface\n            rendering. For colormaps, keys are ['colormap', 'vmin',\n            'vmax', 'alpha'] to specify the name, minimum, maximum,\n            and alpha transparency of the colormap respectively. For\n            colors, keys are ['color', 'alpha'] to specify the name\n            and alpha transparency of the color respectively.\n        reverse : boolean\n            Boolean indicating whether a colormap should be\n            reversed. Set to False if a color (rather than a colormap)\n            is specified.\n        curv : boolean\n            Boolean indicating whether curv file is loaded and binary\n            curvature is displayed.\n\n        \"\"\"\n        from matplotlib.colors import colorConverter\n        colormap_map = dict(classic=(dict(colormap=\"Greys\",\n                                          vmin=-1, vmax=2,\n                                          opacity=alpha), False, True),\n                            high_contrast=(dict(colormap=\"Greys\",\n                                                vmin=-.1, vmax=1.3,\n                                                opacity=alpha), False, True),\n                            low_contrast=(dict(colormap=\"Greys\",\n                                               vmin=-5, vmax=5,\n                                               opacity=alpha), False, True),\n                            bone=(dict(colormap=\"bone\",\n                                       vmin=-.2, vmax=2,\n                                       opacity=alpha), True, True))\n        if isinstance(cortex, dict):\n            if 'opacity' not in cortex:\n                cortex['opacity'] = alpha\n            if 'colormap' in cortex:\n                if 'vmin' not in cortex:\n                    cortex['vmin'] = -1\n                if 'vmax' not in cortex:\n                    cortex['vmax'] = 2\n            geo_params = cortex, False, True\n        elif isinstance(cortex, string_types):\n            if cortex in colormap_map:\n                geo_params = colormap_map[cortex]\n            elif cortex in lut_manager.lut_mode_list():\n                geo_params = dict(colormap=cortex, vmin=-1, vmax=2,\n                                  opacity=alpha), False, True\n            else:\n                try:\n                    color = colorConverter.to_rgb(cortex)\n                    geo_params = dict(color=color, opacity=alpha), False, False\n                except ValueError:\n                    geo_params = cortex, False, True\n        # check for None before checking len:\n        elif cortex is None:\n            geo_params = dict(color=(0.5, 0.5, 0.5),\n                              opacity=alpha), False, False\n        # Test for 4-tuple specifying colormap parameters. Need to\n        # avoid 4 letter strings and 4-tuples not specifying a\n        # colormap name in the first position (color can be specified\n        # as RGBA tuple, but the A value will be dropped by to_rgb()):\n        elif (len(cortex) == 4) and (isinstance(cortex[0], string_types)):\n            geo_params = dict(colormap=cortex[0], vmin=cortex[1],\n                              vmax=cortex[2], opacity=alpha), cortex[3], True\n        else:\n            try:  # check if it's a non-string color specification\n                color = colorConverter.to_rgb(cortex)\n                geo_params = dict(color=color, opacity=alpha), False, False\n            except ValueError:\n                try:\n                    lut = create_color_lut(cortex)\n                    geo_params = dict(colormap=\"Greys\", opacity=alpha,\n                                      lut=lut), False, True\n                except ValueError:\n                    geo_params = cortex, False, True\n        return geo_params\n\n    def get_data_properties(self):\n        \"\"\" Get properties of the data shown\n\n        Returns\n        -------\n        props : dict\n            Dictionary with data properties\n\n            props[\"fmin\"] : minimum colormap\n            props[\"fmid\"] : midpoint colormap\n            props[\"fmax\"] : maximum colormap\n            props[\"transparent\"] : lower part of colormap transparent?\n            props[\"time\"] : time points\n            props[\"time_idx\"] : current time index\n            props[\"smoothing_steps\"] : number of smoothing steps\n        \"\"\"\n        props = dict()\n        keys = ['fmin', 'fmid', 'fmax', 'transparent', 'time', 'time_idx',\n                'smoothing_steps', 'center']\n        try:\n            if self.data_dict['lh'] is not None:\n                hemi = 'lh'\n            else:\n                hemi = 'rh'\n            for key in keys:\n                props[key] = self.data_dict[hemi][key]\n        except KeyError:\n            # The user has not added any data\n            for key in keys:\n                props[key] = 0\n        return props\n\n    def toggle_toolbars(self, show=None):\n        \"\"\"Toggle toolbar display\n\n        Parameters\n        ----------\n        show : bool | None\n            If None, the state is toggled. If True, the toolbar will\n            be shown, if False, hidden.\n        \"\"\"\n        # don't do anything if testing is on\n        if self._figures[0][0].scene is not None:\n            # this may not work if QT is not the backend (?), or in testing\n            if hasattr(self._figures[0][0].scene, 'scene_editor'):\n                # Within TraitsUI\n                bars = [f.scene.scene_editor._tool_bar\n                        for ff in self._figures for f in ff]\n            else:\n                # Mayavi figure\n                bars = [f.scene._tool_bar for ff in self._figures for f in ff]\n\n            if show is None:\n                if hasattr(bars[0], 'isVisible'):\n                    # QT4\n                    show = not bars[0].isVisible()\n                elif hasattr(bars[0], 'Shown'):\n                    # WX\n                    show = not bars[0].Shown()\n            for bar in bars:\n                if hasattr(bar, 'setVisible'):\n                    bar.setVisible(show)\n                elif hasattr(bar, 'Show'):\n                    bar.Show(show)\n\n    def _get_one_brain(self, d, name):\n        \"\"\"Helper for various properties\"\"\"\n        if len(self.brains) > 1:\n            raise ValueError('Cannot access brain.%s when more than '\n                             'one view is plotted. Use brain.brain_matrix '\n                             'or brain.brains.' % name)\n        if isinstance(d, dict):\n            out = dict()\n            for key, value in d.items():\n                out[key] = value[0]\n        else:\n            out = d[0]\n        return out\n\n    @property\n    def overlays(self):\n        return self._get_one_brain(self.overlays_dict, 'overlays')\n\n    @property\n    def foci(self):\n        return self._get_one_brain(self.foci_dict, 'foci')\n\n    @property\n    def labels(self):\n        return self._get_one_brain(self.labels_dict, 'labels')\n\n    @property\n    def contour(self):\n        return self._get_one_brain(self.contour_list, 'contour')\n\n    @property\n    def annot(self):\n        return self._get_one_brain(self.annot_list, 'annot')\n\n    @property\n    def texts(self):\n        self._get_one_brain([[]], 'texts')\n        out = dict()\n        for key, val in self.texts_dict.iteritems():\n            out[key] = val['text']\n        return out\n\n    @property\n    def data(self):\n        self._get_one_brain([[]], 'data')\n        if self.data_dict['lh'] is not None:\n            data = self.data_dict['lh'].copy()\n        else:\n            data = self.data_dict['rh'].copy()\n        if 'colorbars' in data:\n            data['colorbar'] = data['colorbars'][0]\n        return data\n\n    def _check_hemi(self, hemi):\n        \"\"\"Check for safe single-hemi input, returns str\"\"\"\n        if hemi is None:\n            if self._hemi not in ['lh', 'rh']:\n                raise ValueError('hemi must not be None when both '\n                                 'hemispheres are displayed')\n            else:\n                hemi = self._hemi\n        elif hemi not in ['lh', 'rh']:\n            extra = ' or None' if self._hemi in ['lh', 'rh'] else ''\n            raise ValueError('hemi must be either \"lh\" or \"rh\"' + extra)\n        return hemi\n\n    def _check_hemis(self, hemi):\n        \"\"\"Check for safe dual or single-hemi input, returns list\"\"\"\n        if hemi is None:\n            if self._hemi not in ['lh', 'rh']:\n                hemi = ['lh', 'rh']\n            else:\n                hemi = [self._hemi]\n        elif hemi not in ['lh', 'rh']:\n            extra = ' or None' if self._hemi in ['lh', 'rh'] else ''\n            raise ValueError('hemi must be either \"lh\" or \"rh\"' + extra)\n        else:\n            hemi = [hemi]\n        return hemi\n\n    def _read_scalar_data(self, source, hemi, name=None, cast=True):\n        \"\"\"Load in scalar data from an image stored in a file or an array\n\n        Parameters\n        ----------\n        source : str or numpy array\n            path to scalar data file or a numpy array\n        name : str or None, optional\n            name for the overlay in the internal dictionary\n        cast : bool, optional\n            either to cast float data into 64bit datatype as a\n            workaround. cast=True can fix a rendering problem with\n            certain versions of Mayavi\n\n        Returns\n        -------\n        scalar_data : numpy array\n            flat numpy array of scalar data\n        name : str\n            if no name was provided, deduces the name if filename was given\n            as a source\n        \"\"\"\n        # If source is a string, try to load a file\n        if isinstance(source, string_types):\n            if name is None:\n                basename = os.path.basename(source)\n                if basename.endswith(\".gz\"):\n                    basename = basename[:-3]\n                if basename.startswith(\"%s.\" % hemi):\n                    basename = basename[3:]\n                name = os.path.splitext(basename)[0]\n            scalar_data = io.read_scalar_data(source)\n        else:\n            # Can't think of a good way to check that this will work nicely\n            scalar_data = source\n\n        if cast:\n            if (scalar_data.dtype.char == 'f' and\n                    scalar_data.dtype.itemsize < 8):\n                scalar_data = scalar_data.astype(np.float)\n\n        return scalar_data, name\n\n    def _get_display_range(self, scalar_data, min, max, sign):\n        if scalar_data.min() >= 0:\n            sign = \"pos\"\n        elif scalar_data.max() <= 0:\n            sign = \"neg\"\n\n        # Get data with a range that will make sense for automatic thresholding\n        if sign == \"neg\":\n            range_data = np.abs(scalar_data[np.where(scalar_data < 0)])\n        elif sign == \"pos\":\n            range_data = scalar_data[np.where(scalar_data > 0)]\n        else:\n            range_data = np.abs(scalar_data)\n\n        # Get a numeric value for the scalar minimum\n        if min is None:\n            min = \"robust_min\"\n        if min == \"robust_min\":\n            min = np.percentile(range_data, 2)\n        elif min == \"actual_min\":\n            min = range_data.min()\n\n        # Get a numeric value for the scalar maximum\n        if max is None:\n            max = \"robust_max\"\n        if max == \"robust_max\":\n            max = np.percentile(scalar_data, 98)\n        elif max == \"actual_max\":\n            max = range_data.max()\n\n        return min, max\n\n    def _iter_time(self, time_idx, interpolation):\n        \"\"\"Iterate through time points, then reset to current time\n\n        Parameters\n        ----------\n        time_idx : array_like\n            Time point indexes through which to iterate.\n        interpolation : str\n            Interpolation method (``scipy.interpolate.interp1d`` parameter,\n            one of 'linear' | 'nearest' | 'zero' | 'slinear' | 'quadratic' |\n            'cubic'). Interpolation is only used for non-integer indexes.\n\n        Yields\n        ------\n        idx : int | float\n            Current index.\n\n        Notes\n        -----\n        Used by movie and image sequence saving functions.\n        \"\"\"\n        current_time_idx = self.data_time_index\n        for idx in time_idx:\n            self.set_data_time_index(idx, interpolation)\n            yield idx\n\n        # Restore original time index\n        self.set_data_time_index(current_time_idx)\n\n    ###########################################################################\n    # ADDING DATA PLOTS\n    def add_overlay(self, source, min=2, max=\"robust_max\", sign=\"abs\",\n                    name=None, hemi=None):\n        \"\"\"Add an overlay to the overlay dict from a file or array.\n\n        Parameters\n        ----------\n        source : str or numpy array\n            path to the overlay file or numpy array with data\n        min : float\n            threshold for overlay display\n        max : float\n            saturation point for overlay display\n        sign : {'abs' | 'pos' | 'neg'}\n            whether positive, negative, or both values should be displayed\n        name : str\n            name for the overlay in the internal dictionary\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, an error will\n            be thrown.\n        \"\"\"\n        hemi = self._check_hemi(hemi)\n        # load data here\n        scalar_data, name = self._read_scalar_data(source, hemi, name=name)\n        min, max = self._get_display_range(scalar_data, min, max, sign)\n        if sign not in [\"abs\", \"pos\", \"neg\"]:\n            raise ValueError(\"Overlay sign must be 'abs', 'pos', or 'neg'\")\n        old = OverlayData(scalar_data, min, max, sign)\n        ol = []\n        views = self._toggle_render(False)\n        for brain in self._brain_list:\n            if brain['hemi'] == hemi:\n                ol.append(brain['brain'].add_overlay(old))\n        if name in self.overlays_dict:\n            name = \"%s%d\" % (name, len(self.overlays_dict) + 1)\n        self.overlays_dict[name] = ol\n        self._toggle_render(True, views)\n\n    @verbose\n    def add_data(self, array, min=None, max=None, thresh=None,\n                 colormap=\"auto\", alpha=1,\n                 vertices=None, smoothing_steps=20, time=None,\n                 time_label=\"time index=%d\", colorbar=True,\n                 hemi=None, remove_existing=False, time_label_size=14,\n                 initial_time=None, scale_factor=None, vector_alpha=None,\n                 mid=None, center=None, transparent=False, verbose=None):\n        \"\"\"Display data from a numpy array on the surface.\n\n        This provides a similar interface to\n        :meth:`surfer.Brain.add_overlay`, but it displays\n        it with a single colormap. It offers more flexibility over the\n        colormap, and provides a way to display four-dimensional data\n        (i.e., a timecourse) or five-dimensional data (i.e., a\n        vector-valued timecourse).\n\n        .. note:: ``min`` sets the low end of the colormap, and is separate\n                  from thresh (this is a different convention from\n                  :meth:`surfer.Brain.add_overlay`).\n\n        Parameters\n        ----------\n        array : numpy array, shape (n_vertices[, 3][, n_times])\n            Data array. For the data to be understood as vector-valued\n            (3 values per vertex corresponding to X\/Y\/Z surface RAS),\n            then ``array`` must be have all 3 dimensions.\n            If vectors with no time dimension are desired, consider using a\n            singleton (e.g., ``np.newaxis``) to create a \"time\" dimension\n            and pass ``time_label=None``.\n        min : float\n            min value in colormap (uses real min if None)\n        mid : float\n            intermediate value in colormap (middle between min and max if None)\n        max : float\n            max value in colormap (uses real max if None)\n        thresh : None or float\n            if not None, values below thresh will not be visible\n        center : float or None\n            if not None, center of a divergent colormap, changes the meaning of\n            min, max and mid, see :meth:`scale_data_colormap` for further info.\n        transparent : bool\n            if True: use a linear transparency between fmin and fmid and make\n            values below fmin fully transparent (symmetrically for divergent\n            colormaps)\n        colormap : string, list of colors, or array\n            name of matplotlib colormap to use, a list of matplotlib colors,\n            or a custom look up table (an n x 4 array coded with RBGA values\n            between 0 and 255), the default \"auto\" chooses a default divergent\n            colormap, if \"center\" is given (currently \"icefire\"), otherwise a\n            default sequential colormap (currently \"rocket\").\n        alpha : float in [0, 1]\n            alpha level to control opacity of the overlay.\n        vertices : numpy array\n            vertices for which the data is defined (needed if len(data) < nvtx)\n        smoothing_steps : int or None\n            number of smoothing steps (smoothing is used if len(data) < nvtx)\n            Default : 20\n        time : numpy array\n            time points in the data array (if data is 2D or 3D)\n        time_label : str | callable | None\n            format of the time label (a format string, a function that maps\n            floating point time values to strings, or None for no label)\n        colorbar : bool\n            whether to add a colorbar to the figure\n        hemi : str | None\n            If None, it is assumed to belong to the hemisphere being\n            shown. If two hemispheres are being shown, an error will\n            be thrown.\n        remove_existing : bool\n            Remove surface added by previous \"add_data\" call. Useful for\n            conserving memory when displaying different data in a loop.\n        time_label_size : int\n            Font size of the time label (default 14)\n        initial_time : float | None\n            Time initially shown in the plot. ``None`` to use the first time\n            sample (default).\n        scale_factor : float | None (default)\n            The scale factor to use when displaying glyphs for vector-valued\n            data.\n        vector_alpha : float | None\n            alpha level to control opacity of the arrows. Only used for\n            vector-valued data. If None (default), ``alpha`` is used.\n        verbose : bool, str, int, or None\n            If not None, override default verbose level (see surfer.verbose).\n\n        Notes\n        -----\n        If the data is defined for a subset of vertices (specified\n        by the \"vertices\" parameter), a smoothing method is used to interpolate\n        the data onto the high resolution surface. If the data is defined for\n        subsampled version of the surface, smoothing_steps can be set to None,\n        in which case only as many smoothing steps are applied until the whole\n        surface is filled with non-zeros.\n\n        Due to a Mayavi (or VTK) alpha rendering bug, ``vector_alpha`` is\n        clamped to be strictly < 1.\n        \"\"\"\n        hemi = self._check_hemi(hemi)\n        array = np.asarray(array)\n\n        if center is None:\n            if min is None:\n                min = array.min() if array.size > 0 else 0\n            if max is None:\n                max = array.max() if array.size > 0 else 1\n        else:\n            if min is None:\n                min = 0\n            if max is None:\n                max = np.abs(center - array).max() if array.size > 0 else 1\n        if mid is None:\n            mid = (min + max) \/ 2.\n        _check_limits(min, mid, max, extra='')\n\n        # Create smoothing matrix if necessary\n        if len(array) < self.geo[hemi].x.shape[0]:\n            if vertices is None:\n                raise ValueError(\"len(data) < nvtx (%s < %s): the vertices \"\n                                 \"parameter must not be None\"\n                                 % (len(array), self.geo[hemi].x.shape[0]))\n            adj_mat = utils.mesh_edges(self.geo[hemi].faces)\n            smooth_mat = utils.smoothing_matrix(vertices, adj_mat,\n                                                smoothing_steps)\n        else:\n            smooth_mat = None\n\n        magnitude = None\n        magnitude_max = None\n        if array.ndim == 3:\n            if array.shape[1] != 3:\n                raise ValueError('If array has 3 dimensions, array.shape[1] '\n                                 'must equal 3, got %s' % (array.shape[1],))\n            magnitude = np.linalg.norm(array, axis=1)\n            if scale_factor is None:\n                distance = np.sum([array[:, dim, :].ptp(axis=0).max() ** 2\n                                   for dim in range(3)])\n                if distance == 0:\n                    scale_factor = 1\n                else:\n                    scale_factor = (0.4 * distance \/\n                                    (4 * array.shape[0] ** (0.33)))\n            if self._units == 'm':\n                scale_factor = scale_factor \/ 1000.\n            magnitude_max = magnitude.max()\n        elif array.ndim not in (1, 2):\n            raise ValueError('array has must have 1, 2, or 3 dimensions, '\n                             'got (%s)' % (array.ndim,))\n\n        # Process colormap argument into a lut\n        lut = create_color_lut(colormap, center=center)\n        colormap = \"Greys\"\n\n        # determine unique data layer ID\n        data_dicts = self._data_dicts['lh'] + self._data_dicts['rh']\n        if data_dicts:\n            layer_id = np.max([data['layer_id'] for data in data_dicts]) + 1\n        else:\n            layer_id = 0\n\n        data = dict(array=array, smoothing_steps=smoothing_steps,\n                    fmin=min, fmid=mid, fmax=max, center=center,\n                    scale_factor=scale_factor,\n                    transparent=False, time=0, time_idx=0,\n                    vertices=vertices, smooth_mat=smooth_mat,\n                    layer_id=layer_id, magnitude=magnitude)\n\n        # clean up existing data\n        if remove_existing:\n            self.remove_data(hemi)\n\n        # Create time array and add label if > 1D\n        if array.ndim <= 1:\n            initial_time_index = None\n        else:\n            # check time array\n            if time is None:\n                time = np.arange(array.shape[-1])\n            else:\n                time = np.asarray(time)\n                if time.shape != (array.shape[-1],):\n                    raise ValueError('time has shape %s, but need shape %s '\n                                     '(array.shape[-1])' %\n                                     (time.shape, (array.shape[-1],)))\n\n            if self.n_times is None:\n                self.n_times = len(time)\n                self._times = time\n            elif len(time) != self.n_times:\n                raise ValueError(\"New n_times is different from previous \"\n                                 \"n_times\")\n            elif not np.array_equal(time, self._times):\n                raise ValueError(\"Not all time values are consistent with \"\n                                 \"previously set times.\")\n\n            # initial time\n            if initial_time is None:\n                initial_time_index = None\n            else:\n                initial_time_index = self.index_for_time(initial_time)\n\n            # time label\n            if isinstance(time_label, string_types):\n                time_label_fmt = time_label\n\n                def time_label(x):\n                    return time_label_fmt % x\n            data[\"time_label\"] = time_label\n            data[\"time\"] = time\n            data[\"time_idx\"] = 0\n            y_txt = 0.05 + 0.05 * bool(colorbar)\n\n        surfs = []\n        bars = []\n        glyphs = []\n        views = self._toggle_render(False)\n        vector_alpha = alpha if vector_alpha is None else vector_alpha\n        for brain in self._brain_list:\n            if brain['hemi'] == hemi:\n                s, ct, bar, gl = brain['brain'].add_data(\n                    array, min, mid, max, thresh, lut, colormap, alpha,\n                    colorbar, layer_id, smooth_mat, magnitude, magnitude_max,\n                    scale_factor, vertices, vector_alpha)\n                surfs.append(s)\n                bars.append(bar)\n                glyphs.append(gl)\n                if array.ndim >= 2 and time_label is not None:\n                    self.add_text(0.95, y_txt, time_label(time[0]),\n                                  name=\"time_label\", row=brain['row'],\n                                  col=brain['col'], font_size=time_label_size,\n                                  justification='right')\n        data['surfaces'] = surfs\n        data['colorbars'] = bars\n        data['orig_ctable'] = ct\n        data['glyphs'] = glyphs\n\n        self._data_dicts[hemi].append(data)\n\n        self.scale_data_colormap(min, mid, max, transparent, center, alpha,\n                                 data)\n\n        if initial_time_index is not None:\n            self.set_data_time_index(initial_time_index)\n        self._toggle_render(True, views)\n\n    def add_annotation(self, annot, borders=True, alpha=1, hemi=None,\n                       remove_existing=True):\n        \"\"\"Add an annotation file.\n\n        Parameters\n        ----------\n        annot : str | tuple\n            Either path to annotation file or annotation name. Alternatively,\n            the annotation can be specified as a ``(labels, ctab)`` tuple per\n            hemisphere, i.e. ``annot=(labels, ctab)`` for a single hemisphere\n            or ``annot=((lh_labels, lh_ctab), (rh_labels, rh_ctab))`` for both\n            hemispheres. ``labels`` and ``ctab`` should be arrays as returned\n            by :func:`nibabel.freesurfer.io.read_annot`.\n        borders : bool | int\n            Show only label borders. If int, specify the number of steps\n            (away from the true border) along the cortical mesh to include\n            as part of the border definition.\n        alpha : float in [0, 1]\n            Alpha level to control opacity.\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, data must exist\n            for both hemispheres.\n        remove_existing : bool\n            If True (default), remove old annotations.\n        \"\"\"\n        hemis = self._check_hemis(hemi)\n\n        # Figure out where the data is coming from\n        if isinstance(annot, string_types):\n            if os.path.isfile(annot):\n                filepath = annot\n                path = os.path.split(filepath)[0]\n                file_hemi, annot = os.path.basename(filepath).split('.')[:2]\n                if len(hemis) > 1:\n                    if annot[:2] == 'lh.':\n                        filepaths = [filepath, pjoin(path, 'rh' + annot[2:])]\n                    elif annot[:2] == 'rh.':\n                        filepaths = [pjoin(path, 'lh' + annot[2:], filepath)]\n                    else:\n                        raise RuntimeError('To add both hemispheres '\n                                           'simultaneously, filename must '\n                                           'begin with \"lh.\" or \"rh.\"')\n                else:\n                    filepaths = [filepath]\n            else:\n                filepaths = []\n                for hemi in hemis:\n                    filepath = pjoin(self.subjects_dir,\n                                     self.subject_id,\n                                     'label',\n                                     \".\".join([hemi, annot, 'annot']))\n                    if not os.path.exists(filepath):\n                        raise ValueError('Annotation file %s does not exist'\n                                         % filepath)\n                    filepaths += [filepath]\n            annots = []\n            for hemi, filepath in zip(hemis, filepaths):\n                # Read in the data\n                labels, cmap, _ = nib.freesurfer.read_annot(\n                    filepath, orig_ids=True)\n                annots.append((labels, cmap))\n        else:\n            annots = [annot] if len(hemis) == 1 else annot\n            annot = 'annotation'\n\n        views = self._toggle_render(False)\n        if remove_existing:\n            # Get rid of any old annots\n            for a in self.annot_list:\n                a['brain']._remove_scalar_data(a['array_id'])\n            self.annot_list = []\n\n        for hemi, (labels, cmap) in zip(hemis, annots):\n\n            # Maybe zero-out the non-border vertices\n            self._to_borders(labels, hemi, borders)\n\n            # Handle null labels properly\n            cmap[:, 3] = 255\n            bgcolor = self._brain_color\n            bgcolor[-1] = 0\n            cmap[cmap[:, 4] < 0, 4] += 2 ** 24  # wrap to positive\n            cmap[cmap[:, 4] <= 0, :4] = bgcolor\n            if np.any(labels == 0) and not np.any(cmap[:, -1] <= 0):\n                cmap = np.vstack((cmap, np.concatenate([bgcolor, [0]])))\n\n            # Set label ids sensibly\n            order = np.argsort(cmap[:, -1])\n            cmap = cmap[order]\n            ids = np.searchsorted(cmap[:, -1], labels)\n            cmap = cmap[:, :4]\n\n            #  Set the alpha level\n            alpha_vec = cmap[:, 3]\n            alpha_vec[alpha_vec > 0] = alpha * 255\n\n            for brain in self._brain_list:\n                if brain['hemi'] == hemi:\n                    self.annot_list.append(\n                        brain['brain'].add_annotation(annot, ids, cmap))\n        self._toggle_render(True, views)\n\n    def add_label(self, label, color=None, alpha=1, scalar_thresh=None,\n                  borders=False, hemi=None, subdir=None):\n        \"\"\"Add an ROI label to the image.\n\n        Parameters\n        ----------\n        label : str | instance of Label\n            label filepath or name. Can also be an instance of\n            an object with attributes \"hemi\", \"vertices\", \"name\", and\n            optionally \"color\" and \"values\" (if scalar_thresh is not None).\n        color : matplotlib-style color | None\n            anything matplotlib accepts: string, RGB, hex, etc. (default\n            \"crimson\")\n        alpha : float in [0, 1]\n            alpha level to control opacity\n        scalar_thresh : None or number\n            threshold the label ids using this value in the label\n            file's scalar field (i.e. label only vertices with\n            scalar >= thresh)\n        borders : bool | int\n            Show only label borders. If int, specify the number of steps\n            (away from the true border) along the cortical mesh to include\n            as part of the border definition.\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, an error will\n            be thrown.\n        subdir : None | str\n            If a label is specified as name, subdir can be used to indicate\n            that the label file is in a sub-directory of the subject's\n            label directory rather than in the label directory itself (e.g.\n            for ``$SUBJECTS_DIR\/$SUBJECT\/label\/aparc\/lh.cuneus.label``\n            ``brain.add_label('cuneus', subdir='aparc')``).\n\n        Notes\n        -----\n        To remove previously added labels, run Brain.remove_labels().\n        \"\"\"\n        if isinstance(label, string_types):\n            hemi = self._check_hemi(hemi)\n            if color is None:\n                color = \"crimson\"\n\n            if os.path.isfile(label):\n                filepath = label\n                label_name = os.path.basename(filepath).split('.')[1]\n            else:\n                label_name = label\n                label_fname = \".\".join([hemi, label_name, 'label'])\n                if subdir is None:\n                    filepath = pjoin(self.subjects_dir, self.subject_id,\n                                     'label', label_fname)\n                else:\n                    filepath = pjoin(self.subjects_dir, self.subject_id,\n                                     'label', subdir, label_fname)\n                if not os.path.exists(filepath):\n                    raise ValueError('Label file %s does not exist'\n                                     % filepath)\n            # Load the label data and create binary overlay\n            if scalar_thresh is None:\n                ids = nib.freesurfer.read_label(filepath)\n            else:\n                ids, scalars = nib.freesurfer.read_label(filepath,\n                                                         read_scalars=True)\n                ids = ids[scalars >= scalar_thresh]\n        else:\n            # try to extract parameters from label instance\n            try:\n                hemi = label.hemi\n                ids = label.vertices\n                if label.name is None:\n                    label_name = 'unnamed'\n                else:\n                    label_name = str(label.name)\n\n                if color is None:\n                    if hasattr(label, 'color') and label.color is not None:\n                        color = label.color\n                    else:\n                        color = \"crimson\"\n\n                if scalar_thresh is not None:\n                    scalars = label.values\n            except Exception:\n                raise ValueError('Label was not a filename (str), and could '\n                                 'not be understood as a class. The class '\n                                 'must have attributes \"hemi\", \"vertices\", '\n                                 '\"name\", and (if scalar_thresh is not None)'\n                                 '\"values\"')\n            hemi = self._check_hemi(hemi)\n\n            if scalar_thresh is not None:\n                ids = ids[scalars >= scalar_thresh]\n\n        label = np.zeros(self.geo[hemi].coords.shape[0])\n        label[ids] = 1\n\n        # make sure we have a unique name\n        if label_name in self._label_dicts:\n            i = 2\n            name = label_name + '_%i'\n            while name % i in self._label_dicts:\n                i += 1\n            label_name = name % i\n\n        self._to_borders(label, hemi, borders, restrict_idx=ids)\n\n        # make a list of all the plotted labels\n        surfaces = []\n        array_ids = []\n        views = self._toggle_render(False)\n        for brain in self.brains:\n            if brain.hemi == hemi:\n                array_id, surf = brain.add_label(label, label_name, color,\n                                                 alpha)\n                surfaces.append(surf)\n                array_ids.append((brain, array_id))\n        self._label_dicts[label_name] = {'surfaces': surfaces,\n                                         'array_ids': array_ids}\n        self._toggle_render(True, views)\n\n    def _to_borders(self, label, hemi, borders, restrict_idx=None):\n        \"\"\"Helper to potentially convert a label\/parc to borders\"\"\"\n        if not isinstance(borders, (bool, int)) or borders < 0:\n            raise ValueError('borders must be a bool or positive integer')\n        if borders:\n            n_vertices = label.size\n            edges = utils.mesh_edges(self.geo[hemi].faces)\n            border_edges = label[edges.row] != label[edges.col]\n            show = np.zeros(n_vertices, dtype=np.int)\n            keep_idx = np.unique(edges.row[border_edges])\n            if isinstance(borders, int):\n                for _ in range(borders):\n                    keep_idx = np.in1d(self.geo[hemi].faces.ravel(), keep_idx)\n                    keep_idx.shape = self.geo[hemi].faces.shape\n                    keep_idx = self.geo[hemi].faces[np.any(keep_idx, axis=1)]\n                    keep_idx = np.unique(keep_idx)\n                if restrict_idx is not None:\n                    keep_idx = keep_idx[np.in1d(keep_idx, restrict_idx)]\n            show[keep_idx] = 1\n            label *= show\n\n    def remove_data(self, hemi=None):\n        \"\"\"Remove data shown with ``Brain.add_data()``.\n\n        Parameters\n        ----------\n        hemi : str | None\n            Hemisphere from which to remove data (default is all shown\n            hemispheres).\n        \"\"\"\n        hemis = self._check_hemis(hemi)\n        for hemi in hemis:\n            for brain in self.brains:\n                if brain.hemi == hemi:\n                    for data in self._data_dicts[hemi]:\n                        brain.remove_data(data['layer_id'])\n            self._data_dicts[hemi] = []\n\n        # if no data is left, reset time properties\n        if all(len(brain.data) == 0 for brain in self.brains):\n            self.n_times = self._times = None\n\n    def remove_foci(self, name=None):\n        \"\"\"Remove foci added with ``Brain.add_foci()``.\n\n        Parameters\n        ----------\n        name : str | list of str | None\n            Names of the foci to remove (if None, remove all).\n\n        Notes\n        -----\n        Only foci added with a unique names can be removed.\n        \"\"\"\n        if name is None:\n            keys = tuple(self.foci_dict)\n        else:\n            if isinstance(name, str):\n                keys = (name,)\n            else:\n                keys = name\n            if not all(key in self.foci_dict for key in keys):\n                missing = ', '.join(key for key in keys if key not in\n                                    self.foci_dict)\n                raise ValueError(\"foci=%r: no foci named %s\" % (name, missing))\n\n        for key in keys:\n            for points in self.foci_dict.pop(key):\n                points.remove()\n\n    def remove_labels(self, labels=None, hemi=None):\n        \"\"\"Remove one or more previously added labels from the image.\n\n        Parameters\n        ----------\n        labels : None | str | list of str\n            Labels to remove. Can be a string naming a single label, or None to\n            remove all labels. Possible names can be found in the Brain.labels\n            attribute.\n        hemi : None\n            Deprecated parameter, do not use.\n        \"\"\"\n        if hemi is not None:\n            warn(\"The `hemi` parameter to Brain.remove_labels() has no effect \"\n                 \"and will be removed in PySurfer 0.9\", DeprecationWarning)\n\n        if labels is None:\n            # make list before iterating (Py3k)\n            labels_ = list(self._label_dicts.keys())\n        else:\n            labels_ = [labels] if isinstance(labels, str) else labels\n            missing = [key for key in labels_ if key not in self._label_dicts]\n            if missing:\n                raise ValueError(\"labels=%r contains unknown labels: %s\" %\n                                 (labels, ', '.join(map(repr, missing))))\n\n        for key in labels_:\n            data = self._label_dicts.pop(key)\n            for brain, array_id in data['array_ids']:\n                brain._remove_scalar_data(array_id)\n\n    def add_morphometry(self, measure, grayscale=False, hemi=None,\n                        remove_existing=True, colormap=None,\n                        min=None, max=None, colorbar=True):\n        \"\"\"Add a morphometry overlay to the image.\n\n        Parameters\n        ----------\n        measure : {'area' | 'curv' | 'jacobian_white' | 'sulc' | 'thickness'}\n            which measure to load\n        grayscale : bool\n            whether to load the overlay with a grayscale colormap\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, data must exist\n            for both hemispheres.\n        remove_existing : bool\n            If True (default), remove old annotations.\n        colormap : str\n            Mayavi colormap name, or None to use a sensible default.\n        min, max : floats\n            Endpoints for the colormap; if not provided the robust range\n            of the data is used.\n        colorbar : bool\n            If True, show a colorbar corresponding to the overlay data.\n\n        \"\"\"\n        hemis = self._check_hemis(hemi)\n        morph_files = []\n        for hemi in hemis:\n            # Find the source data\n            surf_dir = pjoin(self.subjects_dir, self.subject_id, 'surf')\n            morph_file = pjoin(surf_dir, '.'.join([hemi, measure]))\n            if not os.path.exists(morph_file):\n                raise ValueError(\n                    'Could not find %s in subject directory' % morph_file)\n            morph_files += [morph_file]\n\n        views = self._toggle_render(False)\n        if remove_existing is True:\n            # Get rid of any old overlays\n            for m in self.morphometry_list:\n                if m[\"colorbar\"] is not None:\n                    m['colorbar'].visible = False\n                m['brain']._remove_scalar_data(m['array_id'])\n            self.morphometry_list = []\n\n        for hemi, morph_file in zip(hemis, morph_files):\n\n            if colormap is None:\n                # Preset colormaps\n                if grayscale:\n                    colormap = \"gray\"\n                else:\n                    colormap = dict(area=\"pink\",\n                                    curv=\"RdBu\",\n                                    jacobian_white=\"pink\",\n                                    sulc=\"RdBu\",\n                                    thickness=\"pink\")[measure]\n\n            # Read in the morphometric data\n            morph_data = nib.freesurfer.read_morph_data(morph_file)\n\n            # Get a cortex mask for robust range\n            self.geo[hemi].load_label(\"cortex\")\n            ctx_idx = self.geo[hemi].labels[\"cortex\"]\n\n            # Get the display range\n            min_default, max_default = np.percentile(morph_data[ctx_idx],\n                                                     [2, 98])\n            if min is None:\n                min = min_default\n            if max is None:\n                max = max_default\n\n            # Use appropriate values for bivariate measures\n            if measure in [\"curv\", \"sulc\"]:\n                lim = np.max([abs(min), abs(max)])\n                min, max = -lim, lim\n\n            # Set up the Mayavi pipeline\n            morph_data = _prepare_data(morph_data)\n\n            for brain in self.brains:\n                if brain.hemi == hemi:\n                    self.morphometry_list.append(brain.add_morphometry(\n                        morph_data, colormap, measure, min, max, colorbar))\n        self._toggle_render(True, views)\n\n    def add_foci(self, coords, coords_as_verts=False, map_surface=None,\n                 scale_factor=1, color=\"white\", alpha=1, name=None,\n                 hemi=None):\n        \"\"\"Add spherical foci, possibly mapping to displayed surf.\n\n        The foci spheres can be displayed at the coordinates given, or\n        mapped through a surface geometry. In other words, coordinates\n        from a volume-based analysis in MNI space can be displayed on an\n        inflated average surface by finding the closest vertex on the\n        white surface and mapping to that vertex on the inflated mesh.\n\n        Parameters\n        ----------\n        coords : numpy array\n            x, y, z coordinates in stereotaxic space (default) or array of\n            vertex ids (with ``coord_as_verts=True``)\n        coords_as_verts : bool\n            whether the coords parameter should be interpreted as vertex ids\n        map_surface : Freesurfer surf or None\n            surface to map coordinates through, or None to use raw coords\n        scale_factor : float\n            Controls the size of the foci spheres (relative to 1cm).\n        color : matplotlib color code\n            HTML name, RBG tuple, or hex code\n        alpha : float in [0, 1]\n            opacity of focus gylphs\n        name : str\n            internal name to use\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, an error will\n            be thrown.\n        \"\"\"\n        from matplotlib.colors import colorConverter\n        hemi = self._check_hemi(hemi)\n\n        # Figure out how to interpret the first parameter\n        if coords_as_verts:\n            coords = self.geo[hemi].coords[coords]\n            map_surface = None\n\n        # Possibly map the foci coords through a surface\n        if map_surface is None:\n            foci_coords = np.atleast_2d(coords)\n        else:\n            foci_surf = Surface(self.subject_id, hemi, map_surface,\n                                subjects_dir=self.subjects_dir,\n                                units=self._units)\n            foci_surf.load_geometry()\n            foci_vtxs = utils.find_closest_vertices(foci_surf.coords, coords)\n            foci_coords = self.geo[hemi].coords[foci_vtxs]\n\n        # Get a unique name (maybe should take this approach elsewhere)\n        if name is None:\n            name = \"foci_%d\" % (len(self.foci_dict) + 1)\n\n        # Convert the color code\n        if not isinstance(color, tuple):\n            color = colorConverter.to_rgb(color)\n\n        views = self._toggle_render(False)\n        fl = []\n        if self._units == 'm':\n            scale_factor = scale_factor \/ 1000.\n        for brain in self._brain_list:\n            if brain['hemi'] == hemi:\n                fl.append(brain['brain'].add_foci(foci_coords, scale_factor,\n                                                  color, alpha, name))\n        self.foci_dict[name] = fl\n        self._toggle_render(True, views)\n\n    def add_contour_overlay(self, source, min=None, max=None,\n                            n_contours=7, line_width=1.5, colormap=\"YlOrRd_r\",\n                            hemi=None, remove_existing=True, colorbar=True):\n        \"\"\"Add a topographic contour overlay of the positive data.\n\n        Note: This visualization will look best when using the \"low_contrast\"\n        cortical curvature colorscheme.\n\n        Parameters\n        ----------\n        source : str or array\n            path to the overlay file or numpy array\n        min : float\n            threshold for overlay display\n        max : float\n            saturation point for overlay display\n        n_contours : int\n            number of contours to use in the display\n        line_width : float\n            width of contour lines\n        colormap : string, list of colors, or array\n            name of matplotlib colormap to use, a list of matplotlib colors,\n            or a custom look up table (an n x 4 array coded with RBGA values\n            between 0 and 255).\n        hemi : str | None\n            If None, it is assumed to belong to the hemipshere being\n            shown. If two hemispheres are being shown, an error will\n            be thrown.\n        remove_existing : bool\n            If there is an existing contour overlay, remove it before plotting.\n        colorbar : bool\n            If True, show the colorbar for the scalar value.\n\n        \"\"\"\n        hemi = self._check_hemi(hemi)\n\n        # Read the scalar data\n        scalar_data, _ = self._read_scalar_data(source, hemi)\n        min, max = self._get_display_range(scalar_data, min, max, \"pos\")\n\n        # Deal with Mayavi bug\n        scalar_data = _prepare_data(scalar_data)\n\n        # Maybe get rid of an old overlay\n        if remove_existing:\n            for c in self.contour_list:\n                if c['colorbar'] is not None:\n                    c['colorbar'].visible = False\n                c['brain']._remove_scalar_data(c['array_id'])\n            self.contour_list = []\n\n        # Process colormap argument into a lut\n        lut = create_color_lut(colormap)\n\n        views = self._toggle_render(False)\n        for brain in self.brains:\n            if brain.hemi == hemi:\n                self.contour_list.append(brain.add_contour_overlay(\n                    scalar_data, min, max, n_contours, line_width, lut,\n                    colorbar))\n        self._toggle_render(True, views)\n\n    def add_text(self, x, y, text, name, color=None, opacity=1.0,\n                 row=-1, col=-1, font_size=None, justification=None):\n        \"\"\" Add a text to the visualization\n\n        Parameters\n        ----------\n        x : Float\n            x coordinate\n        y : Float\n            y coordinate\n        text : str\n            Text to add\n        name : str\n            Name of the text (text label can be updated using update_text())\n        color : Tuple\n            Color of the text. Default is the foreground color set during\n            initialization (default is black or white depending on the\n            background color).\n        opacity : Float\n            Opacity of the text. Default: 1.0\n        row : int\n            Row index of which brain to use\n        col : int\n            Column index of which brain to use\n        \"\"\"\n        if name in self.texts_dict:\n            self.texts_dict[name]['text'].remove()\n        text = self.brain_matrix[row, col].add_text(x, y, text,\n                                                    name, color, opacity)\n        self.texts_dict[name] = dict(row=row, col=col, text=text)\n        if font_size is not None:\n            text.property.font_size = font_size\n            text.actor.text_scale_mode = 'viewport'\n        if justification is not None:\n            text.property.justification = justification\n\n    def update_text(self, text, name, row=-1, col=-1):\n        \"\"\"Update text label\n\n        Parameters\n        ----------\n        text : str\n            New text for label\n        name : str\n            Name of text label\n        \"\"\"\n        if name not in self.texts_dict:\n            raise KeyError('text name \"%s\" unknown' % name)\n        self.texts_dict[name]['text'].text = text\n\n    ###########################################################################\n    # DATA SCALING \/ DISPLAY\n    def reset_view(self):\n        \"\"\"Orient camera to display original view\n        \"\"\"\n        for view, brain in zip(self._original_views, self._brain_list):\n            brain['brain'].show_view(view)\n\n    def show_view(self, view=None, roll=None, distance=None, row=-1, col=-1):\n        \"\"\"Orient camera to display view\n\n        Parameters\n        ----------\n        view : str | dict\n            brain surface to view (one of 'lateral', 'medial', 'rostral',\n            'caudal', 'dorsal', 'ventral', 'frontal', 'parietal') or kwargs to\n            pass to :func:`mayavi.mlab.view()`.\n        roll : float\n            camera roll\n        distance : float | 'auto' | None\n            distance from the origin\n        row : int\n            Row index of which brain to use\n        col : int\n            Column index of which brain to use\n\n        Returns\n        -------\n        view : tuple\n            tuple returned from mlab.view\n        roll : float\n            camera roll returned from mlab.roll\n        \"\"\"\n        return self.brain_matrix[row][col].show_view(view, roll, distance)\n\n    def set_distance(self, distance=None):\n        \"\"\"Set view distances for all brain plots to the same value\n\n        Parameters\n        ----------\n        distance : float | None\n            Distance to use. If None, brains are set to the farthest\n            \"best fit\" distance across all current views; note that\n            the underlying \"best fit\" function can be buggy.\n\n        Returns\n        -------\n        distance : float\n            The distance used.\n        \"\"\"\n        if distance is None:\n            distance = []\n            for ff in self._figures:\n                for f in ff:\n                    mlab.view(figure=f, distance='auto')\n                    v = mlab.view(figure=f)\n                    # This should only happen for the test backend\n                    if v is None:\n                        v = [0, 0, 100]\n                    distance += [v[2]]\n            distance = max(distance)\n\n        for ff in self._figures:\n            for f in ff:\n                mlab.view(distance=distance, figure=f)\n        return distance\n\n    def set_surf(self, surf):\n        \"\"\"Change the surface geometry\n\n        Parameters\n        ----------\n        surf : str\n            freesurfer surface mesh name (ie 'white', 'inflated', etc.)\n        \"\"\"\n        if self.surf == surf:\n            return\n\n        views = self._toggle_render(False)\n\n        # load new geometry\n        for geo in self.geo.values():\n            try:\n                geo.surf = surf\n                geo.load_geometry()\n            except IOError:  # surface file does not exist\n                geo.surf = self.surf\n                self._toggle_render(True)\n                raise\n\n        # update mesh objects (they use a reference to geo.coords)\n        for brain in self.brains:\n            brain._geo_mesh.data.points = self.geo[brain.hemi].coords\n            brain.update_surf()\n\n        self.surf = surf\n        self._toggle_render(True, views)\n\n        for brain in self.brains:\n            if brain._f.scene is not None:\n                brain._f.scene.reset_zoom()\n\n    @property\n    def _brain_color(self):\n        geo_actor = self._brain_list[0]['brain']._geo_surf.actor\n        if self._brain_list[0]['brain']._using_lut:\n            bgcolor = np.mean(\n                self._brain_list[0]['brain']._geo_surf.module_manager\n                .scalar_lut_manager.lut.table.to_array(), axis=0)\n        else:\n            bgcolor = geo_actor.property.color\n            if len(bgcolor) == 3:\n                bgcolor = bgcolor + (1,)\n            bgcolor = 255 * np.array(bgcolor)\n        bgcolor[-1] *= geo_actor.property.opacity\n        return bgcolor\n\n    @verbose\n    def scale_data_colormap(self, fmin, fmid, fmax, transparent,\n                            center=None, alpha=1.0, data=None, verbose=None):\n        \"\"\"Scale the data colormap.\n\n        The colormap may be sequential or divergent. When the colormap is\n        divergent indicate this by providing a value for 'center'. The\n        meanings of fmin, fmid and fmax are different for sequential and\n        divergent colormaps. For sequential colormaps the colormap is\n        characterised by::\n\n            [fmin, fmid, fmax]\n\n        where fmin and fmax define the edges of the colormap and fmid will be\n        the value mapped to the center of the originally chosen colormap. For\n        divergent colormaps the colormap is characterised by::\n\n            [center-fmax, center-fmid, center-fmin, center,\n             center+fmin, center+fmid, center+fmax]\n\n        i.e., values between center-fmin and center+fmin will not be shown\n        while center-fmid will map to the middle of the first half of the\n        original colormap and center-fmid to the middle of the second half.\n\n        Parameters\n        ----------\n        fmin : float\n            minimum value for colormap\n        fmid : float\n            value corresponding to color midpoint\n        fmax : float\n            maximum value for colormap\n        transparent : boolean\n            if True: use a linear transparency between fmin and fmid and make\n            values below fmin fully transparent (symmetrically for divergent\n            colormaps)\n        center : float\n            if not None, gives the data value that should be mapped to the\n            center of the (divergent) colormap\n        alpha : float\n            sets the overall opacity of colors, maintains transparent regions\n        data : dict | None\n            The data entry for which to scale the colormap.\n            If None, will use the data dict from either the left or right\n            hemisphere (in that order).\n        verbose : bool, str, int, or None\n            If not None, override default verbose level (see surfer.verbose).\n        \"\"\"\n        divergent = center is not None\n\n        # Get the original colormap\n        if data is None:\n            for h in ['lh', 'rh']:\n                data = self.data_dict[h]\n                if data is not None:\n                    break\n        table = data[\"orig_ctable\"].copy()\n\n        lut = _scale_mayavi_lut(table, fmin, fmid, fmax, transparent,\n                                center, alpha)\n\n        # Get the effective background color as 255-based 4-element array\n        bgcolor = self._brain_color\n\n        views = self._toggle_render(False)\n        # Use the new colormap\n        for hemi in ['lh', 'rh']:\n            data = self.data_dict[hemi]\n            if data is not None:\n                for surf in data['surfaces']:\n                    cmap = surf.module_manager.scalar_lut_manager\n                    cmap.load_lut_from_list(lut \/ 255.)\n                    if divergent:\n                        cmap.data_range = np.array([center-fmax, center+fmax])\n                    else:\n                        cmap.data_range = np.array([fmin, fmax])\n\n                    # if there is any transparent color in the lut\n                    if np.any(lut[:, -1] < 255):\n                        # Update the colorbar to deal with transparency\n                        cbar_lut = tvtk.LookupTable()\n                        cbar_lut.deep_copy(surf.module_manager\n                                           .scalar_lut_manager.lut)\n                        alphas = lut[:, -1][:, np.newaxis] \/ 255.\n                        use_lut = lut.copy()\n                        use_lut[:, -1] = 255.\n                        vals = (use_lut * alphas) + bgcolor * (1 - alphas)\n                        cbar_lut.table.from_array(vals)\n                        cmap.scalar_bar.lookup_table = cbar_lut\n                        cmap.scalar_bar.use_opacity = 1\n\n                # Update the data properties\n                data.update(fmin=fmin, fmid=fmid, fmax=fmax, center=center,\n                            transparent=transparent)\n                # And the hemisphere properties to match\n                for glyph in data['glyphs']:\n                    if glyph is not None:\n                        l_m = glyph.parent.vector_lut_manager\n                        l_m.load_lut_from_list(lut \/ 255.)\n                        if divergent:\n                            l_m.data_range = np.array(\n                                    [center-fmax, center+fmax])\n                        else:\n                            l_m.data_range = np.array([fmin, fmax])\n\n        self._toggle_render(True, views)\n\n    def set_data_time_index(self, time_idx, interpolation='quadratic'):\n        \"\"\"Set the data time index to show\n\n        Parameters\n        ----------\n        time_idx : int | float\n            Time index. Non-integer values will be displayed using\n            interpolation between samples.\n        interpolation : str\n            Interpolation method (``scipy.interpolate.interp1d`` parameter,\n            one of 'linear' | 'nearest' | 'zero' | 'slinear' | 'quadratic' |\n            'cubic', default 'quadratic'). Interpolation is only used for\n            non-integer indexes.\n        \"\"\"\n        from scipy.interpolate import interp1d\n        if self.n_times is None:\n            raise RuntimeError('cannot set time index with no time data')\n        if time_idx < 0 or time_idx >= self.n_times:\n            raise ValueError(\"time index out of range\")\n\n        views = self._toggle_render(False)\n        for hemi in ['lh', 'rh']:\n            for data in self._data_dicts[hemi]:\n                if data['array'].ndim == 1:\n                    continue  # skip data without time axis\n\n                # interpolation\n                if data['array'].ndim == 2:\n                    scalar_data = data['array']\n                    vectors = None\n                else:\n                    scalar_data = data['magnitude']\n                    vectors = data['array']\n                if isinstance(time_idx, float):\n                    times = np.arange(self.n_times)\n                    scalar_data = interp1d(\n                        times, scalar_data, interpolation, axis=1,\n                        assume_sorted=True)(time_idx)\n                    if vectors is not None:\n                        vectors = interp1d(\n                            times, vectors, interpolation, axis=2,\n                            assume_sorted=True)(time_idx)\n                else:\n                    scalar_data = scalar_data[:, time_idx]\n                    if vectors is not None:\n                        vectors = vectors[:, :, time_idx]\n\n                vector_values = scalar_data.copy()\n                if data['smooth_mat'] is not None:\n                    scalar_data = data['smooth_mat'] * scalar_data\n                for brain in self.brains:\n                    if brain.hemi == hemi:\n                        brain.set_data(data['layer_id'], scalar_data,\n                                       vectors, vector_values)\n                del brain\n                data[\"time_idx\"] = time_idx\n\n                # Update time label\n                if data[\"time_label\"]:\n                    if isinstance(time_idx, float):\n                        ifunc = interp1d(times, data['time'])\n                        time = ifunc(time_idx)\n                    else:\n                        time = data[\"time\"][time_idx]\n                    self.update_text(data[\"time_label\"](time), \"time_label\")\n\n        self._toggle_render(True, views)\n\n    @property\n    def data_time_index(self):\n        \"\"\"Retrieve the currently displayed data time index\n\n        Returns\n        -------\n        time_idx : int\n            Current time index.\n\n        Notes\n        -----\n        Raises a RuntimeError if the Brain instance has not data overlay.\n        \"\"\"\n        for hemi in ['lh', 'rh']:\n            data = self.data_dict[hemi]\n            if data is not None:\n                time_idx = data[\"time_idx\"]\n                return time_idx\n        raise RuntimeError(\"Brain instance has no data overlay\")\n\n    @verbose\n    def set_data_smoothing_steps(self, smoothing_steps, verbose=None):\n        \"\"\"Set the number of smoothing steps\n\n        Parameters\n        ----------\n        smoothing_steps : int\n            Number of smoothing steps\n        verbose : bool, str, int, or None\n            If not None, override default verbose level (see surfer.verbose).\n        \"\"\"\n        views = self._toggle_render(False)\n        for hemi in ['lh', 'rh']:\n            data = self.data_dict[hemi]\n            if data is not None:\n                adj_mat = utils.mesh_edges(self.geo[hemi].faces)\n                smooth_mat = utils.smoothing_matrix(data[\"vertices\"],\n                                                    adj_mat, smoothing_steps)\n                data[\"smooth_mat\"] = smooth_mat\n\n                # Redraw\n                if data[\"array\"].ndim == 1:\n                    plot_data = data[\"array\"]\n                elif data[\"array\"].ndim == 2:\n                    plot_data = data[\"array\"][:, data[\"time_idx\"]]\n                else:  # vector-valued\n                    plot_data = data[\"magnitude\"][:, data[\"time_idx\"]]\n\n                plot_data = data[\"smooth_mat\"] * plot_data\n                for brain in self.brains:\n                    if brain.hemi == hemi:\n                        brain.set_data(data['layer_id'], plot_data)\n\n                # Update data properties\n                data[\"smoothing_steps\"] = smoothing_steps\n        self._toggle_render(True, views)\n\n    def index_for_time(self, time, rounding='closest'):\n        \"\"\"Find the data time index closest to a specific time point.\n\n        Parameters\n        ----------\n        time : scalar\n            Time.\n        rounding : 'closest' | 'up' | 'down'\n            How to round if the exact time point is not an index.\n\n        Returns\n        -------\n        index : int\n            Data time index closest to time.\n        \"\"\"\n        if self.n_times is None:\n            raise RuntimeError(\"Brain has no time axis\")\n        times = self._times\n\n        # Check that time is in range\n        tmin = np.min(times)\n        tmax = np.max(times)\n        max_diff = (tmax - tmin) \/ (len(times) - 1) \/ 2\n        if time < tmin - max_diff or time > tmax + max_diff:\n            err = (\"time = %s lies outside of the time axis \"\n                   \"[%s, %s]\" % (time, tmin, tmax))\n            raise ValueError(err)\n\n        if rounding == 'closest':\n            idx = np.argmin(np.abs(times - time))\n        elif rounding == 'up':\n            idx = np.nonzero(times >= time)[0][0]\n        elif rounding == 'down':\n            idx = np.nonzero(times <= time)[0][-1]\n        else:\n            err = \"Invalid rounding parameter: %s\" % repr(rounding)\n            raise ValueError(err)\n\n        return idx\n\n    def set_time(self, time):\n        \"\"\"Set the data time index to the time point closest to time\n\n        Parameters\n        ----------\n        time : scalar\n            Time.\n        \"\"\"\n        idx = self.index_for_time(time)\n        self.set_data_time_index(idx)\n\n    def _get_colorbars(self, row, col):\n        shape = self.brain_matrix.shape\n        row = row % shape[0]\n        col = col % shape[1]\n        ind = np.ravel_multi_index((row, col), self.brain_matrix.shape)\n        colorbars = []\n        h = self._brain_list[ind]['hemi']\n        if self.data_dict[h] is not None and 'colorbars' in self.data_dict[h]:\n            colorbars.append(self.data_dict[h]['colorbars'][row])\n        if len(self.morphometry_list) > 0:\n            colorbars.append(self.morphometry_list[ind]['colorbar'])\n        if len(self.contour_list) > 0:\n            colorbars.append(self.contour_list[ind]['colorbar'])\n        if len(self.overlays_dict) > 0:\n            for name, obj in self.overlays_dict.items():\n                for bar in [\"pos_bar\", \"neg_bar\"]:\n                    try:  # deal with positive overlays\n                        this_ind = min(len(obj) - 1, ind)\n                        colorbars.append(getattr(obj[this_ind], bar))\n                    except AttributeError:\n                        pass\n        return colorbars\n\n    def _colorbar_visibility(self, visible, row, col):\n        for cb in self._get_colorbars(row, col):\n            if cb is not None:\n                cb.visible = visible\n\n    def show_colorbar(self, row=-1, col=-1):\n        \"\"\"Show colorbar(s) for given plot\n\n        Parameters\n        ----------\n        row : int\n            Row index of which brain to use\n        col : int\n            Column index of which brain to use\n        \"\"\"\n        self._colorbar_visibility(True, row, col)\n\n    def hide_colorbar(self, row=-1, col=-1):\n        \"\"\"Hide colorbar(s) for given plot\n\n        Parameters\n        ----------\n        row : int\n            Row index of which brain to use\n        col : int\n            Column index of which brain to use\n        \"\"\"\n        self._colorbar_visibility(False, row, col)\n\n    def close(self):\n        \"\"\"Close all figures and cleanup data structure.\"\"\"\n        for ri, ff in enumerate(self._figures):\n            for ci, f in enumerate(ff):\n                if f is not None:\n                    mlab.close(f)\n                    self._figures[ri][ci] = None\n        _force_render([])\n\n        # should we tear down other variables?\n        if self._v is not None:\n            self._v.dispose()\n            self._v = None\n\n    def __del__(self):\n        if hasattr(self, '_v') and self._v is not None:\n            self._v.dispose()\n            self._v = None\n\n    ###########################################################################\n    # SAVING OUTPUT\n    def save_single_image(self, filename, row=-1, col=-1):\n        \"\"\"Save view from one panel to disk\n\n        Only mayavi image types are supported:\n        (png jpg bmp tiff ps eps pdf rib  oogl iv  vrml obj\n\n        Parameters\n        ----------\n        filename: string\n            path to new image file\n        row : int\n            row index of the brain to use\n        col : int\n            column index of the brain to use\n\n        Due to limitations in TraitsUI, if multiple views or hemi='split'\n        is used, there is no guarantee painting of the windows will\n        complete before control is returned to the command line. Thus\n        we strongly recommend using only one figure window (which uses\n        a Mayavi figure to plot instead of TraitsUI) if you intend to\n        script plotting commands.\n        \"\"\"\n        brain = self.brain_matrix[row, col]\n        ftype = filename[filename.rfind('.') + 1:]\n        good_ftypes = ['png', 'jpg', 'bmp', 'tiff', 'ps',\n                       'eps', 'pdf', 'rib', 'oogl', 'iv', 'vrml', 'obj']\n        if ftype not in good_ftypes:\n            raise ValueError(\"Supported image types are %s\"\n                             % \" \".join(good_ftypes))\n        mlab.draw(brain._f)\n        if mlab.options.backend != 'test':\n            mlab.savefig(filename, figure=brain._f)\n\n    def _screenshot_figure(self, mode='rgb', antialiased=False):\n        \"\"\"Create a matplolib figure from the current screenshot.\"\"\"\n        # adapted from matplotlib.image.imsave\n        from matplotlib.backends.backend_agg import FigureCanvasAgg\n        from matplotlib.figure import Figure\n        fig = Figure(frameon=False)\n        FigureCanvasAgg(fig)\n        fig.figimage(self.screenshot(mode, antialiased), resize=True)\n        return fig\n\n    def save_image(self, filename, mode='rgb', antialiased=False):\n        \"\"\"Save view from all panels to disk\n\n        Only mayavi image types are supported:\n        (png jpg bmp tiff ps eps pdf rib  oogl iv  vrml obj\n\n        Parameters\n        ----------\n        filename: string\n            path to new image file\n        mode : string\n            Either 'rgb' (default) to render solid background, or 'rgba' to\n            include alpha channel for transparent background.\n        antialiased : bool\n            Antialias the image (see :func:`mayavi.mlab.screenshot`\n            for details; see default False).\n\n        Notes\n        -----\n        Due to limitations in TraitsUI, if multiple views or hemi='split'\n        is used, there is no guarantee painting of the windows will\n        complete before control is returned to the command line. Thus\n        we strongly recommend using only one figure window (which uses\n        a Mayavi figure to plot instead of TraitsUI) if you intend to\n        script plotting commands.\n        \"\"\"\n        self._screenshot_figure(mode, antialiased).savefig(filename)\n\n    def screenshot(self, mode='rgb', antialiased=False):\n        \"\"\"Generate a screenshot of current view.\n\n        Wraps to :func:`mayavi.mlab.screenshot` for ease of use.\n\n        Parameters\n        ----------\n        mode : string\n            Either 'rgb' or 'rgba' for values to return.\n        antialiased : bool\n            Antialias the image (see :func:`mayavi.mlab.screenshot`\n            for details; default False).\n\n        Returns\n        -------\n        screenshot : array\n            Image pixel values.\n\n        Notes\n        -----\n        Due to limitations in TraitsUI, if multiple views or ``hemi='split'``\n        is used, there is no guarantee painting of the windows will\n        complete before control is returned to the command line. Thus\n        we strongly recommend using only one figure window (which uses\n        a Mayavi figure to plot instead of TraitsUI) if you intend to\n        script plotting commands.\n        \"\"\"\n        row = []\n        for ri in range(self.brain_matrix.shape[0]):\n            col = []\n            n_col = 2 if self._hemi == 'split' else 1\n            for ci in range(n_col):\n                col += [self.screenshot_single(mode, antialiased,\n                                               ri, ci)]\n            row += [np.concatenate(col, axis=1)]\n        data = np.concatenate(row, axis=0)\n        return data\n\n    def screenshot_single(self, mode='rgb', antialiased=False, row=-1, col=-1):\n        \"\"\"Generate a screenshot of current view from a single panel.\n\n        Wraps to :func:`mayavi.mlab.screenshot` for ease of use.\n\n        Parameters\n        ----------\n        mode: string\n            Either 'rgb' or 'rgba' for values to return\n        antialiased: bool\n            Antialias the image (see :func:`mayavi.mlab.screenshot`\n            for details).\n        row : int\n            row index of the brain to use\n        col : int\n            column index of the brain to use\n\n        Returns\n        -------\n        screenshot: array\n            Image pixel values\n\n        Notes\n        -----\n        Due to limitations in TraitsUI, if multiple views or hemi='split'\n        is used, there is no guarantee painting of the windows will\n        complete before control is returned to the command line. Thus\n        we strongly recommend using only one figure window (which uses\n        a Mayavi figure to plot instead of TraitsUI) if you intend to\n        script plotting commands.\n        \"\"\"\n        brain = self.brain_matrix[row, col]\n        if mlab.options.backend != 'test':\n            return mlab.screenshot(brain._f, mode, antialiased)\n        else:\n            out = np.ones(tuple(self._scene_size) + (3,), np.uint8)\n            out[0, 0, 0] = 0\n            return out\n\n    def save_imageset(self, prefix, views, filetype='png', colorbar='auto',\n                      row=-1, col=-1):\n        \"\"\"Convenience wrapper for save_image\n\n        Files created are prefix+'_$view'+filetype\n\n        Parameters\n        ----------\n        prefix: string | None\n            filename prefix for image to be created. If None, a list of\n            arrays representing images is returned (not saved to disk).\n        views: list\n            desired views for images\n        filetype: string\n            image type\n        colorbar: 'auto' | int | list of int | None\n            For 'auto', the colorbar is shown in the middle view (default).\n            For int or list of int, the colorbar is shown in the specified\n            views. For ``None``, no colorbar is shown.\n        row : int\n            row index of the brain to use\n        col : int\n            column index of the brain to use\n\n        Returns\n        -------\n        images_written: list\n            all filenames written\n        \"\"\"\n        if isinstance(views, string_types):\n            raise ValueError(\"Views must be a non-string sequence\"\n                             \"Use show_view & save_image for a single view\")\n        if colorbar == 'auto':\n            colorbar = [len(views) \/\/ 2]\n        elif isinstance(colorbar, int):\n            colorbar = [colorbar]\n        images_written = []\n        for iview, view in enumerate(views):\n            try:\n                if colorbar is not None and iview in colorbar:\n                    self.show_colorbar(row, col)\n                else:\n                    self.hide_colorbar(row, col)\n                self.show_view(view, row=row, col=col)\n                if prefix is not None:\n                    fname = \"%s_%s.%s\" % (prefix, view, filetype)\n                    images_written.append(fname)\n                    self.save_single_image(fname, row, col)\n                else:\n                    images_written.append(self.screenshot_single(row=row,\n                                                                 col=col))\n            except ValueError:\n                print(\"Skipping %s: not in view dict\" % view)\n        return images_written\n\n    def save_image_sequence(self, time_idx, fname_pattern, use_abs_idx=True,\n                            row=-1, col=-1, montage='single', border_size=15,\n                            colorbar='auto', interpolation='quadratic'):\n        \"\"\"Save a temporal image sequence\n\n        The files saved are named ``fname_pattern % pos`` where ``pos`` is a\n        relative or absolute index (controlled by ``use_abs_idx``).\n\n        Parameters\n        ----------\n        time_idx : array_like\n            Time indices to save. Non-integer values will be displayed using\n            interpolation between samples.\n        fname_pattern : str\n            Filename pattern, e.g. 'movie-frame_%0.4d.png'.\n        use_abs_idx : bool\n            If True the indices given by ``time_idx`` are used in the filename\n            if False the index in the filename starts at zero and is\n            incremented by one for each image (Default: True).\n        row : int\n            Row index of the brain to use.\n        col : int\n            Column index of the brain to use.\n        montage : 'current' | 'single' | list\n            Views to include in the images: 'current' uses the currently\n            displayed image; 'single' (default) uses a single view, specified\n            by the ``row`` and ``col`` parameters; a 1 or 2 dimensional list\n            can be used to specify a complete montage. Examples:\n            ``['lat', 'med']`` lateral and ventral views ordered horizontally;\n            ``[['fro'], ['ven']]`` frontal and ventral views ordered\n            vertically.\n        border_size : int\n            Size of image border (more or less space between images).\n        colorbar : 'auto' | int | list of int | None\n            For 'auto', the colorbar is shown in the middle view (default).\n            For int or list of int, the colorbar is shown in the specified\n            views. For ``None``, no colorbar is shown.\n        interpolation : str\n            Interpolation method (``scipy.interpolate.interp1d`` parameter,\n            one of 'linear' | 'nearest' | 'zero' | 'slinear' | 'quadratic' |\n            'cubic', default 'quadratic'). Interpolation is only used for\n            non-integer indexes.\n\n        Returns\n        -------\n        images_written : list\n            All filenames written.\n        \"\"\"\n        images_written = list()\n        for i, idx in enumerate(self._iter_time(time_idx, interpolation)):\n            fname = fname_pattern % (idx if use_abs_idx else i)\n            if montage == 'single':\n                self.save_single_image(fname, row, col)\n            elif montage == 'current':\n                self.save_image(fname)\n            else:\n                self.save_montage(fname, montage, 'h', border_size, colorbar,\n                                  row, col)\n            images_written.append(fname)\n\n        return images_written\n\n    def save_montage(self, filename, order=['lat', 'ven', 'med'],\n                     orientation='h', border_size=15, colorbar='auto',\n                     row=-1, col=-1):\n        \"\"\"Create a montage from a given order of images\n\n        Parameters\n        ----------\n        filename: string | None\n            path to final image. If None, the image will not be saved.\n        order: list\n            list of views: order of views to build montage (default\n            ``['lat', 'ven', 'med']``; nested list of views to specify\n            views in a 2-dimensional grid (e.g,\n            ``[['lat', 'ven'], ['med', 'fro']]``)\n        orientation: {'h' | 'v'}\n            montage image orientation (horizontal of vertical alignment; only\n            applies if ``order`` is a flat list)\n        border_size: int\n            Size of image border (more or less space between images)\n        colorbar: 'auto' | int | list of int | None\n            For 'auto', the colorbar is shown in the middle view (default).\n            For int or list of int, the colorbar is shown in the specified\n            views. For ``None``, no colorbar is shown.\n        row : int\n            row index of the brain to use\n        col : int\n            column index of the brain to use\n\n        Returns\n        -------\n        out : array\n            The montage image, usable with :func:`matplotlib.pyplot.imshow`.\n        \"\"\"\n        # find flat list of views and nested list of view indexes\n        assert orientation in ['h', 'v']\n        if isinstance(order, (str, dict)):\n            views = [order]\n        elif all(isinstance(x, (str, dict)) for x in order):\n            views = order\n        else:\n            views = []\n            orientation = []\n            for row_order in order:\n                if isinstance(row_order, (str, dict)):\n                    orientation.append([len(views)])\n                    views.append(row_order)\n                else:\n                    orientation.append([])\n                    for view in row_order:\n                        orientation[-1].append(len(views))\n                        views.append(view)\n\n        if colorbar == 'auto':\n            colorbar = [len(views) \/\/ 2]\n        elif isinstance(colorbar, int):\n            colorbar = [colorbar]\n        brain = self.brain_matrix[row, col]\n\n        # store current view + colorbar visibility\n        with warnings.catch_warnings(record=True):  # traits focalpoint\n            current_view = mlab.view(figure=brain._f)\n        colorbars = self._get_colorbars(row, col)\n        colorbars_visibility = dict()\n        for cb in colorbars:\n            if cb is not None:\n                colorbars_visibility[cb] = cb.visible\n\n        images = self.save_imageset(None, views, colorbar=colorbar, row=row,\n                                    col=col)\n        out = make_montage(filename, images, orientation, colorbar,\n                           border_size)\n\n        # get back original view and colorbars\n        if current_view is not None:  # can be None with test backend\n            with warnings.catch_warnings(record=True):  # traits focalpoint\n                mlab.view(*current_view, figure=brain._f)\n        for cb in colorbars:\n            if cb is not None:\n                cb.visible = colorbars_visibility[cb]\n        return out\n\n    def save_movie(self, fname, time_dilation=4., tmin=None, tmax=None,\n                   framerate=24, interpolation='quadratic', codec=None,\n                   bitrate=None, **kwargs):\n        \"\"\"Save a movie (for data with a time axis)\n\n        The movie is created through the :mod:`imageio` module. The format is\n        determined by the extension, and additional options can be specified\n        through keyword arguments that depend on the format. For available\n        formats and corresponding parameters see the imageio documentation:\n        http:\/\/imageio.readthedocs.io\/en\/latest\/formats.html#multiple-images\n\n        .. Warning::\n            This method assumes that time is specified in seconds when adding\n            data. If time is specified in milliseconds this will result in\n            movies 1000 times longer than expected.\n\n        Parameters\n        ----------\n        fname : str\n            Path at which to save the movie. The extension determines the\n            format (e.g., `'*.mov'`, `'*.gif'`, ...; see the :mod:`imageio`\n            documenttion for available formats).\n        time_dilation : float\n            Factor by which to stretch time (default 4). For example, an epoch\n            from -100 to 600 ms lasts 700 ms. With ``time_dilation=4`` this\n            would result in a 2.8 s long movie.\n        tmin : float\n            First time point to include (default: all data).\n        tmax : float\n            Last time point to include (default: all data).\n        framerate : float\n            Framerate of the movie (frames per second, default 24).\n        interpolation : str\n            Interpolation method (``scipy.interpolate.interp1d`` parameter,\n            one of 'linear' | 'nearest' | 'zero' | 'slinear' | 'quadratic' |\n            'cubic', default 'quadratic').\n        **kwargs :\n            Specify additional options for :mod:`imageio`.\n\n        Notes\n        -----\n        Requires imageio package, which can be installed together with\n        PySurfer with::\n\n            $ pip install -U pysurfer[save_movie]\n        \"\"\"\n        try:\n            import imageio\n        except ImportError:\n            raise ImportError(\"Saving movies from PySurfer requires the \"\n                              \"imageio library. To install imageio with pip, \"\n                              \"run\\n\\n    $ pip install imageio\\n\\nTo \"\n                              \"install\/update PySurfer and imageio together, \"\n                              \"run\\n\\n    $ pip install -U \"\n                              \"pysurfer[save_movie]\\n\")\n        from scipy.interpolate import interp1d\n\n        # find imageio FFMPEG parameters\n        if 'fps' not in kwargs:\n            kwargs['fps'] = framerate\n        if codec is not None:\n            kwargs['codec'] = codec\n        if bitrate is not None:\n            kwargs['bitrate'] = bitrate\n\n        # find tmin\n        if tmin is None:\n            tmin = self._times[0]\n        elif tmin < self._times[0]:\n            raise ValueError(\"tmin=%r is smaller than the first time point \"\n                             \"(%r)\" % (tmin, self._times[0]))\n\n        # find indexes at which to create frames\n        if tmax is None:\n            tmax = self._times[-1]\n        elif tmax > self._times[-1]:\n            raise ValueError(\"tmax=%r is greater than the latest time point \"\n                             \"(%r)\" % (tmax, self._times[-1]))\n        n_frames = floor((tmax - tmin) * time_dilation * framerate)\n        times = np.arange(n_frames, dtype=float)\n        times \/= framerate * time_dilation\n        times += tmin\n        interp_func = interp1d(self._times, np.arange(self.n_times))\n        time_idx = interp_func(times)\n\n        n_times = len(time_idx)\n        if n_times == 0:\n            raise ValueError(\"No time points selected\")\n\n        logger.debug(\"Save movie for time points\/samples\\n%s\\n%s\"\n                     % (times, time_idx))\n        # Sometimes the first screenshot is rendered with a different\n        # resolution on OS X\n        self.screenshot()\n        images = [self.screenshot() for _ in\n                  self._iter_time(time_idx, interpolation)]\n        imageio.mimwrite(fname, images, **kwargs)\n\n    def animate(self, views, n_steps=180., fname=None, use_cache=False,\n                row=-1, col=-1):\n        \"\"\"Animate a rotation.\n\n        Currently only rotations through the axial plane are allowed.\n\n        Parameters\n        ----------\n        views: sequence\n            views to animate through\n        n_steps: float\n            number of steps to take in between\n        fname: string\n            If not None, it saves the animation as a movie.\n            fname should end in '.avi' as only the AVI format is supported\n        use_cache: bool\n            Use previously generated images in ``.\/.tmp\/``\n        row : int\n            Row index of the brain to use\n        col : int\n            Column index of the brain to use\n        \"\"\"\n        brain = self.brain_matrix[row, col]\n        gviews = list(map(brain._xfm_view, views))\n        allowed = ('lateral', 'caudal', 'medial', 'rostral')\n        if not len([v for v in gviews if v in allowed]) == len(gviews):\n            raise ValueError('Animate through %s views.' % ' '.join(allowed))\n        if fname is not None:\n            if not fname.endswith('.avi'):\n                raise ValueError('Can only output to AVI currently.')\n            tmp_dir = '.\/.tmp'\n            tmp_fname = pjoin(tmp_dir, '%05d.png')\n            if not os.path.isdir(tmp_dir):\n                os.mkdir(tmp_dir)\n        for i, beg in enumerate(gviews):\n            try:\n                end = gviews[i + 1]\n                dv, dr = brain._min_diff(beg, end)\n                dv \/= np.array((n_steps))\n                dr \/= np.array((n_steps))\n                brain.show_view(beg)\n                for i in range(int(n_steps)):\n                    brain._f.scene.camera.orthogonalize_view_up()\n                    brain._f.scene.camera.azimuth(dv[0])\n                    brain._f.scene.camera.elevation(dv[1])\n                    brain._f.scene.renderer.reset_camera_clipping_range()\n                    _force_render([[brain._f]])\n                    if fname is not None:\n                        if not (os.path.isfile(tmp_fname % i) and use_cache):\n                            self.save_single_image(tmp_fname % i, row, col)\n            except IndexError:\n                pass\n        if fname is not None:\n            fps = 10\n            # we'll probably want some config options here\n            enc_cmd = \" \".join([\"mencoder\",\n                                \"-ovc lavc\",\n                                \"-mf fps=%d\" % fps,\n                                \"mf:\/\/%s\" % tmp_fname,\n                                \"-of avi\",\n                                \"-lavcopts vcodec=mjpeg\",\n                                \"-ofps %d\" % fps,\n                                \"-noskip\",\n                                \"-o %s\" % fname])\n            ret = os.system(enc_cmd)\n            if ret:\n                print(\"\\n\\nError occured when exporting movie\\n\\n\")\n\n\ndef _scale_sequential_lut(lut_table, fmin, fmid, fmax):\n    \"\"\"Scale a sequential colormap.\"\"\"\n\n    lut_table_new = lut_table.copy()\n    n_colors = lut_table.shape[0]\n    n_colors2 = n_colors \/\/ 2\n\n    # Index of fmid in new colorbar (which position along the N colors would\n    # fmid take, if fmin is first and fmax is last?)\n    fmid_idx = int(np.round(n_colors * ((fmid - fmin) \/\n                                        (fmax - fmin))) - 1)\n\n    # morph each color channel so that fmid gets assigned the middle color of\n    # the original table and the number of colors to the left and right are\n    # stretched or squeezed such that they correspond to the distance of fmid\n    # to fmin and fmax, respectively\n    for i in range(4):\n        part1 = np.interp(np.linspace(0, n_colors2 - 1, fmid_idx + 1),\n                          np.arange(n_colors),\n                          lut_table[:, i])\n        lut_table_new[:fmid_idx + 1, i] = part1\n        part2 = np.interp(np.linspace(n_colors2, n_colors - 1,\n                                      n_colors - fmid_idx - 1),\n                          np.arange(n_colors),\n                          lut_table[:, i])\n        lut_table_new[fmid_idx + 1:, i] = part2\n\n    return lut_table_new\n\n\ndef _check_limits(fmin, fmid, fmax, extra='f'):\n    \"\"\"Check for monotonicity.\"\"\"\n    if fmin >= fmid:\n        raise ValueError('%smin must be < %smid, got %0.4g >= %0.4g'\n                         % (extra, extra, fmin, fmid))\n    if fmid >= fmax:\n        raise ValueError('%smid must be < %smax, got %0.4g >= %0.4g'\n                         % (extra, extra, fmid, fmax))\n\n\ndef _get_fill_colors(cols, n_fill):\n    \"\"\"Get the fill colors for the middle of divergent colormaps.\n\n    Tries to figure out whether there is a smooth transition in the center of\n    the original colormap. If yes, it chooses the color in the center as the\n    only fill color, else it chooses the two colors between which there is\n    a large step in color space to fill up the middle of the new colormap.\n    \"\"\"\n    steps = np.linalg.norm(np.diff(cols[:, :3].astype(float), axis=0), axis=1)\n\n    # if there is a jump in the middle of the colors\n    # (define a jump as a step in 3D colorspace whose size is 3-times larger\n    # than the mean step size between the first and last steps of the given\n    # colors - I verified that no such jumps exist in the divergent colormaps\n    # of matplotlib 2.0 which all have a smooth transition in the middle)\n    ind = np.flatnonzero(steps[1:-1] > steps[[0, -1]].mean() * 3)\n    if ind.size > 0:\n        # choose the two colors between which there is the large step\n        ind = ind[0] + 1\n        fillcols = np.r_[np.tile(cols[ind, :], (n_fill \/ 2, 1)),\n                         np.tile(cols[ind + 1, :], (n_fill - n_fill \/ 2, 1))]\n    else:\n        # choose a color from the middle of the colormap\n        fillcols = np.tile(cols[int(cols.shape[0] \/ 2), :], (n_fill, 1))\n\n    return fillcols\n\n\n@verbose\ndef _scale_mayavi_lut(lut_table, fmin, fmid, fmax, transparent,\n                      center=None, alpha=1.0, verbose=None):\n    \"\"\"Scale a mayavi colormap LUT to a given fmin, fmid and fmax.\n\n    This function operates on a Mayavi LUTManager. This manager can be obtained\n    through the traits interface of mayavi. For example:\n    ``x.module_manager.vector_lut_manager``.\n\n    Divergent colormaps are respected, if ``center`` is given, see\n    ``Brain.scale_data_colormap`` for more info.\n\n    Parameters\n    ----------\n    lut_orig : array\n        The original LUT.\n    fmin : float\n        minimum value of colormap.\n    fmid : float\n        value corresponding to color midpoint.\n    fmax : float\n        maximum value for colormap.\n    transparent : boolean\n        if True: use a linear transparency between fmin and fmid and make\n        values below fmin fully transparent (symmetrically for divergent\n        colormaps)\n    center : float\n        gives the data value that should be mapped to the center of the\n        (divergent) colormap\n    alpha : float\n        sets the overall opacity of colors, maintains transparent regions\n    verbose : bool, str, int, or None\n        If not None, override default verbose level (see mne.verbose).\n\n    Returns\n    -------\n    lut_table_new : 2D array (n_colors, 4)\n        The re-scaled color lookup table\n    \"\"\"\n    if not (fmin < fmid) and (fmid < fmax):\n        raise ValueError(\"Invalid colormap, we need fmin<fmid<fmax\")\n    if not 0 <= alpha <= 1:\n        raise ValueError(\"Invalid alpha: it needs to be within [0, 1]\")\n\n    # Cast inputs to float to prevent integer division\n    fmin = float(fmin)\n    fmid = float(fmid)\n    fmax = float(fmax)\n    _check_limits(fmin, fmid, fmax)\n\n    divergent = center is not None\n\n    trstr = ['(opaque)', '(transparent)']\n    if divergent:\n        logger.info(\n            \"colormap divergent: center=%0.2e, [%0.2e, %0.2e, %0.2e] %s\"\n            % (center, fmin, fmid, fmax, trstr[transparent]))\n    else:\n        logger.info(\"colormap sequential: [%0.2e, %0.2e, %0.2e] %s\"\n                    % (fmin, fmid, fmax, trstr[transparent]))\n\n    n_colors = lut_table.shape[0]\n\n    # Add transparency if needed\n    if transparent:\n        if divergent:\n            N4 = np.full(4, n_colors \/ 4, dtype=int)\n            N4[:np.mod(n_colors, 4)] += 1\n            assert N4.sum() == n_colors\n            lut_table[:, -1] = np.r_[255 * np.ones(N4[0]),\n                                     np.linspace(255, 0, N4[2]),\n                                     np.linspace(0, 255, N4[3]),\n                                     255 * np.ones(N4[1])]\n        else:\n            n_colors2 = int(n_colors \/ 2)\n            lut_table[:n_colors2, -1] = np.linspace(0, 255, n_colors2)\n            lut_table[n_colors2:, -1] = 255 * np.ones(n_colors - n_colors2)\n\n    alpha = float(alpha)\n    if alpha < 1.0:\n        lut_table[:, -1] = lut_table[:, -1] * alpha\n\n    if divergent:\n        # the colormap should consist of 3 parts: a left part for the negative\n        # data, a right part for the positive data and a middle, fill part\n        # representing the values in [center-fmin, center+fmin], we\n        # introduce this middle part by extending the number of 'colors' of the\n        # original colormap because the Mayavi lut manager scales linearly\n        # between colors and we don't want to reduce the color resolution in\n        # the interesting regions of data space\n        n_colors2 = int(n_colors \/ 2)\n        n_fill = int(round(fmin * n_colors2 \/ (fmax-fmin))) * 2\n        lut_table = np.r_[\n                _scale_sequential_lut(lut_table[:n_colors2, :],\n                                      center-fmax, center-fmid, center-fmin),\n                _get_fill_colors(\n                    lut_table[n_colors2 - 3:n_colors2 + 3, :], n_fill),\n                _scale_sequential_lut(lut_table[n_colors2:, :],\n                                      center+fmin, center+fmid, center+fmax)]\n    else:\n        lut_table = _scale_sequential_lut(lut_table, fmin, fmid, fmax)\n\n    # rescale to 256 colors; this is necessary, because Mayavi\/VTK does not\n    # handle a change in the number of colors well: when you change from a long\n    # table to a short table, values beyond the table value range get somehow\n    # not mapped to the colors defined by the table edges; it may be that this\n    # is due to improper setting of the number of table values \/ colors in the\n    # underlying VTK lookup table, or mapper, but I couldn't figure out where\n    # exactly the fault lies, so simply stick with the constant table size\n    n_colors = lut_table.shape[0]\n    if n_colors != 256:\n        lut = np.zeros((256, 4))\n        x = np.linspace(1, n_colors, 256)\n        for chan in range(4):\n            lut[:, chan] = np.interp(x,\n                                     np.arange(1, n_colors+1),\n                                     lut_table[:, chan])\n        lut_table = lut\n\n    return lut_table\n\n\nclass _Hemisphere(object):\n    \"\"\"Object for visualizing one hemisphere with mlab\"\"\"\n\n    def __init__(self, subject_id, hemi, figure, geo, geo_curv,\n                 geo_kwargs, geo_reverse, subjects_dir, bg_color, backend,\n                 fg_color):\n        if hemi not in ['lh', 'rh']:\n            raise ValueError('hemi must be either \"lh\" or \"rh\"')\n        # Set the identifying info\n        self.subject_id = subject_id\n        self.hemi = hemi\n        self.subjects_dir = subjects_dir\n        self.viewdict = viewdicts[hemi]\n        self._f = figure\n        self._bg_color = bg_color\n        self._fg_color = fg_color\n        self._backend = backend\n        self.data = {}\n        self._mesh_clones = {}  # surface mesh data-sources\n\n        # mlab pipeline mesh and surface for geomtery\n        meshargs = dict(scalars=geo.bin_curv) if geo_curv else dict()\n        with warnings.catch_warnings(record=True):  # traits\n            self._geo_mesh = mlab.pipeline.triangular_mesh_source(\n                geo.x, geo.y, geo.z, geo.faces, figure=self._f, **meshargs)\n        self._geo_mesh.data.points = geo.coords\n        self._mesh_dataset = self._geo_mesh.mlab_source.dataset\n        # add surface normals\n        self._geo_mesh.data.point_data.normals = geo.nn\n        self._geo_mesh.data.cell_data.normals = None\n        if mlab.options.backend != 'test':\n            self._geo_mesh.update()\n        if 'lut' in geo_kwargs:\n            # create a new copy we can modify:\n            geo_kwargs = dict(geo_kwargs)\n            lut = geo_kwargs.pop('lut')\n        else:\n            lut = None\n        self._using_lut = bool(geo_curv)\n        with warnings.catch_warnings(record=True):  # traits warnings\n            self._geo_surf = mlab.pipeline.surface(\n               self._geo_mesh, figure=self._f, reset_zoom=True, **geo_kwargs)\n        self._geo_surf.actor.property.backface_culling = True\n        if lut is not None:\n            lut_manager = self._geo_surf.module_manager.scalar_lut_manager\n            lut_manager.load_lut_from_list(lut \/ 255.)\n        if geo_curv and geo_reverse:\n            curv_bar = mlab.scalarbar(self._geo_surf)\n            curv_bar.reverse_lut = True\n            curv_bar.visible = False\n\n    def show_view(self, view=None, roll=None, distance=None):\n        \"\"\"Orient camera to display view\"\"\"\n        if isinstance(view, string_types):\n            try:\n                vd = self._xfm_view(view, 'd')\n                view = dict(azimuth=vd['v'][0], elevation=vd['v'][1])\n                roll = vd['r']\n            except ValueError as v:\n                print(v)\n                raise\n\n        _force_render(self._f)\n        if view is not None:\n            view = deepcopy(view)\n            view['reset_roll'] = True\n            view['figure'] = self._f\n            if 'distance' not in view:\n                view['distance'] = distance\n            elif distance is not None and distance != view['distance']:\n                raise ValueError('view parameters view[\"distance\"] != '\n                                 'distance (%s != %s)' % (view['distance'],\n                                                          distance))\n            # DO NOT set focal point, can screw up non-centered brains\n            # view['focalpoint'] = (0.0, 0.0, 0.0)\n            mlab.view(**view)\n        if roll is not None:\n            mlab.roll(roll=roll, figure=self._f)\n        _force_render(self._f)\n\n        view = mlab.view(figure=self._f)\n        roll = mlab.roll(figure=self._f)\n\n        return view, roll\n\n    def _xfm_view(self, view, out='s'):\n        \"\"\"Normalize a given string to available view\n\n        Parameters\n        ----------\n        view: string\n            view which may match leading substring of available views\n\n        Returns\n        -------\n        good: string\n            matching view string\n        out: {'s' | 'd'}\n            's' to return string, 'd' to return dict\n\n        \"\"\"\n        if view not in self.viewdict:\n            good_view = [k for k in self.viewdict if view == k[:len(view)]]\n            if len(good_view) == 0:\n                raise ValueError('No views exist with this substring')\n            if len(good_view) > 1:\n                raise ValueError(\"Multiple views exist with this substring.\"\n                                 \"Try a longer substring\")\n            view = good_view[0]\n        if out == 'd':\n            return self.viewdict[view]\n        else:\n            return view\n\n    def _min_diff(self, beg, end):\n        \"\"\"Determine minimum \"camera distance\" between two views.\n\n        Parameters\n        ----------\n        beg : string\n            origin anatomical view.\n        end : string\n            destination anatomical view.\n\n        Returns\n        -------\n        diffs : tuple\n            (min view \"distance\", min roll \"distance\").\n\n        \"\"\"\n        beg = self._xfm_view(beg)\n        end = self._xfm_view(end)\n        if beg == end:\n            dv = [360., 0.]\n            dr = 0\n        else:\n            end_d = self._xfm_view(end, 'd')\n            beg_d = self._xfm_view(beg, 'd')\n            dv = []\n            for b, e in zip(beg_d['v'], end_d['v']):\n                diff = e - b\n                # to minimize the rotation we need -180 <= diff <= 180\n                if diff > 180:\n                    dv.append(diff - 360)\n                elif diff < -180:\n                    dv.append(diff + 360)\n                else:\n                    dv.append(diff)\n            dr = np.array(end_d['r']) - np.array(beg_d['r'])\n        return (np.array(dv), dr)\n\n    def _add_scalar_data(self, data):\n        \"\"\"Add scalar values to dataset\"\"\"\n        array_id = self._mesh_dataset.point_data.add_array(data)\n        self._mesh_dataset.point_data.get_array(array_id).name = array_id\n        self._mesh_dataset.point_data.update()\n\n        # build visualization pipeline\n        with warnings.catch_warnings(record=True):\n            pipe = mlab.pipeline.set_active_attribute(\n                self._mesh_dataset, point_scalars=array_id, figure=self._f)\n            # The new data-source is added to the wrong figure by default\n            # (a Mayavi bug??)\n            if pipe.parent not in self._f.children:\n                self._f.add_child(pipe.parent)\n        self._mesh_clones[array_id] = pipe.parent\n        return array_id, pipe\n\n    def _remove_scalar_data(self, array_id):\n        \"\"\"Removes scalar data\"\"\"\n        self._mesh_clones.pop(array_id).remove()\n        self._mesh_dataset.point_data.remove_array(array_id)\n\n    def _add_vector_data(self, vectors, vector_values, fmin, fmid, fmax,\n                         scale_factor_norm, vertices, vector_alpha, lut):\n        vertices = slice(None) if vertices is None else vertices\n        x, y, z = np.array(self._geo_mesh.data.points.data)[vertices].T\n        vector_alpha = min(vector_alpha, 0.9999999)\n        with warnings.catch_warnings(record=True):  # HasTraits\n            quiver = mlab.quiver3d(\n                x, y, z, vectors[:, 0], vectors[:, 1], vectors[:, 2],\n                scalars=vector_values, colormap='hot', vmin=fmin,\n                vmax=fmax, figure=self._f, opacity=vector_alpha)\n\n        # Enable backface culling\n        quiver.actor.property.backface_culling = True\n        quiver.mlab_source.update()\n\n        # Compute scaling for the glyphs\n        quiver.glyph.glyph.scale_factor = (scale_factor_norm *\n                                           vector_values.max())\n\n        # Scale colormap used for the glyphs\n        l_m = quiver.parent.vector_lut_manager\n        l_m.load_lut_from_list(lut \/ 255.)\n        l_m.data_range = np.array([fmin, fmax])\n        return quiver\n\n    def _remove_vector_data(self, glyphs):\n        if glyphs is not None:\n            glyphs.parent.parent.remove()\n\n    def add_overlay(self, old):\n        \"\"\"Add an overlay to the overlay dict from a file or array\"\"\"\n        array_id, mesh = self._add_scalar_data(old.mlab_data)\n\n        if old.pos_lims is not None:\n            with warnings.catch_warnings(record=True):\n                pos_thresh = threshold_filter(mesh, low=old.pos_lims[0])\n                pos = mlab.pipeline.surface(\n                    pos_thresh, colormap=\"YlOrRd\", figure=self._f,\n                    vmin=old.pos_lims[1], vmax=old.pos_lims[2],\n                    reset_zoom=False)\n                pos.actor.property.backface_culling = False\n                pos_bar = mlab.scalarbar(pos, nb_labels=5)\n            pos_bar.reverse_lut = True\n            pos_bar.scalar_bar_representation.position = (0.53, 0.01)\n            pos_bar.scalar_bar_representation.position2 = (0.42, 0.09)\n            pos_bar.label_text_property.color = self._fg_color\n        else:\n            pos = pos_bar = None\n\n        if old.neg_lims is not None:\n            with warnings.catch_warnings(record=True):\n                neg_thresh = threshold_filter(mesh, up=old.neg_lims[0])\n                neg = mlab.pipeline.surface(\n                    neg_thresh, colormap=\"PuBu\", figure=self._f,\n                    vmin=old.neg_lims[1], vmax=old.neg_lims[2],\n                    reset_zoom=False)\n                neg.actor.property.backface_culling = False\n                neg_bar = mlab.scalarbar(neg, nb_labels=5)\n            neg_bar.scalar_bar_representation.position = (0.05, 0.01)\n            neg_bar.scalar_bar_representation.position2 = (0.42, 0.09)\n            neg_bar.label_text_property.color = self._fg_color\n        else:\n            neg = neg_bar = None\n\n        return OverlayDisplay(self, array_id, pos, pos_bar, neg, neg_bar)\n\n    @verbose\n    def add_data(self, array, fmin, fmid, fmax, thresh, lut, colormap, alpha,\n                 colorbar, layer_id, smooth_mat, magnitude, magnitude_max,\n                 scale_factor, vertices, vector_alpha):\n        \"\"\"Add data to the brain\"\"\"\n        # Calculate initial data to plot\n        if array.ndim == 1:\n            array_plot = array\n        elif array.ndim == 2:\n            array_plot = array[:, 0]\n        elif array.ndim == 3:\n            assert array.shape[1] == 3  # should always be true\n            assert magnitude is not None\n            assert scale_factor is not None\n            array_plot = magnitude[:, 0]\n        else:\n            raise ValueError(\"data has to be 1D, 2D, or 3D\")\n        vector_values = array_plot\n        if smooth_mat is not None:\n            array_plot = smooth_mat * array_plot\n\n        # Copy and byteswap to deal with Mayavi bug\n        array_plot = _prepare_data(array_plot)\n\n        array_id, pipe = self._add_scalar_data(array_plot)\n        scale_factor_norm = None\n        if array.ndim == 3:\n            scale_factor_norm = scale_factor \/ magnitude_max\n            vectors = array[:, :, 0].copy()\n            glyphs = self._add_vector_data(\n                vectors, vector_values, fmin, fmid, fmax,\n                scale_factor_norm, vertices, vector_alpha, lut)\n        else:\n            glyphs = None\n        del scale_factor\n        mesh = pipe.parent\n        if thresh is not None:\n            if array_plot.min() >= thresh:\n                warn(\"Data min is greater than threshold.\")\n            else:\n                with warnings.catch_warnings(record=True):\n                    pipe = threshold_filter(pipe, low=thresh, figure=self._f)\n        with warnings.catch_warnings(record=True):\n            surf = mlab.pipeline.surface(\n                pipe, colormap=colormap, vmin=fmin, vmax=fmax,\n                opacity=float(alpha), figure=self._f, reset_zoom=False)\n            surf.actor.property.backface_culling = False\n\n        # apply look up table if given\n        if lut is not None:\n            l_m = surf.module_manager.scalar_lut_manager\n            l_m.load_lut_from_list(lut \/ 255.)\n\n        # Get the original colormap table\n        orig_ctable = \\\n            surf.module_manager.scalar_lut_manager.lut.table.to_array().copy()\n\n        # Get the colorbar\n        if colorbar:\n            bar = mlab.scalarbar(surf)\n            bar.label_text_property.color = self._fg_color\n            bar.scalar_bar_representation.position2 = .8, 0.09\n        else:\n            bar = None\n\n        self.data[layer_id] = dict(\n            array_id=array_id, mesh=mesh, glyphs=glyphs,\n            scale_factor_norm=scale_factor_norm)\n        return surf, orig_ctable, bar, glyphs\n\n    def add_annotation(self, annot, ids, cmap):\n        \"\"\"Add an annotation file\"\"\"\n        # Add scalar values to dataset\n        array_id, pipe = self._add_scalar_data(ids)\n        with warnings.catch_warnings(record=True):\n            surf = mlab.pipeline.surface(pipe, name=annot, figure=self._f,\n                                         reset_zoom=False)\n            surf.actor.property.backface_culling = False\n\n        # Set the color table\n        l_m = surf.module_manager.scalar_lut_manager\n        l_m.load_lut_from_list(cmap \/ 255.)\n\n        # Set the brain attributes\n        return dict(surface=surf, name=annot, colormap=cmap, brain=self,\n                    array_id=array_id)\n\n    def add_label(self, label, label_name, color, alpha):\n        \"\"\"Add an ROI label to the image\"\"\"\n        from matplotlib.colors import colorConverter\n        array_id, pipe = self._add_scalar_data(label)\n        with warnings.catch_warnings(record=True):\n            surf = mlab.pipeline.surface(pipe, name=label_name, figure=self._f,\n                                         reset_zoom=False)\n            surf.actor.property.backface_culling = False\n        color = colorConverter.to_rgba(color, alpha)\n        cmap = np.array([(0, 0, 0, 0,), color])\n        l_m = surf.module_manager.scalar_lut_manager\n        # for some reason (traits?) using `load_lut_from_list` here does\n        # not work (.data_range needs to be tweaked in this case),\n        # but setting the table directly does:\n        l_m.lut.table = np.round(cmap * 255).astype(np.uint8)\n        return array_id, surf\n\n    def add_morphometry(self, morph_data, colormap, measure,\n                        min, max, colorbar):\n        \"\"\"Add a morphometry overlay to the image\"\"\"\n        array_id, pipe = self._add_scalar_data(morph_data)\n        with warnings.catch_warnings(record=True):\n            surf = mlab.pipeline.surface(\n                pipe, colormap=colormap, vmin=min, vmax=max, name=measure,\n                figure=self._f, reset_zoom=False)\n\n        # Get the colorbar\n        if colorbar:\n            bar = mlab.scalarbar(surf)\n            bar.label_text_property.color = self._fg_color\n            bar.scalar_bar_representation.position2 = .8, 0.09\n        else:\n            bar = None\n\n        # Fil in the morphometry dict\n        return dict(surface=surf, colorbar=bar, measure=measure, brain=self,\n                    array_id=array_id)\n\n    def add_foci(self, foci_coords, scale_factor, color, alpha, name):\n        \"\"\"Add spherical foci, possibly mapping to displayed surf\"\"\"\n        # Create the visualization\n        with warnings.catch_warnings(record=True):  # traits\n            points = mlab.points3d(\n                foci_coords[:, 0], foci_coords[:, 1], foci_coords[:, 2],\n                np.ones(foci_coords.shape[0]), name=name, figure=self._f,\n                scale_factor=(10. * scale_factor), color=color, opacity=alpha)\n        return points\n\n    def add_contour_overlay(self, scalar_data, min=None, max=None,\n                            n_contours=7, line_width=1.5, lut=None,\n                            colorbar=True):\n        \"\"\"Add a topographic contour overlay of the positive data\"\"\"\n        array_id, pipe = self._add_scalar_data(scalar_data)\n        with warnings.catch_warnings(record=True):\n            thresh = threshold_filter(pipe, low=min)\n            surf = mlab.pipeline.contour_surface(\n                thresh, contours=n_contours, line_width=line_width,\n                reset_zoom=False)\n        if lut is not None:\n            l_m = surf.module_manager.scalar_lut_manager\n            l_m.load_lut_from_list(lut \/ 255.)\n\n        # Set the colorbar and range correctly\n        with warnings.catch_warnings(record=True):  # traits\n            bar = mlab.scalarbar(surf, nb_colors=n_contours,\n                                 nb_labels=n_contours + 1)\n        bar.data_range = min, max\n        bar.label_text_property.color = self._fg_color\n        bar.scalar_bar_representation.position2 = .8, 0.09\n        if not colorbar:\n            bar.visible = False\n\n        # Set up a dict attribute with pointers at important things\n        return dict(surface=surf, colorbar=bar, brain=self, array_id=array_id)\n\n    def add_text(self, x, y, text, name, color=None, opacity=1.0):\n        \"\"\" Add a text to the visualization\"\"\"\n        color = self._fg_color if color is None else color\n        with warnings.catch_warnings(record=True):\n            text = mlab.text(x, y, text, name=name, color=color,\n                             opacity=opacity, figure=self._f)\n            return text\n\n    def remove_data(self, layer_id):\n        \"\"\"Remove data shown with .add_data()\"\"\"\n        data = self.data.pop(layer_id)\n        self._remove_scalar_data(data['array_id'])\n        self._remove_vector_data(data['glyphs'])\n\n    def set_data(self, layer_id, values, vectors=None, vector_values=None):\n        \"\"\"Set displayed data values and vectors.\"\"\"\n        data = self.data[layer_id]\n        self._mesh_dataset.point_data.get_array(\n            data['array_id']).from_array(values)\n        # avoid \"AttributeError: 'Scene' object has no attribute 'update'\"\n        data['mesh'].update()\n        if vectors is not None:\n            q = data['glyphs']\n\n            # extract params that will change after calling .update()\n            l_m = q.parent.vector_lut_manager\n            data_range = np.array(l_m.data_range)\n            lut = l_m.lut.table.to_array().copy()\n\n            # Update glyphs\n            q.mlab_source.vectors = vectors\n            q.mlab_source.scalars = vector_values\n            q.mlab_source.update()\n\n            # Update changed parameters, and glyph scaling\n            q.glyph.glyph.scale_factor = (data['scale_factor_norm'] *\n                                          values.max())\n            l_m.load_lut_from_list(lut \/ 255.)\n            l_m.data_range = data_range\n\n    def _orient_lights(self):\n        \"\"\"Set lights to come from same direction relative to brain.\"\"\"\n        if self.hemi == \"rh\":\n            if self._f.scene is not None and \\\n                    self._f.scene.light_manager is not None:\n                for light in self._f.scene.light_manager.lights:\n                    light.azimuth *= -1\n\n    def update_surf(self):\n        \"\"\"Update surface mesh after mesh coordinates change.\"\"\"\n        with warnings.catch_warnings(record=True):  # traits\n            self._geo_mesh.update()\n            for mesh in self._mesh_clones.values():\n                mesh.update()\n\n\nclass OverlayData(object):\n    \"\"\"Encapsulation of statistical neuroimaging overlay viz data\"\"\"\n\n    def __init__(self, scalar_data, min, max, sign):\n        if scalar_data.min() >= 0:\n            sign = \"pos\"\n        elif scalar_data.max() <= 0:\n            sign = \"neg\"\n\n        if sign in [\"abs\", \"pos\"]:\n            # Figure out the correct threshold to avoid TraitErrors\n            # This seems like not the cleanest way to do this\n            pos_max = np.max((0.0, np.max(scalar_data)))\n            if pos_max < min:\n                thresh_low = pos_max\n            else:\n                thresh_low = min\n            self.pos_lims = [thresh_low, min, max]\n        else:\n            self.pos_lims = None\n\n        if sign in [\"abs\", \"neg\"]:\n            # Figure out the correct threshold to avoid TraitErrors\n            # This seems even less clean due to negative convolutedness\n            neg_min = np.min((0.0, np.min(scalar_data)))\n            if neg_min > -min:\n                thresh_up = neg_min\n            else:\n                thresh_up = -min\n            self.neg_lims = [thresh_up, -max, -min]\n        else:\n            self.neg_lims = None\n        # Byte swap copy; due to mayavi bug\n        self.mlab_data = _prepare_data(scalar_data)\n\n\nclass OverlayDisplay():\n    \"\"\"Encapsulation of overlay viz plotting\"\"\"\n\n    def __init__(self, brain, array_id, pos, pos_bar, neg, neg_bar):\n        self._brain = brain\n        self._array_id = array_id\n        self.pos = pos\n        self.pos_bar = pos_bar\n        self.neg = neg\n        self.neg_bar = neg_bar\n\n    def remove(self):\n        self._brain._remove_scalar_data(self._array_id)\n        if self.pos_bar is not None:\n            self.pos_bar.visible = False\n        if self.neg_bar is not None:\n            self.neg_bar.visible = False\n\n\nclass TimeViewer(HasTraits):\n    \"\"\"TimeViewer object providing a GUI for visualizing time series\n\n    Useful for visualizing M\/EEG inverse solutions on Brain object(s).\n\n    Parameters\n    ----------\n    brain : Brain (or list of Brain)\n        brain(s) to control\n    \"\"\"\n    # Nested import of traisui for setup.py without X server\n    min_time = Int(0)\n    max_time = Int(1E9)\n    current_time = Range(low=\"min_time\", high=\"max_time\", value=0)\n    # colormap: only update when user presses Enter\n    fmax = Float(enter_set=True, auto_set=False)\n    fmid = Float(enter_set=True, auto_set=False)\n    fmin = Float(enter_set=True, auto_set=False)\n    transparent = Bool(True)\n    smoothing_steps = Int(20, enter_set=True, auto_set=False,\n                          desc=\"number of smoothing steps. Use -1 for\"\n                               \"automatic number of steps\")\n    orientation = Enum(\"lateral\", \"medial\", \"rostral\", \"caudal\",\n                       \"dorsal\", \"ventral\", \"frontal\", \"parietal\")\n\n    # GUI layout\n    view = View(VSplit(Item(name=\"current_time\"),\n                       Group(HSplit(Item(name=\"fmin\"),\n                                    Item(name=\"fmid\"),\n                                    Item(name=\"fmax\"),\n                                    Item(name=\"transparent\")\n                                    ),\n                             label=\"Color scale\",\n                             show_border=True),\n                       Item(name=\"smoothing_steps\"),\n                       Item(name=\"orientation\")\n                       )\n                )\n\n    def __init__(self, brain):\n        super(TimeViewer, self).__init__()\n\n        if isinstance(brain, (list, tuple)):\n            self.brains = brain\n        else:\n            self.brains = [brain]\n\n        # Initialize GUI with values from first brain\n        props = self.brains[0].get_data_properties()\n\n        self._disable_updates = True\n        self.max_time = len(props[\"time\"]) - 1\n        self.current_time = props[\"time_idx\"]\n        self.fmin = props[\"fmin\"]\n        self.fmid = props[\"fmid\"]\n        self.fmax = props[\"fmax\"]\n        self.transparent = props[\"transparent\"]\n        self.center = props[\"center\"]\n        if props[\"smoothing_steps\"] is None:\n            self.smoothing_steps = -1\n        else:\n            self.smoothing_steps = props[\"smoothing_steps\"]\n        self._disable_updates = False\n\n        # Make sure all brains have the same time points\n        for brain in self.brains[1:]:\n            this_props = brain.get_data_properties()\n            if not np.all(props[\"time\"] == this_props[\"time\"]):\n                raise ValueError(\"all brains must have the same time\"\n                                 \"points\")\n\n        # Show GUI\n        self.configure_traits()\n\n    @on_trait_change(\"smoothing_steps\")\n    def _set_smoothing_steps(self):\n        \"\"\" Change number of smooting steps\n        \"\"\"\n        if self._disable_updates:\n            return\n\n        smoothing_steps = self.smoothing_steps\n        if smoothing_steps < 0:\n            smoothing_steps = None\n\n        for brain in self.brains:\n            brain.set_data_smoothing_steps(self.smoothing_steps)\n\n    @on_trait_change(\"orientation\")\n    def _set_orientation(self):\n        \"\"\" Set the orientation\n        \"\"\"\n        if self._disable_updates:\n            return\n\n        for brain in self.brains:\n            brain.show_view(view=self.orientation)\n\n    @on_trait_change(\"current_time\")\n    def _set_time_point(self):\n        \"\"\" Set the time point shown\n        \"\"\"\n        if self._disable_updates:\n            return\n\n        for brain in self.brains:\n            brain.set_data_time_index(self.current_time)\n\n    @on_trait_change(\"fmin, fmid, fmax, transparent\")\n    def _scale_colormap(self):\n        \"\"\" Scale the colormap\n        \"\"\"\n        if self._disable_updates:\n            return\n\n        for brain in self.brains:\n            brain.scale_data_colormap(self.fmin, self.fmid, self.fmax,\n                                      self.transparent, self.center)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_672","text":"def pupil_quant_cmh(avi_path):\n\n    # -*- coding: utf-8 -*-\n    #import libraries and define movie\n    from CVROIGrabber_MRtest import CVROIGrabber\n    from src.ext.PupilTracker_MRtest import PupilTracker\n    import cv2, scipy.io, numpy as np\n\n    \n    \n    \n    \n    \n    #define pupil area\n    cap = cv2.VideoCapture(avi_path) #avi_path is the video being called\n    cap.set(1,1); #Take the first frame\n    ret, frame = cap.read() # Read the frame\n    cv = CVROIGrabber(frame)\n    cv.grab() # you can drag the window. Q exits\n    \n    \n    #Pupil size tracking parameters (why are these in a function)\n    param = dict(\n    relative_area_threshold=0.01,#.001\n    ratio_threshold=2, #2\n    error_threshold=1,\n    min_contour_len=5,#5\n    margin=0.02,\n    contrast_threshold=0.2, #0.2\n    speed_threshold=0.2,\n    dr_threshold=0.2,#.2\n    gaussian_blur=5,#5\n    perc_high =90,\n    perc_low = 10,\n    perc_weight = 0.9,\n    )\n    \n    tr = PupilTracker(param)\n    Pupildata = tr.track(avi_path, cv.roi, display=True)\n    \n    #save \n    np.save('Pupildata.npy',Pupildata)\n    Pupildata = np.load('Pupildata.npy',allow_pickle=True)\n    scipy.io.savemat(avi_path[:-4]+'_pupildata.mat', {\"Pupildata\": Pupildata})\n        \n    return\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_674","text":"# coding=utf-8\nfrom math import sqrt, floor, ceil   # Mathematische Hilfsfunktionen\nfrom scipy.optimize import fmin      # Zum Ermitteln von Minima einer Funktion\nfrom copy import deepcopy            # Zum Kopieren von Hashtables\/Dictionaries\nimport os                            # Zum Lesen von Ordnern\nimport datetime                      # Zum Konvertieren von Sekunden in eine Uhrzeit\n\n# Repraesentiert einen Punkt in Form einer Koordinate oder einen Vektor mit dessen x- und y-Wert\nclass Point:\n    def __init__(self, x, y):\n        self.x = x      # x-Koordinate\n        self.y = y      # y-Koordinate\n\n    # Hash-Funktion\n    def __hash__(self):\n        return hash((self.x, self.y))\n\n    # Punkt als Zeichenkette\n    def __repr__(self):\n        return \" (\" + str(self.x) + \" | \" + str(self.y) + \") \"\n\n    # Vergleich-Funktion\n    def __eq__(self, other):\n        return (self.x, self.y) == (other.x, other.y)\n\n    # Euklidische Distanz zweier Punkte berechnen (Anwendung des Satz des Pythagoras)\n    def euclidean_distance(self, other_point):\n        cathetus_a = other_point.x - self.x\n        cathetus_b = other_point.y - self.y\n        hypotenuse = sqrt(cathetus_a**2 + cathetus_b**2)\n        return hypotenuse\n\n\n# Repraesentiert eine Kante, bzw. eine Strecke mit zwei definierten Punkten A und B\nclass Edge:\n    def __init__(self, point_a, point_b):\n        self.point_a = point_a\n        self.point_b = point_b\n\n    # Vergleich-Funktion\n    def __eq__(self, other):\n        return (self.point_a, self.point_b) == (other.point_a, other.point_b) \\\n               or (self.point_a, self.point_b) == (other.point_b, other.point_a)\n    \n    # Erhalte Schnittpunkt mit einer anderen Kante, wobei beide Kanten als Geraden fortgefuehrt werden\n    def get_intersection_with(self, other_edge):\n        # Als allgm. Geradengleichung gilt: y=mx+b.\n        # Hier: Zwei Geraden mit jeweils m1 bzwn. m2 und b1 bzw. b2\n        # Es gilt: m1 = dy1\/dx1 und m2 = dy2\/dx2\n        dy1 = self.point_b.y - self.point_a.y\n        dy2 = other_edge.point_b.y - other_edge.point_a.y\n        dx1 = float(self.point_b.x - self.point_a.x)\n        dx2 = float(other_edge.point_b.x - other_edge.point_a.x)\n\n        # Wenn Kante a parallel zur y-Achse ist\n        if dx1 == 0.0:\n            intersection_x = self.point_a.x\n            m2 = dy2 \/ dx2\n            b2 = other_edge.point_a.y - m2 * other_edge.point_a.x\n            intersection_y = m2 * intersection_x + b2\n            return Point(intersection_x, intersection_y)\n\n        # Steigung m1 kann berechnet werden, da dx1 ungleich 0 ist\n        m1 = dy1 \/ dx1\n        b1 = self.point_a.y - m1 * self.point_a.x\n\n        # Wenn Kante b parallel zur y-Achse ist\n        if dx2 == 0.0:\n            intersection_x = other_edge.point_a.x\n            intersection_y = m1 * intersection_x + b1\n            return Point(intersection_x, intersection_y)\n\n        # Steigung m2 kann berechnet werden, da dx2 ungleich 0 ist\n        m2 = dy2 \/ dx2\n        b2 = other_edge.point_a.y - m2 * other_edge.point_a.x\n        intersection_x = (b2-b1)\/float(m1-m2)\n        intersection_y = m1 * intersection_x + b1\n\n        return Point(intersection_x, intersection_y)\n\n    # Prueft, ob Kante sich ausserhalb der Flaeche von zwei aufgespannten Punkten befindet\n    def is_out_of_area(self, point_a, point_b):\n        # Pruefen, ob Kante im x-Bereich zwischen den Punkten A und B liegt\n        if not point_b.x < point_a.x:\n            # Punkt A ist links von B oder ueber bzw. unter B\n            if self.point_a.x <= point_a.x and self.point_b.x <= point_a.x:\n                # Kante liegt links ausserhalb von A\n                return True\n            if self.point_a.x >= point_b.x and self.point_b.x >= point_b.x:\n                # Kante liegt rechts ausserhalb von B\n                return True\n        if not point_a.x < point_b.x:\n            # Punkt A ist rechts von B oder ueber bzw. unter B\n            if self.point_a.x >= point_a.x and self.point_b.x >= point_a.x:\n                # Kante liegt rechts ausserhalb von A\n                return True\n            if self.point_a.x <= point_b.x and self.point_b.x <= point_b.x:\n                # Kante liegt links ausserhalb von B\n                return True\n\n        # Pruefen, ob Kante im y-Bereich zwischen den Punkten A und B liegt\n        if not point_b.y < point_a.y:\n            # Punkt B ist ueber A oder auf gleicher hoehe\n            if self.point_a.y <= point_a.y and self.point_b.y <= point_a.y:\n                # Kante liegt unterhalb von A\n                return True\n            if self.point_b.y >= point_b.y and self.point_a.y >= point_b.y:\n                # Kante liegt oberhalb von B\n                return True\n        if not point_a.y < point_b.y:\n            # Punkt A ist ueber B oder auf gleicher hoehe\n            if self.point_a.y >= point_a.y and self.point_b.y >= point_a.y:\n                # Kante liegt oberhalb von A oder ist auf gleicher hoehe\n                return True\n            if self.point_a.y <= point_b.y and self.point_b.y <= point_b.y:\n                # Kante liegt liegt unterhalb von B oder ist auf gleicher hoehe\n                return True\n\n        return False\n\n    # Erhalte den Faktor mit dem die Kante erweitert werden muss, um auf einen bestimmten Punkt zu treffen\n    def get_ratio(self, point):\n        # Zu pruefende Kante ist parallel zur Y-Achse --> Verhaeltnis ueber y-Werte\n        if self.point_b.x == self.point_a.x:\n            ratio = (point.y - self.point_a.y) \/ float(self.point_b.y - self.point_a.y)\n        # Sonst: Verhaeltnis ueber x-Werte\n        else:\n            ratio = (point.x - self.point_a.x) \/ float(self.point_b.x - self.point_a.x)\n\n        return ratio\n\n\n# Repraesentiert einen Knoten im Sichtbarkeitsgraphen\nclass Node:\n    def __init__(self, point, id):\n        self.point = point  # Jeder Knoten hat einen Punkt\n        self.id = id        # Und eine ID, fuer Polygone gilt: ID > 0, Startknoten hat die ID -1, der Endknoten -2\n\n        # Attribute, die fuer den A-Star-Algorithmus relevant sind\n        self.g_cost = 0\n        self.h_cost = 0\n        self.f_cost = 0\n        self.previous_node = 0\n\n    # Methode zum Zuweisen der Heuristik (hier: euklidische Distanz)\n    def assign_h_cost(self, end_node):\n        self.h_cost = self.point.euclidean_distance(end_node.point)\n        return self\n\n    # Hash-Funktion, damit Knoten als Schluessel und Werte in einer Hash-Table sein koennen\n    def __hash__(self):\n        return hash((self.point, self.id))\n\n    # Vergleich-Funktion (Knoten sind identisch, wenn sie den selben Punkt und die selbe ID haben)\n    def __eq__(self, other):\n        return (self.point, self.id) == (other.point, other.id)\n\n    # Knoten als Zeichenkette\n    def __repr__(self):\n        if self.id == -2:   # Endknoten\n            return \" [Y, (\" + str(self.point.x) + \" | \" + str(self.point.y) + \")]\"\n        if self.id == -1:\n            return \" [L, (\" + str(self.point.x) + \" | \" + str(self.point.y) + \")]\"\n        return \" [P\" + str(self.id) + \", (\" + str(self.point.x) + \" | \" + str(self.point.y) + \")]\"\n\n    # Prueft, ob aktueller Knoten A einen anderen Knoten B sehen kann\n    def can_see(self, node_b):\n        if node_b.id != -2:\n            # Zugehoeriges Polygon des ersten Knoten\n            polygon_of_first_node = Input.polygon_list[self.id-1]\n        # Pruefen ob beide Knoten zu einem Polygon gehoeren\n        if self.id == node_b.id:\n            for edge in polygon_of_first_node.convert_to_edges():\n                # Wenn Knoten sich eine Kante teilen, ...\n                current_points = [edge.point_a, edge.point_b]\n                if self.point in current_points and node_b.point in current_points:\n                    # ... dann sehen sie sich in jedem Fall\n                    return True\n\n        # Richtungsvektor der Verbindung zwischen Knoten a und b\n        vector_connection = Point(node_b.point.x - self.point.x, node_b.point.y - self.point.y)\n\n        # Potentielle Hindernisse sind jene Kanten, die die Verbindung a zu b lediglich beruehren\n        potential_obstacles = []\n\n        # Pruefen, ob eine aller Kanten den Weg von node_a zu node_b verdeckt\n        for edge in Input.list_of_all_edges:\n            # Richtungsvektor der zu pruefenden Kante\n            vector_edge = Point(edge.point_b.x - edge.point_a.x, edge.point_b.y - edge.point_a.y)\n            # Pruefen, ob Verbindung a zu b und aktuelle Kante parallel sind\n            if vector_connection.x*vector_edge.y == vector_connection.y * vector_edge.x:\n                continue    # Kante kann Verbindung nicht schneiden\n\n            # Falls sich die Kante ausserhalb des von a und b aufgespannten Rechtecks befindet\n            if edge.is_out_of_area(self.point, node_b.point):\n                continue    # Kante kann Verbindung nicht schneiden\n\n            intersection_point = edge.get_intersection_with(Edge(self.point, node_b.point))\n            ratio_edge = round(edge.get_ratio(intersection_point), 6)\n            ratio_connection = round(Edge(self.point, node_b.point).get_ratio(intersection_point), 6)\n\n            # Kante verdeckt beide Knoten\n            if 0 < ratio_edge < 1 and 0 < ratio_connection < 1:\n                return False\n\n            # Verbindung koennte durch Eckpunkt eines Polygons gehen, Kanten beruehren die Verbindung a zu b\n            elif (ratio_edge == 1 or ratio_edge == 0) and 0 < ratio_connection < 1:\n                potential_obstacles.append(edge)\n\n        # Knoten teilt Punkt mit anderen Knoten\n        if node_b.point in Input.double_corners or \\\n                self.point in Input.double_corners:\n            return False    # Doppelte Eckpunkte werden ausgelassen\n\n        # Pruefen, ob Verbindung im Polygon liegt bei Knoten gleicher Polygone\n        if self.id == node_b.id:\n            # OA + AB\/2 = OP, OP ist Ortsvektor des zu pruefenden Punktes\n            local_vector_checkpoint = Point(self.point.x + vector_connection.x\/2,\n                                            self.point.y + vector_connection.y\/2)\n            # Beide Knoten koennen sich nicht sehen, da die Verbindung im Polygon liegt\n            if polygon_of_first_node.contains(local_vector_checkpoint):\n                return False\n            else:\n                return True\n\n        # Pruefen, ob Verbindung durch eine Ecke geht, ohne Kanten zu schneiden\n        # Dabei muss es benachbarte Kanten geben, die weder Knoten A noch B enthalten\n        if len(potential_obstacles) > 1:\n            for i in range(len(potential_obstacles)):\n                for j in range(i+1, len(potential_obstacles)):\n                    points_in_edges = [potential_obstacles[i].point_a, potential_obstacles[i].point_b,\n                                       potential_obstacles[j].point_a, potential_obstacles[j].point_b]\n                    # Kanten haben einen gemeinsamen Punkt, wenn es Duplikate in der\n                    # Liste (bestehend aus jeweils beiden Punkten beider Kanten) gibt\n                    if len(points_in_edges) != len(set(points_in_edges)):\n                        # Wenn Knoten A und B nicht auf den Kanten liegen\n                        if self.point not in points_in_edges and node_b.point not in points_in_edges:\n                            return False\n        return True\n    \n    # Prueft, ob Eckpunkt 2 im B-Bereich von Eckpunkt 1 liegt, wodurch die Verbindung von E2 zu E1 redundant waere\n    def is_redundant_to(self, node_2):\n\n        # Polygon des Eckpunkts 1\n        polygon = Input.polygon_list[self.id-1]\n\n        # Benachbarte Ecken von Eckpunkt 1\n        adjacent_points = polygon.get_adjacent_points(self.point)\n\n        # Richtungsvektoren der beiden fortgefuehrten Kanten an Eckpunkt 1\n        r1 = Point(2*self.point.x-adjacent_points[0].x, 2*self.point.y-adjacent_points[0].y)\n        r2 = Point(2*self.point.x-adjacent_points[1].x, 2*self.point.y-adjacent_points[1].y)\n\n        # Richtungsvektor vom Eckpunkt 1 zum Eckpunkt 2\n        vector_connection = Point(node_2.point.x - self.point.x, node_2.point.y - self.point.y)\n\n        # Determinante der Orientierungs-Matrix berechnen\n        def det(p, q, r):\n            return (q.x * r.y + p.x * q.y + p.y * r.x) - (p.y * q.x + q.y * r.x + p.x * r.y)\n\n        determinant_r1 = det(self.point, Point(r1.x + vector_connection.x, r1.y + vector_connection.y), node_2.point)\n        determinant_r2 = det(self.point, Point(r2.x + vector_connection.x, r2.y + vector_connection.y), node_2.point)\n\n        # Falls Eckpunkt 2 zwischen den beiden fortgefuehrten Kanten von Eckpunkt 1 liegt\n        # Wenn also die Determinante der Orientierungsmatrix einmal negativ und einmal positiv ist\n        if determinant_r1 < 0 < determinant_r2 or determinant_r2 < 0 < determinant_r1:\n            return True\n\n        return False\n\n\n# Repraesentiert ein Polygon mit seiner ID und seinen Eckpunkten\nclass Polygon:\n    def __init__(self, points, id):\n        self.points = points\n        self.id = id\n\n    # Prueft, ob ein Punkt im Polygon befindet mithilfe der Strahl-Methode\n    def contains(self, point):\n        polygon_edges = self.convert_to_edges()  # Alle Kanten des Polygons\n        count_to_left_of_point = 0               # Variable zum Zaehlen der Schnittpunkte des Strahls links vom Punkt\n        for edge in polygon_edges:\n            if edge.point_a.y <= point.y <= edge.point_b.y or edge.point_b.y <= point.y <= edge.point_a.y:\n                # Punkt ist auf einer Y-Ebene mit der aktuellen Kante des Polygons\n                if edge.point_a.y == edge.point_b.y == point.y:\n                    # Kante liegt auf Strahl --> Wird aber als darueber gezaehlt\n                    continue\n                intersection_point = edge.get_intersection_with(Edge(Point(0, point.y), Point(1, point.y)))\n                if intersection_point in [edge.point_a, edge.point_b]:\n                    # Strahl geht durch Eckpunkt der Kante, Punkte auf dem Strahl werden als Punkte darueber gezaehlt\n                    if edge.point_a.y == point.y:\n                        # Punkt A der Kante liegt auf dem Strahl\n                        if edge.point_b.y > point.y:\n                            # Kante schneidet nicht Strahl, da Punkt B und Punkt A \"ueber\" dem Strahl\n                            continue\n                    else:\n                        # Punkt B liegt auf dem Strahl\n                        if edge.point_a.y > point.y:\n                            # Kante schneidet nicht Strahl, da Punkt B und Punkt A \"ueber\" dem Strahl\n                            continue\n\n                if intersection_point.x < point.x:\n                    # Schnittpunkt der Kante links vom zu pruefenden Punkt\n                    count_to_left_of_point += 1\n\n        # Wenn Anzahl der Schnittpunkte links vom Punkt ungerade ist --> Punkt liegt im Polygon\n        if count_to_left_of_point % 2 != 0:\n            return True\n        else:\n            return False\n\n    # Erhalte benachbarten Punkte eines Punktes in einem Polygon\n    def get_adjacent_points(self, point):\n        adjacent_points = []\n        for edge in self.convert_to_edges():\n            if point == edge.point_a:\n                adjacent_points.append(edge.point_b)\n            if point == edge.point_b:\n                adjacent_points.append(edge.point_a)\n\n        return adjacent_points\n\n    # Zusammenfuegen von Punkten eines Polygons zu Kanten\n    def convert_to_edges(self):\n        edges_list = []\n        number_of_corners = len(self.points)\n        for i in range(number_of_corners):\n            if i == number_of_corners - 1:\n                edges_list.append(Edge(self.points[i], self.points[0]))\n            else:\n                edges_list.append(Edge(self.points[i], self.points[i + 1]))\n        return edges_list\n\n    # Gibt nur konvexe Punkte eines Polygons zurueck\n    def convex_vertices_only(self):\n        points = self.points\n        # Finde oberste linke Ecke, da diese in jedem Fall konvex ist\n        top_left_corner_index = 0\n        for i in range(1, len(points)):\n            if points[i].x <= points[top_left_corner_index].x:\n                if points[i].y >= points[top_left_corner_index].y:\n                    top_left_corner_index = i\n\n        # neue Liste der Eckpunkte mit der obersten linken Ecke als Startwert\n        new_points_list = points[top_left_corner_index:]\n        new_points_list.extend(points[0:top_left_corner_index])\n        points = new_points_list\n\n        # Alle Ecken, bei denen die Kante rechts von der vorherigen Kante angelegt wird, sind in list_right\n        list_right = []\n        # Die restlichen Ecken kommen in list_left\n        list_left = []\n\n        # Determinante der Orientierungs-Matrix berechnen\n        def det(p, q, r):\n            return (q.x * r.y + p.x * q.y + p.y * r.x) - (p.y * q.x + q.y * r.x + p.x * r.y)\n\n        # Richtungen fuer jede Ecke bestimmen mithilfe von drei Punkten, der jeweils anliegenden zwei Kanten\n        for i in range(len(points)):\n            if i == 0:\n                point_p = points[len(points)-1]\n            else:\n                point_p = points[i-1]\n\n            point_q = points[i]\n\n            if i == len(points)-1:\n                point_r = points[0]\n            else:\n                point_r = points[i+1]\n\n            determinant = det(point_p, point_q, point_r)\n\n            # Orientierung ist im Uhrzeigersinn --> Rechtsrum\n            if determinant < 0:\n                list_right.append(point_q)\n            # Orientierung gegen den Uhrzeigersinn --> Linksrum\n            else:\n                list_left.append(point_q)\n\n        if points[0] in list_right:\n            # Ecken, deren Kanten einen Rechts-Turn machen sind konvex\n\n            return list_right\n        else:\n            # Ecken, deren Kanten einen Links-Turn machen sind konvex\n            return list_left\n\n\nclass VisibilityGraph:\n\n    # Gibt einen Sichtbarkeitsgraph als Hash-Table zurueck (Rekursive Methode)\n    @staticmethod\n    def get_graph(to_visit, current_graph):\n\n        # Es muessen keine Knoten mehr besucht werden\n        if len(to_visit) == 1:\n            return current_graph\n\n        # Knoten wird abgearbeitet\n        current_node = to_visit[0]\n        to_visit.pop(0)\n\n        # Jeden zu besuchenden Knoten mit aktuellem Knoten auf Sichtbarkeit und Redundanz pruefen\n        for node in to_visit:\n            if node.can_see(current_node):\n                if not node.is_redundant_to(current_node):\n                    current_graph[current_node].append(node)\n                if not current_node.is_redundant_to(node):\n                    current_graph[node].append(current_node)\n\n        # Naechsten zu besuchenden Knoten pruefen, Erweiterung des aktuellen Sichtbarkeitsgraphen\n        return VisibilityGraph.get_graph(to_visit, current_graph)\n\n    # Methode zum Hinzufuegen eines Start- oder Endknotens in einen bereits vorhandenen Sichtbarkeitsgraphen\n    @staticmethod\n    def add_node(to_add, visibility_graph):\n        all_key_nodes = visibility_graph.keys()\n        visibility_graph[to_add] = []\n\n        # Jeden Knoten mit zu ergaenzendem Knoten auf Sichtbarkeit und Redundanz pruefen\n        for node in all_key_nodes:\n            if node.can_see(to_add):\n                    if node.id >= 0:\n                        if not node.is_redundant_to(to_add):\n                            visibility_graph[node].append(to_add)\n                            visibility_graph[to_add].append(node)\n                    else:\n                        visibility_graph[node].append(to_add)\n                        visibility_graph[to_add].append(node)\n\n        return visibility_graph\n\n\n# Klasse, die alle wichtigen Methoden zum A* Pathfinding-Algorithmus enthaelt\nclass AStar:\n\n    # Findet den kuerzesten Pfad in einem Sichtbarkeitsgraphen\n    @staticmethod\n    def get_shortest_path(visibility_graph):\n        start_node = Input.start_node\n        open_list = [start_node]\n        current_node = start_node\n        closed_list = []\n\n        # Solange die Open-Liste nicht leer ist\n        while len(open_list) != 0:\n\n            # Alle sichtbaren Knoten des aktuellen Knotens\n            visible_nodes = visibility_graph[current_node]\n\n            # Knoten wird als abgeschlossen markiert\n            closed_list.append(current_node)\n            open_list.remove(current_node)\n\n            # Iteriere durch sichtbare Knoten des aktuellen Knotens\n            for i in range(len(visible_nodes)):\n                visible_node = visible_nodes[i]\n                # Berechne gCost (Abstand zum Startknoten)\n                new_g_cost = current_node.g_cost + current_node.point.euclidean_distance(visible_node.point)\n\n                # Wenn sichtbarer Knoten als abgeschlossen markiert und der neue Pfad zu ihm nicht guenstiger ist\n                if visible_node in closed_list and new_g_cost >= visibility_graph[current_node][i].g_cost:\n                    continue\n\n                # Falls Knoten noch nicht entdeckt oder ein guenstigerer Pfad gefunden wurde\n                if visible_node not in open_list or new_g_cost < visibility_graph[current_node][i].g_cost:\n                    # Aktualisieren der gCost und Gesamtkosten fuer diesen Knoten\n                    visibility_graph[current_node][i].g_cost = new_g_cost\n                    visibility_graph[current_node][i].f_cost = new_g_cost + visible_node.h_cost\n\n                    # Setzen des Zeigers auf den vorherigen Knoten\n                    visibility_graph[current_node][i].previous_node = current_node\n\n                    # Falls Knoten noch nicht entdeckt\n                    if visible_node not in open_list:\n                        # Knoten wird als offen markiert\n                        open_list.append(visible_node)\n\n            # Erhalte Knoten mit geringsten Gesamtkosten\n            if len(open_list) > 0:\n                best_next_node = open_list[0]\n                for node in open_list:\n                    if node.f_cost < best_next_node.f_cost:\n                        best_next_node = node\n                current_node = best_next_node\n\n            else:\n                return None     # Kein Pfad konnte gefunden werden\n\n            # Wenn End-Knoten Knoten mit geringsten Gesamtkosten ist\n            if current_node.id == -2:\n                # Optimaler Pfad wurde gefunden, muss rekonstruiert werden\n                return AStar.reconstruct_path(current_node)\n\n        # Es konnte kein Pfad gefunden werden\n        return None\n\n    # Methode zur Rekonstruierung des optimalsten Wegs\n    @staticmethod\n    def reconstruct_path(end_node):\n        shortest_path = [end_node]\n        previous_node = end_node.previous_node\n        total_length = end_node.point.euclidean_distance(previous_node.point)\n\n        # Pfad erweitern mithilfe des Vorgaenger-Knotens, Erhoehung der Gesamtlaenge\n        while previous_node.id != -1:                   # Solange der Startknoten nicht erreicht ist\n            shortest_path.append(previous_node)\n            total_length += previous_node.point.euclidean_distance(previous_node.previous_node.point)\n            if previous_node.previous_node.id == -1:    # Falls der vorherige Knoten der Startknoten ist\n                total_length += previous_node.point.euclidean_distance(previous_node.previous_node.point)\n            previous_node = previous_node.previous_node\n\n        shortest_path.append(previous_node)\n        return shortest_path, total_length    # Rueckgabe des kuerzesten Wegs und der Gesamtlaenge als Tupel\n\n\n# Klasse, die allgemeine Methoden zur Loesung der Aufgabe enthaelt\nclass LisaRennt:\n\n    # Gibt den optimalsten Pfad mit Sichtbarkeitsgraphen zurueck,\n    # bei dem Lisa ihr Haus so spaet wie moeglich verlassen muss\n    @staticmethod\n    def get_optimal_result():\n        to_visit = []       # Liste aller Knoten, die auf Sichtbarkeit ueberprueft werden muss\n        start_graph = {}    # Anfangsgraph mit allen Polygonecken als Knoten\n\n        # Konvexe Ecken aller Polygone als Ausgangsknoten hinzufuegen\n        for polygon in Input.polygon_list:\n            for convex_vertice in polygon.convex_vertices_only():\n                # Erstellung eines Knotens aus einem konvexen Eckpunkt\n                converted_node = Node(convex_vertice, polygon.id)\n\n                # Heuristik fuer Knoten berechnen und hinzufuegen\n                converted_node = converted_node.assign_h_cost(Input.end_node)\n\n                # Knoten jeweils initialisieren\n                to_visit.append(converted_node)\n                start_graph[converted_node] = []\n\n        # Liste aller Kanten generieren (Zur Erstellung des Sichtbarkeitsgraphen erforderlich)\n        for polygon in Input.polygon_list:\n            Input.list_of_all_edges.extend(polygon.convert_to_edges())\n\n        # Sichtbarkeitsgraph mit Start- aber ohne Endknoten\n        visibility_graph = VisibilityGraph.get_graph(to_visit, start_graph)\n        visibility_graph = VisibilityGraph.add_node(Input.start_node, visibility_graph)\n\n        # Untersten und obersten Knoten ermitteln (um Bereich zu definieren), Startknoten als Referenzwert\n        smallest_y = Input.start_node.point.y\n        biggest_y = Input.start_node.point.y\n        for node in visibility_graph.keys():\n            if node.point.y < smallest_y:\n                smallest_y = node.point.y\n            if node.point.y > biggest_y:\n                biggest_y = node.point.y\n\n        # Maximum von t(x), s. Dokumentation\n        optimum_y = fmin(lambda x: -LisaRennt.t(x), 0, disp=False)\n\n        # Bereich justieren, indem optimaler Weg gesucht wird, da das Optimum ein Teil dieses Bereichs sein muss\n        if optimum_y < smallest_y:\n            smallest_y = int(floor(optimum_y))\n        if optimum_y > biggest_y:\n            biggest_y = int(ceil(optimum_y))\n\n        # Ermitteln des optimalsten Wegs durch Ausprobieren aller moeglichen Endknoten im vordefinierten Bereich\n        full_visibility_graph = VisibilityGraph.add_node(Node(Point(0,smallest_y), -2), deepcopy(visibility_graph))\n        best_visibility_graph = deepcopy(full_visibility_graph)\n        calc_path = AStar.get_shortest_path(full_visibility_graph)\n        if calc_path is None:\n            return  # Kein Pfad\n        best_path = calc_path\n        Output.highest_time_after_departure = LisaRennt.time(smallest_y, calc_path[1])\n        for i in range(smallest_y+1, biggest_y):\n            full_visibility_graph = VisibilityGraph.add_node(Node(Point(0, i), -2), deepcopy(visibility_graph))\n            calc_path = AStar.get_shortest_path(full_visibility_graph)\n            time_after_departure = LisaRennt.time(i, calc_path[1])\n\n            if time_after_departure > Output.highest_time_after_departure:\n                Output.highest_time_after_departure = time_after_departure\n\n                best_path = calc_path\n                best_visibility_graph = deepcopy(full_visibility_graph)\n\n        return best_path, best_visibility_graph  # Rueckgabe des optimalsten Wegs (inkl. Laenge) und Sichtbarkeitsgraph\n\n    # Zeitdifferenz ohne Hindernisse\n    @staticmethod\n    def t(x):\n        # Optimaler Punkt (0|x) auf der y-Achse, wenn es keine Hindernisse gibt\n        s_x = Input.start_node.point.x  # Standort Lisa, x-Wert\n        s_y = Input.start_node.point.y  # Standort Lisa, y-Wert\n        return (3*x\/25.0) - (6 * sqrt(s_x**2 + (s_y-x)**2))\/25.0\n\n    # Zeitdifferenz mit Hindernissen\n    @staticmethod\n    def time(x, path_length):\n        return (3*x\/25.0) - (6*path_length)\/25.0\n\n\nclass Input:\n    polygon_list = []\n    list_of_all_edges = []\n    start_node = Node(Point(0,0),-1)     # Platzhalter Start-Knoten\n    end_node = Node(Point(0,0), -2)      # Platzhalter End-Knoten\n    double_corners = []\n\n    @staticmethod\n    def polygon_liste_einlesen(file_name):\n        lines = [line.rstrip('\\n') for line in open('beispieldaten\/' + file_name)]\n        count_polygons = int(lines[0])\n        all_vertices = []\n        for i in range(count_polygons):\n            corner_info = lines[i + 1].split(\" \")\n            count_corners = int(corner_info[0])\n            corner_info.pop(0)\n            corner_list = []\n            x = 0\n            for j in range(count_corners * 2):\n                if j % 2 == 0:\n                    x = int(corner_info[j])\n                else:\n                    y = int(corner_info[j])\n                    corner_list.append(Point(x, y))\n                    all_vertices.append(Point(x, y))\n\n            Input.polygon_list.append(Polygon(corner_list, i + 1))\n\n        start_information = lines[len(lines) - 1].split(\" \")\n        Input.start_node = Node(Point(int(start_information[0]), int(start_information[1])), -1)\n\n        # Wenn Punkte doppelt vorkommen, haben Sie den Wert true, ansonsten false\n        duplicates = {}\n        for vertice in all_vertices:\n            duplicates[vertice] = vertice in duplicates\n        # Alle relevanten Eckpunkte, die nicht in mehr als einem Polygon vorkommen\n        doulbe_corners = [i for i in duplicates if duplicates[i]]\n        Input.double_corners.extend(doulbe_corners)\n\n\nclass Output:\n\n    output_file = \"\"\n    highest_time_after_departure = 0\n\n\n    @staticmethod\n    def display_result(result):\n        final_output = \"<svg xmlns='http:\/\/www.w3.org\/2000\/svg' version='1.1' viewBox='0 0 1024 768'> \" \\\n                       \"<g transform='scale(1 -1)'> <g transform='translate(0 -768)'>\" \\\n                       \"<line id='y' x1='0' x2='0' y1='0' y2='768' fill='none' stroke='#212121' stroke-width='3'\/>\"\n        final_output += Output.draw_polygons()\n\n        if result is None:\n            print (\"Es gibt keinen Pfad zum Ziel\")\n            return\n\n        shortest_path = result[0][0]\n        visibility_graph = result[1]\n\n\n\n        bus_departure_time = 27000      # 7:30 in Sekunden\n        lisas_leaving = int(round(Output.highest_time_after_departure))     # Lisas Verlassen des Hauses\n        start_time = str(datetime.timedelta(seconds=bus_departure_time+lisas_leaving))\n        print (\"Startzeit: \" + start_time)\n\n\n        all_nodes = visibility_graph.keys()\n\n        output_lines = \"\"\n        for node in all_nodes:\n            if node.id == -1:\n                # Kreis zeichnen fuer Start-Knoten\n                output_lines += \"<circle cx='\" + str(node.point.x) +\"' cy='\" + \\\n                                str(node.point.y) +\"' r='3' stroke='black' stroke-width='3' fill='red'><\/circle>\"\n\n            if node.id == -2:\n                end_time = int(bus_departure_time + node.point.y*(3.0\/25.0))\n                print (\"Zielzeit: \" + str(datetime.timedelta(seconds=end_time)))      # Zielzeit\n                print (\"y-Koordinate des Auftreffens: \" + str(node.point.y))        # y-Koordinaten des Auftreffens\n                # Kreis zeichnen fuer End-Knoten\n                output_lines += \"<circle cx='\" + str(node.point.x) +\"' cy='\" + \\\n                                str(node.point.y) +\"' r='3' stroke='black' stroke-width='3' fill='blue'><\/circle>\"\n            for visible_node in visibility_graph[node]:\n                output_lines += \"\\n <line \"\n                output_lines += \"x1='\" + str(node.point.x) + \"' y1='\" + str(node.point.y) + \"'\"\n                output_lines += \" x2='\" + str(visible_node.point.x) + \"' y2='\" + str(visible_node.point.y) + \"' \"\n                output_lines += \"stroke='green' stroke-width='1'\/>\"\n\n        length_lisas_path = int(round(result[0][1]))  # Laenge von Lisas Route in Minuten\n        print (\"Länge von Lisas Route: \" + str(length_lisas_path) + \" Meter\")\n\n        duration_lisas_path = round((length_lisas_path * (6.0 \/ 25.0)) \/ 60.0, 2)  # Dauer von Lisas Route in Minuten\n        print (\"Dauer von Lisas Route: \" + str(duration_lisas_path) + \" Minuten\")\n\n        lisas_route = \"\"\n        for i, first_node in reversed(list(enumerate(shortest_path))):\n            lisas_route += str(first_node) + \" -->\"\n            if i > 0:\n                second_node = shortest_path[i-1]\n                output_lines += \"\\n <line \"\n                output_lines += \"x1='\" + str(first_node.point.x) + \"' y1='\" + str(first_node.point.y) + \"'\"\n                output_lines += \" x2='\" + str(second_node.point.x) + \"' y2='\" + str(second_node.point.y) + \"' \"\n                output_lines += \"stroke='red' stroke-width='3'\/>\"\n\n        print(\"Lisas Route: \" + lisas_route + \" Ziel erreicht\")\n\n\n\n\n        final_output += output_lines\n        final_output += \"<\/g> <\/g> <\/svg>\"\n\n        if Output.output_file in os.listdir(\"output\"):\n            os.remove(\"output\/\" + Output.output_file)\n\n        with open(\"output\/\" + Output.output_file, \"a\") as f:\n            f.write(final_output)\n            f.close()\n\n        print (\"\\nDie generierte SVG-Datei befindet sich im Output-Ordner\")\n\n\n    @staticmethod\n    def draw_polygons():\n        output = \"\"\n        # Eckpunkte die zu zwei Polygonen gehoeren werden ausgefiltert\n        all_vertices = []\n        for polygon in Input.polygon_list:\n            for vertice in polygon.points:\n                all_vertices.append(vertice)\n\n        for polygon in Input.polygon_list:\n            output += \"<polygon id='P\" + str(polygon.id) + \"' points='\"\n            for point in polygon.points:\n                output += str(point.x) + \" \" + str(point.y) + \" \"\n            output += \"' fill='#6B6B6B' stroke='#212121' stroke-width='2'\/> \\n\"\n\n\n        return output\n\n\nclass Interface:\n\n    @staticmethod\n    def start():\n        print (\"Welche Umgebung soll eingelesen werden?\")\n        all_text_files = []\n        for file in os.listdir(\"beispieldaten\"):\n            if file.endswith(\".txt\"):\n                all_text_files.append(file)\n\n        for i in range(len(all_text_files)):\n            print (\"[\" + str(i+1) + \"] \" + all_text_files[i])\n\n        choice = int(input(\"\\nAuswahl: \"))-1\n        print (\"\\nRoute wird berechnet... \\n\")\n        Input.polygon_liste_einlesen(all_text_files[choice])\n        Output.output_file = all_text_files[choice].replace(\".txt\", \"\") + \".svg\"\n        Output.display_result(LisaRennt.get_optimal_result())\n\n\n\nInterface.start()\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_675","text":"<gh_stars>0\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport os\nimport torch\nimport torchvision.datasets\nimport torchvision.models\nimport torchvision.transforms\n\nfrom AIS import get_obj_term_A, manual_AIS\nfrom custom_rbm import RBM_custom, RBM_gaussian_custom\nfrom data_process import image_data_collapse, binarize_image_data, data_mnist\nfrom RBM_assess import plot_confusion_matrix, confusion_matrix_from_pred, get_X_y_dataset\nfrom settings import MNIST_BINARIZATION_CUTOFF, DIR_OUTPUT, CLASSIFIER, BETA, DIR_MODELS\n\n\n########## CONFIGURATION ##########\nBATCH_SIZE = 100  # default 64\nVISIBLE_UNITS = 784  # 28 x 28 images\nHIDDEN_UNITS = 10  # was 128 but try 10\nCD_K = 20\nEPOCHS = 100  # was 10, or 51\n\nLEARNING_RATE = 1*1e-4               # default was 1e-3, new base is 1e-4\nlearningrate_schedule = False         # swap from LEARNING_RATE to diff value at specified epoch\nlearningrate_schedule_value = 1*1e-4\nlearningrate_schedule_epoch = 25\n\nAIS_STEPS = 0 #1000      # 0 or 1000 typically\nAIS_CHAINS = 0 #100      # 100 or 500\nUSE_FIELDS = False\nPLOT_WEIGHTS = False\nPOINTS_PER_EPOCH = 1\n\nGAUSSIAN_RBM = True\nif RBM_gaussian_custom:\n    RBM = RBM_gaussian_custom\nelse:\n    RBM = RBM_custom\n\n\ndef torch_data_loading(batch_size=BATCH_SIZE):\n    print('Loading dataset...')\n    DATA_FOLDER = 'data'\n    train_dataset = torchvision.datasets.MNIST(root=DATA_FOLDER, train=True,\n                                               transform=torchvision.transforms.ToTensor(), download=True)\n    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\n    test_dataset = torchvision.datasets.MNIST(root=DATA_FOLDER, train=False,\n                                              transform=torchvision.transforms.ToTensor(), download=True)\n    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)\n    return train_dataset, train_loader, test_dataset, test_loader\n\n\ndef get_classloader(global_dataset, class_name):\n    # see https:\/\/discuss.pytorch.org\/t\/how-to-use-one-class-of-number-in-mnist\/26276\/12\n    def get_indices(dataset):\n        indices = []\n        for i in range(len(dataset.targets)):\n            if dataset.targets[i] == class_name:\n                indices.append(i)\n        return indices\n\n    idx = get_indices(global_dataset)\n    num_class_samples = len(idx)\n    loader = torch.utils.data.DataLoader(global_dataset, batch_size=BATCH_SIZE, sampler=torch.utils.data.sampler.SubsetRandomSampler(idx))\n\n    return loader, num_class_samples\n\n\ndef custom_RBM_loop(train_loader, train_data_as_arr, hidden_units=HIDDEN_UNITS, init_weights=None,\n                    use_fields=USE_FIELDS, beta=BETA, epochs=EPOCHS, cdk=CD_K,\n                    outdir=None, classify=False, restart=False, points_per_epoch=POINTS_PER_EPOCH):\n    assert beta == BETA         # TODO uncouple global STDEV in rbm class to make beta passable\n    assert classify is False    # TODO need to add support for classify_with_rbm_hidden(...) at end\n\n    if restart:\n        fmod = ''  # was '_restart'; now use rundir name alone to store restart label\n    else:\n        fmod = ''\n\n    if outdir is not None:\n        if not os.path.exists(outdir):\n            os.makedirs(outdir)\n        trainingdir = outdir + os.sep + 'training' + fmod\n        if not os.path.exists(trainingdir):\n            os.makedirs(trainingdir)\n    else:\n        trainingdir = DIR_OUTPUT + os.sep + 'training'\n\n    # initialize RBM class\n    rbm = RBM(VISIBLE_UNITS, hidden_units, cdk, init_weights=init_weights, use_fields=use_fields,\n              learning_rate=LEARNING_RATE)\n\n    # prep object timeseries to store over training\n    num_samples = train_data_as_arr.shape[0]\n    batches_per_epoch = num_samples \/ BATCH_SIZE\n    total_timepoints = points_per_epoch * epochs + 1\n    iterations_per_pt = batches_per_epoch \/ points_per_epoch\n    if POINTS_PER_EPOCH != 1:\n        assert num_samples % BATCH_SIZE == 0\n        assert batches_per_epoch % points_per_epoch == 0\n    print(\"epochs:\", epochs)\n    print(\"num_samples:\", num_samples)\n    print(\"batches_per_epoch:\", batches_per_epoch)\n    print(\"iterations_per_pt:\", iterations_per_pt)\n    print(\"total_timepoints:\", total_timepoints)\n    iteration_arr = np.arange(total_timepoints) * iterations_per_pt  # iteration pt of the saved data\n    print(iteration_arr)\n\n    weights_timeseries = np.zeros((rbm.num_visible, rbm.num_hidden, total_timepoints))\n    weights_timeseries[:, :, 0] = rbm.weights\n    if use_fields:\n        visible_bias_timeseries = np.zeros((rbm.num_visible, total_timepoints))\n        visible_bias_timeseries[:, 0] = rbm.visible_bias.numpy()\n        hidden_bias_timeseries = np.zeros((rbm.num_hidden, total_timepoints))\n        hidden_bias_timeseries[:, 0] = rbm.hidden_bias.numpy()\n\n    if PLOT_WEIGHTS:\n        rbm.plot_model(title='epoch_0', outdir=trainingdir)\n\n    obj_reconstruction = np.zeros(total_timepoints - 1)\n    obj_logP_termA = np.zeros(total_timepoints)\n    obj_logP_termB = np.zeros(total_timepoints)\n\n\n    def loop_updates(iteration_idx, iteration_counter, epoch_recon_error=None):\n        if PLOT_WEIGHTS:\n            rbm.plot_model(title='iteration_%d' % (iteration_counter), outdir=trainingdir)\n\n        if epoch_recon_error is not None:\n            print('Epoch (Reconstruction) Error (epoch=%d) (iteration_idx:%d): %.4f' % (\n                epoch + 1, iteration_idx, epoch_recon_error))\n            obj_reconstruction[iteration_idx - 1] = epoch_recon_error\n\n        if AIS_STEPS > 0:\n            obj_logP_termA[iteration_idx] = get_obj_term_A(train_data_as_arr, rbm.weights, rbm.visible_bias,\n                                                           rbm.hidden_bias, beta=beta)\n            print('Estimating log Z...', )\n            obj_logP_termB[iteration_idx], _ = manual_AIS(rbm, beta, nchains=AIS_CHAINS, nsteps=AIS_STEPS, CDK=1,\n                                                          joint_mode=True)\n        # save parameters each epoch\n        weights_timeseries[:, :, iteration_idx] = rbm.weights.numpy()\n        if use_fields:\n            visible_bias_timeseries[:, iteration_idx] = rbm.visible_bias.numpy()\n            hidden_bias_timeseries[:, iteration_idx] = rbm.hidden_bias.numpy()\n\n        print('Term A:', obj_logP_termA[iteration_idx],\n              '| Log Z:', obj_logP_termB[iteration_idx],\n              '| Score:', obj_logP_termA[iteration_idx] - obj_logP_termB[iteration_idx])\n\n    loop_updates(0, 0)\n\n    print('Training RBM...')\n    iteration_counter = 0\n    for epoch in range(epochs):\n        if epoch == learningrate_schedule_epoch and learningrate_schedule:\n            rbm.learning_rate = learningrate_schedule_value\n        print('LEARNING RATE: %.2E' % rbm.learning_rate)\n\n        epoch_recon_error = 0.0\n        for batch, _ in train_loader:\n            iteration_counter += 1\n            batch = batch.view(len(batch), VISIBLE_UNITS)  # flatten input data\n            batch = (batch > MNIST_BINARIZATION_CUTOFF).float()  # convert to 0,1 form\n            batch = -1 + batch * 2  # convert to -1,1 form\n            batch_recon_error = rbm.contrastive_divergence(batch)\n            epoch_recon_error += batch_recon_error\n\n            if POINTS_PER_EPOCH != 1:\n                if iteration_counter % iterations_per_pt == 0:\n                    iteration_idx = int(iteration_counter \/ iterations_per_pt)\n                    loop_updates(iteration_idx, iteration_counter, epoch_recon_error=epoch_recon_error)\n\n        if POINTS_PER_EPOCH == 1:\n            iteration_idx = epoch + 1\n            loop_updates(iteration_idx, iteration_counter, epoch_recon_error=epoch_recon_error)\n\n    score_arr = obj_logP_termA - obj_logP_termB\n\n    if outdir is None:\n        scoredir = DIR_OUTPUT + os.sep + 'logZ' + os.sep + 'rbm'\n    else:\n        scoredir = outdir\n\n    # save parameters\n    title_mod = '%dhidden_%dfields_%dcdk_%dstepsAIS_%.2fbeta%s' % (hidden_units, use_fields, cdk, AIS_STEPS, beta, fmod)\n    fpath = scoredir + os.sep + 'objective_%s' % title_mod\n    np.savez(fpath,\n             epochs=range(epochs + 1),\n             iterations=iteration_arr,\n             termA=obj_logP_termA,\n             logZ=obj_logP_termB,\n             score=score_arr)\n\n    fpath = scoredir + os.sep + 'weights_%s' % title_mod\n    np.savez(fpath,\n             epochs=range(epochs + 1),\n             weights=weights_timeseries)  #TODO add iterations arr\n    if use_fields:\n        np.savez(scoredir + os.sep + 'visiblefield_%s' % title_mod,\n                 epochs=range(epochs + 1),\n                 iterations=iteration_arr,\n                 visiblefield=visible_bias_timeseries)\n        np.savez(scoredir + os.sep + 'hiddenfield_%s' % title_mod,\n                 epochs=range(epochs + 1),\n                 iterations=iteration_arr,\n                 hiddenfield=hidden_bias_timeseries)\n\n    plot_scores(iteration_arr, obj_logP_termA, obj_logP_termB, score_arr, scoredir, title_mod, 'iterations',\n                obj_reconstruction=obj_reconstruction)\n\n    if classify:\n        classify_with_rbm_hidden(rbm, outdir=outdir)\n\n    return rbm\n\n\ndef plot_scores(iteration_arr, obj_logP_termA, obj_logP_termB, score_arr, scoredir, title_mod, xlabel,\n                obj_reconstruction=None):\n    if obj_reconstruction is not None:\n        plt.plot(iteration_arr[1:], obj_reconstruction)\n        plt.xlabel(xlabel);\n        plt.ylabel('reconstruction error')\n        plt.savefig(scoredir + os.sep + 'rbm_recon_%s.pdf' % (title_mod)); plt.close()\n\n    plt.plot(iteration_arr, obj_logP_termA)\n    plt.xlabel(xlabel);\n    plt.ylabel(r'$- \\langle H(s) \\rangle$')\n    plt.savefig(scoredir + os.sep + 'rbm_termA_%s.pdf' % (title_mod)); plt.close()\n\n    plt.plot(iteration_arr, obj_logP_termB)\n    plt.xlabel(xlabel);\n    plt.ylabel(r'$\\ln \\ Z$')\n    plt.savefig(scoredir + os.sep + 'rbm_logZ_%s.pdf' % (title_mod)); plt.close()\n\n    plt.plot(iteration_arr, score_arr)\n    plt.xlabel(xlabel);\n    plt.ylabel(r'$\\langle\\ln \\ p(x)\\rangle$')\n    plt.savefig(scoredir + os.sep + 'rbm_score_%s.pdf' % (title_mod)); plt.close()\n    return\n\n\ndef classify_with_rbm_hidden(rbm, train_dataset, train_loader, test_dataset, test_loader, outdir=None, beta=BETA):\n    stdev = 1.0\/np.sqrt(beta)\n\n    print('Extracting features...')\n    train_features = np.zeros((len(train_dataset), rbm.num_hidden))\n    train_labels = np.zeros(len(train_dataset))\n    test_features = np.zeros((len(test_dataset), rbm.num_hidden))\n    test_labels = np.zeros(len(test_dataset))\n    for i, (batch, labels) in enumerate(train_loader):\n        batch = batch.view(len(batch), VISIBLE_UNITS)  # flatten input data\n        batch = (batch > MNIST_BINARIZATION_CUTOFF).float()  # convert to 0,1 form\n        batch = 2 * batch - 1  # convert to -1,1 form\n        train_features[i * BATCH_SIZE:i * BATCH_SIZE + len(batch), :] = rbm.sample_hidden(batch, stdev=stdev)\n        train_labels[i * BATCH_SIZE:i * BATCH_SIZE + len(batch)] = labels.numpy()\n\n    for i, (batch, labels) in enumerate(test_loader):\n        batch = batch.view(len(batch), VISIBLE_UNITS)  # flatten input data\n        batch = (batch > MNIST_BINARIZATION_CUTOFF).float()  # convert to 0,1 form\n        batch = 2 * batch - 1  # convert to -1,1 form\n        test_features[i * BATCH_SIZE:i * BATCH_SIZE + len(batch), :] = rbm.sample_hidden(batch, stdev=stdev)\n        test_labels[i * BATCH_SIZE:i * BATCH_SIZE + len(batch)] = labels.numpy()\n\n    print('Training Classifier...')\n    CLASSIFIER.fit(train_features, train_labels)\n    print('Classifying...')\n    predictions = CLASSIFIER.predict(test_features).astype(int)\n\n    confusion_matrix = np.zeros((10, 10), dtype=int)\n    matches = [False for _ in test_dataset]\n    for idx, pair in enumerate(test_dataset):\n        if pair[1] == predictions[idx]:\n            matches[idx] = True\n        confusion_matrix[pair[1], predictions[idx]] += 1\n    title = \"Successful test cases: %d\/%d (%.3f)\" % (\n        matches.count(True), len(matches), float(matches.count(True) \/ len(matches)))\n    if outdir is None:\n        fpath = DIR_OUTPUT + os.sep + 'training' + os.sep + 'cm.jpg'\n    else:\n        fpath = outdir + os.sep + 'cm.jpg'\n    cm = plot_confusion_matrix(confusion_matrix, title=title, save=fpath)\n    print(title)\n    return\n\n\ndef classifier_on_poe_scores(models, dataset_train, dataset_test, outpath, clfs=None, beta=2.0, plot=False):\n    \"\"\"\n    models: dict of idx: rbm for idx in {0, ..., 9} i.e. the experts on each digit class\n    clfs: list of classifiers\n    \"\"\"\n\n    def score_1digit_model(model, img):\n        \"\"\"\n        see hinton2002 ... .py for details\n        \"\"\"\n        # should just be 0.5 * beta * Jij si sj\n        beta = 1.0\n        W = model.weights\n        dotp = np.dot(W.T, img)\n        # score = np.dot(dotp, dotp)  #\n        score = beta * np.dot(dotp, dotp) \/ 2.0\n        return score\n\n    if clfs is None:\n        clfs = [CLASSIFIER]\n\n    features_order = list(models.keys())\n    feature_dim = len(features_order)\n\n    def get_X_y_features(dataset):\n        X = np.zeros((len(dataset), feature_dim))\n        y = np.zeros(len(dataset), dtype=int)\n        for idx, pair in enumerate(dataset):\n            elem_arr, elem_label = pair\n            preprocessed_input = binarize_image_data(image_data_collapse(elem_arr), threshold=MNIST_BINARIZATION_CUTOFF)\n            features = np.array([score_1digit_model(models[key], preprocessed_input) for key in features_order])\n            #features = np.array([score_1digit_model(models[idx], preprocessed_input) for idx in range(10)])\n            X[idx, :] = features\n            y[idx] = elem_label\n        return X, y\n\n    print(\"[classifier_on_rbm_features] Step 1: get features for training\")\n    X_train_reduced, y_train = get_X_y_features(dataset_train)\n    print(\"\\tTraining data dimension\", X_train_reduced.shape, y_train.shape)\n\n    print(\"[classifier_on_rbm_features] Step 2: train classifier layer\")\n    for clf in clfs:\n        print('fitting...')\n        clf.fit(X_train_reduced, y_train)  # fit data\n\n    print(\"[classifier_on_rbm_features] Step 3: get features for testing\")\n    X_test_reduced, y_test = get_X_y_features(dataset_test)\n\n    print(\"[classifier_on_rbm_features] Step 4: classification metrics and confusion matrix\")\n    cms = [0] * len(clfs)\n    accs = [0] * len(clfs)\n    for idx, clf in enumerate(clfs):\n        print('predicting...')\n        predictions = clf.predict(X_test_reduced).astype(int)\n        confusion_matrix, matches = confusion_matrix_from_pred(predictions, y_test)\n        acc = float(matches.count(True) \/ len(matches))\n        cms[idx] = confusion_matrix\n        accs[idx] = acc\n        title = \"Successful test cases: %d\/%d (%.3f)\" % (matches.count(True), len(matches), acc)\n        if plot:\n            cm = plot_confusion_matrix(confusion_matrix, title=title, save=outpath)\n            plt.close()\n        print(title)\n    return cms, accs\n\n\nif __name__ == '__main__':\n\n    train_dataset, train_loader, test_dataset, test_loader = torch_data_loading()\n    TRAINING, TESTING = data_mnist(binarize=True)\n    X, _ = get_X_y_dataset(TRAINING, dim_visible=VISIBLE_UNITS, binarize=True)\n\n    test_data_loader = False\n\n    num_runs = 5\n    hopfield_runs = False\n    random_runs = False\n    restart_random_runs = False\n\n    load_scores = False\n    load_weights = False\n\n    poe_mode_train = False\n    poe_mode_classify = True\n    # TODO print settings file for each run\n\n    rescore_ais_trained_rbms = False\n\n    if test_data_loader:\n        seven_loader = get_classloader(train_dataset, 7)\n\n    bigruns = DIR_OUTPUT + os.sep + 'archive' + os.sep + 'big_runs'\n    if hopfield_runs:\n\n        HEBBIAN = False\n        PCA = False\n        MOD_SVD = False\n        MOD_SQRT = False\n        if HEBBIAN:\n            hmod = '_hebbian'\n            assert not PCA\n        elif PCA:\n            hmod = '_PCA'\n        else:\n            hmod = ''\n\n        # load hopfield weights\n        npzpath = DIR_MODELS + os.sep + 'saved' + os.sep + 'hopfield_mnist_%d%s.npz' % (HIDDEN_UNITS, hmod)\n        print(\"Loading weights from %s\" % npzpath)\n        arr = np.load(npzpath)['Q']\n\n        # modify initial weight matrix\n        if MOD_SVD or MOD_SQRT:\n            assert HEBBIAN\n            import scipy as sp\n            A = np.dot(arr.T, arr)\n            A_inv = np.linalg.inv(A)\n            A_sqrt = sp.linalg.sqrtm(A)  # A_sqrt = mtrx_sqrt(A)\n            A_sqrt_inv = np.linalg.inv(A_sqrt)\n\n            if MOD_SVD:\n                # svd of XI\n                U, Sigma, V = np.linalg.svd(arr, full_matrices=False)\n\n                init_weights = torch.from_numpy(U).float()\n            else:\n                assert MOD_SQRT\n                K = np.dot(arr, A_sqrt_inv)\n                init_weights = torch.from_numpy(K).float()\n        else:\n            init_weights = torch.from_numpy(arr).float()\n\n        outdir = bigruns + os.sep + 'rbm' + os.sep + 'hopfield%s_%dhidden_%dfields_%.2fbeta_%dbatch_%depochs_%dcdk_%.2Eeta_%dais_%dppEpoch' % \\\n                 (hmod, HIDDEN_UNITS, USE_FIELDS, BETA, BATCH_SIZE, EPOCHS, CD_K, LEARNING_RATE, AIS_STEPS, POINTS_PER_EPOCH)\n\n        for idx in range(num_runs):\n            rundir = outdir + os.sep + 'run%d' % idx\n            custom_RBM_loop(train_loader, X, init_weights=init_weights.clone(), outdir=rundir, classify=False)\n\n    if random_runs:\n        for idx in range(num_runs):\n            outdir = bigruns + os.sep + 'rbm' + os.sep + 'normal_%dhidden_%dfields_%.2fbeta_%dbatch_%depochs_%dcdk_%.2Eeta_%dais_%dppEpoch' % \\\n                     (HIDDEN_UNITS, USE_FIELDS, BETA, BATCH_SIZE, EPOCHS, CD_K, LEARNING_RATE, AIS_STEPS, POINTS_PER_EPOCH)\n            rundir = outdir + os.sep + 'run%d' % idx\n            custom_RBM_loop(train_loader, X, init_weights=None, outdir=rundir, classify=False)\n\n    if restart_random_runs:\n        EPOCHS_RESTART = 100\n        HIDDEN_RESTART = 50\n        ETA_RESTART = 1e-4\n        AIS_STEPS_RESTART = 200\n        EPOCHS_TO_EXTEND = 100\n\n        for idx in range(num_runs):\n            # load pre-trained weights\n            indir = bigruns + os.sep + 'rbm' + os.sep + 'normal_%dhidden_%dfields_%.2fbeta_%dbatch_%depochs_%dcdk_%.2Eeta_%dais' % \\\n                     (HIDDEN_RESTART, USE_FIELDS, BETA, BATCH_SIZE, EPOCHS_RESTART, CD_K, ETA_RESTART, AIS_STEPS_RESTART)\n            rundir = indir + os.sep + 'run%d' % idx\n            print(\"Loading PRE_TRAINED weights from %s\" % rundir)\n            npzpath = rundir + os.sep + 'weights_%dhidden_%dfields_%dcdk_%dstepsAIS_%.2fbeta.npz' % (HIDDEN_RESTART, USE_FIELDS, CD_K, AIS_STEPS_RESTART, BETA)\n            loaded_weights_timeseries_np = np.load(npzpath)['weights']\n            init_weights_np = loaded_weights_timeseries_np[:, :, -1]\n            init_weights = torch.from_numpy(init_weights_np).float()\n            # specify new filename modifier\n            outdir = rundir + '_restart'\n            custom_RBM_loop(train_loader, X, init_weights=init_weights, outdir=outdir, classify=False, restart=True, epochs=EPOCHS_TO_EXTEND)\n\n    if load_scores:\n        outdir = bigruns + os.sep + 'rbm' + os.sep + 'C_beta2duringTraining_%dbatch_%depochs_%dcdk_%.2Eeta_%dais' % (BATCH_SIZE, EPOCHS, CD_K, LEARNING_RATE, AIS_STEPS)\n        fname = 'objective_10hidden_0fields_20cdk_200stepsAIS_2.00beta.npz'\n        dataobj = np.load(outdir + os.sep + fname)\n\n        obj_logP_termA = dataobj['termA']\n        obj_logP_termB = dataobj['logZ']\n        score_arr = dataobj['score']\n        epochs = dataobj['epochs']\n        timesteps = len(epochs) - 1\n\n        title_mod = '10hidden_0fields_20cdk_200stepsAIS_2.00beta'\n        plot_scores(timesteps, obj_logP_termA, obj_logP_termB, score_arr, outdir, title_mod,\n                    'epochs', obj_reconstruction=None)\n\n    if load_weights:\n        # Note: looks like generative training does not help with classification at first glance\n        local_beta = 200\n        hidden = 1000\n        epoch_idx = 199\n\n        outdir = bigruns + os.sep + 'rbm' + os.sep + 'normal_%dhidden_0fields_2.00beta_100batch_200epochs_1cdk_1.00E-04eta_0ais' % hidden \\\n                 + os.sep + 'run0'\n        fname = 'weights_%dhidden_0fields_1cdk_0stepsAIS_2.00beta.npz' % hidden\n        dataobj = np.load(outdir + os.sep + fname)\n        arr = dataobj['weights'][:, :, epoch_idx]\n\n        rbm = RBM(VISIBLE_UNITS, hidden, 0, init_weights=None, use_fields=False, learning_rate=0)\n        rbm.weights = torch.from_numpy(arr).float()\n\n        classify_with_rbm_hidden(rbm, train_dataset, train_loader, test_dataset, test_loader, outdir=outdir, beta=local_beta)\n\n    if poe_mode_train:\n        # TODO X_for_digit make (will be called if AIS steps > 0 ) -- second arg to custom_RBM_loop()\n        # TODO beta in scoring\n        use_hopfield = True\n        k_range = [10, 20, 100] #, 200, 500, 250, 300]\n        runs = 3\n\n        HEBBIAN = False\n        PCA = True\n        MOD_SVD = False\n        MOD_SQRT = False\n        if HEBBIAN:\n            hmod = '_hebbian'\n            assert not PCA\n        elif PCA:\n            hmod = '_PCA'\n        else:\n            hmod = ''\n\n        loader_dict = {idx: get_classloader(train_dataset, idx)[0] for idx in range(10)}\n        loader_num_samples_dict = {idx: get_classloader(train_dataset, idx)[1] for idx in range(10)}\n\n        for idx in range(runs):\n            for k in k_range:\n                print(\"Training POE for k=%d\" % k)\n                for digit in range(10):\n                    print(\"Training POE for k=%d (digit: %d)\" % (k, digit))\n                    dir_modifier = '%ddigit_%dhidden_%dfields_%.2fbeta_%dbatch_%depochs_%dcdk_%.2Eeta_%dais' % \\\n                                   (digit, k, USE_FIELDS, BETA, BATCH_SIZE, EPOCHS, CD_K, LEARNING_RATE, AIS_STEPS)\n\n                    fake_empty_data = np.zeros((loader_num_samples_dict[digit], 28**2))\n\n                    if use_hopfield:\n                        outdir = bigruns + os.sep + 'poe' + os.sep + 'run%d' % idx + os.sep + \\\n                                 'poe_hopfield%s_%s' % (hmod, dir_modifier)\n                        rundir = outdir\n                        # load hopfield weights\n                        npzpath = DIR_MODELS + os.sep + 'poe' + os.sep + 'hopfield_digit%d_p%d%s.npz' % (digit, 10*k, hmod)\n                        print(\"Loading weights from %s\" % npzpath)\n                        arr = np.load(npzpath)['Q']\n                        init_weights = torch.from_numpy(arr).float()\n\n                        custom_RBM_loop(loader_dict[digit], fake_empty_data, hidden_units=k, init_weights=init_weights.clone(), outdir=rundir, classify=False)\n                    else:\n                        outdir = bigruns + os.sep + 'poe' + os.sep + 'run%d' % idx + os.sep + \\\n                                 'poe_normal_%s' % dir_modifier\n                        rundir = outdir\n                        custom_RBM_loop(loader_dict[digit], fake_empty_data, hidden_units=k, init_weights=None, outdir=rundir, classify=False)\n\n    if poe_mode_classify:\n        init_weights_type = 'hopfield'  # hopfield or normal\n\n        HEBBIAN = False\n        PCA = False\n        if HEBBIAN:\n            assert init_weights_type == 'hopfield'\n            assert not PCA\n            init_weights_type += '_hebbian'\n        elif PCA:\n            assert init_weights_type == 'hopfield'\n            init_weights_type += '_PCA'\n        else:\n            hmod = ''\n\n        k_range = [10, 20, 100]    #, 200, 250, 300, 500]  # range(1, 110)  # 110\n        epochs = [0, 1, 2, 3, 4] + list(range(5, 101, 5))\n        runs = [2] # [0,1,2]          # TODO care\n        accs = np.zeros((len(epochs), len(k_range)))\n\n        for run in runs:\n            for epoch_idx, epoch in enumerate(epochs):\n                for k_idx, k in enumerate(k_range):\n                    print('epoch, k:', epoch, k)\n                    hidden_units = k\n                    dir_modifier = '0fields_2.00beta_100batch_100epochs_%dcdk_1.00E-04eta_0ais' % (CD_K)\n                    models10 = {}\n                    for digit in range(10):\n                        rbm_digit = RBM(VISIBLE_UNITS, hidden_units, 0, init_weights=None, use_fields=False, learning_rate=0)\n                        # load weights for given epoch\n                        run_dir = bigruns + os.sep + 'poe' + os.sep + '%s' % init_weights_type + os.sep + 'run%d' % run\n                        npzpdir = run_dir + os.sep + \\\n                                  'poe_%s_%ddigit_%dhidden_%s' % (init_weights_type, digit, hidden_units, dir_modifier)\n                        weights_path = npzpdir + os.sep + 'weights_%dhidden_0fields_%dcdk_0stepsAIS_2.00beta.npz' % (hidden_units, CD_K)\n                        arr = np.load(weights_path)['weights'][:, :, epoch]\n                        rbm_digit.weights = torch.from_numpy(arr).float()\n                        # set as model for that digit\n                        models10[digit] = rbm_digit\n                    fpath = DIR_OUTPUT + os.sep + 'training' + os.sep + 'cm_%s_k%d_epoch%d.jpg' % (init_weights_type, k, epoch)\n                    cm_list, acc_list = classifier_on_poe_scores(models10, TRAINING, TESTING, fpath, clfs=None, beta=2.0, plot=False)\n                    accs[epoch_idx, k_idx] = acc_list[0]\n\n            # save data\n            fpath = DIR_OUTPUT + os.sep + 'training' + os.sep + 'poe_scores_kNum%d_epochsNum%d_%s%d.npz' % \\\n                    (len(k_range), len(epochs), init_weights_type, run)\n            np.savez(fpath, accs_epoch_by_k=accs, epochs=epochs, k_range=k_range)\n            print(accs)\n            # plot data\n            plt.figure()\n            error_pct = 100 * (1 - accs)\n            for idx, epoch in enumerate(epochs):\n                plt.plot(k_range, error_pct[idx, :], label='Epoch: %d' % epoch)\n            plt.xlabel(r'$k$')\n            plt.ylabel('Error')\n            plt.legend()\n            plt.savefig(DIR_OUTPUT + os.sep + 'training' + os.sep + 'score_vs_k%d_vs_epoch%d_%s%d.jpg' %\n                        (len(k_range), len(epochs), init_weights_type, run))\n            plt.show()\n            # TODO check if hinton use logreg or SVM\n            # TODO increase max iter to remove warning: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n            #   \"the coef_ did not converge\", ConvergenceWarning)\n            # TODO more epochs on whichever k worked best? depends on how the error scales with epoch at large k\n            # TODO compare vs normal dist (note this run of 20epochs x 110 k values was ~11GB)\n\n    if rescore_ais_trained_rbms:\n\n        # AIS settings\n        beta = 2.0\n        nsteps = 1000\n        nchains = 100\n        ntest = 1\n        nsteps_rev = 0\n        nchains_rev = 0\n        runs = 1\n        assert runs == 1\n        # hebbian = False\n        \"\"\"\n        if hebbian:\n            strmod = '_hebbian'\n        else:\n            strmod = '' \"\"\"\n\n        # prep dataset\n        training_subsample = TRAINING[:]\n        X, _ = get_X_y_dataset(training_subsample, dim_visible=28 ** 2, binarize=True)\n\n        # prep models to load\n        epoch_list = list(range(0, 51))  #71\n        VISIBLE_UNITS = 28 ** 2\n        hidden_units = 50\n        CD_K = 20\n        bigruns = DIR_OUTPUT + os.sep + 'archive' + os.sep + 'big_runs' + os.sep + 'rbm'\n        model_dir = 'hopfield_PCA_%dhidden_0fields_2.00beta_100batch_50epochs_20cdk_1.00E-04eta_0ais_1ppEpoch' % hidden_units\n        model_runs = [2,3,4] #[0,1,2,3,4]  #[0, 1, 2, 3, 4]\n        model_paths = [\n            bigruns + os.sep + model_dir + os.sep + 'run%d' % a + os.sep +\n            'weights_%dhidden_0fields_20cdk_0stepsAIS_2.00beta.npz' % hidden_units\n            for a in model_runs\n        ]\n\n        for training_run_idx, weights_path in enumerate(model_paths):\n\n            # load weights for given epoch\n            weights_timeseries_np = np.load(weights_path)['weights']\n\n            rbm = RBM(VISIBLE_UNITS, hidden_units, 0, init_weights=None, use_fields=False, learning_rate=0)\n            N = rbm.num_visible\n            p = rbm.num_hidden\n            zero_field_visible = np.zeros(N)\n            zero_field_hidden = np.zeros(p)\n\n            termA_arr = np.zeros(len(epoch_list))\n            logZ_arr = np.zeros(len(epoch_list))\n            score_arr = np.zeros(len(epoch_list))\n\n            for idx in range(len(epoch_list)):\n                epoch = epoch_list[idx]\n                # specify new local rbm class for this epoch only\n                weights_epoch_np = weights_timeseries_np[:, :, epoch]\n                rbm.weights = torch.from_numpy(weights_epoch_np).float()\n\n                obj_term_A = get_obj_term_A(X, weights_epoch_np, zero_field_visible, zero_field_hidden, beta=beta)\n                termA_arr[idx] = obj_term_A\n\n                # Forward AIS\n                logZ_fwd, _ = manual_AIS(rbm, beta, nchains=nchains, nsteps=nsteps)\n                score_fwd = obj_term_A - logZ_fwd\n                print('training_run_idx, epoch:', training_run_idx, epoch)\n                print('mean log p(data):', score_fwd,\n                      '(run 1 only, beta=%.2f, A=%.2f, B=%.2f)' % (beta, obj_term_A, logZ_fwd))\n                logZ_arr[idx] = logZ_fwd\n                score_arr[idx] = score_fwd\n\n            # save updated AIS data\n            out_dir = os.path.dirname(weights_path)\n            title_mod = '%dhidden_%dfields_%dcdk_%dstepsAIS_%.2fbeta' % (hidden_units, False, CD_K, nsteps, beta)\n            fpath = out_dir + os.sep + 'objective_%s' % title_mod\n            np.savez(fpath,\n                     epochs=epoch_list,\n                     termA=termA_arr,\n                     logZ=logZ_arr,\n                     score=score_arr)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_676","text":"import numpy as np\nfrom scipy.special import roots_legendre\n\nclass Contour():\n    def __init__(self, emin, emax=0.0):\n        self.emin=emin\n        self.emax=emax\n\n    def build_path_semicircle(self, npoints, endpoint=True):\n        R= (self.emax-self.emin)\/2.0\n        R0= (self.emin+self.emax)\/2.0\n        phi=np.linspace(np.pi, 0, num=npoints+1, endpoint=endpoint)\n        p=R0+R*np.exp(1.0j * phi)\n        if endpoint:\n            self.path=p\n            self.de=np.diff(p)\n        else:\n            self.path=(p[:-1]+p[1:])\/2\n            self.de=p[1:]-p[:-1]\n    \n    def build_path_legendre(self, npoints, endpoint=True):\n        p=13\n        x,w= roots_legendre(npoints)\n        R= (self.emax-self.emin)\/2.0\n        R0= (self.emin+self.emax)\/2.0\n        y1 = -np.log(1+np.pi*p)\n        y2 = 0\n        y   = (y2-y1)\/2*x+(y2+y1)\/2\n        phi = (np.exp(-y)-1)\/p\n        path  = R0+R*np.exp(1.0j*phi)\n        #weight= -(y2-y1)\/2*np.exp(-y)\/p*1j*(path-R0)*w\n        if endpoint:\n            self.path=path\n            self.de=np.diff(path)\n        else:\n            self.path=(path[:-1]+path[1:])\/2\n            self.de=path[1:]-path[:-1]\n \n    def build_path_rectangle(self, height=0.1, nz1=50, nz2=200, nz3=50):\n        \"\"\"\n        prepare list of energy for integration.\n        The path has three segments:\n         emin --1-> emin + 1j*height --2-> emax+1j*height --3-> emax\n        \"\"\"\n        nz1, nz2, nz3 = nz1, nz2, nz3\n        nz = nz1+nz2+nz3\n        p= np.zeros(nz + 1, dtype='complex128')\n        p[:nz1] = self.emin + np.linspace(\n            0, height, nz1, endpoint=False) * 1j\n        p[nz1:nz1 + nz2] = self.emin + height * 1j + np.linspace(\n            0, self.emax - self.emin, nz2, endpoint=False)\n        p[nz1 + nz2:nz] = self.emax + height * 1j + np.linspace(\n            0, -height, nz3, endpoint=False) * 1j\n        p[-1] = self.emax  # emax\n        self.path=(p[:-1]+p[1:])\/2\n        self.de=p[1:]-p[:-1]\n\n\n    @property\n    def npoints(self):\n        return len(self.path)\n\n    def de(self):\n        return self.de\n\n    def plot(self, ax=None):\n        import matplotlib.pyplot as plt\n        if ax is None:\n            fig,ax=plt.subplots()\n        plt.plot(self.path.real, self.path.imag, marker='.')\n        plt.show()\n\n\n\ndef test():\n    ct=Contour(emin=-16, emax=0)\n    #ct.build_path_semicircle(npoints=100)\n    #ct.build_path_rectangle()\n    ct.build_path_legendre(npoints=50)\n    print(ct.npoints)\n    ct.plot()\nif __name__ == '__main__':\n    test()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_677","text":"<reponame>Noone65536\/CORSMAL-Challenge-2022-Squids\nfrom logging.config import valid_ident\nimport numpy as np\nimport cv2\nimport torch\nimport os\nimport scipy.stats as stats\nfrom torch.utils.data import Dataset\nfrom tqdm import tqdm\nfrom PIL import Image\nfrom torchvision import datasets, transforms\n\ndef randomlyAug(crop, depth, label, max_val=640, square=False, normal=False, depth_aug=False):\n  h, w, c = crop.shape\n\n  if h >= w:\n    max_dim = h\n  else:\n    max_dim = w\n  max_rand = max_val \/ max_dim\n\n  lower, upper = 0.5, 1.5\n  if upper > max_rand:\n      upper = max_rand\n  mu, sigma = 1, 0.5\n  X = stats.truncnorm(\n    (lower - mu) \/ sigma, (upper - mu) \/ sigma, loc=mu, scale=sigma)\n\n  if not normal:\n      rand_num = np.random.uniform(0.5,max_rand,1).item()\n  else:\n      rand_num = X.rvs(1).item()\n\n      while rand_num < lower or rand_num > upper:\n          rand_num = X.rvs(1).item()\n\n\n      \n\n  width = int(w * rand_num)\n  height = int(h * rand_num)\n  dim = (width, height)\n    \n  # resize image\n  crop = cv2.resize(crop, dim, interpolation = cv2.INTER_AREA)\n  depth = cv2.resize(depth, dim, interpolation = cv2.INTER_NEAREST)[:, :, np.newaxis]\n\n  if square:\n      label *= (height \/ h)**2\n  else:\n      label *= (height \/ h)\n  \n  # depth aug\n\n  lower, upper = 0.8, 1.2\n\n  mu, sigma = 1, 0.5\n  X = stats.truncnorm(\n    (lower - mu) \/ sigma, (upper - mu) \/ sigma, loc=mu, scale=sigma)\n\n  if depth_aug:\n      rand_num = X.rvs(1).item()\n\n      while rand_num < lower or rand_num > upper:\n              rand_num = X.rvs(1).item()\n      \n      depth = (depth * rand_num).astype(np.uint8)\n    \n      if square:\n          label *= rand_num**2\n      else:\n          label *= rand_num\n\n\n  \n  \n  return crop, depth, label\n \n\n\n\ndef get_annotation(id,input,anno_path='\/content\/labels'):\n    anno = np.load(os.path.join(anno_path,'{:06d}.npy'.format(id)),allow_pickle=True).item()\n    return anno.get(input)\n    \n\nclass MiniDataset(Dataset):\n    def __init__(self, base_p, label_f, depth, crops_rgb_f, aug=False, square=False, normal=False, depth_aug=False, label_name=['container capacity']):\n      self.label_f = label_f #_f = folder\n      self.depth = depth\n      self.base = base_p\n      self.label_name = label_name\n      self.crops_rgb_f = crops_rgb_f\n      self.samples = os.listdir(crops_rgb_f)\n      self.ids = [ int(x.split('.')[0]) for x in self.samples]\n      self.transform = transforms.Compose([\n                                             transforms.Resize((320, 320)),\n                                             transforms.ToTensor(),\n                                             transforms.ConvertImageDtype(torch.float),\n                                             ])\n      self.aug = aug\n      self.square = square\n      self.normal = normal\n      self.depth_aug = depth_aug\n    def __len__(self):\n      return len(self.ids)\n\n    def __getitem__(self, idx):\n      id_ = self.ids[idx]\n        \n      # depth\n      depth = np.asarray(Image.open(os.path.join(self.depth,'{:06d}.png'.format(id_))))[:,:,np.newaxis]\n      \n      # rgb_cropped\n      crop = np.asarray(Image.open(os.path.join(self.crops_rgb_f,'{:06d}.png'.format(id_))))\n      # label\n      label = np.array([get_annotation(id_,name,os.path.join(self.base, 'labels')) for name in self.label_name]).astype(np.float)\n\n      if self.aug:\n          crop, depth, label = randomlyAug(crop, depth, label, max_val=640, square=self.square, normal=self.normal, depth_aug=self.depth_aug)\n\n      h, w, c = crop.shape\n\n      resX = 640 - h\n      resY = 640 - w\n\n      up = resX \/\/ 2\n      down = up\n      if resX % 2 != 0:\n        down +=1\n\n      left = resY \/\/ 2\n      right = left\n\n      if resY % 2 != 0:\n        left += 1\n\n      padding = transforms.Pad((left, up, right, down))\n\n    \n      image = Image.fromarray(np.concatenate((crop, depth), axis=2))\n      image = padding(image)\n      image = self.transform(image)\n      \n\n      return image, label\n\n\nclass audioDataSet(Dataset):\n  def __init__(self,root_pth,test=False,transform = None):\n    print(\"Dataset initializing...\")\n    class_num=4\n    self.audio_pth = os.path.join(root_pth, 'audios', 'mfcc')\n    filling_type = np.load(os.path.join(root_pth, 'audios', 'filling_type.npy'))\n    pouring_or_shaking = np.load(os.path.join(root_pth,  'audios', 'pouring_or_shaking.npy'))\n    self.label = filling_type * pouring_or_shaking\n    self.is_test=test\n    self.each_class_size = []\n    for i in range(class_num):\n        self.each_class_size.append(np.count_nonzero(self.label==i))\n    mx=0\n    mn=1000\n    for idx in tqdm(range(self.label.shape[0])):\n        data=np.load(os.path.join(self.audio_pth, \"{0:06d}\".format(idx+1) + '.npy'), allow_pickle=True)\n        tmp_max=np.max(data)\n        tmp_min=np.min(data)\n        if mx<tmp_max:\n            mx=tmp_max\n        if mn>tmp_min:\n            mn=tmp_min\n    self.mn=mn\n    self.mx=mx\n  def __len__(self):\n    return self.label.shape[0]\n  def __getitem__(self, idx):\n        if torch.is_tensor(idx):\n            idx = idx.tolist()\n\n        lbl = -1\n\n        if self.is_test is False:\n            lbl = self.label[idx]\n        data=np.load(os.path.join(self.audio_pth, \"{0:06d}\".format(idx+1) + '.npy'), allow_pickle=True)\n        data= (data-self.mn)\/(self.mx-self.mn)\n        data=data.transpose(2,0,1)\n        data=torch.from_numpy(data.astype(np.float32))\n        return data , lbl\n            \n  def get_each_class_size(self):\n    return np.array(self.each_class_size)\n\n\n\nclass Padding(object):\n    def __init__(self, seq_len):\n        self.seq_len = seq_len\n\n    def __call__(self, sample, pred):\n        #np.clip(pred, 0,1,out=pred)\n        sample_len, input_dim = sample.shape\n        #for i in range(sample_len):\n        #    sample[i, :] *= pred[i]\n\n        if sample_len >= self.seq_len:\n            features = sample[:self.seq_len, :]\n            return features\n        else:\n            start_seq = np.random.randint(0, self.seq_len - sample_len+1)\n            #ini=[1]+[0]*(input_dim-1)\n            ini=[0]*(input_dim)\n            features = np.full((self.seq_len, input_dim),ini, dtype = float)\n            features[start_seq:start_seq+sample_len, :] = sample\n            return features\n\nclass MyLSTMDataset(torch.utils.data.Dataset):\n    def __init__(self,root_pth,label=None, test=False,transform = None, padding_size = 100):\n        class_num=3\n        self.mid_pth = os.path.join(root_pth,'features', 'T2_mid_test')\n        self.pred_pth = os.path.join(root_pth,'features', 'T2_pred_test')\n        self.label = label  # gt['filling_level'].to_numpy()\n        self.is_test=test\n        self.each_class_size = []\n        self.each_class_sum = [0]*class_num\n        for i in range(class_num):\n            self.each_class_size.append(np.count_nonzero(self.label==i))\n        mx=0\n        mn=1000\n        len_mx = 0\n        \n        if label is None:\n            self.label = np.zeros((len(os.listdir(self.mid_pth))))\n        \n        for idx in range(len(os.listdir(self.mid_pth))):\n            data=np.load(os.path.join(self.mid_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n            #self.each_class_sum[self.label[idx]]+=data.shape[0]\n            if data.shape[0] > len_mx:\n                len_mx=data.shape[0]\n            tmp_max=np.max(data)\n            tmp_min=np.min(data)\n            if mx<tmp_max:\n                mx=tmp_max\n            if mn>tmp_min:\n                mn=tmp_min\n        self.mn=mn\n        self.mx=mx\n        self.pad = Padding(padding_size)\n        print(len_mx)\n            \n    def __len__(self):\n        return self.label.shape[0]\n    \n    def __getitem__(self, idx):\n        if torch.is_tensor(idx):\n            idx = idx.tolist()\n\n        lbl = -1\n\n        if self.is_test is False:\n            lbl = self.label[idx]\n            \n        data=np.load(os.path.join(self.mid_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n        pred=np.load(os.path.join(self.pred_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n        data = (data-self.mn)\/(self.mx-self.mn)\n        data = self.pad(data, pred)\n\n        #np.clip(data, 0,1,out=data)\n        data=torch.from_numpy(data.astype(np.float32))\n        return data , lbl\n            \n    def get_each_class_size(self):\n        return np.array(self.each_class_size)\n\n    def get_each_class_avg_len(self):\n        each_class_avg_len =  np.array(self.each_class_sum)\/np.array(self.each_class_size)\n        all_class_avg_len = np.sum(np.array(self.each_class_sum))\/np.sum(np.array(self.each_class_size))\n        return each_class_avg_len, all_class_avg_len\n    \nclass BatchProcess(Dataset):\n    \"\"\"\n    type  = train or test   \n    \"\"\"\n    def __init__(self,rgbs,depths):\n        \n        self.rgbs = rgbs\n        self.depths = depths\n        self.transform = transforms.Compose([transforms.Resize((320, 320)),\n                                             transforms.ToTensor(),\n                                             transforms.ConvertImageDtype(torch.float),\n                                             ])\n\n    def __len__(self):\n        return len(self.rgbs)\n\n    def __getitem__(self, idx):\n    \n        depth = np.asarray(self.depths[idx])[:,:,np.newaxis]\n\n        # rgb_cropped\n        crop = np.asarray(self.rgbs[idx])\n        h, w, c = crop.shape\n        resX = 640 - h\n        resY = 640 - w\n        up = resX \/\/ 2\n        down = up\n        if resX % 2 != 0:\n            down +=1\n        left = resY \/\/ 2\n        right = left\n        if resY % 2 != 0:\n            left += 1\n        padding = transforms.Pad((left, up, right, down))\n        image = Image.fromarray(np.concatenate((crop, depth), axis=2))\n        image = padding(image)\n        image = self.transform(image)\n\n        return image\n\nclass MyLSTMDataset_combine(torch.utils.data.Dataset):\n    def __init__(self,root_pth,label=None, test=False,transform = None, padding_size = 100):\n        class_num=3\n        self.mid_pth = os.path.join(root_pth,'features', 'T2_mid_test')\n        self.pred_pth = os.path.join(root_pth,'features', 'T2_pred_test')\n        self.video_pth = os.path.join(root_pth,'features_video_test')\n        self.label = label  # gt['filling_level'].to_numpy()\n        self.is_test=test\n        self.each_class_size = []\n        self.each_class_sum = [0]*class_num\n        for i in range(class_num):\n            self.each_class_size.append(np.count_nonzero(self.label==i))\n        mx=0\n        mn=1000\n        len_mx = 0\n        \n        if label is None:\n            self.label = np.zeros((len(os.listdir(self.mid_pth))))\n\n        for idx in range(len(os.listdir(self.mid_pth))):\n            data=np.load(os.path.join(self.mid_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n            #self.each_class_sum[self.label[idx]]+=data.shape[0]\n            if data.shape[0] > len_mx:\n                len_mx=data.shape[0]\n            tmp_max=np.max(data)\n            tmp_min=np.min(data)\n            if mx<tmp_max:\n                mx=tmp_max\n            if mn>tmp_min:\n                mn=tmp_min\n        self.mn=mn\n        self.mx=mx\n        self.pad = Padding(padding_size)\n        \n    def __len__(self):\n        return self.label.shape[0]\n    \n    def __getitem__(self, idx):\n        if torch.is_tensor(idx):\n            idx = idx.tolist()\n\n        lbl = -1\n\n        if self.is_test is False:\n            lbl = self.label[idx]\n          \n        data=np.load(os.path.join(self.mid_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n        data_video=np.load(os.path.join(self.video_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n        pred=np.load(os.path.join(self.pred_pth, \"{0:06d}\".format(idx) + '.npy'), allow_pickle=True)\n        data = (data-self.mn)\/(self.mx-self.mn)\n        data = self.pad(data, pred)\n        data_video =self.pad(self.pad(data, pred), pred)\n        data_combine=np.concatenate((data, data_video),axis=0)\n        data_combine=torch.from_numpy(data_combine.astype(np.float32))\n        return data_combine , lbl\n              \n    def get_each_class_size(self):\n        return np.array(self.each_class_size)\n\n    def get_each_class_avg_len(self):\n        each_class_avg_len =  np.array(self.each_class_sum)\/np.array(self.each_class_size)\n        all_class_avg_len = np.sum(np.array(self.each_class_sum))\/np.sum(np.array(self.each_class_size))\n        return each_class_avg_len, all_class_avg_len\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_678","text":"<reponame>msgoff\/sympy<filename>sympy\/polys\/tests\/test_orthopolys.py\n\"\"\"Tests for efficient functions for generating orthogonal polynomials. \"\"\"\n\nfrom sympy import Poly, S, Rational as Q\nfrom sympy.testing.pytest import raises\n\nfrom sympy.polys.orthopolys import (\n    jacobi_poly,\n    gegenbauer_poly,\n    chebyshevt_poly,\n    chebyshevu_poly,\n    hermite_poly,\n    legendre_poly,\n    laguerre_poly,\n)\n\nfrom sympy.abc import x, a, b\n\n\ndef test_jacobi_poly():\n    raises(ValueError, lambda: jacobi_poly(-1, a, b, x))\n\n    assert jacobi_poly(1, a, b, x, polys=True) == Poly(\n        (a \/ 2 + b \/ 2 + 1) * x + a \/ 2 - b \/ 2, x, domain=\"ZZ(a,b)\"\n    )\n\n    assert jacobi_poly(0, a, b, x) == 1\n    assert jacobi_poly(1, a, b, x) == a \/ 2 - b \/ 2 + x * (a \/ 2 + b \/ 2 + 1)\n    assert jacobi_poly(2, a, b, x) == (\n        a ** 2 \/ 8\n        - a * b \/ 4\n        - a \/ 8\n        + b ** 2 \/ 8\n        - b \/ 8\n        + x ** 2\n        * (a ** 2 \/ 8 + a * b \/ 4 + a * Q(7, 8) + b ** 2 \/ 8 + b * Q(7, 8) + Q(3, 2))\n        + x * (a ** 2 \/ 4 + a * Q(3, 4) - b ** 2 \/ 4 - b * Q(3, 4))\n        - S.Half\n    )\n\n    assert jacobi_poly(1, a, b, polys=True) == Poly(\n        (a \/ 2 + b \/ 2 + 1) * x + a \/ 2 - b \/ 2, x, domain=\"ZZ(a,b)\"\n    )\n\n\ndef test_gegenbauer_poly():\n    raises(ValueError, lambda: gegenbauer_poly(-1, a, x))\n\n    assert gegenbauer_poly(1, a, x, polys=True) == Poly(2 * a * x, x, domain=\"ZZ(a)\")\n\n    assert gegenbauer_poly(0, a, x) == 1\n    assert gegenbauer_poly(1, a, x) == 2 * a * x\n    assert gegenbauer_poly(2, a, x) == -a + x ** 2 * (2 * a ** 2 + 2 * a)\n    assert gegenbauer_poly(3, a, x) == x ** 3 * (\n        4 * a ** 3 \/ 3 + 4 * a ** 2 + a * Q(8, 3)\n    ) + x * (-2 * a ** 2 - 2 * a)\n\n    assert gegenbauer_poly(1, S.Half).dummy_eq(x)\n    assert gegenbauer_poly(1, a, polys=True) == Poly(2 * a * x, x, domain=\"ZZ(a)\")\n\n\ndef test_chebyshevt_poly():\n    raises(ValueError, lambda: chebyshevt_poly(-1, x))\n\n    assert chebyshevt_poly(1, x, polys=True) == Poly(x)\n\n    assert chebyshevt_poly(0, x) == 1\n    assert chebyshevt_poly(1, x) == x\n    assert chebyshevt_poly(2, x) == 2 * x ** 2 - 1\n    assert chebyshevt_poly(3, x) == 4 * x ** 3 - 3 * x\n    assert chebyshevt_poly(4, x) == 8 * x ** 4 - 8 * x ** 2 + 1\n    assert chebyshevt_poly(5, x) == 16 * x ** 5 - 20 * x ** 3 + 5 * x\n    assert chebyshevt_poly(6, x) == 32 * x ** 6 - 48 * x ** 4 + 18 * x ** 2 - 1\n\n    assert chebyshevt_poly(1).dummy_eq(x)\n    assert chebyshevt_poly(1, polys=True) == Poly(x)\n\n\ndef test_chebyshevu_poly():\n    raises(ValueError, lambda: chebyshevu_poly(-1, x))\n\n    assert chebyshevu_poly(1, x, polys=True) == Poly(2 * x)\n\n    assert chebyshevu_poly(0, x) == 1\n    assert chebyshevu_poly(1, x) == 2 * x\n    assert chebyshevu_poly(2, x) == 4 * x ** 2 - 1\n    assert chebyshevu_poly(3, x) == 8 * x ** 3 - 4 * x\n    assert chebyshevu_poly(4, x) == 16 * x ** 4 - 12 * x ** 2 + 1\n    assert chebyshevu_poly(5, x) == 32 * x ** 5 - 32 * x ** 3 + 6 * x\n    assert chebyshevu_poly(6, x) == 64 * x ** 6 - 80 * x ** 4 + 24 * x ** 2 - 1\n\n    assert chebyshevu_poly(1).dummy_eq(2 * x)\n    assert chebyshevu_poly(1, polys=True) == Poly(2 * x)\n\n\ndef test_hermite_poly():\n    raises(ValueError, lambda: hermite_poly(-1, x))\n\n    assert hermite_poly(1, x, polys=True) == Poly(2 * x)\n\n    assert hermite_poly(0, x) == 1\n    assert hermite_poly(1, x) == 2 * x\n    assert hermite_poly(2, x) == 4 * x ** 2 - 2\n    assert hermite_poly(3, x) == 8 * x ** 3 - 12 * x\n    assert hermite_poly(4, x) == 16 * x ** 4 - 48 * x ** 2 + 12\n    assert hermite_poly(5, x) == 32 * x ** 5 - 160 * x ** 3 + 120 * x\n    assert hermite_poly(6, x) == 64 * x ** 6 - 480 * x ** 4 + 720 * x ** 2 - 120\n\n    assert hermite_poly(1).dummy_eq(2 * x)\n    assert hermite_poly(1, polys=True) == Poly(2 * x)\n\n\ndef test_legendre_poly():\n    raises(ValueError, lambda: legendre_poly(-1, x))\n\n    assert legendre_poly(1, x, polys=True) == Poly(x)\n\n    assert legendre_poly(0, x) == 1\n    assert legendre_poly(1, x) == x\n    assert legendre_poly(2, x) == Q(3, 2) * x ** 2 - Q(1, 2)\n    assert legendre_poly(3, x) == Q(5, 2) * x ** 3 - Q(3, 2) * x\n    assert legendre_poly(4, x) == Q(35, 8) * x ** 4 - Q(30, 8) * x ** 2 + Q(3, 8)\n    assert legendre_poly(5, x) == Q(63, 8) * x ** 5 - Q(70, 8) * x ** 3 + Q(15, 8) * x\n    assert legendre_poly(6, x) == Q(231, 16) * x ** 6 - Q(315, 16) * x ** 4 + Q(\n        105, 16\n    ) * x ** 2 - Q(5, 16)\n\n    assert legendre_poly(1).dummy_eq(x)\n    assert legendre_poly(1, polys=True) == Poly(x)\n\n\ndef test_laguerre_poly():\n    raises(ValueError, lambda: laguerre_poly(-1, x))\n\n    assert laguerre_poly(1, x, polys=True) == Poly(-x + 1)\n\n    assert laguerre_poly(0, x) == 1\n    assert laguerre_poly(1, x) == -x + 1\n    assert laguerre_poly(2, x) == Q(1, 2) * x ** 2 - Q(4, 2) * x + 1\n    assert (\n        laguerre_poly(3, x) == -Q(1, 6) * x ** 3 + Q(9, 6) * x ** 2 - Q(18, 6) * x + 1\n    )\n    assert (\n        laguerre_poly(4, x)\n        == Q(1, 24) * x ** 4\n        - Q(16, 24) * x ** 3\n        + Q(72, 24) * x ** 2\n        - Q(96, 24) * x\n        + 1\n    )\n    assert (\n        laguerre_poly(5, x)\n        == -Q(1, 120) * x ** 5\n        + Q(25, 120) * x ** 4\n        - Q(200, 120) * x ** 3\n        + Q(600, 120) * x ** 2\n        - Q(600, 120) * x\n        + 1\n    )\n    assert (\n        laguerre_poly(6, x)\n        == Q(1, 720) * x ** 6\n        - Q(36, 720) * x ** 5\n        + Q(450, 720) * x ** 4\n        - Q(2400, 720) * x ** 3\n        + Q(5400, 720) * x ** 2\n        - Q(4320, 720) * x\n        + 1\n    )\n\n    assert laguerre_poly(0, x, a) == 1\n    assert laguerre_poly(1, x, a) == -x + a + 1\n    assert (\n        laguerre_poly(2, x, a)\n        == x ** 2 \/ 2 + (-a - 2) * x + a ** 2 \/ 2 + a * Q(3, 2) + 1\n    )\n    assert (\n        laguerre_poly(3, x, a)\n        == -(x ** 3) \/ 6\n        + (a \/ 2 + Q(3) \/ 2) * x ** 2\n        + (-(a ** 2) \/ 2 - a * Q(5, 2) - 3) * x\n        + a ** 3 \/ 6\n        + a ** 2\n        + a * Q(11, 6)\n        + 1\n    )\n\n    assert laguerre_poly(1).dummy_eq(-x + 1)\n    assert laguerre_poly(1, polys=True) == Poly(-x + 1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_679","text":"#!\/usr\/bin\/env python\n\"\"\"Collection of simple functions useful in computational chemistry scripting.\n\nMany of the following functions are used to make operations on xyz coordinates\nof molecular structure. When refering to ``xyz_data`` bellow, the following\nstructures (also used in :py:mod:`~comp_chem_utils.molecule_data`) is assumed::\n\n    atom 1 label  and corresponding xyz coordinate\n    atom 2 label  and corresponding xyz coordinate\n    : : :\n    atom N label  and corresponding xyz coordinate\n\nFor example the ``xyz_data`` of a Hydrogen molecule along the z-axis\nshould be passed as::\n\n    >>> xyz_data\n    [['H', 0.0, 0.0, 0.0], ['H', 0.0, 0.0, 1.0]]\n\n\"\"\"\n\n__author__=\"<NAME>\"\n__email__=\"<EMAIL>\"\n\n\nimport os\nimport shutil\nimport numpy as np\nfrom scipy.spatial.distance import pdist\n\nfrom comp_chem_utils.periodic import element\n\n\ndef vel_auto_corr(vel, max_corr_index, tstep):\n    \"\"\"Calculate velocity autocorrelation function.\n\n    Args:\n        vel (list): The velocities along the trajectory are given as\n            a list of ``np.array()`` of dimensions N_atoms . 3.\n\n        max_corr_index (int): Maximum number of steps to consider\n            for the auto correlation function. In other words, it\n            corresponds to the number of points in the output function.\n    \"\"\"\n\n    max_step_index = len(vel) - max_corr_index\n    natoms = vel[0].shape[0]\n\n    G = np.zeros((max_corr_index), dtype='float64')\n\n\n    for itau in range(max_corr_index):\n        for it in range(max_step_index):\n            #for i in range(natoms):\n            #    G[itau] += np.dot(vel[it][i,:], vel[it+itau][i,:])\n\n            G[itau] += np.trace(np.dot(vel[it],np.transpose(vel[it+itau])))\n\n    G = G \/ (natoms * max_corr_index * tstep)\n    xpts = np.arange(max_corr_index)\n    xpts = xpts * tstep\n\n    return xpts, G\n\n\ndef get_lmax_from_atomic_charge(charge):\n    \"\"\"Return the maximum angular momentum based on the input atomic charge.\n\n    This function is designed to return LMAX in a CPMD input file.\n\n    Args:\n        charge (int): Atomic charge.\n\n    Returns:\n        'S' for H or He; 'P' for second row elements; and 'D' for heavier elements.\n    \"\"\"\n\n    if charge <= 2:\n        # H or He\n        lmax = 'S'\n    elif charge <= 10:\n        lmax = 'P'\n    else:\n        lmax = 'D'\n\n    return lmax\n\n\ndef get_file_as_list(filename, raw=False):\n    \"\"\"Read a file and return it as a list of lines (str).\n\n    By default comments (i.e. lines starting with #)\n    and empty lines are ommited. This can be changed\n    by setting ``raw=True``\n\n    Args:\n        filename (str): Name of the file to read.\n        raw (bool, optional): To return the file as it is,\n            i.e. with comments and blank lines. Default\n            is ``raw=False``.\n\n    Returns:\n        A list of lines (str).\"\"\"\n\n    lines = []\n    with open(filename,'r') as myfile:\n        for line in myfile:\n            if raw:\n                lines.append(line)\n            else:\n                # remove empty lines\n                if line.strip():\n                    # remove comments\n                    if line.strip()[0] != '#':\n                        lines.append(line)\n\n    return lines\n\n\ndef make_new_dir(dirn):\n    \"\"\"Make new empty directory.\n\n    If the directory already exists it is erased and replaced.\n\n    Args:\n        dirn (str): Name for the new directory (can include path).\n    \"\"\"\n\n    if not os.path.exists(dirn):\n        os.makedirs(dirn)\n    else:\n        try:\n            os.removedirs(dirn)\n        except(OSError):\n            print(\"WARNING: erasing (not empty) directory! {}\".format(dirn))\n            shutil.rmtree(dirn)\n\n        os.makedirs(dirn)\n\n\ndef center_of_mass(xyz_data):\n    \"\"\"Calculate center of mass of a molecular structure based on xyz coordinates.\n\n    Args:\n        xyz_data (list): xyz atomic coordinates arranged as described above.\n\n    Returns:\n        3-dimensional ``np.array()`` containing the xyz coordinates of the\n        center of mass of the molecular structure. The unit of the center of mass\n        matches the xyz input units (usually Angstroms).\n    \"\"\"\n\n    totM = 0.0\n    COM = np.zeros((3))\n    for line in xyz_data:\n        symbol = line[0]\n        coord = np.array(line[1:])\n\n        mass = element(symbol).mass\n        totM += mass\n        COM += coord*mass\n\n    COM = COM\/totM\n    return COM\n\n\ndef change_vector_norm(fix, mob, R):\n    \"\"\"Scale a 3-D vector defined by two points in space to have a new norm R.\n\n    The input vector is defined by a fix position in 3-D space ``fix``,\n    and a mobile position ``mob``. The function returns a new mobile\n    position such that the new vector has the norm R.\n\n    Args:\n        fix (np.array): xyz coordinates of the fix point.\n        mob (np.array): Original xyz coordinates of the mobile point.\n        R (float): Desired norm for the new vector.\n\n    Returns:\n        The new mobile position as an ``np.array()`` of dimenssion 3.\n    \"\"\"\n\n    unit = mob - fix\n    unit = unit\/np.linalg.norm(unit)\n\n    # return new position\n    return fix + R * unit\n\n\ndef change_vector_norm_sym(pos1, pos2, R):\n    \"\"\"Symmetric version of change_vector_norm function.\n\n    In other word both positions are modified symmetrically.\n    \"\"\"\n\n    unit = pos2 - pos1\n    norm = np.linalg.norm(unit)\n    unit = unit\/norm\n\n    shift = (R-norm)\/2.0\n\n    # return new position\n    new_pos1 = pos1 - unit * shift\n    new_pos2 = pos2 + unit * shift\n    return new_pos1, new_pos2\n\n\ndef get_rmsd(xyz_data1, xyz_data2):\n    \"\"\"Calculate RMSD between two sets of coordinates.\n\n    The Root-mean-square deviation of atomic positions is calculated as\n\n    .. math::\n        RMSD = \\\\sqrt{ \\\\frac{1}{N} \\\\sum_{i=1}^N \\\\delta_{i}^{2} }\n\n    Where ``\\delta_i`` is the distance between atom i in ``xyz_data1`` and in\n    ``xyz_data2``.\n\n    Args:\n        xyz_data1 (list): List of atomic coordinates for the first structure\n            arranged as described above for xyz_data.\n        xyz_data2 (list): Like ``xyz_data1`` but for the second structure.\n\n    Returns:\n        The RMSD (float).\n    \"\"\"\n\n    rmsd = 0\n    for c1, c2 in zip(xyz_data1, xyz_data2):\n\n        d1 = np.array([c1[x] for x in range(1,4)])\n        d2 = np.array([c2[x] for x in range(1,4)])\n        vector = d2 - d1\n        rmsd += np.dot(vector, vector)\n\n    rmsd = rmsd\/(len(xyz_data1))\n    return np.sqrt(rmsd)\n\n\ndef get_distance(xyz_data, atoms, box_size=None):\n    \"\"\"Calculate distance between two atoms in xyz_data.\n\n    Args:\n        xyz_data (list): xyz atomic coordinates arranged as described above.\n        atoms (list): list of two indices matching the two rows of the\n            xyz_data for wich the distance should be calculated.\n\n    Returns:\n        Distance between the two atoms in the list as a ``float``, the\n        unit will match the input unit in the ``xyz_data``.\n\n    \"\"\"\n    coord1 = np.array([xyz_data[atoms[0]][x] for x in range(1,4)])\n    coord2 = np.array([xyz_data[atoms[1]][x] for x in range(1,4)])\n    vector = coord2 - coord1\n\n    if box_size:\n       for i,x in enumerate(vector):\n          if abs(x) > box_size\/2.0:\n             vector[i] = box_size - abs(x)\n\n    return np.linalg.norm(vector)\n\n\ndef get_distance_matrix(xyz_data, box_size=None):\n\n   # make np.array\n   natoms = len(xyz_data)\n   coord = np.zeros((natoms,3), dtype='float')\n   for i,line in enumerate(xyz_data):\n      coord[i,:] = line[1:]\n\n   if box_size:\n      npairs = natoms * (natoms - 1)\n      matrix = np.zeros((npairs,3), dtype='float')\n\n      for i in range(natoms):\n         for j in range(i+1,natoms):\n            ij = i + (j-1)*natoms\n\n            matrix[ij,:] = coord[i,:] - coord[j,:]\n\n      # find out which element to shift:\n      # basically shift is an array of same shape as matrix\n      # with zeros every where except where the elements of\n      # matrix are larger than box_size\/2.0\n      # in that case shift as the value box_size\n      shift = box_size * (matrix > box_size\/2.0).astype(int)\n\n      # we can now shift the matrix as follows:\n      matrix = abs(shift - matrix)\n\n      # and get the distances...\n      matrix = np.linalg.norm(matrix, axis=1)\n\n   else:\n      matrix = pdist(coord)\n\n   return matrix\n\ndef get_distance_matrix_2(xyz_data1, xyz_data2, box_size=None):\n   # repeat as above for 2 different sets of coordinates\n   nat1 = len(xyz_data1)\n   coord1 = np.zeros((nat1,3), dtype='float')\n   for i,line in enumerate(xyz_data1):\n      coord1[i,:] = line[1:]\n\n   nat2 = len(xyz_data2)\n   coord2 = np.zeros((nat2,3), dtype='float')\n   for i,line in enumerate(xyz_data2):\n      coord2[i,:] = line[1:]\n\n   if box_size:\n      matrix = np.zeros((nat1,nat2,3), dtype='float')\n\n      for i in range(nat1):\n         for j in range(nat2):\n            matrix[i,j,:] = coord[i,:] - coord[j,:]\n\n      # find out which element to shift:\n      # basically shift is an array of same shape as matrix\n      # with zeros every where except where the elements of\n      # matrix are larger than box_size\/2.0\n      # in that case shift as the value box_size\n      shift = box_size * (matrix > box_size\/2.0).astype(int)\n\n      # we can now shift the matrix as follows:\n      matrix = abs(shift - matrix)\n\n      # and get the distances...\n      matrix = np.linalg.norm(matrix, axis=2)\n\n   else:\n      matrix = cdist(coord1, coord2)\n\n   return matrix\n\ndef get_angle(xyz_data, atoms):\n    \"\"\"Calculate angle between three atoms in xyz_data.\n\n    Args:\n        xyz_data (list): xyz atomic coordinates arranged as described above.\n        atoms (list): list of three indices matching the rows of the\n            xyz_data for wich the angle should be calculated.\n\n    Returns:\n        Angle between the three atoms in the list as a ``float`` in degrees.\n\n    \"\"\"\n\n    coord1 = np.array([xyz_data[atoms[0]][x] for x in range(1,4)])\n    coord2 = np.array([xyz_data[atoms[1]][x] for x in range(1,4)])\n    coord3 = np.array([xyz_data[atoms[2]][x] for x in range(1,4)])\n    vec1 = coord1-coord2\n    vec2 = coord3-coord2\n\n    return np.degrees( np.arccos( np.dot(vec1,vec2) \/ (np.linalg.norm(vec1) * np.linalg.norm(vec2)) ) )\n\ndef get_dihedral_angle(table, atoms):\n    \"\"\"Calculate dihedral angle defined by 4 atoms in xyz_data.\n\n    It relies on the praxeolitic formula (1 sqrt, 1 cross product).\n\n    Args:\n        xyz_data (list): xyz atomic coordinates arranged as described above.\n        atoms (list): list of 4 indices matching the rows of the\n            xyz_data for wich the dihedral angle should be calculated.\n\n    Returns:\n        Dihedral angle defined by the 4 atoms in the list as a ``float`` in degrees.\n\n    \"\"\"\n\n    p0 = np.array([table[atoms[0]][x] for x in range(1,4)])\n    p1 = np.array([table[atoms[1]][x] for x in range(1,4)])\n    p2 = np.array([table[atoms[2]][x] for x in range(1,4)])\n    p3 = np.array([table[atoms[3]][x] for x in range(1,4)])\n\n    b0 = -1.0*(p1 - p0)\n    b1 = p2 - p1\n    b2 = p3 - p2\n\n    # normalize b1 so that it does not influence magnitude of vector\n    # rejections that come next\n    b1 \/= np.linalg.norm(b1)\n\n    # vector rejections\n    # v = projection of b0 onto plane perpendicular to b1\n    #   = b0 minus component that aligns with b1\n    # w = projection of b2 onto plane perpendicular to b1\n    #   = b2 minus component that aligns with b1\n    v = b0 - np.dot(b0, b1)*b1\n    w = b2 - np.dot(b2, b1)*b1\n\n    # angle between v and w in a plane is the torsion angle\n    # v and w may not be normalized but that's fine since tan is y\/x\n    x = np.dot(v, w)\n    y = np.dot(np.cross(b1, v), w)\n\n    return np.degrees(np.arctan2(y, x))\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_680","text":"<filename>growspace\/envs\/spotlight.py<gh_stars>10-100\nimport os\nimport random\nimport sys\nfrom enum import IntEnum\nfrom random import sample\n\nimport cv2\nimport gym\nimport numpy as np\nimport tqdm\nfrom numpy.linalg import norm\nfrom scipy.spatial import distance\nimport random\nimport torchvision\nfrom torchvision import datasets\nimport growspace.plants.tree\n\nnp.set_printoptions(threshold=sys.maxsize)\n# customizable variables by user\n\nBRANCH_THICCNESS = .036 # before was 0.036 in 28 x 28 and .015 in 28 x 28\nMAX_BRANCHING = 10\nDEFAULT_RES = 28\nLIGHT_WIDTH = 0.25\nLIGHT_DIF = 200\nLIGHT_DISPLACEMENT = 0.1\nLIGHT_W_INCREMENT = 0.1\nMIN_LIGHT_WIDTH = 0.1\nMAX_LIGHT_WIDTH = 0.5\n\nBRANCH_LENGTH = (1 \/ 9) * DEFAULT_RES\n\ndef to_int(v):\n    return int(round(v))\n\n\nir = to_int  # shortcut for function calld\n\nFIRST_BRANCH_HEIGHT = ir(0.1 * DEFAULT_RES)\n\n\ndef unpack(w):\n    return map(list, zip(*enumerate(w)))\n\ndef load_mnist(digit):\n    mnist_dataset = datasets.MNIST('.\/data', train=True, download=True)\n    if digit == 'partymix':\n        return mnist_dataset\n    if digit == 'curriculum':\n        return mnist_dataset\n    else:\n        return idx_digit(mnist_dataset,digit)\n\ndef idx_digit(mnist_dataset, digit):\n    idx = mnist_dataset.train_labels == int(digit) #and mnist_dataset.train_labels  == 6  # digit comes as string\n    mnist_digit = mnist_dataset.train_data[idx]\n\n    return mnist_digit\n\ndef sample_digit(digit_set):\n    digit_set = digit_set.data.numpy()\n    digit = np.random.randint(len(digit_set)-1)\n    im1 = np.zeros((28, 28), dtype=np.uint8)\n    im2 = np.zeros((28, 28), dtype=np.uint8)\n    im3 = np.zeros((28, 28, 3), dtype=np.uint8)\n    number = np.where(digit_set[digit] == 0, im2, 1 * 255)\n    img = np.dstack((im1,im2, number))\n    A = np.array((im3, img))\n    final_img = np.float32(np.sum(A, axis=0))\n\n    return final_img\n\ndef stage_curriculum(episode, mnist_dataset):\n    _0 = idx_digit(mnist_dataset, 0)\n    _1 = idx_digit(mnist_dataset, 1)\n    _2 = idx_digit(mnist_dataset, 2)\n    _3 = idx_digit(mnist_dataset, 3)\n    _4 = idx_digit(mnist_dataset, 4)\n    _5 = idx_digit(mnist_dataset, 5)\n    _6 = idx_digit(mnist_dataset, 6)\n    _7 = idx_digit(mnist_dataset, 7)\n    _8 = idx_digit(mnist_dataset, 8)\n    _9 = idx_digit(mnist_dataset, 9)\n    curriculum = []\n    if episode < 500:\n        curriculum.append(_3)\n        curriculum.append(_6)\n\n        if episode == 1:\n            print('check1')\n\n    if 500 <= episode < 1000:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        if episode == 500:\n             print('check2')\n\n    if 1000 <= episode < 1500:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n\n        if episode == 1000:\n            print('check3')\n\n    if 1500 <= episode < 2500:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n        curriculum.append(_4)\n\n        if self.episode == 1500:\n            print('check4')\n\n    if 2500 <= episode < 3500:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n        curriculum.append(_4)\n        curriculum.append(_5)\n\n        if self.episode == 2500:\n            print('check5')\n\n    if 3500 <= episode < 5000:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n        curriculum.append(_4)\n        curriculum.append(_5)\n        curriculum.append(_7)\n\n        if self.episode == 3500:\n            print('check6')\n\n    if 5000 <= episode < 6500:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n        curriculum.append(_4)\n        curriculum.append(_5)\n        curriculum.append(_7)\n        curriculum.append(_8)\n\n        if episode == 5000:\n            print('check7')\n\n    if 6500 <= episode < 10000:\n        curriculum.append(_3)\n        curriculum.append(_6)\n        curriculum.append(_2)\n        curriculum.append(_1)\n        curriculum.append(_4)\n        curriculum.append(_5)\n        curriculum.append(_7)\n        curriculum.append(_8)\n        curriculum.append(_0)\n        curriculum.append(_9)\n\n    idx = len(curriculum)\n    id = np.random.randint(idx)\n    x = sample_digit(curriculum[id])\n    return x\n\nclass Features(IntEnum):\n    light = 0\n    scatter = 1\n\n\nclass GrowSpaceEnvSpotlightMnist(gym.Env):\n    metadata = {'render.modes': ['human', 'rgb_array']}  # Required, otherwise gym.Monitor disables itself.\n\n    def __init__(self, width=DEFAULT_RES, height=DEFAULT_RES, digit='curriculum'):\n        self.width = width\n        self.height = height\n        self.seed()\n        self.action_space = gym.spaces.Discrete(5)  # L, R, keep of light paddle, or increase, decrease\n        self.feature_maps = np.zeros((len(Features), self.height, self.width), dtype=np.uint8)\n\n        self.observation_space = gym.spaces.Box(0, 255, shape=(self.height, self.width, 3), dtype=np.uint8)\n        self.digit = digit\n        self.mnist_digit = load_mnist(self.digit)\n\n        self.focus_point = None\n        self.focus_radius = None\n\n        self.branches = None\n        self.target = None\n        self.steps = None\n        self.new_branches = None\n        self.tips_per_step = None\n        self.tips = None\n        self.episode = -1\n\n    def render(self, mode='human', debug_show_scatter=False):\n        \"\"\"\n        @mode: ['mode', 'rgb_array']\n\n        \"\"\"\n        img = self.get_observation(debug_show_scatter)\n        #dsize = (84,84)\n        #img = cv2.resize(img, dsize)\n        # if self.obs_type == 'Binary':\n        #     image = img.astype(np.uint8)\n        #     img = image * 255\n\n        if mode == \"human\":\n            cv2.imshow('plant', img)  # create opencv window to show plant\n            cv2.waitKey(1)  # this is necessary or the window closes immediately\n        else:\n            return img\n\n\n    def seed(self, seed=None):\n        return [np.random.seed(seed)]\n\n    def light_scatter(self):\n        filter_ = np.logical_and(self.feature_maps[Features.light], self.feature_maps[Features.scatter])\n        return np.argwhere(filter_)\n\n    def tree_grow(self, activated_photons, mindist, maxdist):\n        branches_trimmed = self.branches\n        # number of possible scatters, check if they allow for branching with min_dist\n        for i in range(len(activated_photons) - 1, 0, -1):\n            closest_branch = 0\n            dist = 1 * self.width\n\n            if len(self.branches) > MAX_BRANCHING:\n                branches_trimmed = sample(self.branches, MAX_BRANCHING)\n            else:\n                branches_trimmed = self.branches\n\n            for branch in branches_trimmed:\n                photon_ptx = np.flip(activated_photons[i])  # flip was necessary bc coordinate systems are inverted -\n                tip_to_scatter = norm(photon_ptx - np.array(branch.tip_point))  # one is np.array, one is tuple\n                if tip_to_scatter < dist:\n                    dist = tip_to_scatter\n                    closest_branch = branch\n\n            # removes scatter points if reached\n\n            if dist < mindist:\n                activated_photons = np.delete(activated_photons, i)\n\n            # when distance is greater than max distance, branching occurs to find other points.\n            elif dist < maxdist:\n                closest_branch.grow_count += 1\n                branch_length = BRANCH_LENGTH \/ dist\n                photon = np.flip(activated_photons[i])\n                g = (photon - closest_branch.tip_point) * branch_length\n                closest_branch.grow_direction += np.round(g).astype(np.int)\n\n        for branch in branches_trimmed:\n            if branch.grow_count > 0:\n                (x2, y2) = branch.tip_point + branch.grow_direction \/ branch.grow_count\n                x2 = np.clip(x2, 0, self.width - 1)\n                y2 = np.clip(y2, 0, self.height - 1)\n\n                newBranch = growspace.plants.tree.PixelBranch(\n                    branch.x2, ir(x2), branch.y2, ir(y2), self.width, self.height\n                )\n                self.branches.append(newBranch)\n                branch.child.append(newBranch)\n                branch.grow_count = 0\n                branch.grow_direction.fill(0)\n\n        # increase thickness of first elements added to tree as they grow\n\n        self.branches[0].update_width()\n\n        branch_coords = []\n\n        # sending coordinates out\n        for branch in self.branches:\n            branch_coords.append(branch.tip_point)\n\n        self.tips = branch_coords\n        return branch_coords\n\n    def get_observation(self, debug_show_scatter=False):\n        img = np.zeros((self.height, self.width, 3), dtype=np.uint8)\n\n        yellow = (0, 128, 128)  # RGB color (dark yellow)\n\n        img[self.feature_maps[Features.light].nonzero()] = yellow\n        cv2.circle(img, tuple(self.to_image(self.focus_point)), int(self.focus_radius * self.height), (0, 128, 128), thickness=2) # only contour\n\n        if debug_show_scatter:\n            pts = self.light_scatter()\n            for p in pts:\n                x, y = p\n                cv2.circle(img, center=(y, x), radius=2, color=(255, 0, 0), thickness=-1)\n\n        # Draw plant as series of lines (1 branch = 1 line)\n        for branch in self.branches:\n            thiccness = ir(branch.width * BRANCH_THICCNESS * self.width)\n            cv2.line(img, pt1=branch.p, pt2=branch.tip_point, color=(0, 255, 0), thickness=thiccness)\n\n        img = cv2.flip(img,0)\n        z = np.where(self.mnist_shape < 255, img, 150)\n\n        return z\n\n    def reset(self):\n        random_start = random.randint(self.width - (self.width*3\/4), self.width - 1 - (self.width*1\/4))\n        self.branches = [\n            growspace.plants.tree.PixelBranch(\n                x=random_start,\n                x2=random_start,\n                y=0,\n                y2=FIRST_BRANCH_HEIGHT,\n                img_width=self.width,\n                img_height=self.height,\n            )\n        ]\n\n        self.episode += 1\n        if self.digit == 'curriculum':\n            self.mnist_shape = stage_curriculum(self.episode,self.mnist_digit)\n\n        else:\n            self.mnist_shape = sample_digit(self.mnist_digit)\n\n        self.focus_point = np.array([random_start \/ self.width, FIRST_BRANCH_HEIGHT \/ self.height])\n        self.focus_radius = 0.1\n\n        x_scatter = np.random.randint(0, self.width, LIGHT_DIF)\n        y_scatter = np.random.randint(0, self.height, LIGHT_DIF)\n        self.feature_maps[Features.scatter].fill(False)\n\n        self.feature_maps[Features.scatter][y_scatter, x_scatter] = True\n\n        self.steps = 0\n        self.new_branches = 0\n        self.tips_per_step = 0\n        self.tips = [\n            self.branches[0].tip_point,\n        ]\n\n        self.draw_spotlight()\n\n        self.mnist_pixels = (self.get_observation()[:, :, 2] \/ 150)  # binary map of mnist shape\n\n        plant_stem = (self.get_observation()[:, :, 1] \/ 255)\n        plant_stem[plant_stem>0.6] =1              # filter for green\n        self.plant_original = plant_stem.astype(int)\n\n\n        return self.get_observation()\n\n    def step(self, action):\n        if action == 0:\n            self.focus_radius = min(0.2, self.focus_radius + 0.05)\n\n        if action == 1:\n            self.focus_radius = max(0.03, self.focus_radius - 0.05)\n\n        if action == 2:\n            self.focus_point[0] = max(0, self.focus_point[0] - 0.1)\n\n        if action == 3:\n            self.focus_point[0] = min(1, self.focus_point[0] + 0.1)\n\n        if action == 4:\n            self.focus_point[1] = min(1, self.focus_point[1] + 0.1)\n\n        if action == 5:\n            self.focus_point[1] = max(0, self.focus_point[1] - 0.1)\n\n        if action == 6:\n            pass\n        #self.draw_spotlight()\n\n        pts = self.light_scatter()\n        tips = self.tree_grow(pts, 0.01 * self.width, 0.15 * self.width)\n        self.draw_spotlight()\n        observation = self.get_observation()  #image\n\n        plant = (observation[:,:,1]\/255) # binary map of plant\n        pixel_plant = np.sum(plant)\n\n        plant[plant>0.6] =1              # filter for green\n        plant = plant.astype(int)\n        true_plant = np.subtract(plant,self.plant_original)\n\n\n        mnist = (observation[:,:,2]\/150)     # binary map of mnist\n\n        mnist[mnist>0.5] =1\n        mnist = mnist.astype(int)\n\n        check = np.sum((true_plant, mnist), axis=0)\n        intersection = np.sum(np.where(check < 2, 0, 1))\n\n        union = np.sum(np.where(check<2,check,1))\n\n        reward = intersection \/ union\n\n        print('reqward',reward)\n\n\n        done = False  # because we don't have a terminal condition\n        misc = {\"tips\": tips, \"target\": self.target, \"light\": None}\n\n        if self.steps == 0:\n            self.new_branches = len(tips)\n            misc[\"new_branches\"] = self.new_branches\n\n        else:\n            new_branches = len(tips) - self.new_branches\n            misc[\"new_branches\"] = new_branches\n            self.new_branches = len(tips)  # reset for future step\n\n        misc[\"img\"] = observation\n        misc[\"plant_pixel\"] = pixel_plant\n        self.steps += 1\n        return observation, float(reward), done, misc\n\n    def draw_spotlight(self):\n        self.feature_maps[Features.light].fill(False)\n        cv2.circle(\n            self.feature_maps[Features.light],\n            tuple(self.to_image(self.focus_point)),\n            int(self.focus_radius * self.height),\n            True,\n            thickness=-1,\n\n        )\n\n    def to_image(self, p):\n        if hasattr(p, \"normalized_array\"):\n            return np.around((self.height, self.width) * p.normalized_array[:-1]).astype(np.int32)\n        else:\n            y, x = p\n            return np.around((self.height * y, self.width * x)).astype(np.int32)\n\n\ndef enjoy():\n    #gse = gym.make(\"GrowSpaceSpotlight-Mnist1-v0\")\n    gse = GrowSpaceEnvSpotlightMnist()\n\n    def key2action(key):\n        if key == ord(\"+\"):\n            return 0  # move left\n        elif key == ord(\"-\"):\n            return 1  # move right\n        elif key == ord(\"a\"):\n            return 2\n        elif key == ord(\"d\"):\n            return 3\n        elif key == ord(\"w\"):\n            return 4\n        elif key == ord(\"s\"):\n            return 5\n        elif key == ord(\"x\"):\n            return 6\n        else:\n            return None\n\n    while True:\n        gse.reset()\n        img = gse.get_observation(debug_show_scatter=False)\n        cv2.imshow(\"plant\", img)\n        cv2.waitKey(-1)\n        rewards = []\n        for _ in range(50):\n            action = key2action(cv2.waitKey(-1))\n            if action is None:\n                quit()\n\n            b, t, c, f = gse.step(action)\n            print(f[\"new_branches\"])\n            rewards.append(t)\n            cv2.imshow(\"plant\", gse.get_observation(debug_show_scatter=False))\n        total = sum(rewards)\n\n        print(\"amount of rewards:\", total)  # cv2.waitKey(1)  # this is necessary or the window closes immediately\n        # else:\n        # dreturn img\n\n\ndef profile():\n    #gse = gym.make(\"GrowSpaceSpotlight-Mnist1-v0\")\n    gse = GrowSpaceEnvSpotlightMnist()\n    gse.reset()\n\n    def do_step():\n        a = gse.action_space.sample()\n        s, r, d, i = gse.step(a)\n        if d:\n            gse.reset()\n\n    for _ in tqdm.trange(100000):\n        do_step()\n    print(\"hi\")\n\n\nif __name__ == \"__main__\":\n    # import matplotlib.pyplot as plt\n    #\n    # env = GrowSpaceEnvSpotlightMnist()\n    # env.reset()\n    # fig, axs = plt.subplots(1, 2)\n    # axs[0].imshow(env.feature_maps[Features.light])\n    # axs[1].imshow(env.feature_maps[Features.scatter])\n    # plt.show()\n    #\n    # env.draw_spotlight()\n    # pts = env.light_scatter()\n    # print(pts.shape)\n    # fig, axs = plt.subplots(1, 2)\n    # axs[0].imshow(env.feature_maps[Features.light])\n    # img = np.zeros((71, 71), dtype=np.float)\n    # img[pts[:, 0], pts[:, 1]] = True\n    # axs[1].imshow(img)\n    # plt.show()\n\n    enjoy()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_681","text":"import warnings\nimport numpy as np\nimport pandas as pd\nimport scipy.stats as st\nimport statsmodels as sm\nimport matplotlib\nimport matplotlib.pyplot as plt\n\n\nimport numpy as np\nfrom statsmodels.base.model import GenericLikelihoodModel\n\nfrom scipy.stats import gamma\nshape = 12; loc = 0.71; scale = 0.0166\ndata = record[\"peaks\"]\nparams = gamma.fit(data) # params close to but not the same as (shape, loc, scale)\n# HOW TO ESTIMATE\/GET ERRORS FOR EACH PARAM?\n\nprint(params)\nprint('\\n')\n\n\nclass Gamma(GenericLikelihoodModel):\n\n    nparams = 3\n\n    def loglike(self, params):\n        return gamma.logpdf(self.endog, *params).sum()\n\n\nres = Gamma(data).fit(start_params=params)\nres.df_model = len(params)\nres.df_resid = len(data) - len(params)\nprint(res.summary())"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_673","text":"\"\"\"\n    Common processing functions for grayscale images: (x, y), where x,y in range (0,255)\n\"\"\"\n\ndef _memoryview_safe(x):\n    \"\"\"Make array safe to run in a Cython memoryview-based kernel. These\n    kernels typically break down with the error ``ValueError: buffer source\n    array is read-only`` when running in dask distributed.\n    SEE: https:\/\/github.com\/dask\/distributed\/issues\/1978\n    \"\"\"\n    if not x.flags.writeable:\n        if not x.flags.owndata:\n            x = x.copy(order='C')\n        x.setflags(write=True)\n    return x\n\n\ndef local_contrast(im_array, box_size, DEBUG = False):\n    \"\"\" REF: https:\/\/scikit-image.org\/docs\/dev\/auto_examples\/color_exposure\/plot_local_equalize.html\n    \"\"\"\n    try:\n        from skimage.filters import rank\n        from skimage.morphology import disk\n    except:\n        print(\" ERROR :: scikit-image not installed, try:\")\n        print(\"     pip install scikit-image\")\n        return\n\n    ## ensure the input array is writable \n    im_array = _memoryview_safe(im_array)\n\n    footprint = disk(box_size * 2)\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: local_contrast\")\n        print(\"---------------------------------------\")\n        print(\"  input img dim = \", im_array.shape)\n        print(\"  box_size = %s px\" % box_size)\n        print(\"  local contrast footprint = \", footprint.shape)\n        print(\"=======================================\")\n    im = rank.equalize(im_array, footprint)\n    return im\n\ndef auto_contrast(im_array, DEBUG = True):\n    \"\"\" Rescale the image intensity levels to a reasonable range using the top\/bottom 2 percent\n        of the data to define the intensity levels\n    \"\"\"\n    import numpy as np\n    ## avoid hotspot pixels by looking at a group of pixels at the extreme ends of the image\n    minval = np.percentile(im_array, 2)\n    maxval = np.percentile(im_array, 98)\n\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: auto_contrast\")\n        print(\"---------------------------------------\")\n        print(\"  input img dim = \", im_array.shape)\n        print(\"  original img min, max = (%s, %s)\" % (np.min(im_array), np.max(im_array)))\n        print(\"  stretch to new min, max = (%s %s)\" % (minval, maxval))\n        print(\"=======================================\")\n\n    ## remove pixles above\/below the defined limits\n    im_array = np.clip(im_array, minval, maxval)\n    ## rescale the image into the range 0 - 255\n    im_array = ((im_array - minval) \/ (maxval - minval)) * 255\n\n    return im_array\n\ndef sigma_contrast(im_array, sigma, DEBUG = True):\n    \"\"\" Rescale the image intensity levels to a range defined by a sigma value (the # of\n        standard deviations to keep). Can perform better than auto_contrast when there is\n        a lot of dark pixels throwing off the level balancing.\n    \"\"\"\n    import numpy as np\n    stdev = np.std(im_array)\n    mean = np.mean(im_array)\n    minval = mean - (stdev * sigma)\n    maxval = mean + (stdev * sigma)\n\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: sigma_contrast\")\n        print(\"---------------------------------------\")\n        print(\"  input img dim = \", im_array.shape)\n        print(\"  img mean, stdev = (%s, %s)\" % (mean, stdev))\n        print(\"  stretch to new min, max = (%s %s)\" % (minval, maxval))\n        print(\"=======================================\")\n\n    ## remove pixles above\/below the defined limits\n    im_array = np.clip(im_array, minval, maxval)\n    ## rescale the image into the range 0 - 255\n    im_array = ((im_array - minval) \/ (maxval - minval)) * 255\n\n    return im_array\n\ndef whiten_outliers(im_array, min, max):\n    \"\"\" Set any pixels outside of a defined intensity range to 255 (white)\n    \"\"\"\n    import numpy as np\n    ## use the input mean\/max to clip the image before increasing contrast\n    im_array = np.where(im_array < min, 255, im_array)\n    im_array = np.where(im_array > max, 255, im_array)\n    return im_array\n\ndef extract_boxes(im_array, box_size, coords, DEBUG = True):\n    \"\"\"\n    PARAMETERS\n        im_array = np array (0 - 255)\n        box_size = int(); pixel size of the box to extract\n        coords = list( tuple(x, y), ... ); centered coordinates in pixels (top left == 0,0 by convention)\n    RETURNS\n        extracted_imgs = list( np arrays of dimension box_size , ... )\n    \"\"\"\n    extracted_imgs = []\n    ## sanity check that not too many coordinates are being asked to be extracted\n    if len(coords) > 500:\n        print(\" ERROR :: extracted_boxes is capped at 500 coordinates to avoid memory issues, remove some and re-run\")\n        return extracted_imgs\n\n    box_size_halfwidth = int( box_size \/ 2)\n\n    for coordinate in coords:\n        x0 = coordinate[0] - box_size_halfwidth\n        y0 = coordinate[1] - box_size_halfwidth\n        x1 = coordinate[0] + box_size_halfwidth\n        y1 = coordinate[1] + box_size_halfwidth\n\n        extracted_img = im_array[y0:y1,x0:x1]\n        extracted_imgs.append(extracted_img)\n\n    if DEBUG:\n        print(\" Extracted %s boxes from image\" % len(extracted_imgs))\n\n    return extracted_imgs\n\ndef find_intensity_range(im_arrays, DEBUG = True):\n    \"\"\"\n        im_arrays = list( 2d numpy arrays, ...)\n\n    RETURNS:\n        min = int()\n        max = int()\n    \"\"\"\n    import numpy as np\n    import statistics\n    mins = []\n    maxs = []\n    ## get the min\/max value for each image we are loading\n    for im_array in im_arrays:\n        mins.append(np.min(im_array))\n        maxs.append(np.max(im_array))\n    ## get the mean value for the min\/maxes\n    min = int(statistics.mean(mins))\n    max = int(statistics.mean(maxs))\n    if DEBUG:\n        print(\" find_intensity_range :: %s imgs\" % len(im_arrays))\n        print(\"    ... (min, max) = (%s, %s)\" % (min, max))\n    return (min, max)\n\ndef gaussian_blur(im_array, sigma, DEBUG = True):\n    import scipy.ndimage as ndimage\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: gaussian_blur\")\n        print(\"---------------------------------------\")\n        print(\"  input img dim = \", im_array.shape)\n        print(\"  sigma = \", sigma)\n        print(\"=======================================\")\n\n    blurred_img = ndimage.gaussian_filter(im_array, sigma)\n    return blurred_img\n\ndef image2array(file, DEBUG = True):\n    \"\"\"\n        Import an image into a grayscal 2d numpy array with values from (0 - 255), where\n            0 == black\n            255 == white\n    \"\"\"\n    from PIL import Image as PIL_Image\n    import numpy as np\n\n    im = PIL_Image.open(file).convert('L') # 'L' == convert to grayscale data\n    # convert image to numpy array\n    im_data = np.asarray(im)\n\n    if DEBUG:\n        print(\"===================================================\")\n        print(\" IMPORT IMAGE :: %s\" % file)\n        print(\"===================================================\")\n        print(\"   >> %s px, min = %s, max = %s\" % (im_data.shape, np.min(im_data), np.max(im_data)))\n\n    return im_data\n\ndef display_img(im_array, coords = None, box_size = 1):\n    \"\"\"\n        box_size = int(); pixel size of the particle\n    \"\"\"\n    from PIL import Image as PIL_Image\n    from PIL import ImageTk\n\n    box_size_halfwidth = int( box_size \/ 2 )\n\n    root = Tk()\n    canvas = Canvas(root, width = im_array.shape[0], height = im_array.shape[1])\n    canvas.pack()\n    img = PIL_Image.fromarray(im_array).convert('L')\n    img = ImageTk.PhotoImage(img)\n    canvas.create_image(0, 0, anchor=NW, image=img)\n\n    if coords is None:\n        pass\n    else:\n        for coordinate in coords:\n            # break\n            ## each coordinate is the center of a box, thus we need to offset by half the gif_box_width pixel length to get the bottom left and top right of the rectangle\n            x0 = coordinate[0] - box_size_halfwidth\n            y0 = coordinate[1] - box_size_halfwidth\n            x1 = coordinate[0] + box_size_halfwidth\n            y1 = coordinate[1] + box_size_halfwidth #y0 - img_box_size # invert direction of box to take into account x0,y0 are at bottom left, not top left\n            canvas.create_rectangle(x0, y0, x1, y1, outline='red', width=1, tags='particle_positions')\n\n    root.mainloop()\n\ndef gaussian_disk(size):\n    \"\"\" Creates a soft gaussian grayscale image of given pixel size with values in range 0 -- 255\n    \"\"\"\n    import numpy as np\n\n    size = int(size)\n    x, y = np.meshgrid(np.linspace(-1,1, size), np.linspace(-1,1, size))\n    d = np.sqrt(x*x+y*y)\n    sigma, mu = 0.4, 0.0\n    g = np.exp(-( (d-mu)**2 \/ ( 2.0 * sigma**2 ) ) )\n    ## invert color to we match to dark pixels\n    g = 1 - g\n\n    g = g * 255\n    return g\n\ndef template_cross_correlate(im_array, template, threshold, DEBUG = False):\n    \"\"\"\n    PARAMETERS\n        im_array = np array of grayscale img in range 0 - 255\n        template = np array of grayscale template img in range 0 - 255\n        threshold = int(); peak cutoff in range 0 - 1\n    RETURNS\n        cc = cross correlation image as a grayscale (0 - 255), note peaks represent positions aligned with top-right of template!\n    \"\"\"\n    import numpy as np\n    from scipy import signal\n\n    if DEBUG:\n        print(\"Template info: %s, min = %s, max %s\" % (template.shape, np.min(template), np.max(template)))\n    cc = signal.correlate2d(im_array, template, boundary='symm', mode='same')\n    ## determine the threshold at which to keep peaks\n    cc_min, cc_max = (np.min(cc), np.max(cc))\n    cc_range = cc_max - cc_min\n    cc_threshold_cutoff = cc_min + (threshold * cc_range)\n    print(\"cc min, max, range, threshold value = (%s, %s, %s, %s)\" % ( np.min(cc), np.max(cc), cc_range, cc_threshold_cutoff))\n    ## remove signal below peaks\n    cc = np.where(cc < cc_threshold_cutoff, 0, 255)\n    return cc\n\ndef bool_img(im_array, threshold, DEBUG = False):\n    \"\"\"\n        For a given threshold value (intensity, i.e. between 0 - 255), make any pixels below the\n        threshold equal to 255 (white) and any above 0 (black)\n    PARAMETERS\n        im_array = np array of a grayscale image (0 - 255)\n    RETURNS\n        im_array = np array as grayscale image (0 - 255)\n    \"\"\"\n    import numpy as np\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: bool_img\")\n        print(\"=======================================\")\n        print(\"  intensity cutoff = \", threshold)\n\n    im_array = np.where(im_array >= threshold, 255, 0)\n    return im_array\n\ndef find_local_peaks(im_array, min_area, max_area, INVERT = False, DEBUG = False):\n    \"\"\"\n    \"\"\"\n    try:\n        from skimage.measure import label, regionprops\n    except:\n        print(\" ERROR :: scikit-image not installed, try:\")\n        print(\"     pip install scikit-image\")\n        return\n    if DEBUG:\n        print(\"=======================================\")\n        print(\" image_handler :: find_local_peaks\")\n        print(\"=======================================\")\n        print(\"  input img dim = \", im_array.shape)\n        print(\"  min_area = %s px\" % min_area)\n        print(\"  max_area = %s px\" % max_area)\n\n\n    if INVERT:\n        if DEBUG:\n            print(\"  invert color scale for autopicking\")\n        im_array = 255 - im_array\n\n    labeled_img = label(im_array) #, connectivity = 2)\n    regions = regionprops(labeled_img)\n    coordinates = []\n\n    # min_area = int(box_size \/ 2) ## minimum # of pixels for a labeled feature to be added as a coordinate\n    # max_area = int(box_size * box_size * 1.5)\n    for props in regions:\n        area = getattr(props, 'area')\n        if area >= min_area:\n            if area <= max_area:\n                y0, x0 = props.centroid\n                coordinates.append((x0, y0))\n\n\n\n    if DEBUG:\n        print(\"  >> %s coordinates found!\" % len(coordinates))\n        print(\"=======================================\")\n\n    return coordinates\n\n\n\n#############################################\n##  RUN BLOCK\n#############################################\nif __name__ == \"__main__\":\n\n    import sys, os\n    from tkinter import *\n\n    ## allow functions of this script to be tested by supplying in an image on the commandline via:\n    ##      $ image_handler.py  <img name>\n    fname = sys.argv[1]\n\n    ## edit the functions that run in this block to test proper execution\n    im = image2array(fname)\n\n    ## box_size and some coordinates for img B1g1...Exp_10.jpg\n    coords = [(444,138), (452, 124), (466, 117)]\n    box_size = 17\n\n\n    im = local_contrast(im, box_size)\n    # im = sigma_contrast(im, 1.5)\n    # im = auto_contrast(im)\n\n    im = gaussian_blur(im, 1)\n\n    # extracted_imgs = extract_boxes(im, box_size, coords, DEBUG = True)\n    # min, max = find_intensity_range(extracted_imgs)\n    # im = whiten_outliers(im, min, max)\n\n    ## boolean image\n    # cutoff = 100 #int(max - min \/ 1000000) + min\n    # im = bool_img(im, cutoff)\n\n\n    # im_inverted = 255 - im ## local maxima uses 0 as background so we need particle peaks to be white\n    # coords = find_local_maxima(im_inverted, box_size, DEBUG = True)\n\n    display_img(im, coords, box_size)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_682","text":"<filename>hidrocomp\/comparasion\/genpareto.py\nfrom scipy.stats import genpareto\nimport pandas as pd\n\nfrom hidrocomp.comparasion.bootstrap_build import BootstrapBuild\n\n\nclass BootsGenPareto(BootstrapBuild):\n\n    def __init__(self, shape, location, scale, size):\n        super().__init__(shape, location, scale, size)\n\n    def fit_resample(self):\n        resample = genpareto.rvs(self.shape, self.location, self.scale,\n                                 self.size)\n        return genpareto.fit(resample)\n\n    def fits_resamples(self, quantity):\n        list_fits = list()\n        for i in range(quantity):\n            list_fits.append(self.fit_resample())\n\n        return list_fits\n\n    def magnitudes_resamples(self, quantity):\n        dic_magns = {0.001: list(), 0.01: list(), 0.1: list(),\n                     0.5: list(), 0.9: list(), 0.99: list(), 0.999: list()\n                     }\n        for i in range(quantity):\n            fit = self.fit_resample()\n            for j in dic_magns:\n                mag = genpareto.ppf(j, fit[0], fit[1], fit[2])\n                dic_magns[j].append(mag)\n\n        return pd.DataFrame(dic_magns)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_528","text":"import numpy as np\nfrom sigpipes.sigcontainer import SigContainer\nfrom sigpipes.sigoperator import SigOperator\nfrom warnings import warn\nfrom typing import Sequence, List\nfrom scipy.signal import correlate, convolve\nfrom deprecated import deprecated\n\n\nclass Joiner(SigOperator):\n    def __init__(self, *branches):\n        self.subop = branches\n\n    def fromSources(self) -> SigContainer:\n        container = self.prepare_container(self.subop[0])\n        return self.join(container, self.subop[1:])\n\n    def apply(self, container: SigContainer) -> SigContainer:\n        container = self.prepare_container(container)\n        containers = [inp if isinstance(inp, SigContainer) else container | inp for inp in self.subop]\n        # containers = container | Alternatives(*self.subop)\n        assert all(isinstance(c, SigContainer) for c in containers), \"Join over non containers\"\n        self.assertion(container, containers)\n        return self.join(container, containers)\n\n    def prepare_container(self, container: SigContainer) -> SigContainer:\n        return SigContainer(container.d.deepcopy(shared_folders=[\"annotations\"],\n                                                 empty_folders=[\"meta\"]))\n\n    def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n        raise NotImplementedError(\"abstract method\")\n\n    def assertion(self, output: SigContainer, inputs: Sequence[SigContainer]) -> None:\n        assert all(c.signals.shape == output.signals.shape for c in inputs)\n        if any(c.d[\"signals\/fs\"] != output.d[\"signals\/fs\"] for c in inputs):\n            warn(\"Join operation on signals with incompatible frequencies\")\n\n\nclass Merge(Joiner):\n    def __init__(self, ufunc: np.ufunc, *branches) -> None:\n        super().__init__(*branches)\n        self.ufunc = ufunc\n\n    def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n        result = np.copy(output.signals)\n        for inc in inputs:\n            self.ufunc(result, inc.signals, out=result)\n        output.d[\"signals\/data\"] = result\n        print(output.d[\"signals\/channels\"])\n        output.d[\"signals\/channels\"] = [\n            f\"{self.ufunc.__name__}({', '.join(input.d['signals\/channels'][i] for input in [output] + inputs)})\"\n            for i in range(output.channel_count)]\n        return output\n\n    def log(self):\n        return f\"M@{self.ufunc.__name__}\"\n\n@deprecated(reason='more generalized and efficient version in Merge joiner')\nclass Sum(Joiner):\n    def __init__(self, *branches) -> None:\n        super().__init__(*branches)\n\n    def join(self, outcontainer: SigContainer, incontainers: Sequence[SigContainer]) -> SigContainer:\n        result = np.copy(outcontainer.signals)\n        for inc in incontainers:\n            result += inc.signals\n        outcontainer.d[\"signals\/data\"] = result\n        return outcontainer\n\n\nclass JoinChannels(Joiner):\n    def __init__(self, *branches):\n        super().__init__(*branches)\n\n    def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n        for input in inputs:\n            output.d[\"signals\/data\"] = np.vstack((output.signals, input.signals))\n            output.d[\"signals\/channels\"].extend(input.d[\"signals\/channels\"])\n            output.d[\"signals\/units\"].extend(input.d[\"signals\/units\"])\n        return output\n\n    def assertion(self, output: SigContainer, inputs: Sequence[SigContainer]) -> None:\n        assert all(c.signals.shape[1] == output.signals.shape[1] for c in inputs)\n        if any(c.d[\"signals\/fs\"] != output.d[\"signals\/fs\"] for c in inputs):\n            warn(\"Join operation on signals with incompatible frequencies\")\n\n\nclass Concatenate(Joiner):\n    def __init__(self, *branches, channel_names = None):\n        super().__init__(*branches)\n        self.names = channel_names\n\n    def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n        if self.names is not None:\n            output.d[\"signals\/channels\"] = self.names\n        for input in inputs:\n            output.d[\"signals\/data\"] = np.hstack((output.signals, input.signals))\n            if self.names is None:\n                output.d[\"signals\/channels\"] = [\n                    output.d[\"signals\/channels\"][i] + \" + \" + input.d[\"signals\/channels\"][i]\n                        for i in range(len(output.d[\"signals\/channels\"]))]\n        return output\n\n    def assertion(self, output: SigContainer, inputs: Sequence[SigContainer]) -> None:\n        assert all(c.signals.shape[0] == output.signals.shape[0] for c in inputs)\n        if any(c.d[\"signals\/fs\"] != output.d[\"signals\/fs\"] for c in inputs):\n            warn(\"Join operation on signals with incompatible frequencies\")\n\n\nclass AssymetricJoiner(Joiner):\n    def assertion(self, output: SigContainer, inputs: Sequence[SigContainer]) -> None:\n        assert all(c.signals.shape[0] == output.signals.shape[0] for c in inputs)\n        if any(c.d[\"signals\/fs\"] != output.d[\"signals\/fs\"] for c in inputs):\n            warn(\"Join operation on signals with incompatible frequencies\")\n\n    def crossChannelNames(self, c1: SigContainer, c2: SigContainer) -> List[str]:\n        return [\n             f\"{name1} x {name2}\" if name1 !=name2 else f\"{name1} (cross)\"\n             for name1, name2 in zip(c1.d[\"\/signals\/channels\"], c2.d[\"\/signals\/channels\"])\n        ]\n\n    def crossUnit(self, c1: SigContainer, c2: SigContainer) -> List[str]:\n        return [\n             f\"{unit1} x {unit2}\" if unit1 !=unit2 else f\"{unit1}$^2$\"\n             for unit1, unit2 in zip(c1.d[\"\/signals\/units\"], c2.d[\"\/signals\/units\"])\n        ]\n\n\nclass CrossCorrelate(AssymetricJoiner):\n    def __init__(self, *branches, mode:str = 'full', method: str = 'auto'):\n        super().__init__(*branches)\n        self.mode = mode\n        self.method = method\n\n    def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n        assert len(inputs) <= 1, \"Cross corelation with more than two signal is not supported\"\n        in1 = output\n        in2 = inputs[0] if inputs else in1\n        result = np.vstack([\n            correlate(in1.signals[i, :], in2.signals[i, :], self.mode, self.method)\n            for i in range(in1.signals.shape[0])\n        ])\n        output.d[\"signals\/data\"] = result\n        output.d[\"signals\/channels\"] = self.crossChannelNames(in1, in2)\n        output.d[\"signals\/units\"] = self.crossUnit(in1, in2)\n        output.d[\"signals\/lag\"] = output.sample_count \/\/ 2\n        return output\n\n\nclass Convolve(AssymetricJoiner):\n        def __init__(self, *branches, mode: str = 'full', method: str = 'auto'):\n            super().__init__(*branches)\n            self.mode = mode\n            self.method = method\n\n        def join(self, output: SigContainer, inputs: Sequence[SigContainer]) -> SigContainer:\n            assert len(inputs) <= 1, \"Convolution with more than two signal is not supported\"\n            in1 = output\n            in2 = inputs[0] if inputs else in1\n            result = np.vstack([\n                convolve(in1.signals[i, :], in2.signals[i, :], self.mode, self.method)\n                for i in range(in1.signals.shape[0])\n            ])\n            output.d[\"signals\/data\"] = result\n            output.d[\"signals\/lag\"] = output.sample_count \/\/ 2\n            return output\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_530","text":"<gh_stars>0\nimport numpy as np\nimport netCDF4 as nc\nimport xarray as xr\nfrom scipy.interpolate import griddata, interp1d\nfrom salishsea_tools import (nc_tools, gsw_calls,viz_tools)\n# import matplotlib.pyplot as plt\n# import matplotlib.cm as cm\n\nfname = '\/home\/ssahu\/saurav\/JP_BC\/cat_42_days_T.nc'\n\ngridT = xr.open_dataset(fname)\n\nmask = nc.Dataset('\/ocean\/ssahu\/CANYONS\/wcvi\/grid\/meshmask_files\/JP_mesh_mask.nc')\n\ntmask_JP = mask.variables['tmask'][0,:,55:420,446:730]\n\nvotemper_JP = np.array(gridT['votemper'][1,:,55:420,446:730]) #Our 1st day of NEMO run (set in namelist and atmos files from that day)  is second day of data which starts from beginning of month\nvotemper_JP[...] = np.ma.masked_array(votemper_JP[...], mask = tmask_JP[...])\nvotemper_JP[votemper_JP == 0] =['Nan']\n\nvosaline_JP = np.array(gridT['vosaline'][1,:,55:420,446:730])\nvosaline_JP[...] = np.ma.masked_array(vosaline_JP[...], mask = tmask_JP[...])\nvosaline_JP[vosaline_JP == 0] = ['Nan']\n\nglamt_bc_JP = np.array(gridT['nav_lon'][55:420,446:730])\ngphit_bc_JP = np.array(gridT['nav_lat'][55:420,446:730])\ndeptht_JP = np.array(gridT['deptht'][:])\n\nprint(\"Removing Nan values from JP's data, since we replaced the zero masks with Nans\")\n\n\nfor i in np.arange(1,votemper_JP.shape[0]):\n    for p in np.arange(votemper_JP.shape[1]):\n        for l in np.arange(votemper_JP.shape[2]):\n            if np.isnan(votemper_JP[i,p,l]):\n                votemper_JP[i,p,l] = votemper_JP[i-1,p,l]\n            else:\n                continue\n\n\nfor i in np.arange(1,vosaline_JP.shape[0]):\n    for p in np.arange(vosaline_JP.shape[1]):\n        for l in np.arange(vosaline_JP.shape[2]):\n            if np.isnan(vosaline_JP[i,p,l]):\n                vosaline_JP[i,p,l] = vosaline_JP[i-1,p,l]\n            else:\n                continue\n                \n                \nfor i in np.arange(votemper_JP.shape[0]):\n    for p in np.arange(votemper_JP.shape[1]):\n        for l in np.arange(votemper_JP.shape[2]):\n            if np.isnan(votemper_JP[i,p,l]):\n                votemper_JP[i,p,l] = votemper_JP[i,p,l-1]\n            else:\n                continue\n\n\nfor i in np.arange(vosaline_JP.shape[0]):\n    for p in np.arange(vosaline_JP.shape[1]):\n        for l in np.arange(vosaline_JP.shape[2]):\n            if np.isnan(vosaline_JP[i,p,l]):\n                vosaline_JP[i,p,l] = vosaline_JP[i,p,l-1]\n            else:\n                continue\n                \nfor i in np.arange(vosaline_JP.shape[1]):\n    for j in np.arange(vosaline_JP.shape[2]):\n        if np.isnan(vosaline_JP[0,i,j]):\n            vosaline_JP[0,i,j] = vosaline_JP[1,i,j]\n        else:\n            continue\n            \n            \nfor i in np.arange(votemper_JP.shape[1]):\n    for j in np.arange(votemper_JP.shape[2]):\n        if np.isnan(votemper_JP[0,i,j]):\n            votemper_JP[0,i,j] = votemper_JP[1,i,j]\n        else:\n            continue\n\n#fname_wcvi = '\/ocean\/ssahu\/CANYONS\/wcvi\/grid\/coordinates.nc'\n\nfname_wcvi = '\/ocean\/ssahu\/CANYONS\/wcvi\/grid\/coordinates_westcoast_seagrid_high_resolution_truncated_wider_west_bdy.nc'\n\nwith nc.Dataset(fname_wcvi, 'r') as coord:\n    gphit_wcvi = coord.variables['gphit'][0,...];\n    glamt_wcvi =  coord.variables['glamt'][0,...];\n\nX = glamt_bc_JP.flatten();\n\nY = gphit_bc_JP.flatten();\n\npoints = (X[:],Y[:]);\n\nxi = (glamt_wcvi.flatten(), gphit_wcvi.flatten());\n\nvotemper_ic = np.empty((votemper_JP.shape[0], glamt_wcvi.shape[0], glamt_wcvi.shape[1]));\nvosaline_ic = np.empty((vosaline_JP.shape[0], glamt_wcvi.shape[0], glamt_wcvi.shape[1]));\n\nfor i in np.arange(votemper_JP.shape[0]):\n    votemper_ic[i,...] = np.reshape(griddata(points, votemper_JP[i,...].flatten(), xi, method= 'linear'), glamt_wcvi.shape)\n    vosaline_ic[i,...] = np.reshape(griddata(points, vosaline_JP[i,...].flatten(), xi, method= 'linear'), glamt_wcvi.shape)\n\n\n\nprint(\"Interpolation to WCVI horizontal points successful\")\n\nprint(\"Calling GSW tools to convert to Conservative Temperature and Reference Salinity\")\n\n\nlat = np.empty_like(gphit_wcvi)\nlon = np.empty_like(gphit_wcvi)\ndepth = np.empty_like(deptht_JP)\n\nlat[:] = gphit_wcvi[:]\nlon[:] = glamt_wcvi[:]\n\ndepth[:] = deptht_JP[:]\n\nz = np.multiply(depth[:],-1)\n\nvotemper_PT = np.empty_like(votemper_ic)\nvosaline_PSU =np.empty_like(vosaline_ic)  \n\n \nvotemper_PT[:] = votemper_ic[:] \nvosaline_PSU[:] = vosaline_ic[:]\n\npressure = np.empty(z.shape)\nlats = np.empty(pressure.shape)\nlons = np.empty(pressure.shape)\nlats[:] = np.mean(lat)\nlons[:] = np.mean(lon)\n\n\nvosaline_SA = np.empty(vosaline_PSU.shape)\nvosaline_RS = np.empty(vosaline_PSU.shape)\nvotemper_CT = np.empty(votemper_PT.shape)\n\npressure = gsw_calls.generic_gsw_caller('gsw_p_from_z.m', [z, np.mean(lat)])\n\nprint(\"Converted z to p: first GSW call successful\")\n\nfor i in np.arange(vosaline_SA.shape[0]):\n    vosaline_SA[i,...] = gsw_calls.generic_gsw_caller('gsw_SA_from_SP', [vosaline_PSU[i,...],pressure[i],lons[i],lats[i]])\n\nprint(\"Got SA from SP: GSW ran successfully inside loop\")\n\nvosaline_RS[:] = gsw_calls.generic_gsw_caller('gsw_SR_from_SP', [vosaline_PSU[:]])\n\nprint(\"Reference Salinity obtained from PS: one more GSW call left\")\n\nvotemper_CT[:] = gsw_calls.generic_gsw_caller('gsw_CT_from_pt', [vosaline_SA[:], votemper_PT[:]])\n\n\nprint(\"GSW Calls successfull\")\n\nmask_wcvi = nc.Dataset('\/ocean\/ssahu\/CANYONS\/wcvi\/grid\/meshmask_files\/mesh_mask_high_res.nc')\n\nNEMO_depth = mask_wcvi.variables['gdept_0'][0,:,0,0]\ntmask_WCVI = mask_wcvi.variables['tmask'][:]\n\n\nsalinity_function = interp1d(depth, vosaline_RS, axis = 0, bounds_error=False, fill_value='extrapolate')\ntemperature_function = interp1d(depth, votemper_CT, axis = 0, bounds_error=False, fill_value='extrapolate')\n\nvosaline_NEMO = np.empty((NEMO_depth.shape[0], vosaline_RS.shape[1], vosaline_RS.shape[2]));\nvotemper_NEMO = np.empty((NEMO_depth.shape[0], vosaline_RS.shape[1], vosaline_RS.shape[2]));\n\nfor indx in np.arange(NEMO_depth.shape[0]):\n    vosaline_NEMO[indx,...] = salinity_function(NEMO_depth[indx]);\n    votemper_NEMO[indx,...] = temperature_function(NEMO_depth[indx]);\n\nfor i in np.arange(votemper_NEMO.shape[0]):\n    for p in np.arange(votemper_NEMO.shape[1]):\n        for l in np.arange(votemper_NEMO.shape[2]):\n            if np.isnan(votemper_NEMO[i,p,l]):\n                votemper_NEMO[i,p,l] = votemper_NEMO[i-1,p,l]\n            else:\n                continue\n\n                \nfor i in np.arange(vosaline_NEMO.shape[0]):\n    for p in np.arange(vosaline_NEMO.shape[1]):\n        for l in np.arange(vosaline_NEMO.shape[2]):\n            if np.isnan(vosaline_NEMO[i,p,l]):\n                vosaline_NEMO[i,p,l] = vosaline_NEMO[i-1,p,l]\n            else:\n                continue\n\n\n\nprint(\"Vertical Interpolation to WCVI depth levels successful\")\n\nprint(\"Now writing into a binary file to be used as IC for NEMO\")\n\nfile_temp = nc.Dataset('\/ocean\/ssahu\/CANYONS\/wcvi\/initial_conditions\/West_coast_NEMO_IC_high_resolution_wide_bdy.nc', 'w', zlib=True)\n# dataset attributes\nnc_tools.init_dataset_attrs(\n    file_temp, \n    title='Temperature and salinity Initial Condition', \n    notebook_name='Making_IC_from_JP', \n    nc_filepath='\/ocean\/ssahu\/CANYONS\/wcvi\/initial_conditions\/West_coast_NEMO_IC_high_resolution.nc',\n    comment='Temperature and salinity from JP Model, high_resolution__grid; used at all grid points and interpolated vertically')\n\nfile_temp.createDimension('xb', votemper_NEMO.shape[2]);\nfile_temp.createDimension('yb', votemper_NEMO.shape[1]);\nfile_temp.createDimension('deptht', votemper_NEMO.shape[0]);\nfile_temp.createDimension('time_counter', None);\n\n\nnav_lat = file_temp.createVariable('nav_lat', 'float32', ('yb','xb'));\nnav_lat.long_name = 'Latitude';\nnav_lat.units = 'degrees_north';\n\n\nnav_lon = file_temp.createVariable('nav_lon', 'float32', ('yb','xb'));\nnav_lon.long_name = 'Longitude';\nnav_lon.units = 'degrees_east';\n\n\ndeptht = file_temp.createVariable('deptht', 'float32', ('deptht'));\ndeptht.long_name = 'Vertical T Levels';\ndeptht.units = 'm';\ndeptht.positive = 'down';\n\n\ntime_counter = file_temp.createVariable('time_counter', 'float32', ('time_counter'));\ntime_counter.units = 's';\ntime_counter.long_name = 'time';\ntime_counter.calendar = 'noleap';\n\n\nvotemper = file_temp.createVariable('votemper', 'float32', ('time_counter','deptht','yb','xb'));\nvotemper.units = 'degC'\nvotemper.long_name = 'Conservative Temperature (CT)';\nvotemper.grid = 'WCVI';\n\n\nvosaline = file_temp.createVariable('vosaline', 'float32', ('time_counter','deptht','yb','xb'));\nvosaline.units = 'g\/Kg';\nvosaline.long_name = 'Reference Salinity (SR)';\nvosaline.grid = 'WCVI';\n\n\n\n\nnav_lat[:] = lat[:];\nnav_lon[:] = lon[:];\ndeptht[:] = NEMO_depth[:];\ntime_counter[0] = 1;\nvotemper[0,...] = votemper_NEMO[:]\nvosaline[0,...]= vosaline_NEMO[:]\n\nfile_temp.close()\n\n\nprint(\"File written: Thank you\")\n\n\n\n\t\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_531","text":"<reponame>johertrich\/Proximal_Neural_Networks<filename>conv_denoiser\/test_conv_denoiser_BSD68.py\n# This code belongs to the paper\n# \n# <NAME>, <NAME> and <NAME>.  \n# Convolutional Proximal Neural Networks and Plug-and-Play Algorithms.\n# Linear Algebra and its Applications, vol 631 pp. 203-234, 2021.\n#\n# Please cite the paper if you use this code.\n#\nfrom core.stiefel_network import *\nfrom core.layers import *\nimport numpy as np\nimport numpy.random\nfrom PIL import Image\nfrom conv_denoiser.readBSD import *\nimport bm3d\nimport pickle\nfrom scipy.io import savemat\n\ndef run(scale=1.99,noise_level=25.\/255.,num=None,pretrained_weights=True):\n    # declare network\n    act=tf.keras.activations.relu\n    num_filters=64\n    max_dim=128\n    num_layers=8\n    sizes=[None]*(num_layers)\n    conv_shapes=[(num_filters,max_dim)]*num_layers\n    filter_length=5\n    if scale is None:\n        model=StiefelModel(sizes,None,convolutional=True,filter_length=filter_length,dim=2,conv_shapes=conv_shapes,activation=act,scale_layer=False)\n    else:\n        model=StiefelModel(sizes,None,convolutional=True,filter_length=filter_length,dim=2,conv_shapes=conv_shapes,activation=act,scale_layer=scale)\n\n    pred=model(tf.random.normal((10,40,40)))\n    model.fast_execution=True\n\n    if scale is None:\n        # load weights\n        if pretrained_weights:\n            file_name='data\/pretrained_weights\/free_noise_level'+str(noise_level)+'.pickle'\n        else:\n            if num is None:\n                file_name='results_conv\/free_noise_level'+str(noise_level)+'\/adam.pickle'\n            else:\n                file_name='results_conv\/free_noise_level'+str(noise_level)+'\/adam'+str(num)+'.pickle'\n        with open(file_name,'rb') as f:\n            trainable_vars=pickle.load(f)\n        for i in range(len(model.trainable_variables)):\n            model.trainable_variables[i].assign(trainable_vars[i])\n    else:\n        # load weights\n        if pretrained_weights:\n            file_name='data\/pretrained_weights\/scale'+str(scale)+'_noise_level'+str(noise_level)+'.pickle'\n        else:\n            if num is None:\n                file_name='results_conv\/scale'+str(scale)+'_noise_level'+str(noise_level)+'\/adam.pickle'\n            else:\n                file_name='results_conv\/scale'+str(scale)+'_noise_level'+str(noise_level)+'\/adam'+str(num)+'.pickle'\n        with open(file_name,'rb') as f:\n            trainable_vars=pickle.load(f)\n        for i in range(len(model.trainable_variables)):\n            model.trainable_variables[i].assign(trainable_vars[i])\n        beta=1e8\n        project=True\n        if project:\n            # projection of the convolution matrices onto the Stiefel manifold\n            for i in range(len(model.stiefel)):\n                convs=model.stiefel[i].convs\n                smaller=convs.shape[0]<convs.shape[1]\n                if smaller:\n                    convs=transpose_convs(convs)\n                iden=np.zeros((convs.shape[1],convs.shape[1],4*filter_length+1,4*filter_length+1),dtype=np.float32)            \n                for j in range(convs.shape[1]):\n                    iden[j,j,2*filter_length,2*filter_length]=1\n                iden=tf.constant(iden)\n                C=tf.identity(convs)\n                def projection_objective(C):\n                    return 0.5*beta*tf.reduce_sum((conv_mult(transpose_convs(C),C)-iden)**2)+.5*tf.reduce_sum((C-convs)**2)\n                for iteration in range(100):\n                    with tf.GradientTape(persistent=True) as tape:\n                        tape.watch(C)\n                        val=projection_objective(C)\n                        grad=tape.gradient(val,C)\n                        grad_sum=tf.reduce_sum(grad*grad)\n                    hess=tape.gradient(grad_sum,C)\n                    hess*=0.5\/tf.sqrt(grad_sum)\n                    C-=grad\/tf.sqrt(tf.reduce_sum(hess*hess))\n                if smaller:\n                    C=transpose_convs(C)\n                model.stiefel[i].convs.assign(C)\n                \n\n    np.set_printoptions(threshold=sys.maxsize)\n\n\n    # set parameters\n    test_directory='data\/BSD68'\n    fileList=os.listdir(test_directory+'\/')\n    fileList.sort()\n    img_names=fileList\n    sig=25.\n    sig\/=255.\n    if scale is None:\n        save_path='results_conv\/denoise_results_free_noise_level'+str(noise_level)\n    else:\n        save_path='results_conv\/denoise_results_scale'+str(scale)+'_noise_level'+str(noise_level)\n    if not os.path.isdir('results_conv'):\n        os.mkdir('results_conv')\n    if not os.path.isdir(save_path):\n        os.mkdir(save_path)\n    if not os.path.isdir(save_path+'\/noisy_data'):\n        os.mkdir(save_path+'\/noisy_data')\n    if not os.path.isdir(save_path+'\/other'):\n        os.mkdir(save_path+'\/other')\n    psnr_sum=0.\n    psnr_noisy_sum=0.\n    psnr_bm3d_sum=0.\n    error_sum=0.\n    error_bm3d_sum=0.\n    counter=0\n    my_shift=10\n    myfile=open(save_path+\"\/psnrs.txt\",\"w\")\n    myfile.write(\"PSNRs:\\n\")\n    myfile.close()\n    np.random.seed(30)\n    # Denoising\n    for name in img_names:\n        counter+=1\n        img=Image.open(test_directory+'\/'+name)\n        img=img.convert('L')\n        img_gray=1.0*np.array(img)\n        img_gray\/=255.0\n        img_gray-=.5\n        img_gray_noisy=img_gray+sig*np.random.normal(size=img_gray.shape)\n        savemat(save_path+'\/noisy_data\/'+name[:-4]+'_noisy.mat',{'noisy': (img_gray_noisy+0.5)*255})\n        img_gray_pil=Image.fromarray((img_gray+.5)*255.0)\n        img_gray_pil=img_gray_pil.convert('RGB')\n        img_gray_pil.save(save_path+'\/original'+name)    \n        pred=model(tf.expand_dims(tf.constant(img_gray_noisy,dtype=tf.float32),0))\n        noisy=(img_gray_noisy+.5)*255\n        reconstructed=((img_gray_noisy-np.reshape(pred.numpy(),img_gray.shape))+.5)*255.\n        img_gray=(img_gray+.5)*255.\n        res_bm3d=(bm3d.bm3d(img_gray_noisy,sig)+0.5)*255.\n        error_sum+=tf.reduce_sum(((reconstructed-img_gray)\/255.)**2).numpy()\n        error_bm3d_sum+=tf.reduce_sum(((res_bm3d-img_gray)\/255.)**2).numpy()\n        psnr=meanPSNR(tf.keras.backend.flatten(reconstructed).numpy()\/255.0,tf.keras.backend.flatten(img_gray).numpy()\/255.0,one_dist=True)\n        psnr_noisy=meanPSNR(tf.keras.backend.flatten(noisy).numpy()\/255.0,tf.keras.backend.flatten(img_gray).numpy()\/255.0,one_dist=True)\n        psnr_bm3d=meanPSNR(tf.keras.backend.flatten(res_bm3d).numpy()\/255.0,tf.keras.backend.flatten(img_gray).numpy()\/255.0,one_dist=True)\n        print('PSNR of '+name+':                    '+str(psnr))\n        print('PSNR of BM3D '+name+':               '+str(psnr_bm3d))\n        print('PSNR of noisy '+name+':              '+str(psnr_noisy))\n        psnr_sum+=psnr\n        psnr_noisy_sum+=psnr_noisy\n        psnr_bm3d_sum+=psnr_bm3d\n        print('Mean PSNR PPNN:                      '+str(psnr_sum\/counter))\n        print('Mean PSNR BM3D:                      '+str(psnr_bm3d_sum\/counter))\n        print('Mean Error PPNN:                     '+str(error_sum\/counter))\n        print('Mean Error BM3D:                     '+str(error_bm3d_sum\/counter))\n        print('Mean PSNR noisy:                     '+str(psnr_noisy_sum\/counter))    \n        myfile=open(save_path+\"\/psnrs.txt\",\"a\")\n        myfile.write('PSNR of '+name+':                    '+str(psnr)+'\\n')\n        myfile.write('PSNR of BM3D '+name+':               '+str(psnr_bm3d)+'\\n')\n        myfile.write('PSNR of noisy '+name+':              '+str(psnr_noisy)+'\\n')\n        myfile.close()\n        img=Image.fromarray(noisy)\n        img=img.convert('RGB')\n        img.save(save_path+'\/noisy'+name)\n        img=Image.fromarray(reconstructed)\n        img=img.convert('RGB')\n        img.save(save_path+'\/reconstructed'+name)            \n        img=Image.fromarray(res_bm3d)\n        img=img.convert('RGB')\n        img.save(save_path+'\/other\/BM3D'+name)            \n    print('Mean PSNR on images: '+str(psnr_sum\/len(img_names)))\n    print('Mean PSNR on noisy images: '+str(psnr_noisy_sum\/len(img_names)))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_532","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Dec 04 10:13:10 2017\n\n@author: PJ\n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.io as sio\n\ndef generate(popSize,m):\n    '''\n    generate a random Individual for HLO\n    '''\n    Bpop = np.random.randint(2,size=(popSize,m))\n    return Bpop\n\ndef B2R(popSize,Bpop,dim,bit,bound):\n    '''\n    convert binary indivdual to real code format\n    '''\n    Rpop = np.zeros((popSize,dim))\n    for i in range(0,popSize):\n        for d in range(0,dim):\n            for j in range(d*bit,(d+1)*bit):\n                Rpop[i,d] = Rpop[i,d] + (Bpop[i,j]*2**((d+1)*bit-j-1))\n            Rpop[i,d] = bound[0]+(bound[1]-bound[0])*Rpop[i,d]\/(2**bit-1)\n    return Rpop\n\ndef Evfit(Rpop,dim):\n    \"\"\"\n    sphere function\n    \"\"\"\n    o=sio.loadmat('sphere_func_data')\n    o = o['o'].reshape(-1)\n    f = np.zeros((len(Rpop)))\n    for i in range(0,len(Rpop)):\n        for j in range(0,dim):\n            f[i] = f[i] + (Rpop[i,j]-o[j])**2\n    return f\n\ndef printResult(Gmax,trace):\n    '''\n    plot the result of the HLO\n    '''\n    x = np.arange(0, Gmax)\n    y1 = trace[:, 0]\n    plt.plot(x, y1, 'r', label='optimal value')\n    plt.xlabel(\"Iteration\")\n    plt.ylabel(\"function value\")\n    plt.title(\"HLO for function optimization\")\n    plt.legend()\n    plt.show() \n        \n       "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_534","text":"<filename>intrinsic\/outlier_detection.py\nfrom numpy import mean, std, sqrt, log, exp\nfrom scipy.stats import norm, shapiro, anderson\nimport math\n\n\n# (nj) TODO: Come up with different (better?) ways of\n# (1) Combining \"probabilities\" for a single passage. Right now we just mulitply \n# the probabilities we get from each of the features. Done in:\n# _combine_feature_probs(prob_vector)\n# (2) Building a \"confidence\" score based on the relative \"probability\" of \n# a passage being plagiarized vs. not-plagiarized. Done in:\n# _get_confidence(plag_prob, non_plag_prob) \n# (3) Scaling the \"confidence\" scores across an entire document (set of \n# stylometric features). Done in:\n# _scale_confidences(confs) \n\nMIN_PROB = 10**(-30)\n# The confidence we use when we are unable to calculate anything about the\n# likelihood of plag\nIMPURITY_ASSUMPTION = .2\n\n\ndef density_based(stylo_vectors, center_at_mean=True, num_to_ignore=1, impurity=.2, feature_confidence_weights=None):\n    '''\n    Implements the algorithm described in <NAME>'s\n    \"Intrinsic Plagiarism Analysis\", Section 2.4 \"Outlier Detection\"\n\n    Estimates the distribution of each feature's non-plag. portion as a normal distribution\n    simply using the MLE (i.e. a normal distribution with sample mean\n    and sample std as parameters). Note that the min and max of the observed\n    features are removed before computing sample mean\/std (and this could perhaps\n    be extended to remove the <k> largest\/smallest observations before computing\n    sample mean\/std)\n\n    if <center_at_mean>, then normal dist is centered at feature's mean\n    if not, then normal dist at feature's median\n\n    When calculating the mean, the minimum and maximum <num_to_ignore> elements\n    are ignored. \n\n    NOTE <impurity> argument is ignored right now.\n    '''\n    transpose = _rotate_vectors(stylo_vectors)\n    confidences = []\n\n    means, stds, mins, medians, maxs = [], [], [], [], []\n    normality_pvals = []\n\n    for row in transpose:\n        cur_mean, cur_std, cur_min, cur_median, cur_max = _get_distribution_features(row, num_to_ignore)\n        means.append(cur_mean)\n        stds.append(cur_std)\n        mins.append(cur_min)\n        medians.append(cur_median)\n        maxs.append(cur_max)\n\n        # Print some data about the normality of our features\n        norm_p = _test_normality(row)\n        normality_pvals.append(norm_p)\n\n    #print 'Normality pvals have min, max, mean:', min(normality_pvals), max(normality_pvals), mean(normality_pvals)\n    \n    for i in xrange(len(stylo_vectors)):\n        vec = stylo_vectors[i]\n        # For current <vec>,\n        # featurewise_plag_prob[i] == prob. that feature <i> was plagiarized in <vec>\n        # NOTE that these are taken from PDFs, so they don't actually correspond\n        # to real probabilities \n        featurewise_nonplag_prob = []\n        featurewise_plag_prob = []\n        featurewise_confs = []\n\n        for feat_num in xrange(len(vec)):\n            # TODO plag_prob is just constant -- precompute this\n            cur_val = vec[feat_num]\n            cur_center = means[feat_num] if center_at_mean else medians[feat_num]\n            cur_std = stds[feat_num]\n            cur_min, cur_max = mins[feat_num], maxs[feat_num]\n\n            \n            # A std of 0 => the feature is constant, and therefore won't \n            # help us distinguish anything!\n            if cur_std != 0.0 and not _in_uncertainty_interval(cur_val, cur_center, cur_std):\n\n                cur_norm_prob = _get_norm_prob(cur_val, cur_center, cur_std)\n                if math.isnan(cur_norm_prob) or cur_norm_prob == 0.0:\n                    cur_norm_prob = MIN_PROB\n                    #print 'Norm prob was nan or 0: %f. Using MIN_PROB' % cur_norm_prob\n\n                cur_unif_prob = _get_unif_prob(cur_val, cur_min, cur_max)\n                if math.isnan(cur_unif_prob) or cur_unif_prob == 0.0:\n                    cur_unif_prob = MIN_PROB\n                    print 'Unif prob was nan or 0: %f. Using MIN_PROB' % cur_unif_prob\n\n\n                featurewise_confs.append(_get_confidence(cur_unif_prob, cur_norm_prob))\n            # TODO what happens if all points are in uncertainty interval??\n        confidences.append(_combine_feature_probs(featurewise_confs))\n            \n    # No more scaling -- we're already returning probs between 0 and 1, so should be all good\n    # scaled = _scale_confidences(confidences)\n    # return scaled\n\n    return confidences\n\ndef _combine_feature_probs(prob_vector):\n    '''\n    Returns the Naive Bayes version of combining probabilites: just multiply them.\n    Note that we take the sum of the log of each probability and exponentiate\n    in hopes of avoiding underflow when multiplying many small numbers\n\n    If the probability vector is empty, then all features were in the uncertainty\n    interval. Return the IMPURITY_ASSUMPTION (unless something else logical comes\n    about)\n    '''\n    if len(prob_vector) == 0:\n        return IMPURITY_ASSUMPTION\n    else:\n        return exp(sum(log(prob_vector)))\n\ndef _get_confidence(plag_prob, non_plag_prob):\n    '''\n    Returns some notion of confidence:\n    If we think there's plag., return the Naive Bayes estimated prob of plag\n    If not, return the negative of the Naive Bayes estimate prob of NOT plag\n\n    Other options:\n    if plag_prob > non_plag_prob:\n        return plag_prob\n    else:\n        return -non_plag_prob\n    \n    The above is an old notion of confidence, which eventually gets\n    scaled. It worked well at the start, but also doesn't make a ton\n    of sense...\n\n    Note that these values are scaled later on to be between 0 and 1\n    '''\n    return plag_prob \/ (plag_prob + non_plag_prob) \n\ndef _scale_confidences(confs):\n    '''\n    NOT BEING USED ANYMORE. The way we combine combine plag\/non-plag probs \n    should already give confs between 0 and 1.\n\n    Scales all \"confidences\" to (0, 1) interval simply by dividing by \n    the maximum \"confidence\"\n\n    If <confs> is constant (i.e. contains all the same values), return\n    a vector of all IMPURITY_ASSUMPTIONs. \n    '''\n    # offset will be either 0 or some negative number, in which case\n    # we subtract the negative offset (i.e. add)\n    offset = min(min(confs), 0.0)\n    max_conf_with_offset = max(confs) - offset\n\n    if max_conf_with_offset == 0.0:\n        return [IMPURITY_ASSUMPTION for x in confs]\n    else:\n        return [(x - offset) \/ max_conf_with_offset for x in confs]\n\ndef _get_distribution_features(row, extremes_to_ignore):\n    '''\n    <row> corresponds to all the observed values of feature\n\n    Per Section 2.4 in Stein, Lipka, Prettenhofer's \"Intrinsic Plagiarism Analysis\",\n    removes min and max when calculating parameters of Gaussian distribution\n    '''\n    sorted_row = sorted(row)\n\n    min_val = sorted_row[0]\n    max_val = sorted_row[-1]\n    median_val = sorted_row[len(sorted_row) \/ 2]\n\n    row_without_extremes = sorted_row[extremes_to_ignore : -extremes_to_ignore]\n    mean_of_row = mean(row_without_extremes)\n    std_of_row = std(row_without_extremes)\n\n    return mean_of_row, std_of_row, min_val, median_val, max_val\n\n\ndef _in_uncertainty_interval(x, center, sd_dist):\n    '''\n    Returns whether <x> is between 1 and 2 standard deviations away from\n    <center> in either direction. Such points are dubbed \"uncertain\"\n    in Stein et. al.'s paper\n    '''\n    right_interval = (center + sd_dist, center + 2 * sd_dist)\n    left_interval = (center - 2 * sd_dist, center - sd_dist)\n\n    if right_interval[0] <= x <= right_interval[1] or \\\n        left_interval[0] <= x <= left_interval[1]:\n        return True\n\n    return False\n\n\ndef _get_norm_prob(x, loc, scale):\n    '''\n    Returns normal PDF evaluated at <x> for a normal dist centered at <loc> \n    with SD == <scale>\n    '''\n    return norm.pdf(x, loc, scale)\n\ndef _get_unif_prob(v, min_val, max_val):\n    '''\n    Returns uniform PDF (probability density function)\n    '''\n    diff = max_val - min_val\n    if diff == 0:\n        return 1.0\n    else:\n        return 1.0 \/ (max_val - min_val)\n\ndef _rotate_vectors(mat):\n    '''\n    This is more verbose than it needs to be, but also perhaps \n    more readable. Transposes <mat> and returns it\n    '''\n    rotated = []\n\n    for col_num in range(len(mat[0])):\n        # Append one column at a time\n        rotated.append([mat[row_num][col_num] for row_num in range(len(mat))])\n\n    return rotated\n\ndef _test_normality(data, threshold=.05):\n    '''\n    '''\n    if len(data) < 4:\n        return 0\n    else:\n        test_stat, pval = shapiro(data)\n\n        return pval\n\n\ndef _test():\n    '''\n    '''\n    dim1_mean = 0\n    dim1_std = 3\n\n    dim2_mean = 20\n    dim2_std = 3\n    # 20 normal RVs with mean=0, std=\n    dim1 = list(norm.rvs(dim1_mean, dim1_std, size=20))\n    # Add a couple of obvious outliers\n    dim1.append(-10)\n    dim1.append(10)\n\n    dim2 = list(norm.rvs(dim2_mean, dim2_std, size=20))\n    dim2.append(10)\n    dim2.append(30)\n\n    data = zip(dim1, dim2)\n\n    confs = density_based(data)\n\n    print 'Dim1 params:', dim1_mean, dim1_std\n    print 'Dim2 params:', dim2_mean, dim2_std\n    for d, conf in zip(data, confs):\n        print d, conf\n\nif __name__ == '__main__':\n    _test()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_535","text":"#!\/usr\/bin\/python\n# -*- coding: latin-1 -*-\n\nimport numpy as np\n\n# Definimos una función senoidal simple.\ndef ondasimple(t):\n  A = 1.0    # amplitud\n  f = 500.0  # frequencia\n  Phi = 0.0  # fase\n  return A * np.sin(2 * np.pi * f * t + Phi)\n\n\n# Generamos 16000 puntos a 16kHz.\nts = np.arange(16000.0) \/ 16000.0\n\n\n# Armamos una onda senoidal discretizada.\nmionda = []\nfor t in ts:\n  mionda.append(ondasimple(t))\nmionda = np.array(mionda)\n\n\n# Graficamos la onda.\nimport matplotlib.pyplot as pyplot\npyplot.clf()\npyplot.plot(ts[0:100], mionda[0:100])\npyplot.savefig('mionda.png')\n\n\n# La guardamos como wav.\nimport scipy.io.wavfile\n#MAL: wavdata = np.array(mionda, dtype=np.int16) * 10000\nwavdata = np.array(mionda * 10000.0, dtype=np.int16)\nscipy.io.wavfile.write('mionda.wav', 16000, wavdata)\n\n\n# Ejercicios:\n#\n# 1. Generar un archivo wav para cada nota musical Do, Re, Mi,\n#    Fa, Sol, La, Si. Consultar las frecuencias en\n#    http:\/\/www.phy.mtu.edu\/~suits\/notefreqs.html\n#    Tomar como referencia La = 440Hz.\n#\n# 2. Buscar la frecuencia más aguda y más grave que pueden percibir.\n#\n# 3. Percepcion relativa. Escuchar la diferencia entre dos tonos graves\n#    separados por 100Hz (ej: 200 y 300Hz) y dos tonos agudos separados\n#    también por 100Hz (ej: 1200 y 1300Hz).\n#\n# 4. Crear una onda cuadrada a 500 Hz, modificando ondasimple(t) de modo\n#    que devuelva solamente 1 o -1. Generar un wav y comparar con una\n#    senoidal de la misma frecuencia.\n#\n# 5. Repetir el punto anterior para 100Hz y para 1000Hz. ¿En algún caso\n#    suenan parecidas las ondas senoidales y cuadradas? (Más allá de las\n#    diferencias de volumen).\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_536","text":"<gh_stars>0\nimport numpy as np\nfrom scipy.stats import zscore\nimport warnings\n\n\ndef cofluct(X, quantiles: tuple = (0, 1), return_mat=True):\n    \"\"\"\n    Computes cofluctuation time-series (per edge) for a nodes x timepoints matrix X.\n    Based on https:\/\/www.pnas.org\/content\/early\/2020\/10\/21\/2005531117\n\n    Parameters\n    ----------\n    quantiles: tuple,default=(0,1)\n        list of lowest\/highest quantile of edge events to use\n        [0, 1]: all events = pearson corr; [0, .05]: bottom 5% of events; [.95, 1]: top 5% of events\n    return_mat: bool,default=True\n        Whether to return a connectivity matrix (True) or dictionary (False). The dict edge contains cofluctuation\n        time-series (pairs_of_nodes x timepoints) and event timeseries.\n\n\n    Returns\n    -------\n    float\n        edge cofluctuation time-series dict (pairs_of_nodes x timepoints) and event timeseries as dict\n\n    \"\"\"\n    X = np.float32(X)\n    # get z-value time series (mean 0, std 1)\n    z_ts = zscore(X, axis=1)\n\n    # multiply z-scored time series to get edge time series (co-fluctuation)\n    edge_ids = np.triu_indices(X.shape[0], k=1)\n    edge_ts = np.einsum('ik,jk->ijk', z_ts, z_ts)[edge_ids]     # get upper triangular values\n\n    # get event_ts as Root Mean Square over nodes\n    event_ts = np.sqrt(np.mean(np.square(edge_ts), axis=0))\n\n    # get correlations for quantile intervals of events\n    q_low = np.quantile(np.abs(event_ts), q=quantiles[0])\n    q_high = np.quantile(np.abs(event_ts), q=quantiles[1])\n    edge_ts = edge_ts[:, (event_ts >= q_low) & (event_ts <= q_high)]\n\n    # compute correlation\/connectivity vector or matrix\n    cors = np.mean(edge_ts, axis=1)\n    if return_mat:\n        tmp = np.eye(X.shape[0])\n        tmp[np.triu_indices(tmp.shape[0], k=1)] = cors\n        cors = tmp + tmp.T\n        np.fill_diagonal(cors, 1)\n\n    # return as dict\n    else:\n        warnings.warn(\"dicts can not be handled by photonai.\"\n                      \"Dicts are implemented for use outside of Photon.\")\n        edge_ids_str = [str(m) + '_' + str(n) for m, n in zip(edge_ids[0], edge_ids[1])]\n        edge_ts_dict = {key: val for val, key in zip(edge_ts, edge_ids_str)}\n        edge_ts_dict['event_ts'] = event_ts\n        return edge_ts_dict\n\n    return cors\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_537","text":"# -*- coding: utf-8 -*-\n\"\"\" Code for training and evaluating Self-Explaining Neural Networks.\nCopyright (C) 2018 <NAME> <<EMAIL>>\n\nThis program is free software: you can redistribute it and\/or modify\nit under the terms of the GNU General Public License as published by\nthe Free Software Foundation, either version 3 of the License,\n(at your option) any later version.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\nGNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License\nalong with this program. If not, see <https:\/\/www.gnu.org\/licenses\/>.\n\"\"\"\n\nimport os\nimport pdb\nimport numpy as np\nfrom scipy import optimize\n\nimport matplotlib.pyplot as plt\nimport pprint # For feature explainer\n\nimport torch\nfrom torch.autograd import Variable\nfrom torchvision.utils import make_grid\nimport matplotlib.gridspec as gridspec\n\naccumulator = list()\npp = pprint.PrettyPrinter(indent=4)\n\n\ndef generate_dir_names(dataset, args, make = True):\n    if args.h_type == 'input':\n        suffix = '{}_H{}_Th{}_Reg{:0.0e}_LR{}'.format(\n                    args.theta_reg_type,\n                    args.h_type,\n                    args.theta_arch,\n                    args.theta_reg_lambda,\n                    args.lr,\n                    )\n    else:\n        suffix = '{}_H{}_Th{}_Cpts{}_Reg{:0.0e}_Sp{}_LR{}'.format(\n                    args.theta_reg_type,\n                    args.h_type,\n                    args.theta_arch,\n                    args.nconcepts,\n                    args.theta_reg_lambda,\n                    args.h_sparsity,\n                    args.lr,\n                    )\n\n    model_path     = os.path.join(args.model_path, dataset, suffix)\n    log_path       = os.path.join(args.log_path, dataset, suffix)\n    results_path   = os.path.join(args.results_path, dataset, suffix)\n\n    if make:\n        for p in [model_path, results_path]: #, log_path,\n            if not os.path.exists(p):\n                os.makedirs(p)\n\n    return model_path, log_path, results_path\n\n\nclass AverageMeter(object):\n    \"\"\"Computes and stores the average and current value\"\"\"\n    def __init__(self):\n        self.reset()\n\n    def reset(self):\n        self.val = 0\n        self.avg = 0\n        self.sum = 0\n        self.count = 0\n\n    def update(self, val, n=1):\n        self.val = val\n        self.sum += val * n\n        self.count += n\n        self.avg = self.sum \/ self.count\n\n\n\n### Animation Utils\n\n# animation function\ndef animate_fn(i, xx,yy,Ts, Cs):\n    t = Ts[i]\n    C = Cs[i]\n    cont = plt.contourf(xx, yy, C, 25, cmap = plt.cm.RdBu)\n    plt.title(r'Iter = %i' % t)\n    return cont\n\ndef animate_training(Steps, Cs, X_train, y_train):\n    cm = plt.cm.RdBu\n    cm_bright = ListedColormap(['#FF0000', '#0000FF'])\n    h = .02  # step size in the mesh\n    x_min, x_max = X_train[:, 0].min() - .5, X_train[:, 0].max() + .5\n    y_min, y_max = X_train[:, 1].min() - .5, X_train[:, 1].max() + .5\n    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n                         np.arange(y_min, y_max, h))\n\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    line, = ax.plot([],[], '-')\n    line2, = ax.plot([],[],'--')\n    ax.set_xlim(np.min(xx), np.max(xx))\n    ax.set_xlim(np.min(yy), np.max(yy))\n    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,\n       edgecolors='k')\n    #ax.contourf(xx, yy, Cs[0].reshape(xx.shape))\n\n    anim = animation.FuncAnimation(fig, animate_fn, frames = len(Steps), fargs = (xx,yy,Steps,Cs,), interval = 200, blit = False)\n\n    return anim\n\n# Got these two from scikit learn embedding example\ndef make_meshgrid(x, y, h=.02):\n    \"\"\"Create a mesh of points to plot in\n\n    Parameters\n    ----------\n    x: data to base x-axis meshgrid on\n    y: data to base y-axis meshgrid on\n    h: stepsize for meshgrid, optional\n\n    Returns\n    -------\n    xx, yy : ndarray\n    \"\"\"\n    x_min, x_max = x.min() - 1, x.max() + 1\n    y_min, y_max = y.min() - 1, y.max() + 1\n    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n                         np.arange(y_min, y_max, h))\n    return xx, yy\n\n\ndef plot_contours(model, X, **params):\n    \"\"\"Plot the decision boundaries for a classifier.\n\n    Parameters\n    ----------\n    ax: matplotlib axes object\n    clf: a classifier\n    xx: meshgrid ndarray\n    yy: meshgrid ndarray\n    params: dictionary of params to pass to contourf, optional\n    \"\"\"\n    fig, ax = plt.subplots()\n    Z = model(X)\n    Z = Z.data.numpy()\n    C = np.argmax(Z,axis=1)\n    C = C.reshape(xx.shape)\n    out = ax.contourf(xx, yy, C, **params)\n    return out\n\n\ndef plot_embedding(X,y,Xp, title=None):\n    \"\"\" Scale and visualize the embedding vectors \"\"\"\n    x_min, x_max = np.min(Xp, 0), np.max(Xp, 0)\n    Xp = (Xp - x_min) \/ (x_max - x_min)\n\n    plt.figure(figsize=(20,10))\n    ax = plt.subplot(111)\n    for i in range(Xp.shape[0]):\n        plt.text(Xp[i, 0], Xp[i, 1], str(y[i]),\n                 color=plt.cm.Set1(y[i] \/ 10.),\n                 fontdict={'weight': 'bold', 'size': 9})\n\n    if hasattr(offsetbox, 'AnnotationBbox'):\n        # only print thumbnails with matplotlib > 1.0\n        shown_images = np.array([[1., 1.]])  # just something big\n        for i in range(X.shape[0]):\n            dist = np.sum((Xp[i] - shown_images) ** 2, 1)\n            if np.min(dist) < 4e-3:\n                # don't show points that are too close\n                continue\n            shown_images = np.r_[shown_images, [Xp[i]]]\n            imagebox = offsetbox.AnnotationBbox(\n                offsetbox.OffsetImage(X[i,:].reshape(28,28), cmap=plt.cm.gray_r),\n                Xp[i])\n            ax.add_artist(imagebox)\n    plt.xticks([]), plt.yticks([])\n    if title is not None:\n        plt.title(title)\n\n\ndef _explain_class(model, x_raw, x,k,typ='pos',thresh = 0.5,recompute=True):\n    \"\"\"\n        Given an input x and class index k, explain f(x) by returning indices of\n        features in x that have highest positive impact on predicting class k.\n    \"\"\"\n    if recompute:\n        y = model(x) # y = self.model(x)\n    B_k = model.params[0,k,:].data.numpy()\n    if typ == 'pos':\n        Mask = (B_k > thresh).astype(np.int).reshape(x.size()).squeeze()\n    elif typ == 'neg':\n        Mask = (B_k < -thresh).astype(np.int).reshape(x.size()).squeeze()\n    else:\n        # Return weights instead of mask\n        return B_k.reshape(x.size()).squeeze()\n    Masked_x = Mask*x_raw.numpy().squeeze()\n    return Masked_x\n\ndef explain_digit(model, x_raw, x, thresh = 0.5, save_path = None):\n    \"\"\"\n        Given an input x, explain f(x) by returning indices of\n        features in x that have highest positive impact on predicting each class.\n\n        x_raw is passed for plotting purposes\n    \"\"\"\n    plt.imshow(x_raw.squeeze().numpy())\n    plt.title('Input:')\n    plt.xticks([])\n    plt.yticks([])\n    if save_path:\n        plt.savefig(save_path+'_input.pdf',  bbox_inches = 'tight', format='pdf', dpi=300)\n    plt.show()\n    y_pred = model(x)\n\n    pred_class = np.argmax(y_pred.data.numpy())\n    print('Predicted: ',pred_class)\n\n    fig, ax = plt.subplots(3,model.dout,figsize=(1.5*model.dout,1.5*3))\n    for i in range(model.dout):\n        #print('Class {}:'.format(i))\n\n        # Positive\n        x_imask = _explain_class(model, x_raw, x,i,typ ='pos', recompute=False, thresh = thresh)\n        ax[0,i].imshow(x_imask)\n        ax[0,i].set_xticks([])\n        ax[0,i].set_yticks([])\n        ax[0,i].set_title('Class: {}'.format(i))\n\n        # Negative\n        x_imask = _explain_class(model, x_raw, x,i,  typ ='neg', recompute=False, thresh = thresh)\n        ax[1,i].imshow(x_imask)\n        ax[1,i].set_xticks([])\n        ax[1,i].set_yticks([])\n\n        # Combined\n        x_imask = _explain_class(model, x_raw, x,i,  typ ='both', recompute=False)\n        ax[2,i].imshow(x_imask, cmap = plt.cm.RdBu)\n        ax[2,i].set_xticks([])\n        ax[2,i].set_yticks([])\n        #print(np.linalg.norm(x_imask))\n        #print(x_imask[:5,:5])\n\n        if i == 0:\n            ax[0,0].set_ylabel('Pos. Feats.')\n            ax[1,0].set_ylabel('Neg. Feats.')\n            ax[2,0].set_ylabel('Combined')\n\n\n    if save_path:\n        plt.savefig(save_path + '_expl.pdf', bbox_inches = 'tight', format='pdf', dpi=300)\n    plt.show()\n\ndef plot_text_explanation(words, values, n_cols = 6, save_path = None):\n    import seaborn as sns\n    # Get some pastel shades for the colors\n    #colors = plt.cm.BuPu(np.linspace(0, 0.5, len(rows)))\n    cmap = sns.cubehelix_palette(light=1, as_cmap=True)\n\n    n_rows = int(min(len(values), len(words)) \/ n_cols) + 1\n\n    # Plot bars and create text labels for the table\n    if type(words) is str:\n        words = words.split(' ')\n\n    cellcolours = np.empty((n_rows, n_cols), dtype='object')\n    celltext    = np.empty((n_rows, n_cols), dtype='object')\n\n    for r in range(n_rows):\n        for c in range(n_cols):\n            idx = (r * n_cols + c)\n            val =  values[idx] if (idx < len(values)) else 0\n            cellcolours[r,c] = cmap(val)\n            celltext[r,c] = words[idx] if (idx < len(words)) else ''\n\n    fig, ax = plt.subplots()#figsize=(n_cols, n_rows))\n\n    # Hide axes\n    ax.xaxis.set_visible(False)\n    ax.yaxis.set_visible(False)\n\n    # Add a table at the bottom of the axes\n    tab = plt.table(cellText=celltext,\n                          cellColours = cellcolours,\n                          rowLabels=None,\n                          rowColours=None,\n                          colLabels=None,\n                          cellLoc='center',\n                          loc='center')\n\n    for key, cell in tab.get_celld().items():\n        cell.set_linewidth(0)\n\n    tab.set_fontsize(14)\n    tab.scale(1.5, 1.5)  # may help\n\n    # Adjust layout to make room for the table:\n    #plt.subplots_adjust(left=0.2, bottom=0.2)\n\n    #plt.ylabel(\"Loss in ${0}'s\".format(value_increment))\n    plt.yticks([])\n    plt.xticks([])\n    plt.title('')\n    plt.axis('off')\n    plt.grid('off')\n    if save_path:\n        plt.savefig(save_path + '_expl.pdf', bbox_inches = 'tight', format='pdf', dpi=300)\n    plt.show()\n\n\nclass FeatureInput_Explainer():\n    \"\"\"\n        Explainer for classification task models that take vector of features\n        as input and and return class probs.\n\n        Arguments:\n\n\n    \"\"\"\n    def __init__(self, feature_names, binary = False, sort_rows = True, scale_values = True):\n        super(FeatureInput_Explainer, self).__init__()\n        self.features = feature_names\n        self.binary   = binary # Whether it is a binary classif task\n        self.sort_rows = sort_rows\n        self.scale_values = scale_values\n\n    def explain(self, model, x, thresh = 0.5, save_path = None):\n        np.set_printoptions(threshold=15, precision = 2)\n        #print('input: {}'.format(x.data.numpy()))\n        print('Input:')\n        pp.pprint(dict(zip(self.features, *x.data.numpy())))\n        print('')\n\n        np.set_printoptions()\n        y_pred = model(x)\n        pred_class = np.argmax(y_pred.data.numpy())\n        print('Predicted: ',pred_class)\n\n        # Get data-dependent params\n        B = model.thetas[0,:,:].data.numpy() # class x feats\n\n        Pos_Mask = (B > thresh).astype(np.int)#.reshape(x.size()).squeeze()\n        Neg_Mask = (B < thresh).astype(np.int)#.reshape(x.size()).squeeze()\n\n        title = r'Relevance Score $\\theta(x)$' + (' (Scaled)' if self.scale_values else '')\n        if self.binary:\n            d = dict(zip(self.features, B[:,0])) # Change to B[0,:] when B model is truly binary\n            A = plot_dependencies(d, title= title,\n                                     scale_values = self.scale_values,\n                                     sort_rows = self.sort_rows)\n        else:\n            Pos_Feats = {}\n            for k in range(B.shape[0]):\n                d = dict(zip(self.features, B[k,:])) # Change to B[0,:] when B model is truly binary\n                A = plot_dependencies(d, title= title,\n                                         scale_values = self.scale_values,\n                                         sort_rows = self.sort_rows)\n                Neg_Feats = list(compress(self.features, B[k,:] < -thresh))\n                Pos_Feats = list(compress(self.features, B[k,:] > thresh))\n                print('Class:{:5} Neg: {}, Pos: {}'.format(k, ','.join(Neg_Feats), ','.join(Pos_Feats)))\n        if save_path:\n            plt.savefig(save_path, bbox_inches = 'tight', format='pdf', dpi=300)\n        plt.show()\n        print('-'*60)\n\n    def _explain_class(self, x_raw, x,k,typ='pos',feat_names = None, thresh = 0.5,recompute=True):\n        \"\"\"\n            Given an input x and class index k, explain f(x) by returning indices of\n            features in x that have highest positive impact on predicting class k.\n        \"\"\"\n        if recompute:\n            y = model(x) # y = self.model(x)\n        B_k = model.params[0,k,:].data.numpy()\n        #print((B_k > thresh).astype(np.int))\n\n        if feat_names and typ == 'pos':\n            # Return masked features instead of values\n            return list(compress(feat_names, B_k > thresh ))\n        elif feat_names and typ == 'neg':\n            return list(compress(feat_names, B_k < thresh ))\n        if typ == 'pos':\n            Mask = (B_k > thresh).astype(np.int).reshape(x.size()).squeeze()\n        elif typ == 'neg':\n            Mask = (B_k < -thresh).astype(np.int).reshape(x.size()).squeeze()\n        else:\n            # Return weights instead of mask\n            return B_k.reshape(x.size()).squeeze()\n\n        Masked_x = Mask*x_raw.numpy().squeeze()\n        return Masked_x\n\ndef plot_dependencies(dictionary_values,\n                      pos_color=\"#ff4d4d\",\n                      negative_color=\"#3DE8F7\",\n                      reverse_values=False,\n                      sort_rows =True,\n                      scale_values = True,\n                      title=\"\",\n                      fig_size=(4, 4),\n                      ax = None,\n                      x = None,\n                      digits = 1, prediction_text = None,\n                      show_table = False, ax_table = None):\n    \"\"\" This function was adapted form the fairml python package\n\n        x needed only if show_table = True\n\n        digits: (int) significant digits in table\n    \"\"\"\n    # add check to make sure that dependence features are not zeros\n    if np.sum(np.array(dictionary_values.values())) == 0.0:\n        print(\"Feature dependence for all attributes equal zero.\"\n              \" There is nothing to plot here. \")\n        return None\n\n    column_names = list(dictionary_values.keys())\n    coefficient_values = list(dictionary_values.values())\n\n    # get maximum\n    maximum_value = np.absolute(np.array(coefficient_values)).max()\n    if scale_values:\n        coefficient_values = ((np.array(coefficient_values) \/ maximum_value) * 100)\n\n    if sort_rows:\n        index_sorted = np.argsort(np.array(coefficient_values))\n    else:\n        index_sorted = range(len(coefficient_values))[::-1]\n\n    sorted_column_names = list(np.array(column_names)[index_sorted])\n    sorted_column_values = list(np.array(coefficient_values)[index_sorted])\n    pos = np.arange(len(sorted_column_values)) + 0.7\n\n    # rearrange this at some other point.\n    def assign_colors_to_bars(array_values,\n                              pos_influence=pos_color,\n                              negative_influence=negative_color,\n                              reverse=reverse_values):\n\n        # if you want the colors to be reversed for positive\n        # and negative influences.\n        if reverse:\n            pos_influence, negative_influence = (negative_influence,\n                                                 pos_influence)\n\n        # could rewrite this as a lambda function\n        # but I understand this better\n        def map_x(x):\n            if x > 0:\n                return pos_influence\n            else:\n                return negative_influence\n        bar_colors = list(map(map_x, array_values))\n        return bar_colors\n\n    bar_colors = assign_colors_to_bars(coefficient_values, reverse=True)\n    bar_colors = list(np.array(bar_colors)[index_sorted])\n\n    #pdb.set_trace()\n    if ax is None and not show_table:\n        #pdb.set_trace()\n        fig, ax = plt.subplots(figsize=fig_size)\n    elif ax is None and show_table:\n        fig, axes = plt.subplots(1, 2, figsize=fig_size)\n        ax_table, ax = axes\n\n    ax.barh(pos, sorted_column_values, align='center', color=bar_colors)\n    ax.set_yticks(pos)\n    ax.set_yticklabels(sorted_column_names)\n    if scale_values:\n        ax.set_xlim(-105, 105)\n    else:\n        pass\n        #ax.set_xlim(-1.05, 1.05)\n    if title:\n        ax.set_title(\"{}\".format(title))\n\n    if show_table and ax_table:\n        cell_text = [[('%1.' + str(digits) + 'f') % v] for v in x]\n        if prediction_text is None:\n            ax_table.axis('off')\n        else:\n            print('here')\n            ax_table.set_xticklabels([])\n            ax_table.set_yticklabels([])\n            ax_table.set_yticks([])\n            ax_table.set_xticks([])\n            for side in ['top', 'right', 'bottom', 'left']:\n                ax_table.spines[side].set_visible(False)\n            ax_table.set_xlabel(prediction_text)\n\n        ax_table.table(cellText=cell_text,\n                                  rowLabels=sorted_column_names[::-1],\n                                  rowColours=bar_colors[::-1],\n                                  colLabels=None,#['Value'],\n                                  colWidths=[1],\n                                  loc='left', cellLoc = 'right',\n                                  bbox=[0.2, 0.025, 0.95, 0.95])\n        ax_table.set_title('Input Value')\n        return ax, ax_table\n\n    return ax\n\n\ndef plot_theta_stability(model, input, pert_type = 'gauss', noise_level = 0.5,\n                         samples = 5, save_path = None):\n    \"\"\" Test stability of relevance scores theta for perturbations of an input.\n\n        If model is of type 1 (i.e. theta is of dimension nconcepts x nclass), visualizes\n        the perturbations of dependencies with respect to predicted class.\n\n        If model is of type 1\/3 (theta is a vector of size nconcepts), then there's only\n        one dimension of theta to visualize.\n\n        Args:\n            model (GSENN): GSENN model.\n            inputs (list of tensors): Inputs over which stability will be tested. First one is \"base\" input.\n\n        Returns:\n            stability: scalar.\n\n        Displays plot also.\n\n    \"\"\"\n    def gauss_perturbation(x, scale = 1):\n        noise = Variable(scale*torch.randn(x.size()), volatile = True)\n        if x.is_cuda:\n            noise = noise.cuda()\n        return x + noise\n\n    model.eval()\n\n    # Generate perturbations\n    inputs = [input]\n    for i in range(samples):\n        inputs.append(gauss_perturbation(input, scale=noise_level))\n\n    fig, ax = plt.subplots(2,len(inputs),figsize=(2*len(inputs),1.5*3))\n\n    # Map Them\n    thetas = []\n    dists  = []\n    for i,x in enumerate(inputs):\n        pred = model(x)\n        ax[0,i].imshow(x.data.cpu().numpy().squeeze())#, cmap = 'Greys', interpolation = 'nearest')\n        ax[0,i].set_xticks([])\n        ax[0,i].set_yticks([])\n        if i == 0:\n            ax[0,i].set_title('Original'.format(i))\n        else:\n            ax[0,i].set_title('Perturbation {}'.format(i))\n\n\n\n        theta = model.thetas.data.cpu().numpy().squeeze()\n        if theta.shape[1] > 1:\n            # Means this is model 1, scalar h and theta_i vector-sized. Choose which one ti visualize\n            klass = pred.data.max(1)[1] # Predicted class\n            deps = theta[:,klass].squeeze()\n            thetas.append(deps)\n        else:\n            deps = theta\n            thetas.append(deps)\n        classes = ['C' + str(i) for i in range(theta.shape[0])]\n        d = dict(zip(classes, deps))\n        A = plot_dependencies(d, title= 'Dependencies', sort_rows = False, ax = ax[1,i])\n        #ax[1,i].locator_params(axis = 'y', nbins=10)\n\n        # max_yticks = 10\n        # yloc = plt.MaxNLocator(max_yticks)\n        # ax[1,i].yaxis.set_major_locator(yloc)\n        #print(thetas[-1])\n        if i > 0:\n            dists.append(np.linalg.norm(thetas[0] - deps))\n\n    dists = np.array(dists)\n    plt.tight_layout()\n    #print(dists.max())\n    if save_path:\n        plt.savefig(save_path, bbox_inches = 'tight', format='pdf', dpi=300)\n    #plt.show(block=False)\n\n\ndef concept_grid(model, data_loader, cuda=False, top_k = 6, layout = 'vertical', return_fig=False, save_path = None):\n    \"\"\"\n        Finds examples in data_loader that are most representatives of concepts.\n\n        For scalar concepts, activation is simply the value of the concept.\n        For vector concepts, activation is the norm of the concept.\n\n    \"\"\"\n    print('Warning: make sure data_loader passed to this function doesnt shuffle data!!')\n    all_norms = []\n    num_concepts = model.parametrizer.nconcept\n    concept_dim  = model.parametrizer.dout\n\n    top_activations = {k: np.array(top_k*[-1000.00]) for k in range(num_concepts)}\n    top_examples = {k: top_k*[None] for k in range(num_concepts)}\n    all_activs = []\n    for idx, (data, target) in enumerate(data_loader):\n        # get the inputs\n        if cuda:\n            data, target = data.cuda(), target.cuda()\n        data, target = Variable(data, volatile=True), Variable(target)\n        output = model(data)\n        concepts = model.concepts.data\n        #pdb.set_trace()\n        #concepts[concepts < 0] = 0.0 # This is unncessary if output of H is designed to be > 0.\n        if concepts.shape[-1] > 1:\n            print('ERROR')\n            print(asd.asd)\n            activations = np.linalg.norm(concepts, axis = 2)\n        else:\n            activations = concepts\n\n        all_activs.append(activations)\n        # if idx == 10:\n        #     break\n\n    all_activs = torch.cat(all_activs)\n    top_activations, top_idxs = torch.topk(all_activs, top_k, 0)\n    top_activations = top_activations.squeeze().t()\n    top_idxs = top_idxs.squeeze().t()\n    top_examples = {}\n    for i in range(num_concepts):\n        top_examples[i] = data_loader.dataset.test_data[top_idxs[i]]\n    #top_examples =\n\n\n    # Before, i was doing this manually :\n        # for i in range(activations.shape[0]):\n        #     #pdb.set_trace()\n        #     for j in range(num_concepts):\n        #         min_val  = top_activations[j].min()\n        #         min_idx  = top_activations[j].argmin()\n        #         if activations[i,j] >  min_val:\n        #             # Put new one in place of min\n        #             top_activations[j][min_idx]  = activations[i,j]\n        #             top_examples[j][min_idx] = data[i, :, :, :].data.numpy().squeeze()\n        #     #pdb.set_trace()\n    # for k in range(num_concepts):\n    #     #print(k)\n    #     Z = [(v,e) for v,e in sorted(zip(top_activations[k],top_examples[k]),  key=lambda x: x[0], reverse = True)]\n    #     top_activations[k], top_examples[k] = zip(*Z)\n\n    if layout == 'horizontal':\n        num_cols = top_k\n        num_rows = num_concepts\n        figsize=(num_cols, 1.2*num_rows)\n    else:\n        num_cols = num_concepts\n        num_rows = top_k\n        figsize=(1.4*num_cols, num_rows)\n\n    fig, axes  = plt.subplots(figsize=figsize, nrows=num_rows, ncols=num_cols )\n\n    for i in range(num_concepts):\n        for j in range(top_k):\n            pos = (i,j) if layout == 'horizontal' else (j,i)\n\n            l = i*top_k + j\n            #print(i,j)\n            #print(top_examples[i][j].shape)\n            axes[pos].imshow(top_examples[i][j], cmap='Greys',  interpolation='nearest')\n            if layout == 'vertical':\n                axes[pos].axis('off')\n                if j == 0:\n                    axes[pos].set_title('Cpt {}'.format(i+1), fontsize = 24)\n            else:\n                axes[pos].set_xticklabels([])\n                axes[pos].set_yticklabels([])\n                axes[pos].set_yticks([])\n                axes[pos].set_xticks([])\n                for side in ['top', 'right', 'bottom', 'left']:\n                    axes[i,j].spines[side].set_visible(False)\n                if i == 0:\n                    axes[pos].set_title('Proto {}'.format(j+1))\n                if j == 0:\n                    axes[pos].set_ylabel('Concept {}'.format(i+1), rotation = 90)\n\n    print('Done')\n\n    # cols = ['Prot.{}'.format(col) for col in range(1, num_cols + 1)]\n    # rows = ['Concept # {}'.format(row) for row in range(1, num_rows + 1)]\n    #\n    # for ax, col in zip(axes[0], cols):\n    #     ax.set_title(col)\n    #\n    # for ax, row in zip(axes[:,0], rows):\n    #     ax.set_ylabel(row, rotation=0, size='large')\n    #plt.tight_layout()\n\n    if layout == 'vertical':\n        fig.subplots_adjust(wspace=0.01, hspace=0.1)\n    else:\n        fig.subplots_adjust(wspace=0.1, hspace=0.01)\n\n    if save_path is not None:\n        plt.savefig(save_path, bbox_inches = 'tight', format='pdf', dpi=300)\n    plt.show()\n    if return_fig:\n        return fig, axes\n\n\ndef plot_prob_drop(attribs, prob_drop, save_path = None):\n\n    ind = np.arange(len(attribs))\n    column_names = [str(j) for j in range(1,22)]\n\n    width = 0.65\n\n    fig, ax1 = plt.subplots(figsize=(8,4))\n\n    color1 = '#377eb8'\n    ax1.bar(ind+width+0.35, attribs, 0.45, color=color1)\n    ax1.set_ylabel(r'Feature Relevance $\\theta(x)_i$',color=color1, fontsize = 14)\n    #ax1.set_ylim(-1,1)\n    ax1.set_xlabel('Feature')\n    ax1.tick_params(axis='y', colors=color1)\n\n\n    color2 = '#ff7f00'\n    ax2 = ax1.twinx()\n    ax2.ticklabel_format(style='sci',scilimits=(-2,2),axis = 'y')\n    ax2.plot(ind+width+0.35, prob_drop, 'bo', linestyle='dashed', color=color2)\n    ax2.set_ylabel('Probability Drop', color = color2, fontsize = 14)\n    ax2.tick_params(axis='y', colors=color2)\n\n\n    ax1.set_xticks(ind+width+(width\/2))\n    ax1.set_xticklabels(column_names)\n\n    fig.tight_layout()\n    if save_path:\n        plt.savefig(save_path, bbox_inches = 'tight', format='pdf', dpi=300)\n\n    plt.show()\n\ndef noise_stability_plots(model, dataset, cuda, save_path):\n    # find one example of each digit:\n    examples = {}\n    i = 0\n    while (not len(examples.keys()) == 10) and (i < len(dataset)):\n        if dataset[i][1] not in examples:\n            examples[dataset[i][1]] = dataset[i][0].view(1,1,28,28)\n        i += 1\n\n    for i in range(10):\n        x = Variable(examples[i], volatile = True)\n        if cuda:\n            x = x.cuda()\n        plot_theta_stability(model, x, noise_level = 0.5,\n                save_path=save_path + '\/noise_stability_{}.pdf'.format(i))\n\ndef plot_digit(x, ax = None, greys = True):\n    if ax is None:\n        fig, ax = plt.subplots()\n    if type(x) is torch.Tensor:\n        x = x.numpy()\n    if x.ndim > 2:\n        x = x.squeeze()\n    if greys:\n        ax.imshow(x, cmap='Greys')\n    else:\n        ax.imshow(x)\n    ax.axis('off')\n    ax.set_xticklabels([])\n    ax.set_yticklabels([])\n\n\n\ndef opt_concept_func(x, model, i, accumulator):\n    x = torch.from_numpy(x).float()\n    x = x.reshape(28,28)[None, None, :, :]\n    accumulator.append(x)\n    # printing the process\n    if len(accumulator) % 5000 == 0:\n        print(len(accumulator), \" rounds so far.\")\n    return torch.sum(model.conceptizer.encode(x).squeeze()[:, None]).numpy() - model.conceptizer.encode(x).squeeze()[:, None][i].numpy()\n\n\ndef get_concept_vis(model, nconcepts):\n    convis = list()\n    for i in range(nconcepts):\n        print(\"Concept: (\" , str(i+1), \"\/\", str(nconcepts), \")\")\n        # normalized random image as specified in the load minst function in main_mnist.py\n        randimg = torch.normal(0.1307, 0.3081, size=(28,28))[None, :, :]\n        # Start with zeros\n        # randimg = torch.zeros(28,28)[None, :, :]\n        accumulator = list()\n        optimize.minimize(opt_concept_func, randimg, args=(model, i, accumulator))\n        convis.append(accumulator[-1])\n        print(\"Concept: \" , str(i), \" done! \", str(len(accumulator)), \" rounds needed.\")\n\n    return convis\n\n\ndef plot_concept_vis(model, nconcepts, cols, rows):\n    convis = get_concept_vis(model, nconcepts)\n    fig=plt.figure(figsize=(8, 8))\n\n    for i in range(nconcepts):\n        ax = fig.add_subplot(cols, rows, i+1)\n        ax.imshow(convis[i].squeeze())\n    plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_538","text":"<reponame>yifan-you-37\/rl_swiss\nimport joblib\n\nimport numpy as np\nfrom numpy.random import choice, randint\n\nfrom rlkit.data_management.env_replay_buffer import get_dim as gym_get_dim\nfrom rlkit.data_management.simple_replay_buffer import SimpleReplayBuffer\nfrom rlkit.envs.maze_envs.trivial_grid import TrivialGrid\nfrom rlkit.envs.maze_envs.pogrid import PartiallyObservedGrid\nfrom rlkit.envs.maze_envs.mem_map_grid import MemoryGrid\n\n\nclass RandomGridPolicy():\n    def __init__(self, max_num_consecutive):\n        self.max_num_consecutive = max_num_consecutive\n        self.cur_act = randint(4)\n        self.num_left = randint(max_num_consecutive) + 1\n\n\n    def get_action(self, obs, *args):\n        if self.num_left == 0:\n            self.num_left = randint(self.max_num_consecutive) + 1\n            self.cur_act = randint(4)\n        self.num_left -= 1\n        return self.cur_act\n\n    def reset(self):\n        pass\n\n\nclass ListPolicy():\n    def __init__(self, act_list):\n        self.act_list = act_list\n        self.ptr = 0\n\n    def get_action(self, obs, *args):\n        a = self.act_list[self.ptr]\n        self.ptr = (self.ptr + 1) % len(self.act_list)\n        return a\n\n    def reset(self):\n        self.ptr = 0\n\n\ndef generate_transitions(policy, env, num_timesteps_total, max_steps_per_episode, save_path): \n    buff = SimpleReplayBuffer(\n        num_timesteps_total, env.observation_space.shape,\n        gym_get_dim(env.action_space), discrete_action_dim=True\n    )\n\n    cur_total = 0\n    steps_left_in_episode = 0\n    while cur_total != num_timesteps_total:\n        if steps_left_in_episode == 0:\n            steps_left_in_episode = max_steps_per_episode\n            obs = env.reset()\n        \n        act = policy.get_action(obs)\n        next_obs, rew, done, _ = env.step(act)\n        buff.add_sample(obs, act, rew, done, next_obs)\n\n        obs = next_obs\n        cur_total += 1\n        steps_left_in_episode -= 1\n    \n    save_dict = dict(\n        observations=buff._observations,\n        actions=buff._actions,\n        rewards=buff._rewards,\n        terminals=buff._terminals,\n        next_observations=buff._next_obs,\n    )\n    joblib.dump(save_dict, save_path)\n\n    # debug\n    from scipy.misc import imsave\n    actions = buff._actions\n    observations = buff._observations\n    for i in range(1000):\n        a = actions[i]\n        obs = observations[i]\n        print(a)\n        imsave('junk_vis\/tiny\/mem_grid_{}.png'.format(i), np.transpose(obs, (1,2,0)))\n\n    # for i in range(90, 110):\n    #     a = actions[i]\n    #     obs = observations[i]\n    #     print(a)\n    #     imsave('junk_vis\/maze_{}.png'.format(i), np.transpose(obs, (1,2,0)))\n\n    # for i in range(70, 90):\n    #     a = actions[i]\n    #     obs = observations[i]\n    #     print(a)\n    #     imsave('junk_vis\/maze_{}.png'.format(i), np.transpose(obs, (1,2,0)))\n    \n    # for i in range(110, 130):\n    #     a = actions[i]\n    #     obs = observations[i]\n    #     print(a)\n    #     imsave('junk_vis\/maze_{}.png'.format(i), np.transpose(obs, (1,2,0)))\n\n\nif __name__ == '__main__':\n    # env_specs = {\n    #     'flat_repr': False,\n    #     'one_hot_repr': False,\n    #     'maze_h': 4,\n    #     'maze_w': 4,\n    #     'scale': 1,\n    # }\n    # env = TrivialGrid(env_specs)\n    # policy = RandomGridPolicy(1)\n\n\n    # env_specs = {\n    #     'flat_repr': False,\n    #     'one_hot_repr': False,\n    #     'maze_h': 9,\n    #     'maze_w': 9,\n    #     'obs_h': 5,\n    #     'obs_w': 5,\n    #     'scale': 4,\n    #     'num_objs': 10 \n    # }\n    # act_list = [1, 0, 3, 2]\n    # env = MemoryGrid(env_specs)\n    # policy = ListPolicy(act_list)\n\n    env_specs = {\n        'flat_repr': False,\n        'one_hot_repr': False,\n        'maze_h': 9,\n        'maze_w': 9,\n        'obs_h': 5,\n        'obs_w': 5,\n        'scale': 4,\n        'num_objs': 10 \n    }\n    act_list = [1, 0, 3, 2]\n    env = PartiallyObservedGrid(env_specs)\n    policy = RandomGridPolicy(1)\n\n    generate_transitions(policy, env, 50000, 8, '\/ais\/gobi6\/kamyar\/oorl_rlkit\/maze_trans_data\/pogrid_len_8_scale_4')\n\n\n\n# 32, 128, 512 for 3x3\n# 32, 512, 2048 for 5x5"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_539","text":"<reponame>RedHeadM\/pytorch_segmentation<gh_stars>0\n# Originally written by <NAME>\n# https:\/\/github.com\/kazuto1011\/deeplab-pytorch\n\nfrom base import BaseDataSet, BaseDataLoader\nfrom utils import palette\nimport numpy as np\nimport os\nimport scipy\nimport torch\nfrom PIL import Image\nimport cv2\nfrom torch.utils.data import Dataset\nfrom torchvision import transforms\n\nfrom multiview.video.datasets import ViewPairDataset\nclass MuiltivwDataset(BaseDataSet):\n    \"\"\"\n    Pascal Voc dataset\n    http:\/\/host.robots.ox.ac.uk\/pascal\/VOC\/voc2012\/VOCtrainval_11-May-2012.tar\n    \"\"\"\n    def __init__(self, number_views, view_idx, **kwargs):\n        # self.num_classes = 3\n        self.num_classes = 2+10\n        self.palette = palette.get_voc_palette(self.num_classes)\n        self.number_views = number_views\n        self.view_idx = view_idx\n        if not isinstance(view_idx,int):\n            raise ValueError('view_idx: {}'.format(view_idx))\n        self.view_key_img = \"frames views \" + str(self.view_idx)\n        self.view_key_seg = \"seg \"+str(self.view_idx)\n        assert isinstance(view_idx, int) and isinstance(number_views, int)\n        super(MuiltivwDataset, self).__init__(**kwargs)\n        print('data dir {}, view idx {}, num views'.format(self.root, view_idx, number_views))\n\n    def _set_files(self):\n        def data_len_filter(comm_name,frame_len_paris):\n            if len(frame_len_paris)<2:\n                return frame_len_paris[0]>10\n            return min(*frame_len_paris)>10\n        self.mvbdata = ViewPairDataset(self.root.strip(),\n\t\t\t\t\t    segmentation= True,\n                                            transform_frames= None,\n\t\t\t\t\t    number_views=self.number_views,\n\t\t\t\t\t    filter_func=data_len_filter)\n\n    def __len__(self):\n        return len(self.mvbdata)\n\n    def _load_data(self, index):\n        s = self.mvbdata[index]\n        label = s[self.view_key_seg]\n        image = s[self.view_key_img]\n        image = np.asarray(image, dtype=np.float32)\n        label = np.asarray(label, dtype=np.int32)\n        return image, label, s[\"id\"]\n\nclass MVB(BaseDataLoader):\n    def __init__(self, data_dir, batch_size, split, crop_size=None, base_size=None, scale=True, num_workers=1, val=False,\n                    shuffle=False, flip=False, rotate=False, blur= False, augment=False, val_split= None, return_id=False,\n                    number_views=1, view_idx=None):\n\n        self.MEAN = [0.45734706, 0.43338275, 0.40058118]\n        self.STD = [0.23965294, 0.23532275, 0.2398498]\n        assert view_idx is not None, \"set view idx in config\"\n        kwargs = {\n            'root': data_dir,\n            'split': split,\n            'mean': self.MEAN,\n            'std': self.STD,\n            'augment': augment,\n            'crop_size': crop_size,\n            'base_size': base_size,\n            'scale': scale,\n            'flip': flip,\n            'blur': blur,\n            'rotate': rotate,\n            'return_id': return_id,\n            'val': val\n        }\n\n        self.dataset = MuiltivwDataset(number_views,view_idx,**kwargs)\n        super(MVB, self).__init__(self.dataset, batch_size, shuffle, num_workers, val_split)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_540","text":"\n\n# ===============================================\n#            Foreword\n# ===============================================\n\n\"\"\" This script works as a demonstration how a given audio file can be transformed into speaker embeddings. When working with multiple audio files, \nconsider first creating the MFCC files as described in \"feature extraction\" and then embed the files separately.\n\"\"\"\n\n# ===============================================\n#            Headers\n# ===============================================\n\nimport argparse\nimport os\nimport wavefile\nimport numpy as np\nfrom keras.models import Model, load_model\nfrom keras.layers import *\nfrom keras.constraints import *\nimport tensorflow as tf\nimport keras\nfrom tensorflow.python.keras import backend as K\nfrom librosa.util import frame\nfrom librosa.feature import mfcc\nfrom sklearn import preprocessing\nfrom scipy.optimize import brentq\nfrom sklearn.metrics import roc_curve\nfrom scipy.interpolate import interp1d\n\n\n# ===============================================\n#           Functions\n# ===============================================\n\nclass VLAD(keras.engine.Layer): \n\n    \"\"\"\n    NetVLAD implementation by <NAME> based on\n    the \"NetVLAD: CNN architecture for weakly supervised place recognition\" paper\n    \"\"\"\n\n    def __init__(self, k_centers=8, kernel_initializer='glorot_uniform', **kwargs):\n        self.k_centers = k_centers\n        self.kernel_initializer = initializers.get(kernel_initializer)\n        super(VLAD, self).__init__(**kwargs)\n\n    def build(self, input_shape):\n        self.w = self.add_weight(name='kernel', \n                                      shape=(input_shape[2], self.k_centers),\n                                      initializer=self.kernel_initializer,\n                                      trainable=True)\n        self.b = self.add_weight(name='kernel', \n                                      shape=(self.k_centers, ),\n                                      initializer=self.kernel_initializer,\n                                      trainable=True)\n        self.c = self.add_weight(name='kernel', \n                                      shape=(input_shape[2], self.k_centers),\n                                      initializer=self.kernel_initializer,\n                                      trainable=True)\n        super(VLAD, self).build(input_shape)  \n\n    def call(self, x):\n        \n        Wx_b = K.dot(x, self.w)+self.b\n        a = tf.nn.softmax(Wx_b)\n        \n        rows = []\n\n        for k in range(self.k_centers):\n            error = x-self.c[:, k]\n            \n            row = K.batch_dot(a[:, :, k],error)\n            row = tf.nn.l2_normalize(row,dim=1)\n            rows.append(row)\n            \n        output = tf.stack(rows)\n        output = tf.transpose(output, perm = [1, 0, 2])\n        output = tf.reshape(output, [tf.shape(output)[0], tf.shape(output)[1]*tf.shape(output)[2]])\n        \n          \n        return output\n\n    def compute_output_shape(self, input_shape):\n        return (input_shape[0], self.k_centers*input_shape[2])\n    \n    def get_config(self):\n        config = super(VLAD, self).get_config()\n        config['k_centers'] = self.k_centers\n        config['kernel_initializer'] = initializers.serialize(self.kernel_initializer)\n        return config\n\ndef amsoftmax_loss(y_true, y_pred, scale = 30, margin = 0.35):\n    y_pred = y_pred - y_true*margin\n    y_pred = y_pred*scale\n    return K.categorical_crossentropy(y_true, y_pred, from_logits = True)\n\ndef feature_extractor(s, fs = 16000):\n   mfcc_feat = mfcc(s, n_mfcc = 30, sr = fs, n_fft=512, hop_length=160)  \n   mfcc_feat = preprocessing.scale(mfcc_feat, axis = 1)                        \n   return mfcc_feat\n\ndef EER_calc(cos_dists, labels):\n    fpr, tpr, thresholds = roc_curve(labels, cos_dists, pos_label=1)\n    EER = brentq(lambda x : 1. - x - interp1d(fpr, tpr)(x), 0., 1.)\n    thresh = interp1d(fpr, thresholds)(EER)\n    return EER, threshI\n\n# ===============================================\n#                   MAIN\n# ===============================================\n\nif __name__ == '__main__':\n\n    parser = argparse.ArgumentParser()\n    parser.add_argument(\"--signal\", help=\"Input signal file\", default = \"\/teamwork\/t40511_asr\/p\/spherediar\/data\/augmented_wavs\/signal.npy\")\n    parser.add_argument(\"--frame_len\", type = int, default = 2000, help=\"Frame length in milliseconds\") # Ensure that the frame length is less or equal to the signal duration\n    parser.add_argument(\"--hop_len\",  type = int, default = 500, help=\"Hop length in milliseconds\")\n    parser.add_argument(\"--mode\",  type = int, default = 1, help=\"1: Save all embeddings, 0: Save only the average embedding.\")\n    parser.add_argument(\"--dest\",  default = \"\/teamwork\/t40511_asr\/p\/spherediar\/data\/augmented_wavs\", help=\"Directory to save the embeddings\")\n    parser.add_argument(\"--model\",  default = \"\/teamwork\/t40511_asr\/p\/spherediar\/models\/current_best.h5\", help=\"Model file.\")\n    args = parser.parse_args()\n\n\n    # ===============================================\n    #           Feature extraction\n    # ===============================================\n\n    # Get the type of the signal file \n    file_name = args.signal.split(\"\/\")[-1]\n    file_format = file_name.split(\".\")[1]\n\n    # Load signal - for now, only works with wav or numpy files\n    if file_format == \"npy\":\n        signal = np.load(args.signal)\n    else:\n        (rate,sig) = wavefile.load(args.signal)\n        signal = sig[0]\n\n\n    # Frame and compute MFCCs\n    S = np.transpose(frame(signal, int(args.frame_len*16), int(args.hop_len*16)))  # For now, only 16kHz sampling rate can be used\n    X = list(map(lambda s: feature_extractor(s, 16000), S)) \n    X = np.array(np.swapaxes(X,1, 2))\n    X = X.astype(np.float16) # Compression to save memory, 16-bit MFCCs have also been used in the training of the current_best.h5\n    num_timesteps = X.shape[1]\n\n    # ===============================================\n    #           Embedding extraction\n    # ===============================================\n\n\n    emb_model = load_model(args.model, custom_objects={'VLAD': VLAD, 'amsoftmax_loss': amsoftmax_loss})\n\n    # Modify input shape if necessary\n    if num_timesteps != 201:\n        emb_model.layers.pop(0)\n        new_input = Input(batch_shape=(None,num_timesteps,30)) \n        new_output = emb_model(new_input)\n        emb_model = Model(new_input, new_output)\n\n    # Create embeddings \n    embs = emb_model.predict(X)\n\n    # ===============================================\n    #           Save\n    # ===============================================\n\n    # Get the name of the signal file\n    sig_name = file_name.split(\".\")[0]\n\n    if args.mode == 0:\n        avg_emb = np.mean(embs, axis = 0)\n        avg_emb = avg_emb\/np.sqrt(sum(avg_emb**2))\n        dest_file = os.path.join(args.dest, \"_\".join([sig_name, \"single_emb\", str(args.frame_len), str(args.hop_len)]))\n        np.save(dest_file, avg_emb)\n    else:\n        dest_file = os.path.join(args.dest, \"_\".join([sig_name, \"embs\", str(args.frame_len), str(args.hop_len)]))\n        np.save(dest_file, embs)\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_541","text":"# MIT License\n#\n# Copyright (c) 2022 Quandela\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport concurrent.futures\nimport logging\nimport random\nimport sys\nimport threading\nimport time\n\nimport numpy as np\nfrom scipy.optimize import minimize\n\nimport perceval as pcvl\nimport perceval.lib.phys as phys\n\n\nmapping = {\n    \"HH\": pcvl.FockState([1, 1, 0, 1, 1, 1, 0]),\n    \"HL\": pcvl.FockState([1, 1, 0, 1, 1, 0, 1]),\n    \"LH\": pcvl.FockState([1, 0, 1, 1, 1, 1, 0]),\n    \"LL\": pcvl.FockState([1, 0, 1, 1, 1, 0, 1])\n}\n\nistates = {v: k for k, v in mapping.items()}\nsimulator_backend = pcvl.BackendFactory().get_backend(\"Naive\")\n\n\ndef f_to_minimize(circuit, params, params_value, prob=1):\n    for idx, p in enumerate(params_value):\n        params[idx].set_value(p)\n\n    sim = simulator_backend(circuit.compute_unitary(use_symbolic=False), n=5, mask=[\"1  11  \"])\n    sim.compile(istates.keys())\n    ca = pcvl.CircuitAnalyser(sim, istates, \"*\")\n    ca.compute(expected={\"LH\": \"LL\", \"LL\": \"LH\", \"HH\": \"HH\", \"HL\": \"HL\"})\n    loss = np.sqrt((0.1*(prob-ca.performance))**2+(0.9*ca.error_rate)**2)\n    return loss\n\n\ndef discover(circuit, p, params=None, method=None, init_params=None, bounds=None):\n    if init_params is None:\n        init_params = np.random.randn(len(params))\n\n    minimize(lambda x: f_to_minimize(circuit, params, x, p), init_params, method=method, bounds=bounds)\n\n    sim = simulator_backend(circuit.compute_unitary(use_symbolic=False), n=5, mask=[\"1  11  \"])\n    ca = pcvl.CircuitAnalyser(sim, istates, \"*\")\n    ca.compute(expected={\"LH\": \"LL\", \"LL\": \"LH\", \"HH\": \"HH\", \"HL\": \"HL\"})\n    performance = ca.performance\n    ber = ca.error_rate\n    return ber, performance, ca.pdisplay()\n\n\nglobal_lock = threading.Lock()\nresult_file = sys.stdout  # open(\"result-discovery.txt\", \"w\")\n\n\ndef run_a_discovery(name):\n    logging.info(\"Discovery thread %s: starting\", name)\n    start = time.time()\n\n    # generic interferometer\n    n = 7\n    gen_rect = pcvl.Circuit.generic_interferometer(\n        n,\n        lambda i: random.randint(0, 1) and phys.BS(R=pcvl.P(\"R%d\" % i), phi_b=np.pi, phi_d=0)\n            or phys.BS(R=pcvl.P(\"R%d\" % i)),\n        shape=\"rectangular\",\n        depth=4\n    )\n\n    params = gen_rect.get_parameters()\n    bounds = [p.bounds for p in params]\n\n    (end_ber, end_performance, cadisplay) = discover(gen_rect,\n                                                     0.5,\n                                                     params=params,\n                                                     init_params=[random.random() for _ in params],\n                                                     bounds=bounds)\n    with global_lock:\n        result_file.write(\"time=%f, performance=%f, ber=%f\\n\" % (time.time()-start, end_performance, end_ber))\n        result_file.write(cadisplay+\"\\n\")\n        result_file.write(str(gen_rect.get_parameters())+\"\\n\\n\")\n\n    logging.info(\"Discovery thread %s: ending in %f seconds\", name, time.time()-start)\n\n\nlog_format = \"%(asctime)s: %(message)s\"\nlogging.basicConfig(format=log_format, level=logging.INFO,\n                    datefmt=\"%H:%M:%S\")\n\n# max_works is the number of parallel workers that will be launched\nwith concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:\n    # launch N iterations\n    executor.map(run_a_discovery, range(10))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_542","text":"import skimage.io\nimport skvideo.io\nimport os\nimport h5py\nfrom sklearn.externals import joblib\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.metrics import f1_score\nimport scipy.misc\nimport scipy.signal\nimport numpy as np\nfrom sporco import util\nimport matplotlib.pyplot as plt\nimport pylab as py\nimport glob\nfrom PIL import Image \nimport cv2\nimport sys\n\ndef get_postrainpatches(hdf5_im, hdf5_lab, hdf5_trainset, idx=0, traintest=0):\n  return genericpospatcher(hdf5_im, hdf5_lab, hdf5_trainset, idx=idx, traintest=traintest)\n\ndef genericpospatcher(hdf5_im, hdf5_lab, hdf5_trainset, idx=0, traintest=0):\n  width = 256+40\n  height = 256+40\n\n  lst480p = np.array(glob.glob(\"\/mnt\/hd3\/scenes\/480p\/*avi\"))\n  lst1080p = np.array(glob.glob(\"\/mnt\/hd3\/scenes\/1080p\/*avi\"))\n  lst480p = np.sort(lst480p)\n  lst1080p = np.sort(lst1080p)\n\n  if traintest == 0:\n    lst = np.hstack((lst480p[:575], lst1080p[:215]))\n  else:\n    lst = np.hstack((lst480p[575:], lst1080p[215:]))\n\n  n_samples = len(lst)\n  for jjj, fname in enumerate(lst):\n    print jjj, n_samples\n    vid_pris = skvideo.io.vread(fname, as_grey=True).astype(np.float32)\n    T, H, W, C = vid_pris.shape\n\n    adj_h = H - height\n    adj_w = W - width\n    iv, jv = np.meshgrid(np.arange(adj_h), np.arange(adj_w), sparse=False, indexing='ij')\n    iv = iv.reshape(-1)\n    jv = jv.reshape(-1)\n\n    jdx = np.random.permutation(adj_h*adj_w)\n\n    iv = iv[jdx]\n    jv = jv[jdx]\n    tv = np.arange(0, T-1)\n\n    limit = 0\n    for (y, x) in zip(iv, jv):\n      np.random.shuffle(tv)\n      t = tv[0]\n      goodpatch = vid_pris[t:t+2, y:y+height, x:x+width, 0]\n      badpatch = goodpatch.copy()\n\n      # random amount of change\n      amt = np.random.randint(3, 6)\n      badpatch \/= 2**amt\n      badpatch = np.floor(badpatch)\n      badpatch *= 2**amt\n\n      diff = np.mean((badpatch[0] - goodpatch[0])**2)\n      if diff < 1.5:\n        continue\n      if np.std(badpatch[0]) < 20:\n        continue\n      if np.std(badpatch[1]) < 20:\n        continue\n      #print diff\n      #skimage.io.imsave(\"extract\/test_%d.png\" % (idx,), np.hstack((goodpatch[0].astype(np.uint8), badpatch[0].astype(np.uint8))))\n\n      #preprocess = preprocess_image(badpatch)\n\n      #preprocess = preprocess[:, 5:-5, 5:-5]\n      badpatch = badpatch[:, 20:-20, 20:-20]\n\n      hdf5_im[idx] = badpatch\n      hdf5_lab[idx] = 1\n      hdf5_trainset[idx] = traintest\n\n      #skimage.io.imsave(\"extract\/%d.png\" % (idx,), patch)\n      limit += 1\n      idx += 1\n      if limit >= 25:\n        break\n\n  return idx\n\ndef get_negtrainpatches(image_patches, labels, trainset, idx=0, traintest=0):\n  return genericnegpatcher(image_patches, labels, trainset, idx=idx, traintest=traintest)\n\ndef genericnegpatcher(hdf5_im, hdf5_lab, hdf5_trainset, idx=0, traintest=0):\n  width = 256+40\n  height = 256+40\n\n  lst480p = np.array(glob.glob(\"\/mnt\/hd3\/scenes\/480p\/*avi\"))\n  lst1080p = np.array(glob.glob(\"\/mnt\/hd3\/scenes\/1080p\/*avi\"))\n  lst480p = np.sort(lst480p)\n  lst1080p = np.sort(lst1080p)\n\n  if traintest == 0:\n    lst = np.hstack((lst480p[:575], lst1080p[:215]))\n  else:\n    lst = np.hstack((lst480p[575:], lst1080p[215:]))\n\n  n_samples = len(lst)\n  for jjj, fname in enumerate(lst):\n    print jjj, n_samples\n    vid_pris = skvideo.io.vread(fname, as_grey=True).astype(np.float32)\n    T, H, W, C = vid_pris.shape\n\n    adj_h = H - height\n    adj_w = W - width\n    iv, jv = np.meshgrid(np.arange(adj_h), np.arange(adj_w), sparse=False, indexing='ij')\n    iv = iv.reshape(-1)\n    jv = jv.reshape(-1)\n\n    jdx = np.random.permutation(adj_h*adj_w)\n\n    iv = iv[jdx]\n    jv = jv[jdx]\n    tv = np.arange(0, T-1)\n\n    limit = 0\n    for (y, x) in zip(iv, jv):\n      np.random.shuffle(tv)\n      t = tv[0]\n      goodpatch = vid_pris[t:t+2, y:y+height, x:x+width, 0]\n\n      #preprocess = preprocess[:, 5:-5, 5:-5]\n      goodpatch = goodpatch[:, 20:-20, 20:-20]\n      #if np.std(goodpatch[0]) < 20:\n      #  continue\n      #if np.std(goodpatch[1]) < 20:\n      #  continue\n\n      hdf5_im[idx] = goodpatch\n      hdf5_lab[idx] = 0\n      hdf5_trainset[idx] = traintest\n\n      #skimage.io.imsave(\"extract\/%d.png\" % (idx,), patch)\n      limit += 1\n      idx += 1\n      if limit >= 25:\n        break\n\n  return idx\n\n# get the number of patches\nnp.random.seed(12345)\n\nn_total_images = 64925#12000\npatch_height = 256\npatch_width = 256\nn_channels = 2\n\n# sf = single frame\n# fd = frame diff\nf = h5py.File('bandingdataset_sf.hdf5', mode='w')\n\nimage_patches = f.create_dataset('image_patches', (n_total_images, n_channels, patch_height, patch_width), dtype='float')\nimage_patches.dims[0].label = 'batch'\nimage_patches.dims[1].label = 'channel'\nimage_patches.dims[2].label = 'height'\nimage_patches.dims[3].label = 'width'\n\nlabels = f.create_dataset('labels', (n_total_images,), dtype='uint8')\ntrainset = f.create_dataset('set', (n_total_images,), dtype='uint8')\n\nn_idx = 0\nn_idx = get_postrainpatches(image_patches, labels, trainset, n_idx, 0)\nn_idx = get_negtrainpatches(image_patches, labels, trainset, n_idx, 0)\nn_idx = get_postrainpatches(image_patches, labels, trainset, n_idx, 1)\nn_idx = get_negtrainpatches(image_patches, labels, trainset, n_idx, 1)\n\nprint n_idx, n_total_images\n\nf.flush()\nf.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_543","text":"import MWPotential2014Likelihood\nimport astropy.units as u\nimport gd1_util\nimport hypothesis\nimport numpy\nimport numpy as np\nimport numpy as np\nimport pickle\nimport torch\n\nfrom galpy.orbit import Orbit\nfrom galpy.potential import MWPotential2014, turn_physical_off, vcirc\nfrom galpy.util import bovy_conversion, bovy_coords, save_pickles, bovy_plot\nfrom gd1_util_MWhaloshape import lb_to_phi12\nfrom scipy import integrate, interpolate\nfrom scipy.integrate import quad\nfrom torch.distributions.uniform import Uniform\n\n\n\ndef allocate_prior_stream_age():\n    lower = torch.tensor(3).float().to(hypothesis.accelerator)\n    upper = torch.tensor(7).float().to(hypothesis.accelerator)\n\n    return Uniform(lower, upper)\n\n\ndef allocate_prior_wdm_mass():\n    lower = torch.tensor(1).float().to(hypothesis.accelerator)\n    upper = torch.tensor(50).float().to(hypothesis.accelerator)\n\n    return Uniform(lower, upper)\n\n\ndef load_observed_gd1(path, phi, degree=1):\n    data = np.genfromtxt(path, names=True)\n    phi_max = max(phi) + 5 # For stability in fitting the splines\n    phi_min = min(phi) - 5 # For stability in fitting the splines\n    phi_data = data[\"phi1mid\"]\n    if phi_min < min(phi_data) or phi_max > max(phi_data):\n        raise ValueError(\"Angles not supported by observation.\")\n    indices = (phi_data <= phi_max) & (phi_data >= phi_min)\n    phi_data = phi_data[indices]\n    linear_density = data[\"lindens\"][indices]\n    error = data[\"e_lindens\"][indices]\n    trend = np.polyfit(phi_data, linear_density, deg=degree)\n    fitted = np.poly1d(trend)(phi_data)\n    error \/= fitted\n    linear_density \/= fitted\n    # Fit a spline and extract the requested values\n    l = np.array(linear_density)\n    fit_density = interpolate.InterpolatedUnivariateSpline(phi_data, linear_density)\n    fit_error = interpolate.InterpolatedUnivariateSpline(phi_data, error)\n    linear_density = fit_density(phi)\n    trend = np.polyfit(phi, linear_density, deg=degree)\n    fitted = np.poly1d(trend)(phi)\n    linear_density \/= fitted\n    error = fit_error(phi)\n    error \/= fitted\n\n    return linear_density, error\n\n\nh=0.6774\nro=8.\nvo=220.\n\n\ndef parse_times(times,age):\n    if 'sampling' in times:\n        nsam= int(times.split('sampling')[0])\n        return [float(ti)\/bovy_conversion.time_in_Gyr(vo,ro)\n                for ti in np.arange(1,nsam+1)\/(nsam+1.)*age]\n    return [float(ti)\/bovy_conversion.time_in_Gyr(vo,ro)\n            for ti in times.split(',')]\n\n\ndef parse_mass(mass):\n    return [float(m) for m in mass.split(',')]\n\n\ndef nsubhalo(m):\n    return 0.3*(10.**6.5\/m)\n\n\ndef rs(m,plummer=False,rsfac=1.):\n    if plummer:\n        #print ('Plummer')\n        return 1.62*rsfac\/ro*(m\/10.**8.)**0.5\n    else:\n        return 1.05*rsfac\/ro*(m\/10.**8.)**0.5\n\n\ndef alpha(m_wdm):\n    return (0.048\/h)*(m_wdm)**(-1.11) #in Mpc , m_wdm in keV\n\n\ndef lambda_hm(m_wdm):\n    nu=1.12\n    return 2*numpy.pi*alpha(m_wdm)\/(2**(nu\/5.) - 1.)**(1\/(2*nu))\n\n\ndef M_hm(m_wdm):\n    Om_m=0.3089\n    rho_c=1.27*10**11 #Msun\/Mpc^3\n    rho_bar=Om_m*rho_c\n    return (4*numpy.pi\/3)*rho_bar*(lambda_hm(m_wdm)\/2.)**3\n\n\ndef Einasto(r):\n    al=0.678 #alpha_shape\n    rm2=199 #kpc, see Erkal et al 1606.04946 for scaling to M^1\/3\n    return numpy.exp((-2.\/al)*((r\/rm2)**al -1.))*4*numpy.pi*(r**2)\n\n\ndef dndM_cdm(M,c0kpc=2.02*10**(-13),mf_slope=-1.9):\n    #c0kpc=2.02*10**(-13) #Msun^-1 kpc^-3 from Denis' paper\n    m0=2.52*10**7 #Msun from Denis' paper\n    return c0kpc*((M\/m0)**mf_slope)\n\n\ndef fac(M,m_wdm):\n    beta=-0.99\n    gamma=2.7\n    return (1.+gamma*(M_hm(m_wdm)\/M))**beta\n\n\ndef dndM_wdm(M,m_wdm,c0kpc=2.02*10**(-13),mf_slope=-1.9):\n    return fac(M,m_wdm)*dndM_cdm(M,c0kpc=c0kpc,mf_slope=mf_slope)\n\n\ndef nsub_cdm(M1,M2,r=20.,c0kpc=2.02*10**(-13),mf_slope=-1.9):\n    #number density of subhalos in kpc^-3\n    m1=10**(M1)\n    m2=10**(M2)\n    return integrate.quad(dndM_cdm,m1,m2,args=(c0kpc,mf_slope))[0]*integrate.quad(Einasto,0.,r)[0]*(8.**3.)\/(4*numpy.pi*(r**3)\/3) #in Galpy units\n\n\ndef nsub_wdm(M1,M2,m_wdm,r=20.,c0kpc=2.02*10**(-13),mf_slope=-1.9):\n    m1=10**(M1)\n    m2=10**(M2)\n    return integrate.quad(dndM_wdm,m1,m2,args=(m_wdm,c0kpc,mf_slope))[0]*integrate.quad(Einasto,0.,r)[0]*(8.**3)\/(4*numpy.pi*(r**3)\/3) #in Galpy units\n\n\ndef simulate_subhalos_mwdm(sdf_pepper,m_wdm,mf_slope=-1.9,c0kpc=2.02*10**(-13),r=20.,Xrs=5.,sigma=120.\/220.):\n\n    Mbin_edge=[5.,6.,7.,8.,9.]\n    Nbins=len(Mbin_edge)-1\n    #compute number of subhalos in each mass bin\n    nden_bin=np.empty(Nbins)\n    rate_bin=np.empty(Nbins)\n    for ll in range(Nbins):\n        nden_bin[ll]=nsub_wdm(Mbin_edge[ll],Mbin_edge[ll+1],m_wdm=m_wdm,r=r,c0kpc=c0kpc,mf_slope=mf_slope)\n        Mmid=10**(0.5*(Mbin_edge[ll]+Mbin_edge[ll+1]))\n        rate_bin[ll]=sdf_pepper.subhalo_encounters(sigma=sigma,nsubhalo=nden_bin[ll],bmax=Xrs*rs(Mmid,plummer=True))\n\n    rate = np.sum(rate_bin)\n\n    Nimpact= numpy.random.poisson(rate)\n\n    norm= 1.\/quad(lambda M : fac(M,m_wdm)*((M)**(mf_slope +0.5)),10**(Mbin_edge[0]),10**(Mbin_edge[Nbins]))[0]\n\n    def cdf(M):\n        return quad(lambda M : norm*fac(M,m_wdm)*(M)**(mf_slope +0.5),10**Mbin_edge[0],M)[0]\n\n    MM=numpy.linspace(Mbin_edge[0],Mbin_edge[Nbins],10000)\n\n    cdfl=[cdf(i) for i in 10**MM]\n    icdf= interpolate.InterpolatedUnivariateSpline(cdfl,10**MM,k=1)\n    timpact_sub= numpy.array(sdf_pepper._uniq_timpact)[numpy.random.choice(len(sdf_pepper._uniq_timpact),size=Nimpact,\n                                p=sdf_pepper._ptimpact)]\n    # Sample angles from the part of the stream that existed then\n    impact_angle_sub= numpy.array([sdf_pepper._icdf_stream_len[ti](numpy.random.uniform())\n            for ti in timpact_sub])\n\n    sample_GM=lambda: icdf(numpy.random.uniform())\/bovy_conversion.mass_in_msol(vo,ro)\n    GM_sub= numpy.array([sample_GM() for a in impact_angle_sub])\n    rs_sub= numpy.array([rs(gm*bovy_conversion.mass_in_msol(vo,ro)) for gm in GM_sub])\n    # impact b\n    impactb_sub= (2.*numpy.random.uniform(size=len(impact_angle_sub))-1.)*Xrs*rs_sub\n    # velocity\n    subhalovel_sub= numpy.empty((len(impact_angle_sub),3))\n    for ii in range(len(timpact_sub)):\n        subhalovel_sub[ii]=sdf_pepper._draw_impact_velocities(timpact_sub[ii],sigma,impact_angle_sub[ii],n=1)[0]\n    # Flip angle sign if necessary\n    if not sdf_pepper._gap_leading: impact_angle_sub*= -1.\n\n    return impact_angle_sub,impactb_sub,subhalovel_sub,timpact_sub,GM_sub,rs_sub\n\n\ndef compute_obs_density_no_interpolation(phi1, apars, dens_apar):\n    apar_edge=[]\n    phi1_edge=[]\n\n    abw0=apars[1]-apars[0]\n    apar_edge.append(apars[0]-(abw0\/2.))\n\n    phi1bw0=phi1[1]-phi1[0]\n    phi1_edge.append(phi1[0]-(phi1bw0\/2.))\n\n    for ii in range(len(apars)-1):\n        abw=apars[ii+1]-apars[ii]\n        phi1bw=phi1[ii+1]-phi1[ii]\n        apar_edge.append(apars[ii]+abw\/2.)\n        phi1_edge.append(phi1[ii]+phi1bw\/2.)\n\n    abw_last=apars[len(apars)-1]-apars[len(apars)-2]\n    apar_edge.append(apars[len(apars)-1]+(abw_last\/2.))\n\n    phi1bw_last=phi1[len(phi1)-1]-phi1[len(phi1)-2]\n    phi1_edge.append(phi1[len(phi1)-1]+(phi1bw_last\/2.))\n\n    #compute the Jacobian d(apar)\/d(phi1) using finite difference method\n    dapar_dphi1=np.fabs(numpy.diff(apar_edge)\/numpy.diff(phi1_edge))\n    density = dens_apar * dapar_dphi1\n\n    return density\n\n\ndef compute_obs_density(phi1,apars,dens_apar,Omega):\n\n    apar_edge=[]\n    phi1_edge=[]\n\n    abw0=apars[1]-apars[0]\n    apar_edge.append(apars[0]-(abw0\/2.))\n\n    phi1bw0=phi1[1]-phi1[0]\n    phi1_edge.append(phi1[0]-(phi1bw0\/2.))\n\n    for ii in range(len(apars)-1):\n        abw=apars[ii+1]-apars[ii]\n        phi1bw=phi1[ii+1]-phi1[ii]\n        apar_edge.append(apars[ii]+abw\/2.)\n        phi1_edge.append(phi1[ii]+phi1bw\/2.)\n\n    abw_last=apars[len(apars)-1]-apars[len(apars)-2]\n    apar_edge.append(apars[len(apars)-1]+(abw_last\/2.))\n\n    phi1bw_last=phi1[len(phi1)-1]-phi1[len(phi1)-2]\n    phi1_edge.append(phi1[len(phi1)-1]+(phi1bw_last\/2.))\n\n    #compute the Jacobian d(apar)\/d(phi1) using finite difference method\n    dapar_dphi1=np.fabs(numpy.diff(apar_edge)\/numpy.diff(phi1_edge))\n    #print (dapar_dphi1)\n\n    #Interpolate dens(apar)\n    ipdens_apar= interpolate.InterpolatedUnivariateSpline(apars,dens_apar)\n\n    #Interpolate apar(phi1)\n    if phi1[1] < phi1[0] : # ad-hoc way of checking whether increasing or decreasing\n        ipphi1= interpolate.InterpolatedUnivariateSpline(phi1[::-1],apars[::-1])\n        #Interpolate Jacobian\n        ipdapar_dphi1=interpolate.InterpolatedUnivariateSpline(phi1[::-1],dapar_dphi1[::-1])\n        #Interpolate density(phi1) by multiplying by jacobian\n        dens_phi1=interpolate.InterpolatedUnivariateSpline(phi1[::-1],ipdens_apar(ipphi1(phi1[::-1]))*ipdapar_dphi1(phi1[::-1]))\n\n    else :\n        ipphi1= interpolate.InterpolatedUnivariateSpline(phi1,apars)\n        #Interpolate Jacobian\n        ipdapar_dphi1=interpolate.InterpolatedUnivariateSpline(phi1,dapar_dphi1)\n        #Interpolate density(phi1) by multiplying by jacobian\n        dens_phi1=interpolate.InterpolatedUnivariateSpline(phi1,ipdens_apar(ipphi1(phi1))*ipdapar_dphi1(phi1))\n\n    return (dens_phi1(phi1))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_529","text":"<reponame>ClusterDuck123\/ringity\nimport scipy\nimport numpy as np\n\ndef slope(rho, rate, a):\n    mu_S = mean_similarity(rate,a)\n    if rho <= mu_S:\n        return rho\/mu_S\n    else:\n        const = 1\/np.sinh(np.pi*rate)\n        def integral(k):\n            term1 = np.sinh((1 + 2*a*(1\/k-1))*np.pi*rate)\n            term2 = (k*np.sinh((a*np.pi*rate)\/k)*np.sinh(((a+k-2*a*k)*np.pi*rate)\/k))\/(a*np.pi*rate)\n            return term1-term2\n        return scipy.optimize.newton(\n            func = lambda k: const*integral(k) + (1-cdf_similarity(1\/k, rate, a)) - rho,\n            x0 = rho\/mu_S)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_533","text":"import sys\nsys.path.append('C:\/python scripts\/ciecam02 plot')\nimport Read_Meredith as rm\n# from scipy.ndimage import binary_dilation\n# from scipy.stats import circstd\n# import scipy.fftpack as fftpack\n# from scipy.linalg import solve_banded\nimport vispol\nimport numpy as np\nfrom scipy.sparse.linalg import spsolve\n# from scipy.sparse.linalg import spilu\nimport matplotlib.pyplot as plt\nfrom scipy.signal import convolve2d\n# from scipy.ndimage import gaussian_filter\nfrom scipy.ndimage import grey_erosion\nfrom scipy.signal import medfilt2d\nfrom scipy.signal import wiener\n\ndef ang_diff(D):\n    P = np.pi\n    return 1 - 2\/P * np.abs((D + P\/2) % (2 * P) - P)\n\nvispol.register_cmaps()\ndata_folder = 'c:\/users\/z5052714\/documents\/unsw\/unsw\/data_sets\/'\n# filename = data_folder + 'forscottfrommeredith\/162041.L1B2.v006.hdf5'\n# filename = data_folder + 'forscottfrommeredith\/162651.L1B2.v006.hdf5'\nfilename = data_folder + 'forscottfrommeredith\/094821.L1B2.v006.hdf5'\n# I, P, A = rm.getIPA(filename, start=[2, 32], end=[3900, 1403])\n_, P, A = rm.getIPA(filename, start=[2, 32], end=[3000, 1403])\n# I, P, A = rm.getIPA(filename, start=[1000, 800], end=[1600, 1300])\n# I, _, A = rm.getIPA(filename, start=[2000, 150], end=[2200, 450]) # looks great\n# _, _, A = rm.getIPA(filename, start=[1500, 150], end=[2200, 450]) # looks good with scaling\n# _, _, A = rm.getIPA(filename, start=[2, 150], end=[2600, 1000])\n# I = np.clip(I\/np.percentile(I,99), 0, 1)\nA *= np.pi\/180.0\nA[A > np.pi] -= np.pi\n\ndelta = vispol.delta_aop(A)\nA45 = A + np.pi\/8\nA45[A45 > np.pi] -= np.pi\nAneg45 = A - np.pi\/8\nAneg45[Aneg45 < 0 ] += np.pi\n# plt.plot(np.linspace(-np.pi, np.pi, 256), ang_diff(np.linspace(-np.pi, np.pi, 256)))\n\n# delta_patch = delta[2520:2620, 1200:1300].reshape((-1, 1))\n# A_patch = A[2520:2620, 1200:1300].reshape((-1, 1))\n# P_patch = P[2520:2620, 1200:1300].reshape((-1, 1))\n# hist1, hist2, edges = np.histogram2d(A_patch, delta_patch, bins='fd')\n\n# f, ax = plt.subplots(3)\n# ax[0].scatter(A_patch, delta_patch)\n# ax[1].scatter(A_patch, P_patch)\n# ax[2].scatter(P_patch, delta_patch)\n# print(np.mean(P_patch))\n# print(np.std(P_patch))\n# print(vispol.circular_mean(A_patch))\n# print(np.sqrt(-2 * np.log(np.hypot(np.mean(np.sin(2 * A_patch)), np.mean(np.cos(2 * A_patch))))))\n# print(np.mean(delta_patch))\n# plt.show()\n\ncap = 95\nsigma = 2\n# delta = grey_erosion(delta, size=(5, 5))\n# delta = medfilt2d(delta, 7)\n# delta = wiener(delta, 5)\n# A, _ = vispol.histogram_eq(A,\n#                                weighted=True,\n#                                min_change=0.25,\n#                                element=5,\n#                                deltas = delta,\n#                                suppress_noise=True,\n#                                interval=[0.0,np.pi])#,\n#                                # box=[[1100, A.shape[0]], [0, A.shape[1]]])\n# plt.imsave(\"C:\/users\/z5052714\/documents\/weekly_meetings\/28-06-2019\/AoP_rot.png\", A, cmap=\"AoP\", vmin=0, vmax=np.pi)\n\nf, ax = plt.subplots(1, 4)\n# ax[0].imshow(delta, vmin=0, vmax=1)\n# ax[1].imshow(A, vmin=0, vmax=np.pi, cmap=\"AoP\")\n# ax[2].imshow(P, vmin=0, vmax=1)\nax[0].imshow(np.cos(2 * A), cmap=\"gray\")\nax[1].imshow(np.cos(2 * A45), cmap=\"gray\")\nax[2].imshow(np.sin(2 * A), cmap=\"gray\")\nax[3].imshow(np.cos(2 * Aneg45), cmap=\"gray\")\nplt.show()\n# kernel = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])\n\n# Ld = convolve2d(delta, kernel, mode='same', boundary='symm')\n# Ld \/= np.percentile(np.abs(Ld), cap)\n# Ld = np.clip(Ld, -1, 1)\n\nx_neg = np.array([[0, 0, 0],\n                  [0, -1, 1],\n                  [0, 0, 0]])\nx_pos = np.array([[0, 0, 0],\n                  [1, -1, 0],\n                  [0, 0, 0]])\ny_neg = np.array([[0, 0, 0],\n                  [0, -1, 0],\n                  [0, 1, 0]])\ny_pos = np.array([[0, 1, 0],\n                  [0, -1, 0],\n                  [0, 0, 0]])\n\nL = np.zeros_like(A)\n\n# plt.imshow(medfilt2d(delta, 7))\n# plt.show()\n\n# f, ax = plt.subplots(1,4)\n# cosA = np.cos(2 * A)\n# sinA = np.sin(2 * A)\n# ax[0].imshow(cosA, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n# ax[2].imshow(sinA, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n# filt_size = 5\n# cosA = wiener(cosA, filt_size)\n# sinA = wiener(sinA, filt_size)\n# cosA = medfilt2d(cosA, filt_size)\n# sinA = medfilt2d(sinA, filt_size)\n# ax[1].imshow(cosA, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n# ax[3].imshow(sinA, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n# plt.show()\nclose_to_zero = np.abs(np.cos(2 * A) - 1) < 0.000005\n\nfor kernel in [x_neg, x_pos, y_neg, y_pos]:\n# for kernel in [x_neg, y_neg]:\n    # Lsub = np.sin(convolve2d(A, kernel, mode='same', boundary='symm'))\n    Lsub0 = ang_diff(convolve2d(A, kernel, mode='same', boundary='symm'))\n    Lsub45 = ang_diff(convolve2d(A45, kernel, mode='same', boundary='symm'))\n    f, ax = plt.subplots(1, 5)\n    ax[0].imshow(Lsub0, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n    ax[1].imshow(Lsub45, vmin=-1, vmax=1, cmap=\"BlueWhiteRed\")\n    ax[2].imshow(close_to_zero)\n    ax[3].imshow(Lsub0 - Lsub45, cmap=\"BlueWhiteRed\", vmin=-0.1, vmax=0.1)\n    Lsub = Lsub0\n    Lsub[close_to_zero] = Lsub45[close_to_zero]\n\n    ax[4].imshow(Lsub - Lsub0, vmin=-.1, vmax=.1, cmap=\"BlueWhiteRed\")\n    # plt.show()\n    # cos_arr = convolve2d(cosA, kernel, mode='same', boundary='symm')\n    # sin_arr = convolve2d(sinA, kernel, mode='same', boundary='symm')\n    # Lsub = cos_arr\n    # Lsub[np.abs(cos_arr) < np.abs(sin_arr)] = sin_arr[np.abs(cos_arr) < np.abs(sin_arr)]\n    L += Lsub\n\n# L[500,500] = 0\n# L = np.sin(np.pi\/2 * L)\n\n# from scipy.special import erf, erfinv\n# endpoint = 0.99999999999\n# factor = erfinv(endpoint)\n# L = erf(factor * L) \/ endpoint\nplt.figure()\nplt.imshow(L, cmap=\"BlueWhiteRed\", vmin=-1, vmax=1)\n\n# plt.show()\n\nn, m = A.shape\n\n# kernel = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])\n# L_F = fftpack.fft2(L)\n# K_F = fftpack.fft2(kernel, shape=L.shape)\n# f, ax = plt.subplots(1, 2)\n# ax[0].imshow(np.real(L_F))\n# ax[1].imshow(np.real(K_F))\n# plt.show()\n# U = fftpack.ifft2(L_F \/ K_F)\nM = vispol.construct_matrix(A.shape, type='laplacian')\n# M = vispol.construct_matrix(A.shape, type='lap_xy')\n\nU = spsolve(M, L.reshape(n * m, 1)).reshape((n, m))\n# U -= np.median(U)\n#\n# U \/= 2 * np.max(np.abs(U))\n# U += 0.5\n#\n\nU = (U - np.min(U)) \/ (np.max(U) - np.min(U))\nU_enhanced = (U - np.percentile(U, 1)) \/ (np.percentile(U, 99) - np.percentile(U, 1))\nU_enhanced = np.clip(wiener(U_enhanced, 3), 0, 1)\nU = np.clip(U, 0, 1)\nUshrink = U_enhanced * (0.8 - 0.2) + 0.2\n\nplt.figure()\nA_slice = A[1000,:600]\/np.pi\n# A_slice[A_slice > 0.93] -= 1\n# A_slice[564:] -= 1\nU_slice = U[1000,:600]\nslopes_A = ang_diff(np.convolve(A_slice, [-1, 1], mode='same'))\nslopes_U = np.convolve(U_slice, [-1, 1], mode='same')\n# A_slice = (A_slice - np.min(A_slice)) \/ (np.max(A_slice) - np.min(A_slice))\n# U_slice = (U_slice - np.min(U_slice)) \/ (np.max(U_slice) - np.min(U_slice))\n# A_delta = np.convolve(A_slice, [1, -1], mode='same')\n# A_slice[A_delta > 0.5] -= 0.5\n# A_slice[A_delta < -0.5] += 0.5\nplt.plot(range(599), slopes_A[1:])\nplt.plot(range(599), slopes_U[1:])\n# plt.plot(range(600), slopes_A \/ slopes_U)\n# plt.plot(range(600), np.abs(slopes_A \/ slopes_U))\n\nP = 1 - np.clip(delta \/ np.max(delta), 0, 1)\n# mask_params ={'thresh':0.4,\n#               'smooth':True,\n#               'morph':True}\n# delta_params = {'mask_on':True, 'mask_params':mask_params}\n# dmask = vispol.dmask(delta, thresh=0.3, smooth=True, morph=True)\n\n\n# U *= dmask\n# A += np.pi\/2\nRGB = vispol.IPAtoRGB(I = Ushrink, P=P, A=A, dependent=\"P\")\n\nf, ax = plt.subplots(1, 2)\n# plt.imsave(\"C:\/users\/z5052714\/documents\/weekly_meetings\/28-06-2019\/U.png\", U, cmap=\"gray\")\n# plt.imsave(\"C:\/users\/z5052714\/documents\/weekly_meetings\/28-06-2019\/U_enhanced.png\", U_enhanced, cmap=\"gray\")\n# plt.imsave(\"C:\/users\/z5052714\/documents\/weekly_meetings\/28-06-2019\/RGB_rot.png\", RGB)\nax[0].imshow(U_enhanced, cmap=\"gray\")\nax[1].imshow(RGB)\n# for idx, sig in enumerate([30, 20, 10, 5]):\n#     ax[idx + 1].imshow(U - gaussian_filter(U, sigma=sig), cmap=\"gray\")\n    # ax[idx].imshow(Usig, cmap=\"gray\")\nplt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_369","text":"# -*- coding: utf-8 -*-\n\"\"\"\nSimple Detection Code\n\"\"\"\n\nimport matplotlib\nmatplotlib.use('agg')\nimport glob\nimport sys\nimport numpy as np\nimport os.path as op\nimport fitsio\nimport argparse as ap\n\nfrom astropy.io import fits\nfrom astropy.convolution import convolve, Gaussian1DKernel, interpolate_replace_nans\nfrom input_utils import setup_logging\nfrom scipy.interpolate import interp1d\nfrom astropy.stats import mad_std, biweight_location\nfrom utils import biweight_midvariance\nfrom astropy.table import Table\nfrom scipy.signal import savgol_filter, medfilt\n\n\ndef get_script_path():\n    return op.dirname(op.realpath(sys.argv[0]))\n\nDIRNAME = get_script_path()\n\n\ndef grab_attribute(filename, args, attributes=[], amps=['LL', 'LU', 'RU',\n                   'RL']):\n    ''' grab specified attributes from multi* file '''\n    basename = filename[:-8]\n    s = [[] for a in attributes]\n    norm = []\n    for amp in amps:\n        name = basename + '_%s.fits' % amp\n        data = fitsio.read(name, 'twi_spectrum')\n        xl = data.shape[1] \/ 3\n        xh = 2 * data.shape[1] \/ 3\n        norm.append(np.median(data[:, xl:xh], axis=1))\n    for amp in amps:\n        name = basename + '_%s.fits' % amp\n        for i, attribute in enumerate(attributes):\n            s[i].append(fitsio.read(name, attribute))\n    X = [np.vstack(si) for si in s]\n    X.append(np.hstack(norm))\n    return X\n\n\ndef put_attribute(filename, args, data, attributes=[]):\n    ''' put specified attributes into multi* file '''\n    try:\n        for i, attribute in enumerate(attributes):\n            F = fitsio.FITS(filename, 'rw')\n            F.write(data[i], extname=attribute+'_1')\n    except IOError:\n        for i, attribute in enumerate(attributes):\n            args.log.warning('%s not found to add %s' % attribute)\n\n\ndef rectify(wave, spec, lims, mask=None, fac=1.0):\n    N, D = wave.shape\n    rect_wave = np.linspace(lims[0], lims[1], int(D*fac))\n    rect_spec = np.zeros((N, len(rect_wave)))\n    G = Gaussian1DKernel(1.5 * fac)\n    for i in np.arange(N):\n        dw = np.diff(wave[i])\n        dw = np.hstack([dw[0], dw])\n        if mask is None:\n            x = wave[i]\n            y = spec[i] \/ dw\n        else:\n            x = wave[i]\n            y = (spec[i] \/ dw)\n            y[mask[i]] = np.nan\n            y = interpolate_replace_nans(y, G)\n        I = interp1d(x, y, kind='quadratic',\n                     bounds_error=False, fill_value=-999.)\n        rect_spec[i, :] = I(rect_wave)\n    return rect_wave, rect_spec\n\n\ndef build_weight_matrix(x, y, sig=1.5):\n    d = np.sqrt((x - x[:, np.newaxis])**2 + (y - y[:, np.newaxis])**2)\n    G = np.exp(-0.5 * (d \/ sig)**2)\n    G = G \/ G.sum(axis=0)[:, np.newaxis]\n    return G.swapaxes(0, 1)\n\n\ndef convolve_spatially(x, y, spec, wave, mask, sig_spatial=0.7, sig_wave=1.5):\n    W = build_weight_matrix(x, y, sig=sig_spatial)\n    Z = spec * 1.\n    G = Gaussian1DKernel(sig_wave)\n    for i in np.arange(spec.shape[0]):\n        Z[i, :] = convolve(Z[i, :], G, nan_treatment='fill', fill_value=0.0)\n    for i in np.arange(spec.shape[1]):\n        Z[:, i] = np.dot(Z[:, i], W)\n    return Z\n\n\ndef safe_division(num, denom, eps=1e-8, fillval=0.0):\n    good = np.isfinite(denom) * (np.abs(denom) > eps)\n    div = num * 0.\n    if num.ndim == denom.ndim:\n        div[good] = num[good] \/ denom[good]\n        div[~good] = fillval\n    else:\n        div[:, good] = num[:, good] \/ denom[good]\n        div[:, ~good] = fillval\n    return div\n\n\ndef mask_cosmics(error, trace, cosmic_avoidance=4):\n    cyind, cxind = np.where(error == -1)\n    mask = np.array(trace * 0., dtype=bool)\n    for xind, yind in zip(cxind, cyind):\n        trace_a = trace[:, xind]\n        fibs = np.where(np.abs(trace_a - yind) < cosmic_avoidance)[0]\n        for fib in fibs:\n            lx = (xind-cosmic_avoidance)\n            hx = (xind+cosmic_avoidance) + 1\n            mask[fib, lx:hx] = True\n    return mask\n\n\ndef dummy_test(image):\n    y = savgol_filter(image, 315, 1, axis=1)\n    s = np.zeros((y.shape[1], 4))\n    for i in np.arange(y.shape[1]):\n        chunks = np.array_split(y[:, i], 4)\n        avg = chunks[-1]\n        n = [biweight_location(avg \/ chunk) for chunk in chunks]\n        s[i, :] = np.array(n)\n\n    chunks = np.array_split(y, 4, axis=0)\n    norm = np.zeros((3*448, chunks[0].shape[1]))\n    for k in np.arange(3):\n        for i in np.arange(y.shape[1]):\n            x = np.arange(chunks[0].shape[0])\n            z = (chunks[k] * s[:, k] \/ chunks[-1])[:, i]\n            test = z - medfilt(z, 51)\n            threshold = 3. * np.nanmedian(np.abs(test))\n            mask = np.abs(test) < threshold\n            xchunk, zchunk, mchunk = [np.array_split(j, 4, axis=0) for j in [x, z, mask]]\n            for xc, zc, mc in zip(xchunk, zchunk, mchunk):\n                p = np.polyfit((xc\/448.)[mc], zc[mc], 2)\n                norm[xc+448*k, i] = np.polyval(p, xc\/448.)\n    return norm\n\ndef main():\n    parser = ap.ArgumentParser(add_help=True)\n\n    parser.add_argument(\"-f\", \"--filename\",\n                        help='''Filename that contains list of files''',\n                        type=str, default=None)\n    parser.add_argument(\"-ac\", \"--spatial_conv_size\",\n                        help='''Spatial Convolution Kernel Sigma (\")''',\n                        type=float, default=0.6)\n    parser.add_argument(\"-ec\", \"--spectral_conv_size\",\n                        help='''Spectral Convolution Kernel Sigma (A)''',\n                        type=float, default=2.5)\n    parser.add_argument(\"-cc\", \"--spectral_cont_conv_size\",\n                        help='''Spectral Continuum Convolution Kernel Sigma (A)''',\n                        type=float, default=25.)\n    parser.add_argument(\"-t\", \"--threshold\",\n                        help='''Detection Threshold''',\n                        type=float, default=5.0)\n    parser.add_argument(\"-o\", \"--outdir\",\n                        help='''Out directory for detections''',\n                        type=str, default='temp')\n    args = parser.parse_args(args=None)\n    args.log = setup_logging(logname='detection')\n\n    filenames = [line.rstrip('\\n').split()\n                 for line in open(args.filename, 'r')]\n    allwave, allspec, allifupos, allmask, alltwi, allmodel, allftf = ([], [], [], [], [], [], [])\n    for filename in filenames:\n        args.log.info('Reading in %s' % filename[0][:-8])\n        dither = np.array([float(filename[2]), float(filename[3])])\n        amps = ['LL', 'LU', 'RU', 'RL']\n        attributes = ['wavelength', 'spectrum', 'twi_spectrum',\n                      'ifupos', 'error', 'trace', 0, 'flat_image']\n        w, s, f, i, e, t, T, m, n  = grab_attribute(filename[0], args,\n                                             attributes=attributes, amps=amps)\n        mask = mask_cosmics(e, t)\n        norm = (n \/ np.median(n))[:, np.newaxis]\n        allwave.append(w)\n        allspec.append(s)#safe_division(s, f * norm))\n        allifupos.append(i + dither)\n        allmask.append(mask)\n        alltwi.append(T)\n        allmodel.append(m)\n        allftf.append(f)\n    allwave, allspec, allifupos, allmask, alltwi, allmodel, allftf = [np.array(np.vstack(x), dtype='float64')\n                                            for x in [allwave, allspec,\n                                                      allifupos, allmask, alltwi, allmodel, allftf]]\n    args.log.info('Rectifying sky subtracted spectra')\n    allmask = np.array(allmask, dtype=bool)\n    rw, rs = rectify(allwave, allspec, [3500., 5500.], mask=allmask, fac=1.5)\n    args.log.info('Convolving sky subtracted spectra for continuum')\n    Zc = convolve_spatially(allifupos[:, 0], allifupos[:, 1], rs, rw, allmask,\n                           sig_spatial=args.spatial_conv_size,\n                           sig_wave=(args.spectral_cont_conv_size \/ (rw[1]-rw[0])))\n    noise = biweight_midvariance(Zc, axis=(0, ))\n    SNc = Zc \/ noise\n    F1 = fits.PrimaryHDU(alltwi)\n    args.log.info('Convolving sky subtracted spectra for emission')\n    Ze = convolve_spatially(allifupos[:, 0], allifupos[:, 1], rs, rw, allmask,\n                           sig_spatial=args.spatial_conv_size,\n                           sig_wave=(args.spectral_conv_size \/ (rw[1]-rw[0])))\n    noise = biweight_midvariance(Ze-Zc, axis=(0, ))\n    SNe = (Ze-Zc) \/ noise\n    F2 = fits.ImageHDU(allmodel)\n    #norm = dummy_test(np.vstack([allspec, alltwi[:448,:]]))\n    F3 = fits.ImageHDU(allftf)\n    fits.HDUList([F1, F2, F3]).writeto('test.fits', overwrite=True)\n    # peaks_fib, peaks_wave = np.where(SN > args.threshold)              \n    \nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_370","text":"<filename>python_scripts\/opencv_utils.py<gh_stars>0\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Jun 23 10:45:49 2017\n\n@author: Aditi\n\"\"\"\nfrom collections import deque\nimport numpy as np\nimport cv2\nimport math\nimport os\nfrom scipy.spatial import distance as dist\nimport copy\n\nCOLORS = {  'plains_color': np.array([42,161,152], dtype=np.uint8),\n            'wetlands_color': np.array([108,113,196], dtype=np.uint8),\n            'desert_color': np.array([181,137,0], dtype=np.uint8),\n            'jungle_color': np.array([211,54,130], dtype=np.uint8),\n            'reservoir_color': np.array([232, 236, 237], dtype=np.uint8),\n            'mountain_valley_color': np.array([232, 236, 237], dtype=np.uint8),\n            'water_color': np.array([0,255,255], dtype=np.uint8),\n            'logs_color': np.array([255,0,0], dtype=np.uint8) }\n\n\n#to capture the position \/ cordinates of the mini video\ndef know_coordinates(event,x,y,flags,param):\n    if event == cv2.EVENT_LBUTTONDBLCLK:\n        print (x ,\",\", y)\n\n# finds the angle of the contour of water path and writes it into a file\ndef detect_water_encoding(min_video_frame,frame_num,directory):\n    angle_matrix=[]\n    #to decode the color information theo embeded\n    hsv = cv2.cvtColor(min_video_frame, cv2.COLOR_BGR2HSV)\n    # define range of green?? color in HSV\n    lower_green = np.array([29,86,6])\n    upper_green = np.array([64,255,255])\n\n    # Threshold the HSV image to get only green colors\n    mask = cv2.inRange(hsv, lower_green, upper_green)\n    # Bitwise-AND mask and original image\n    res = cv2.bitwise_and(min_video_frame,min_video_frame, mask= mask)\n   # cv2.imshow('res',res)\n    #cv2.imwrite('frame.png',res)\n    name = str(directory)+\"\\\\water_path_angle\"+str(frame_num)+\".csv\"\n    rows, cols, channel = res.shape\n    handle = open(name, 'wb')\n    blank = np.zeros(res.shape,res.dtype)\n    #get green and red channel and convert into useful information\n    for row in range(0,rows):\n        for col in range(0,cols):\n            k = res[row,col]    #B=0 G=1 R=2\n            #green channel\n            green =  res.item(row,col,1)-120\n            #red channel\n            red = res.item(row,col,2)-120\n            handle.write(\"\\n\")\n            handle.write(str(row))\n            handle.write(\",\")\n            handle.write(str(col))\n            handle.write(\",\")\n            #Blue channel which was made 0 above\n            handle.write(str(res.item(row,col,0)))\n            handle.write(\",\")\n            handle.write(str(green))\n            handle.write(\",\")\n            handle.write(str(red))\n            handle.write(\",\")\n            #all channels\n            handle.write(str(k))\n            \"\"\" red+120 <0 and green+120 < 0 first quadrant\n                if green negative and red==0 y axis decide\n                direction based on green negative or poistive\n                if red < 0 ( third quadrant) add 180\n                else check green negative\n            \"\"\"\n            if(red + 120 < 20 and green + 120 < 20):\n                angle = -1000\n            elif(red==0):\n                if((-1)*green < 0):#downwards y axis negative\n                    angle =270\n                    handle.write(\",\")\n                    handle.write(str(angle))\n                elif((-1)*green > 0): #upwards y axis positive\n                    angle =90\n                    handle.write(\",\")\n                    handle.write(str(angle))\n                else:\n                    angle= -1000\n            else:\n                if(red < 0): #second quadrant left negative x axis\n                    angle= 180 + math.degrees(math.atan2((-1)*green,red))\n                    handle.write(\",\")\n                    handle.write(str(angle))\n                else: #positive x axis right\n                    if((-1)*green < 0): #first quadrant upwards negative y axis\n                        angle= 360 + math.degrees(math.atan2((-1)*green,red))\n                        handle.write(\",\")\n                        handle.write(str(angle))\n                    else:#    fourth quadrant\n                        angle=  math.degrees(math.atan2((-1)*green,red))\n                        handle.write(\",\")\n                        handle.write(str(angle))\n            if(angle >= 0 and angle < 90):\n                cv2.circle(blank,(col,row),1,(0,255,0),-1)\n            elif(angle >=90 and angle <180):\n                cv2.circle(blank,(col,row),1,(0,0,255),-1)\n            elif(angle>= 180 and angle<270):\n                cv2.circle(blank,(col,row),1,(255,0,0),-1)\n            elif(angle>=270 and angle<=360):\n                cv2.circle(blank,(col,row),1,(0,255,255),-1)\n            angle_matrix.append([row,col,angle])\n            #cv2.imshow(\"blank\",blank)\n    handle.close()\n    return angle_matrix\n\n\n\n#just identify water flow path for drawing graphs\ndef detect_water(min_video_frame):\n    hsv = cv2.cvtColor(min_video_frame, cv2.COLOR_BGR2HSV)\n    # define range of green\/yellow color in HSV\n    lower_green = np.array([29,86,6])\n    upper_green = np.array([64,255,255])\n    th3 = extract_boundary(min_video_frame,hsv,lower_green, upper_green,0)\n    store = th3\n    # morphing to get the skeletal structure\/ medial line of the water flow\n    size = np.size(th3)\n    skel = np.zeros(th3.shape,np.uint8)\n    element = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))\n    done = False\n\n    while(not done):\n        eroded = cv2.erode(th3,element)\n        temp = cv2.dilate(eroded,element)\n        temp = cv2.subtract(th3,temp)\n        skel = cv2.bitwise_or(skel,temp)\n        th3 = eroded.copy()\n\n        zeros = size - cv2.countNonZero(th3)\n        if zeros==size:\n            done = True\n    return store,skel\n\n\"\"\"checks if a particular log is active or inactive, i.e. if\nlog touches water active else inactive\"\"\"\ndef check_logs(log,water):\n    res = np.logical_and(log, water)\n    ans = np.where(res == True)\n    if len(ans[0])==0 and len(ans[1])==0:\n        return \"inactive\"\n    return \"active\"\n\ndef detect_logs(min_video_frame, filename, thresh_water):\n    hsv = cv2.cvtColor(min_video_frame, cv2.COLOR_BGR2HSV)\n    # define range of blue color in HSV\n    lower_blue = np.array([110,50,50])\n    upper_blue = np.array([130,255,255])\n\n    th3 = extract_boundary(min_video_frame,hsv,lower_blue, upper_blue,0)\n\n    #smooth the logs (current version very fat lines)\n    image ,contours, heirarchy = cv2.findContours(th3,1,2)#cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)\n\n    #Draw log contour + bonding rects\n    colored = cv2.cvtColor(image,cv2.COLOR_GRAY2BGR)\n    count =0\n    black = np.zeros(colored.shape)\n    centers=[]\n    for contour in contours:\n       # returns top left (x,y), width, height, and angle of rotation\n       rect = cv2.minAreaRect(contour)\n       box = cv2.boxPoints(rect)\n       box = np.int0(box)\n       \"\"\" rotated rectangle angle in opencv is calculated fro -0 to\n       -90 in degrees as the angle the lowest vertex of the bounding\n       rectangle makes with the horizontal counter clockwise direction, (the vertices are\n       considered clockwise from the lowest vertex), width is the\n       distance between second and third vertex, and height is the\n       distance between first and second vertex.\n       The following \"if\" converts the angle to o to -180 counterclockwise.\"\"\"\n       if(rect[1][0] < rect[1][1]):\n           angle = rect[2] - 90\n       else:\n           angle = rect[2]\n       filename.write(str(count))\n       filename.write(\",\")\n       filename.write(str(abs(angle)))\n       filename.write(\",\")\n       filename.write(str(rect[0][0]))\n       filename.write(\",\")\n       filename.write(str(rect[0][1]))\n       filename.write(\",\")\n\n       #to check if log is active\/ inactive\n       blank = np.zeros(thresh_water.shape,thresh_water.dtype)\n       log = cv2.drawContours(blank,[contour],-1,(255,0,255),-1)\n       res = check_logs(log,thresh_water)\n       filename.write(res)\n       filename.write(\",\")\n       count= count+1\n       image=cv2.drawContours(colored,[box],-1,(0,0,255),-1)\n       #returns centroid of the bounding rectangle same  as contour centroid\n\n       cx= int(rect[0][0])\n       cy= int(rect[0][1])\n       image = cv2.circle(black,(cx,cy),1,(0,255,0),-1)\n       if(res is \"active\"):\n           centers.append([cx,cy])\n    return image,filename,centers\n\n\n#def check_validity(frame, frame_number, handle_valid):\n#    handle_valid.write(\"\\n\")\n#    rows,cols, channels = frame.shape\n#    print frame.shape\n#    for row in range(0,rows):\n#        for col in range(0,cols):\n#            if(row>= 5 and row <=9 and col >=215 and col<=219):\n#                k = frame[row,col]\n#                handle_valid.write(str(row))\n#                handle_valid.write(\",\")\n#                handle_valid.write(str(col))\n#                handle_valid.write(\",\")\n#                handle_valid.write(str(frame_number))\n#                handle_valid.write(\",\")\n#                handle_valid.write(str(k))\n#                handle_valid.write(\",\")\n#    return handle_valid\n\n\ndef extract_boundary(original,hsv_image, lower, upper, flag):\n    # need end points of the boundary too\n    mask = cv2.inRange(hsv_image, lower, upper)\n    # Bitwise-AND mask and original image\n    res = cv2.bitwise_and(original,original,mask=mask)\n    #boundaries in gray scale\n    gray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY)\n    # Otsu's thresholding and gaussian filtering  to make the logs white and the background black for better detection\n    ret2,th2 = cv2.threshold(gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)\n    # Otsu's thresholding after Gaussian filtering\n    blur = cv2.GaussianBlur(gray,(5,5),0)\n    #logs will be white in th3\n    ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)\n    if(flag==1):\n        black, extLeft, extRight, cx,cy = find_contour(th3,original)\n        return black,extLeft,extRight,cx,cy\n    return th3\n\n\ndef find_contour(th3,original):\n    black = np.zeros(original.shape,original.dtype)\n    image ,contours, heirarchy = cv2.findContours(th3,1,2)\n    for contour in contours:\n        M = cv2.moments(contour)\n        cx = int(M['m10']\/M['m00'])\n        cy = int(M['m01']\/M['m00'])\n        black = cv2.circle(black,(cx,cy),3,(255,255,255),-1)\n        extLeft = tuple(contour[contour[:, :, 0].argmin()][0])\n        extRight = tuple(contour[contour[:, :, 0].argmax()][0])\n        black = cv2.circle(black,extLeft,3,(255,255,255),-1)\n        black = cv2.circle(black,extRight,3,(255,255,255),-1)\n    return black,extLeft,extRight,cx,cy\n\ndef fix_color(matrix, lower, upper, new_color, roll=2):\n    mask = np.zeros_like(matrix[:,:,0])\n    mask += matrix[:,:,0]<=upper[0]\n    mask += matrix[:,:,0]>=lower[0]\n    mask += matrix[:,:,1]<=upper[1]\n    mask += matrix[:,:,1]>=lower[1]\n    mask += matrix[:,:,2]<=upper[2]\n    mask += matrix[:,:,2]>=lower[2]\n\n    matrix[mask==6] = new_color\n    matrix[np.roll(mask, roll, axis=0)==6] = new_color\n    matrix[np.roll(mask, -roll, axis=0)==6] = new_color\n    matrix[np.roll(mask, roll, axis=1)==6] = new_color\n    matrix[np.roll(mask, -roll, axis=1)==6] = new_color\n    return matrix\n\ndef mark_boundaries():\n     boundary_ends=[]\n     center_biomes =[]\n\n     convert_boundaries = cv2.imread(\"CW-BiomeBoundary.png\")\n     hsv = cv2.cvtColor(convert_boundaries, cv2.COLOR_BGR2HSV)\n\n     # mountain valley\n     lower = np.array([0,100,0])\n     upper = np.array([5,255,5])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['mountain_valley_color'])\n\n     #Plains\n     lower = np.array([170,0,0])\n     upper = np.array([255,5,5])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['plains_color'])\n\n     #jungle - megenta\n     lower=np.array([100, 0, 100])\n     upper=np.array([255,5,255])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['jungle_color'])\n\n     #wetlands\n     lower=np.array([0, 150, 150])\n     upper=np.array([5,255,255])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['wetlands_color'])\n\n     #reservoir\n     lower=np.array([135, 135, 0])\n     upper=np.array([255,255,5])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['reservoir_color'])\n\n     #desert\n     lower = np.array([0,0,170])\n     upper = np.array([5,5,255])\n     convert_boundaries = fix_color(convert_boundaries, lower, upper, COLORS['desert_color'])\n\n     temp = np.float64(convert_boundaries)\n     return temp, boundary_ends, center_biomes\n\ndef find_biome_sector(shape,dtype,start,end,x,y):\n    blank = np.zeros(shape,dtype)\n    pts=np.array([start,end,[x,y]])\n    rect = cv2.minAreaRect(pts)\n    box = cv2.boxPoints(rect)\n    upper = dist.euclidean(box[0],box[1])\n    lower = dist.euclidean(box[1], box[2])\n    #if longest side is not necessarily the 0 and 1 coordinates\n    if lower > upper:\n        temp = lower\n        lower= upper\n        upper= temp\n    box = np.int0(box)\n    cv2.drawContours(blank,[box],0,(255,255,255),2)\n    filled = cv2.fillPoly(blank, [pts], color=(255,255,255))\n    return filled, lower, upper\n\n#def find_long_side(x,y,start,end):\n#    dist1 = dist.euclidean([x,y],start)\n#    dist2 = dist.euclidean([x,y],end)\n#    limit = abs(dist1-dist2)\n#    if(dist1 >= dist2):\n#        return dist1,limit\n#    else:\n#        return dist2,limit\n\ndef log2log(biome,log_centers,flag_logs):\n    i =0\n    for x,y in log_centers:\n        if(biome[y,x] == 255 and flag_logs[i]==0):\n            join =[x,y]\n            break\n        i=i+1\n    if(i >= len(log_centers)):\n         join = [-1000,-1000]\n    return join\n\n#def customsort(log_centers,logs):\n#    log_x=[]\n#    log_y=[]\n#    for log in logs:\n#        x,y = log_centers[log]\n#        log_x.append(x)\n#        log_y.append(y)\n#    sorted_logs = np.lexsort((log_y,log_x))\n#    return_logs = [(log_x[i],log_y[i]) for i in sorted_logs]\n#    print return_logs\n#    return return_logs\n\ndef draw_graph(boundaries,skeleton,log_centers,boundary_ends,center_biome):\n    log_list = []\n    flag=0\n    for log in log_centers:\n        #a flag along with the coordinates to indcate log=0 or wall=1\n        log_list.append([])\n        x,y = log\n        log_list[flag].append([(x,y),0])\n        flag=flag+1\n\n    flag_logs =np.zeros(len(log_centers))\n    blank = np.zeros(boundaries.shape, boundaries.dtype)\n    flag =0\n    for x,y in log_centers:\n            flag_logs[flag]=1\n            cv2.circle(blank,(x,y),3,[0,0,255],-1)\n            count=0\n            for i in range(0,len(boundary_ends),2):\n                filled_biome, lower, upper = find_biome_sector(skeleton.shape,skeleton.dtype,boundary_ends[i],boundary_ends[i+1],x,y)\n                res = cv2.bitwise_and(np.float32(filled_biome),np.float32(skeleton))\n                #cv2.imshow(\"result\",res)\n                if(cv2.countNonZero(res) > lower):#lower and cv2.countNonZero(res) <= upper):  #threshhold of  pixels\n                    #indices of logs in the same sector=1 else 0\n                    join = log2log(filled_biome,log_centers,flag_logs)\n                    x_join , y_join = join\n                    #separate join and if it is not -1000 then draw line from log to end\n                    if(x_join!=-1000 and y_join!=-1000):\n                        log_list[flag].append([(x_join,y_join),0])\n                        cv2.line(blank.astype(np.int32),(x,y),(x_join,y_join),[0,255,255],1)\n                       # cv2.imshow(\"middle\",blank)#check for upper asending may not work\n                    else: #(other check can be checking if point of intersection is between which boundaries ends and join for adjacent boundary ends)\n                        #check point of intersection in which sector this or neighbouring\n                        if(count==1):\n                            center_count = check_bound_intersection(boundaries,res,boundary_ends,1)\n                        elif(count==5):\n                            center_count = check_bound_intersection(boundaries,res,boundary_ends,2)\n                        else:\n                            center_count = count\n                        center_count = int(center_count)\n                        if(center_count!=13):     # if 13 no line to be drawn\n                            cb = (int(center_biomes[center_count][0]), int(center_biomes[center_count][1]))\n                            log_list[flag].append([cb,1])\n                            cv2.line(blank,(x,y),cb,[0,255,255],1)\n                count=count+1\n            flag=flag+1\n    #checking cycles without directions is difficult\n    #so for each two logs that are neighbours of each other measure distance from the common wall\n    #check for cycles remove redundant edges  (can i remove longest edge??)\n\n    #log_list = remove_redundant_edges(log_list)\n\n    #convert into alphabets and write into a file framewise\n    #blanknew = cv2.add(boundaries,blank)\n   # cv2.imshow('blanknew',blanknew)\n    return log_list\n\n\ndef remove_redundant_edges(log_list):\n    count =0\n    for log in log_list:\n        neighbour_logs = find_neighbour_log(log)\n        head = neighbour_logs.popleft()\n        while (len(neighbour_logs)!=0):\n            tail = neighbour_logs.popleft()\n            index = locate_tail(tail,log_list)\n\n            common = findcommon(log_list[count],log_list[index])\n            for each_common in common:\n                discard = find_discard(head,tail,each_common)\n                if(discard ==\"head\"):\n                    log_list[count].remove(each_common)\n                else:\n                    log_list[index].remove(each_common)\n        count =count+1\n    return log_list\n\n\ndef locate_tail(tail, log_list):\n    all_heads = [item[0] for item in log_list]\n    for i in range(0,len(all_heads)):\n        if(all_heads[i]==tail):\n            return i\n\ndef find_discard(log1,log2,common):\n    [log1_x,log1_y], log1_flag = log1\n    [log2_x,log2_y], log2_flag = log2\n    [common_x,common_y], common1_flag = common\n    log1_common = dist.euclidean([log1_x,log1_y],[common_x,common_y])\n    log2_common = dist.euclidean([log2_x,log2_y],[common_x,common_y])\n    if(log1_common > log2_common):\n        return \"head\"\n    else:\n        return \"tail\"\n\n\ndef findcommon(log1, log2):\n    temp1 = copy.deepcopy(log1)\n    temp2 = copy.deepcopy(log2)\n    del temp1[0]\n    del temp2[0]\n    return [x for x in temp1 if x in temp2]\n\ndef find_neighbour_log(log):\n    d = deque()\n    for element in log:\n        (x,y),flag = element\n        if (flag==0):\n           d.append([(x,y),flag])\n    return d\n\ndef check_bound_intersection(boundaries,res,boundary_ends,flag):\n    #may not work when  some times the water doesnt intersect the walls like in desert goes little out side\n     boundaries_thresh = cv2.cvtColor(np.float32(boundaries),cv2.COLOR_BGR2GRAY)\n     res = cv2.bitwise_and(boundaries_thresh,np.float32(res))\n     index = np.where(res)\n     index_x = index[1]\n     index_y = index[0]\n     if(flag==1):\n         start = 0\n         finish = 5\n     elif(flag==2):\n         start=8\n         finish=13\n     for ends in range(start, finish,2):\n         if(ends>=0 and ends<=5):\n             lower= boundary_ends[ends]\n             upper = boundary_ends[ends+1]\n         elif(ends >=8  and ends <=13):\n             lower= boundary_ends[ends +1]\n             upper = boundary_ends[ends]\n        # if(x >= lower[0] and y>=lower[1] and x<= upper[0] and y<=upper[1]):\n         check = np.where(np.greater_equal(index_x,lower[0]) & np.less_equal(index_x,upper[0]) & np.greater_equal(index_y,lower[1]) & np.less_equal( index_y,upper[1]))\n         if(len(check[0])!=0):\n             return ends\/2   # only first point may not be a good idea\n\n             #may be calculate maximum coverage\n\n     return 13   # some dummy value if intersection doesnt fall in the range\n\n\n#def check_angle(angle_matrix, row,col):\n#    for row_elem, col_elem,angle in angle_matrix:\n#         if row == row_elem and col == col_elem:\n#            return angle\n#    return 0\n\ndef add_waterfall(boundaries, boundary_ends, center_biomes):\n    water_fall_start = boundary_ends[6]\n    water_fall_end = boundary_ends[7]\n    x_start= water_fall_start[0]\n    y_start = water_fall_start[1]\n    x_end = water_fall_end[0]\n    y_end = water_fall_end[1]\n    x_mid = (x_start + x_end) \/ 2\n    y_mid = (y_start + y_end) \/ 2\n    center_biomes.insert(3,((x_mid,y_mid)))\n    boundaries = cv2.line(boundaries,boundary_ends[6],boundary_ends[7],[255,255,255],3)\n    return boundaries,center_biomes\n\n\ndef biome_alpha(index):\n    if(index==0):\n        return \"D\"\n    elif(index==1):\n        return \"MV\"\n    elif(index==2):\n        return \"P\"\n    elif(index==3):\n        return \"WF\"\n    elif(index==4):\n        return \"J\"\n    elif(index==5):\n        return \"R\"\n    elif(index==6):\n        return \"W\"\n\n\ndef write_log_list(image,file_write,log_list,frame, center_biomes):\n    file_write.write(\"\\n\"+str(frame))\n    file_write.write(\",\")\n    unique_logs=[item[0] for item in log_list]\n    for lists in log_list:\n        head = lists[0]\n        head_pts, flag = head\n        if(flag==0):\n            file_write.write(str(head_pts)+\": log\"+str(unique_logs.index(head))+\"->\")\n        for tail in range(1,len(lists)):\n            tail_pts, flag =  lists[tail]\n            if(flag==0):\n                file_write.write(str(tail_pts)+\": log\"+str(unique_logs.index(lists[tail]))+\"->\")\n            else:\n                index = center_biomes.index(tail_pts)\n                alpha= biome_alpha(index)\n                file_write.write(str(tail_pts)+\":\"+ alpha+ \"->\" )\n            cv2.line(image,head_pts,tail_pts,[75,0,130],3)\n    cv2.imshow(\"finalize\",image)\n    return file_write,image\n\n\n# filename = 'C:\\\\Aditi\\\\phd\\\\Log_Files\\\\2017-05-05\\\\theo emails\\\\17-43-36-May_17_Highschool-miniVid-PlantCreatureInfo\\\\17-43-36-May_17_Highschool-miniVid-PlantCreatureInfo\\\\0-Section_One-17-43-36-502.mov'\n# #filename = 'C:\\\\Aditi\\\\phd\\\\Log_Files\\\\2017-05-05\\\\theo emails\\\\june 6 email\\\\16-21-27-May_17_Highschool-StoicBabyMigrate\\\\16-21-27-May_17_Highschool-StoicBabyMigrate\\\\0-Section_One-16-21-27-528.mov'\n# cap = cv2.VideoCapture(filename)\n# ex_filename = filename.strip(\".mov\")\n# directory=ex_filename\n# ex_filename = str(ex_filename)+\".csv\"\n#\n# handle = open(ex_filename, 'w')\n# handle_valid= open('validity_file.csv','wb')\n# \"\"\" per frame angle should be stored, so for each video file\n# for each frame create a water_path angles file giving water contour angles\n# \"\"\"\n# name = str(directory)+\"\\\\adjacency_list.txt\"\n# file_writer= open(name,'w')\n# handle.write(\"frame position\")\n#\n# for i in range(0,8):\n#     handle.write(\",\")\n#     handle.write(\"index of log\")\n#     handle.write(\",\")\n#     handle.write(\"angle with horizontal\")\n#     handle.write(\",\")\n#     handle.write(\"centroid x\")\n#     handle.write(\",\")\n#     handle.write(\"centroid y\")\n#     handle.write(\",\")\n#     handle.write(\"status: active\/inactive\")\n#\n# cv2.namedWindow('video',0)\n# boundaries, boundary_ends, center_biomes = mark_boundaries()\n# complete_boundary,center_biomes = add_waterfall(boundaries,boundary_ends, center_biomes)\n# while(cap.isOpened()):\n#     flag, frame = cap.read()\n#     if flag:\n#         #display only mini video\n#         min_video = frame[864:1080,0:384]\n#\n#         cv2.imshow('video',min_video)\n#         handle.write(\"\\n\")\n#         temp = frame[864:1080,0:384]\n#\n#         #break\n#         # 1= will be frame number of next frame\n#         pos_frame = cap.get(1)\n#         #handle_valid=check_validity(min_video,pos_frame-1,handle_valid)\n#\n#         if not os.path.exists(directory):\n#             os.makedirs(directory)\n#         angle_matrix = detect_water_encoding(temp,(pos_frame-1),directory)\n#         handle.write(str(pos_frame-1))\n#         handle.write(\",\")\n#         thresh_water, skeleton = detect_water(min_video)\n#         logs,handle,centers = detect_logs(min_video, handle,thresh_water)\n#         #cv2.imwrite(\"logs.png\",logs)\n#         color_water = cv2.cvtColor(skeleton,cv2.COLOR_GRAY2BGR)\n#         water = np.float64(color_water)\n#         #cv2.imwrite('snap.png',thresh_water)\n#         dst = cv2.add(water,logs)\n#         dst = cv2.add(complete_boundary, dst)\n#\n#         log_list = draw_graph(dst,skeleton,centers,boundary_ends,center_biomes)\n#         file_writer,image = write_log_list(dst,file_writer,log_list,str(pos_frame-1),center_biomes)\n#         #The frame is ready and already captured\n#         cv2.imshow('video', image)\n#\n#\n# #        break #added to process just one frame\n#         cap.set(3,240)\n#         cap.set(4,640)\n#         cv2.setMouseCallback('video',know_coordinates)\n#         cv2.waitKey(1000)\n#     else:\n#         # The next frame is not ready, so we try to read it again\n#         cap.set(1, pos_frame-1)\n#         print (\"frame is not ready\")\n#         # It is better to wait for a while for the next frame to be ready\n#         cv2.waitKey(1000)\n#\n#     if cv2.waitKey(10) == 27:\n#         break\n#     if cap.get(1) == cap.get(7):\n#         # If the number of captured frames is equal to the total number of frames,\n#         # we stop\n#         break\n# #handle_valid.close()\n# file_writer.close()\n# handle.close()\n# cap.release()\n# cv2.destroyAllWindows()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_371","text":"import ctypes\nimport numpy\nimport os\nimport time\nfrom scipy.linalg.blas import daxpy, saxpy\nimport functools\nfrom numba import jit, prange, njit\nimport sys\n\n\nn_axpby = numpy.frompyfunc(lambda x,y,a,b: a*x + b*y, 4,1)\n\nprint (\"current dir \", os.path.abspath(__file__))\nN = 1048\nif len(sys.argv) > 1:\n    N = int(sys.argv[1])\nshape = (N, N)\n\nA = numpy.float32(2.)\nB = numpy.float32(1.)\n\nnumpy.random.seed(1)\na = numpy.random.random(shape)\nb = numpy.random.random(shape)\na = 2.5 * numpy.ones(shape)\nb = 1. * numpy.ones(shape)\n\ndll = os.path.abspath(os.path.join( \n         os.path.abspath(os.path.dirname(__file__)),\n         'libfdiff.dll')\n)\n\ndll = 'libfdiff.so'\n\nprint (\"dll location\", dll)\nfdiff = ctypes.cdll.LoadLibrary(dll)\n\n\ndef axpby(a,b,out,A,B,dtype=numpy.float64):\n\n\n    c_float_p = ctypes.POINTER(ctypes.c_float)\n    c_double_p = ctypes.POINTER(ctypes.c_double)\n\n    if a.dtype != dtype:\n        a = a.astype(dtype)\n    if b.dtype != dtype:\n        b = b.astype(dtype)\n    \n    if dtype == numpy.float32:\n        a_p = a.ctypes.data_as(c_float_p)\n        b_p = b.ctypes.data_as(c_float_p)\n        out_p = out.ctypes.data_as(c_float_p)\n\n    elif dtype == numpy.float64:\n        a = a.astype(numpy.float64)\n        b = b.astype(numpy.float64)\n        a_p = a.ctypes.data_as(c_float_p)\n        b_p = b.ctypes.data_as(c_float_p)\n        out_p = out.ctypes.data_as(c_float_p)\n    else:\n        raise TypeError('Unsupported type {}. Expecting numpy.float32 or numpy.float64'.format(dtype))\n\n    out = numpy.empty_like(a)\n\n    \n    # int psaxpby(float * x, float * y, float * out, float a, float b, long size)\n    fdiff.saxpby.argtypes = [ctypes.POINTER(ctypes.c_float), # pointer to the first array \n                              ctypes.POINTER(ctypes.c_float), # pointer to the second array \n                              ctypes.POINTER(ctypes.c_float), # pointer to the third array \n                              ctypes.c_float,                 # type of A (float)\n                              ctypes.c_float,                 # type of B (float)\n                              ctypes.c_long]                  # type of size of first array \n    fdiff.daxpby.argtypes = [ctypes.POINTER(ctypes.c_double), # pointer to the first array \n                              ctypes.POINTER(ctypes.c_double), # pointer to the second array \n                              ctypes.POINTER(ctypes.c_double), # pointer to the third array \n                              ctypes.c_double,                 # type of A (c_double)\n                              ctypes.c_double,                 # type of B (c_double)\n                              ctypes.c_long]                  # type of size of first array \n\n    if dtype == numpy.float32:\n        return fdiff.saxpby(a_p, b_p, out_p, A, B, a.size)\n    elif dtype == numpy.float64:\n        return fdiff.daxpby(a_p, b_p, out_p, A, B, a.size)\n\n\nc_float_p = ctypes.POINTER(ctypes.c_float)\nc_double_p = ctypes.POINTER(ctypes.c_double)\ndtype = numpy.float32\na = a.astype(dtype)\nb = b.astype(dtype)\n    \nif dtype == numpy.float32:\n    a_p = a.ctypes.data_as(c_float_p)\n    b_p = b.ctypes.data_as(c_float_p)\n    out = numpy.empty_like(a)\n    out_p = out.ctypes.data_as(c_float_p)\n    # int psaxpby(float * x, float * y, float * out, float a, float b, long size)\n    fdiff.saxpby.argtypes = [ctypes.POINTER(ctypes.c_float), # pointer to the first array \n                              ctypes.POINTER(ctypes.c_float), # pointer to the second array \n                              ctypes.POINTER(ctypes.c_float), # pointer to the third array \n                              ctypes.c_float,                 # type of A (float)\n                              ctypes.c_float,                 # type of B (float)\n                              ctypes.c_long]                  # type of size of first array \n    \n\n#out_nfrom = n_axpby(a,b,A,B)\n\n@jit(nopython=True, parallel=True)\ndef numba_axpby(x,y,out,ca,cb):\n    for i in prange(x.size):\n        out.flat[i] = ca*x.flat[i] + cb*y.flat[i]\n\n\n\nN = 100\n\nfdiff.saxpby(a_p, b_p, out_p, A, B, a.size)\nt0 = time.time()\nfor i in range(N):\n    fdiff.saxpby(a_p, b_p, out_p, A, B, a.size)\nt1 = time.time()\nprint (\"lib saxpby\", t1-t0)\n\naxpby(a, b, out, A, B, numpy.float32)\nt0 = time.time()\nfor i in range(N):\n    axpby(a, b, out, A, B, numpy.float32)\nt1 = time.time()\nprint (\"lib axpby\", t1-t0)\n\nfdiff.saxpby(a_p, b_p, out_p, A, B, a.size)\nt0 = time.time()\nfor i in range(N):\n    fdiff.saxpby(a_p, b_p, out_p, A, B, a.size)\nt1 = time.time()\nprint (\"lib saxpby\", t1-t0)\n\nout_numpy = numpy.empty_like(a)\nout_numpy2 = numpy.empty_like(a)\nnumpy.subtract(a,b, out=out_numpy)\nt2 = time.time()\nfor i in range(N):\n    numpy.multiply (a, A, out=out_numpy )\n    numpy.multiply (b, B, out=out_numpy2)\n    numpy.add(out_numpy,out_numpy2, out=out_numpy)\nt3 = time.time()\nprint (\"numpy memopt\", t3-t2)\n\nt2 = time.time()\nfor i in range(N):\n    out_numpy2 = A*a + B*b\nt3 = time.time()\nprint (\"numpy no memopt\", t3-t2)\n\n\n\nt2 = time.time()\nfor i in range(N):\n    out_scipy = saxpy(a,b,a=A)\nt3 = time.time()\nprint (\"scipy saxpy\", t3-t2)\n\naf = numpy.asfortranarray(a)\nbf = numpy.asfortranarray(b)\nprint (\"af.shape\", af.shape, \"a.shape\", a.shape, \"af.dtype\", af.dtype)\nt2 = time.time()\nfor i in range(N):\n    out_scipy_f = daxpy(af,bf,a=A)\nt3 = time.time()\nprint (\"scipy saxpy fortran\", t3-t2)\n\n\nout_nfrom = n_axpby(a,b,A,B)\nt2 = time.time()\nfor i in range(1):\n    out_nfrom = n_axpby(a,b,A,B)\nt3 = time.time()\nprint (\"numpy frompyfunc\", t3-t2)\n\nfrom itertools import chain\n\nout_map =  numpy.fromiter(chain.from_iterable(map(lambda y: A * y[0] + B * y[1], zip(a,b))), dtype=a.dtype).reshape(a.shape)\nt2 = time.time()\nfor i in range(N):\n    out_map = numpy.fromiter(chain.from_iterable(map(lambda y: A * y[0] + B * y[1], zip(a,b))), dtype=a.dtype).reshape(a.shape)\nt3 = time.time()\nprint (\"map\", t3-t2)\n\nout_numba = numpy.empty_like(a)\nnumba_axpby(a,b,out_numba,A,B)\nt4 = time.time()\nfor i in range(N):\n    numba_axpby(a,b,out_numba,A,B)\nt5 = time.time()\nprint (\"numba\", t5-t4)\n\nout_scipy_f_c = numpy.ascontiguousarray(out_scipy_f)\nprint (\"out_scipy_f.shape\", out_scipy_f.shape, \"out_scipy_f_c.shape\", out_scipy_f_c.shape)\nnumpy.testing.assert_array_equal(out, out_numpy)\nnumpy.testing.assert_array_equal(out_numpy, out_scipy)\nnumpy.testing.assert_array_almost_equal(out_numpy, numpy.ascontiguousarray(out_scipy_f))\nnumpy.testing.assert_array_almost_equal(out_numpy, out_nfrom)\nnumpy.testing.assert_array_almost_equal(out_numpy, numpy.asarray(list(out_map)))\n\nnumpy.testing.assert_array_almost_equal(out_numpy, out_numba)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_372","text":"<reponame>ifsm\/apollon\n\"\"\"hmm_test.py\nUnit test for HMM implementation.\"\"\"\n\n\nimport numpy as np\nfrom scipy.stats import poisson\nimport unittest\n\nfrom apollon.hmm.poisson import PoissonHmm\n\n\nclass TestHMM_utilities(unittest.TestCase):\n    def setUp(self):\n        # Arbitrary transition probability matrix\n        self.A = np.array([[1., 0, 0], [.2, .3, .5], [.1, .3, .6]])\n\n        # Wrong number of dimensions\n        self.B1 = np.array([1., 0, 0, 0])\n        self.B2 = np.array([[[1., 0, 0], [.2, .3, .5], [.1, .3, .6]]])\n\n        # Not quadratic\n        self.C1 = np.array([[1., 0, 0], [.2, .3, .5]])\n        self.C2 = np.array([[1.0], [.5, .5], [.2, .8]])\n\n        # Rows do not sum up to one\n        self.D = np.array([[.2, .3, .5], [.5, .4, .2], [1., 0, 0]])\n\n    def test_success(self):\n        mus = [20, 40, 80, 120, 40]\n        m = len(mus)\n        data = np.concatenate([poisson(mu).rvs(30) for mu in mus])\n        hmm = PoissonHmm(data, m)\n        hmm.fit(data)\n        self.assertTrue(hmm.success)\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_374","text":"<reponame>hamid-m\/NavSimLab\n__author__ = '<NAME>'\n# Created: October 10th, 2014\n# Last Update: June 6th, 2015\n\n# -*- coding: utf-8 -*-\nimport os\nimport sys\nimport scipy.io as sio\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as clr\nfrom matplotlib.gridspec import GridSpec\nfrom numpy import linalg as lina\n# Clear the Console\nos.system('cls')\nplt.close('all')\n\n\n'''\n========================================================================================================================\n                                                GLOBAL VARIABLE DECLARATIONS\n========================================================================================================================\n'''\n'''\n---------------------\nA. Conversion Factors\n---------------------\n'''\nglobal d2r, r2d, micro_g, g, R_0, ecc_o, mu, OMEGA_ie, c, dd2sec, hr2sec, mn2sec, tol\nc = 2.99792458E08                           # Speed of light in (m\/s)\necc_o = 0.0818191908425                     # WGS84 Eccentricity\ng = 9.80665                                 # Earth graviational acceleration (m\/s^2)\nmu = 3.986004418E+14                        # WGS84 Earth gravitational constant (m^3\/s^2)\nJ_2 = 1.082627E-03                          # WGS84 Earth's second gravitational constant\nd2r = np.pi \/ 180.0                         # Degree to radian (rad\/deg)\nr2d = 180.0 \/ np.pi                         # Radian to degree\nR_0 = 6.378137E06                           # WGS84 Equatorial radius in meters\nOMEGA_ie = 7.292115146E-05                  # Earth rotation rate in (rad\/s)\nmicro_g = 9.80665E-06                       # Micro g in (m\/s^2)\ndd2sec = 86400.0                            # seconds per day\nhr2sec = 3600.00                            # seconds per hour\nmn2sec = 60.0                               # seconds per minute\ntol = 1.0E-08                               # tolerance in solving Kepler's equation\n\n# End of Conversion Factor Declaration\n\n\n'''\n-----------------------\nB. File Directory Paths\n-----------------------\n'''\nglobal finpath, foutpath\nfinpath = os.path.join('SimData', 'SimIn') + os.path.sep            # input data file path\nfoutpath = os.path.join('SimData', 'SimOut') + os.path.sep          # output data file path\n\n'''\n========================================================================================================================\n                                        FUNCTIONS TO CREATE GRAPHS OF RESULTS\n========================================================================================================================\n'''\n'''\n    -----------------------------\n    1. Customize Color for Graphs\n    -----------------------------\n'''\n\nclr.ColorConverter.colors['c1'] = (0.0, 0.4, 0.9)\nclr.ColorConverter.colors['c2'] = (0.0, 0.9, 0.4)\nclr.ColorConverter.colors['c3'] = (0.9, 0.0, 0.4)\nclr.ColorConverter.colors['c4'] = (0.9, 0.4, 0.0)\nclr.ColorConverter.colors['c5'] = (0.4, 0.9, 0.0)\nclr.ColorConverter.colors['c6'] = (0.4, 0.0, 0.9)\nclr.ColorConverter.colors['c7'] = (0.7, 0.5, 0.0)\nclr.ColorConverter.colors['c8'] = (0.7, 0.0, 0.5)\nclr.ColorConverter.colors['c9'] = (0.0, 0.7, 0.5)\nclr.ColorConverter.colors['c10'] = (0.8, 0.2, 0.6)\nclr.ColorConverter.colors['c11'] = (0.5, 0.0, 0.7)\nclr.ColorConverter.colors['c12'] = (0.5, 0.7, 0.0)\nclr.ColorConverter.colors['c13'] = (0.2, 0.6, 0.8)\nclr.ColorConverter.colors['c14'] = (0.2, 0.4, 0.6)\nclr.ColorConverter.colors['c15'] = (0.8, 0.6, 0.2)\nclr.ColorConverter.colors['c16'] = (0.1, 0.9, 0.6)\nclr.ColorConverter.colors['c17'] = (0.6, 0.8, 0.2)\nclr.ColorConverter.colors['c18'] = (0.6, 0.2, 0.8)\nclr.ColorConverter.colors['c19'] = (0.1, 0.2, 0.3)\n\n# End of Color Customization\n\n\n'''\n    --------------------------------------\n    2. Plot Results from Single Simulation\n    --------------------------------------\n'''\n\n\ndef plot_single_profile(true_profile, est_profile):\n\n    # 1. Create the Vehicle Scatter Profile\n    tin = true_profile[:, 0] \/ 60.0\n    dat_len = len(tin)\n    spacing = 30\n    dat_point = dat_len\/spacing\n    scatter_track = np.nan * np.ones((dat_point, 2))\n    indx = 0\n    for i in xrange(0, (dat_len - np.mod(dat_len, spacing)), spacing):\n        scatter_track[indx, :] = true_profile[i, 1:3]\n        indx += 1\n    # End of For loop to collect data points for scatter plot\n    lat_arr = scatter_track[:, 0] * r2d\n    lat_head = lat_arr[1:]\n    lat_tail = lat_arr[:-1]\n    lat_mag = lat_head - lat_tail\n    lon_arr = scatter_track[:, 1] * r2d\n    lon_head = lon_arr[1:]\n    lon_tail = lon_arr[:-1]\n    lon_mag = lon_head - lon_tail\n\n    # 2. Plot Ground Track in Geodetic Frame\n    plt.figure(num=1, figsize=(12, 8), dpi=80, facecolor='w', edgecolor='k')\n    plt.plot(true_profile[:, 2] * r2d, true_profile[:, 1] * r2d, 'c1', label='$Flight Data$')\n    plt.hold('on')\n    plt.grid('on')\n    plt.quiver(lon_tail, lat_tail, lon_mag, lat_mag, scale_units='xy', angles='xy', scale=1.5, color='c1')\n    plt.plot(est_profile[:, 2] * r2d, est_profile[:, 1] * r2d, 'c3', linestyle='--', label='$Simulation$')\n    plt.xlabel('$Longitude$' + ' ' + '$(deg)$', fontsize=16)\n    plt.ylabel('$Latitude$' + ' ' + '$(deg)$', fontsize=16)\n    plt.title('$Ground$' + ' ' + '$Track$' + ' ' + '$in$' + ' ' + '$Geodetic$', fontsize=18)\n    plt.legend(loc='best', prop={'size': 12})\n\n    # 3. Plot Position, Velocity, and Attitude in NED:\n    tout = est_profile[:, 0] \/ 60.0\n\n    # 3.1 For Position Displacements:\n    [in_r_ns, in_r_ew] = radii_of_curv(true_profile[0, 1])\n    [out_r_ns, out_r_ew] = radii_of_curv(est_profile[0, 1])\n    pfig, p = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 3.1.a For North Position Displacement from Its Initial Value\n    p[0, 0].plot(tin, (true_profile[:, 1] - true_profile[0, 1]) * (in_r_ns + true_profile[0, 3]), 'c19',\n                 linestyle='--', label='$Orig$')\n    p[0, 0].hold('on')\n    p[0, 0].plot(tout, (est_profile[:, 1] - est_profile[0, 1]) * (out_r_ns + est_profile[0, 3]), 'c1',\n                 label='$Sim$')\n    p[0, 0].set_title('$North$' + ' ' + '$Displacement$')\n    p[0, 0].set_ylabel('$(m)$')\n\n    # 3.1.b. For East Position Displacement from Its Initial Value\n    p[0, 1].plot(tin, (true_profile[:, 2] - true_profile[0, 2]) * (in_r_ns + true_profile[0, 3]) *\n                 np.cos(true_profile[0, 1]), 'c19', linestyle='--', label='$Orig$')\n    p[0, 1].hold('on')\n    p[0, 1].plot(tout, (est_profile[:, 2] - est_profile[0, 2]) * (out_r_ns + est_profile[0, 3]) *\n                 np.cos(est_profile[0, 1]), 'c2', label='$Sim$')\n    p[0, 1].set_title('$East$' + ' ' + '$Displacement$')\n\n    # 3.1.c. For Down Position Displacement (Altitude) from Its Initial Value\n    p[0, 2].plot(tin, true_profile[:, 3], 'c19', linestyle='--', label='$Orig$')\n    p[0, 2].hold('on')\n    p[0, 2].plot(tout, est_profile[:, 3], 'c3', label='$Sim$')\n    p[0, 2].set_title('$Altitude$')\n    p[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 3.2 For Velocity:\n    # 3.2.a For North Velocity\n    p[1, 0].plot(tin, true_profile[:, 4], 'c19', linestyle='--', label='$Orig$')\n    p[1, 0].hold('on')\n    p[1, 0].plot(tout, est_profile[:, 4], 'c4', label='$Sim$')\n    p[1, 0].set_title('$v_N$')\n    p[1, 0].set_ylabel('$(m\/s)$')\n\n    # 3.2.b For East Velocity\n    p[1, 1].plot(tin, true_profile[:, 5], 'c19', linestyle='--', label='$Orig$')\n    p[1, 1].hold('on')\n    p[1, 1].plot(tout, est_profile[:, 5], 'c5', label='$Sim$')\n    p[1, 1].set_title('$v_E$')\n\n    # 3.2.c For Down Velocity\n    p[1, 2].plot(tin, true_profile[:, 6], 'c19', linestyle='--', label='$Orig$')\n    p[1, 2].hold('on')\n    p[1, 2].plot(tout, est_profile[:, 6], 'c6', label='$Sim$')\n    p[1, 2].set_title('$v_E$')\n\n    # 3.3 For Attitude:\n    # 3.3.a For Roll Angle\n    p[2, 0].plot(tin, r2d * true_profile[:, 7], 'c19', linestyle='--', label='$Orig$')\n    p[2, 0].hold('on')\n    p[2, 0].plot(tout, r2d * est_profile[:, 7], 'c7', label='$Sim$')\n    p[2, 0].set_title('$Roll$'+' '+'$Angle$')\n    p[2, 0].set_ylabel('$(deg)$')\n    p[2, 0].set_xlabel('$t (mn)$')\n\n    # 3.3.b For Pitch Angle\n    p[2, 1].plot(tin, r2d * true_profile[:, 8], 'c19', linestyle='--', label='$Orig$')\n    p[2, 1].hold('on')\n    p[2, 1].plot(tout, r2d * est_profile[:, 8], 'c8', label='$Sim$')\n    p[2, 1].set_title('$Pitch$'+' '+'$Angle$')\n    p[2, 1].set_xlabel('$t (mn)$')\n\n    # 3.3.c For Yaw Angle\n    p[2, 2].plot(tin, r2d * true_profile[:, 9], 'c19', linestyle='--', label='$Orig$')\n    p[2, 2].hold('on')\n    p[2, 2].plot(tout, r2d * est_profile[:, 9], 'c9', label='$Sim$')\n    p[2, 2].set_title('$Yaw$'+' '+'$Angle$')\n    p[2, 2].set_xlabel('$t (mn)$')\n\n    plt.tight_layout()\n\n    return\n\n# End of Plotting Profiles\n\n\n'''\n    ------------------------------------\n    3. Plot Results from Dual Simulation\n    ------------------------------------\n'''\n\n\ndef plot_dual_profile(true_profile, lc_est_profile, tc_est_profile):\n\n    # 1. Create the Vehicle Scatter Profile\n    tin = true_profile[:, 0] \/ 60.0\n    dat_len = len(tin)\n    spacing = 30\n    dat_point = dat_len\/spacing\n    scatter_track = np.nan * np.ones((dat_point, 2))\n    indx = 0\n    for i in xrange(0, (dat_len - np.mod(dat_len, spacing)), spacing):\n        scatter_track[indx, :] = true_profile[i, 1:3]\n        indx += 1\n    # End of For loop to collect data points for scatter plot\n    lat_arr = scatter_track[:, 0] * r2d\n    lat_head = lat_arr[1:]\n    lat_tail = lat_arr[:-1]\n    lat_mag = lat_head - lat_tail\n    lon_arr = scatter_track[:, 1] * r2d\n    lon_head = lon_arr[1:]\n    lon_tail = lon_arr[:-1]\n    lon_mag = lon_head - lon_tail\n\n    # 2. Plot Ground Track in Geodetic Frame\n    plt.figure(num=1, figsize=(12, 8), dpi=80, facecolor='w', edgecolor='k')\n    plt.plot(true_profile[:, 2] * r2d, true_profile[:, 1] * r2d, color='c1', label='$Flight Data$')\n    plt.hold('on')\n    plt.grid('on')\n    plt.quiver(lon_tail, lat_tail, lon_mag, lat_mag, scale_units='xy', angles='xy', scale=1.5, color='c1')\n    plt.plot(lc_est_profile[:, 2] * r2d, lc_est_profile[:, 1] * r2d, color='c2', linestyle='--', label='$LC Sim$')\n    plt.plot(tc_est_profile[:, 2] * r2d, tc_est_profile[:, 1] * r2d, color='c3', linestyle='-.', label='$TC Sim$')\n    plt.xlabel('$Longitude$' + ' ' + '$(deg)$', fontsize=16)\n    plt.ylabel('$Latitude$' + ' ' + '$(deg)$', fontsize=16)\n    plt.title('$Ground$' + ' ' + '$Track$' + ' ' + '$in$' + ' ' + '$Geodetic$', fontsize=18)\n    plt.legend(loc='best', prop={'size': 12})\n\n    # 3. Plot the Displacements, Speeds, and Attitudes\n    lc_tout = lc_est_profile[:, 0] \/ 60.0\n    tc_tout = tc_est_profile[:, 0] \/ 60.0\n\n    # 3.1 For Position Displacements:\n    [in_r_ns, in_r_ew] = radii_of_curv(true_profile[0, 1])\n    [lc_out_r_ns, lc_out_r_ew] = radii_of_curv(lc_est_profile[0, 1])\n    [tc_out_r_ns, tc_out_r_ew] = radii_of_curv(tc_est_profile[0, 1])\n    pfig, p = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 3.1.a For North Position Displacement from Its Initial Value\n    p[0, 0].plot(tin, ((true_profile[:, 1] - true_profile[0, 1]) * (in_r_ns + true_profile[0, 3])), 'c19',\n                 label='$Orig$')\n    p[0, 0].hold('on')\n    p[0, 0].plot(lc_tout, ((lc_est_profile[:, 1] - lc_est_profile[0, 1]) * (lc_out_r_ns + lc_est_profile[0, 3])), 'c1',\n                 linestyle='--', label='$LC Sim$')\n    p[0, 0].plot(tc_tout, ((tc_est_profile[:, 1] - tc_est_profile[0, 1]) * (tc_out_r_ns + tc_est_profile[0, 3])), 'c10',\n                 linestyle='-.', label='$TC Sim$')\n    p[0, 0].set_title('$North$' + ' ' + '$Displacement$')\n    p[0, 0].set_ylabel('$(m)$')\n    p[0, 0].legend(loc='best', prop={'size': 10})\n\n    # 3.1.b. For East Position Displacement from Its Initial Value\n    p[0, 1].plot(tin, ((true_profile[:, 2] -\n                        true_profile[0, 2]) * (in_r_ns + true_profile[0, 3]) * np.cos(true_profile[0, 1])), 'c19',\n                 label='$Orig$')\n    p[0, 1].hold('on')\n    p[0, 1].plot(lc_tout,\n                 ((lc_est_profile[:, 2] - lc_est_profile[0, 2]) * (lc_out_r_ns + lc_est_profile[0, 3]) * np.cos(\n                     lc_est_profile[0, 1])), 'c2', linestyle='--', label='$LC Sim$')\n    p[0, 1].plot(tc_tout,\n                 ((tc_est_profile[:, 2] - tc_est_profile[0, 2]) * (tc_out_r_ns + tc_est_profile[0, 3]) * np.cos(\n                     tc_est_profile[0, 1])), 'c11', linestyle='-.', label='$TC Sim$')\n    p[0, 1].set_title('$East$' + ' ' + '$Displacement$')\n    p[0, 1].legend(loc='best', prop={'size': 10})\n\n    # 3.1.c. For Down Position Displacement (Altitude) from Its Initial Value\n    p[0, 2].plot(tin, true_profile[:, 3], 'c19', label='$Orig$')\n    p[0, 2].hold('on')\n    p[0, 2].plot(lc_tout, lc_est_profile[:, 3], 'c3', linestyle='--', label='$LC Sim$')\n    p[0, 2].plot(tc_tout, tc_est_profile[:, 3], 'c12', linestyle='-.', label='$TC Sim$')\n    p[0, 2].set_title('$Altitude$')\n    p[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 3.2 For Velocity:\n    # 3.2.a For North Velocity\n    p[1, 0].plot(tin, true_profile[:, 4], 'c19', label='$Orig$')\n    p[1, 0].hold('on')\n    p[1, 0].plot(lc_tout, lc_est_profile[:, 4], 'c4', linestyle='--', label='$LC Sim$')\n    p[1, 0].plot(tc_tout, tc_est_profile[:, 4], 'c13', linestyle='-.', label='$TC Sim$')\n    p[1, 0].set_title('$v_N$')\n    p[1, 0].set_ylabel('$(m\/s)$')\n    p[1, 0].legend(loc='best', prop={'size': 10})\n\n    # 3.2.b For East Velocity\n    p[1, 1].plot(tin, true_profile[:, 5], 'c19', label='$Orig$')\n    p[1, 1].hold('on')\n    p[1, 1].plot(lc_tout, lc_est_profile[:, 5], 'c5', linestyle='--', label='$LC Sim$')\n    p[1, 1].plot(tc_tout, tc_est_profile[:, 5], 'c14', linestyle='-.', label='$TC Sim$')\n    p[1, 1].set_title('$v_E$')\n    p[1, 1].legend(loc='best', prop={'size': 10})\n\n    # 3.2.c For Down Velocity\n    p[1, 2].plot(tin, true_profile[:, 6], 'c19', label='$Orig$')\n    p[1, 2].hold('on')\n    p[1, 2].plot(lc_tout, lc_est_profile[:, 6], 'c6', linestyle='--', label='$LC Sim$')\n    p[1, 2].plot(tc_tout, tc_est_profile[:, 6], 'c15', linestyle='-.', label='$TC Sim$')\n    p[1, 2].set_title('$v_E$')\n    p[1, 2].legend(loc='best', prop={'size': 10})\n\n    # 3.3 For Attitude:\n    # 3.3.a For Roll Angle\n    p[2, 0].plot(tin, r2d * true_profile[:, 7], 'c19', label='$Orig$')\n    p[2, 0].hold('on')\n    p[2, 0].plot(lc_tout, r2d * lc_est_profile[:, 7], 'c7', linestyle='--', label='$LC Sim$')\n    p[2, 0].plot(tc_tout, r2d * tc_est_profile[:, 7], 'c16', linestyle='-.', label='$TC Sim$')\n    p[2, 0].set_title('$Roll$'+' '+'$Angle$')\n    p[2, 0].set_ylabel('$(deg)$')\n    p[2, 0].set_xlabel('$t (mn)$')\n    p[2, 0].legend(loc='best', prop={'size': 10})\n\n    # 3.3.b For Pitch Angle\n    p[2, 1].plot(tin, r2d * true_profile[:, 8], 'c19', label='$Orig$')\n    p[2, 1].hold('on')\n    p[2, 1].plot(lc_tout, r2d * lc_est_profile[:, 8], 'c8', linestyle='--', label='$LC Sim$')\n    p[2, 1].plot(tc_tout, r2d * tc_est_profile[:, 8], 'c17', linestyle='-.', label='$TC Sim$')\n    p[2, 1].set_title('$Pitch$'+' '+'$Angle$')\n    p[2, 1].set_xlabel('$t (mn)$')\n    p[2, 1].legend(loc='best', prop={'size': 10})\n\n    # 3.3.c For Yaw Angle\n    p[2, 2].plot(tin, r2d * true_profile[:, 9], 'c19', label='$Orig$')\n    p[2, 2].hold('on')\n    p[2, 2].plot(lc_tout, r2d * lc_est_profile[:, 9], 'c9', linestyle='--', label='$LC Sim$')\n    p[2, 2].plot(tc_tout, r2d * tc_est_profile[:, 9], 'c18', linestyle='-.', label='$TC Sim$')\n    p[2, 2].set_title('$Yaw$'+' '+'$Angle$')\n    p[2, 2].set_xlabel('$t (mn)$')\n    p[2, 2].legend(loc='best', prop={'size': 10})\n\n    plt.tight_layout()\n\n    return\n\n# End of plotting dual profiles\n\n\n'''\n    ------------------------------------\n    4. Plot Errors for Single Simulation\n    ------------------------------------\n'''\n\n\ndef plot_single_error(errors, kf_sd):\n\n    nsig = 3.0                      # Number of sigmas (standard deviation)\n    tkf = kf_sd[:, 0] \/ 60.0        # Kalman Filter updating time history\n    ter = errors[:, 0] \/ 60.0       # Output errors updating time history\n\n    perfig, per = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 1. For Position Errors:\n    [r_ns, r_ew] = radii_of_curv(kf_sd[0, 1])\n    # 1.1. For North Position Error\n    per[0, 0].plot(ter, errors[:, 1], 'c1', label=r'$\\delta$' + '$r_N$')\n    per[0, 0].hold('on')\n    per[0, 0].plot(tkf, nsig * (kf_sd[:, 1] - kf_sd[0, 1]) * (r_ns + kf_sd[0, 3]), 'k', label=r'$3\\sigma_N$')\n    per[0, 0].plot(tkf, -nsig * (kf_sd[:, 1] - kf_sd[0, 1]) * (r_ns + kf_sd[0, 3]), 'k')\n    per[0, 0].set_title(r'$\\delta$' + '$r_N$')\n    per[0, 0].set_ylabel('$(m)$')\n\n    # 1.2. For East Position Error\n    per[0, 1].plot(ter, errors[:, 2], 'c2', label=r'$\\delta$' + '$r_E$')\n    per[0, 1].hold('on')\n    per[0, 1].plot(tkf, nsig * (kf_sd[:, 2] - kf_sd[0, 2]) * (r_ns + kf_sd[0, 3]) * np.cos(kf_sd[0, 1]), 'k',\n                   label=r'$3\\sigma_E$')\n    per[0, 1].plot(tkf, -nsig * (kf_sd[:, 2] - kf_sd[0, 2]) * (r_ns + kf_sd[0, 3]) * np.cos(kf_sd[0, 1]), 'k')\n    per[0, 1].set_title(r'$\\delta$' + '$r_E$')\n\n    # 1.3. For Down Position Error\n    per[0, 2].plot(ter, errors[:, 3], 'c3', label=r'$\\delta$' + '$r_D$')\n    per[0, 2].hold('on')\n    per[0, 2].plot(tkf, nsig * kf_sd[:, 3], 'k', label=r'$3\\sigma_D$')\n    per[0, 2].plot(tkf, -nsig * kf_sd[:, 3], 'k')\n    per[0, 2].set_title(r'$\\delta$' + '$r_D$')\n    per[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 2. For Velocity Errors:\n    # 2.1. For North Velocity Error\n    per[1, 0].plot(ter, errors[:, 4], 'c4', label=r'$\\delta$' + '$v_N$')\n    per[1, 0].hold('on')\n    per[1, 0].plot(tkf, nsig * kf_sd[:, 4], 'k', label=r'$3\\sigma_{v_N}$')\n    per[1, 0].plot(tkf, -nsig * kf_sd[:, 4], 'k')\n    per[1, 0].set_title(r'$\\delta$' + '$v_N$')\n    per[1, 0].set_ylabel('$(m\/s)$')\n\n    # 2.2. For East Velocity Error\n    per[1, 1].plot(ter, errors[:, 5], 'c5', label=r'$\\delta$' + '$v_E$')\n    per[1, 1].hold('on')\n    per[1, 1].plot(tkf, nsig * kf_sd[:, 5], 'k', label=r'$3\\sigma_{v_E}$')\n    per[1, 1].plot(tkf, -nsig * kf_sd[:, 5], 'k')\n    per[1, 1].set_title(r'$\\delta$' + '$v_E$')\n\n    # 2.3. For Down Velocity Error\n    per[1, 2].plot(ter, errors[:, 6], 'c6', label=r'$\\delta$' + '$v_D$')\n    per[1, 2].hold('on')\n    per[1, 2].plot(tkf, nsig * kf_sd[:, 6], 'k', label=r'$3\\sigma_{v_D}$')\n    per[1, 2].plot(tkf, -nsig * kf_sd[:, 6], 'k')\n    per[1, 2].set_title(r'$\\delta$' + '$v_D$')\n\n    # 3. For Attitude Errors:\n    # 3.1. For Roll Angle Error\n    per[2, 0].plot(ter, r2d * errors[:, 7], 'c7', label=r'$\\delta_\\phi$')\n    per[2, 0].hold('on')\n    per[2, 0].plot(tkf, nsig * r2d * kf_sd[:, 7], 'k', label=r'$3\\sigma_\\phi$')\n    per[2, 0].plot(tkf, -nsig * r2d * kf_sd[:, 7], 'k')\n    per[2, 0].set_title(r'$\\delta\\phi$')\n    per[2, 0].set_ylabel('$(deg)$')\n    per[2, 0].set_xlabel('$t (mn)$')\n\n    # 3.2. For Pitch Angle Error\n    per[2, 1].plot(ter, r2d * errors[:, 8], 'c8', label=r'$\\delta_\\theta$')\n    per[2, 1].hold('on')\n    per[2, 1].plot(tkf, nsig * r2d * kf_sd[:, 8], 'k', label=r'$3\\sigma_\\theta$')\n    per[2, 1].plot(tkf, -nsig * r2d * kf_sd[:, 8], 'k')\n    per[2, 1].set_title(r'$\\delta\\theta$')\n    per[2, 1].set_xlabel('$t (mn)$')\n\n    # 3.3. For Yaw Angle Error\n    per[2, 2].plot(ter, r2d * errors[:, 9], 'c9', label=r'$\\delta_\\psi$')\n    per[2, 2].hold('on')\n    per[2, 2].plot(tkf, nsig * r2d * kf_sd[:, 9], 'k', label=r'$3\\sigma_\\psi$')\n    per[2, 2].plot(tkf, -nsig * r2d * kf_sd[:, 9], 'k')\n    per[2, 2].set_title(r'$\\delta\\psi$')\n    per[2, 2].set_xlabel('$t (mn)$')\n\n    # perfig.suptitle(\"Estimation Error Profile over Time\")\n\n    plt.tight_layout()\n\n    return\n\n# End of Plotting Errors for Single Simulation\n\n\n'''\n    ----------------------------------\n    5. Plot Errors for Dual Simulation\n    ----------------------------------\n'''\n\n\ndef plot_dual_error(lc_errors, lc_kf_sd, tc_errors, tc_kf_sd):\n\n    nsig = 3.0                         # Number of sigma (standard deviation)\n    tkf = lc_kf_sd[:, 0] \/ 60.0        # Kalman Filter updating time history\n    ter = lc_errors[:, 0] \/ 60.0       # Output errors updating time history\n\n    # A. Loosely Coupled Errors\n    lc_perfig, lc_per = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 1. For Position Errors:\n    [lc_r_ns, lc_r_ew] = radii_of_curv(lc_kf_sd[0, 1])\n    # 1.1. For North Position Error\n    lc_per[0, 0].plot(ter, lc_errors[:, 1], 'c1', label=r'$\\delta$' + '$r_N$')\n    lc_per[0, 0].hold('on')\n    lc_per[0, 0].plot(tkf, nsig * (lc_kf_sd[:, 1] - lc_kf_sd[0, 1]) * (lc_r_ns + lc_kf_sd[0, 3]), 'k',\n                      label=r'$3\\sigma_N$')\n    lc_per[0, 0].plot(tkf, -nsig * (lc_kf_sd[:, 1] - lc_kf_sd[0, 1]) * (lc_r_ns + lc_kf_sd[0, 3]), 'k')\n    lc_per[0, 0].set_title('$LC$' + ' ' + r'$\\delta$' + '$r_N$')\n    lc_per[0, 0].set_ylabel('$(m)$')\n\n    # 1.2. For East Position Error\n    lc_per[0, 1].plot(ter, lc_errors[:, 2], 'c2', label=r'$\\delta$' + '$r_E$')\n    lc_per[0, 1].hold('on')\n    lc_per[0, 1].plot(tkf, nsig * (lc_kf_sd[:, 2] - lc_kf_sd[0, 2]) * (lc_r_ns + lc_kf_sd[0, 3]) *\n                      np.cos(lc_kf_sd[0, 1]), 'k', label=r'$3\\sigma_E$')\n    lc_per[0, 1].plot(tkf, -nsig * (lc_kf_sd[:, 2] - lc_kf_sd[0, 2]) * (lc_r_ns + lc_kf_sd[0, 3]) *\n                      np.cos(lc_kf_sd[0, 1]), 'k')\n    lc_per[0, 1].set_title('$LC$' + ' ' + r'$\\delta$' + '$r_E$')\n\n    # 1.3. For Down Position Error\n    lc_per[0, 2].plot(ter, lc_errors[:, 3], 'c3', label=r'$\\delta$' + '$r_D$')\n    lc_per[0, 2].hold('on')\n    lc_per[0, 2].plot(tkf, nsig * lc_kf_sd[:, 3], 'k', label=r'$3\\sigma_D$')\n    lc_per[0, 2].plot(tkf, -nsig * lc_kf_sd[:, 3], 'k')\n    lc_per[0, 2].set_title('$LC$' + ' ' + r'$\\delta$' + '$r_D$')\n    lc_per[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 2. For Velocity Errors:\n    # 2.1. For North Velocity Error\n    lc_per[1, 0].plot(ter, lc_errors[:, 4], 'c4', label=r'$\\delta$' + '$v_N$')\n    lc_per[1, 0].hold('on')\n    lc_per[1, 0].plot(tkf, nsig * lc_kf_sd[:, 4], 'k', label=r'$3\\sigma_{v_N}$')\n    lc_per[1, 0].plot(tkf, -nsig * lc_kf_sd[:, 4], 'k')\n    lc_per[1, 0].set_title('$LC$' + ' ' + r'$\\delta$' + '$v_N$')\n    lc_per[1, 0].set_ylabel('$(m\/s)$')\n\n    # 2.2. For East Velocity Error\n    lc_per[1, 1].plot(ter, lc_errors[:, 5], 'c5', label=r'$\\delta$' + '$v_E$')\n    lc_per[1, 1].hold('on')\n    lc_per[1, 1].plot(tkf, nsig * lc_kf_sd[:, 5], 'k', label=r'$3\\sigma_{v_E}$')\n    lc_per[1, 1].plot(tkf, -nsig * lc_kf_sd[:, 5], 'k')\n    lc_per[1, 1].set_title('$LC$' + ' ' + r'$\\delta$' + '$v_E$')\n\n    # 3.3. For Down Velocity Error\n    lc_per[1, 2].plot(ter, lc_errors[:, 6], 'c6', label=r'$\\delta$' + '$v_D$')\n    lc_per[1, 2].hold('on')\n    lc_per[1, 2].plot(tkf, nsig * lc_kf_sd[:, 6], 'k', label=r'$3\\sigma_{v_D}$')\n    lc_per[1, 2].plot(tkf, -nsig * lc_kf_sd[:, 6], 'k')\n    lc_per[1, 2].set_title('$LC$' + ' ' + r'$\\delta$' + '$v_D$')\n\n    # 3. For Attitude Errors:\n    # 3.1. For Roll Angle Error\n    lc_per[2, 0].plot(ter, r2d * lc_errors[:, 7], 'c7', label=r'$\\delta_\\phi$')\n    lc_per[2, 0].hold('on')\n    lc_per[2, 0].plot(tkf, nsig * r2d * lc_kf_sd[:, 7], 'k', label=r'$3\\sigma_\\phi$')\n    lc_per[2, 0].plot(tkf, -nsig * r2d * lc_kf_sd[:, 7], 'k')\n    lc_per[2, 0].set_title('$LC$' + ' ' + r'$\\delta\\phi$')\n    lc_per[2, 0].set_ylabel('$(deg)$')\n    lc_per[2, 0].set_xlabel('$t (mn)$')\n\n    # 3.2. For Pitch Angle Error\n    lc_per[2, 1].plot(ter, r2d * lc_errors[:, 8], 'c8', label=r'$\\delta_\\theta$')\n    lc_per[2, 1].hold('on')\n    lc_per[2, 1].plot(tkf, nsig * r2d * lc_kf_sd[:, 8], 'k', label=r'$3\\sigma_\\theta$')\n    lc_per[2, 1].plot(tkf, -nsig * r2d * lc_kf_sd[:, 8], 'k')\n    lc_per[2, 1].set_title('$LC$' + ' ' + r'$\\delta\\theta$')\n    lc_per[2, 1].set_xlabel('$t (mn)$')\n\n    # 3.3. For Yaw Angle Error\n    lc_per[2, 2].plot(ter, r2d * lc_errors[:, 9], 'c9', label=r'$\\delta_\\psi$')\n    lc_per[2, 2].hold('on')\n    lc_per[2, 2].plot(tkf, nsig * r2d * lc_kf_sd[:, 9], 'k', label=r'$3\\sigma_\\psi$')\n    lc_per[2, 2].plot(tkf, -nsig * r2d * lc_kf_sd[:, 9], 'k')\n    lc_per[2, 2].set_title('$LC$' + ' ' + r'$\\delta\\psi$')\n    lc_per[2, 2].set_xlabel('$t (mn)$')\n\n    # lc_perfig.suptitle(\"Estimation Error Profile over Time\")\n\n    plt.tight_layout()\n\n    # B. Tightly Coupled Errors\n    tc_perfig, tc_per = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 1. For Position Errors:\n    [tc_r_ns, tc_r_ew] = radii_of_curv(tc_kf_sd[0, 1])\n    # 1.1. For North Position Error\n    tc_per[0, 0].plot(ter, tc_errors[:, 1], 'c10', label=r'$\\delta$' + '$r_N$')\n    tc_per[0, 0].hold('on')\n    tc_per[0, 0].plot(tkf, nsig * (tc_kf_sd[:, 1] - tc_kf_sd[0, 1]) * (tc_r_ns + tc_kf_sd[0, 3]), 'k',\n                      label=r'$3\\sigma_N$')\n    tc_per[0, 0].plot(tkf, -nsig * (tc_kf_sd[:, 1] - tc_kf_sd[0, 1]) * (tc_r_ns + tc_kf_sd[0, 3]), 'k')\n    tc_per[0, 0].set_title('$TC$' + ' ' + r'$\\delta$' + '$r_N$')\n    tc_per[0, 0].set_ylabel('$(m)$')\n\n    # 1.2. For East Position Error\n    tc_per[0, 1].plot(ter, tc_errors[:, 2], 'c11', label=r'$\\delta$' + '$r_E$')\n    tc_per[0, 1].hold('on')\n    tc_per[0, 1].plot(tkf, nsig * (tc_kf_sd[:, 2] - tc_kf_sd[0, 2]) * (tc_r_ns + tc_kf_sd[0, 3]) *\n                      np.cos(tc_kf_sd[0, 1]), 'k', label=r'$3\\sigma_E$')\n    tc_per[0, 1].plot(tkf, -nsig * (tc_kf_sd[:, 2] - tc_kf_sd[0, 2]) * (tc_r_ns + tc_kf_sd[0, 3]) *\n                      np.cos(tc_kf_sd[0, 1]), 'k')\n    tc_per[0, 1].set_title('$TC$' + ' ' + r'$\\delta$' + '$r_E$')\n\n    # 1.3. For Down Position Error\n    tc_per[0, 2].plot(ter, tc_errors[:, 3], 'c12', label=r'$\\delta$' + '$r_D$')\n    tc_per[0, 2].hold('on')\n    tc_per[0, 2].plot(tkf, nsig * tc_kf_sd[:, 3], 'k', label=r'$3\\sigma_D$')\n    tc_per[0, 2].plot(tkf, -nsig * tc_kf_sd[:, 3], 'k')\n    tc_per[0, 2].set_title('$TC$' + ' ' + r'$\\delta$' + '$r_D$')\n    tc_per[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 2. For Velocity Errors:\n    # 2.1. For North Velocity Error\n    tc_per[1, 0].plot(ter, tc_errors[:, 4], 'c13', label=r'$\\delta$' + '$v_N$')\n    tc_per[1, 0].hold('on')\n    tc_per[1, 0].plot(tkf, nsig * tc_kf_sd[:, 4], 'k', label=r'$3\\sigma_{v_N}$')\n    tc_per[1, 0].plot(tkf, -nsig * tc_kf_sd[:, 4], 'k')\n    tc_per[1, 0].set_title('$TC$' + ' ' + r'$\\delta$' + '$v_N$')\n    tc_per[1, 0].set_ylabel('$(m\/s)$')\n\n    # 2.2. For East Velocity Error\n    tc_per[1, 1].plot(ter, tc_errors[:, 5], 'c14', label=r'$\\delta$' + '$v_E$')\n    tc_per[1, 1].hold('on')\n    tc_per[1, 1].plot(tkf, nsig * tc_kf_sd[:, 5], 'k', label=r'$3\\sigma_{v_E}$')\n    tc_per[1, 1].plot(tkf, -nsig * tc_kf_sd[:, 5], 'k')\n    tc_per[1, 1].set_title('$TC$' + ' ' + r'$\\delta$' + '$v_E$')\n\n    # 2.3. For Down Velocity Error\n    tc_per[1, 2].plot(ter, tc_errors[:, 6], 'c15', label=r'$\\delta$' + '$v_D$')\n    tc_per[1, 2].hold('on')\n    tc_per[1, 2].plot(tkf, nsig * tc_kf_sd[:, 6], 'k', label=r'$3\\sigma_{v_D}$')\n    tc_per[1, 2].plot(tkf, -nsig * tc_kf_sd[:, 6], 'k')\n    tc_per[1, 2].set_title('$TC$' + ' ' + r'$\\delta$' + '$v_D$')\n\n    # 3. For Attitude Errors:\n    # 3.1. For Roll Angle Error\n    tc_per[2, 0].plot(ter, r2d * tc_errors[:, 7], 'c16', label=r'$\\delta_\\phi$')\n    tc_per[2, 0].hold('on')\n    tc_per[2, 0].plot(tkf, nsig * r2d * tc_kf_sd[:, 7], 'k', label=r'$3\\sigma_\\phi$')\n    tc_per[2, 0].plot(tkf, -nsig * r2d * tc_kf_sd[:, 7], 'k')\n    tc_per[2, 0].set_title('$TC$' + ' ' + r'$\\delta\\phi$')\n    tc_per[2, 0].set_ylabel('$(deg)$')\n    tc_per[2, 0].set_xlabel('$t (mn)$')\n\n    # 3.2. For Pitch Angle Error\n    tc_per[2, 1].plot(ter, r2d * tc_errors[:, 8], 'c17', label=r'$\\delta_\\theta$')\n    tc_per[2, 1].hold('on')\n    tc_per[2, 1].plot(tkf, nsig * r2d * tc_kf_sd[:, 7], 'k', label=r'$3\\sigma_\\theta$')\n    tc_per[2, 1].plot(tkf, -nsig * r2d * tc_kf_sd[:, 7], 'k')\n    tc_per[2, 1].set_title('$TC$' + ' ' + r'$\\delta\\theta$')\n    tc_per[2, 1].set_xlabel('$t (mn)$')\n\n    # 3.3. For Yaw Angle Error\n    tc_per[2, 2].plot(ter, r2d * tc_errors[:, 9], 'c18', label=r'$\\delta_\\psi$')\n    tc_per[2, 2].hold('on')\n    tc_per[2, 2].plot(tkf, nsig * r2d * tc_kf_sd[:, 9], 'k', label=r'$3\\sigma_\\psi$')\n    tc_per[2, 2].plot(tkf, -nsig * r2d * tc_kf_sd[:, 9], 'k')\n    tc_per[2, 2].set_title('$TC$' + ' ' + r'$\\delta\\psi$')\n    tc_per[2, 2].set_xlabel('$t (mn)$')\n\n    # tc_perfig.suptitle(\"Estimation Error Profile over Time\")\n\n    plt.tight_layout()\n\n    # C. Loosely and Tightly Coupled Errors Together\n    perfig, per = plt.subplots(3, 3, sharex=True, figsize=(12, 8))\n\n    # 1. For Position Errors:\n    # 1.1. For North Position Error\n    per[0, 0].plot(ter, lc_errors[:, 1], 'c1', linestyle='--', label='$LC$')\n    per[0, 0].hold('on')\n    per[0, 0].plot(ter, tc_errors[:, 1], 'c10', linestyle='-.', label='$TC$')\n    per[0, 0].set_title(r'$\\delta$' + '$r_N$')\n    per[0, 0].set_ylabel('$(m)$')\n    per[0, 0].legend(loc='best', prop={'size': 10})\n\n    # 1.2. For East Position Error\n    per[0, 1].plot(ter, lc_errors[:, 2], 'c2', linestyle='--', label='$LC$')\n    per[0, 1].hold('on')\n    per[0, 1].plot(ter, tc_errors[:, 2], 'c11', linestyle='-.', label='$TC$')\n    per[0, 1].set_title(r'$\\delta$' + '$r_E$')\n    per[0, 1].legend(loc='best', prop={'size': 10})\n\n    # 1.3. For Down Position Error\n    per[0, 2].plot(ter, lc_errors[:, 3], 'c3', linestyle='--', label='$LC$')\n    per[0, 2].hold('on')\n    per[0, 2].plot(ter, tc_errors[:, 3], 'c12', linestyle='-.', label='$TC$')\n    per[0, 2].set_title(r'$\\delta$' + '$r_D$')\n    per[0, 2].legend(loc='best', prop={'size': 10})\n\n    # 2. For Velocity Errors:\n    # 2.1. For North Velocity Error\n    per[1, 0].plot(ter, lc_errors[:, 4], 'c4', linestyle='--', label='$LC$')\n    per[1, 0].hold('on')\n    per[1, 0].plot(ter, tc_errors[:, 4], 'c13', linestyle='-.', label='$TC$')\n    per[1, 0].set_title(r'$\\delta$' + '$v_N$')\n    per[1, 0].set_ylabel('$(m\/s)$')\n    per[1, 0].legend(loc='best', prop={'size': 10})\n\n    # 2.2. For East Velocity Error\n    per[1, 1].plot(ter, lc_errors[:, 5], 'c5', linestyle='--', label='$LC$')\n    per[1, 1].hold('on')\n    per[1, 1].plot(ter, tc_errors[:, 5], 'c14', linestyle='-.', label='$TC$')\n    per[1, 1].set_title(r'$\\delta$' + '$v_E$')\n    per[1, 1].legend(loc='best', prop={'size': 10})\n\n    # 2.3. For Down Velocity Error\n    per[1, 2].plot(ter, lc_errors[:, 6], 'c6', linestyle='--', label='$LC$')\n    per[1, 2].hold('on')\n    per[1, 2].plot(ter, tc_errors[:, 6], 'c15', linestyle='-.', label='$TC$')\n    per[1, 2].set_title(r'$\\delta$' + '$v_D$')\n    per[1, 2].legend(loc='best', prop={'size': 10})\n\n    # 3. For Attitude Errors:\n    # 3.1. For Roll Angle Error\n    per[2, 0].plot(ter, r2d * lc_errors[:, 7], 'c7', linestyle='--', label='$LC$')\n    per[2, 0].hold('on')\n    per[2, 0].plot(ter, r2d * tc_errors[:, 7], 'c16', linestyle='-.', label='$TC$')\n    per[2, 0].set_title(r'$\\delta\\phi$')\n    per[2, 0].set_ylabel('$(deg)$')\n    per[2, 0].set_xlabel('$t (mn)$')\n    per[2, 0].legend(loc='best', prop={'size': 10})\n\n    # 3.2. For Pitch Angle Error\n    per[2, 1].plot(ter, r2d * lc_errors[:, 8], 'c8', linestyle='--', label='$LC$')\n    per[2, 1].hold('on')\n    per[2, 1].plot(ter, r2d * tc_errors[:, 8], 'c17', linestyle='-.', label='$TC$')\n    per[2, 1].set_title(r'$\\delta\\theta$')\n    per[2, 1].set_xlabel('$t (mn)$')\n    per[2, 1].legend(loc='best', prop={'size': 10})\n\n    # 3.3. For Yaw Angle Error\n    per[2, 2].plot(ter, r2d * lc_errors[:, 9], 'c9', linestyle='--', label='$LC$')\n    per[2, 2].hold('on')\n    per[2, 2].plot(ter, r2d * tc_errors[:, 9], 'c18', linestyle='-.', label='$TC$')\n    per[2, 2].set_title(r'$\\delta\\psi$')\n    per[2, 2].set_xlabel('$t (mn)$')\n    per[2, 2].legend(loc='best', prop={'size': 10})\n\n    # perfig.suptitle(\"Estimation Error Profile over Time\")\n\n    plt.tight_layout()\n\n    return\n\n# End of Plotting Errors for Dual Simulation\n\n\n'''\n========================================================================================================================\n                                                PROCESSING RAW DATA\n========================================================================================================================\n'''\n'''\n    -----------------------------------------------------------------------------------\n    B. Load the raw data into workspace and process raw data into usable formatted data\n    -----------------------------------------------------------------------------------\n'''\n\n\ndef data_processing(fpath, fname):\n    print 'Processing Flight Data...'\n    global datlen, no_epoch\n    no_epoch = 0\n\n    # Assemble full file location\n    in_file = fpath + fname\n\n    # Load the raw data\n    raw_data = sio.loadmat(in_file, struct_as_record=False, squeeze_me=True)\n\n    # Check whether the raw data was unpacked or not\n    if not 'flight_data' in raw_data:\n        # If yes, process the raw data and organize the data into the profile.\n        datlen = len(raw_data['time'])              # Determine the length of raw data\n        gps_lock = raw_data['navValid'] == 0        # Determine the GPS lock moments\n        # Determine the number of true epochs (in which GPS was locked)\n        for i in xrange(0, datlen):\n            if gps_lock[i]:\n                no_epoch += 1\n        # Declare the profile variable\n        flightdata = np.nan * np.ones((no_epoch, 30))\n        k = 0\n        for i in xrange(0, datlen):\n            if gps_lock[i]:\n                # Time is seconds\n                flightdata[k, 0] = raw_data['time'][i]\n\n                # Navigation from EKF_15_State Solution\n                # Latitude and longitude are in radians\n                flightdata[k, 1] = raw_data['navlat'][i]              # latitude\n                flightdata[k, 2] = raw_data['navlon'][i]              # longitude\n                # Altitude is in meters\n                flightdata[k, 3] = raw_data['navalt'][i]              # altitude\n\n                # Velocity components are in m\/s\n                flightdata[k, 4] = raw_data['navvn'][i]               # North velocity\n                flightdata[k, 5] = raw_data['navve'][i]               # East velocity\n                flightdata[k, 6] = raw_data['navvd'][i]               # Down velocity\n\n                # Attitude angles are in radians\n                flightdata[k, 7] = raw_data['phi'][i]                 # roll angle\n                if 'theta' in raw_data:\n                    # If the raw data has \"theta\" for pitch\n                    flightdata[k, 8] = raw_data['theta'][i]           # pitch angle\n                else:\n                    # Else the raw data has \"the\" for pitch\n                    flightdata[k, 8] = raw_data['the'][i]\n                flightdata[k, 9] = raw_data['psi'][i]                 # yaw angle\n\n                # Gyroscope outputs (rad\/s)\n                flightdata[k, 10] = raw_data['p'][i]                  # roll rate\n                flightdata[k, 11] = raw_data['q'][i]                  # pitch rate\n                flightdata[k, 12] = raw_data['r'][i]                  # yaw rate\n\n                # Gyro biases are in rad\/s\n                flightdata[k, 13] = raw_data['p_bias'][i]             # roll rate bias\n                flightdata[k, 14] = raw_data['q_bias'][i]             # pitch rate bias\n                flightdata[k, 15] = raw_data['r_bias'][i]             # yaw rate bias\n\n                # Acceleronmeter outputs (m\/s^2)\n                flightdata[k, 16] = raw_data['ax'][i]                 # specific force in the x-axis\n                flightdata[k, 17] = raw_data['ay'][i]                 # specific force in the y-axis\n                flightdata[k, 18] = raw_data['az'][i]                 # specific force in the z-axis\n\n                # Acceleronmeter biases are in m\/s^2\n                flightdata[k, 19] = raw_data['ax_bias'][i]            # x-acceleration bias\n                flightdata[k, 20] = raw_data['ay_bias'][i]            # y-acceleration bias\n                flightdata[k, 21] = raw_data['az_bias'][i]            # z-acceleration bias\n\n                # Navigation Information from GPS\n                # Latitude and longitude are in degree\n                flightdata[k, 22] = raw_data['lat'][i]\n                flightdata[k, 23] = raw_data['lon'][i]\n\n                # Altitude is in meter\n                flightdata[k, 24] = raw_data['alt'][i]\n\n                # Velocity components are in m\/s\n                flightdata[k, 25] = raw_data['vn'][i]\n                flightdata[k, 26] = raw_data['ve'][i]\n                flightdata[k, 27] = raw_data['vd'][i]\n\n                # Number of satellites used in the GPS solution\n                flightdata[k, 28] = raw_data['satVisible'][i]\n\n                # GPS TOW (GPS Time of the Week in seconds)\n                flightdata[k, 29] = raw_data['GPS_TOW'][i]\n\n                k += 1\n            # End of If Statement on GPS Lock\n        # End of For Loop Sweeping Through the Data\n    else:\n        # If not, pull the data out of the \"flight_data\" struct element.\n        unpackdata = raw_data['flight_data']\n        datlen = len(unpackdata.time)  # Determine the length of raw data\n        gps_lock = unpackdata.navValid == 0  # Determine the GPS lock moments\n\n        # Determine the number of true epochs (in which GPS was locked)\n        for i in xrange(0, datlen):\n\n            if gps_lock[i]:\n                no_epoch += 1\n\n        # Declare the profile variable\n        flightdata = np.nan * np.ones((no_epoch, 30))\n        k = 0\n        for i in xrange(0, datlen):\n\n            if gps_lock[i]:\n\n                # Time is seconds\n                flightdata[k, 0] = unpackdata.time[i]\n\n                # Navigation from EKF_15_State Solution\n                # Latitude and longitude are in rad\n                flightdata[k, 1] = unpackdata.navlat[i]         # latitude\n                flightdata[k, 2] = unpackdata.navlon[i]         # longitude\n                # Altitude is in meter\n                flightdata[k, 3] = unpackdata.navalt[i]         # altitude\n\n                # Velocity components are in m\/s\n                flightdata[k, 4] = unpackdata.navvn[i]          # North velocity\n                flightdata[k, 5] = unpackdata.navve[i]          # East velocity\n                flightdata[k, 6] = unpackdata.navvd[i]          # Down velocity\n\n                # Attitude angles are in radian\n                flightdata[k, 7] = unpackdata.phi[i]            # roll angle\n                # If the raw data has \"theta\" for pitch\n                if hasattr(unpackdata, 'theta'):\n                    flightdata[k, 8] = unpackdata.theta[i]      # pitch angle\n                # Else the raw data has \"the\" for pitch\n                else:\n                    flightdata[k, 8] = unpackdata.the[i]\n                flightdata[k, 9] = unpackdata.psi[i]            # yaw angle\n\n                # Gyroscope outputs (rad\/s)\n                flightdata[k, 10] = unpackdata.p[i]           # roll rate\n                flightdata[k, 11] = unpackdata.q[i]           # pitch rate\n                flightdata[k, 12] = unpackdata.r[i]           # yaw rate\n\n                # Gyroscope biases are in rad\/s\n                flightdata[k, 13] = unpackdata.p_bias[i]      # roll rate bias\n                flightdata[k, 14] = unpackdata.q_bias[i]      # pitch rate bias\n                flightdata[k, 15] = unpackdata.r_bias[i]      # yaw rate bias\n\n                # Acceleronmeter outputs (m\/s^2)\n                flightdata[k, 16] = unpackdata.ax[i]          # specific force in the x-axis\n                flightdata[k, 17] = unpackdata.ay[i]          # specific force in the y-axis\n                flightdata[k, 18] = unpackdata.az[i]          # specific force in the z-axis\n\n                # Acceleronmeter biases are in m\/s^2\n                if hasattr(unpackdata, 'ax_bias'):\n                    flightdata[k, 19] = unpackdata.ax_bias[i]      # x-acceleration bias\n                else:\n                    flightdata[k, 19] = unpackdata.ax_bias_nav[i]  # x-acceleration bias\n                if hasattr(unpackdata, 'ay_bias'):\n                    flightdata[k, 20] = unpackdata.ay_bias[i]      # y-acceleration bias\n                else:\n                    flightdata[k, 20] = unpackdata.ay_bias_nav[i]  # y-acceleration bias\n                if hasattr(unpackdata, 'az_bias'):\n                    flightdata[k, 21] = unpackdata.az_bias[i]      # z-acceleration bias\n                else:\n                    flightdata[k, 21] = unpackdata.az_bias_nav[i]  # z-acceleration bias\n\n                # Navigation Information from GPS\n                # Latitude and longitude are in degree\n                flightdata[k, 22] = unpackdata.lat[i]\n                flightdata[k, 23] = unpackdata.lon[i]\n\n                # Altitude is in meter\n                flightdata[k, 24] = unpackdata.alt[i]\n\n                # Velocity components are in m\/s\n                flightdata[k, 25] = unpackdata.vn[i]\n                flightdata[k, 26] = unpackdata.ve[i]\n                flightdata[k, 27] = unpackdata.vd[i]\n\n                # Number of satellites used in the GPS solution\n                flightdata[k, 28] = unpackdata.satVisible[i]\n\n                # GPS TOW (GPS Time of the Week in seconds)\n                flightdata[k, 29] = unpackdata.GPS_TOW[i]\n\n                k += 1\n            # End of If Statement on GPS Lock\n        # End of For Loop Sweeping Through the Data\n    # ------------------------------------------------------------------------------------\n    # End of If Statement on Checking for Data Status\n\n    # Off set the time so that the first GPS lock moment is the initial time, t_o = 0 s.\n    flightdata[:, 0] = flightdata[:, 0] - flightdata[0, 0]\n    flightdata = np.matrix(flightdata)\n\n    return flightdata, no_epoch\n\n# End of Data Processing\n\n\n'''\n    ------------------------------------------------------------------------------------\n    C. Load the raw navigation and observation messages into workspace and process them\n    ------------------------------------------------------------------------------------\n'''\n\n\ndef ephem_processing(fpath, fname_n, TOW, DyOM):\n\n    print 'Processing the Navigation Message...'\n\n    # Assemble full file location and open the file\n    nav_message = open(fpath+fname_n, 'r')\n\n    # Place holders\n    raw_ephem = np.nan*np.ones((1, 35))\n    iono_alpha = np.nan*np.ones((1, 4))\n    iono_beta = np.nan*np.ones((1, 4))\n    alma_t_para = np.nan*np.ones((1, 4))\n\n    # Reading navigation message file's header\n    end_of_header = False\n    nav_hdr_cnt = 0\n    while not end_of_header:\n        nav_header = nav_message.readline()\n        # print 'HLine #%s:_%s' % (nav_hdr_cnt, nav_header)\n        words = nav_header.strip().split()\n        # Checking for the end of header\n        if words == ['END', 'OF', 'HEADER']:\n            end_of_header = True\n        # Reading ionosphere alpha parameters (A0 - A3) of almanac\n        elif words[-1] == 'ALPHA':\n            nav_header = nav_header.replace('D', 'E')\n            for j in xrange(0, 4):\n                iono_alpha[0][j] = float(nav_header[2 + j*12:2 + (j + 1)*12])\n        # Reading ionosphere beta parameters (B0 - B3) of almanac\n        elif words[-1] == 'BETA':\n            nav_header = nav_header.replace('D', 'E')\n            for j in xrange(0, 4):\n                iono_beta[0][j] = float(nav_header[2 + j*12:2 + (j + 1)*12])\n        # Reading almanac parameters to compute time in UTC\n        elif words[-1] == 'A0,A1,T,W':\n            nav_header = nav_header.replace('D', 'E')\n            alma_t_para[0][0] = float(nav_header[3:3 + 19])\n            alma_t_para[0][1] = float(nav_header[3 + 19:3 + 2*19])\n            alma_t_para[0][2] = int(nav_header[3 + 2*19:3 + 2*19 + 9])\n            alma_t_para[0][3] = int(nav_header[3 + 2*19 + 9: 3 + 2*19 + 2*9])\n\n        nav_hdr_cnt += 1\n    # End of reading the navigation message's header\n\n    # ******************************************************************************************************************\n\n    # Reading navigation message content\n    cnt0 = 0\n    cnt2 = 0\n    for nav_line in nav_message:\n        # print 'Line #%s:_%s' % (cnt0, nav_line)\n        # Replacing scientific notation 'D' by 'E' so that we can convert a string to a number\n        nav_line = nav_line.replace('D', 'E')\n        if cnt0 <= 7:\n            # Reading the PRN\/EPOCH\/SV CLK\n            if np.mod(cnt0, 8) == 0:\n                cnt1 = 0\n                raw_ephem[cnt2][0] = int(nav_line[0:2])                     # Col. 0: PRN\n                raw_ephem[cnt2][1] = int(nav_line[3:5])                     # Col. 1: Toc - Year\n                raw_ephem[cnt2][2] = int(nav_line[6:8])                     # Col. 2: Toc - Month\n                raw_ephem[cnt2][3] = int(nav_line[9:11])                    # Col. 3: Toc - Day\n                raw_ephem[cnt2][4] = int(nav_line[12:14])                   # Col. 4: Toc - Hour (hr)\n                raw_ephem[cnt2][5] = int(nav_line[15:17])                   # Col. 5: Toc - Minute (mn)\n                raw_ephem[cnt2][6] = float(nav_line[17:22])                 # Col. 6: Toc - Second (s)\n                raw_ephem[cnt2][7] = float(nav_line[22:22 + 19])            # Col. 7: SV clock bias (s)\n                raw_ephem[cnt2][8] = float(nav_line[22 + 19:22 + 2*19])     # Col. 8: SV clock drift (s\/s)\n                raw_ephem[cnt2][9] = float(nav_line[22 + 2*19:22 + 3*19])   # Col. 9: SV clock drift rate (s\/s^2)\n                cnt3 = 9\n            else:\n                cnt1 += 1\n                # Reading IODE\/Crs\/Delta n\/Mo\n                if cnt1 == 1:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 10: IODE - Issue of Data, Ephemeris\n                        # Col. 11: Crs      (meter)\n                        # Col. 12: Delta n  (rad\/sec)\n                        # Col. 13: Mo       (rad)\n                # Reading Cuc\/e Eccentricity\/Cus\/Sqrt(A)\n                elif cnt1 == 2:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 14: Cuc              (rad)\n                        # Col. 15: Eccentricity, e\n                        # Col. 16: Cus              (rad)\n                        # Col. 17: sqrt(A)          (sqrt(meter))\n                # Reading Toe\/Cic\/OMEGA\/Cis\n                elif cnt1 == 3:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 18: Toe, time of ephemeris   (sec of GPS Week)\n                        # Col. 19: Cic                      (rad)\n                        # Col. 20: OMEGA                    (rad)\n                        # Col. 21: Cis                      (rad)\n                # Reading Inclination\/Crc\/omega\/OMEGA DOT\n                elif cnt1 == 4:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 22: i_o, reference inclination   (rad)\n                        # Col. 23: Crc                          (meter)\n                        # Col. 24: omega                        (rad)\n                        # Col. 25: OMEGA DOT                    (rad\/sec)\n                # Reading IDOT\/L2 Codes\/GPS Week# (to go with Toe)\/L2 P data flag\n                elif cnt1 == 5:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 26: IDOT, inclination rate (rad\/sec)\n                        # Col. 27: Codes on L2 channel\n                        # Col. 28: GPS Week # (to go with Toe)\n                        # Col. 29: L2 P data flag\n                # Reading SV accuracy\/SV health\/TGD\/IODC\n                elif cnt1 == 6:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        raw_ephem[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                        # Col. 30: SV accuracy  (meter)\n                        # Col. 31: SV health\n                        # Col. 32: TGD          (sec)\n                        # Col. 33: IODC - Issue of Data, Clock\n                # Reading Transmission time of message (sec of GPS week)\n                elif cnt1 == 7:\n                    raw_ephem[cnt2][34] = float(nav_line[3:3 + 19])\n                    # Col. 34: Tsv - transmission time of message (sec of GPS week)\n                    # Update the row count in \"raw_ephem\" array\n                    cnt2 += 1\n                    # First time declare \"temp\" array\n                    temp = np.nan*np.ones((cnt2 + 1, 35))\n                    # Cast \"raw_ephem\" into the first row of \"temp\"\n                    temp[0:cnt2][:] = raw_ephem\n        # Done reading the first time entry\n        else:\n            # Reading the PRN\/EPOCH\/SV CLK\n            if np.mod(cnt0, 8) == 0:\n                cnt1 = 0\n                temp[cnt2][0] = int(nav_line[0:2])\n                temp[cnt2][1] = int(nav_line[3:5])\n                temp[cnt2][2] = int(nav_line[6:8])\n                temp[cnt2][3] = int(nav_line[9:11])\n                temp[cnt2][4] = int(nav_line[12:14])\n                temp[cnt2][5] = int(nav_line[15:17])\n                temp[cnt2][6] = float(nav_line[17:22])\n                temp[cnt2][7] = float(nav_line[22:22 + 19])\n                temp[cnt2][8] = float(nav_line[22 + 19:22 + 2*19])\n                temp[cnt2][9] = float(nav_line[22 + 2*19:22 + 3*19])\n                cnt3 = 9\n            else:\n                cnt1 += 1\n                # Reading IODE\/Crs\/Delta n\/Mo\n                if cnt1 == 1:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading Cuc\/e Eccentricity\/Cus\/Sqrt(A)\n                elif cnt1 == 2:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading Toe\/Cic\/OMEGA\/Cis\n                elif cnt1 == 3:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading Inclination\/Crc\/omega\/OMEGA DOT\n                elif cnt1 == 4:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading IDOT\/L2 Codes\/GPS Week# (to go with Toe)\/L2 P data flag\n                elif cnt1 == 5:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading SV accuracy\/SV health\/TGD\/IODC\n                elif cnt1 == 6:\n                    for i in xrange(0, 4):\n                        cnt3 += 1\n                        temp[cnt2][cnt3] = float(nav_line[3 + i*19:3 + (i + 1)*19])\n                # Reading Transmission time of message (sec of GPS week)\n                elif cnt1 == 7:\n                    temp[cnt2][34] = float(nav_line[3:3 + 19])\n                    # Update the raw_ephem array\n                    raw_ephem = temp\n                    # Update the row count in raw_ephem array\n                    cnt2 += 1\n                    # Extend the \"temp\" array by one row\n                    temp = np.nan*np.ones((cnt2 + 1, 35))\n                    # Cast the \"raw_ephem\" array into the extended \"temp[0:n-1][:]\"\n                    temp[0:cnt2][:] = raw_ephem\n        # Just read another time entry\n        # Update the nav_line count\n        cnt0 += 1\n    # End of \"for\" loop over the navigation message\n    # Close the navigation file\n    nav_message.close()\n\n    # \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n    #                           EXTRACTING THE EPHEMERIS OUT OF THE NAVIGATION MESSAGE\n    # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n    # Post processing the ephemeris:\n    print 'Extracting the Ephemeris...'\n\n    # Rounding up the time stamp base on the minute\n    rndup_index = []\n    rnddown_index = []\n    # Loop over the entire \"raw_ephem\" array\n    for i in xrange(0, len(raw_ephem)):\n        # If the minute is not exactly zero, then round up hour, minute, and second\n        if raw_ephem[i, 5] != 0:\n            # If the minute is less than 30,\n            if raw_ephem[i, 5] < 30:\n                raw_ephem[i, 4] -= 1        # round the hour down by 1 unit\n                raw_ephem[i, 5] = 0         # set the minute to zero\n                raw_ephem[i, 6] = 0         # set the second to zero\n                rnddown_index.append(i)\n            # If the minute is greater than or equal 30,\n            elif raw_ephem[i, 5] >= 30:\n                raw_ephem[i, 4] += 1        # round the hour up by 1 unit\n                raw_ephem[i, 5] = 0         # set the minute to zero\n                raw_ephem[i, 6] = 0         # set the second to zero\n                rndup_index.append(i)\n    # Create the flags for different types of rounding\n    if rnddown_index:\n        rnddown_flag = True\n    elif rndup_index:\n        rndup_flag = True\n    elif not (rndup_index and rnddown_index):\n        rnddown_flag = False\n        rndup_flag = False\n\n    # Collect the initial and final TOWs from the flight data\n    TOWo = TOW[0]       # Initial time of week (seconds)\n    TOWf = TOW[-1]      # Final time of week (seconds)\n    # Days of week based on the initial time of week\n    DyOW = (TOWo - np.mod(TOWo, dd2sec))\/dd2sec         # days\n    # The remaining seconds of the day after extracting the days\n    rem_sec = np.mod(TOWo, dd2sec)                      # seconds\n    # Hours of the day\n    HrOD = (rem_sec - np.mod(rem_sec, hr2sec))\/hr2sec   # hours\n    # The remaining seconds of the hour after extracting days and hours\n    rem_sec = np.mod(rem_sec, hr2sec)                   # seconds\n    # Minutes of the hour\n    MnOH = (rem_sec - np.mod(rem_sec, mn2sec))\/mn2sec   # minutes\n    # Flight duration in GPS time (seconds)\n    deltaTOW = TOWf - TOWo\n    if (rem_sec + deltaTOW)\/mn2sec <= 60:\n        LkUpHr = HrOD\n    elif (rem_sec + deltaTOW)\/mn2sec > 60:\n        LkUpHr = HrOD + 1\n    print \"Look-up hour: %d\" % LkUpHr\n    # Look up for the nearest time stamp, then collect the PRNs in this time stamp.\n    ephem = np.nan*np.ones((32, 17))\n    sv_clock = np.nan * np.ones((32, 5))\n    search_again = False\n    prev_PRN = 0\n    PRN = 1\n    cnt4 = 0\n    # Loop over the entire \"raw_ephem\" array\n    for i in xrange(0, len(raw_ephem)):\n        # Look up the day of the month\n        if raw_ephem[i, 3] == DyOM:\n            # If found the day, look up the hour\n            if raw_ephem[i, 4] == LkUpHr:\n                # If the hour matches, check for new PRN\n                if raw_ephem[i, 0] == PRN and raw_ephem[i, 0] != prev_PRN:\n                    # If new PRN is found, collect the ephemeris parameters\n                    for j in xrange(0, 17):\n                        if j == 0:\n                            ephem[cnt4, j] = raw_ephem[i, 0]\n                            # Col. 0: PRN\n                        else:\n                            ephem[cnt4, j] = raw_ephem[i, 10 + j]\n                            # Col. 1: Crs                           (meter)\n                            # Col. 2: Delta n                       (rad\/sec)\n                            # Col. 3: Mo                            (rad)\n                            # Col. 4: Cuc                           (rad)\n                            # Col. 5: Eccentricity, e\n                            # Col. 6: Cus                           (rad)\n                            # Col. 7: sqrt(A)                       (sqrt(meter))\n                            # Col. 8: Toe, time of ephemeris        (sec of GPS Week)\n                            # Col. 9: Cic                           (rad)\n                            # Col. 10: OMEGA                        (rad)\n                            # Col. 11: Cis                          (rad)\n                            # Col. 12: i_o, reference inclination   (rad)\n                            # Col. 13: Crc                          (meter)\n                            # Col. 14: omega                        (rad)\n                            # Col. 15: OMEGA DOT                    (rad\/sec)\n                            # Col. 16: IDOT, inclination rate       (rad\/sec)\n                    # Collect the SV Clock information\n                    for m in xrange(0, 5):\n                        # Collect af0, af1, and af2\n                        if m < 3:\n                            sv_clock[cnt4, m] = raw_ephem[i, m + 7]\n                        # Collect toc, time of clock                (sec of GPS Week)\n                        elif m == 3:\n                            sv_clock[cnt4, m] = DyOW*dd2sec + LkUpHr*hr2sec + raw_ephem[i, 5]*mn2sec + raw_ephem[i, 6]\n                        # Collect TGD, group delay                  (sec)\n                        else:\n                            sv_clock[cnt4, m] = raw_ephem[i, 32]\n                    # Remember the current PRN\n                    prev_PRN = PRN\n                    # Update the PRN and the \"ephemeris\" row index\n                    PRN += 1\n                    cnt4 += 1\n                elif raw_ephem[i, 0] == (PRN - 1) and raw_ephem[i, 0] == prev_PRN:\n                    # Else if the PRN is repeated, check for rounding condition\n                    if rndup_flag:\n                        # If the previous time stamp was rounded up,\n                        print \"Used the original time stamp instead of the rounded up on PRN %s\" % prev_PRN\n                        # use the current (original) time stamp instead of the rounding one.\n                        for j in xrange(0, 17):\n                            if j == 0:\n                                ephem[cnt4 - 1, j] = raw_ephem[i, 0]\n                            else:\n                                ephem[cnt4 - 1, j] = raw_ephem[i, 10 + j]\n                        # Collect the SV Clock information\n                        for m in xrange(0, 5):\n                            # Collect af0, af1, and af2\n                            if m < 3:\n                                sv_clock[cnt4 - 1, m] = raw_ephem[i, m + 7]\n                            # Collect toc, time of clock                (sec of GPS Week)\n                            elif m == 3:\n                                sv_clock[cnt4 - 1, m] = DyOW * dd2sec + LkUpHr * hr2sec + raw_ephem[i, 5] * mn2sec + \\\n                                                     raw_ephem[i, 6]\n                            # Collect TGD, group delay                  (sec)\n                            else:\n                                sv_clock[cnt4 - 1, m] = raw_ephem[i, 32]\n                    elif rnddown_flag:\n                        # If the current time stamp is rounded down, skipped it and used the previous (original) one.\n                        print 'Skipped repeated rounded down time stamp on PRN %s' % prev_PRN\n    # End of \"raw_ephem\" and did not find all 32 satellites in the time stamp,\n    # or did not find any time stamp that matches the look up hour.\n        elif i == (len(raw_ephem) - 1) and cnt4 < 32:\n            # If the hour does not match, adjust the look up hour based on the minute of the hour.\n            print \"Did not find any time stamp that matches the initial TOW.\"\n            if MnOH <= 30:\n                # If the minute is less than or equal to 30,\n                HrOD -= 1         # decrease the look up hour by 1 unit\n                if (rem_sec + deltaTOW) \/ mn2sec <= 60:\n                    LkUpHr = HrOD\n                elif (rem_sec + deltaTOW) \/ mn2sec > 60:\n                    LkUpHr = HrOD + 1\n                print \"Change look up hour to %d.\" % LkUpHr\n            elif MnOH > 30:\n                # If the minute is greater than 30,\n                HrOD += 1         # increase the look up hour by 1 unit\n                if (rem_sec + deltaTOW) \/ mn2sec <= 60:\n                    LkUpHr = HrOD\n                elif (rem_sec + deltaTOW) \/ mn2sec > 60:\n                    LkUpHr = HrOD + 1\n                print \"Change look up hour to %d.\" % LkUpHr\n            search_again = True\n\n    if search_again:\n        prev_PRN = 0\n        PRN = 1\n        cnt4 = 0\n        while cnt4 < 32:\n            for k in xrange(0, len(raw_ephem)):\n                # Look up the day of the month\n                if raw_ephem[k, 3] == DyOM:\n                    # If found the day, look up the hour\n                    if raw_ephem[k, 4] == LkUpHr:\n                        # If the hour matches, check for new PRN\n                        if raw_ephem[k, 0] == PRN and raw_ephem[k, 0] != prev_PRN:\n                            # If new PRN is found, collect the ephemeris parameters\n                            for j in xrange(0, 17):\n                                if j == 0:\n                                    ephem[cnt4, j] = raw_ephem[k, 0]\n                                else:\n                                    ephem[cnt4, j] = raw_ephem[k, 10 + j]\n                            # Collect the SV Clock information\n                            for m in xrange(0, 5):\n                                # Collect af0, af1, and af2\n                                if m < 3:\n                                    sv_clock[cnt4, m] = raw_ephem[k, m + 7]\n                                # Collect toc, time of clock                (sec of GPS Week)\n                                elif m == 3:\n                                    sv_clock[cnt4, m] = DyOW * dd2sec + LkUpHr * hr2sec + raw_ephem[k, 5] * mn2sec + \\\n                                                        raw_ephem[k, 6]\n                                # Collect TGD, group delay                  (sec)\n                                else:\n                                    sv_clock[cnt4, m] = raw_ephem[k, 32]\n                            # Remember the current PRN\n                            prev_PRN = PRN\n                            # Update the PRN and \"ephemeris\" row index\n                            PRN += 1\n                            cnt4 += 1\n                        elif raw_ephem[k, 0] == (PRN - 1) and raw_ephem[k, 0] == prev_PRN:\n                            # Else if the PRN is repeated, check for rounding condition\n                            if rndup_flag:\n                                # If the previous time stamp was rounded up,\n                                print \"Used the original time stamp instead of the rounded up on PRN %s\" % prev_PRN\n                                # use the current (original) time stamp instead of the rounding one.\n                                for j in xrange(0, 17):\n                                    if j == 0:\n                                        ephem[cnt4 - 1, j] = raw_ephem[k, 0]\n                                    else:\n                                        ephem[cnt4 - 1, j] = raw_ephem[k, 10 + j]\n                                # Collect the SV Clock information\n                                for m in xrange(0, 5):\n                                    # Collect af0, af1, and af2\n                                    if m < 3:\n                                        sv_clock[cnt4 - 1, m] = raw_ephem[k, m + 7]\n                                    # Collect toc, time of clock                (sec of GPS Week)\n                                    elif m == 3:\n                                        sv_clock[cnt4 - 1, m] = DyOW * dd2sec + LkUpHr * hr2sec + \\\n                                                         raw_ephem[k, 5] * mn2sec + raw_ephem[k, 6]\n                                    # Collect TGD, group delay                  (sec)\n                                    else:\n                                        sv_clock[cnt4 - 1, m] = raw_ephem[k, 32]\n                            elif rnddown_flag:\n                                # If the current time stamp is rounded down,\n                                # skipped it and used the previous (original) one\n                                print 'Skipped repeated rounded down time stamp on PRN %s' % prev_PRN\n\n    # Finish reading and processing navigation message\n\n    return iono_alpha, iono_beta, alma_t_para, sv_clock, raw_ephem, ephem\n\n# End of Ephemeris Processing\n\n\n'''\n========================================================================================================================\n                                                SYSTEM CONFIGURATIONS\n========================================================================================================================\n'''\n'''\n    ---------------------------\n    A. IMU Configuration Struct\n    ---------------------------\n'''\n\n\nclass ImuConfigStruct:\n\n    def __init__(self):\n        self.b_a = np.nan * np.ones((3, 1))\n        self.b_g = np.nan * np.ones((3, 1))\n        self.M_a = np.nan * np.matrix(np.ones((3, 3)))\n        self.M_g = np.nan * np.matrix(np.ones((3, 3)))\n        self.G_g = np.nan * np.matrix(np.ones((3, 3)))\n        self.accel_noise_root_PSD = np.nan\n        self.gyro_noise_root_PSD = np.nan\n        self.accel_quant_level = np.nan\n        self.gyro_quant_level = np.nan\n\n\n'''\n    ----------------------------\n    B. GNSS Configuration Struct\n    ----------------------------\n'''\n\n\nclass GnssConfigStruct:\n\n    def __init__(self):\n        self.epoch_interval = np.nan\n        self.init_est_r_ea_e = np.nan * np.ones((3, 1))\n        self.init_est_v_ea_e = np.nan * np.ones((3, 1))\n        self.no_sat = np.nan\n        self.r_os = np.nan\n        self.inclination = np.nan\n        self.const_delta_lon = np.nan\n        self.const_t_offset = np.nan\n        self.mask_angle = np.nan\n        self.SIS_err_SD = np.nan\n        self.zenith_iono_err_SD = np.nan\n        self.zenith_trop_err_SD = np.nan\n        self.code_track_err_ID = np.nan\n        self.rate_track_err_ID = np.nan\n        self.rx_clock_offset = np.nan\n        self.rx_clock_drift = np.nan\n\n\n'''\n    ---------------------------\n    C. EKF Configuration Struct\n    ---------------------------\n'''\n\n\nclass EkfConfigStruct:\n\n    def __init__(self):\n        self.init_att_unc = np.nan\n        self.init_vel_unc = np.nan\n        self.init_pos_unc = np.nan\n        self.init_b_a_unc = np.nan\n        self.init_b_g_unc = np.nan\n        self.gyro_clock_offset_unc = np.nan\n        self.init_clock_drift_unc = np.nan\n        self.gyro_noise_PSD = np.nan\n        self.accel_noise_PSD = np.nan\n        self.accel_bias_PSD = np.nan\n        self.gyro_bias_PSD = np.nan\n        self.clock_freq_PSD = np.nan\n        self.clock_phase_PSD = np.nan\n        self.pseudo_range_SD = np.nan\n        self.range_rate_SD = np.nan\n        self.pos_meas_SD = np.nan\n        self.vel_meas_SD = np.nan\n\n\n'''\n    -------------------------------------------------------------------\n    D. Initial Errors of Attitude Angles (radian) Resolved in NED Frame\n    -------------------------------------------------------------------\n'''\n\n\ndef att_init_error(r_err, p_err, y_err, unit):\n\n    print ' Set Initial Errors...'\n\n    if unit == 'radian':\n        eul_err_nb_n = np.array([[r_err], [p_err], [y_err]])\n    elif unit == 'degree':\n        eul_err_nb_n = d2r * np.array([[r_err], [p_err], [y_err]])\n\n    return eul_err_nb_n\n\n# End of Attitude Error Initialization\n\n\n'''\n    -----------------------------\n    E. IMU Configuration Function\n    -----------------------------\n'''\n\n\ndef imu_configuration(imugrade):\n\n    print ' Setup IMU Configuraton...'\n    imu_config = ImuConfigStruct()\n\n    if imugrade == 'aviation':\n\n        # Accelerometer biases (micro-g --> m\/s^2; body axes)\n        imu_config.b_a = micro_g * np.matrix([[30.0], [-45.0], [26.0]])\n\n        # Gyro biases (deg\/hr --> rad\/s; body axes)\n        imu_config.b_g = (d2r \/ 3600.0) * np.matrix([[-0.0009], [0.0013], [-0.0008]])\n\n        # Accelerometer scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_a = 1.0e-06 * np.matrix([[100.0, -120.0, 80.0],\n                                             [-60.0, -120.0, 100.0],\n                                             [-100.0, 40.0, 90.0]])\n\n        # Gyro scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_g = 1.0e-06 * np.matrix([[8.0, -120.0, 100.0],\n                                             [0.0, -6.0, -60.0],\n                                             [0.0, 0.0, -7.0]])\n\n        # Gyro g-dependent biases (deg\/hr\/g --> rad-s\/m; body axes)\n        imu_config.G_g = -(d2r \/ (3600.0 * g)) * np.matrix(np.zeros(3))\n\n        # Accelerometer noise sqrt(PSD) (micro-g\/sqrt(Hz) --> m\/s^1.5)\n        imu_config.accel_noise_root_PSD = 20.0 * micro_g\n\n        # Gyro noise root PSD (deg\/sqrt(hr) --> rad\/sqrt(s))\n        imu_config.gyro_noise_root_PSD = 0.002 * d2r \/ 60.0\n\n        # Accelerometer quantization level (m\/s^2)\n        imu_config.accel_quant_level = 5.0e-05\n\n        # Gyro quantization level (rad\/s)\n        imu_config.gyro_quant_level = 1.0e-06\n\n    elif imugrade == 'consumer':\n\n        # Accelerometer biases (micro-g --> m\/s^2; body axes)\n        imu_config.b_a = micro_g * np.array([[9.0e03], [-1.3e04], [8.0e03]])\n\n        # Gyro biases (deg\/hr --> rad\/s; body axes)\n        imu_config.b_g = (d2r \/ 3600.0) * np.array([[-1.8e02], [2.6e02], [-1.6e02]])\n\n        # Accelerometer scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_a = 1.0e-06 * np.matrix([[5.0e4,  -1.5e04,  1.0e04],\n                                             [-7.5e03, -6.0e04, 1.25e04],\n                                             [-1.25e04, 5.0e03,  2.0e04]])\n\n        # Gyro scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_g = 1.0e-06 * np.matrix([[4.0e04, -1.4e04,  1.25e04],\n                                              [0.0,    -3.0e04,  -7.5e03],\n                                              [0.0,        0.0, -1.75e04]])\n\n        # Gyro g-dependent biases (deg\/hr\/g --> rad-s\/m; body axes)\n        imu_config.G_g = (d2r \/ (3600.0 * g)) * np.matrix([[9.0e01, -1.1e02, -6.0e01],\n                                                          [-5.0e01,  1.9e02, -1.6e02],\n                                                           [3.0e01,  1.1e02, -1.3e02]])\n\n        # Accelerometer noise sqrt(PSD) (micro-g\/sqrt(Hz) --> m\/s^1.5)\n        imu_config.accel_noise_root_PSD = 1000.0 * micro_g\n\n        # Gyro noise root PSD (deg\/sqrt(hr) --> rad\/sqrt(s))\n        imu_config.gyro_noise_root_PSD = 1.0 * d2r \/ 60.0\n\n        # Accelerometer quantization level (m\/s^2)\n        imu_config.accel_quant_level = 1.0e-01\n\n        # Gyro quantization level (rad\/s)\n        imu_config.gyro_quant_level = 2.0e-03\n\n    elif imugrade == 'tactical':\n\n        # Accelerometer biases (micro-g --> m\/s^2; body axes)\n        imu_config.b_a = micro_g * np.array([[9.0e02], [-13.0e02], [8.0e02]])\n\n        # Gyro biases (deg\/hr --> rad\/s; body axes)\n        imu_config.b_g = (d2r \/ 3600.0) * np.array([[-9.0], [13.0], [-8.0]])\n\n        # Accelerometer scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_a = 1.0e-06 * np.matrix([[5.0e02, -3.0e02, 2.0e02],\n                                             [-1.5e02, -6.0e02, 2.5e02],\n                                             [-2.5e02,  1.0e02, 4.5e02]])\n\n        # Gyro scale factor and cross coupling errors (ppm --> unitless; body axes)\n        imu_config.M_g = 1.0e-06 * np.matrix([[4.0e02, -3.0e02,  2.5e02],\n                                              [0.0,    -3.0e02, -1.5e02],\n                                              [0.0,        0.0, -3.5e02]])\n\n        # Gyro g-dependent biases (deg\/hr\/g --> rad-s\/m; body axes)\n        imu_config.G_g = (d2r \/ (3600.0 * g)) * np.matrix([[0.9, -1.1, -0.6],\n                                                          [-0.5,  1.9, -1.6],\n                                                           [0.3,  1.1, -1.3]])\n\n        # Accelerometer noise root PSD (micro-g\/sqrt(Hz) --> m\/s^1.5)\n        imu_config.accel_noise_root_PSD = 100.0 * micro_g\n\n        # Gyro noise root PSD (deg\/sqrt(hr) --> rad\/sqrt(s))\n        imu_config.gyro_noise_root_PSD = 0.01 * d2r \/ 60.0\n\n        # Accelerometer quantization level (m\/s^2)\n        imu_config.accel_quant_level = 1.0e-02\n\n        # Gyro quantization level (rad\/s)\n        imu_config.gyro_quant_level = 2.0e-04\n\n    # End of \"If\" Statement\n\n    return imu_config\n\n# End of IMU Configuration\n\n\n'''\n    ---------------------\n    F. GNSS Configuration\n    ---------------------\n'''\n\n\ndef gnss_configuration(frequence, constellation, tow):\n\n    print ' Setup GNSS Constellation...'\n    gnss_config = GnssConfigStruct()\n\n    if constellation == 'gps':\n\n        gnss_config.epoch_interval = 1.0 \/ frequence            # GNSS updating frequency (Hz --> sec)\n        gnss_config.init_est_r_ea_e = np.zeros((3, 1))          # Initial estimated position (m; ECEF)\n        gnss_config.init_est_v_ea_e = np.zeros((3, 1))          # Initial estimated velocity (m\/s; ECEF)\n        gnss_config.no_sat = 32                                 # Number of satellites in constellation\n        gnss_config.r_os = 2.656175e+07                         # Orbital radius of satellites (m)\n        gnss_config.inclination = 55.0                          # Inclination angle of satellites (deg)\n        gnss_config.const_delta_lon = 0.0                    # Longitude offset of constellation (deg)\n        gnss_config.const_t_offset = tow[0, 0]                  # Timing offset of constellation (s)\n        gnss_config.mask_angle = 10.0                           # Mask angle (deg)\n        gnss_config.SIS_err_SD = 1.0                            # Signal in space error SD (m)\n        gnss_config.zenith_iono_err_SD = 2.0                    # Zenith ionosphere error SD (m)\n        gnss_config.zenith_trop_err_SD = 0.2                    # Zenith troposphere error SD (m)\n        gnss_config.code_track_err_SD = 1.0                     # Code tracking error SD (m)\n        gnss_config.rate_track_err_SD = 0.02                    # Range rate tracking error SD (m\/s)\n        gnss_config.rx_clock_offset = 10000.0                   # Receiver clock offset at time = 0 (m)\n        gnss_config.rx_clock_drift = 100.0                      # Receiver clock drift at time = 0 (m\/s)\n\n    # End of \"If\" Statement\n\n    return gnss_config\n\n# End of GNSS Configuration\n\n\n'''\n    -----------------------------------------\n    G. EKF Initialization for Single Coupling\n    -----------------------------------------\n'''\n\n\ndef single_ekf_configuration(imugrade, tightness):\n    print ' Setup Single EKF...'\n    tc_ekf_config = EkfConfigStruct()\n    lc_ekf_config = EkfConfigStruct()\n\n    if imugrade == 'aviation' and tightness == 'tight':\n        tc_ekf_config.init_att_unc = 0.01*d2r                       # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 30.0*micro_g\n        # Initial gyroscope bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 0.001*d2r\/3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = (0.004*d2r\/60.0)**2          # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = (40.0*micro_g)**2           # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 3.0E-9                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 2.0E-16                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    elif imugrade == 'consumer' and tightness == 'tight':\n        tc_ekf_config.init_att_unc = 2.0*d2r                        # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 10000.0*micro_g\n        # Initial gyroscope bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 200.0*d2r\/3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = 1.0E-4                       # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = 0.04                        # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 1.0E-5                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 4.0E-11                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    elif imugrade == 'tactical' and tightness == 'tight':\n        tc_ekf_config.init_att_unc = 1.0*d2r                        # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 1000.0 * micro_g\n        # Initial gyroscope bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 10.0 * d2r \/ 3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = (0.02 * d2r \/ 60) ** 2       # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = (200.0*micro_g)**2          # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 1.0E-7                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 2.0E-12                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    elif imugrade == 'aviation' and tightness == 'loose':\n        lc_ekf_config.init_att_unc = 0.01 * d2r                     # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.2                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 30.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 0.001 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = (0.004 * d2r \/ 60.0) ** 2    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = (40.0*micro_g)**2           # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 3.0E-9                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 2.0E-16                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n    elif imugrade == 'consumer' and tightness == 'loose':\n\n        lc_ekf_config.init_att_unc = 2.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.2                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 10000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 200.0 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = 0.01 ** 2                    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = 0.2 ** 2                    # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 1.0E-5                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 4.0E-11                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n    elif imugrade == 'tactical' and tightness == 'loose':\n\n        lc_ekf_config.init_att_unc = 1.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.2                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 1000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 10.0 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = (0.02 * d2r \/ 60) ** 2       # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = (200.0 * micro_g) ** 2      # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 1.0E-7                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 2.0E-12                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n    # End of If statement for initialization\n\n    if tightness == 'loose':\n        return lc_ekf_config\n    elif tightness == 'tight':\n        return tc_ekf_config\n\n    # End of If statement for returning\n\n# End of EKF Initialization\n\n\n'''\n    ---------------------------------------\n    H. EKF Initialization for Dual Coupling\n    ---------------------------------------\n'''\n\n\ndef dual_ekf_configuration(imugrade):\n    print 'Setup Dual EKF...'\n    tc_ekf_config = EkfConfigStruct()\n    lc_ekf_config = EkfConfigStruct()\n\n    if imugrade == 'aviation':\n\n        # Loosely coupling\n        lc_ekf_config.init_att_unc = 0.01 * d2r                     # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 30.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 0.001 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = (0.004 * d2r \/ 60.0) ** 2    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = (40.0 * micro_g) ** 2       # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 3.0E-9                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 2.0E-16                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n        # Tightly coupling\n        tc_ekf_config.init_att_unc = 0.01 * d2r                     # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 30.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 0.001 * d2r \/ 3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = (0.004 * d2r \/ 60.0) ** 2    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = (40.0 * micro_g) ** 2       # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 3.0E-9                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 2.0E-16                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    elif imugrade == 'consumer':\n\n        # Loosely coupling\n        lc_ekf_config.init_att_unc = 2.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 10000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 200.0 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = 0.01 ** 2                    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = 0.2 ** 2                    # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 1.0E-5                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 4.0E-11                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n        # Tightly coupling\n        tc_ekf_config.init_att_unc = 2.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 10000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 200.0 * d2r \/ 3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = 0.01 ** 2                    # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = 0.2 ** 2                    # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 1.0E-5                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 4.0E-11                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    elif imugrade == 'tactical':\n\n        # Loosely coupling\n        lc_ekf_config.init_att_unc = 1.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        lc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        lc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        lc_ekf_config.init_b_a_unc = 1000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        lc_ekf_config.init_b_g_unc = 10.0 * d2r \/ 3600.0\n        lc_ekf_config.gyro_noise_PSD = (0.02 * d2r \/ 60) ** 2       # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        lc_ekf_config.accel_noise_PSD = (200.0 * micro_g) ** 2      # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        lc_ekf_config.accel_bias_PSD = 1.0E-7                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        lc_ekf_config.gyro_bias_PSD = 2.0E-12                       # Gyro bias random walk PSD (rad^2\/s^3)\n        lc_ekf_config.pos_meas_SD = 2.5                             # Position measurement noise SD per axis (m)\n        lc_ekf_config.vel_meas_SD = 0.1                             # Velocity measurement noise SD per axis (m\/s)\n\n        # Tightly coupling\n        tc_ekf_config.init_att_unc = 1.0 * d2r                      # Initial attitude uncertainty per axis (deg-->rad)\n        tc_ekf_config.init_vel_unc = 0.1                            # Initial velocity uncertainty per axis (m\/s)\n        tc_ekf_config.init_pos_unc = 2.0                            # Initial position uncertainty per axis (m)\n        # Initial accelerometer bias uncertainty per instrument (micro-g --> m\/s^2)\n        tc_ekf_config.init_b_a_unc = 1000.0 * micro_g\n        # Initial gyro bias uncertainty per instrument (deg\/hr --> rad\/s)\n        tc_ekf_config.init_b_g_unc = 10.0 * d2r \/ 3600.0\n        tc_ekf_config.init_clock_offset_unc = 10.0                  # Initial clock offset uncertainty per axis (m)\n        tc_ekf_config.init_clock_drift_unc = 0.1                    # Initial clock drift uncertainty per axis (m\/s)\n        tc_ekf_config.gyro_noise_PSD = (0.02 * d2r \/ 60) ** 2       # Gyro noise PSD (deg^2\/hr --> rad^2\/s)\n        tc_ekf_config.accel_noise_PSD = (200.0 * micro_g) ** 2      # Accelerometer noise PSD (micro-g^2\/Hz --> m^2\/s^3)\n        tc_ekf_config.accel_bias_PSD = 1.0E-7                       # Accelerometer bias random walk PSD (m^2\/s^5)\n        tc_ekf_config.gyro_bias_PSD = 2.0E-12                       # Gyro bias random walk PSD (rad^2\/s^3)\n        tc_ekf_config.clock_freq_PSD = 1.0                          # Receiver clock frequency-drift PSD (m^2\/s^3)\n        tc_ekf_config.clock_phase_PSD = 1.0                         # Receiver clock phase-drift PSD (m^2\/s)\n        tc_ekf_config.pseudo_range_SD = 2.5                         # Pseudo-range measurement noise SD (m)\n        tc_ekf_config.range_rate_SD = 0.1                           # Pseudo-range rate measurement noise SD (m\/s)\n\n    # End of \"If\" statement for initialization\n\n    return lc_ekf_config, tc_ekf_config\n\n# End of Dual EKF Initialization\n\n\n'''\n========================================================================================================================\n                                                UTILITY FUNCTIONS\n========================================================================================================================\n'''\n'''\n    ---------------------------------------------------------\n    1. Euler Angles to Coordinate Transformation Matrix (CTM)\n    ---------------------------------------------------------\n'''\n\n\ndef euler_to_ctm(euler):\n\n    # Pre-calculate np.sines and np.cosines of the Euler angles\n    sin_phi = np.sin(euler[0, 0])\n    cos_phi = np.cos(euler[0, 0])\n    sin_theta = np.sin(euler[1, 0])\n    cos_theta = np.cos(euler[1, 0])\n    sin_psi = np.sin(euler[2, 0])\n    cos_psi = np.cos(euler[2, 0])\n\n    # Establish the coordinate transformation matrix using (2.22)\n    c_matrix = np.nan * np.matrix(np.ones((3, 3)))\n    c_matrix[0, 0] = cos_theta * cos_psi\n    c_matrix[0, 1] = cos_theta * sin_psi\n    c_matrix[0, 2] = -sin_theta\n    c_matrix[1, 0] = -cos_phi * sin_psi + sin_phi * sin_theta * cos_psi\n    c_matrix[1, 1] = cos_phi * cos_psi + sin_phi * sin_theta * sin_psi\n    c_matrix[1, 2] = sin_phi * cos_theta\n    c_matrix[2, 0] = sin_phi * sin_psi + cos_phi * sin_theta * cos_psi\n    c_matrix[2, 1] = -sin_phi * cos_psi + cos_phi * sin_theta * sin_psi\n    c_matrix[2, 2] = cos_phi * cos_theta\n\n    return c_matrix\n\n# End of Euler Angle to CTM Conversion\n\n\n'''\n    ----------------------\n    2. CTM to Euler Angles\n    ----------------------\n'''\n\n\ndef ctm_to_euler(c_matrix):\n\n    euler = np.zeros((3, 1))\n    euler[0, 0] = np.arctan2(c_matrix[1, 2], c_matrix[2, 2])\n    euler[1, 0] = -np.arcsin(c_matrix[0, 2])\n    euler[2, 0] = np.arctan2(c_matrix[0, 1], c_matrix[0, 0])\n\n    return euler\n\n# End of CTM to Euler Angle Conversion\n\n\n'''\n    -----------------------------------------------------\n    3. ECEF to NED Coordinate Transformation Matrix (CTM)\n    -----------------------------------------------------\n'''\n\n\ndef ecef_to_ned_ctm(lat, lon, trig):\n\n    # Calculate ECEF to NED coordinate transformation matrix\n    cos_lat = np.cos(lat)\n    sin_lat = np.sin(lat)\n    cos_lon = np.cos(lon)\n    sin_lon = np.sin(lon)\n    c_e_n_matrix = np.matrix([[-sin_lat * cos_lon, -sin_lat * sin_lon, cos_lat],\n                              [-sin_lon,                cos_lon,             0],\n                              [-cos_lat * cos_lon, -cos_lat * sin_lon, -sin_lat]])\n\n    if trig == 'yes':\n        trig = np.array([cos_lat, sin_lat, cos_lon, sin_lon])\n        return c_e_n_matrix, trig\n    elif trig == 'no':\n        return c_e_n_matrix\n\n# End of ECEF to NED CTM Conversion\n\n\n'''\n    -----------------------------------------------------\n    4. ECEF to ECI Coordinate Transformation Matrix (CTM)\n    -----------------------------------------------------\n'''\n\n\ndef ecef_to_eci_ctm(omega, approx_range, c_speed):\n\n    # Calculate ECEF to ECI CTM\n    c_e_i_matrix = np.matrix([[1, omega*approx_range\/c_speed, 0],\n                              [-omega*approx_range\/c_speed, 1, 0],\n                              [0, 0, 1]])\n\n    return c_e_i_matrix\n\n# End of ECEF to ECI CTM Conversion\n\n\n'''\n    ------------------------\n    5. Skew-Symmetric Matrix\n    ------------------------\n'''\n\n\ndef skew_sym(vector):\n\n    s_matrix = np.matrix(np.zeros((3, 3)))\n    s_matrix[0, 1] = -vector[2, 0]\n    s_matrix[0, 2] = vector[1, 0]\n    s_matrix[1, 0] = vector[2, 0]\n    s_matrix[1, 2] = -vector[0, 0]\n    s_matrix[2, 0] = -vector[1, 0]\n    s_matrix[2, 1] = vector[0, 0]\n\n    return s_matrix\n\n# End of Creating Skew Symmetric Matrix\n\n\n'''\n    -----------------------------------------\n    6. Calculate the Radii of Earth Curvature\n    -----------------------------------------\n'''\n\n\ndef radii_of_curv(latitude):\n\n    # Calculate meridian radius of curvature\n    temp = 1 - (ecc_o * np.sin(latitude)) ** 2\n    r_ns = R_0 * (1 - ecc_o ** 2) \/ (temp ** 1.5)\n\n    # Calculate transverse radius of curvature\n    r_ew = R_0 \/ np.sqrt(temp)\n\n    return r_ns, r_ew\n\n# End of Calculate Radii of Earth Curvature\n\n\n'''\n    --------------------------------------------------------------\n    7. Convert Position, Velocity, and CTM in NED to Those in ECEF\n    --------------------------------------------------------------\n'''\n\n\ndef lla_to_ecef(lat_b, lon_b, h_b, v_eb_n, c_b_n_matrix):\n\n    # Calculate transverse radius of curvature\n    [r_ns, r_ew] = radii_of_curv(lat_b)\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    [c_e_n_matrix, trig] = ecef_to_ned_ctm(lat_b, lon_b, trig='yes')\n\n    # Convert position\n    cos_lat = trig[0]\n    sin_lat = trig[1]\n    cos_lon = trig[2]\n    sin_lon = trig[3]\n    r_eb_e = np.matrix([[(r_ew + h_b) * cos_lat * cos_lon],\n                        [(r_ew + h_b) * cos_lat * sin_lon],\n                        [((1 - ecc_o ** 2) * r_ew + h_b) * sin_lat]])\n\n    # Transform velocity\n    v_eb_e = c_e_n_matrix.T * v_eb_n\n\n    # Transform attitude\n    c_b_e_matrix = c_e_n_matrix.T * c_b_n_matrix\n\n    return r_eb_e, v_eb_e, c_b_e_matrix\n\n# End of NED to ECEF Convertion\n\n\n'''\n    --------------------------------------------------------------\n    8. Convert Position, Volocity, and CTM in ECEF to Those in NED\n    --------------------------------------------------------------\n'''\n\n\ndef ecef_to_lla(r_eb_e, v_eb_e, c_b_e_matrix):\n\n    # Compute the Longitude is straight forward\n    lon_b = np.arctan2(r_eb_e[1, 0], r_eb_e[0, 0])\n\n    # Convert position using Borkowski closed-form exact solution in order to avoid while loop never exits. If doing\n    # this by iteration, we can't ensure while loop convergence. Refer to Appendix C (Paul Grove) or Borkowski, K.M.,\n    # \"Accurate Algorithms to Transform Geocentric to Geodetic Coordinates\", Bull. Geod. 63, pp.50 - 56, 1989.\n    k1 = np.sqrt(1 - ecc_o ** 2) * abs(r_eb_e[2, 0])\n    k2 = (ecc_o ** 2) * R_0\n    beta = np.sqrt(r_eb_e[0, 0] ** 2 + r_eb_e[1, 0] ** 2)\n    e_term = (k1 - k2) \/ beta\n    f_term = (k1 + k2) \/ beta\n    p_term = (4 \/ 3.0) * (e_term * f_term + 1)\n    q_term = 2 * (e_term ** 2 - f_term ** 2)\n    d_term = p_term ** 3 + q_term ** 2\n    v_term = (np.sqrt(d_term) - q_term) ** (1 \/ 3.0) - (np.sqrt(d_term) + q_term) ** (1 \/ 3.0)\n    g_term = 0.5 * (np.sqrt(e_term ** 2 + v_term) + e_term)\n    t_term = np.sqrt(g_term ** 2 + (f_term - v_term * g_term) \/ (2 * g_term - e_term)) - g_term\n    lat_b = np.sign(r_eb_e[2, 0]) * np.arctan((1 - t_term ** 2) \/ (2 * t_term * np.sqrt(1 - ecc_o ** 2)))\n    h_b = (beta - R_0 * t_term) * np.cos(lat_b) + (r_eb_e[2, 0] -\n                                                np.sign(r_eb_e[2, 0]) * R_0 * np.sqrt(1 - ecc_o ** 2)) * np.sin(lat_b)\n\n    # Calculate ECEF to NED coordinate transformation matrix\n    c_e_n_matrix = ecef_to_ned_ctm(lat_b, lon_b, trig='no')\n\n    # Transform velocity\n    v_eb_n = c_e_n_matrix * v_eb_e\n\n    # Transform attitude\n    c_b_n_matrix = c_e_n_matrix * c_b_e_matrix\n\n    return lat_b, lon_b, h_b, v_eb_n, c_b_n_matrix\n\n# End of Converting Position, Velocity, and CTM from ECEF to NED\n\n\n'''\n    ---------------------------------\n    9. Convert Position in LLA to XYZ\n    ---------------------------------\n'''\n\n\ndef lla_to_xyz(lat_b, lon_b, h_b):\n\n    # Calculate transverse radius of curvature\n    r_ew = R_0 \/ np.sqrt(1 - (ecc_o * np.sin(lat_b)) ** 2)\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    [c_e_n_matrix, trig] = ecef_to_ned_ctm(lat_b, lon_b, trig='yes')\n\n    # Convert position\n    cos_lat = trig[0]\n    sin_lat = trig[1]\n    cos_lon = trig[2]\n    sin_lon = trig[3]\n    r_eb_e = np.matrix([[(r_ew + h_b) * cos_lat * cos_lon],\n                        [(r_ew + h_b) * cos_lat * sin_lon],\n                        [((1 - ecc_o ** 2) * r_ew + h_b) * sin_lat]])\n\n    return r_eb_e\n\n# End of LLA to XYZ\n\n\n'''\n    ----------------------------------\n    10. Convert Position in XYZ to NED\n    ----------------------------------\n'''\n\n\ndef xyz_to_ned(r_eb_e, lat_b_ref, lon_b_ref, h_b_ref):\n\n    # Convert referenced position in LLA to ECEF\n    r_eb_e_ref = lla_to_xyz(lat_b_ref, lon_b_ref, h_b_ref)\n\n    # Compute the relative position vector in ECEF\n    delta_r_eb_e = r_eb_e - r_eb_e_ref\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    c_e_n_matrix = ecef_to_ned_ctm(lat_b_ref, lon_b_ref, trig='no')\n\n    # Convert the relative position vector in ECEF to NED\n    r_eb_ned = c_e_n_matrix*delta_r_eb_e\n\n    return r_eb_ned\n\n# End of XYZ to NED\n\n\n'''\n    ----------------------------------\n    11. Calculate Output Errors in NED\n    ----------------------------------\n'''\n\n\ndef cal_err_ned(est_lat_b, est_lon_b, est_alt_b, est_v_eb_n, est_ctm_b_n, true_lat_b, true_lon_b,\n                true_alt_b, true_v_eb_n, true_ctm_b_n):\n\n    # Earth's radii\n    [r_ns, r_ew] = radii_of_curv(true_lat_b)\n\n    # Position error calculation\n    delta_r_eb_n = np.nan * np.ones((3, 1))\n    delta_r_eb_n[0, 0] = (est_lat_b - true_lat_b) * (r_ns + true_alt_b)\n    delta_r_eb_n[1, 0] = (est_lon_b - true_lon_b) * (r_ew + true_alt_b) * np.cos(true_lat_b)\n    delta_r_eb_n[2, 0] = -(est_alt_b - true_alt_b)\n\n    # Velocity error calculation\n    delta_v_eb_n = est_v_eb_n - true_v_eb_n\n\n    # Attitude error calculation\n    delta_ctm_b_n = est_ctm_b_n * true_ctm_b_n.T\n    eul_err_nb_n = -ctm_to_euler(delta_ctm_b_n)\n\n    return delta_r_eb_n, delta_v_eb_n, eul_err_nb_n\n\n# End of Calculating Errors in NED\n\n\n'''\n    -----------------------------------------------------------------------------\n    12. Convert Position and Volocity Standard Deviations in ECEF to Those in NED\n    -----------------------------------------------------------------------------\n'''\n\n\ndef ekfsd_ecef_to_lla(lat_b_ref, lon_b_ref, alt_b_ref, pva_eb_e):\n\n    # Separating the pva vector into:\n    rsd_eb_e = pva_eb_e[0, 0:3].T\n    vsd_eb_e = pva_eb_e[0, 3:6].T\n    euler_sd_eb_e = pva_eb_e[0, 6:9].T\n\n    # Earth's radii using (2.105-106)\n    [r_ns, r_ew] = radii_of_curv(lat_b_ref)\n\n    # Jacobian of xyz to lla using (2.119)\n    t_r_p_matrix = np.matrix([[1.0\/(r_ns + alt_b_ref),                    0.0,                      0.0],\n                              [0.0,                    1.0\/(r_ew + alt_b_ref) * np.cos(lat_b_ref),  0.0],\n                              [0.0,                                       0.0,                     -1.0]])\n\n    # Calculate ECEF to NED coordinate transformation matrix using (2.150)\n    [c_e_n_matrix, trig] = ecef_to_ned_ctm(lat_b_ref, lon_b_ref, trig='yes')\n\n    # Transform position using (2.118)\n    rsd_eb_l = t_r_p_matrix * c_e_n_matrix * rsd_eb_e\n\n    # The down-component error\n    term_1 = rsd_eb_e[2, 0] \/ trig[1]\n    term_2 = np.sqrt(rsd_eb_e[0, 0] ** 2 + rsd_eb_e[1, 0] ** 2) \/ trig[0]\n    rsd_eb_l[2, 0] += term_1 + term_2\n\n    # ECEF to NED coordinate transformation matrix\n    delta_c_e_n_matrix = ecef_to_ned_ctm(rsd_eb_l[0, 0], rsd_eb_l[1, 0], trig='no')\n\n    # Transform velocity using (2.152)\n    vsd_eb_n = delta_c_e_n_matrix * vsd_eb_e\n\n    # Transform attitude using (2.152)\n    euler_sd_eb_n = delta_c_e_n_matrix * euler_sd_eb_e\n\n    return rsd_eb_l, vsd_eb_n, euler_sd_eb_n\n\n# End of Converting Position, Velocity, and CTM from ECEF to NED\n\n\n'''\n    --------------------------------------------------\n    13. Convert Position and Velocity from ECEF to NED\n    --------------------------------------------------\n'''\n\n\ndef pv_ecef_to_lla(r_eb_e, v_eb_e):\n\n    # Compute the Longitude\n    lon_b = np.arctan2(r_eb_e[1, 0], r_eb_e[0, 0])\n\n    # Convert position using Borkowski closed-form exact solution in order to avoid while loop never exits. If doing\n    # this by iteration, we can't ensure while loop convergence. Refer to Appendix C (Paul Grove) or Borkowski, K.M.,\n    # \"Accurate Algorithms to Transform Geocentric to Geodetic Coordinates\", Bull. Geod. 63, pp.50 - 56, 1989.\n    k1 = np.sqrt(1 - ecc_o ** 2) * abs(r_eb_e[2, 0])\n    k2 = (ecc_o ** 2) * R_0\n    beta = np.sqrt(r_eb_e[0, 0] ** 2 + r_eb_e[1, 0] ** 2)\n    e_term = (k1 - k2) \/ beta\n    f_term = (k1 + k2) \/ beta\n    p_term = (4 \/ 3.0) * (e_term * f_term + 1)\n    q_term = 2 * (e_term ** 2 - f_term ** 2)\n    d_term = p_term ** 3 + q_term ** 2\n    v_term = (np.sqrt(d_term) - q_term) ** (1 \/ 3.0) - (np.sqrt(d_term) + q_term) ** (1 \/ 3.0)\n    g_term = 0.5 * (np.sqrt(e_term ** 2 + v_term) + e_term)\n    t_term = np.sqrt(g_term ** 2 + (f_term - v_term * g_term) \/ (2 * g_term - e_term)) - g_term\n    lat_b = np.sign(r_eb_e[2, 0]) * np.arctan((1 - t_term ** 2) \/ (2 * t_term * np.sqrt(1 - ecc_o ** 2)))\n    h_b = (beta - R_0 * t_term) * np.cos(lat_b) + (r_eb_e[2, 0] - np.sign(r_eb_e[2, 0]) * R_0 *\n                                                   np.sqrt(1 - ecc_o ** 2)) * np.sin(lat_b)\n\n    # Calculate ECEF to NED coordinate transformation matrix\n    c_e_n_matrix = ecef_to_ned_ctm(lat_b, lon_b, trig='no')\n\n    # Transform velocity\n    v_eb_n = c_e_n_matrix * v_eb_e\n\n    return lat_b, lon_b, h_b, v_eb_n\n\n# End of Converting Position an Velocity from ECEF to NED\n\n\n'''\n    ------------------------------\n    14. Initialized Attitude in NED\n    ------------------------------\n'''\n\n\ndef init_ned_att(c_b_n_matrix, eul_err_nb_n):\n\n    # Attitude initialization\n    delta_c_b_n_matrix = euler_to_ctm(-eul_err_nb_n)\n    est_c_b_n_matrix = delta_c_b_n_matrix * c_b_n_matrix\n\n    return est_c_b_n_matrix\n\n# End of Initializing Attitude in NED\n\n\n'''\n    ------------------------------------------------------------\n    15. Progress Bar: Displays or Updates a Console Progress Bar\n    ------------------------------------------------------------\n'''\n\n\ndef progressbar(progress):\n\n    # Accepts \"progress\" as a float percentage between 0 and 1.\n    barlength = 25  # Modify this to change the length of the progress bar\n    status = \" \"\n    block = int(round(barlength * progress))\n    text = \"\\r NavSim: [{0}] {1}% {2}\".format(\">\" * block + \"-\" * (barlength - block), int(round(progress * 100)),\n                                              status)\n    sys.stdout.write(text)\n    sys.stdout.flush()\n\n# End of Progress Bar\n\n\n'''\n    ----------------------------------------------------------\n    16. Calculate the Earth Gravitational Force Vector in ECEF\n    ----------------------------------------------------------\n'''\n\n\ndef gravity_ecef(r_eb_e):\n\n    # Calculate distance from center of the Earth\n    mag_r = np.sqrt(r_eb_e.T * r_eb_e)\n\n    # If the input position is [0,0,0], produce a dummy output\n    if mag_r == 0:\n        gravity_vec = np.matrix(np.zeros((3, 1)))\n\n    else:\n        # Calculate gravitational acceleration\n        gravity_vec = np.nan * np.matrix(np.ones((3, 1)))\n        gamma = np.nan * np.matrix(np.ones((3, 1)))\n        z_scale = 5.0 * (r_eb_e[2, 0] \/ mag_r) ** 2\n        gamma[0, 0] = (-mu \/ mag_r ** 3) * (r_eb_e[0.0] + 1.5 * J_2 * (R_0 \/ mag_r) ** 2 * (1.0 - z_scale) *\n                                            r_eb_e[0, 0])\n        gamma[1, 0] = (-mu \/ mag_r ** 3) * (r_eb_e[1.0] + 1.5 * J_2 * (R_0 \/ mag_r) ** 2 * (1.0 - z_scale) *\n                                            r_eb_e[1, 0])\n        gamma[2, 0] = (-mu \/ mag_r ** 3) * (r_eb_e[2.0] + 1.5 * J_2 * (R_0 \/ mag_r) ** 2 * (1.0 - z_scale) *\n                                            r_eb_e[2, 0])\n\n        # Add centripetal acceleration\n        gravity_vec[0:2, 0] = gamma[0:2, 0] + OMEGA_ie ** 2 * r_eb_e[0:2, 0]\n        gravity_vec[2, 0] = gamma[2, 0]\n\n    return gravity_vec\n\n# End of Calculating Earth Gravitation Force in ECEF\n\n\n'''\n    -------------------------------------------\n    17. Earth Rotation Over the Update Interval\n    -------------------------------------------\n'''\n\n\ndef c_earth(tau_i):\n\n    # Determine the Earth rotation over the update interval\n    alpha_ie = OMEGA_ie * tau_i\n    c_earth_matrix = np.matrix([[np.cos(alpha_ie), np.sin(alpha_ie), 0.0],\n                                [-np.sin(alpha_ie), np.cos(alpha_ie), 0.0],\n                                [0, 0, 1]])\n\n    return c_earth_matrix, alpha_ie\n\n# End of Calculating the Earth Rotational Matrix\n\n\n'''\n    -----------------------------------------------------------------------\n    18. Solve Kepler's Equation for Eccentric Anomaly Using Newton's Method\n    -----------------------------------------------------------------------\n'''\n\n\ndef kepler(Mk, ecc, tol):\n\n    # Determine the initial guess for eccentric anomaly, Ek\n    # From <NAME>\n    Ek = Mk + (ecc*np.sin(Mk))\/(1.0 - np.sin(Mk + ecc) + np.sin(Mk))\n\n    # From <NAME>\n    # if Mk < np.pi:\n    #     Ek = Mk + ecc\/2.0\n    # else:\n    #     Ek = Mk - ecc\/2.0\n\n    # Define ratio = f(Ei)\/f'(Ei) to be the conditioner\n    # Hence, ratio = (E_i - e*sin(E_i) - M)\/(1 - e*cos(E_i))\n    ratio = 1\n    # Iterate over E_(i+1) = E_i - (E_i - e*sin(E_i) - M)\/(1 - e*cos(E_i))\n    while abs(ratio) > tol:\n        ratio = (Ek - ecc*np.sin(Ek) - Mk)\/(1.0 - ecc*np.cos(Ek))\n        Ek -= ratio\n    # End of while\n\n    return Ek\n\n# End of Kepler's equation solver\n\n\n'''\n    ---------------------------\n    19. Determine the Leap Year\n    ---------------------------\n'''\n\n\ndef is_leap_year(yyyy):\n\n    # Function is_leap_year() determines whether a given year \"yyyy\" is a leap year.\n    # A leap year year is defined as a year that is divisible by 4 but not by 100,\n    # unless it is divisible by 400 as every 100 years a leap year is skipped.\n    if yyyy % 4 == 0:\n        if yyyy % 100 == 0:\n            if yyyy % 400 == 0:\n                return True\n            else:\n                return False\n        else:\n            return True\n    else:\n        return False\n\n# End of leap year checker\n\n\n'''\n    --------------------------------------------------\n    20. Calculate the Number of Days between Two Dates\n    --------------------------------------------------\n'''\n\n\ndef num_days(yyyy1, mm1, dd1, yyyy2, mm2, dd2):\n\n    # Function numdays() calculates the number of days between two given dates.\n    # Date #1: year = yyyy1, month = mm1, and day = dd1\n    # Date #2: year = yyyy2, month = mm2, and day = dd2\n    # Usually, date #2 is after date #1 counting from the past to the future.\n\n    # Cumulative days by month for a non-leap year (up to the beginning of the month)\n    cum_days = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]\n\n    # Cumulative days by month for a leap year (up to the beginning of the month)\n    leap_cum_days = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]\n\n    # Total days\n    totdays = 0\n\n    # Checking for the same year (if the two dates are in the same year).\n    if yyyy1 == yyyy2:\n        # If the two dates are in the same year, check for the leap year\n        if is_leap_year(yyyy1):\n            # If the year is a leap year, count the cumulative days for each date by\n            # using the cumulative days in the year for a leap year.\n            # Then calculate the difference in the number of days of year between them.\n            return (leap_cum_days[mm2 - 1] + dd2) - (leap_cum_days[mm1 - 1] + dd1)\n        else:\n            # If the year is not a leap year, count the cumulative days for each date by\n            # using the cumulative days in the year for a non-leap year.\n            return (cum_days[mm2 - 1] + dd2) - (cum_days[mm1 - 1] + dd1)\n    else:\n        # If the two years are different, check for leap year on year #1\n        if is_leap_year(yyyy1):\n            # A leap year has 366 days.\n            totdays = totdays + 366 - (leap_cum_days[mm1 - 1] + dd1)\n        else:\n            # A non-leap year has 365 days.\n            totdays = totdays + 365 - (cum_days[mm1 - 1] + dd1)\n        # Counting the number of years different between year #1 and year #2.\n        # Increase year #1 by 1 unit,\n        year = yyyy1 + 1\n        # check if the incremented year is equal to the year #2\n        while year < yyyy2:\n            # For each leap year in difference,\n            if is_leap_year(year):\n                # the total days is accumulated by 366 days\n                totdays += 366\n            # Otherwise,\n            else:\n                # the total days is accumulated by 365 days\n                totdays += 365\n            # Increase year #1 by another unit\n            year += 1\n        # Check for leap year on year #2\n        if is_leap_year(yyyy2):\n            # If year #2 is a leap year, the total days equals days of year for date #1\n            # plus number of days for number of years in difference between two years,\n            # then plus days of year for date #2 by cumulative days of a leap year.\n            totdays = totdays + (leap_cum_days[mm2 - 1] + dd2)\n        else:\n            # Otherwise, the total days equals days of year for date #1 plus number of\n            # days for number of years in difference between two years, then plus days\n            # of year for date #2 by cumulative days of a non-leap year.\n            totdays = totdays + (cum_days[mm2 - 1] + dd2)\n        return totdays\n# End of days between two dates\n\n\n'''\n    ------------------------------------------------------\n    21. Calculate the Number of Days of the Year of a Date\n    ------------------------------------------------------\n'''\n\n\ndef days_of_year(yyyy, mm, dd):\n\n    # Cumulative days by month\n    cum_days = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]\n\n    # Cumulative days by month for leap year\n    leap_cum_days = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]\n\n    # Check for leap year on year (yyyy)\n    if is_leap_year(yyyy):\n        # If yyyy is a leap year, then count the cumulative days of year by leap year.\n        return leap_cum_days[mm - 1] + dd\n    else:\n        # Otherwise, count the cumulative days of year by non-leap year.\n        return cum_days[mm - 1] + dd\n\n# End of days of year of a date\n\n\n'''\n    --------------------------------------------------------\n    22. Convert GPS TOW to UTC Time (Day\/Hour\/Minute\/Second)\n    --------------------------------------------------------\n'''\n\n\ndef tow_to_utc(tow):\n\n    # Days of week based on the initial time of week\n    DyOW = (tow - np.mod(tow, dd2sec)) \/ dd2sec  # days\n\n    # The remaining seconds of the day after extracting the days\n    rem_sec = np.mod(tow, dd2sec)  # seconds\n\n    # Hours of the day\n    HrOD = (rem_sec - np.mod(rem_sec, hr2sec)) \/ hr2sec  # hours\n\n    # The remaining seconds of the hour after extracting days and hours\n    rem_sec = np.mod(rem_sec, hr2sec)  # seconds\n\n    # Minutes of the hour\n    MnOH = (rem_sec - np.mod(rem_sec, mn2sec)) \/ mn2sec  # minutes\n\n    # The remaining seconds of the minute after extracting days, hours, and minutes\n    ScOM = np.mod(rem_sec, mn2sec)\n\n    return DyOW, HrOD, MnOH, ScOM\n\n# End of TOW to UTC\n\n\n'''\n    ----------------------------------------------------------------\n    23. Determine Flgith Duration Based on TOWs from the Flight Data\n    ----------------------------------------------------------------\n'''\n\n\ndef flight_duration(towo, towf):\n\n    # Flight duration in GPS time (seconds)\n    delta_tow = towf - towo\n\n    # Flight duration in minutes\n    deltaMnOW = (delta_tow - np.mod(delta_tow, mn2sec)) \/ mn2sec\n\n    # Remaining flight duration in seconds\n    rem_deltaTOW = np.mod(delta_tow, mn2sec)\n\n    return deltaMnOW, rem_deltaTOW\n\n# End of Flight Duration\n\n\n'''\n========================================================================================================================\n                                                    MAIN FUNCTIONS\n========================================================================================================================\n'''\n'''\n    ----------------------------------------------------------------------------------\n    1. Generate Satellite Positions and Velocities by Simulating Virtual Constellation\n    ----------------------------------------------------------------------------------\n'''\n\n\ndef sat_pv_sim(t_i, gnss_config):\n\n    # Convert inclination angle to degrees\n    inclination = d2r * gnss_config.inclination\n\n    # Determine orbital angular rate\n    omega_is = np.sqrt(mu \/ (gnss_config.r_os ** 3))\n\n    # Determine constellation time\n    tgps = t_i + gnss_config.const_t_offset\n\n    # Allocate the position and the velocity arrays for all satellites\n    sat_r_es_e = np.nan * np.matrix(np.ones((gnss_config.no_sat, 3)))\n    sat_v_es_e = np.nan * np.matrix(np.ones((gnss_config.no_sat, 3)))\n\n    # Loop over the satellites\n    for i in xrange(0, gnss_config.no_sat):\n\n        # Corrected argument of latitude\n        u_os_o = 2 * np.pi * i \/ gnss_config.no_sat + omega_is * tgps\n\n        # Satellite position in the orbital plane\n        r_os_o = gnss_config.r_os * np.matrix([np.cos(u_os_o), np.sin(u_os_o), 0]).T\n\n        # Longitude of the ascending node\n        omega = (np.pi * np.mod(i + 1, 6) \/ 3) + d2r * gnss_config.const_delta_lon - OMEGA_ie * tgps\n\n        # ECEF Satellite Position\n        sat_r_es_e[i, 0] = r_os_o[0, 0] * np.cos(omega) - r_os_o[1, 0] * np.cos(inclination) * np.sin(omega)\n        sat_r_es_e[i, 1] = r_os_o[0, 0] * np.sin(omega) + r_os_o[1, 0] * np.cos(inclination) * np.cos(omega)\n        sat_r_es_e[i, 2] = r_os_o[1, 0] * np.sin(inclination)\n\n        # Satellite velocity in the orbital frame, noting that with a circular orbit r_os_o is constant and\n        # the time derivative of u_os_o is omega_is.\n        v_os_o = gnss_config.r_os * omega_is * np.matrix([-np.sin(u_os_o), np.cos(u_os_o), 0]).T\n\n        # ECEF Satellite velocity\n        sat_v_es_e[i, 0] = v_os_o[0, 0] * np.cos(omega) - v_os_o[1, 0] * np.cos(inclination) * np.sin(omega) + \\\n                           (OMEGA_ie * sat_r_es_e[i, 1])\n        sat_v_es_e[i, 1] = v_os_o[0, 0] * np.sin(omega) + v_os_o[1, 0] * np.cos(inclination) * np.cos(omega) - \\\n                           (OMEGA_ie * sat_r_es_e[i, 0])\n        sat_v_es_e[i, 2] = v_os_o[1, 0] * np.sin(inclination)\n\n    # End of For Loop\n\n    return sat_r_es_e, sat_v_es_e\n\n# End of Generating Satellite Positions and Velocities\n\n\n'''\n    -----------------------------------------------------------------\n    2. Generate Satellite Positions and Velocities from the Ephemeris\n    -----------------------------------------------------------------\n'''\n\n\ndef sat_pv_ephem(ephem, gnss_config, t_i, tol):\n\n    # Ephemeris Array Structure:\n    # Col. 0: PRN\n    # Col. 1: Crs                           (meter)\n    # Col. 2: Delta n                       (rad\/sec)\n    # Col. 3: Mo                            (rad)\n    # Col. 4: Cuc                           (rad)\n    # Col. 5: Eccentricity, e\n    # Col. 6: Cus                           (rad)\n    # Col. 7: sqrt(A)                       (sqrt(meter))\n    # Col. 8: Toe, time of ephemeris        (sec of GPS Week)\n    # Col. 9: Cic                           (rad)\n    # Col. 10: OMEGA_o                      (rad)\n    # Col. 11: Cis                          (rad)\n    # Col. 12: i_o, reference inclination   (rad)\n    # Col. 13: Crc                          (meter)\n    # Col. 14: omega                        (rad)\n    # Col. 15: OMEGA DOT                    (rad\/sec)\n    # Col. 16: IDOT, inclination rate       (rad\/sec)\n    # Col. 17: Toc, time of clock           (sec of GPS Week)\n    # Col. 18: TGD, group delay             (sec)\n\n    # Determine constellation time\n    tgps = t_i + gnss_config.const_t_offset\n\n    # Create frames for the position and the velocity arrays of all the satellites in the constellation\n    sat_r_es_e = np.nan * np.matrix(np.ones((gnss_config.no_sat, 3)))\n    sat_v_es_e = np.nan * np.matrix(np.ones((gnss_config.no_sat, 3)))\n\n    # Loop over all satellites\n    for i in xrange(0, gnss_config.no_sat):\n        # Compute the semi-major axis\n        A = ephem[i, 7]**2\n\n        # Compute the mean motion (rd\/sec)\n        n_o = np.sqrt(mu\/(A**3))\n\n        # Calculate the time from ephemeris reference epoch\n        tk = tgps - ephem[i, 8]\n\n        # Correct the beginning or end of week crossovers\n        if tk > 3.024E+05:\n            tk -= 6.048E+05\n        elif tk < -3.024E+05:\n            tk += 6.048E+05\n\n        # Correct the mean motion\n        n = n_o + ephem[i, 2]\n\n        # Determine the mean anomaly\n        Mk = ephem[i, 3] + n*tk\n\n        # Solve Kepler's Equation for eccentric anomaly\n        ecc = ephem[i, 5]\n        Ek = kepler(Mk, ecc, tol)\n\n        # Determine the true anomaly\n        sin_nuk = np.sqrt(1.0 - ecc)*np.sin(Ek)\/(1.0 - ecc*np.cos(Ek))\n        cos_nuk = (np.cos(Ek) - ecc)\/(1.0 - ecc*np.cos(Ek))\n        nuk = np.arctan2(sin_nuk, cos_nuk)\n\n        # Calculate the argument of latitude\n        Phik = nuk + ephem[i, 14]\n\n        # Compute the 2nd harmonic perturbations\n        delt_uk = ephem[i, 6]*np.sin(2.0*Phik) + ephem[i, 4]*np.cos(2.0*Phik)    # Argument of latitude correction\n        delt_rk = ephem[i, 1]*np.sin(2.0*Phik) + ephem[i, 13]*np.cos(2.0*Phik)   # Radius correction\n        delt_ik = ephem[i, 11]*np.sin(2.0*Phik) + ephem[i, 9]*np.cos(2.0*Phik)   # Inclination correction\n\n        # Corrected argument of latitude\n        uk = Phik + delt_uk\n\n        # Corrected radius\n        rk = A*(1 - ecc*np.cos(Ek)) + delt_rk\n\n        # Corrected inclination\n        ik = ephem[i, 12] + delt_ik + ephem[i, 16]*tk\n\n        # Satellite's position in orbital plane\n        xk_prime = rk*np.cos(uk)        # x-component\n        yk_prime = rk*np.sin(uk)        # y-component\n\n        # Corrected longitude of ascending node\n        OMEGAk = ephem[i, 10] + (ephem[i, 15] - OMEGA_ie)*tk - OMEGA_ie*ephem[i, 8]\n\n        # Satellite's position in ECEF\n        sat_r_es_e[i, 0] = xk_prime*np.cos(OMEGAk) - yk_prime*np.cos(ik)*np.sin(OMEGAk)     # x-component\n        sat_r_es_e[i, 1] = xk_prime*np.sin(OMEGAk) + yk_prime*np.cos(ik)*np.cos(OMEGAk)     # y-component\n        sat_r_es_e[i, 2] = yk_prime*np.sin(ik)                                              # z-component\n\n        # Calculate the time derivative of the eccentric anomaly\n        Ek_dot = n\/(1.0 - ecc*np.cos(Ek))\n\n        # Compute the time derivative of the argument of latitude\n        Phik_dot = (np.sin(nuk)\/np.sin(Ek))*Ek_dot\n\n        # Determine the time derivative of the corrected radius\n        rk_dot = A*ecc*np.sin(Ek)*Ek_dot + 2.0*(ephem[i, 1]*np.cos(2.0*Phik) - ephem[i, 13]*np.sin(2.0*Phik))*Phik_dot\n\n        # Determine the time derivative of the corrected argument of latitude\n        uk_dot = (1.0 + 2.0*ephem[i, 6]*np.cos(2.0*Phik) - 2.0*ephem[i, 4]*np.sin(2.0*Phik))*Phik_dot\n\n        # Satellite's velocity in orbital plane\n        xk_prime_dot = rk_dot*np.cos(uk) - rk*uk_dot*np.sin(uk)       # x-component\n        yk_prime_dot = rk_dot*np.sin(uk) + rk*uk_dot*np.cos(uk)       # y-component\n\n        # Calculate the time derivative of corrected longitude of ascending node\n        OMEGAk_dot = ephem[i, 15] - OMEGA_ie\n\n        # Calculate the time derivative of corrected inclination\n        ik_dot = ephem[i, 16] + 2.0*(ephem[i, 11]*np.cos(2.0*Phik) - ephem[i, 9]*np.sin(2.0*Phik))*Phik_dot\n\n        # Satellite's velocity in ECEF\n        vx_term1 = xk_prime_dot*np.cos(OMEGAk) - yk_prime_dot*np.cos(ik)*np.sin(OMEGAk) + \\\n                   ik_dot*yk_prime*np.sin(ik)*np.sin(OMEGAk)\n\n        vx_term2 = -OMEGAk_dot*(xk_prime*np.sin(OMEGAk) + yk_prime*np.cos(ik)*np.cos(OMEGAk))\n\n        sat_v_es_e[i, 0] = vx_term1 + vx_term2                                      # x-component\n\n        vy_term1 = xk_prime_dot*np.sin(OMEGAk) + yk_prime_dot*np.cos(ik)*np.cos(OMEGAk) - \\\n                  ik_dot*yk_prime*np.sin(ik)*np.cos(OMEGAk)\n\n        vy_term2 = -OMEGAk_dot*(-xk_prime*np.cos(OMEGAk) + yk_prime*np.cos(ik)*np.sin(OMEGAk))\n\n        sat_v_es_e[i, 1] = vy_term1 + vy_term2                                      # y-component\n\n        sat_v_es_e[i, 2] = yk_prime_dot*np.sin(ik) + ik_dot*yk_prime*np.cos(ik)     # z-component\n\n    return sat_r_es_e, sat_v_es_e\n\n# End of Determine Satellite Position and Velocity in ECEF Using Ephemeris\n\n\n'''\n    -----------------------------------------------------------------\n    3. Initialize GNSS Biases by Simulating the Virtual Constellation\n    -----------------------------------------------------------------\n'''\n\n\ndef init_gnss_bias_sim(sat_r_es_e, r_ea_e, lat_a, lon_a, gnss_config):\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    ctm_e_n = ecef_to_ned_ctm(lat_a, lon_a, trig='no')\n\n    # Loop satellites\n    gnss_biases = np.nan * np.matrix(np.ones((gnss_config.no_sat, 1)))\n\n    for i in xrange(0, gnss_config.no_sat):\n\n        # Determine ECEF line-of-sight vector\n        delta_r = sat_r_es_e[i, 0:3].T - r_ea_e\n        u_as_e = delta_r \/ np.sqrt(delta_r.T * delta_r)\n\n        # Convert line-of-sight vector to NED and determine elevation\n        elevation = -np.arcsin(ctm_e_n[2, :] * u_as_e)\n\n        # Limit the minimum elevation angle to the masking angle\n        elevation = max(elevation, d2r * gnss_config.mask_angle)\n\n        # Calculate ionosphere and troposphere error SDs\n        iono_sd = gnss_config.zenith_iono_err_SD \/ np.sqrt(1 - 0.899 * np.cos(elevation) ** 2)\n        trop_sd = gnss_config.zenith_trop_err_SD \/ np.sqrt(1 - 0.998 * np.cos(elevation) ** 2)\n\n        # Determine range bias\n        gnss_biases[i, 0] = gnss_config.SIS_err_SD * rnd.randn() + iono_sd * rnd.randn() + trop_sd * rnd.randn()\n\n    # End of For Loop\n\n    return gnss_biases\n# End of Initializing GNSS Biases\n\n\n'''\n    --------------------------------------------------------------\n    4. Initialize GNSS Biases: Ionospheric and Tropospheric Delays\n    --------------------------------------------------------------\n'''\n\n\ndef init_gnss_bias_ephem(t_i, doy, ephem, iono_alpha, iono_beta, lat_a, lon_a, alt_a, sat_r_es_e, r_ea_e, gnss_config):\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    ctm_e_n = ecef_to_ned_ctm(lat_a, lon_a, trig='no')\n\n    # Determine constellation time\n    tgps = t_i + gnss_config.const_t_offset\n\n    # Loop satellites\n    gnss_biases = np.nan * np.matrix(np.ones((gnss_config.no_sat, 1)))\n\n    for i in xrange(0, gnss_config.no_sat):\n\n        # Determine ECEF line-of-sight vector\n        delta_r = sat_r_es_e[i, 0:3].T - r_ea_e\n        u_as_e = delta_r \/ np.sqrt(delta_r.T * delta_r)\n\n        # Convert line-of-sight vector to NED and determine the elevation and the azimuth\n        elevation = -np.arcsin(ctm_e_n[2, :] * u_as_e)\n        azimuth = np.arctan2(ctm_e_n[1, :] * u_as_e, ctm_e_n[0, :] * u_as_e)\n\n        # Limit the minimum elevation angle to the masking angle\n        elevation = max(elevation, d2r * gnss_config.mask_angle)\n\n        # --------------------------------------------------------\n        # Calculate the ionospheric bias using the Klobuchar model\n        # --------------------------------------------------------\n\n        # 1.1 Compute the Earth-central angle and the sub-ionospheric latitude\n        Psi_E_s = (0.0137*(np.pi**2))\/(elevation + 0.11*np.pi) - 0.022*np.pi        # (rad)\n        L_I_s = lat_a + Psi_E_s*np.cos(azimuth)                                     # (rad)\n        # 1.2 Apply limits to L_I_s, [-1.307, 1.307] rad\n        if L_I_s < -1.307:\n            L_I_s  = -1.307\n        elif L_I_s > 1.307:\n            L_I_s = 1.307\n\n        # 2. Calculate the sub-ionospheric longitude and the geomagnetic latitude\n        lon_I_s = lon_a + Psi_E_s*np.sin(azimuth)\/np.cos(L_I_s)                  # (rad)\n        L_m_s = L_I_s + (0.064*np.pi)*np.cos(lon_I_s - 1.617*np.pi)              # (rad)\n\n        # 3.1 Compute the time of flight, delta_t = t_gps - t_oe\n        delt_t_s = tgps - ephem[i, 8]                                               # (sec)\n\n        # 3.2 Apply limits to delta_t_s, [0, 86400) sec\n        if delt_t_s > 8.64E+04:\n            delt_t_s -= 8.64E+04\n        elif delt_t_s <= 0:\n            delt_t_s += 8.64E+04\n        # 3.3 Compute the time at the sub-ionopsheric point\n        t_I_s = delt_t_s + ((4.32E+04)\/np.pi)*lon_I_s                            # (sec)\n\n        # 4.1 Calculate PER\n        PER = 0.0\n        for n in xrange(0, 4):\n            PER += iono_beta[0, n]*(L_m_s\/np.pi)**n                                 # (sec)\n        # 4.2 Apply minimum limit to PER\n        if PER < 7.2E+04:\n            PER = 7.2E+04                                                           # (sec)\n        # 4.3 Calculate the phase X_s, as the ionospheric formula's conditioner\n        X_s = 2*np.pi*(t_I_s - 5.04E+04)\/PER\n\n        # 5. Estimate the ionosphere propagation delay (for GPS L1 band signal)\n        # 5.1 Compute the obliquity factor\n        F = 1.0 + (16.0\/(np.pi**3))*(0.53*np.pi - elevation)**3\n        # 5.2 Condition 1 on X\n        if np.abs(X_s) >= 1.57:\n            iono_delay = 5.0E-09*F                                                              # (sec)\n        # 5.3 Condition 2 on X\n        elif np.abs(X_s) < 1.57:\n            # 5.3.1 Compute AMP\n            AMP = 0.0\n            for n in xrange(0, 4):\n                AMP += iono_alpha[0, n]*(L_m_s\/np.pi)**n                                        # (sec)\n            # 5.3.2 Apply minimum limit to AMP\n            if AMP < 0.0:\n                AMP = 0.0                                                                       # (sec)\n            # 5.3.3 Compute the ionospheric delay\n            iono_delay = F*(5.0E-09 + AMP*(1 - (X_s**2)\/2.0 + (X_s**4)\/24.0))                   # (sec)\n        # Estimate the ionospheric psuedorange bias, (m)\n        iono_bias = iono_delay*c\n\n        # -----------------------------------------------------\n        # Calculate the trophospheric bias using the WAAS Model\n        # -----------------------------------------------------\n\n        # Estimate the surface refractivity based on the user's altitude and latitude\n        # User's in the Northen hemisphere\n        if lat_a > 0.0:\n            cosine1 = np.cos(2.0 * np.pi * ((doy - 152) \/ 365))\n            cosine2 = np.cos(2.0 * np.pi * ((doy - 213) \/ 365))\n            delta_N = 3.61E-03 * alt_a * cosine1 + (0.1 * cosine2 - 0.8225) * np.abs(lat_a)\n        # User's in the Southern hemisphere\n        elif lat_a < 0.0:\n            cosine1 = np.cos(2.0 * np.pi * ((doy - 335) \/ 365))\n            cosine2 = np.cos(2.0 * np.pi * ((doy - 30) \/ 365))\n            delta_N = 3.61E-03 * alt_a * cosine1 + (0.1 * cosine2 - 0.8225) * np.abs(lat_a)\n        # User's lower than 1,500 m\n        den = np.sin(elevation + 6.11E-03)\n        if alt_a <= 1.5E+03:\n            num = 2.506*(1.0 + 1.25E-03*delta_N)*(1.0 - 1.264E-04*alt_a)\n            tropo_bias = num\/den    # (m)\n        # User's higher than 1,500 m\n        elif alt_a > 1.5E+03:\n            num = 2.484*(1.0 + 1.5363E-03*np.exp(-2.133E-04*alt_a)*delta_N)*np.exp(-1.509E-04*alt_a)\n            tropo_bias = num\/den    # (m)\n\n        # Assemble the ionopsheric bias and the tropospheric bias into the initial GNSS bias matrix\n        gnss_biases[i, 0] = iono_bias + tropo_bias\n\n    # End of \"for\" loop\n\n    return gnss_biases\n# End of Initializing GNSS Biases\n\n\n'''\n    -----------------------------------------------------------------------------------------------------\n    5. Generate GNSS Measurements (pseudorange, range rate, etc.) by Simulating the Virtual Constellation\n    -----------------------------------------------------------------------------------------------------\n'''\n\n\ndef gnss_meas_gen_sim(t, sat_r_es_e, sat_v_es_e, r_ea_e, lat_a, lon_a, v_ea_e, gnss_biases, gnss_config):\n\n    # Allocate necessary place holders before generating GNSS measurements\n    no_gnss_meas = 0\n    prn = []\n    pseudorange = []\n    pseudorange_rate = []\n    rx = []\n    ry = []\n    rz = []\n    vx = []\n    vy = []\n    vz = []\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    ctm_e_n = ecef_to_ned_ctm(lat_a, lon_a, trig='no')\n\n    # Skew symmetric matrix of Earth rate\n    omega_ie_matrix = skew_sym(np.matrix([[0], [0], [OMEGA_ie]]))\n\n    # Loop over all satellites\n    for i in xrange(0, gnss_config.no_sat):\n\n        # Determine ECEF line-of-sight vector\n        delta_r = sat_r_es_e[i, :].T - r_ea_e\n        approx_range = np.sqrt(delta_r.T * delta_r)\n        u_as_e = delta_r \/ approx_range\n\n        # Convert line-of-sight vector to NED and determine elevation\n        elevation = -np.arcsin(ctm_e_n[2, :] * u_as_e)\n\n        # Determine if satellite is above the masking angle\n        if elevation >= d2r * gnss_config.mask_angle:\n\n            # Record the PRN\n            prn.append(i + 1)\n\n            # Increment number of measurements\n            no_gnss_meas += 1\n\n            # Calculate frame rotation during signal transit time\n            ctm_e_i = ecef_to_eci_ctm(OMEGA_ie, approx_range, c)\n\n            # Calculate geometric range\n            delta_r = ctm_e_i * sat_r_es_e[i, :].T - r_ea_e\n            rangex = np.sqrt(delta_r.T * delta_r)\n\n            # Calculate geometric range rate\n            range_rate = u_as_e.T * (ctm_e_i * (sat_v_es_e[i, :].T + omega_ie_matrix * sat_r_es_e[i, :].T) -\n                                     (v_ea_e + omega_ie_matrix * r_ea_e))\n\n            # Calculate pseudo-range measurement\n            psdrel1 = gnss_config.rx_clock_offset\n            psdrel2 = gnss_config.rx_clock_drift * t\n            psdrel3 = gnss_config.code_track_err_SD * rnd.randn()\n            psdr = rangex + gnss_biases[i] + psdrel1 + psdrel2 + psdrel3\n            pseudorange.append(psdr[0, 0])\n\n            # Calculate pseudo-range rate measurement\n            rateel1 = gnss_config.rx_clock_drift\n            rateel2 = gnss_config.rate_track_err_SD * rnd.randn()\n            psdr_rate = range_rate + rateel1 + rateel2\n            pseudorange_rate.append(psdr_rate[0, 0])\n\n            # Append satellite position and velocity to output data\n            rx.append(sat_r_es_e[i, 0])\n            ry.append(sat_r_es_e[i, 1])\n            rz.append(sat_r_es_e[i, 2])\n            vx.append(sat_v_es_e[i, 0])\n            vy.append(sat_v_es_e[i, 1])\n            vz.append(sat_v_es_e[i, 2])\n\n            # End of \"If\" Statement to Determine the Number of Satellites in View\n\n    # End of For Loop Sweeping Through All Satellites in the Constellation\n\n    # Forming the GNSS Measurement Output matrix\n    gnss_meas = np.matrix([pseudorange, pseudorange_rate, rx, ry, rz, vx, vy, vz]).T\n\n    return gnss_meas, no_gnss_meas, prn\n\n# End of GNSS Measurement Generation\n\n\n'''\n    --------------------------------------------------------------------------------\n    6. Generate GNSS Measurements (pseudorange, range rate, etc.) from the Ephemeris\n    --------------------------------------------------------------------------------\n'''\n\n\ndef gnss_meas_gen_ephem(t_i, sat_r_es_e, sat_v_es_e, r_ea_e, lat_a, lon_a, v_ea_e, gnss_biases, gnss_config, sv_clock,\n                        ephem, alma_t_para):\n\n    # Allocate necessary place holders before generating GNSS measurements\n    no_gnss_meas = 0\n    prn = []\n    pseudorange = []\n    pseudorange_rate = []\n    rx = []\n    ry = []\n    rz = []\n    vx = []\n    vy = []\n    vz = []\n\n    # Calculate ECEF to NED CTM using ECEF_to_NED_CTM()\n    ctm_e_n = ecef_to_ned_ctm(lat_a, lon_a, trig='no')\n\n    # Determine constellation time\n    tgps = t_i + gnss_config.const_t_offset\n\n    # Skew symmetric matrix of Earth rate\n    omega_ie_matrix = skew_sym(np.matrix([[0], [0], [OMEGA_ie]]))\n\n    # Loop over all satellites\n    for i in xrange(0, gnss_config.no_sat):\n        # Determine ECEF line-of-sight vector\n        delta_r = sat_r_es_e[i, :].T - r_ea_e\n        approx_range = np.sqrt(delta_r.T * delta_r)\n        u_as_e = delta_r \/ approx_range\n\n        # Convert line-of-sight vector to NED and determine elevation\n        elevation = -np.arcsin(ctm_e_n[2, :] * u_as_e)\n\n        # Determine if satellite is above the masking angle\n        if elevation >= d2r * gnss_config.mask_angle:\n\n            # Record the PRN\n            prn.append(ephem[i, 0])\n\n            # Increment number of measurements\n            no_gnss_meas += 1\n\n            # Calculate frame rotation during signal transit time\n            ctm_e_i = ecef_to_eci_ctm(OMEGA_ie, approx_range, c)\n\n            # Calculate geometric range\n            delta_r = ctm_e_i * sat_r_es_e[i, :].T - r_ea_e\n            rangex = np.sqrt(delta_r.T * delta_r)\n\n            # Calculate geometric range rate\n            range_rate = u_as_e.T * (ctm_e_i * (sat_v_es_e[i, :].T + omega_ie_matrix * sat_r_es_e[i, :].T) -\n                                     (v_ea_e + omega_ie_matrix * r_ea_e))\n\n            # Calculate pseudo-range measurement: geometric range + SV clock errors + I and T delay + Epsilon\n            delta_t = tgps - sv_clock[i, 3]        # delta_t = tgps - toc (sec)\n\n            # Week crossover correction on t_oc\n            if delta_t > 3.024E+05:\n                delta_t -= 6.048E+05\n            elif delta_t < -3.024E+05:\n                delta_t += 6.048E+05\n\n            # Inter-signal timing biases for GPS L1 band signal, (sec)\n            delta_a_is_L1 = (gnss_config.SIS_err_SD\/c)*rnd.randn() - sv_clock[i, 4]\n\n            # SV clock bias, (m)\n            sv_clock_bias = (sv_clock[i, 1] * delta_t + delta_a_is_L1) * c\n\n            # Relativistic correction, (m)\n            rel_corr = -2.0*(sat_r_es_e[i, :]*sat_v_es_e[i, :].T)\/c\n\n            # SV clock errors, (m)\n            sv_clock_err = sv_clock_bias + rel_corr\n\n            # Code track error, (m)\n            epsilon = gnss_config.code_track_err_SD * rnd.randn()\n\n            # Pseudo-range, (m)\n            psdrel1 = gnss_config.rx_clock_offset\n            psdrel2 = gnss_config.rx_clock_drift * t_i\n            psdr = rangex + gnss_biases[i] + psdrel1 + psdrel2 + sv_clock_err + epsilon\n            pseudorange.append(psdr[0, 0])\n\n            # Calculate pseudo-range measurement: geometric range rate + SV clock drift error + Epsilon rate\n            # SV clock drift error, (m\/s)\n            sv_clock_drift = (sv_clock[i, 1] + sv_clock[i, 2]*delta_t)*c\n\n            # Code tracker error rate, (m\/s)\n            epsilon_rate = gnss_config.rate_track_err_SD * rnd.randn()\n\n            # Pseudo-range rate, (m\/s)\n            rx_clock_drift = gnss_config.rx_clock_drift\n            psdr_rate = range_rate + rx_clock_drift + sv_clock_drift + epsilon_rate\n            pseudorange_rate.append(psdr_rate[0, 0])\n\n            # Append satellite position and velocity to output data\n            rx.append(sat_r_es_e[i, 0])\n            ry.append(sat_r_es_e[i, 1])\n            rz.append(sat_r_es_e[i, 2])\n            vx.append(sat_v_es_e[i, 0])\n            vy.append(sat_v_es_e[i, 1])\n            vz.append(sat_v_es_e[i, 2])\n\n    # End of If Statement to Determine the Number of Satellites in View\n\n    # Forming the GNSS Measurement Output matrix\n    gnss_meas = np.matrix([pseudorange, pseudorange_rate, rx, ry, rz, vx, vy, vz]).T\n\n    return gnss_meas, no_gnss_meas, prn\n\n# End of GNSS Measurement Generation\n\n\n'''\n    --------------------------------------------------\n    7. Determine the LS Position & Velocity of Vehicle\n    --------------------------------------------------\n'''\n\n\ndef gnss_ls_pos_vel(gnss_meas, no_gnss_meas, pred_r_ea_e, pred_v_ea_e):\n\n    # ******************************************************************************************************************\n    #                                           POSITION AND CLOCK BIAS\n    # ******************************************************************************************************************\n\n    # Setup predicted state\n    x_pred = np.nan * np.matrix(np.ones((4, 1)))\n    x_pred[0:3, 0] = pred_r_ea_e\n    x_pred[3, 0] = 0\n    pred_meas = np.nan * np.matrix(np.ones((no_gnss_meas, 1)))\n    geo_matrix = np.nan * np.matrix(np.ones((no_gnss_meas, 4)))\n    est_clock = np.nan * np.ones((1, 2))\n    est_r_ea_e = np.nan * np.matrix([1, 1, 1]).T\n    est_v_ea_e = np.nan * np.matrix([1, 1, 1]).T\n    tolerance = 1\n\n    # Repeat until convergence\n    while tolerance > 1.0E-04:\n\n        # Loop measurements\n        for i in xrange(0, no_gnss_meas):\n\n            # Predict approximated geometric range\n            delta_r = gnss_meas[i, 2:5].T - x_pred[0:3, 0]\n            approx_range = np.sqrt(delta_r.T * delta_r)\n\n            # Calculate frame rotation during signal transit time\n            ctm_e_i = ecef_to_eci_ctm(OMEGA_ie, approx_range, c)\n\n            # Predict pseudo-range\n            delta_r = (ctm_e_i * gnss_meas[i, 2:5].T) - x_pred[0:3, 0]\n            rangex = np.sqrt(delta_r.T * delta_r)\n            pred_meas[i, 0] = rangex + x_pred[3, 0]\n\n            # Predict line of sight and deploy in measurement matrix\n            geo_matrix[i, 0:3] = -delta_r.T \/ rangex\n            geo_matrix[i, 3] = 1\n\n        # End of For Loop to Compute the Geometric matrix\n\n        # Unweighted least-squares solution\n        x_est = x_pred + (geo_matrix.T * geo_matrix).I * geo_matrix.T * (gnss_meas[:, 0] - pred_meas)\n\n        # Test convergence\n        tolerance = np.sqrt((x_est - x_pred).T * (x_est - x_pred))\n\n        # Set predictions to estimates for next iteration\n        x_pred = x_est\n\n    # End of While Loop (LS Estimation Converged)\n\n    # Set outputs to estimates\n    est_r_ea_e[:, 0] = x_est[0:3, 0]\n    est_clock[0, 0] = x_est[3, 0]\n\n    # ******************************************************************************************************************\n    #                                               VELOCITY AND CLOCK DRIFT\n    # ******************************************************************************************************************\n\n    # Skew symmetric matrix of Earth rate\n    omega_ie_matrix = skew_sym(np.matrix([[0], [0], [OMEGA_ie]]))\n\n    # Setup predicted state\n    x_pred[0:3, 0] = pred_v_ea_e\n    x_pred[3, 0] = 0\n    tolerance = 1\n\n    # Repeat until convergence\n    while tolerance > 1.0E-04:\n\n        # Loop measurements\n        for i in xrange(0, no_gnss_meas):\n\n            # Predict approximated geometric range\n            delta_r = gnss_meas[i, 2:5].T - est_r_ea_e\n            approx_range = np.sqrt(delta_r.T * delta_r)\n\n            # Calculate frame rotation during signal transit time\n            ctm_e_i = ecef_to_eci_ctm(OMEGA_ie, approx_range, c)\n\n            # Calculate geometric range\n            delta_r = ctm_e_i * gnss_meas[i, 2:5].T - est_r_ea_e\n            rangex = np.sqrt(delta_r.T * delta_r)\n\n            # Calculate line of sight\n            u_as_e = delta_r \/ rangex\n\n            # Predict pseudo-range rate\n            range_rate = u_as_e.T * (ctm_e_i * (gnss_meas[i, 5:8].T + omega_ie_matrix * gnss_meas[i, 2:5].T) -\n                                     (x_pred[0:3, 0] + omega_ie_matrix * est_r_ea_e))\n            pred_meas[i, 0] = range_rate + x_pred[3, 0]\n\n            # Predict line of sight and deploy in measurement matrix\n            geo_matrix[i, 0:3] = -u_as_e.T\n            geo_matrix[i, 3] = 1\n\n        # End of For Loop to Compute the Geometric matrix\n\n        # Unweighted least-squares solution\n        x_est = x_pred + (geo_matrix.T * geo_matrix).I * geo_matrix.T * (gnss_meas[:, 1] - pred_meas)\n\n        # Test convergence\n        tolerance = np.sqrt((x_est - x_pred).T * (x_est - x_pred))\n\n        # Set predictions to estimates for next iteration\n        x_pred = x_est\n\n    # End of While Loop (LS Estimation Converged)\n\n    # Set outputs to estimates\n    est_v_ea_e[:, 0] = x_est[0:3, 0]\n    est_clock[0, 1] = x_est[3, 0]\n\n    return est_r_ea_e, est_v_ea_e, est_clock\n\n# End of Computing GNSS Least Square Positions and Velocities\n\n\n'''\n    ---------------------------------------------------------------------------\n    8. Initialize the State Estimate Covariance Matrix, P for LC_EKF and TC_EKF\n    ---------------------------------------------------------------------------\n'''\n\n\ndef init_p_matrix(tightness, ekf_config):\n\n    if tightness == 'loose':\n\n        # Initialize error covariance matrix\n        p_matrix = np.zeros((15, 15))\n\n        # Determine each element of the covariance matrix\n        p_matrix[0:3, 0:3] = np.eye(3) * ekf_config.init_pos_unc ** 2\n        p_matrix[3:6, 3:6] = np.eye(3) * ekf_config.init_vel_unc ** 2\n        p_matrix[6:9, 6:9] = np.eye(3) * ekf_config.init_att_unc ** 2\n        p_matrix[9:12, 9:12] = np.eye(3) * ekf_config.init_b_a_unc ** 2\n        p_matrix[12:15, 12:15] = np.eye(3) * ekf_config.init_b_g_unc ** 2\n\n    elif tightness == 'tight':\n\n        # Initialize error covariance matrix\n        p_matrix = np.zeros((17, 17))\n\n        # Determine each element of the covariance matrix\n        p_matrix[0:3, 0:3] = np.eye(3) * ekf_config.init_pos_unc ** 2\n        p_matrix[3:6, 3:6] = np.eye(3) * ekf_config.init_vel_unc ** 2\n        p_matrix[6:9, 6:9] = np.eye(3) * ekf_config.init_att_unc ** 2\n        p_matrix[9:12, 9:12] = np.eye(3) * ekf_config.init_b_a_unc ** 2\n        p_matrix[12:15, 12:15] = np.eye(3) * ekf_config.init_b_g_unc ** 2\n        p_matrix[15, 15] = ekf_config.init_clock_offset_unc ** 2\n        p_matrix[16, 16] = ekf_config.init_clock_drift_unc ** 2\n\n    return p_matrix\n\n# End of Initializing Single EKF Matrix\n\n\n'''\n    ------------------------------------------------------------------\n    9. Initialize the State Estimate Covariance Matrix, P for Dual EKF\n    ------------------------------------------------------------------\n'''\n\n\ndef init_dual_p_matrix(lc_ekf_config, tc_ekf_config):\n\n    # Initialize error covariance matrix\n    lc_p_matrix = np.zeros((15, 15))\n    tc_p_matrix = np.zeros((17, 17))\n\n    # Determine each element of the covariance matrix\n    # For loosely coupled EKF\n    lc_p_matrix[0:3, 0:3] = np.eye(3) * lc_ekf_config.init_pos_unc ** 2\n    lc_p_matrix[3:6, 3:6] = np.eye(3) * lc_ekf_config.init_vel_unc ** 2\n    lc_p_matrix[6:9, 6:9] = np.eye(3) * lc_ekf_config.init_att_unc ** 2\n    lc_p_matrix[9:12, 9:12] = np.eye(3) * lc_ekf_config.init_b_a_unc ** 2\n    lc_p_matrix[12:15, 12:15] = np.eye(3) * lc_ekf_config.init_b_g_unc ** 2\n\n    # For tightly coupled EKF\n    tc_p_matrix[0:3, 0:3] = np.eye(3) * tc_ekf_config.init_pos_unc ** 2\n    tc_p_matrix[3:6, 3:6] = np.eye(3) * tc_ekf_config.init_vel_unc ** 2\n    tc_p_matrix[6:9, 6:9] = np.eye(3) * tc_ekf_config.init_att_unc ** 2\n    tc_p_matrix[9:12, 9:12] = np.eye(3) * tc_ekf_config.init_b_a_unc ** 2\n    tc_p_matrix[12:15, 12:15] = np.eye(3) * tc_ekf_config.init_b_g_unc ** 2\n    tc_p_matrix[15, 15] = tc_ekf_config.init_clock_offset_unc ** 2\n    tc_p_matrix[16, 16] = tc_ekf_config.init_clock_drift_unc ** 2\n\n    return lc_p_matrix, tc_p_matrix\n\n# End of Initializing Dual EKF Covariance Matrices\n\n\n'''\n    ------------------------------------------------------------\n    10. Calculate Specific Forces and Angular Rates from the IMU\n    ------------------------------------------------------------\n'''\n\n\ndef kinematics_ecef(tau_i, ctm_b_e, old_ctm_b_e, v_eb_e, old_v_eb_e, r_eb_e):\n\n    # Allocate the alpha_ib_b vector\n    alpha_ib_b = np.nan * np.matrix([[1], [1], [1]])\n\n    if tau_i > 0:\n\n        # Determine the Earth rotation over the update interval\n        [ctm_earth, alpha_ie] = c_earth(tau_i)\n\n        # Obtain coordinate transformation matrix from the old attitude (w.r.t. an inertial frame) to the new\n        ctm_old_new = ctm_b_e.T * ctm_earth * old_ctm_b_e\n\n        # Calculate the approximate angular rate w.r.t. an inertial frame\n        alpha_ib_b[0, 0] = 0.5 * (ctm_old_new[1, 2] - ctm_old_new[2, 1])\n        alpha_ib_b[1, 0] = 0.5 * (ctm_old_new[2, 0] - ctm_old_new[0, 2])\n        alpha_ib_b[2, 0] = 0.5 * (ctm_old_new[0, 1] - ctm_old_new[1, 0])\n\n        # Calculate and apply the scaling factor\n        scale = np.arccos(0.5 * (ctm_old_new[0, 0] + ctm_old_new[1, 1] + ctm_old_new[2, 2] - 1.0))\n\n        if scale > 2E-05:  # scaling factor is 1 if \"scale\" is less than this minimum limit.\n\n            alpha_ib_b = alpha_ib_b * scale \/ np.sin(scale)\n\n        # Calculate the angular rate using\n        omega_ib_b = alpha_ib_b \/ tau_i\n\n        # Calculate the specific force resolved about ECEF-frame axes\n        f_ib_e = ((v_eb_e - old_v_eb_e) \/ tau_i) - gravity_ecef(r_eb_e) + 2 * skew_sym(\n            np.matrix([[0], [0], [OMEGA_ie]])) * old_v_eb_e\n\n        # Calculate the average body-to-ECEF-frame coordinate transformation matrix over the update interval\n        mag_alpha = np.sqrt(alpha_ib_b.T * alpha_ib_b)\n        alpha_ib_b_matrix = skew_sym(alpha_ib_b)\n\n        if mag_alpha > 1.0E-8:\n\n            term_1 = ((1 - np.cos(mag_alpha[0, 0])) \/ (mag_alpha[0, 0] ** 2)) * alpha_ib_b_matrix\n\n            term_2 = ((1 - np.sin(mag_alpha[0, 0]) \/ mag_alpha[0, 0]) \/ (mag_alpha[0, 0] ** 2)) * (alpha_ib_b_matrix *\n                                                                                                   alpha_ib_b_matrix)\n            term_3 = 0.5 * skew_sym(np.matrix([[0], [0], [alpha_ie]])) * tau_i\n\n            ave_ctm_b_e = old_ctm_b_e * (np.matrix(np.eye(3)) + term_1 + term_2) + term_3 * old_ctm_b_e\n\n        else:\n\n            ave_ctm_b_e = old_ctm_b_e - 0.5 * skew_sym(np.matrix([[0], [0], [alpha_ie]])) * old_ctm_b_e * tau_i\n\n        # End of \"if\" mag_alpha\n\n        # Transform specific force to body-frame resolving axes\n        f_ib_b = ave_ctm_b_e.I * f_ib_e\n\n    else:\n\n        # If time interval is zero, set angular rate and specific force to zero\n        omega_ib_b = np.matrix(np.zeros((3, 1)))\n        f_ib_b = np.matrix(np.zeros((3, 1)))\n\n    # End of \"if\" tau_i\n\n    return f_ib_b, omega_ib_b\n\n# End of Calculating Specific Forces and Angular Rates\n\n\n'''\n    ----------------------------\n    11. Simulating the IMU Model\n    ----------------------------\n'''\n\n\ndef imu_model(tau_i, true_f_ib_b, true_omega_ib_b, imu_config, old_quant_residuals):\n\n    # Generate noise for accelerometer and gyroscope\n    if tau_i > 0:\n        accel_noise = np.matrix(rnd.randn(3, 1)) * imu_config.accel_noise_root_PSD \/ np.sqrt(tau_i)\n        gyro_noise = np.matrix(rnd.randn(3, 1)) * imu_config.gyro_noise_root_PSD \/ np.sqrt(tau_i)\n\n    else:\n        accel_noise = np.matrix([0, 0, 0]).T\n        gyro_noise = np.matrix([0, 0, 0]).T\n    # End  of If tau_i\n\n    # Calculate accelerometer and gyro outputs\n    uq_f_ib_b = imu_config.b_a + (np.matrix(np.eye(3)) + imu_config.M_a) * true_f_ib_b + accel_noise\n    uq_omega_ib_b = imu_config.b_g + imu_config.G_g * true_f_ib_b + gyro_noise + (np.matrix(np.eye(3)) +\n                                                                                  imu_config.M_g) * true_omega_ib_b\n    # Quantize accelerometer outputs\n    quant_residuals = np.nan * np.matrix(np.ones((6, 1)))\n\n    if imu_config.accel_quant_level > 0:\n        meas_f_ib_b = imu_config.accel_quant_level * np.round((uq_f_ib_b + old_quant_residuals[0:3, 0]) \/\n                                                              imu_config.accel_quant_level)\n        quant_residuals[0:3, 0] = uq_f_ib_b + old_quant_residuals[0:3, 0] - meas_f_ib_b\n\n    else:\n        meas_f_ib_b = uq_f_ib_b\n        quant_residuals[0:3, 0] = np.matrix([0, 0, 0]).T\n    # End  of If IMU_errors.accel_quant_level\n\n    # Quantize gyro outputs\n    if imu_config.gyro_quant_level > 0:\n        meas_omega_ib_b = imu_config.gyro_quant_level * np.round((uq_omega_ib_b + old_quant_residuals[3:6, 0]) \/\n                                                                 imu_config.gyro_quant_level)\n        quant_residuals[3:6, 0] = uq_omega_ib_b + old_quant_residuals[3:6, 0] - meas_omega_ib_b\n\n    else:\n        meas_omega_ib_b = uq_omega_ib_b\n        quant_residuals[3:6, 0] = np.matrix([0, 0, 0]).T\n\n    return meas_f_ib_b, meas_omega_ib_b, quant_residuals\n\n# End of Simulating IMU Model\n\n\n'''\n    -----------------------------------------\n    12. Update Estimated Navigation Solutions\n    -----------------------------------------\n'''\n\n\ndef nav_eqs_ecef(tau_i, old_r_eb_e, old_v_eb_e, old_ctm_b_e, f_ib_b, omega_ib_b):\n\n    # ******************************************************************************************************************\n    #                                               UPDATE ATTITUDE\n    # ******************************************************************************************************************\n    [ctm_earth, alpha_ie] = c_earth(tau_i)\n\n    # Calculate attitude increment, magnitude, and skew-symmetric matrix\n    alpha_ib_b = omega_ib_b * tau_i\n    mag_alpha = np.sqrt(alpha_ib_b.T * alpha_ib_b)\n    alpha_ib_b_matrix = skew_sym(alpha_ib_b)\n\n    # Obtain coordinate transformation matrix from the new attitude w.r.t. an inertial frame to the old using\n    # Rodrigues' formula\n    if mag_alpha > 1.0E-08:\n        c_term_1 = (np.sin(mag_alpha[0, 0]) \/ mag_alpha[0, 0]) * alpha_ib_b_matrix\n        c_term_2 = ((1 - np.cos(mag_alpha[0, 0])) \/ (mag_alpha[0, 0] ** 2)) * (alpha_ib_b_matrix * alpha_ib_b_matrix)\n        ctm_new_old = np.matrix(np.eye(3)) + c_term_1 + c_term_2\n    else:\n        ctm_new_old = np.matrix(np.eye(3)) + alpha_ib_b_matrix\n    # End  of \"if\" mag_alpha\n\n    # Update attitude\n    ctm_b_e = ctm_earth * old_ctm_b_e * ctm_new_old\n\n    # ******************************************************************************************************************\n    #                                   SPECIFIC FORCE FRAME TRANSFORMATION\n    # ******************************************************************************************************************\n\n    # Calculate the average body-to-ECEF-frame coordinate transformation matrix over the update interval\n    if mag_alpha > 1.0E-08:\n\n        a_term_1 = ((1 - np.cos(mag_alpha[0, 0])) \/ (mag_alpha[0, 0] ** 2)) * alpha_ib_b_matrix\n\n        a_term_2 = ((1 - np.sin(mag_alpha[0, 0]) \/ mag_alpha[0, 0]) \/ (mag_alpha[0, 0] ** 2)) * (alpha_ib_b_matrix *\n                                                                                                 alpha_ib_b_matrix)\n        a_term_3 = 0.5 * skew_sym(np.matrix([[0], [0], [alpha_ie]])) * tau_i\n\n        ave_ctm_b_e = old_ctm_b_e * (np.matrix(np.eye(3)) + a_term_1 + a_term_2) - a_term_3 * old_ctm_b_e\n\n    else:\n\n        ave_ctm_b_e = old_ctm_b_e - 0.5 * skew_sym(np.matrix([[0], [0], [alpha_ie]])) * old_ctm_b_e * tau_i\n\n    # End of \"if\" mag_alpha\n\n    # Transform specific force to ECEF-frame resolving axes\n    f_ib_e = ave_ctm_b_e * f_ib_b\n\n    # ******************************************************************************************************************\n    #                                           UPDATE VELOCITY\n    # ******************************************************************************************************************\n\n    v_eb_e = old_v_eb_e + tau_i * (f_ib_e + gravity_ecef(old_r_eb_e) -\n                                   2 * skew_sym(np.matrix([[0], [0], [OMEGA_ie]])) * old_v_eb_e)\n\n    # ******************************************************************************************************************\n    #                                       UPDATE CARTESIAN POSITION\n    # ******************************************************************************************************************\n    # From (5.38),\n    r_eb_e = old_r_eb_e + (v_eb_e + old_v_eb_e) * 0.5 * tau_i\n\n    return r_eb_e, v_eb_e, ctm_b_e\n\n# End of Updating Estimated Navigation Solutions\n\n\n'''\n    --------------------------------------------------------------\n    13. Loosely Coupled INS\/GNSS EKF Integration in a Single Epoch\n    --------------------------------------------------------------\n'''\n\n\ndef lc_ekf_epoch(gnss_r_eb_e, gnss_v_eb_e, tau_s, est_ctm_b_e_old, est_v_eb_e_old, est_r_eb_e_old, est_imu_bias_old,\n                 p_matrix_old, meas_f_ib_b, est_lat_b_old, lc_kf_config):\n\n    # 0. Skew symmetric matrix of Earth rate\n    omega_ie_matrix = skew_sym(np.matrix([[0], [0], [OMEGA_ie]]))\n\n    # ******************************************************************************************************************\n    #                                           SYSTEM PROPAGATION PHASE\n    # ******************************************************************************************************************\n\n    # 1. Build the System Matrix F in ECEF Frame\n    f_matrix = np.matrix(np.zeros((15, 15)))\n\n    # Calculate the meridian radius and transverse radius\n    [r_ns, r_ew] = radii_of_curv(est_lat_b_old)\n\n    # Calculate the geocentric radius at current latitude\n    geo_radius = r_ew * np.sqrt(np.cos(est_lat_b_old) ** 2.0 + ((1.0 - ecc_o ** 2.0) ** 2.0) *\n                                np.sin(est_lat_b_old) ** 2.0)\n\n    # For position vector\n    f_matrix[0:3, 3:6] = np.eye(3)\n\n    # For velocity vector\n    f_matrix[3:6, 0:3] = -(2.0 * gravity_ecef(est_r_eb_e_old) \/ geo_radius) * (est_r_eb_e_old.T \/ np.sqrt(\n        est_r_eb_e_old.T * est_r_eb_e_old))\n    f_matrix[3:6, 3:6] = -2.0 * omega_ie_matrix\n    f_matrix[3:6, 6:9] = -skew_sym(est_ctm_b_e_old * meas_f_ib_b)\n    f_matrix[3:6, 9:12] = est_ctm_b_e_old\n\n    # For attitude vector\n    f_matrix[6:9, 0:3] = -omega_ie_matrix\n    f_matrix[6:9, 12:15] = est_ctm_b_e_old\n\n    # 2. Determine the State Transition Matrix (first-order approximate), PHI = I + F*tau\n    phi_matrix = np.matrix(np.eye(15)) + f_matrix * tau_s\n\n    # 3. Determine approximate system noise covariance matrix\n    q_prime_matrix = np.matrix(np.zeros((15, 15)))\n    q_prime_matrix[3:6, 3:6] = np.eye(3) * lc_kf_config.accel_noise_PSD * tau_s\n    q_prime_matrix[6:9, 6:9] = np.eye(3) * lc_kf_config.gyro_noise_PSD * tau_s\n    q_prime_matrix[9:12, 9:12] = np.eye(3) * lc_kf_config.accel_bias_PSD * tau_s\n    q_prime_matrix[12:15, 12:15] = np.eye(3) * lc_kf_config.gyro_bias_PSD * tau_s\n\n    # 4. Propagate state estimates, noting that only the clock states are non-zero due to closed-loop correction\n    x_est_propa = np.matrix(np.zeros((15, 1)))\n\n    # 5. Propagate state estimation error covariance matrix\n    p_matrix_propa = phi_matrix * (p_matrix_old + 0.5 * q_prime_matrix) * phi_matrix.T + 0.5 * q_prime_matrix\n    # Check for NaNs\n    nans_indx = np.isnan(p_matrix_propa)\n    if nans_indx.any():\n        for i in xrange(0, 15):\n            for j in xrange(0, 15):\n                if nans_indx[i, j]:\n                    p_matrix_propa[i, j] = 0.0\n    # Check for negative infinity\n    neginf_indx = np.isneginf(p_matrix_propa)\n    if neginf_indx.any():\n        for i in xrange(0, 15):\n            for j in xrange(0, 15):\n                if neginf_indx[i, j]:\n                    p_matrix_propa[i, j] = -1.0E+08\n    # Check for positive infinity\n    posinf_indx = np.isposinf(p_matrix_propa)\n    if posinf_indx.any():\n        for i in xrange(0, 15):\n            for j in xrange(0, 15):\n                if posinf_indx[i, j]:\n                    p_matrix_propa[i, j] = 1.0E+08\n\n    # ******************************************************************************************************************\n    #                                           MEASUREMENT UPDATE PHASE\n    # ******************************************************************************************************************\n\n    # 6. Set-up measurement matrix\n    h_matrix = np.matrix(np.zeros((6, 15)))\n    h_matrix[0:3, 0:3] = -np.eye(3)\n    h_matrix[3:6, 3:6] = -np.eye(3)\n\n    # 7. Set-up measurement noise covariance matrix assuming all measurements are independent and have equal variance\n    #    for a given measurement type\n    r_matrix = np.matrix(np.zeros((6, 6)))\n    r_matrix[0:3, 0:3] = np.eye(3) * lc_kf_config.pos_meas_SD ** 2\n    r_matrix[3:6, 3:6] = np.eye(3) * lc_kf_config.vel_meas_SD ** 2\n\n    # 7. Calculate Kalman gain\n    k_matrix = p_matrix_propa * h_matrix.T * (h_matrix * p_matrix_propa * h_matrix.T + r_matrix).I\n\n    # 8. Formulate measurement innovations, noting that zero lever arm is assumed here\n    delta_z = np.matrix(np.zeros((6, 1)))\n    delta_z[0:3, 0] = gnss_r_eb_e - est_r_eb_e_old\n    delta_z[3:6, 0] = gnss_v_eb_e - est_v_eb_e_old\n\n    # 9. Update state estimates\n    x_est_new = x_est_propa + k_matrix * delta_z\n\n    # 10. Update state estimation error covariance matrix\n    p_matrix_new = (np.eye(15) - k_matrix * h_matrix) * p_matrix_propa\n\n    # ******************************************************************************************************************\n    #                                           CLOSED-LOOP CORRECTION\n    # ******************************************************************************************************************\n\n    # 11. Correct attitude, velocity, and position\n    est_ctm_b_e_new = (np.eye(3) - skew_sym(x_est_new[6:9])) * est_ctm_b_e_old\n    est_v_eb_e_new = est_v_eb_e_old - x_est_new[3:6]\n    est_r_eb_e_new = est_r_eb_e_old - x_est_new[0:3]\n\n    # 12. Update IMU bias estimates\n    est_imu_bias_new = est_imu_bias_old + x_est_new[9:15, 0]\n\n    return est_ctm_b_e_new, est_v_eb_e_new, est_r_eb_e_new, est_imu_bias_new, p_matrix_new\n\n# End of Loosely Coupled INS\/GNSS EKF Integration for a Single Epoch\n\n\n'''\n    ---------------------------------------------------------------\n    14. Main Function to Run the Loosely Coupled INS\/GPS EKF Fusion\n    ---------------------------------------------------------------\n'''\n\n\ndef lc_ins_gps_ekf_fusion(simtype, tightness, true_profile, no_t_steps, eul_err_nb_n, imu_config, gnss_config,\n                          lc_kf_config, DyOM, doy, fin_nav, gps_tow):\n\n    print 'Starting Loosely EKF Fusion...'\n\n    # 1. Initialize true navigation solution\n    old_t = true_profile[0, 0]                          # starting epoch (s)\n    true_lat_b = true_profile[0, 1]                     # initial true latitude (rad)\n    true_lon_b = true_profile[0, 2]                     # initial true longitude (rad)\n    true_alt_b = true_profile[0, 3]                     # initial true altitude (m)\n    true_v_eb_n = true_profile[0, 4:7].T                # initial true velocity vector (m\/s)\n    true_eul_nb = true_profile[0, 7:10].T               # initial true attitude (rad)\n    true_ctm_b_n = euler_to_ctm(true_eul_nb).T          # coordinate transfer matrix from body frame to NED frame\n\n    # 2. Convert all the above parameters to ECEF frame\n    [old_true_r_eb_e, old_true_v_eb_e, old_true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b,\n                                                                       true_v_eb_n, true_ctm_b_n)\n\n    # Conditioning the GNSS simulation by the \"simtype\"\n    if simtype == 'simulation':\n\n        # 3. Determine satellite positions and velocities\n        [sat_r_es_e, sat_v_es_e] = sat_pv_sim(old_t, gnss_config)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_sim(sat_r_es_e, old_true_r_eb_e, true_lat_b, true_lon_b, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = gnss_meas_gen_sim(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b,\n                                                           true_lon_b, old_true_v_eb_e, gnss_biases, gnss_config)\n\n    elif simtype == 'play back':\n\n        # 3.1 Process the Ephemeris only in the \"play back\" Mode\n        [iono_alpha, iono_beta, alma_t_para, sv_clock, navigation, ephemeris] = ephem_processing(finpath, fin_nav,\n                                                                                                 gps_tow, DyOM)\n        # 3.2 Save the Ephemris Data\n        navigation_fname = foutpath + 'navigation_message.txt'\n        np.savetxt(navigation_fname, navigation)\n        ephem_fname = foutpath + 'ephemeris.txt'\n        np.savetxt(ephem_fname, ephemeris)\n\n        # 3.3 Determine satellite positions and velocities in ECEF\n        [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, old_t, tol)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_ephem(old_t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                           true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = \\\n            gnss_meas_gen_ephem(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n    # Array to hold GNSS generated measurements for output\n    out_gnss_time = [old_t]\n    # out_gnss_time.append(old_t)\n    out_gnss_gen = np.nan * np.ones((1, 16, 9))\n    out_gnss_gen[0, 0:len(prn), 0] = prn\n    out_gnss_gen[0, 0:len(prn), 1:9] = gnss_meas\n\n    # 6. Determine Least-Square GNSS position solutions\n    [gnss_r_eb_e, gnss_v_eb_e, est_clock] = gnss_ls_pos_vel(gnss_meas, no_gnss_meas, gnss_config.init_est_r_ea_e,\n                                                            gnss_config.init_est_v_ea_e)\n\n    old_est_r_eb_e = gnss_r_eb_e\n    old_est_v_eb_e = gnss_v_eb_e\n\n    # 7. Convert Position and Velocity from ECEF to NED\n    [old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n] = pv_ecef_to_lla(old_est_r_eb_e, old_est_v_eb_e)\n    est_lat_b = old_est_lat_b\n    # Save the least-square gnss navigation solution to the outprofile\n\n    # 8. Initialize estimated attitude solution\n    old_est_ctm_b_n = init_ned_att(true_ctm_b_n, eul_err_nb_n)\n\n    # 9. Compute the CTM from NED to ECEF\n    [temp1, temp2, old_est_ctm_b_e] = lla_to_ecef(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n,\n                                                  old_est_ctm_b_n)\n\n    # 10. Initialize loosely coupled output profile and error profile\n    est_profile = np.nan * np.ones((no_t_steps, 10))\n    est_errors = np.nan * np.ones((no_t_steps, 10))\n\n    # 11. Generate loosely coupled initial output profile\n    est_profile[0, 0] = old_t\n    est_profile[0, 1] = old_est_lat_b\n    est_profile[0, 2] = old_est_lon_b\n    est_profile[0, 3] = old_est_alt_b\n    est_profile[0, 4:7] = old_est_v_eb_n.T\n    est_profile[0, 7:10] = ctm_to_euler(old_est_ctm_b_n.T).T\n\n    # 12. Determine errors and generate output record\n    [delta_r_eb_n, delta_v_eb_n, eul_err_nb_n] = \\\n        cal_err_ned(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n, old_est_ctm_b_n, true_lat_b,\n                    true_lon_b, true_alt_b, true_v_eb_n, true_ctm_b_n)\n\n    # 13. Generate loosely coupled initial error profile\n    est_errors[0, 0] = old_t\n    est_errors[0, 1:4] = delta_r_eb_n.T\n    est_errors[0, 4:7] = delta_v_eb_n.T\n    est_errors[0, 7:10] = eul_err_nb_n.T\n\n    # 15. Initialize loosely coupled Kalman filter P matrix\n    p_matrix = init_p_matrix(tightness, lc_kf_config)\n\n    # 16. Initialize IMU bias states\n    est_imu_bias = np.matrix(np.zeros((6, 1)))\n\n    # 17. Initialize IMU quantization residuals\n    quant_resid = np.matrix(np.zeros((6, 1)))\n\n    # 18. Generate IMU bias and clock output records\n    out_imu_gen = np.nan * np.matrix(np.ones((no_t_steps, 7)))\n    out_imu_gen[0, 0] = old_t\n    out_imu_gen[0, 1:7] = 0.0\n    out_imu_bias_est = np.nan * np.matrix(np.ones((1, 7)))\n    out_imu_bias_est[0, 0] = old_t\n    out_imu_bias_est[0, 1:7] = est_imu_bias.T\n    output_clock = np.nan * np.matrix(np.ones((1, 3)))\n    output_clock[0, 0] = old_t\n    output_clock[0, 1:3] = est_clock\n\n    # 19. Generate KF uncertainty record in ECEF\n    output_kf_sd = np.nan * np.matrix(np.ones((1, 16)))\n    output_kf_sd[0, 0] = old_t\n    eig_value = lina.eigvals(p_matrix)\n    for i in xrange(0, 15):\n        output_kf_sd[0, i + 1] = np.sqrt(abs(eig_value[i]))\n    # End of For Loop\n\n    # Convert the standard deviations to NED\n    [r_temp, v_temp, euler_temp] = ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, output_kf_sd[0, 1:10])\n\n    output_kf_sd[0, 1:4] = r_temp.T\n    output_kf_sd[0, 4:7] = v_temp.T\n    output_kf_sd[0, 7:10] = euler_temp.T\n\n    # 20. Initialize GNSS model timing\n    t_last_gnss = old_t\n    gnss_epoch = 1\n\n    # 21. Initialize Progress Bar\n    print 'Simulation is in Progress. Please Wait!'\n\n    # ******************************************************************************************************************\n    #                                                   MAIN LOOP\n    # ******************************************************************************************************************\n\n    for epoch in xrange(1, no_t_steps):\n\n        # 22. Input data from motion profile\n        t = true_profile[epoch, 0]                      # current epoch (s)\n        true_lat_b = true_profile[epoch, 1]             # current true latitude (rad)\n        true_lon_b = true_profile[epoch, 2]             # current true longitude (rad)\n        true_alt_b = true_profile[epoch, 3]             # current true altitude (m)\n        true_v_eb_n = true_profile[epoch, 4:7].T        # current true velocity vector (m\/s)\n        true_eul_nb = true_profile[epoch, 7:10].T\n        true_ctm_b_n = euler_to_ctm(true_eul_nb).T\n        [true_r_eb_e, true_v_eb_e, true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b, true_v_eb_n,\n                                                               true_ctm_b_n)\n        tau_i = t - old_t\n\n        # Conditioning the IMU simulation by the \"simtype\"\n        if simtype == 'simulation':\n\n            # 23. Calculate specific force and angular rate\n            [true_f_ib_b, true_omega_ib_b] = kinematics_ecef(tau_i, true_ctm_b_e, old_true_ctm_b_e, true_v_eb_e,\n                                                             old_true_v_eb_e, old_true_r_eb_e)\n\n            # 24. Simulate IMU errors\n            [meas_f_ib_b, meas_omega_ib_b, quant_resid] = imu_model(tau_i, true_f_ib_b, true_omega_ib_b, imu_config,\n                                                                    quant_resid)\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        elif simtype == 'play back':\n\n            # 23. Calculate specific force and angular rate\n            true_f_ib_b = true_profile[epoch, 16:19].T                          # accelerometer reading (error free)\n            true_omega_ib_b = true_profile[epoch, 10:13].T                      # gyroscope reading (error free)\n\n            # 24. Simulate IMU errors\n            meas_f_ib_b = true_f_ib_b + true_profile[epoch, 19:22].T            # accelerometer reading\n            meas_omega_ib_b = true_omega_ib_b + true_profile[epoch, 13:16].T    # gyroscope reading\n\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        # 25. Correct IMU errors\n        meas_f_ib_b = meas_f_ib_b - est_imu_bias[0:3, 0]\n        meas_omega_ib_b = meas_omega_ib_b - est_imu_bias[3:6, 0]\n\n        # 26. Update estimated navigation solution\n        [est_r_eb_e, est_v_eb_e, est_ctm_b_e] = nav_eqs_ecef(tau_i, old_est_r_eb_e, old_est_v_eb_e, old_est_ctm_b_e,\n                                                             meas_f_ib_b, meas_omega_ib_b)\n\n        # 27. Determine whether to update GNSS simulation and run Kalman filter\n        if (t - t_last_gnss) >= gnss_config.epoch_interval:\n\n            gnss_epoch += 1             # update epoch (time) index\n            tau_s = t - t_last_gnss     # KF time interval\n            t_last_gnss = t             # update the last epoch\n\n            # Conditioning the GNSS simulation by the \"simtype\"\n            if simtype == 'simulation':\n\n                # 28. Determine satellite positions and velocities\n                [sat_r_es_e, sat_v_es_e] = sat_pv_sim(t, gnss_config)\n\n                # 29. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = gnss_meas_gen_sim(t, sat_r_es_e, sat_v_es_e, true_r_eb_e, true_lat_b,\n                                                                   true_lon_b, true_v_eb_e, gnss_biases, gnss_config)\n\n            elif simtype == 'play back':\n\n                # 28.1 Determine satellite positions and velocities in ECEF\n                [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, t, tol)\n\n                # 28.2 Initialize the GNSS biases\n                gnss_biases = init_gnss_bias_ephem(t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                                   true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n                # 29. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = \\\n                    gnss_meas_gen_ephem(t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                        old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n            # Array to hold GNSS generated measurements for output\n            out_gnss_time.append(t)\n            out_gnss_gen_new = np.nan * np.ones((gnss_epoch, 16, 9))\n            out_gnss_gen_new[0:gnss_epoch - 1, :, :] = out_gnss_gen\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 0] = prn\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 1:9] = gnss_meas\n            out_gnss_gen = out_gnss_gen_new\n\n            # 30. Determine Least-Square GNSS position solutions\n            [gnss_r_eb_e, gnss_v_eb_e, est_clock] = gnss_ls_pos_vel(gnss_meas, no_gnss_meas, gnss_r_eb_e, gnss_v_eb_e)\n\n            # 31. Run Integration Kalman filter\n            [est_ctm_b_e, est_v_eb_e, est_r_eb_e, est_imu_bias, p_matrix] = \\\n                lc_ekf_epoch(gnss_r_eb_e, gnss_v_eb_e, tau_s, est_ctm_b_e, est_v_eb_e, est_r_eb_e, est_imu_bias,\n                             p_matrix, meas_f_ib_b, est_lat_b, lc_kf_config)\n\n            # 32. Generate IMU Bias and Clock Output Records Recursively\n            # 32.1 IMU Bias\n            out_imu_bias_est_new = np.nan * np.matrix(np.ones((gnss_epoch, 7)))\n            out_imu_bias_est_new[0:gnss_epoch - 1, 0] = out_imu_bias_est[0:gnss_epoch - 1, 0]\n            out_imu_bias_est_new[gnss_epoch - 1, 0] = t\n            out_imu_bias_est_new[0:gnss_epoch - 1, 1:7] = out_imu_bias_est[0:gnss_epoch - 1, 1:7]\n            out_imu_bias_est_new[gnss_epoch - 1, 1:7] = est_imu_bias.T\n            out_imu_bias_est = out_imu_bias_est_new\n\n            # 32.2 Clock Bias\n            out_clock_new = np.nan * np.matrix(np.ones((gnss_epoch, 3)))\n            out_clock_new[0:gnss_epoch - 1, 0] = output_clock[0:gnss_epoch - 1, 0]\n            out_clock_new[gnss_epoch - 1, 0] = t\n            out_clock_new[0:gnss_epoch - 1, 1:3] = output_clock[0:gnss_epoch - 1, 1:3]\n            out_clock_new[gnss_epoch - 1, 1:3] = est_clock\n            output_clock = out_clock_new\n\n            # 33. Generate KF uncertainty output record recursively\n            out_kf_sd_new = np.nan * np.matrix(np.ones((gnss_epoch, 16)))\n            out_kf_sd_new[0:gnss_epoch - 1, 0] = output_kf_sd[0:gnss_epoch - 1, 0]\n            out_kf_sd_new[gnss_epoch - 1, 0] = t\n            out_kf_sd_new[0:gnss_epoch - 1, 1:16] = output_kf_sd[0:gnss_epoch - 1, 1:16]\n            eig_value = lina.eigvals(p_matrix)\n            for i in xrange(0, 15):\n                out_kf_sd_new[gnss_epoch - 1, i + 1] = np.sqrt(abs(eig_value[i]))\n            # End of For out_kf_sd update\n\n            # Convert the standard deviations to LLA\n            [r_temp, v_temp, euler_temp] = \\\n                ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, out_kf_sd_new[gnss_epoch - 1, 1:10])\n\n            out_kf_sd_new[gnss_epoch - 1, 1:4] = r_temp.T\n            out_kf_sd_new[gnss_epoch - 1, 4:7] = v_temp.T\n            out_kf_sd_new[gnss_epoch - 1, 7:10] = euler_temp.T\n\n            output_kf_sd = out_kf_sd_new\n\n        # End of \"if\" on checking for GNSS update\n\n        # 34. Convert navigation solution to NED\n        [est_lat_b, est_lon_b, est_alt_b, est_v_eb_n, est_ctm_b_n] = ecef_to_lla(est_r_eb_e, est_v_eb_e, est_ctm_b_e)\n\n        # 35. Generate output profile record\n        est_profile[epoch, 0] = t\n        est_profile[epoch, 1] = est_lat_b\n        est_profile[epoch, 2] = est_lon_b\n        est_profile[epoch, 3] = est_alt_b\n        est_profile[epoch, 4:7] = est_v_eb_n.T\n        est_profile[epoch, 7:10] = ctm_to_euler(est_ctm_b_n.T).T\n\n        # 36. Determine Errors\n        [delta_r_eb_n, delta_v_eb_n, eul_err_nb_n] = \\\n            cal_err_ned(est_lat_b, est_lon_b, est_alt_b, est_v_eb_n, est_ctm_b_n, true_lat_b, true_lon_b, true_alt_b,\n                        true_v_eb_n, true_ctm_b_n)\n\n        # 37. Generate Error Records\n        est_errors[epoch, 0] = t\n        est_errors[epoch, 1:4] = delta_r_eb_n.T\n        est_errors[epoch, 4:7] = delta_v_eb_n.T\n        est_errors[epoch, 7:10] = eul_err_nb_n.T\n\n        # 38. Reset old values\n        old_t = t\n        old_true_r_eb_e = true_r_eb_e\n        old_true_v_eb_e = true_v_eb_e\n        old_true_ctm_b_e = true_ctm_b_e\n        old_est_r_eb_e = est_r_eb_e\n        old_est_v_eb_e = est_v_eb_e\n        old_est_ctm_b_e = est_ctm_b_e\n\n        # 39. Updating Progress Bar\n        progressbar(epoch \/ float(no_t_steps))\n\n    # End of For Main Loop\n\n    print '\\n NavSim Completed!'\n\n    return est_profile, est_errors, output_kf_sd, out_imu_gen, out_imu_bias_est, output_clock, out_gnss_gen, \\\n           out_gnss_time\n\n# End of Main Loosely Coupled INS\/GNSS Fusion\n\n\n'''\n    --------------------------------------------------------------\n    15. Tightly Coupled INS\/GNSS EKF Integration in a Single Epoch\n    --------------------------------------------------------------\n'''\n\n\ndef tc_ekf_epoch(gnss_meas, no_meas, tau_s, est_ctm_b_e_old, est_v_eb_e_old, est_r_eb_e_old, est_imu_bias_old,\n                 est_clock_old, p_matrix_old, meas_f_ib_b, est_lat_b_old, tc_kf_config):\n\n    # 0. Skew symmetric matrix of Earth rate\n    omega_ie_matrix = skew_sym(np.matrix([[0], [0], [OMEGA_ie]]))\n\n    # ******************************************************************************************************************\n    #                                           SYSTEM PROPAGATION PHASE\n    # ******************************************************************************************************************\n\n    # 1. Build the System Matrix F in ECEF Frame\n    f_matrix = np.matrix(np.zeros((17, 17)))\n\n    # Calculate the meridian radius and transverse radius\n    [r_ns, r_ew] = radii_of_curv(est_lat_b_old)\n\n    # Calculate the geocentric radius at current latitude\n    geo_radius = r_ew * np.sqrt(np.cos(est_lat_b_old) ** 2.0 + ((1.0 - ecc_o ** 2.0) ** 2.0) *\n                                np.sin(est_lat_b_old) ** 2.0)\n\n    # For position vector\n    f_matrix[0:3, 3:6] = np.eye(3)\n\n    # For velocity vector\n    f_matrix[3:6, 0:3] = -(2.0 * gravity_ecef(est_r_eb_e_old) \/ geo_radius) * (est_r_eb_e_old.T \/ np.sqrt(\n        est_r_eb_e_old.T * est_r_eb_e_old))\n    f_matrix[3:6, 3:6] = -2.0 * omega_ie_matrix\n    f_matrix[3:6, 6:9] = -skew_sym(est_ctm_b_e_old * meas_f_ib_b)\n    f_matrix[3:6, 9:12] = est_ctm_b_e_old\n\n    # For attitude vector\n    f_matrix[6:9, 0:3] = -omega_ie_matrix\n    f_matrix[6:9, 12:15] = est_ctm_b_e_old\n\n    # For user's clock drift (bias rate)\n    f_matrix[15, 16] = 1.0\n\n    # 2. Determine the State Transition Matrix (first-order approximate), PHI = I + F*tau\n    phi_matrix = np.matrix(np.eye(17)) + f_matrix * tau_s\n\n    # 3. Determine approximate system noise covariance matrix\n    q_prime_matrix = np.matrix(np.zeros((17, 17)))\n    q_prime_matrix[3:6, 3:6] = np.eye(3) * tc_kf_config.accel_noise_PSD * tau_s\n    q_prime_matrix[6:9, 6:9] = np.eye(3) * tc_kf_config.gyro_noise_PSD * tau_s\n    q_prime_matrix[9:12, 9:12] = np.eye(3) * tc_kf_config.accel_bias_PSD * tau_s\n    q_prime_matrix[12:15, 12:15] = np.eye(3) * tc_kf_config.gyro_bias_PSD * tau_s\n    q_prime_matrix[15, 15] = tc_kf_config.clock_phase_PSD * tau_s\n    q_prime_matrix[16, 16] = tc_kf_config.clock_freq_PSD * tau_s\n\n    # 3. Propagate state estimates, noting that only the clock states are non-zero due to closed-loop correction\n    x_est_propa = np.nan * np.matrix(np.ones((17, 1)))\n    x_est_propa[0:15, 0] = 0.0\n    x_est_propa[15, 0] = est_clock_old[0, 0] + est_clock_old[0, 1] * tau_s\n    x_est_propa[16, 0] = est_clock_old[0, 1]\n\n    # 4. Propagate state estimation error covariance matrix\n    p_matrix_propa = phi_matrix * (p_matrix_old + 0.5 * q_prime_matrix) * phi_matrix.T + 0.5 * q_prime_matrix\n    # Check for NaNs\n    nans_indx = np.isnan(p_matrix_propa)\n    if nans_indx.any():\n        for i in xrange(0, 17):\n            for j in xrange(0, 17):\n                if nans_indx[i, j]:\n                    p_matrix_propa[i, j] = 0.0\n    # Check for negative infinity\n    neginf_indx = np.isneginf(p_matrix_propa)\n    if neginf_indx.any():\n        for i in xrange(0, 17):\n            for j in xrange(0, 17):\n                if neginf_indx[i, j]:\n                    p_matrix_propa[i, j] = -1.0E+08\n    # Check for positive infinity\n    posinf_indx = np.isposinf(p_matrix_propa)\n    if posinf_indx.any():\n        for i in xrange(0, 17):\n            for j in xrange(0, 17):\n                if posinf_indx[i, j]:\n                    p_matrix_propa[i, j] = 1.0E+08\n\n    # ******************************************************************************************************************\n    #                                           MEASUREMENT UPDATE PHASE\n    # ******************************************************************************************************************\n    u_as_e_trps = np.matrix(np.zeros((no_meas, 3)))\n    v_as_e_trps = np.matrix(np.zeros((no_meas, 3)))\n    pred_meas = np.matrix(np.zeros((no_meas, 2)))\n\n    # 5. Loop over measurements\n    for i in xrange(0, no_meas):\n\n        # 5.1 Predict approximated geometric range\n        delta_r = gnss_meas[i, 2:5].T - est_r_eb_e_old\n        approx_range = np.sqrt(delta_r.T * delta_r)\n\n        # 5.2 Calculate frame rotation during signal transit time\n        ctm_e_i = ecef_to_eci_ctm(OMEGA_ie, approx_range, c)\n\n        # 5.3 Predict pseudo-range in ECEF\n        delta_r = ctm_e_i * gnss_meas[i, 2:5].T - est_r_eb_e_old\n        rangex = np.sqrt(delta_r.T * delta_r)\n        pred_meas[i, 0] = rangex + x_est_propa[15, 0]\n\n        # 5.4 Predict line of sight\n        u_as_e_trps[i, 0:3] = delta_r.T \/ rangex\n\n        # 5.5 For pseudorange-range rate position dependent unit vector\n        delta_v = ctm_e_i * gnss_meas[i, 5:8].T - est_v_eb_e_old\n        v_as_e_trps[i, 0] = (delta_r[0, 0] ** 2 - rangex ** 2) * delta_v[0, 0] \/ (rangex ** 3)\n        v_as_e_trps[i, 1] = (delta_r[1, 0] ** 2 - rangex ** 2) * delta_v[1, 0] \/ (rangex ** 3)\n        v_as_e_trps[i, 2] = (delta_r[2, 0] ** 2 - rangex ** 2) * delta_v[2, 0] \/ (rangex ** 3)\n\n        # 5.6 Predict pseudo-range rate in ECEF\n        rate_term_1 = ctm_e_i * (gnss_meas[i, 5:8].T + omega_ie_matrix * gnss_meas[i, 2:5].T)\n        rate_term_2 = est_v_eb_e_old + omega_ie_matrix * est_r_eb_e_old\n        range_rate = u_as_e_trps[i, 0:3] * (rate_term_1 - rate_term_2)\n        pred_meas[i, 1] = range_rate + x_est_propa[16, 0]\n\n    # End of For Loop on Measurements\n\n    # 6. Set-up measurement matrix\n    h_matrix = np.matrix(np.zeros((2 * no_meas, 17)))\n    h_matrix[0:no_meas, 0:3] = u_as_e_trps[0:no_meas, 0:3]\n    h_matrix[0:no_meas, 15] = np.ones((no_meas, 1))\n    h_matrix[no_meas:2 * no_meas, 0:3] = v_as_e_trps[0:no_meas, 0:3]\n    h_matrix[no_meas:2 * no_meas, 3:6] = u_as_e_trps[0:no_meas, 0:3]\n    h_matrix[no_meas:2 * no_meas, 16] = np.ones((no_meas, 1))\n\n    # 7. Set-up measurement noise covariance matrix assuming all measurements are independent and have equal variance\n    #    for a given measurement type\n    r_matrix = np.matrix(np.zeros((2 * no_meas, 2 * no_meas)))\n    r_matrix[0:no_meas, 0:no_meas] = np.eye(no_meas) * tc_kf_config.pseudo_range_SD ** 2\n    r_matrix[no_meas:2 * no_meas, no_meas:2 * no_meas] = np.eye(no_meas) * tc_kf_config.range_rate_SD ** 2\n\n    # 8. Calculate Kalman gain\n    k_matrix = p_matrix_propa * h_matrix.T * (h_matrix * p_matrix_propa * h_matrix.T + r_matrix).I\n\n    # 9. Formulate measurement innovations\n    delta_z = np.matrix(np.zeros((2 * no_meas, 1)))\n    delta_z[0:no_meas, 0] = gnss_meas[0:no_meas, 0] - pred_meas[0:no_meas, 0]\n    delta_z[no_meas:2 * no_meas, 0] = gnss_meas[0:no_meas, 1] - pred_meas[0:no_meas, 1]\n\n    # 10. Update state estimates\n    x_est_new = x_est_propa + k_matrix * delta_z\n\n    # 11. Update state estimation error covariance matrix\n    p_matrix_new = (np.eye(17) - k_matrix * h_matrix) * p_matrix_propa\n\n    # ******************************************************************************************************************\n    #                                           CLOSED-LOOP CORRECTION\n    # ******************************************************************************************************************\n\n    # 12. Correct attitude, velocity, and position\n    est_ctm_b_e_new = (np.eye(3) - skew_sym(x_est_new[6:9])) * est_ctm_b_e_old\n    est_v_eb_e_new = est_v_eb_e_old - x_est_new[3:6]\n    est_r_eb_e_new = est_r_eb_e_old - x_est_new[0:3]\n\n    # 13. Update IMU bias and GNSS receiver clock estimates\n    est_imu_bias_new = est_imu_bias_old + x_est_new[9:15]\n    est_clock_new = x_est_new[15:17].T\n\n    return est_ctm_b_e_new, est_v_eb_e_new, est_r_eb_e_new, est_imu_bias_new, est_clock_new, p_matrix_new\n\n# End of Tightly Coupled INS\/GNSS EKF Integration for a Single Epoch\n\n\n'''\n    ---------------------------------------------------------------\n    16. Main Function to Run the Tightly Coupled INS\/GPS EKF Fusion\n    ---------------------------------------------------------------\n'''\n\n\ndef tc_ins_gps_ekf_fusion(simtype, tightness, true_profile, no_t_steps, eul_err_nb_n, imu_config, gnss_config,\n                          tc_kf_config, DyOM, doy, fin_nav, gps_tow):\n\n    print 'Starting Tightly EKF Fusion...'\n\n    # 1. Initialize true navigation solution\n    old_t = true_profile[0, 0]                          # starting epoch (s)\n    true_lat_b = true_profile[0, 1]                     # initial true latitude (rad)\n    true_lon_b = true_profile[0, 2]                     # initial true longitude (rad)\n    true_alt_b = true_profile[0, 3]                     # initial true altitude (m)\n    true_v_eb_n = true_profile[0, 4:7].T                # initial true velocity vector (m\/s)\n    true_eul_nb = true_profile[0, 7:10].T               # initial true attitude (rad)\n    true_ctm_b_n = euler_to_ctm(true_eul_nb).T          # coordinate transfer matrix from body frame to NED frame\n\n    # 2. Convert all the above parameters to ECEF frame\n    [old_true_r_eb_e, old_true_v_eb_e, old_true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b,\n                                                                       true_v_eb_n, true_ctm_b_n)\n\n    # Conditioning the GNSS simulation by the \"simtype\"\n    if simtype == 'simulation':\n\n        # 3. Determine satellite positions and velocities\n        [sat_r_es_e, sat_v_es_e] = sat_pv_sim(old_t, gnss_config)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_sim(sat_r_es_e, old_true_r_eb_e, true_lat_b, true_lon_b, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = gnss_meas_gen_sim(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b,\n                                                           true_lon_b, old_true_v_eb_e, gnss_biases, gnss_config)\n\n    elif simtype == 'play back':\n\n        # 3.1 Process the Ephemeris only in the \"play back\" Mode\n        [iono_alpha, iono_beta, alma_t_para, sv_clock, navigation, ephemeris] = ephem_processing(finpath, fin_nav,\n                                                                                                 gps_tow, DyOM)\n\n        # 3.2 Save the Ephemris Data\n        navigation_fname = foutpath + 'navigation_message.txt'\n        np.savetxt(navigation_fname, navigation)\n        ephem_fname = foutpath + 'ephemeris.txt'\n        np.savetxt(ephem_fname, ephemeris)\n\n        # 3.3 Determine satellite positions and velocities in ECEF\n        [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, old_t, tol)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_ephem(old_t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                           true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = \\\n            gnss_meas_gen_ephem(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n    # Array to hold GNSS generated measurements for output\n    out_gnss_time = [old_t]\n    out_gnss_gen = np.nan * np.ones((1, 16, 9))\n    out_gnss_gen[0, 0:len(prn), 0] = prn\n    out_gnss_gen[0, 0:len(prn), 1:9] = gnss_meas\n\n    # 6. Determine Least-square GNSS position solutions\n    [old_est_r_eb_e, old_est_v_eb_e, est_clock] = gnss_ls_pos_vel(gnss_meas, no_gnss_meas, gnss_config.init_est_r_ea_e,\n                                                                  gnss_config.init_est_v_ea_e)\n\n    # 7. Convert Position and Velocity from ECEF to NED\n    [old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n] = pv_ecef_to_lla(old_est_r_eb_e, old_est_v_eb_e)\n    est_lat_b = old_est_lat_b\n\n    # 8. Initialize estimated attitude solution\n    old_est_ctm_b_n = init_ned_att(true_ctm_b_n, eul_err_nb_n)\n\n    # 9. Compute the CTM from NED to ECEF\n    [temp1, temp2, old_est_ctm_b_e] = lla_to_ecef(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n,\n                                                  old_est_ctm_b_n)\n\n    # 10. Initialize tightly coupled output profile and error profile\n    est_profile = np.nan * np.ones((no_t_steps, 10))\n    est_errors = np.nan * np.ones((no_t_steps, 10))\n\n    # 11. Generate tightly coupled initial output profile\n    est_profile[0, 0] = old_t\n    est_profile[0, 1] = old_est_lat_b\n    est_profile[0, 2] = old_est_lon_b\n    est_profile[0, 3] = old_est_alt_b\n    est_profile[0, 4:7] = old_est_v_eb_n.T\n    est_profile[0, 7:10] = ctm_to_euler(old_est_ctm_b_n.T).T\n\n    # 13. Determine errors and generate output record\n    [delta_r_eb_n, delta_v_eb_n, eul_err_nb_n] = \\\n        cal_err_ned(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n, old_est_ctm_b_n, true_lat_b,\n                    true_lon_b, true_alt_b, true_v_eb_n, true_ctm_b_n)\n\n    # 14. Generate tightly coupled initial error profile\n    est_errors[0, 0] = old_t\n    est_errors[0, 1:4] = delta_r_eb_n.T\n    est_errors[0, 4:7] = delta_v_eb_n.T\n    est_errors[0, 7:10] = eul_err_nb_n.T\n\n    # 15. Initialize tightly coupled Kalman filter P matrix\n    p_matrix = init_p_matrix(tightness, tc_kf_config)\n\n    # 16. Initialize IMU bias states\n    est_imu_bias = np.matrix(np.zeros((6, 1)))\n\n    # 17. Initialize IMU quantization residuals\n    quant_resid = np.matrix(np.zeros((6, 1)))\n\n    # 18. Generate IMU bias and clock output records\n    out_imu_gen = np.nan * np.matrix(np.ones((no_t_steps, 7)))\n    out_imu_gen[0, 0] = old_t\n    out_imu_gen[0, 1:7] = 0.0\n    out_imu_bias_est = np.nan * np.matrix(np.ones((1, 7)))\n    out_imu_bias_est[0, 0] = old_t\n    out_imu_bias_est[0, 1:7] = est_imu_bias.T\n    output_clock = np.nan * np.matrix(np.ones((1, 3)))\n    output_clock[0, 0] = old_t\n    output_clock[0, 1:3] = est_clock\n\n    # 19. Generate KF uncertainty record\n    output_kf_sd = np.nan * np.matrix(np.ones((1, 18)))\n    output_kf_sd[0, 0] = old_t\n    eig_value = lina.eigvals(p_matrix)\n    for i in xrange(0, 17):\n        output_kf_sd[0, i + 1] = np.sqrt(abs(eig_value[i]))\n    # End of For Loop\n\n    # Convert the standard deviations to LLA\n    [r_temp, v_temp, euler_temp] = ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, output_kf_sd[0, 1:10])\n\n    output_kf_sd[0, 1:4] = r_temp.T\n    output_kf_sd[0, 4:7] = v_temp.T\n    output_kf_sd[0, 7:10] = euler_temp.T\n\n    # 20. Initialize GNSS model timing\n    t_last_gnss = old_t\n    gnss_epoch = 1\n\n    # 21. Initialize Progress Bar\n    print 'Simulation is in Progress. Please Wait!'\n\n    # ******************************************************************************************************************\n    #                                                   MAIN LOOP\n    # ******************************************************************************************************************\n\n    for epoch in xrange(1, no_t_steps):\n\n        # 22. Input data from motion profile\n        t = true_profile[epoch, 0]                      # current epoch (s)\n        true_lat_b = true_profile[epoch, 1]             # current true latitude (rad)\n        true_lon_b = true_profile[epoch, 2]             # current true longitude (rad)\n        true_alt_b = true_profile[epoch, 3]             # current true altitude (m)\n        true_v_eb_n = true_profile[epoch, 4:7].T        # current true velocity vector (m\/s)\n        true_eul_nb = true_profile[epoch, 7:10].T\n        true_ctm_b_n = euler_to_ctm(true_eul_nb).T\n        [true_r_eb_e, true_v_eb_e, true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b, true_v_eb_n,\n                                                               true_ctm_b_n)\n        tau_i = t - old_t\n\n        # Conditioning the IMU simulation by the \"simtype\"\n        if simtype == 'simulation':\n\n            # 23. Calculate specific force and angular rate\n            [true_f_ib_b, true_omega_ib_b] = kinematics_ecef(tau_i, true_ctm_b_e, old_true_ctm_b_e, true_v_eb_e,\n                                                             old_true_v_eb_e, old_true_r_eb_e)\n\n            # 24. Simulate IMU errors\n            [meas_f_ib_b, meas_omega_ib_b, quant_resid] = imu_model(tau_i, true_f_ib_b, true_omega_ib_b, imu_config,\n                                                                    quant_resid)\n\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        elif simtype == 'play back':\n\n            # 23. Calculate specific force and angular rate\n            true_f_ib_b = true_profile[epoch, 16:19].T                          # accelerometer reading (error free)\n            true_omega_ib_b = true_profile[epoch, 10:13].T                      # gyroscope reading (error free)\n\n            # 24. Simulate IMU errors\n            meas_f_ib_b = true_f_ib_b + true_profile[epoch, 19:22].T            # accelerometer reading\n            meas_omega_ib_b = true_omega_ib_b + true_profile[epoch, 13:16].T    # gyroscope reading\n\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        # 25. Correct IMU errors\n        meas_f_ib_b = meas_f_ib_b - est_imu_bias[0:3, 0]\n        meas_omega_ib_b = meas_omega_ib_b - est_imu_bias[3:6, 0]\n\n        # 26. Update estimated navigation solution\n        [est_r_eb_e, est_v_eb_e, est_ctm_b_e] = nav_eqs_ecef(tau_i, old_est_r_eb_e, old_est_v_eb_e, old_est_ctm_b_e,\n                                                             meas_f_ib_b, meas_omega_ib_b)\n\n        # 27. Determine whether to update GNSS simulation and run Kalman filter\n        if (t - t_last_gnss) >= gnss_config.epoch_interval:\n\n            gnss_epoch += 1             # update epoch (time) index\n            tau_s = t - t_last_gnss     # KF time interval\n            t_last_gnss = t             # update the last epoch\n\n            # Conditioning the GNSS simulation by the \"simtype\"\n            if simtype == 'simulation':\n\n                # 28. Determine satellite positions and velocities\n                [sat_r_es_e, sat_v_es_e] = sat_pv_sim(t, gnss_config)\n\n                # 29. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = gnss_meas_gen_sim(t, sat_r_es_e, sat_v_es_e, true_r_eb_e, true_lat_b,\n                                                                   true_lon_b, true_v_eb_e, gnss_biases, gnss_config)\n\n            elif simtype == 'play back':\n\n                # 28.1 Determine satellite positions and velocities in ECEF\n                [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, t, tol)\n\n                # 28.2 Initialize the GNSS biases\n                gnss_biases = init_gnss_bias_ephem(t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                                   true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n                # 29. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = \\\n                    gnss_meas_gen_ephem(t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                        old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n            # Array to hold GNSS generated measurements for output\n            out_gnss_time.append(t)\n            out_gnss_gen_new = np.nan * np.ones((gnss_epoch, 16, 9))\n            out_gnss_gen_new[0:gnss_epoch - 1, :, :] = out_gnss_gen\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 0] = prn\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 1:9] = gnss_meas\n            out_gnss_gen = out_gnss_gen_new\n\n            # 30. Run Integration Kalman filter\n            [est_ctm_b_e, est_v_eb_e, est_r_eb_e, est_imu_bias, est_clock, p_matrix] = \\\n                tc_ekf_epoch(gnss_meas, no_gnss_meas, tau_s, est_ctm_b_e, est_v_eb_e, est_r_eb_e, est_imu_bias,\n                             est_clock, p_matrix, meas_f_ib_b, est_lat_b, tc_kf_config)\n\n            # 31. Generate IMU bias and clock output records recursively\n            # 31.1 IMU Bias\n            out_imu_bias_est_new = np.nan * np.matrix(np.ones((gnss_epoch, 7)))\n            out_imu_bias_est_new[0:gnss_epoch - 1, 0] = out_imu_bias_est[0:gnss_epoch - 1, 0]\n            out_imu_bias_est_new[gnss_epoch - 1, 0] = t\n            out_imu_bias_est_new[0:gnss_epoch - 1, 1:7] = out_imu_bias_est[0:gnss_epoch - 1, 1:7]\n            out_imu_bias_est_new[gnss_epoch - 1, 1:7] = est_imu_bias.T\n            out_imu_bias_est = out_imu_bias_est_new\n\n            # 31.2 Clock Bias\n            out_clock_new = np.nan * np.matrix(np.ones((gnss_epoch, 3)))\n            out_clock_new[0:gnss_epoch - 1, 0] = output_clock[0:gnss_epoch - 1, 0]\n            out_clock_new[gnss_epoch - 1, 0] = t\n            out_clock_new[0:gnss_epoch - 1, 1:3] = output_clock[0:gnss_epoch - 1, 1:3]\n            out_clock_new[gnss_epoch - 1, 1:3] = est_clock\n            output_clock = out_clock_new\n\n            # 32. Generate KF uncertainty output record recursively\n            out_kf_sd_new = np.nan * np.matrix(np.ones((gnss_epoch, 18)))\n            out_kf_sd_new[0:gnss_epoch - 1, 0] = output_kf_sd[0:gnss_epoch - 1, 0]\n            out_kf_sd_new[gnss_epoch - 1, 0] = t\n            out_kf_sd_new[0:gnss_epoch - 1, 1:18] = output_kf_sd[0:gnss_epoch - 1, 1:18]\n            eig_value = lina.eigvals(p_matrix)\n            for i in xrange(0, 17):\n                out_kf_sd_new[gnss_epoch - 1, i + 1] = np.sqrt(abs(eig_value[i]))\n            # End of For out_kf_sd update\n\n            # Convert the standard deviations to LLA\n            [r_temp, v_temp, euler_temp] = \\\n                ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, out_kf_sd_new[gnss_epoch - 1, 1:10])\n\n            out_kf_sd_new[gnss_epoch - 1, 1:4] = r_temp.T\n            out_kf_sd_new[gnss_epoch - 1, 4:7] = v_temp.T\n            out_kf_sd_new[gnss_epoch - 1, 7:10] = euler_temp.T\n\n            output_kf_sd = out_kf_sd_new\n\n        # End of If on checking for GNSS update\n\n        # 33. Convert navigation solution to NED\n        [est_lat_b, est_lon_b, est_alt_b, est_v_eb_n, est_ctm_b_n] = ecef_to_lla(est_r_eb_e, est_v_eb_e, est_ctm_b_e)\n\n        # 34. Generate output profile record\n        est_profile[epoch, 0] = t\n        est_profile[epoch, 1] = est_lat_b\n        est_profile[epoch, 2] = est_lon_b\n        est_profile[epoch, 3] = est_alt_b\n        est_profile[epoch, 4:7] = est_v_eb_n.T\n        est_profile[epoch, 7:10] = ctm_to_euler(est_ctm_b_n.T).T\n\n        # 35. Determine Errors\n        [delta_r_eb_n, delta_v_eb_n, eul_err_nb_n] = cal_err_ned(est_lat_b, est_lon_b, est_alt_b, est_v_eb_n,\n                                                                 est_ctm_b_n, true_lat_b, true_lon_b, true_alt_b,\n                                                                 true_v_eb_n, true_ctm_b_n)\n        # 36. Generate Error Records\n        est_errors[epoch, 0] = t\n        est_errors[epoch, 1:4] = delta_r_eb_n.T\n        est_errors[epoch, 4:7] = delta_v_eb_n.T\n        est_errors[epoch, 7:10] = eul_err_nb_n.T\n\n        # 37. Reset old values\n        old_t = t\n        old_true_r_eb_e = true_r_eb_e\n        old_true_v_eb_e = true_v_eb_e\n        old_true_ctm_b_e = true_ctm_b_e\n        old_est_r_eb_e = est_r_eb_e\n        old_est_v_eb_e = est_v_eb_e\n        old_est_ctm_b_e = est_ctm_b_e\n\n        # 38. Updating Progress Bar\n        progressbar(epoch \/ float(no_t_steps))\n\n    # End of For Main Loop\n\n    print '\\n NavSim Completed!'\n\n    return est_profile, est_errors, output_kf_sd, out_imu_gen, out_imu_bias_est, output_clock, out_gnss_gen, \\\n           out_gnss_time\n\n# End of Main Tightly Coupled INS\/GNSS Fusion\n\n\n'''\n    ---------------------------------------------\n    17. Main Function to Run the Dual INS\/GPS EKF\n    ---------------------------------------------\n'''\n\n\ndef dual_ins_gps_ekf_fusion(simtype, true_profile, no_t_steps, eul_err_nb_n, imu_config, gnss_config, lc_kf_config,\n                            tc_kf_config, DyOM, doy, fin_nav, gps_tow):\n\n    print 'Starting Dual EKF Fusion...'\n\n    # 1. Initialize true navigation solution\n    old_t = true_profile[0, 0]                          # starting epoch (s)\n    true_lat_b = true_profile[0, 1]                     # initial true latitude (rad)\n    true_lon_b = true_profile[0, 2]                     # initial true longitude (rad)\n    true_alt_b = true_profile[0, 3]                     # initial true altitude (m)\n    true_v_eb_n = true_profile[0, 4:7].T                # initial true velocity vector (m\/s)\n    true_eul_nb = true_profile[0, 7:10].T               # initial true attitude (rad)\n    true_ctm_b_n = euler_to_ctm(true_eul_nb).T          # coordinate transfer matrix from body frame to NED frame\n\n    # 2. Convert all the above parameters to ECEF frame\n    [old_true_r_eb_e, old_true_v_eb_e, old_true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b,\n                                                                       true_v_eb_n, true_ctm_b_n)\n    # Conditioning the GNSS simulation by the \"simtype\"\n    if simtype == 'simulation':\n\n        # 3. Determine satellite positions and velocities\n        [sat_r_es_e, sat_v_es_e] = sat_pv_sim(old_t, gnss_config)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_sim(sat_r_es_e, old_true_r_eb_e, true_lat_b, true_lon_b, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = \\\n            gnss_meas_gen_sim(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b, old_true_v_eb_e,\n                              gnss_biases, gnss_config)\n\n    elif simtype == 'play back':\n\n        # 3.1 Process the Ephemeris only in the \"play back\" Mode\n        [iono_alpha, iono_beta, alma_t_para, sv_clock, navigation, ephemeris] = ephem_processing(finpath, fin_nav,\n                                                                                                 gps_tow, DyOM)\n\n        # 3.2 Save the Ephemris Data\n        navigation_fname = foutpath + 'navigation_message.txt'\n        np.savetxt(navigation_fname, navigation)\n        ephem_fname = foutpath + 'ephemeris.txt'\n        np.savetxt(ephem_fname, ephemeris)\n\n        # 3.3 Determine satellite positions and velocities in ECEF\n        [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, old_t, tol)\n\n        # 4. Initialize the GNSS biases\n        gnss_biases = init_gnss_bias_ephem(old_t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                           true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n        # 5. Generate GNSS measurements\n        [gnss_meas, no_gnss_meas, prn] = \\\n            gnss_meas_gen_ephem(old_t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n    # Array to hold GNSS generated measurements for output\n    out_gnss_time = [old_t]\n    out_gnss_gen = np.nan * np.ones((1, 16, 9))\n    out_gnss_gen[0, 0:len(prn), 0] = prn\n    out_gnss_gen[0, 0:len(prn), 1:9] = gnss_meas\n\n    # 6. Determine Least-Square GNSS position solutions\n    [gnss_r_eb_e, gnss_v_eb_e, est_clock] = gnss_ls_pos_vel(gnss_meas, no_gnss_meas, gnss_config.init_est_r_ea_e,\n                                                            gnss_config.init_est_v_ea_e)\n    old_est_r_eb_e = gnss_r_eb_e\n    old_est_v_eb_e = gnss_v_eb_e\n\n    # 6.1 Initialize loosely coupled pos, vel estimations\n    lc_old_est_r_eb_e = gnss_r_eb_e\n    lc_old_est_v_eb_e = gnss_v_eb_e\n\n    # 6.2 Initialize tightly coupled pos, vel estimations\n    tc_old_est_r_eb_e = gnss_r_eb_e\n    tc_old_est_v_eb_e = gnss_v_eb_e\n    tc_est_clock = est_clock\n\n    # 7. Convert Position and Velocity from ECEF to NED\n    [old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n] = pv_ecef_to_lla(old_est_r_eb_e, old_est_v_eb_e)\n\n    # 7.1 Initialize loosely coupled latitude estimation\n    lc_est_lat_b = old_est_lat_b\n\n    # 7.2 Initialize tightly coupled latitude estimation\n    tc_est_lat_b = old_est_lat_b\n\n    # 8. Initialize estimated attitude solution\n    old_est_ctm_b_n = init_ned_att(true_ctm_b_n, eul_err_nb_n)\n\n    # 9. Compute the CTM from NED to ECEF\n    [temp1, temp2, old_est_ctm_b_e] = lla_to_ecef(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n,\n                                                  old_est_ctm_b_n)\n\n    # 9.1 Initialize loosely coupled CTM from NED to ECEF\n    lc_old_est_ctm_b_e = old_est_ctm_b_e\n\n    # 9.2 Initialize tightly coupled CTM from NED to ECEF\n    tc_old_est_ctm_b_e = old_est_ctm_b_e\n\n    # 10. Initialize loosely and tightly coupled output profiles\n    lc_est_profile = np.nan * np.ones((no_t_steps, 10))\n    tc_est_profile = np.nan * np.ones((no_t_steps, 10))\n\n    # 11. Generate loosely coupled output profile\n    lc_est_profile[0, 0] = old_t\n    lc_est_profile[0, 1] = old_est_lat_b\n    lc_est_profile[0, 2] = old_est_lon_b\n    lc_est_profile[0, 3] = old_est_alt_b\n    lc_est_profile[0, 4:7] = old_est_v_eb_n.T\n    lc_est_profile[0, 7:10] = ctm_to_euler(old_est_ctm_b_n.T).T\n\n    # 12. Generate tightly coupled output profile\n    tc_est_profile[0, 0] = old_t\n    tc_est_profile[0, 1] = old_est_lat_b\n    tc_est_profile[0, 2] = old_est_lon_b\n    tc_est_profile[0, 3] = old_est_alt_b\n    tc_est_profile[0, 4:7] = old_est_v_eb_n.T\n    tc_est_profile[0, 7:10] = ctm_to_euler(old_est_ctm_b_n.T).T\n\n    # 13. Determine errors and generate output record\n    [delta_r_eb_n, delta_v_eb_n, eul_err_nb_n] = \\\n        cal_err_ned(old_est_lat_b, old_est_lon_b, old_est_alt_b, old_est_v_eb_n, old_est_ctm_b_n, true_lat_b,\n                    true_lon_b, true_alt_b, true_v_eb_n, true_ctm_b_n)\n\n    # 14. Initialize loosely and tightly coupled error profiles\n    lc_est_errors = np.nan * np.ones((no_t_steps, 10))\n    tc_est_errors = np.nan * np.ones((no_t_steps, 10))\n\n    # 15. Loosely coupled errors\n    lc_est_errors[0, 0] = old_t\n    lc_est_errors[0, 1:4] = delta_r_eb_n.T\n    lc_est_errors[0, 4:7] = delta_v_eb_n.T\n    lc_est_errors[0, 7:10] = eul_err_nb_n.T\n\n    # 16. Tightly coupled errors\n    tc_est_errors[0, 0] = old_t\n    tc_est_errors[0, 1:4] = delta_r_eb_n.T\n    tc_est_errors[0, 4:7] = delta_v_eb_n.T\n    tc_est_errors[0, 7:10] = eul_err_nb_n.T\n\n    # 17. Dual coupled Kalman filter\n    [lc_p_matrix, tc_p_matrix] = init_dual_p_matrix(lc_kf_config, tc_kf_config)\n\n    # 18. Initialize IMU bias states\n    lc_est_imu_bias = np.matrix(np.zeros((6, 1)))\n    tc_est_imu_bias = np.matrix(np.zeros((6, 1)))\n\n    # 19. Initialize IMU quantization residuals\n    quant_resid = np.matrix(np.zeros((6, 1)))\n\n    # 20. Generate IMU bias and clock output records\n    out_imu_gen = np.nan * np.matrix(np.ones((no_t_steps, 7)))\n    out_imu_gen[0, 0] = old_t\n    out_imu_gen[0, 1:7] = 0.0\n    # 20.1 Loosely coupled\n    lc_out_imu_bias_est = np.nan * np.matrix(np.ones((1, 7)))\n    lc_out_imu_bias_est[0, 0] = old_t\n    lc_out_imu_bias_est[0, 1:7] = lc_est_imu_bias.T\n    lc_output_clock = np.nan * np.matrix(np.ones((1, 3)))\n    lc_output_clock[0, 0] = old_t\n    lc_output_clock[0, 1:3] = est_clock\n\n    # 20.2 Tightly coupled\n    tc_out_imu_bias_est = np.nan * np.matrix(np.ones((1, 7)))\n    tc_out_imu_bias_est[0, 0] = old_t\n    tc_out_imu_bias_est[0, 1:7] = tc_est_imu_bias.T\n    tc_output_clock = np.nan * np.matrix(np.ones((1, 3)))\n    tc_output_clock[0, 0] = old_t\n    tc_output_clock[0, 1:3] = est_clock\n\n    # 21. Generate KF uncertainty record\n    # 21.1 Loosely coupled EKF\n    lc_output_kf_sd = np.nan * np.matrix(np.ones((1, 16)))\n    lc_output_kf_sd[0, 0] = old_t\n    lc_eig_value = lina.eigvals(lc_p_matrix)\n    for i in xrange(0, 15):\n        lc_output_kf_sd[0, i + 1] = np.sqrt(abs(lc_eig_value[i]))\n    # End of For Loop\n\n    # Convert the standard deviations to LLA\n    [lc_r_temp, lc_v_temp, lc_eul_tmp] = ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, lc_output_kf_sd[0, 1:10])\n\n    lc_output_kf_sd[0, 1:4] = lc_r_temp.T\n    lc_output_kf_sd[0, 4:7] = lc_v_temp.T\n    lc_output_kf_sd[0, 7:10] = lc_eul_tmp.T\n\n    # 21.2 Tightly coupled EKF\n    tc_output_kf_sd = np.nan * np.matrix(np.ones((1, 18)))\n    tc_output_kf_sd[0, 0] = old_t\n    tc_eig_value = lina.eigvals(tc_p_matrix)\n    for i in xrange(0, 17):\n        tc_output_kf_sd[0, i + 1] = np.sqrt(abs(tc_eig_value[i]))\n    # End of For Loop\n\n    # Convert the standard deviations to LLA\n    [tc_r_temp, tc_v_temp, tc_eul_tmp] = ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, tc_output_kf_sd[0, 1:10])\n\n    tc_output_kf_sd[0, 1:4] = tc_r_temp.T\n    tc_output_kf_sd[0, 4:7] = tc_v_temp.T\n    tc_output_kf_sd[0, 7:10] = tc_eul_tmp.T\n\n    # 22. Initialize GNSS model timing\n    t_last_gnss = old_t\n    gnss_epoch = 1\n\n    # 23. Initialize Progress Bar\n    print 'Simulation is in progress. Please wait!'\n\n    # ******************************************************************************************************************\n    #                                                   MAIN LOOP\n    # ******************************************************************************************************************\n\n    for epoch in xrange(1, no_t_steps):\n\n        # 24. Input data from motion profile\n        t = true_profile[epoch, 0]                      # current epoch (s)\n        true_lat_b = true_profile[epoch, 1]             # current true latitude (rad)\n        true_lon_b = true_profile[epoch, 2]             # current true longitude (rad)\n        true_alt_b = true_profile[epoch, 3]             # current true altitude (m)\n        true_v_eb_n = true_profile[epoch, 4:7].T        # current true velocity vector (m\/s)\n        true_eul_nb = true_profile[epoch, 7:10].T\n        true_ctm_b_n = euler_to_ctm(true_eul_nb).T\n        [true_r_eb_e, true_v_eb_e, true_ctm_b_e] = lla_to_ecef(true_lat_b, true_lon_b, true_alt_b, true_v_eb_n,\n                                                               true_ctm_b_n)\n        # 25. Calculate the time interval\n        tau_i = t - old_t\n\n        # Conditioning the IMU simulation by the \"simtype\"\n        if simtype == 'simulation':\n\n            # 26. Calculate specific force and angular rate\n            [true_f_ib_b, true_omega_ib_b] = kinematics_ecef(tau_i, true_ctm_b_e, old_true_ctm_b_e, true_v_eb_e,\n                                                             old_true_v_eb_e, old_true_r_eb_e)\n\n            # 27. Simulate IMU errors\n            [meas_f_ib_b, meas_omega_ib_b, quant_resid] = imu_model(tau_i, true_f_ib_b, true_omega_ib_b, imu_config,\n                                                                    quant_resid)\n\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        elif simtype == 'play back':\n\n            # 26. Calculate specific force and angular rate\n            true_f_ib_b = true_profile[epoch, 16:19].T          # accelerometer reading (error free)\n            true_omega_ib_b = true_profile[epoch, 10:13].T      # gyroscope reading (error free)\n\n            # 27. Simulate IMU errors\n            meas_f_ib_b = true_f_ib_b + true_profile[epoch, 19:22].T            # accelerometer reading\n            meas_omega_ib_b = true_omega_ib_b + true_profile[epoch, 13:16].T    # gyroscope reading\n\n            out_imu_gen[epoch, 0] = t\n            out_imu_gen[epoch, 1:4] = meas_f_ib_b.T\n            out_imu_gen[epoch, 4:7] = meas_omega_ib_b.T\n\n        # 28. Correct IMU errors\n        # 28.1 Loosely coupled IMU error corrections\n        lc_meas_f_ib_b = meas_f_ib_b - lc_est_imu_bias[0:3, 0]\n        lc_meas_omega_ib_b = meas_omega_ib_b - lc_est_imu_bias[3:6, 0]\n\n        # 28.2 Tightly coupled IMU error corrections\n        tc_meas_f_ib_b = meas_f_ib_b - tc_est_imu_bias[0:3, 0]\n        tc_meas_omega_ib_b = meas_omega_ib_b - tc_est_imu_bias[3:6, 0]\n\n        # 29. Update estimated navigation solution\n        # 29.1 Loosely coupled estimated navigation solution update\n        [lc_est_r_eb_e, lc_est_v_eb_e, lc_est_ctm_b_e] = nav_eqs_ecef(\n            tau_i, lc_old_est_r_eb_e, lc_old_est_v_eb_e, lc_old_est_ctm_b_e, lc_meas_f_ib_b, lc_meas_omega_ib_b)\n\n        # 29.2 Tightly coupled estimated navigation solution update\n        [tc_est_r_eb_e, tc_est_v_eb_e, tc_est_ctm_b_e] = nav_eqs_ecef(\n            tau_i, tc_old_est_r_eb_e, tc_old_est_v_eb_e, tc_old_est_ctm_b_e, tc_meas_f_ib_b, tc_meas_omega_ib_b)\n\n        # 30. Determine whether to update GNSS simulation and run Kalman filter\n        if (t - t_last_gnss) >= gnss_config.epoch_interval:\n\n            gnss_epoch += 1             # update epoch (time) index\n            tau_s = t - t_last_gnss     # KF time interval\n            t_last_gnss = t             # update the last epoch\n\n            # Conditioning the GNSS simulation by the \"simtype\"\n            if simtype == 'simulation':\n\n                # 31. Determine satellite positions and velocities in ECEF\n                [sat_r_es_e, sat_v_es_e] = sat_pv_sim(t, gnss_config)\n\n                # 32. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = gnss_meas_gen_sim(t, sat_r_es_e, sat_v_es_e, true_r_eb_e, true_lat_b,\n                                                                   true_lon_b, true_v_eb_e, gnss_biases, gnss_config)\n\n            elif simtype == 'play back':\n\n                # 31.1 Determine satellite positions and velocities in ECEF\n                [sat_r_es_e, sat_v_es_e] = sat_pv_ephem(ephemeris, gnss_config, t, tol)\n\n                # 31.2 Initialize the GNSS biases\n                gnss_biases = init_gnss_bias_ephem(t, doy, ephemeris, iono_alpha, iono_beta, true_lat_b, true_lon_b,\n                                                   true_alt_b, sat_r_es_e, old_true_r_eb_e, gnss_config)\n\n                # 32. Generate GNSS measurements\n                [gnss_meas, no_gnss_meas, prn] = \\\n                    gnss_meas_gen_ephem(t, sat_r_es_e, sat_v_es_e, old_true_r_eb_e, true_lat_b, true_lon_b,\n                                        old_true_v_eb_e, gnss_biases, gnss_config, sv_clock, ephemeris, alma_t_para)\n\n            # Array to hold GNSS generated measurements for output\n            out_gnss_time.append(t)\n            out_gnss_gen_new = np.nan * np.ones((gnss_epoch, 16, 9))\n            out_gnss_gen_new[0:gnss_epoch - 1, :, :] = out_gnss_gen\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 0] = prn\n            out_gnss_gen_new[gnss_epoch - 1, 0:len(prn), 1:9] = gnss_meas\n            out_gnss_gen = out_gnss_gen_new\n\n            # 33. Determine Least-Square GNSS position solutions for loosely coupling\n            [gnss_r_eb_e, gnss_v_eb_e, lc_est_clock] = gnss_ls_pos_vel(gnss_meas, no_gnss_meas, gnss_r_eb_e,\n                                                                       gnss_v_eb_e)\n\n            # 34. Run Loosely Coupled Integration Kalman filter\n            [lc_est_ctm_b_e, lc_est_v_eb_e, lc_est_r_eb_e, lc_est_imu_bias, lc_p_matrix] = \\\n                lc_ekf_epoch(gnss_r_eb_e, gnss_v_eb_e, tau_s, lc_est_ctm_b_e, lc_est_v_eb_e, lc_est_r_eb_e,\n                             lc_est_imu_bias, lc_p_matrix, lc_meas_f_ib_b, lc_est_lat_b, lc_kf_config)\n\n            # 35. Run Tightly Coupled Integration Kalman filter\n            [tc_est_ctm_b_e, tc_est_v_eb_e, tc_est_r_eb_e, tc_est_imu_bias, tc_est_clock, tc_p_matrix] = \\\n                tc_ekf_epoch(gnss_meas, no_gnss_meas, tau_s, tc_est_ctm_b_e, tc_est_v_eb_e, tc_est_r_eb_e,\n                             tc_est_imu_bias, tc_est_clock, tc_p_matrix, tc_meas_f_ib_b, tc_est_lat_b, tc_kf_config)\n\n            # 36. Generate IMU bias and clock output records recursively\n            # 36.1 Loosely coupled IMU bias\n            lc_out_imu_bias_est_new = np.nan * np.matrix(np.ones((gnss_epoch, 7)))\n            lc_out_imu_bias_est_new[0:gnss_epoch - 1, 0] = lc_out_imu_bias_est[0:gnss_epoch - 1, 0]\n            lc_out_imu_bias_est_new[gnss_epoch - 1, 0] = t\n            lc_out_imu_bias_est_new[0:gnss_epoch - 1, 1:7] = lc_out_imu_bias_est[0:gnss_epoch - 1, 1:7]\n            lc_out_imu_bias_est_new[gnss_epoch - 1, 1:7] = lc_est_imu_bias.T\n\n            lc_out_imu_bias_est = lc_out_imu_bias_est_new\n\n            # 36.2 Tightly coupled IMU bias\n            tc_out_imu_bias_est_new = np.nan * np.matrix(np.ones((gnss_epoch, 7)))\n            tc_out_imu_bias_est_new[0:gnss_epoch - 1, 0] = tc_out_imu_bias_est[0:gnss_epoch - 1, 0]\n            tc_out_imu_bias_est_new[gnss_epoch - 1, 0] = t\n            tc_out_imu_bias_est_new[0:gnss_epoch - 1, 1:7] = tc_out_imu_bias_est[0:gnss_epoch - 1, 1:7]\n            tc_out_imu_bias_est_new[gnss_epoch - 1, 1:7] = tc_est_imu_bias.T\n\n            tc_out_imu_bias_est = tc_out_imu_bias_est_new\n\n            # 36.3 Loosely coupled clock bias\n            lc_out_clock_new = np.nan * np.matrix(np.ones((gnss_epoch, 3)))\n            lc_out_clock_new[0:gnss_epoch - 1, 0] = lc_output_clock[0:gnss_epoch - 1, 0]\n            lc_out_clock_new[gnss_epoch - 1, 0] = t\n            lc_out_clock_new[0:gnss_epoch - 1, 1:3] = lc_output_clock[0:gnss_epoch - 1, 1:3]\n            lc_out_clock_new[gnss_epoch - 1, 1:3] = lc_est_clock\n\n            lc_output_clock = lc_out_clock_new\n\n            # 36.4 Tightly coupled clock bias\n            tc_out_clock_new = np.nan * np.matrix(np.ones((gnss_epoch, 3)))\n            tc_out_clock_new[0:gnss_epoch - 1, 0] = tc_output_clock[0:gnss_epoch - 1, 0]\n            tc_out_clock_new[gnss_epoch - 1, 0] = t\n            tc_out_clock_new[0:gnss_epoch - 1, 1:3] = tc_output_clock[0:gnss_epoch - 1, 1:3]\n            tc_out_clock_new[gnss_epoch - 1, 1:3] = tc_est_clock\n\n            tc_output_clock = tc_out_clock_new\n\n            # 37. Generate EKF uncertainty output record recursively\n            # 37.1 Loosely coupled EKF standard deviation\n            lc_out_kf_sd_new = np.nan * np.matrix(np.ones((gnss_epoch, 16)))\n            lc_out_kf_sd_new[0:gnss_epoch - 1, 0] = lc_output_kf_sd[0:gnss_epoch - 1, 0]\n            lc_out_kf_sd_new[gnss_epoch - 1, 0] = t\n            lc_out_kf_sd_new[0:gnss_epoch - 1, 1:16] = lc_output_kf_sd[0:gnss_epoch - 1, 1:16]\n            lc_eig_value = lina.eigvals(lc_p_matrix)\n            for i in xrange(0, 15):\n                lc_out_kf_sd_new[gnss_epoch - 1, i + 1] = np.sqrt(abs(lc_eig_value[i]))\n            # End of For out_kf_sd update\n\n            # Convert the standard deviations to LLA\n            [lc_r_temp, lc_v_temp, lc_eul_tmp] = \\\n                ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, lc_out_kf_sd_new[gnss_epoch - 1, 1:10])\n\n            lc_out_kf_sd_new[gnss_epoch - 1, 1:4] = lc_r_temp.T\n            lc_out_kf_sd_new[gnss_epoch - 1, 4:7] = lc_v_temp.T\n            lc_out_kf_sd_new[gnss_epoch - 1, 7:10] = lc_eul_tmp.T\n\n            lc_output_kf_sd = lc_out_kf_sd_new\n\n            # 37.2 Tightly coupled EKF standard deviation\n            tc_out_kf_sd_new = np.nan * np.matrix(np.ones((gnss_epoch, 18)))\n            tc_out_kf_sd_new[0:gnss_epoch - 1, 0] = tc_output_kf_sd[0:gnss_epoch - 1, 0]\n            tc_out_kf_sd_new[gnss_epoch - 1, 0] = t\n            tc_out_kf_sd_new[0:gnss_epoch - 1, 1:18] = tc_output_kf_sd[0:gnss_epoch - 1, 1:18]\n            tc_eig_value = lina.eigvals(tc_p_matrix)\n            for i in xrange(0, 17):\n                tc_out_kf_sd_new[gnss_epoch - 1, i + 1] = np.sqrt(abs(tc_eig_value[i]))\n            # End of For out_kf_sd update\n\n            # Convert the standard deviations to LLA\n            [tc_r_temp, tc_v_temp, tc_eul_tmp] = \\\n                ekfsd_ecef_to_lla(true_lat_b, true_lon_b, true_alt_b, tc_out_kf_sd_new[gnss_epoch - 1, 1:10])\n\n            tc_out_kf_sd_new[gnss_epoch - 1, 1:4] = tc_r_temp.T\n            tc_out_kf_sd_new[gnss_epoch - 1, 4:7] = tc_v_temp.T\n            tc_out_kf_sd_new[gnss_epoch - 1, 7:10] = tc_eul_tmp.T\n\n            tc_output_kf_sd = tc_out_kf_sd_new\n\n        # End of \"If\" on checking for GNSS update\n\n        # 38. Convert navigation solution to NED\n        # 38.1 Loosely coupled\n        [lc_est_lat_b, lc_est_lon_b, lc_est_alt_b, lc_est_v_eb_n, lc_est_ctm_b_n] = \\\n            ecef_to_lla(lc_est_r_eb_e, lc_est_v_eb_e, lc_est_ctm_b_e)\n\n        # 38.2 Tightly coupled\n        [tc_est_lat_b, tc_est_lon_b, tc_est_alt_b, tc_est_v_eb_n, tc_est_ctm_b_n] = \\\n            ecef_to_lla(tc_est_r_eb_e, tc_est_v_eb_e, tc_est_ctm_b_e)\n\n        # 39. Generate output profile record\n        # 39.1 Loosely coupled EKF outputs\n        lc_est_profile[epoch, 0] = t\n        lc_est_profile[epoch, 1] = lc_est_lat_b\n        lc_est_profile[epoch, 2] = lc_est_lon_b\n        lc_est_profile[epoch, 3] = lc_est_alt_b\n        lc_est_profile[epoch, 4:7] = lc_est_v_eb_n.T\n        lc_est_profile[epoch, 7:10] = ctm_to_euler(lc_est_ctm_b_n.T).T\n\n        # 39.2 Tightly coupled EKF outputs\n        tc_est_profile[epoch, 0] = t\n        tc_est_profile[epoch, 1] = tc_est_lat_b\n        tc_est_profile[epoch, 2] = tc_est_lon_b\n        tc_est_profile[epoch, 3] = tc_est_alt_b\n        tc_est_profile[epoch, 4:7] = tc_est_v_eb_n.T\n        tc_est_profile[epoch, 7:10] = ctm_to_euler(tc_est_ctm_b_n.T).T\n\n        # 40. Determine Errors\n        # 40.1 Loosely coupled\n        [lc_delta_r_eb_n, lc_delta_v_eb_n, lc_eul_err_nb_n] = \\\n            cal_err_ned(lc_est_lat_b, lc_est_lon_b, lc_est_alt_b, lc_est_v_eb_n, lc_est_ctm_b_n, true_lat_b,\n                        true_lon_b, true_alt_b, true_v_eb_n, true_ctm_b_n)\n\n        # 40.2 Tightly coupled\n        [tc_delta_r_eb_n, tc_delta_v_eb_n, tc_eul_err_nb_n] = \\\n            cal_err_ned(tc_est_lat_b, tc_est_lon_b, tc_est_alt_b, tc_est_v_eb_n, tc_est_ctm_b_n, true_lat_b,\n                        true_lon_b, true_alt_b, true_v_eb_n, true_ctm_b_n)\n\n        # 41. Generate Error Records\n        # 41.1 Loosely coupled error records\n        lc_est_errors[epoch, 0] = t\n        lc_est_errors[epoch, 1:4] = lc_delta_r_eb_n.T\n        lc_est_errors[epoch, 4:7] = lc_delta_v_eb_n.T\n        lc_est_errors[epoch, 7:10] = lc_eul_err_nb_n.T\n\n        # 41.2 Tightly coupled error records\n        tc_est_errors[epoch, 0] = t\n        tc_est_errors[epoch, 1:4] = tc_delta_r_eb_n.T\n        tc_est_errors[epoch, 4:7] = tc_delta_v_eb_n.T\n        tc_est_errors[epoch, 7:10] = tc_eul_err_nb_n.T\n\n        # 42. Reset old values\n        # 42.1 Time and True Pos, Vel, Att\n        old_t = t\n        old_true_r_eb_e = true_r_eb_e\n        old_true_v_eb_e = true_v_eb_e\n        old_true_ctm_b_e = true_ctm_b_e\n\n        # 42.2 Loosely coupled Pos, Vel, Att\n        lc_old_est_r_eb_e = lc_est_r_eb_e\n        lc_old_est_v_eb_e = lc_est_v_eb_e\n        lc_old_est_ctm_b_e = lc_est_ctm_b_e\n\n        # 42.3 Tightly coupled Pos, Vel, Att\n        tc_old_est_r_eb_e = tc_est_r_eb_e\n        tc_old_est_v_eb_e = tc_est_v_eb_e\n        tc_old_est_ctm_b_e = tc_est_ctm_b_e\n\n        # 43. Updating Progress Bar\n        progressbar(epoch \/ float(no_t_steps))\n\n    # End of For Main Loop\n\n    print '\\n NavSim Completed!'\n\n    return lc_est_profile, lc_est_errors, lc_output_kf_sd, tc_est_profile, tc_est_errors, tc_output_kf_sd, out_imu_gen,\\\n           lc_out_imu_bias_est, tc_out_imu_bias_est, lc_output_clock, tc_output_clock, out_gnss_gen, out_gnss_time\n\n# End of Main Dual INS\/GNSS Fusion\n\n\n'''\n========================================================================================================================\n                                        INS\/GNSS FUSION SIMULATION DRIVER\n========================================================================================================================\n'''\n\n\ndef nav_sim_driver(fin_data, fin_nav, DyOM, doy, imugrade, constellation, frequency, simtype, simmode,\n                   tightness):\n\n    # 1.1 Process the Flight Data for All Modes\n    [in_profile, epochs] = data_processing(finpath, fin_data)\n    gps_tow = in_profile[:, 29]\n    [DyOW, HrOD, MnOH, ScOM] = tow_to_utc(gps_tow[0])\n    print \"Initial TOW in UTC: %d Days %d Hours %d Minutes %.2f Seconds\" % (DyOW, HrOD, MnOH, ScOM)\n    [deltaMnOW, rem_deltaTOW] = flight_duration(gps_tow[0], gps_tow[-1])\n    print \"Flight Duration: %d Minutes %.2f Seconds\" % (deltaMnOW, rem_deltaTOW)\n\n    # 1.2 Save the Flight Data to Simout Directory\n    words = fin_data.split('.')\n    flightdata_fname = foutpath + words[0] + '_in_profile.txt'\n    np.savetxt(flightdata_fname, in_profile)\n\n    # 2. Initialize the Navigation Simulation (NavSim) System\n    print 'Initializing NavSim...'\n    delta_eul_nb_n = att_init_error(-0.01, 0.008, 0.01, unit='degree')\n    imu_config = imu_configuration(imugrade)\n    gnss_config = gnss_configuration(frequency, constellation, gps_tow)\n    if simmode == 'alone':\n        ekf_config = single_ekf_configuration(imugrade, tightness)\n    elif simmode == 'dual':\n        [lc_ekf_config, tc_ekf_config] = dual_ekf_configuration(imugrade)\n\n    # End of If on initialization\n\n    # 3. Call Main Fusion Function to Start Simulation\n    if simmode == 'alone' and tightness == 'loose':\n        [out_profile, out_errors, out_kf_sd, out_imu_gen, out_imu_bias_est, output_clock, out_gnss_gen,\n         out_gnss_time] = lc_ins_gps_ekf_fusion(simtype, tightness, in_profile, epochs, delta_eul_nb_n, imu_config,\n                                                gnss_config, ekf_config, DyOM, doy, fin_nav, gps_tow)\n\n        # Save simulation outputs to Simout directory\n        outprofile_fname = foutpath + words[0] + '_out_profile_lc.txt'\n        np.savetxt(outprofile_fname, out_profile)\n        outerrors_fname = foutpath + words[0] + '_out_errors_lc.txt'\n        np.savetxt(outerrors_fname, out_errors)\n        outekf_sds_fname = foutpath + words[0] + '_out_EKF_SDs_lc.txt'\n        np.savetxt(outekf_sds_fname, out_kf_sd)\n        outimu_fname = foutpath + words[0] + '_out_IMU_Gen_lc.txt'\n        np.savetxt(outimu_fname, out_imu_gen)\n        outimu_bias_fname = foutpath + words[0] + '_out_IMU_Bias_lc.txt'\n        np.savetxt(outimu_bias_fname, out_imu_bias_est)\n        outlock_bias_fname = foutpath + words[0] + '_out_Rx_Lock_Bias_lc.txt'\n        np.savetxt(outlock_bias_fname, output_clock)\n        outgnss_fname = foutpath + 'gnss_measurements.txt'\n        with file(outgnss_fname, 'w') as outfile:\n            outfile.write('GNSS Measurement array shape: {0}\\n'.format(out_gnss_gen.shape))\n            epoch = 0\n            for gnss_slice in out_gnss_gen:\n                string = 'Epoch (sec): ' + str(out_gnss_time[epoch]) + '\\n'\n                outfile.write(string)\n                np.savetxt(outfile, gnss_slice)\n                epoch += 1\n\n        # Plot Output Data for Graphical Analysis\n        print ' Begin Plotting Results...'\n        plot_single_profile(in_profile, out_profile)\n        plot_single_error(out_errors, out_kf_sd)\n        print 'Finish!'\n        plt.show()\n\n    elif simmode == 'alone' and tightness == 'tight':\n        [out_profile, out_errors, out_kf_sd, out_imu_gen, out_imu_bias_est, output_clock, out_gnss_gen,\n         out_gnss_time] = tc_ins_gps_ekf_fusion(simtype, tightness, in_profile, epochs, delta_eul_nb_n, imu_config,\n                                                gnss_config, ekf_config, DyOM, doy, fin_nav, gps_tow)\n\n        # Save simulation outputs\n        outprofile_fname = foutpath + words[0] + '_out_profile_tc.txt'\n        np.savetxt(outprofile_fname, out_profile)\n        outerrors_fname = foutpath + words[0] + '_out_errors_tc.txt'\n        np.savetxt(outerrors_fname, out_errors)\n        outekf_sds_fname = foutpath + words[0] + '_out_EKF_SDs_tc.txt'\n        np.savetxt(outekf_sds_fname, out_kf_sd)\n        outimu_fname = foutpath + words[0] + '_out_IMU_Gen_tc.txt'\n        np.savetxt(outimu_fname, out_imu_gen)\n        outimu_bias_fname = foutpath + words[0] + '_out_IMU_Bias_tc.txt'\n        np.savetxt(outimu_bias_fname, out_imu_bias_est)\n        outlock_bias_fname = foutpath + words[0] + '_out_Rx_Lock_Bias_tc.txt'\n        np.savetxt(outlock_bias_fname, output_clock)\n        outgnss_fname = foutpath + 'gnss_measurements.txt'\n        with file(outgnss_fname, 'w') as outfile:\n            outfile.write('GNSS Measurement array shape: {0}\\n'.format(out_gnss_gen.shape))\n            epoch = 0\n            for gnss_slice in out_gnss_gen:\n                string = 'Epoch (sec): ' + str(out_gnss_time[epoch]) + '\\n'\n                outfile.write(string)\n                np.savetxt(outfile, gnss_slice)\n                epoch += 1\n\n        # Plot Output Data for Graphical Analysis\n        print ' Begin Plotting Results...'\n        plot_single_profile(in_profile, out_profile)\n        plot_single_error(out_errors, out_kf_sd)\n        print 'Finish!'\n        plt.show()\n\n    elif simmode == 'dual':\n        [lc_out_profile, lc_out_errors, lc_out_kf_sd, tc_out_profile, tc_out_errors, tc_out_kf_sd, out_imu_gen,\n         lc_out_imu_bias_est, tc_out_imu_bias_est, lc_output_clock, tc_output_clock, out_gnss_gen, out_gnss_time] = \\\n            dual_ins_gps_ekf_fusion(simtype, in_profile, epochs, delta_eul_nb_n, imu_config, gnss_config, lc_ekf_config,\n                                    tc_ekf_config, DyOM, doy, fin_nav, gps_tow)\n\n        # Save simulation outputs from LC\n        lc_outprofile_fname = foutpath + words[0] + '_out_profile_lc.txt'\n        np.savetxt(lc_outprofile_fname, lc_out_profile)\n        lc_outerrors_fname = foutpath + words[0] + '_out_errors_lc.txt'\n        np.savetxt(lc_outerrors_fname, lc_out_errors)\n        lc_outekf_sds_fname = foutpath + words[0] + '_out_EKF_SDs_lc.txt'\n        np.savetxt(lc_outekf_sds_fname, lc_out_kf_sd)\n        outimu_fname = foutpath + words[0] + '_out_IMU_Gen.txt'\n        np.savetxt(outimu_fname, out_imu_gen)\n        lc_outimu_bias_fname = foutpath + words[0] + '_out_IMU_Bias_lc.txt'\n        np.savetxt(lc_outimu_bias_fname, lc_out_imu_bias_est)\n        lc_outlock_bias_fname = foutpath + words[0] + '_out_Rx_Lock_Bias_lc.txt'\n        np.savetxt(lc_outlock_bias_fname, lc_output_clock)\n\n        # Save simulation outputs from TC\n        tc_outprofile_fname = foutpath + words[0] + '_out_profile_tc.txt'\n        np.savetxt(tc_outprofile_fname, tc_out_profile)\n        tc_outerrors_fname = foutpath + words[0] + '_out_errors_tc.txt'\n        np.savetxt(tc_outerrors_fname, tc_out_errors)\n        tc_outekf_sds_fname = foutpath + words[0] + '_out_EKF_SDs_tc.txt'\n        np.savetxt(tc_outekf_sds_fname, tc_out_kf_sd)\n        tc_outimu_bias_fname = foutpath + words[0] + '_out_IMU_Bias_tc.txt'\n        np.savetxt(tc_outimu_bias_fname, tc_out_imu_bias_est)\n        tc_outlock_bias_fname = foutpath + words[0] + '_out_Rx_Lock_Bias_tc.txt'\n        np.savetxt(tc_outlock_bias_fname, tc_output_clock)\n        outgnss_fname = foutpath + 'gnss_measurements.txt'\n        with file(outgnss_fname, 'w') as outfile:\n            outfile.write('GNSS Measurement array shape: {0}\\n'.format(out_gnss_gen.shape))\n            epoch = 0\n            for gnss_slice in out_gnss_gen:\n                string = 'Epoch (sec): ' + str(out_gnss_time[epoch]) + '\\n'\n                outfile.write(string)\n                np.savetxt(outfile, gnss_slice)\n                epoch += 1\n\n        # Plot Output Data for Graphical Analysis\n        print ' Begin Plotting Results...'\n        plot_dual_profile(in_profile, lc_out_profile, tc_out_profile)\n        plot_dual_error(lc_out_errors, lc_out_kf_sd, tc_out_errors, tc_out_kf_sd)\n        print 'Finish!'\n        plt.show()\n\n    # End of If on calling main fusion runner\n\n# End of Navigation Simulation Driver\n\n\n# **********************************************************************************************************************\n#                                                  SET UP THE SIMULATION\n# **********************************************************************************************************************\n\n# 1. Select the simulation type\nprint '\\nNavSim Lab has two simulation types:\\n\\n' \\\n      '     Type #1 == \"simulation\": performs the flight by the simulating the virtual GNSS constellation and the ' \\\n      'virtual IMU model based on the flight trajectory, the vehicle dynamics, the vehicle attitude from the '\\\n      'flight data.\\n\\n' \\\n      '     Type #2 == \"play back\": performs the flight by playing back the entire flight profile in which the GNSS ' \\\n      'measurements are calculated using the real ephemeris, the real specific forces and the real angular rates ' \\\n      'from the flight data.\\n'\n\nsim_type = raw_input('Please select the simulation type by entering either \"simulation\" or \"play back\": ')\nwhile sim_type != 'simulation' and sim_type != 'play back':\n    sim_type = raw_input('\\nPlease select the simulation type by entering either \"simulation\" or \"play back\": ')\n\n# 2. Specify the simulation mode\nprint '\\nEach simulation type has two modes:\\n\\n' \\\n      '     Mode #1 == \"stand alone\": performs either the \"loosely coupled\" integration ' \\\n      'or the \"tightly coupled\" integration.\\n\\n' \\\n      '     Mode #2 == \"dual\": performs both the \"loosely coupled\" integration and ' \\\n      'the \"tightly coupled\" integration simultaneously.\\n'\n\nsim_mode = raw_input('Please select the simulation mode by entering either \"alone\" or \"dual\": ')\nwhile sim_mode != 'alone' and sim_mode != 'dual':\n    sim_mode = raw_input('\\nPlease select the simulation mode by entering either \"alone\" or \"dual\": ')\n\n# 3. Specify the tightness\nif sim_mode == 'alone':\n    print '\\nThere are two integration schemes in the \"stand-alone\" mode:\\n\\n' \\\n          '     Scheme #1 == \"Loose\": to loosely integrate the INS and the GNSS solutions.\\n\\n' \\\n          '     Scheme #2 == \"Tight\": to tightly integrate the INS and the GNSS solutions.\\n'\n    scheme = raw_input('Specify your choice by entering either \"loose\" or \"tight\": ')\n    while scheme != 'loose' and scheme != 'tight':\n        scheme = raw_input('\\nSpecify your choice by entering either \"loose\" or \"tight\": ')\nelif sim_mode == 'dual':\n    scheme = 'loose'  # default integration scheme\n\n# 4. Specify the flight data file and the ephemeris file\nif sim_type == 'play back':\n    data_fname = raw_input('Enter the flight data file name (.mat file): ')\n    nav_fname = raw_input('\\nEnter the navigation message file name (.xxn file, include the file extension): ')\n    nav_words = nav_fname.split('.')\n    while len(nav_words) != 2:\n        nav_fname = raw_input('\\nEnter the navigation message file name (.xxn file, include the file extension): ')\n        nav_words = nav_fname.split('.')\nelif sim_type == 'simulation':\n    nav_fname = 'none.12n'\n    data_fname = raw_input('Enter the flight data file name (.mat file): ')\n\n# 5. Specify the date of the flight\ndate = raw_input('\\nPlease enter the date when the flight test was carried out (mm\/dd\/yyyy): ')\nnum_chars = len(date)\nwhile num_chars != 10:\n    date = raw_input('\\nPlease enter the date when the flight test was carried out (mm\/dd\/yyyy): ')\n    num_chars = len(date)\nnumbers = date.split('\/')\nmonth = int(numbers[0])\n# The number of days of the month\nnum_dom = int(numbers[1])\nyear = int(numbers[2])\n# Calculate the number of days of the year\nnum_doy = days_of_year(year, month, num_dom)\n\n# 6. Specify the grade of the IMU\nimu_grade = raw_input('\\nPlease specify the grade of the IMU (\"aviation\", \"consumer\", and \"tactical\"): ')\nwhile imu_grade != 'aviation' and imu_grade != 'consumer' and imu_grade != 'tactical':\n    imu_grade = raw_input('\\nPlease specify the grade of the IMU (\"aviation\", \"consumer\", and \"tactical\"): ')\n\n# 7. Specify the GNSS constellation\nprint '\\nCurrently, NavSim Lab has only the GPS option for GNSS constellation. Please enter \"gps\" at prompt.'\ngnss = raw_input('Please specify the GNSS constellation (\"gps\", \"glonass\", galileo\"): ')\nwhile gnss != 'gps':\n    gnss = raw_input('\\nPlease specify the GNSS constellation as \"gps\": ')\n\n# 8. Specify the integration update rate\nfreq = input('\\nPlease enter the integration rate (GNSS update rate) in Hz: ')\n\n# 9. Specify the random seed\nseed = input('\\nPlease choose your random seed int[0, inf): ')\nwhile seed < 0:\n    print '\\nRandom seed must be an non-negative integer.'\n    seed = input('Please choose your random seed int[0, inf): ')\nrnd = np.random.RandomState(seed)\n\n# 10. Run the simulation by calling the nav_sim_driver with appropriate options\nnav_sim_driver(data_fname, nav_fname, num_dom, num_doy, imu_grade, gnss, freq, sim_type, sim_mode, scheme)\n\n# **********************************************************************************************************************\n# *******************************************  REACH THE PYTHON'S TAIL  ************************************************\n# **********************************************************************************************************************"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_375","text":"<gh_stars>100-1000\n# Copyright (c) 1996-2015 PSERC. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n\"\"\"Tests of C{qps_pypower} QP solvers.\n\"\"\"\n\nfrom numpy import array, zeros, shape, Inf\n\nfrom scipy.sparse import csr_matrix as sparse\n\nfrom pypower.ppoption import ppoption\nfrom pypower.cplex_options import cplex_options\nfrom pypower.mosek_options import mosek_options\nfrom pypower.qps_pypower import qps_pypower\nfrom pypower.util import have_fcn\n\nfrom pypower.t.t_begin import t_begin\nfrom pypower.t.t_is import t_is\nfrom pypower.t.t_end import t_end\nfrom pypower.t.t_ok import t_ok\nfrom pypower.t.t_skip import t_skip\n\n\ndef t_qps_pypower(quiet=False):\n    \"\"\"Tests of C{qps_pypower} QP solvers.\n\n    @author: <NAME> (PSERC Cornell)\n    \"\"\"\n    algs = [200, 250, 400, 500, 600, 700]\n    names = ['PIPS', 'sc-PIPS', 'IPOPT', 'CPLEX', 'MOSEK', 'Gurobi']\n    check = [None, None, 'ipopt', 'cplex', 'mosek', 'gurobipy']\n\n    n = 36\n    t_begin(n * len(algs), quiet)\n\n    for k in range(len(algs)):\n        if check[k] is not None and not have_fcn(check[k]):\n            t_skip(n, '%s not installed' % names[k])\n        else:\n            opt = {'verbose': 0, 'alg': algs[k]}\n\n            if names[k] == 'PIPS' or names[k] == 'sc-PIPS':\n                opt['pips_opt'] = {}\n                opt['pips_opt']['comptol'] = 1e-8\n            if names[k] == 'CPLEX':\n#               alg = 0        ## default uses barrier method with NaN bug in lower lim multipliers\n                alg = 2        ## use dual simplex\n                ppopt = ppoption(CPLEX_LPMETHOD = alg, CPLEX_QPMETHOD = min([4, alg]))\n                opt['cplex_opt'] = cplex_options([], ppopt)\n\n            if names[k] == 'MOSEK':\n#                alg = 5        ## use dual simplex\n                ppopt = ppoption()\n#                ppopt = ppoption(ppopt, MOSEK_LP_ALG = alg)\n                ppopt = ppoption(ppopt, MOSEK_GAP_TOL=1e-9)\n                opt['mosek_opt'] = mosek_options([], ppopt)\n\n            t = '%s - 3-d LP : ' % names[k]\n            ## example from 'doc linprog'\n            c = array([-5, -4, -6], float)\n            A = sparse([[1, -1,  1],\n                        [3,  2,  4],\n                        [3,  2,  0]], dtype=float)\n            l = None\n            u = array([20, 42, 30], float)\n            xmin = array([0, 0, 0], float)\n            x0 = None\n            x, f, s, _, lam = qps_pypower(None, c, A, l, u, xmin, None, None, opt)\n            t_is(s, 1, 12, [t, 'success'])\n            t_is(x, [0, 15, 3], 6, [t, 'x'])\n            t_is(f, -78, 6, [t, 'f'])\n            t_is(lam['mu_l'], [0, 0, 0], 13, [t, 'lam.mu_l'])\n            t_is(lam['mu_u'], [0, 1.5, 0.5], 9, [t, 'lam.mu_u'])\n            t_is(lam['lower'], [1, 0, 0], 9, [t, 'lam.lower'])\n            t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper'])\n\n            t = '%s - unconstrained 3-d quadratic : ' % names[k]\n            ## from http:\/\/www.akiti.ca\/QuadProgEx0Constr.html\n            H = sparse([\n                [ 5, -2, -1],\n                [-2,  4,  3],\n                [-1,  3,  5]\n            ], dtype=float)\n            c = array([2, -35, -47], float)\n            x0 = array([0, 0, 0], float)\n            x, f, s, _, lam = qps_pypower(H, c, opt=opt)\n            t_is(s, 1, 12, [t, 'success'])\n            t_is(x, [3, 5, 7], 8, [t, 'x'])\n            t_is(f, -249, 13, [t, 'f'])\n            t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l'])\n            t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u'])\n            t_is(lam['lower'], zeros(shape(x)), 13, [t, 'lam.lower'])\n            t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper'])\n\n            t = '%s - constrained 2-d QP : ' % names[k]\n            ## example from 'doc quadprog'\n            H = sparse([[ 1, -1],\n                        [-1,  2]], dtype=float)\n            c = array([-2, -6], float)\n            A = sparse([[ 1, 1],\n                        [-1, 2],\n                        [ 2, 1]], dtype=float)\n            l = None\n            u = array([2, 2, 3], float)\n            xmin = array([0, 0])\n            x0 = None\n            x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt)\n            t_is(s, 1, 12, [t, 'success'])\n            t_is(x, array([2., 4.]) \/ 3, 7, [t, 'x'])\n            t_is(f, -74. \/ 9, 6, [t, 'f'])\n            t_is(lam['mu_l'], [0., 0., 0.], 13, [t, 'lam.mu_l'])\n            t_is(lam['mu_u'], array([28., 4., 0.]) \/ 9, 7, [t, 'lam.mu_u'])\n            t_is(lam['lower'], zeros(shape(x)), 8, [t, 'lam.lower'])\n            t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper'])\n\n            t = '%s - constrained 4-d QP : ' % names[k]\n            ## from http:\/\/www.jmu.edu\/docs\/sasdoc\/sashtml\/iml\/chap8\/sect12.htm\n            H = sparse([[1003.1,  4.3,     6.3,     5.9],\n                        [4.3,     2.2,     2.1,     3.9],\n                        [6.3,     2.1,     3.5,     4.8],\n                        [5.9,     3.9,     4.8,    10.0]])\n            c = zeros(4)\n            A = sparse([[   1,       1,       1,       1],\n                        [0.17,    0.11,    0.10,    0.18]])\n            l = array([1, 0.10])\n            u = array([1, Inf])\n            xmin = zeros(4)\n            x0 = array([1, 0, 0, 1], float)\n            x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt)\n            t_is(s, 1, 12, [t, 'success'])\n            t_is(x, array([0, 2.8, 0.2, 0]) \/ 3, 5, [t, 'x'])\n            t_is(f, 3.29 \/ 3, 6, [t, 'f'])\n            t_is(lam['mu_l'], array([6.58, 0]) \/ 3, 6, [t, 'lam.mu_l'])\n            t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u'])\n            t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower'])\n            t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper'])\n\n            t = '%s - (dict) constrained 4-d QP : ' % names[k]\n            p = {'H': H, 'A': A, 'l': l, 'u': u, 'xmin': xmin, 'x0': x0, 'opt': opt}\n            x, f, s, _, lam = qps_pypower(p)\n            t_is(s, 1, 12, [t, 'success'])\n            t_is(x, array([0, 2.8, 0.2, 0]) \/ 3, 5, [t, 'x'])\n            t_is(f, 3.29 \/ 3, 6, [t, 'f'])\n            t_is(lam['mu_l'], array([6.58, 0]) \/ 3, 6, [t, 'lam.mu_l'])\n            t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u'])\n            t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower'])\n            t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper'])\n\n            t = '%s - infeasible LP : ' % names[k]\n            p = {'A': sparse([1, 1]), 'c': array([1, 1]), 'u': array([-1]),\n                 'xmin': array([0, 0]), 'opt': opt}\n            x, f, s, _, lam = qps_pypower(p)\n            t_ok(s <= 0, [t, 'no success'])\n\n    t_end()\n\n\nif __name__ == '__main__':\n    t_qps_pypower(quiet=False)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_376","text":"#!\/usr\/bin\/env python3\n\nimport numpy as np\nimport rclpy\nimport rclpy.qos\nfrom halodi_msgs.msg import (\n    ReferenceFrameName,\n    TaskSpaceCommand,\n    WholeBodyControllerCommand\n)\nfrom rclpy.node import Node\nfrom scipy.spatial.transform import Rotation\n\ndef generate_task_space_command_msg(\n    body_frame_id, expressed_in_frame_id, xyzrpy, z_up=True\n):\n    \"\"\"Generates a task space command msg.\n\n    Parameters:\n    - body_frame_id (enum): body part to be moved, e.g. ReferenceFrameName.PELVIS\n    - expressed_in_frame_id (enum): reference frame for body_frame_id, e.g. ReferenceFrameName.BASE\n    - xyzrpy (array of 6 floats): desired pose of body_frame_id relative to expressed_in_frame_id\n      , as a list\/tuple\/1D np.array of [ posX, posY, posZ, rotX, rotY, rotZ ]\n    - z_up (bool): whether or not xyzrpy follows the Z-up co-ordinate convention. Default: True\n\n    Returns: TaskSpaceCommand msg\n    \"\"\"\n\n    msg_ = TaskSpaceCommand(express_in_z_up=z_up)\n    msg_.body_frame.frame_id = body_frame_id\n    msg_.expressed_in_frame.frame_id = expressed_in_frame_id\n\n    msg_.pose.position.x = xyzrpy[0]\n    msg_.pose.position.y = xyzrpy[1]\n    msg_.pose.position.z = xyzrpy[2]\n    quat_ = Rotation.from_euler(\"xyz\", xyzrpy[3:]).as_quat()  # Euler to quaternion\n    msg_.pose.orientation.x = quat_[0]\n    msg_.pose.orientation.y = quat_[1]\n    msg_.pose.orientation.z = quat_[2]\n    msg_.pose.orientation.w = quat_[3]\n\n    return msg_\n\nclass WholeBodyCommandPublisher(Node):\n    \"\"\"A helper\/example class to publish whole body controller messages.\n    \"\"\"\n\n    def __init__(self, whole_body_command_msg=None):\n        super().__init__(\n            \"task_circle\"\n        )  # initialize the underlying Node with the name hands_position_circle_rt\n\n        # Publisher for WholeBodyControllerCommand, 10 is overloaded for being 10 deep history QoS\n        self._publisher = self.create_publisher(\n            WholeBodyControllerCommand, \"\/eve\/whole_body_command\", 10\n        )\n\n        # Keep time for position control\n        self.t = 0.0\n        self.dt = 0.002\n\n        # Create timer that calls every self.dt\n        self.timer = self.create_timer(self.dt, self.timer_callback)\n\n    def timer_callback(self):\n        \n        whole_body_command_msg_ = WholeBodyControllerCommand();\n\n        # Append two half circle tracing position control with both hands using some trigioiniometry\n        # Don't get too close with hands together because otherwise eve hits herself\n        whole_body_command_msg_.task_space_commands.append(generate_task_space_command_msg(\n            ReferenceFrameName.RIGHT_HAND, \n            ReferenceFrameName.PELVIS, \n            [0.4, -np.cos(2*np.pi*self.t\/5)\/10-0.3, np.sin(2*np.pi*self.t\/10)\/5+0.2, 0.0, -np.deg2rad(90.0), 0.0]\n            ))\n        whole_body_command_msg_.task_space_commands.append(generate_task_space_command_msg(\n            ReferenceFrameName.LEFT_HAND, \n            ReferenceFrameName.PELVIS, \n            [0.4, np.cos(2*np.pi*self.t\/5)\/10+0.3, np.sin(2*np.pi*self.t\/10)\/5+0.2, 0.0, -np.deg2rad(90.0), 0.0]\n            ))\n\n        self.t += self.dt\n\n        self._publisher.publish(whole_body_command_msg_)\n\ndef main():\n\n    rclpy.init()\n\n    node = WholeBodyCommandPublisher()\n\n    try:\n        rclpy.spin(node)\n    except KeyboardInterrupt:\n        pass\n\n    rclpy.shutdown()\n\nif __name__ == \"__main__\":\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_377","text":"\"\"\" Noise models. \"\"\"\nimport numpy as np\nimport scipy.stats as stats\nfrom modelmodel.misc import process_prng\n\n\ndef white(N, sigma=1, prng=None):\n    \"\"\" Create white noise.\n    \n    Parameters\n    ---------\n    N : numeric\n        Length of 1d noise array to return\n    sigma : numeric\n        Standard deviation\n    prng : np.random.RandomState, None\n        A RandomState instance, or None\n    \"\"\"\n    \n    prng = process_prng(prng)\n    \n    return prng.normal(loc=0, scale=sigma, size=N), prng\n\n\ndef ar1(N, alpha=0.2, sigma=1, prng=None):\n    \"\"\" Create AR1 noise.\n    \n    Parameters\n    ---------\n    N : numeric\n        Length of 1d noise array to return\n    alpha : float\n        Degree of autocorrelation\n    sigma : numeric\n        Standard deviation of white noise\n    prng : np.random.RandomState, None\n        A RandomState instance, or None\n        \n    Alpha of 0.2 was taken from the 'temporalnoise.R' function \n    in the R neuRosim package (ver 02-10)\n    \"\"\"\n    \n    if (alpha > 1) or (alpha < 0):\n        raise ValueError(\"alpha must be between 0-1.\")\n    \n    prng = process_prng(prng)\n    \n    noise, prng = white(N=N, sigma=sigma, prng=prng)\n    arnoise = [noise[0], ]\n    \n    [arnoise.append(\n            noise[ii] + (alpha * noise[ii-1])\n            ) for ii in range(1, len(noise))]\n    \n    return arnoise, prng\n\n\ndef physio(N, TR=1, freq_heart=1.17, freq_resp=0.2, sigma=1, prng=None):\n    \"\"\" Create periodic physiological noise \n    \n    Parameters\n    ---------\n    N : numeric\n        Length of 1d noise array to return\n    TR : float\n        The repetition rate (BOLD signal)\n    freq_heart : float\n        Frequency of heart rate (s)\n    freq_resp : float\n        Frequency of respiration (s)\n    sigma : numeric\n        Standard deviation of white noise\n    prng : np.random.RandomState, None\n        A RandomState instance, or None\n    \n    Note\n    ----  \n    freq_heart and freq_resp defaults were taken from \n    the 'temporalnoise.R' function in the R neuRosim \n    package (ver 02-10)\n    \"\"\"\n        \n    # Calculate rates\n    heart_beat = 2 * np.pi * freq_heart * TR\n    resp_rate = 2 * np.pi * freq_resp * TR\n    \n    # Use rate to make periodic heart \n    # and respiration (physio) drift \n    # timeseries\n    t = np.arange(N)\n    hr_drift = np.sin(heart_beat * t) + np.cos(resp_rate * t)\n    \n    # Renormalize sigma using the \n    # sigma of the physio signals\n    hr_weight = sigma \/ np.std(hr_drift)\n    \n    # Create the white noise then\n    # add the weighted physio\n    noise, prng = white(N=N, prng=prng) \n    noise += hr_weight * hr_drift\n    \n    return noise, prng\n\n\ndef _gen_drifts(nrow, ncol):\n    idx = np.arange(0, nrow)\n\n    drifts = np.zeros((nrow, ncol+1))\n    drifts[:,0] = np.repeat(1 \/ np.sqrt(nrow), nrow)\n    for col in range(2, ncol+1):\n        drift = np.sqrt(2. \/ nrow) * 10. * np.cos(\n                np.pi * (2. * idx + 1.) * (col - 1.) \/ (2. * nrow))\n        drifts[:, col] = drift\n        \n    return drifts\n    \n    \ndef lowfreqdrift(N, TR=1, sigma=1, prng=None):\n    \"\"\" Create noise with a low frequency drift (0.002-0.015 Hz)  \n    \n    Parameters\n    ---------\n    N : numeric\n        Length of 1d noise array to return\n    TR : float\n        The repetition rate (BOLD signal)\n    prng : np.random.RandomState, None\n        A RandomState instance, or None\n    \n    Note\n    ----  \n    Smith et al (1999), Investigation of the Low Frequency Drift in fMRI \n    Signal, NeuroImage 9, 526-533.\n    \n    This function was ported form a similar function ('lowfreqdrift.R')\n    in the R 'neuRosim' package (ver 02-10):\n    \n    http:\/\/cran.r-project.org\/web\/packages\/neuRosim\/index.html\n    \"\"\"\n\n    prng = process_prng(prng)\n    \n    freq = prng.randint(66, 500)\n        ## i.e. 0.002-0.015 Hz\n    \n    nbasis = int(np.floor(2 * (N * TR) \/ freq + 1))\n    noise = _gen_drifts(N, nbasis)\n    noise = noise[:,1:]     ## Drop the first col\n    noise = noise.sum(1)    ## Sum the rows, creating\n                            ## creating the final noise\n    \n    # Now add white noise\n    whiten, prng = white(N, sigma=sigma, prng=prng)\n    noise += whiten\n\n    return noise, prng\n\n\ndef onef(N, fraction, prng=None):\n    \"\"\" Simulate the typical 1\/f fMRI noise distribution.\n    \"\"\"\n    \n    raise NotImplementedError(\"TODO\")\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_378","text":"<filename>features\/rms.py\nimport numpy as np\nfrom scipy.signal.windows import hann\n\nfrom sklearn.utils.validation import check_is_fitted\nfrom sklearn.base import BaseEstimator, TransformerMixin\n\nclass RMSFeatures(BaseEstimator, TransformerMixin):\n    def __init__(self, window_size=300, shift=15, percentile=0.1):\n        self.window_size = window_size\n        self.shift = shift\n        self.percentile = percentile\n\n    def _get_basal_tones(self, signal):\n        basal_tones = []\n        for i in range(0, len(signal) - self.window_size + 1, self.shift):\n            window = signal[i:i+self.window_size]\n            _min, _max = np.min(window), np.max(window)\n            base_value = 0.25 * (_max - _min)\n            # Take the mean of the 10% smallest values\n            mean_smallest_values = np.mean(sorted(window)[:int(self.percentile * len(window))])\n            \n            basal_tones.append(mean_smallest_values + base_value)\n\n        basal_tones = np.array(basal_tones)\n        basal_tones = np.interp(list(range(len(signal))),\n                                list(range(0, len(signal) - self.window_size + 1, self.shift)),\n                                basal_tones)\n        return basal_tones\n\n\n    def _rms(self, signal):\n        window = hann(self.window_size)\n        rms_signal = []\n        for i in range(0, len(signal) - self.window_size + 1, self.shift):\n            subsignal = signal[i:i+self.window_size] * window\n            rms_signal.append(np.sqrt(np.mean(subsignal ** 2)))\n        rms_signal = np.array(rms_signal)\n        rms_signal = np.interp(list(range(len(signal))),\n                               list(range(0, len(signal) - self.window_size + 1, self.shift)),\n                               rms_signal)\n        return rms_signal\n\n    def fit(self, X, y):\n        self.names_ = [\n            'RMS_mean',\n            'RMS_std',\n            'RMS_max',\n            'RMS_min',\n            'RMS_nr_zeros'\n        ]\n        return self\n\n    def transform(self, X):\n        check_is_fitted(self, ['names_'])\n        features = np.zeros((X.shape[0], len(self.names_)))\n        for i in range(X.shape[0]):\n            signal = X[i, :]\n            rms_signal = self._rms(signal)\n            basal_signal = self._get_basal_tones(rms_signal)\n            length = min(len(rms_signal), len(basal_signal))\n            diff_signal = rms_signal[:length] - basal_signal[:length]\n            diff_signal[diff_signal < 0] = 0\n            features[i, :] =[np.mean(diff_signal), np.std(diff_signal), \n                             np.max(diff_signal), np.min(diff_signal), \n                             np.sum(diff_signal == 0)]\n        return features\n\n    def fit_transform(self, X, y):\n        self.fit(X, y)\n        return self.transform(X)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_379","text":"import abc\nimport warnings\n\nimport gym\nimport numpy as np\nfrom scipy.spatial.ckdtree import cKDTree\n\nfrom gym_guppy.guppies import Agent, Guppy, GlobalTargetRobot\nfrom gym_guppy.tools import Feedback\nfrom gym_guppy.tools.math import is_point_left, normalize, rotation\n\n\nclass AdaptiveAgent(GlobalTargetRobot):\n    def action_completed(self) -> bool:\n        return True\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n        self._feedback = Feedback()\n        self._state: AdaptiveState = ApproachState()\n\n    @property\n    def action_space(self) -> gym.spaces.Box:\n        return gym.spaces.Box(high=np.inf, low=-np.inf, shape=tuple())\n\n    def set_action(self, action):\n        robot_pose = self._env_state[self.id]\n        _, [nn] = self._env_kd_tree.query(robot_pose[:2], k=[2])\n        guppy_pose = self._env_state[nn]\n\n        self._feedback.update(guppy_pose, robot_pose)\n\n        self._state = self._state.switch_state()\n        self._target = self._state.compute_next_action(self, self._feedback, self._env_state, self._env_kd_tree)\n\n    def compute_next_action(self, state: np.ndarray, kd_tree: cKDTree = None):\n        # robot_pose = state[self.id]\n        # _, [nn] = kd_tree.query(robot_pose[:2], k=[2])\n        # guppy_pose = state[nn]\n        #\n        # self._feedback.update(guppy_pose, robot_pose)\n        #\n        # self._state = self._state.switch_state()\n        # self._target = self._state.compute_next_action(self, self._feedback, state, kd_tree)\n        pass\n\n\nclass AdaptiveState(abc.ABC):\n    _dt = 0.01\n\n    @abc.abstractmethod\n    def compute_next_action(self, agent: Agent, feedback: Feedback, state: np.ndarray, kd_tree: cKDTree = None) -> \\\n            np.ndarray:\n        pass\n\n    @abc.abstractmethod\n    def switch_state(self) -> \"AdaptiveState\":\n        pass\n\n\nclass MillingState(AdaptiveState):\n    _mill_diameter = 0.2\n    _mill_center = np.array([.0, .0])\n\n    def __init__(self):\n        # TODO compute mill points\n        self._mill_points = []\n        self._mill_index = 0\n\n    def compute_next_action(self, agent: Agent, feedback: Feedback, state: np.ndarray, kd_tree: cKDTree = None):\n        # TODO implement\n        pass\n\n    def switch_state(self) -> \"AdaptiveState\":\n        # TODO implement\n        pass\n\n\nclass ApproachState(AdaptiveState):\n    _decision_bound = 0.5\n    _learning_rate = 0.075\n    _linear_speed_correction = 0.2\n    _comfort_zone = 0.12\n\n    def __init__(self):\n        super().__init__()\n\n        self._close_enough = False\n        self._approach_parameter = 0.5\n\n    def compute_next_action(self, agent: Agent, feedback: Feedback, state: np.ndarray, kd_tree: cKDTree = None):\n        # get own position and nearest fish position\n        robot_pos = state[agent.id][:2]\n        _, [nn] = kd_tree.query(robot_pos, k=[2])\n        guppy_pos = state[nn, :2]\n\n        # get fear and compute integrate\n        fear = feedback.fear\n        integrate = (fear - self._decision_bound) * self._dt * self._learning_rate\n\n        self._approach_parameter += integrate\n        self._approach_parameter = min(max(self._approach_parameter, 0.0), 1.0)\n\n        # infer fish motion\n        guppy_dir = feedback.infer_guppy_motion_direction(1.0)\n\n        # compute motion target\n        guppy_robot_vec = robot_pos - guppy_pos\n\n        if np.linalg.norm(guppy_robot_vec) < self._comfort_zone:\n            self._close_enough = True\n            return robot_pos\n\n        target = guppy_pos + normalize(guppy_robot_vec) * self._comfort_zone \/ 2.\n        rot_dir = 1 if is_point_left(guppy_pos, guppy_pos + guppy_dir, robot_pos) else -1\n        r = rotation(self._approach_parameter * np.pi * .5 * rot_dir)\n        return r.dot(target - robot_pos) + robot_pos\n\n    def switch_state(self) -> \"AdaptiveState\":\n        if self._close_enough:\n            print('Switching to LeadState')\n            return LeadState()\n        return self\n\n\nclass LeadState(AdaptiveState):\n    _target_radius = 0.05\n    _max_lead_dist = 0.1\n\n    _targets = np.array([[0.4, 0.4],\n                         [0.4, -0.4],\n                         [-0.4, -0.4],\n                         [-0.4, 0.4]])\n\n    def __init__(self):\n        super().__init__()\n\n        self._waiting_counter = 0\n        self._target_idx = None\n\n    def compute_next_action(self, agent: Agent, feedback: Feedback, state: np.ndarray, kd_tree: cKDTree = None):\n        robot_pos = state[agent.id, :2]\n        _, [nn] = kd_tree.query(robot_pos, k=[2])\n        guppy_pos = state[nn, :2]\n\n        # compute next target\n        if self._target_idx is None:\n            target_dists = np.linalg.norm(self._targets - robot_pos, axis=1)\n            self._target_idx = np.argmin(target_dists)\n\n        # check if robot is close enough to target\n        if np.linalg.norm(self._targets[self._target_idx] - robot_pos) < self._target_radius:\n            self._target_idx += 1\n            self._target_idx %= len(self._targets)\n\n        # check if guppy is close enough to robot\n        if np.linalg.norm(guppy_pos - robot_pos) > self._max_lead_dist:\n            print('Waiting for Guppy')\n            self._waiting_counter += 1\n            return robot_pos\n\n        self._waiting_counter = 0\n        return self._targets[self._target_idx]\n\n    def switch_state(self):\n        if self._waiting_counter > 10:\n            print('Switching to ApproachState')\n            return ApproachState()\n        return self\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_380","text":"<filename>fisspy\/analysis\/filter.py\nfrom __future__ import absolute_import, division\nimport numpy as np\nfrom scipy.fftpack import fft, fftfreq, ifft\n\n__author__= \"<NAME>\"\n__email__ = \"<EMAIL>\"\n\ndef FourierFilter(data, nt, dt, filterRange, axis=0):\n    \"\"\"\n    Apply the Fourier bandpass filter.\n\n    Parameters\n    ----------\n    data: `~numpy.ndarray`\n        N-dimensional array.\n    nt: `int`\n        The number of the time domain.\n    dt: `float`\n        Bin size of the time domain.\n    filterRange: `list`\n        Bandpass filter range.\n    axis: `int`\n        time axis of the data.\n    \"\"\"\n    if data.dtype == '>f8':\n        data = data.astype(float)\n    freq = fftfreq(nt, dt)\n    if filterRange[0] == None:\n        filterRange[0] = 0\n    if filterRange[1] == None:\n        filterRange[1] = freq.max()\n    filt = np.logical_or(np.abs(freq) < filterRange[0],\n                         np.abs(freq) > filterRange[1])\n    fdata = fft(data, axis=axis)\n    fdata[filt] = 0\n    return ifft(fdata, axis=axis).real\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_381","text":"<gh_stars>1-10\nfrom collections import defaultdict\nimport numpy as np\nimport scipy.optimize\n\n\nclass NashQ:\n\n    def __init__(self, env, config):\n        self._env = env\n\n        # Check that we are in a two-player game\n        assert env.num_players() == 2, \"Nash-Q is only implemented for 2-player games\"\n        \n        # Get configuration\n        self._iteration_episodes = config.get(\"iteration_episodes\", 10)\n        self._learning_rate = config.get(\"learning_rate\", 1.0)\n        self._initial_value = config.get(\"initial_value\", env.max_payoff())\n        self._solver = config.get(\"solver\", \"revised simplex\")\n        self._epsilon = config.get(\"epsilon\", 0.0)\n\n        # Initialize upper and lower value functions\n        self._Q = dict()\n        self._V = defaultdict(lambda: self._initial_value)\n\n        # Initialize strategies\n        self._strategies = dict()\n\n    def _solve_row(self, G):\n        N, M = G.shape\n\n        # Objective - maximize game value 'v'\n        c = np.zeros(1 + N, dtype=np.float64)\n        c[0] = -1.0\n\n        # Find a row-strategy that receives payoff at least 'v' for all column actions\n        A_ub = np.concatenate((np.ones((M,1,), dtype=np.float64), -G.T,), axis=1)\n        b_ub = np.zeros(M, dtype=np.float64)\n\n        # Ensure that row strategy is a distribution\n        A_eq = np.ones((1, 1 + N,), dtype=np.float64)\n        A_eq[0, 0] = 0.0\n        b_eq = np.ones(1, dtype=np.float64)\n\n        bounds = [(0.0,None,)] * (1 + N)\n        bounds[0] = (None, None)\n\n        # Use SciPy to solve the game\n        result = scipy.optimize.linprog(c, A_ub, b_ub, A_eq, b_eq, bounds, self._solver)\n\n        # Normalize strategy\n        strategy = np.clip(result.x[1:], 0.0, 1.0)\n        strategy \/= np.sum(strategy)\n\n        if np.isnan(strategy).any():\n            print(result)\n            exit(1)\n\n        return strategy\n\n    def _solve_nash(self, G):\n        row_strategy = self._solve_row(G)\n        column_strategy = self._solve_row(-G.T)\n\n        return row_strategy, column_strategy\n\n    def _update_simultaneous(self, state, actions, rewards, next_state):\n\n        # Get number of actions for each player\n        row_actions = state.num_actions(0)\n        column_actions = state.num_actions(1)\n\n        # Compute learning rate - constant for now\n        alpha = self._learning_rate\n\n        # Initialize Q-function for the current state if necessary\n        if state not in self._Q:\n            self._Q[state] = np.full((row_actions, column_actions,), self._initial_value, dtype=np.float64)\n        \n        # Compute Q-target\n        q_target = rewards[0]\n\n        if next_state is not None:\n            q_target += self._V[next_state]\n\n        # Update Q-function\n        self._Q[state][actions[0], actions[1]] = (1.0 - alpha) * self._Q[state][actions[0], actions[1]] + alpha * q_target\n\n        # Recompute strategies\n        row_strategy, column_strategy = self._solve_nash(self._Q[state])\n        self._strategies[state] = (row_strategy, column_strategy)\n\n        # Recompute value function\n        self._V[state] = row_strategy.dot(self._Q[state]).dot(column_strategy)\n\n    def _update_turn_based(self, state, actions, rewards, next_state):\n\n        # Get current player ID\n        player_id = state.active_players()[0]\n\n        # Get number of actions for current player\n        num_actions = state.num_actions(player_id)\n\n        # Compute learning rate - constant for now\n        alpha = self._learning_rate\n\n        # Initialize Q-bounds the current state if necessary\n        if state not in self._Q:\n            self._Q[state] = np.full(num_actions, self._initial_value, dtype=np.float64)\n        \n        # Compute Q-target\n        q_target = rewards[0]\n\n        if next_state is not None:\n            q_target += self._V[next_state]\n        \n        # Update Q-function\n        self._Q[state][actions[0]] = (1.0 - alpha) * self._Q[state][actions[0]] + alpha * q_target\n\n        # Recompute strategy\n        q_function = self._Q[state]\n\n        if 0 == player_id:\n            q_target = np.max(q_function)\n        else:\n            q_target = np.min(q_function)\n\n        strategy = np.zeros(num_actions, dtype=np.float64)\n\n        for action in range(num_actions):\n            if q_function[action] == q_target:\n                strategy[action] = 1.0\n\n        strategy = strategy \/ np.sum(strategy)\n        self._strategies[state] = strategy\n\n        # Recompute value function\n        self._V[state] = np.sum(q_function * strategy)\n\n    def _actions(self, state):\n        if len(state.active_players()) == 1:\n            num_actions = state.num_actions(state.active_players()[0])\n\n            if state not in self._strategies or np.random.random() < self._epsilon:\n                strategy = np.ones(num_actions, dtype=np.float64) \/ num_actions\n            else:\n                strategy = self._strategies[state]\n\n            return [np.random.choice(num_actions, p=strategy)]\n        else:\n            row_actions = state.num_actions(0)\n            column_actions = state.num_actions(1)\n\n            if state not in self._strategies or np.random.random() < self._epsilon:\n                row_strategy = np.ones(row_actions, dtype=np.float64) \/ row_actions\n                column_strategy = np.ones(column_actions, dtype=np.float64) \/ column_actions\n            else:\n                row_strategy, column_strategy = self._strategies[state]\n\n            row_action = np.random.choice(row_actions, p=row_strategy)\n            column_action = np.random.choice(column_actions, p=column_strategy)\n\n            return [row_action, column_action]\n    \n    def train(self):\n\n        # Step counter\n        total_steps = 0\n\n        for _ in range(self._iteration_episodes):\n\n            # Reset environment\n            current_state = self._env.reset()\n\n            # Initialize history\n            state_history = []\n            action_history = []\n            reward_history = []\n\n            while current_state is not None:\n\n                # Append current state to state history\n                state_history.append(current_state)\n\n                # Get actions for all active players\n                current_action = self._actions(current_state)\n                action_history.append(current_action)\n\n                # Take joint action in environment\n                current_state, rewards = self._env.step(current_action)\n\n                # Append payoffs to payoff history\n                reward_history.append(rewards)\n\n            # Update step count\n            total_steps += len(state_history)\n\n            # Do updates for each player - work forward through history\n            for step in range(len(state_history)):\n                state = state_history[step]\n                actions = action_history[step]\n                rewards = reward_history[step]\n\n                if step + 1 < len(state_history):\n                    next_state = state_history[step + 1]\n                else:\n                    next_state = None\n                \n                if len(state.active_players()) == 1:\n                    self._update_turn_based(state, actions, rewards, next_state)\n                else:\n                    self._update_simultaneous(state, actions, rewards, next_state)\n\n        # Return number of steps and episodes sampled, and episode statistics\n        return total_steps, self._iteration_episodes, self._env.pull_stats()\n\n    def strategy(self, state, player_id):\n        if state not in self._strategies:\n            num_actions = state.num_actions(player_id)\n            return np.ones(num_actions, dtype=np.float64) \/ num_actions\n        elif len(state.active_players()) == 1:\n            return self._strategies[state]\n        else:\n            return self._strategies[state][player_id]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_382","text":"import unittest\nimport numpy as np\nfrom pyapprox.low_rank_multifidelity import *\nfrom functools import partial\nfrom scipy.stats import uniform\nimport pyapprox as pya\n\nfrom scipy.special import jv as bessel_function\nclass OscillatoryPolyLowFidelityModel(object):\n    def __init__( self, mesh_dof=100, num_terms=35 ):\n        self.mesh = np.linspace( -1.,1., mesh_dof )\n        self.num_terms = num_terms\n\n        variable = [uniform(-1,2)]\n        var_trans = pya.AffineRandomVariableTransformation(variable)\n        self.poly = pya.PolynomialChaosExpansion()\n        poly_opts = pya.define_poly_options_from_variable_transformation(\n            var_trans)\n        self.poly.configure(poly_opts)\n        self.poly.set_indices(pya.compute_hyperbolic_indices(\n            1,self.num_terms-1))\n\n    def basis_matrix(self):\n        # compute vandermonde matrix, i.e. all legendre polynomials up\n        # at most degree self.num_terms\n        basis_matrix = self.poly.basis_matrix( \n            self.mesh.reshape(1,self.mesh.shape[0]))\n        return basis_matrix\n\n    def compute_abs_z(self,z):\n        abs_z = np.absolute(z)\n        return abs_z\n\n    def __call__(self,samples):\n        z = samples[0,:]\n        # z in [0,10*pi]\n\n        basis_matrix = self.basis_matrix()\n\n        coeffs = np.zeros((self.num_terms,samples.shape[1]) ,float )\n        abs_z = self.compute_abs_z(z)\n        for k in range( self.num_terms ):\n            ck = np.exp( np.sign( z )*1j )*1j**k\n            ck = ck.real\n            gk = ck * np.sqrt( np.pi*(2.*k+1.)\/ abs_z )*\\\n                bessel_function( k+.5, abs_z )\n            # gk not defined for z=0\n            coeffs[k,:] = gk\n            # must divide by sqrt(2), due to using orthonormal basis with\n            # respect to w=1\/2, but needing orthonormal basis with respect\n            # to w=1\n            coeffs[k,:] \/= np.sqrt(2) \n\n        result = np.dot(basis_matrix, coeffs).T\n        return result\n\n    def generate_samples(self,num_samples):\n        num_vars = 1\n        return np.random.uniform(0,10.*np.pi,(num_vars,num_samples))\n\n\nclass OscillatoryHighFidelityModel(OscillatoryPolyLowFidelityModel):\n    def __init__(self,mesh_dof=100,num_terms=35,eps=1e-3):\n        super().__init__(mesh_dof,num_terms)\n        self.eps = eps\n\n    def compute_abs_z(self,z):\n        abs_z = np.absolute(z+self.eps*z**2)\n        return abs_z\n\nclass OscillatorySinLowFidelityModel(OscillatoryPolyLowFidelityModel):\n    def __init__(self,mesh_dof=100,num_terms=35,eps=1e-3):\n        super().__init__(mesh_dof,num_terms)\n        self.eps = eps\n\n    def basis_matrix(self):\n        kk = np.arange(self.num_terms)[np.newaxis,:]\n        basis_matrix = np.sin(np.pi*(kk+1)*self.mesh[:,np.newaxis])\n        return basis_matrix\n\nclass TestLowRankMultiFidelity(unittest.TestCase):\n    def setUp(self):\n        np.random.seed(1)\n\n    def test_select_nodes(self):\n        A = numpy.array([[1.,1.,1 ],[1.,2.,5.5],[1.,3.,13.]])\n        A = np.random.normal(0,1,(3,3))\n        G = numpy.dot( A.T, A )\n        pivots, L = select_nodes( A.copy(), A.shape[1] )\n        numpy_L = numpy.linalg.cholesky( G )\n        P = numpy.eye(pivots.shape[0])[pivots,:]\n        assert numpy.allclose( numpy.dot(P,numpy.dot(G,P.T)),\n                                   numpy.dot(L,L.T))\n        assert numpy.allclose(numpy.dot(P.T,numpy.dot(numpy.dot(L,L.T),P)),G)\n\n        A = numpy.random.normal( 0.,1., (4, 3) )\n        G = numpy.dot( A.T, A )\n        pivots, L = select_nodes( A.copy(), A.shape[1] )\n        P = numpy.eye(pivots.shape[0])[pivots,:]\n        numpy_L = numpy.linalg.cholesky( G )\n        assert numpy.allclose( numpy.dot(P,numpy.dot(G,P.T)),\n                                   numpy.dot(L,L.T))\n        assert numpy.allclose(numpy.dot(P.T,numpy.dot(numpy.dot(L,L.T),P)),G)\n\n    def test_select_nodes_cholesky(self):\n        A = numpy.array([[1.,1.,1 ],[1.,2.,5.5],[1.,3.,13.]])\n        A = np.random.normal(0,1,(3,3))\n        G = numpy.dot( A.T, A )\n        pivots, L = select_nodes_cholesky( A, A.shape[1] )\n        numpy_L = numpy.linalg.cholesky( G )\n        P = pya.get_pivot_matrix_from_vector(pivots,G.shape[0])\n        assert np.allclose(P.dot(G).dot(P.T),L.dot(L.T))\n\n        A = numpy.random.normal( 0.,1., (4, 3) )\n        G = numpy.dot( A.T, A )\n        pivots, L = select_nodes_cholesky( A, A.shape[1] )\n        numpy_L = numpy.linalg.cholesky( G )\n        P = pya.get_pivot_matrix_from_vector(pivots,G.shape[0])\n        assert np.allclose(P.dot(G).dot(P.T),L.dot(L.T))\n        \n    def test_select_nodes_update(self):\n        A = numpy.random.normal( 0.,1., (5, 4) )\n        G = numpy.dot( A.T, A )\n        pivots, L = select_nodes( A.copy(), A.shape[1], order=[1,3,0] )\n        assert numpy.allclose(pivots,[1,3,0,2])\n        P = numpy.eye(pivots.shape[0])[pivots,:]\n        numpy_L = numpy.linalg.cholesky( G )\n        assert numpy.allclose( numpy.dot(P,numpy.dot(G,P.T)),\n                                   numpy.dot(L,L.T))\n        assert numpy.allclose(numpy.dot(P.T,numpy.dot(numpy.dot(L,L.T),P)),G)\n\n\n    def test_oscillatory_model(self):\n        eps = 1.e-3\n        mesh_dof=100\n        K=35\n        lf_model1 = OscillatoryPolyLowFidelityModel(mesh_dof,K)\n        lf_model2 = OscillatorySinLowFidelityModel(mesh_dof,K)\n        hf_model  = OscillatoryHighFidelityModel(mesh_dof,100,eps)\n        lf_model  = lf_model2\n\n        # for tutorial\n        # samples = np.array([[5]])\n        # import matplotlib.pyplot as plt\n        # fig,axs=plt.subplots(1,2,figsize=(2*8,6))\n        # hf_model.eps=1e-2\n        # axs[0].plot(hf_model.mesh,hf_model(samples)[0,:],label='$u_0$')\n        # hf_model.eps=1e-3\n        # axs[0].plot(hf_model.mesh,lf_model1(samples)[0,:],label='$u_1$')\n        # axs[0].plot(hf_model.mesh,lf_model2(samples)[0,:],label='$u_2$')\n        # axs[0].legend()\n\n        # samples = np.linspace(0.01,np.pi*10-0.1,101)[np.newaxis,:]\n        # hf_model.eps=1e-2\n        # axs[1].plot(samples[0,:],hf_model(samples)[:,50],label='$u_0$')\n        # hf_model.eps=1e-3\n        # axs[1].plot(samples[0,:],lf_model1(samples)[:,50],label='$u_1$')\n        # axs[1].plot(samples[0,:],lf_model2(samples)[:,50],label='$u_2$')\n\n        # plt.show()\n        # assert False\n        \n        # number of quantities of interest\/outputs\n        num_QOI = mesh_dof\n        # number of random paramters\/inputs\n        num_dims = 1\n        # number of initial candidates\/snapshots for low-fidelity model\n        num_lf_candidates = int(1e4)\n        # number of interpolations nodes\/high-fidelity runs\n        num_hf_runs = 20\n        \n        num_test_samples = int(1e3)\n        test_samples = hf_model.generate_samples(num_test_samples)\n        hf_test_values = hf_model( test_samples )\n        lf_test_values = lf_model( test_samples )\n\n        mf_model = BiFidelityModel(lf_model,hf_model)\n        mf_model.build(num_hf_runs,hf_model.generate_samples,\n                       num_lf_candidates)\n\n        # regression test. To difficult to compute a unit test\n        mf_test_values = mf_model( test_samples )\n\n        error_mf = compute_mean_l2_error(hf_test_values,\n                                         mf_test_values)[1]\n        assert error_mf<1e-4#3.0401959914364483e-05)\n        \n        return\n        # for tutorial\n        hf_runs = [i*2 for i in range(1,11)]\n        error_mf = numpy.empty((len(hf_runs)))\n        error_lf = numpy.empty((len(hf_runs)))\n        error_nodes = numpy.empty((len(hf_runs)))\n        condition = numpy.empty((len(hf_runs)))\n\n        for j in range(len(hf_runs)):\n            num_hf_runs = hf_runs[j]\n\n            mf_model = BiFidelityModel(lf_model,hf_model)\n            mf_model.build(num_hf_runs,hf_model.generate_samples,\n                           num_lf_candidates)\n\n            mf_test_values = mf_model( test_samples )\n\n            error_mf[j] = compute_mean_l2_error(hf_test_values,\n                                                mf_test_values)[1]\n            error_lf[j] = compute_mean_l2_error(hf_test_values,\n                                                lf_test_values)[1]\n            print (\"|hf-lf|\", error_lf[j])\n            print (\"|hf-mf|\", error_mf[j])\n\n        \n        # plt.semilogy(hf_runs,error_mf,label=f'$K={K}$')\n        # plt.show()\n        \n\nif __name__== \"__main__\":    \n    low_rank_mf_test_suite = unittest.TestLoader().loadTestsFromTestCase(\n         TestLowRankMultiFidelity)\n    unittest.TextTestRunner(verbosity=2).run(low_rank_mf_test_suite)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_383","text":"import logging\r\nimport os\r\nimport random\r\nimport sys\r\n\r\nimport hydra\r\nimport numpy as np\r\nimport torch\r\nfrom omegaconf import OmegaConf\r\nfrom scipy.spatial.distance import cdist\r\nfrom torch.backends import cudnn\r\nfrom tqdm import tqdm\r\n\r\nsys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))\r\nos.chdir(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))\r\n\r\nfrom configs.configs import Config\r\nfrom dataloader import get_RMFD_target_dataloader, get_target_dataloader\r\nfrom utils.utils import Scheduler, AverageMeter, Entropy, cal_acc_target_oda\r\nfrom networks import network\r\n\r\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\r\n\r\n\r\ndef change_model_require_grad(model: torch.nn.Module, true_or_false: bool):\r\n    for k, v in model.named_parameters():\r\n        v.requires_grad = true_or_false\r\n\r\n\r\ndef obtain_label(loader, netF, netB, netC, cfg):\r\n    start_test = True\r\n    with torch.no_grad():\r\n        iter_test = iter(loader)\r\n        for _ in range(len(loader)):\r\n            data = iter_test.next()\r\n            inputs = data[0]\r\n            labels = data[1]\r\n            inputs = inputs.cuda()\r\n            feas = netB(netF(inputs))\r\n            outputs = netC(feas)\r\n            if start_test:\r\n                all_fea = feas.float().cpu()\r\n                all_output = outputs.float().cpu()\r\n                all_label = labels.float()\r\n                start_test = False\r\n            else:\r\n                all_fea = torch.cat((all_fea, feas.float().cpu()), 0)\r\n                all_output = torch.cat((all_output, outputs.float().cpu()), 0)\r\n                all_label = torch.cat((all_label, labels.float()), 0)\r\n\r\n    all_output = torch.nn.Softmax(dim=1)(all_output)\r\n    _, predict = torch.max(all_output, 1)\r\n    before_acc = torch.sum(torch.squeeze(predict).float() == all_label).item() \/ float(all_label.size()[0])\r\n    if cfg.model.distance == 'cosine':\r\n        all_fea = torch.cat((all_fea, torch.ones(all_fea.size(0), 1)), 1)\r\n        all_fea = (all_fea.t() \/ torch.norm(all_fea, p=2, dim=1)).t()\r\n\r\n    ent = torch.sum(-all_output * torch.log(all_output + cfg.model.epsilon), dim=1) \/ np.log(cfg.dataset.class_num)\r\n    ent = ent.float().cpu()\r\n\r\n    from sklearn.cluster import KMeans\r\n    kmeans = KMeans(2, random_state=0).fit(ent.reshape(-1, 1))\r\n    labels = kmeans.predict(ent.reshape(-1, 1))\r\n\r\n    idx = np.where(labels == 1)[0]\r\n    iidx = 0\r\n    if ent[idx].mean() > ent.mean():\r\n        iidx = 1\r\n    known_idx = np.where(kmeans.labels_ != iidx)[0]\r\n\r\n    all_fea = all_fea[known_idx, :]\r\n    all_output = all_output[known_idx, :]\r\n    predict = predict[known_idx]\r\n    all_label_idx = all_label[known_idx]\r\n    ENT_THRESHOLD = (kmeans.cluster_centers_).mean()\r\n\r\n    all_fea = all_fea.float().cpu().numpy()\r\n    K = all_output.size(1)\r\n    aff = all_output.float().cpu().numpy()\r\n    initc = aff.transpose().dot(all_fea)\r\n    initc = initc \/ (1e-8 + aff.sum(axis=0)[:, None])\r\n    cls_count = np.eye(K)[predict].sum(axis=0)\r\n    labelset = np.where(cls_count > cfg.train.threshold)\r\n    labelset = labelset[0]\r\n\r\n    dd = cdist(all_fea, initc[labelset], cfg.model.distance)\r\n    pred_label = dd.argmin(axis=1)\r\n    pred_label = labelset[pred_label]\r\n\r\n    for round in range(1):\r\n        aff = np.eye(K)[pred_label]\r\n        initc = aff.transpose().dot(all_fea)\r\n        initc = initc \/ (1e-8 + aff.sum(axis=0)[:, None])\r\n        dd = cdist(all_fea, initc[labelset], cfg.model.distance)\r\n        pred_label = dd.argmin(axis=1)\r\n        pred_label = labelset[pred_label]\r\n\r\n    guess_label = cfg.dataset.class_num * np.ones(len(all_label), )\r\n    guess_label[known_idx] = pred_label\r\n\r\n    after_acc = np.sum(guess_label == all_label.float().numpy()) \/ len(all_label_idx)\r\n    log_str = f'PseudoLabeling: Threshold = {ENT_THRESHOLD:.2f}, Accuracy = {before_acc * 100:.2f}% -> {after_acc * 100:.2f}%'\r\n\r\n    logging.info(log_str)\r\n\r\n    return guess_label.astype('int'), ENT_THRESHOLD\r\n\r\n\r\ndef get_mem_label(cfg, netF, netB, netC, test_loader):\r\n    netF.eval()\r\n    netB.eval()\r\n    mem_label, ENT_THRESHOLD = obtain_label(test_loader, netF, netB, netC, cfg)\r\n    mem_label = torch.from_numpy(mem_label).cuda()\r\n\r\n    return mem_label, ENT_THRESHOLD\r\n\r\n\r\ndef op_copy(optimizer):\r\n    for param_group in optimizer.param_groups:\r\n        param_group['lr0'] = param_group['lr']\r\n    return optimizer\r\n\r\n\r\ndef init_seed(seed):\r\n    torch.manual_seed(seed)\r\n    torch.cuda.manual_seed(seed)\r\n    np.random.seed(seed)\r\n    random.seed(seed)\r\n    cudnn.benchmark = True\r\n\r\n\r\ndef init_dataset_name(cfg):\r\n    specific_name_dict = {\r\n        \"office-home\": ['Art', 'Clipart', 'Product', 'RealWorld'],\r\n        \"RMFD\": ['AFDB_face_dataset', 'AFDB_masked_face_dataest']\r\n    }\r\n\r\n    cfg.dataset.name_src = specific_name_dict[cfg.dataset.name][cfg.dataset.s]\r\n    cfg.dataset.name_tar = specific_name_dict[cfg.dataset.name][cfg.dataset.t]\r\n\r\n\r\ndef train(epoch, train_loader, netF, netB, netC, criterion, optimizer, scheduler, mem_label, cfg):\r\n    losses = AverageMeter()\r\n    epoch_sum = epoch * len(train_loader)\r\n    netF.train()\r\n    netB.train()\r\n    for i, data in enumerate(tqdm(train_loader, total=len(train_loader), leave=False, dynamic_ncols=True)):\r\n        optimizer.zero_grad()\r\n        scheduler(optimizer, epoch_sum + i + 1)\r\n        x, tar_idx = data[0].to(device), data[2].to(device)\r\n\r\n        pred = mem_label[tar_idx]\r\n        features_test = netB(netF(x))\r\n        outputs_test = netC(features_test)\r\n\r\n        softmax_out = torch.nn.Softmax(dim=1)(outputs_test)\r\n        outputs_test_known = outputs_test[pred < cfg.dataset.class_num, :]\r\n        pred = pred[pred < cfg.dataset.class_num]\r\n\r\n        if len(pred) == 0:\r\n            del features_test\r\n            del outputs_test\r\n            continue\r\n\r\n        if cfg.train.cls_par > 0:\r\n            loss = criterion(outputs_test_known, pred)\r\n            loss *= cfg.train.cls_par\r\n        else:\r\n            loss = torch.tensor(0.0).to(device)\r\n\r\n        if cfg.train.ent:\r\n            softmax_out_known = torch.nn.Softmax(dim=1)(outputs_test_known)\r\n            entropy_loss = torch.mean(Entropy(softmax_out_known))\r\n            if cfg.train.gent:\r\n                msoftmax = softmax_out.mean(dim=0)\r\n                gentropy_loss = torch.sum(-msoftmax * torch.log(msoftmax + cfg.model.epsilon))\r\n                entropy_loss -= gentropy_loss\r\n            loss += entropy_loss * cfg.train.ent_par\r\n\r\n        losses.update(loss, x.size(0))\r\n\r\n        optimizer.zero_grad()\r\n        loss.backward()\r\n        optimizer.step()\r\n\r\n    log_str = f'Train: Loss = {losses.avg:.3f}'\r\n    return log_str\r\n\r\n\r\ndef validate(valid_loader, netF, netB, netC, cfg):\r\n    netF.eval()\r\n    netB.eval()\r\n    acc_os1, acc_os2, acc_unknown = cal_acc_target_oda(valid_loader, netF, netB, netC, cfg, True)\r\n    log_str = f'Valid_Accuracy OS2 = {acc_os2:.2f}%, OS1 = {acc_os1:.2f}%, Unknown = {acc_unknown:.2f}%'\r\n\r\n    return acc_os1, acc_os2, acc_unknown, log_str\r\n\r\n\r\n@hydra.main(config_path='configs', config_name='config')\r\ndef main(cfg: Config) -> None:\r\n    init_seed(cfg.train.seed)\r\n    init_dataset_name(cfg)\r\n\r\n    logging.info(OmegaConf.to_yaml(cfg))\r\n    if cfg.da.type != 'oda':\r\n        raise ValueError(f\"This python file doesn't match {cfg.da.type}\")\r\n\r\n    if cfg.dataset.name == \"RMFD\":\r\n        train_loader, test_loader = get_RMFD_target_dataloader(cfg)\r\n    else:\r\n        train_loader, test_loader = get_target_dataloader(cfg)\r\n\r\n    netF = network.ResBase('resnet50').to(device)\r\n    netB = network.feat_bootleneck(netF.in_features, cfg.model.bottleneck_dim, cfg.model.classifier).to(device)\r\n    netC = network.feat_classifier(cfg.dataset.num_class, cfg.model.bottleneck_dim, cfg.model.layer).to(device)\r\n\r\n    netF.load_state_dict(torch.load(os.path.join(cfg.train.saved_model_path, 'source_F.pt')))\r\n    netB.load_state_dict(torch.load(os.path.join(cfg.train.saved_model_path, 'source_B.pt')))\r\n    netC.load_state_dict(torch.load(os.path.join(cfg.train.saved_model_path, 'source_C.pt')))\r\n\r\n    netC.eval()\r\n    change_model_require_grad(netC, False)\r\n\r\n    params = list()\r\n\r\n    if cfg.train.lr_decay1 > 0:\r\n        params.append({\"params\": netF.parameters(), \"lr\": cfg.train.lr * cfg.train.lr_decay1})\r\n    else:\r\n        change_model_require_grad(netF, False)\r\n\r\n    if cfg.train.lr_decay2 > 0:\r\n        params.append({\"params\": netB.parameters(), \"lr\": cfg.train.lr * cfg.train.lr_decay2})\r\n    else:\r\n        change_model_require_grad(netB, False)\r\n\r\n    optimizer = torch.optim.SGD(params)\r\n    optimizer = op_copy(optimizer)\r\n\r\n    criterion = torch.nn.CrossEntropyLoss()\r\n    scheduler = Scheduler(cfg.train.max_epoch * len(train_loader))\r\n\r\n    best_acc = 0\r\n    best_netF = None\r\n    best_netB = None\r\n    best_netC = None\r\n    mem_label = None\r\n    interval = cfg.train.max_epoch \/\/ 15\r\n    for epoch in range(cfg.train.max_epoch):\r\n\r\n        if epoch % interval == 0 and cfg.train.cls_par > 0:\r\n            mem_label, _ = get_mem_label(cfg, netF, netB, netC, test_loader)\r\n\r\n        train_log = train(epoch, train_loader, netF, netB, netC, criterion, optimizer, scheduler, mem_label, cfg)\r\n\r\n        if epoch % interval == 0 or epoch == cfg.train.max_epoch:\r\n            acc_os1, acc_os2, acc_unknown, val_log = validate(test_loader, netF, netB, netC, cfg)\r\n\r\n            if acc_os2 >= best_acc:\r\n                best_acc = acc_os2\r\n                best_netF = netF.state_dict()\r\n                best_netB = netB.state_dict()\r\n                best_netC = netC.state_dict()\r\n\r\n            logging.info(f\"[{epoch + 1}\/{cfg.train.max_epoch}] {train_log} {val_log}\")\r\n        else:\r\n            logging.info(f\"[{epoch + 1}\/{cfg.train.max_epoch}] {train_log}\")\r\n\r\n    torch.save(best_netF, \"target_F.pt\")\r\n    torch.save(best_netB, \"target_B.pt\")\r\n    torch.save(best_netC, \"target_C.pt\")\r\n\r\n    logging.info(f\"{cfg.dataset.name_src}=>{cfg.dataset.name_tar} Best Accuracy: {best_acc}\")\r\n\r\n\r\nif __name__ == '__main__':\r\n    main()\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_368","text":"import os\nimport argparse\nimport numpy as np\nimport csv\nfrom scipy import stats\n\nimport hydra\nfrom omegaconf import DictConfig\nfrom hydra import slurm_utils\n\n@hydra.main(config_path='\/h\/nng\/conf\/robust\/config.yaml', strict=False)\ndef display_bias(cfg: DictConfig):\n\n    if cfg.extra:\n        cfg.display.dir.name.append(cfg.extra)\n\n    if cfg.gen.seed is not None:\n        cfg.display.dir.name[3] = '_'.join(cfg.display.dir.name[3].split('_')[:-1])\n\n    base_path = os.path.join('\/h\/nng\/data', cfg.data.task, cfg.compare.name, cfg.data.tdset)\n    csv_file = os.path.join(base_path, 'orig', cfg.eval.split + '.csv')\n\n    # properties for each line\n    bias_prop = []\n\n    # possible values for each property\n    prop_list = [[] for _ in range(len(cfg.display.props))]\n\n    with open(csv_file, 'r') as csv_f:\n        reader = csv.reader(csv_f)\n        header = next(reader)\n        for row in reader:\n            res = []\n            if cfg.display.prop_split == 'Race' and  row[header.index('Race')] == '':\n                continue\n            for i in range(len(cfg.display.props)):\n                prop = cfg.display.props[i]\n                if prop == \"Person\":\n                    prop_val = row[header.index(prop)] if row[header.index(\"Race\")] == \"\" else \"\"\n                else:\n                    prop_val = row[header.index(cfg.display.props[i])]\n                res.append(prop_val)\n                if prop_val not in prop_list[i]:\n                    prop_list[i].append(prop_val)\n            bias_prop.append(res)\n\n    compare_idx = cfg.display.props.index(cfg.display.prop_split)\n\n    if len(prop_list[compare_idx]) != 2:\n        raise Exception(\"Can only compare 2 values\")\n\n    cfg.display.dir.name[2] = cfg.data.fdset\n    cfg.display.dir.name[5] = cfg.data.tdset\n\n    cfg.display.dir.name[4] = cfg.gen.seed\n    t_tests = []\n    for seed in empty_to_list(cfg.display.seed):\n        cfg.display.dir.name[6] = seed\n\n        display_dir = os.path.join('\/h\/nng\/slurm', cfg.display.dir.date, slurm_utils.resolve_name(cfg.display.dir.name), 'log')\n        fnames = sorted(os.listdir(display_dir))[::-1]\n        for fname in fnames:\n            if 'err' in fname:\n                continue\n            res = open(os.path.join(display_dir, fname), 'r').readlines()\n            if res == [] or 'Accuracy' not in res[-1]:\n                continue\n            probs = []\n            for line in res:\n                line = line.strip()\n                if line[0] == '[' and line[-1] == ']':\n                    probs.append([float(val) for val in line[1:-1].split(',')])\n            break\n\n        x_dim_size = tuple(len(prop_l) for prop_l in prop_list)\n        sums = np.zeros(x_dim_size)\n        nums = np.zeros(x_dim_size)\n\n        for i in range(len(bias_prop)):\n            props = bias_prop[i]\n            prop_idxs = [[prop_list[j].index(props[j])] for j in range(len(props))]\n            sums[np.ix_(*prop_idxs)] += probs[i][0]\n            nums[np.ix_(*prop_idxs)] += 1\n\n\n        avgs = np.divide(sums, nums)\n\n        avg_0 = avgs.take(0, axis=compare_idx).flatten()\n        avg_1 = avgs.take(1, axis=compare_idx).flatten()\n\n        avg_0 = avg_0[~np.isnan(avg_0)]\n        avg_1 = avg_1[~np.isnan(avg_1)]\n\n        t_tests.append(stats.ttest_ind(avg_0, avg_1))\n\n    print(t_tests)\n\n\ndef empty_to_list(l):\n    if l is None:\n        return [None]\n    else:\n        return list(l)\n\nif __name__ == \"__main__\":\n    display_bias()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_373","text":"<filename>util.py<gh_stars>10-100\n\"\"\"Utility functions.\"\"\"\nimport torch\nfrom torch_geometric.utils import degree, softmax, subgraph\nfrom torch_sparse import SparseTensor\nfrom torch_geometric.utils import remove_self_loops, add_self_loops\nimport sys, os\nimport os.path as osp\nsys.path.append(os.path.join(os.path.dirname(\"__file__\"), '..'))\nsys.path.append(os.path.join(os.path.dirname(\"__file__\"), '..', '..'))\nfrom GIB.pytorch_net.util import to_np_array\nfrom GIB.DeepRobust.deeprobust.graph.defense import GCN\nimport scipy.sparse as sp\nimport numpy as np\nimport pdb\nimport pickle\n\ndef get_root_dir():\n    dirname = os.getcwd()\n    dirname_split = dirname.split(\"\/\")\n    index = dirname_split.index(\"GIB\")\n    dirname = \"\/\".join(dirname_split[:index + 1])\n    return dirname\n\nGIB_PATH = get_root_dir() + \"\/results\"\n\n\nCOLOR_LIST = [\"b\", \"r\", \"g\", \"y\", \"c\", \"m\", \"skyblue\", \"indigo\", \"goldenrod\", \"salmon\", \"pink\",\n                  \"silver\", \"darkgreen\", \"lightcoral\", \"navy\", \"orchid\", \"steelblue\", \"saddlebrown\", \n                  \"orange\", \"olive\", \"tan\", \"firebrick\", \"maroon\", \"darkslategray\", \"crimson\", \"dodgerblue\", \"aquamarine\"]\nCOLOR_LIST = COLOR_LIST * 2\n\nLINESTYLE_LIST = [\"-\", \"--\", \"-.\", \":\", (0, (5, 10))]\n\ndef get_reparam_num_neurons(out_channels, reparam_mode):\n    if reparam_mode is None or reparam_mode == \"None\":\n        return out_channels\n    elif reparam_mode == \"diag\":\n        return out_channels * 2\n    elif reparam_mode == \"full\":\n        return int((out_channels + 3) * out_channels \/ 2)\n    else:\n        raise \"reparam_mode {} is not valid!\".format(reparam_mode)\n\n\ndef sample_lognormal(mean, sigma=None, sigma0=1.):\n    \"\"\"\n    Samples from a log-normal distribution using the reparametrization\n    trick so that we can backprogpagate the gradients through the sampling.\n    By setting sigma0=0 we make the operation deterministic (useful at testing time)\n    \"\"\"\n    e = torch.randn(mean.shape).to(sigma.device)\n    return torch.exp(mean + sigma * sigma0 * e)\n\ndef scatter_sample(src, index, temperature, num_nodes=None):\n    gumbel = torch.distributions.Gumbel(torch.tensor([0.]).to(src.device), \n            torch.tensor([1.0]).to(src.device)).sample(src.size()).squeeze(-1)\n    log_prob = torch.log(src+1e-16)\n    logit = (log_prob + gumbel) \/ temperature\n    return softmax(logit, index, num_nodes)\n\ndef uniform_prior(index):\n    deg = degree(index)\n    deg = deg[index]\n    return 1.\/deg.unsqueeze(1)\n\ndef add_distant_neighbors(data, hops):\n    \"\"\"Add multi_edge_index attribute to data which includes the edges of 2,3,... hops neighbors.\"\"\"\n    assert hops > 1\n    edge_index, _ = remove_self_loops(data.edge_index)\n    edge_index, _ = add_self_loops(edge_index,\n                                   num_nodes=data.x.size(0))\n    one_hop_set = set([tuple(x) for x in edge_index.transpose(0, 1).tolist()])\n    row, col = edge_index\n    adj = SparseTensor(row=row, col=col)\n    multi_adj = adj\n    for _ in range(hops - 1):\n        multi_adj = multi_adj @ adj\n    row, col, _ = multi_adj.coo()\n    multi_edge_index = torch.stack([row, col], dim=0)\n    multi_hop_set = set([tuple(x) for x in multi_edge_index.transpose(0, 1).tolist()])\n    multi_hop_set = multi_hop_set - one_hop_set\n    multi_edge_index = torch.LongTensor(list(multi_hop_set)).transpose(0, 1)\n    data.multi_edge_index = multi_edge_index\n    return\n\n\ndef compose_log(metrics, key, spaces=0, tabs=0, newline=False):\n    string = \"\\n\" if newline else \"\"\n    return string + \"\\t\" * tabs + \" \" * spaces + \"{}: ({:.4f}, {:.4f}, {:.4f})\".format(key, metrics[\"train_{}\".format(key)], metrics[\"val_{}\".format(key)], metrics[\"test_{}\".format(key)])\n\n\ndef edge_index_2_csr(edge_index, size):\n    \"\"\"Edge index (PyG COO format) transformed to csr format.\"\"\"\n    csr_matrix = sp.csr_matrix(\n        (np.ones(edge_index.shape[1]), to_np_array(edge_index)),\n        shape=(size, size))\n    return csr_matrix\n\n\ndef process_data_for_nettack(data):\n    data.features = sp.csr_matrix(to_np_array(data.x))\n    data.adj = edge_index_2_csr(data.edge_index, size=data.x.shape[0])\n    data.labels = to_np_array(data.y)\n    data.idx_train = np.where(to_np_array(data.train_mask))[0]\n    data.idx_val = np.where(to_np_array(data.val_mask))[0]\n    data.idx_test = np.where(to_np_array(data.test_mask))[0]\n    return data\n\n\ndef to_tuple_list(edge_index):\n    \"\"\"Transform a coo-format edge_index to a list of edge tuples.\"\"\"\n    return [tuple(item) for item in edge_index.T.cpu().numpy()]\n\n\ndef classification_margin(output, true_label):\n    '''probs_true_label - probs_best_second_class'''\n    probs = torch.exp(output)\n    probs_true_label = probs[true_label].clone()\n    probs[true_label] = 0\n    probs_best_second_class = probs[probs.argmax()]\n    return (probs_true_label - probs_best_second_class).item()\n\n\ndef select_nodes(data, info, data_type, num=10, seed=None):\n    '''\n    selecting nodes as reported in nettack paper:\n    (i) the 10 nodes with highest margin of classification, i.e. they are clearly correctly classified,\n    (ii) the 10 nodes with lowest margin (but still correctly classified) and\n    (iii) 20 more nodes randomly\n    '''\n    attack_path = osp.join(get_root_dir(), 'experiments\/attack_data', data_type)\n    if not os.path.exists(attack_path):\n        os.makedirs(attack_path)\n    filename = os.path.join(attack_path, \"test-node_n:{}_seed_{}.pkl\".format(num, seed))\n    try:\n        with open(filename, 'rb') as f:\n            node_ids = pickle.load(f)\n            print(\"Load previous attacked node_ids saved in {}.\".format(filename))\n    except:\n        raise\n        device = data.x.device\n        gcn = GCN(nfeat=info[\"num_features\"],\n                  nclass=info[\"num_classes\"],\n                  nhid=16,\n                  dropout=0.5, device=device).to(device)\n        gcn.fit(data.features, data.adj, data.labels, data.idx_train)\n        gcn.eval()\n        output = gcn.predict()\n\n        margin_dict = {}\n        for idx in data.idx_test:\n            margin = classification_margin(output[idx], data.labels[idx])\n            if margin < 0: # only keep the nodes correctly classified\n                continue\n            margin_dict[idx] = margin\n        sorted_margins = sorted(margin_dict.items(), key=lambda x:x[1], reverse=True)\n        high = [x for x, y in sorted_margins[: num]]\n        low = [x for x, y in sorted_margins[-num: ]]\n        other = [x for x, y in sorted_margins[num: -num]]\n        other = np.random.choice(other, num * 2, replace=False).tolist()\n        node_ids = other + low + high\n        pickle.dump(node_ids, open(filename, \"wb\"))\n        print(\"Save attacked node_ids to {}:test-node_n:{}.pkl.\".format(attack_path, num))\n    return node_ids\n\ndef to_inductive(data):\n    mask = data.train_mask | data.val_mask\n    data.x = data.x[mask]\n    data.y = data.y[mask]\n    data.train_mask = data.train_mask[mask]\n    data.val_mask = data.val_mask[mask]\n    data.test_mask = None\n    data.edge_index, _ = subgraph(mask, data.edge_index, None,\n                                  relabel_nodes=True, num_nodes=data.num_nodes)\n    data.num_nodes = mask.sum().item()\n    return data\n\n\ndef parse_filename(filename, is_adversarial=False, **kwargs):\n    \"\"\"Parse the filename of the experment result file into a dictionary of settings.\n    \n    Args:\n        filename: a string of filename\n        is_adversarial: whether the file is from experiments\/GIB_node_adversarial_attack.\n    \"\"\"\n    if is_adversarial:\n        return parse_filename_adversarial(filename, **kwargs)\n    else:\n        return parse_filename_standard(filename)\n\n\ndef parse_filename_standard(filename):\n    \"\"\"Parse the filename of the standard experment result file into a dictionary of settings.\"\"\"\n    parse_dict = {}\n    filename_split = filename.split(\"_\")\n    parse_dict[\"data_type\"] = filename_split[0]\n    parse_dict[\"model_type\"] = filename_split[1]\n\n    baseline = parse_dict[\"model_type\"] in ['GCNSVD', 'GCNJaccard', 'RGCN']\n\n    parse_dict[\"train_fraction\"] = eval(filename_split[filename_split.index(\"tr\") + 1]) if \"tr\" in filename_split else 1\n    parse_dict[\"added_edge_fraction\"] = eval(filename_split[filename_split.index(\"ed\") + 1]) if \"ed\" in filename_split else 0\n    parse_dict[\"feature_noise_ratio\"] = eval(filename_split[filename_split.index(\"ed\") + 2]) if filename_split[filename_split.index(\"ed\") + 2] != \"beta\" else 0\n    parse_dict[\"beta1\"] = eval(filename_split[filename_split.index(\"beta\") + 1])\n    parse_dict[\"beta2\"] = eval(filename_split[filename_split.index(\"beta\") + 2])\n    parse_dict[\"latent_size\"] = int(filename_split[filename_split.index(\"lat\") + 1])\n    parse_dict[\"sample_size\"] = int(filename_split[filename_split.index(\"samp\") + 1])\n    parse_dict[\"num_layers\"] = int(filename_split[filename_split.index(\"lay\") + 1]) if \"lay\" in filename_split else 2\n    parse_dict[\"is_anneal_beta\"] = eval(filename_split[filename_split.index(\"anl\") + 1])\n    parse_dict[\"val_use_mean\"] = eval(filename_split[filename_split.index(\"mean\") + 1])\n    parse_dict[\"reparam_all_layers\"] = eval(filename_split[filename_split.index(\"reall\") + 1])\n    parse_dict[\"epochs\"] = int(filename_split[filename_split.index(\"epochs\") + 1])\n    parse_dict[\"lr\"] = eval(filename_split[filename_split.index(\"lr\") + 1]) if \"lr\" in filename_split else -1\n    parse_dict[\"weight_decay\"] = eval(filename_split[filename_split.index(\"weight_decay\") + 1]) if \"weight_decay\" in filename_split else -1\n    parse_dict[\"seed\"] = int(filename_split[filename_split.index(\"seed\") + 1])\n    parse_dict[\"idx\"] = filename_split[filename_split.index(\"id\") + 1][:-2]\n    if baseline:\n        parse_dict[\"threshold\"] = float(filename_split[filename_split.index(\"threshold\") + 1])\n        parse_dict[\"gamma\"] = float(filename_split[filename_split.index(\"gamma\") + 1]) if \"gamma\" in filename_split else None\n    else:\n        parse_dict[\"reparam_mode\"] = filename_split[filename_split.index(\"reparam\") + 1]\n        parse_dict[\"prior_mode\"] = filename_split[filename_split.index(\"prior\") + 1]\n        parse_dict[\"struct_dropout_mode\"] = filename_split[filename_split.index(\"sdrop\") + 1] if \"sdrop\" in filename_split else \"(standard,0.6)\"\n    return parse_dict\n\n\ndef parse_filename_adversarial(filename, baseline=False):\n    \"\"\"Parse the filename of the adversarial experment result file into a dictionary of settings.\"\"\"\n    parse_dict = {}\n    filename_split = filename.split(\"_\")\n    parse_dict[\"data_type\"] = filename_split[0]\n    parse_dict[\"model_type\"] = filename_split[1]\n    parse_dict[\"direct_attack\"] = eval(filename_split[filename_split.index(\"dire\") + 1])\n    parse_dict[\"attacked_nodes\"] = filename_split[filename_split.index(\"nodes\") + 1]\n    parse_dict[\"n_perturbations\"] = eval(filename_split[filename_split.index(\"pert\") + 1])\n    parse_dict[\"latent_size\"] = int(filename_split[filename_split.index(\"lat\") + 1])\n    parse_dict[\"sample_size\"] = int(filename_split[filename_split.index(\"samp\") + 1])\n    parse_dict[\"num_layers\"] = eval(filename_split[filename_split.index(\"l\") + 1]) if \"l\" in filename_split else 2\n    parse_dict[\"is_anneal_beta\"] = eval(filename_split[filename_split.index(\"anl\") + 1])\n    parse_dict[\"val_use_mean\"] = eval(filename_split[filename_split.index(\"mean\") + 1])\n    parse_dict[\"reparam_all_layers\"] = filename_split[filename_split.index(\"reall\") + 1]\n    parse_dict[\"lr\"] = eval(filename_split[filename_split.index(\"lr\") + 1]) if \"lr\" in filename_split else -1\n    parse_dict[\"weight_decay\"] = eval(filename_split[filename_split.index(\"l2\") + 1]) if \"l2\" in filename_split else -1\n    parse_dict[\"epochs\"] = int(filename_split[filename_split.index(\"epochs\") + 1])\n    parse_dict[\"seed\"] = int(filename_split[filename_split.index(\"seed\") + 1])\n    parse_dict[\"cuda\"] = filename_split[filename_split.index(\"id\") - 1]\n    parse_dict[\"idx\"] = filename_split[filename_split.index(\"id\") + 1][:-2]\n    if not baseline:\n        parse_dict[\"beta1\"] = eval(filename_split[filename_split.index(\"beta\") + 1])\n        parse_dict[\"beta2\"] = eval(filename_split[filename_split.index(\"beta\") + 2])\n        parse_dict[\"reparam_mode\"] = filename_split[filename_split.index(\"reparam\") + 1]\n        parse_dict[\"prior_mode\"] = filename_split[filename_split.index(\"prior\") + 1]\n        parse_dict[\"struct_dropout_mode\"] = filename_split[filename_split.index(\"sdrop\") + 1]\n    else:\n        parse_dict[\"gamma\"] = eval(filename_split[filename_split.index(\"gamma\") + 1])\n        parse_dict[\"threshold\"] = eval(filename_split[filename_split.index(\"threshold\") + 1][:-2])\n    return parse_dict"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_336","text":"params = [    \n    { \"start\": 34.77,  \"attr\": \"Ra\",        \"low\": 5.0, \"high\": 100.0, \"lists\": [\"all\"] },\n    { \"start\": 2.706,   \"attr\": \"cm\",        \"low\": 0.1, \"high\": 4.0, \"lists\": [\"all\"] },\n    { \"start\": 49.95,  \"attr\": \"ena\",       \"low\": 40.0, \"high\": 50.0, \"lists\": [\"all\"] },\n    { \"start\": -70.03,  \"attr\": \"ek\",        \"low\": -100.0, \"high\": -70.0, \"lists\": [\"all\"] },\n    { \"start\": -64.42,  \"attr\": \"e_pas\",     \"low\": -70.0, \"high\": -50.0, \"lists\": [\"all\"] },\n    { \"start\": 0.0005955, \"attr\": \"g_pas\",     \"low\": 0, \"high\": 0.00003, \"lists\": [\"all\"] },    \n    { \"start\": 0.5955,  \"attr\": \"sh_Na\",     \"low\": 0, \"high\": 10, \"lists\": [\"all\"] },    \n    { \"start\": 10,  \"attr\": \"tau_CaPool\",     \"low\": 1, \"high\": 500, \"lists\": [\"all\"] },    \n\n    { \"start\":  0.87485,  \"attr\": \"gbar_Na\",     \"low\": 0, \"high\": 0.05, \"lists\": [\"all\"] },\n    { \"start\": 0.0297,  \"attr\": \"gbar_Kd\",     \"low\": 0, \"high\": 0.04, \"lists\": [\"all\"] },\n    { \"start\": 0.000264,  \"attr\": \"gbar_Kslow\",  \"low\": 0, \"high\": 0.004, \"lists\": [\"all\"] },\n    { \"start\": 0.07215,  \"attr\": \"gbar_KA\",     \"low\": 0, \"high\": 0.005, \"lists\": [\"all\"] },\n    { \"start\": 0.001,  \"attr\": \"gbar_KCa\",    \"low\": 0, \"high\": 0.004, \"lists\": [\"all\"] },\n    { \"start\": 0.00081441,  \"attr\": \"gbar_LCa\",  \"low\": 0, \"high\": 0.001, \"lists\": [\"all\"] },\n    \n    { \"start\": -30.805,  \"attr\": \"eh\",       \"low\": -40.0, \"high\": -25.0, \"lists\": [\"apical\"] },\n    { \"start\": 0.00335,  \"attr\": \"gbar_Ih\",    \"low\": 0, \"high\": 0.00003, \"lists\": [\"apical\"] },\n    { \"start\": 0.000107,  \"attr\": \"gbar_CaT\",    \"low\": 0, \"high\": 18e-3, \"lists\": [\"apical\"] },\n]\n\ntop = [[34.40577448714667,\n  1.7746337170486868,\n  48.600061083126825,\n  -73.37824874831657,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  6.513661312706145,\n  0.01835806177392501,\n  0.012685911771409467,\n  0.001009786028927451,\n  0.003485358049971202,\n  0.0009111182551995163,\n  0.0006405838020076363,\n  -36.191181538089175,\n  2.6308088272967942e-06,\n  0.009520566435955282],\n [54.371057327671025,\n  1.343586187918468,\n  44.40845548134062,\n  -81.17397852577881,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  12.492102024675049,\n  0.01835806177392501,\n  0.012243090987314832,\n  0.001009786028927451,\n  0.0025920677224618473,\n  0.0006458839218994715,\n  0.0006437525063628547,\n  -36.474771746065244,\n  1.480641964136122e-06,\n  0.009384267411892713],\n [34.40577448714667,\n  1.7746337170486868,\n  48.25121832219984,\n  -85.83988610793635,\n  -52.149512474246556,\n  2.9121194317970837e-05,\n  7.600064936952291,\n  11.469065054901318,\n  0.01835806177392501,\n  0.012685911771409467,\n  0.001009786028927451,\n  0.003485358049971202,\n  0.0009111182551995163,\n  0.0006405838020076363,\n  -36.191181538089175,\n  4.9750908402217285e-06,\n  0.009520566435955282],\n [34.40577448714667,\n  1.7746337170486868,\n  48.25121832219984,\n  -73.37824874831657,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  11.99833703626091,\n  0.01835806177392501,\n  0.012685911771409467,\n  0.001009786028927451,\n  0.003485358049971202,\n  0.0009111182551995163,\n  0.0006405838020076363,\n  -36.191181538089175,\n  4.9750908402217285e-06,\n  0.009520566435955282],\n [34.40577448714667,\n  1.7746337170486868,\n  48.25121832219984,\n  -73.37824874831657,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  12.492102024675049,\n  0.01835806177392501,\n  0.012685911771409467,\n  0.001009786028927451,\n  0.003485358049971202,\n  0.0009111182551995163,\n  0.0006405838020076363,\n  -36.191181538089175,\n  4.9750908402217285e-06,\n  0.009520566435955282],\n [30.15666549418986,\n  1.7746337170486868,\n  44.40845548134062,\n  -81.17397852577881,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  12.492102024675049,\n  0.01835806177392501,\n  0.012243090987314832,\n  0.001009786028927451,\n  0.0025920677224618473,\n  0.0006458839218994715,\n  0.0006437525063628547,\n  -36.474771746065244,\n  4.9750908402217285e-06,\n  0.009384267411892713],\n [30.15666549418986,\n  1.7746337170486868,\n  47.11501790497679,\n  -81.17397852577881,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  12.492102024675049,\n  0.01835806177392501,\n  0.012243090987314832,\n  0.001009786028927451,\n  0.0025920677224618473,\n  0.0006458839218994715,\n  0.0006437525063628547,\n  -36.474771746065244,\n  4.9750908402217285e-06,\n  0.009384267411892713],\n [34.40577448714667,\n  1.7746337170486868,\n  48.25121832219984,\n  -85.83988610793635,\n  -52.149512474246556,\n  2.8689454891603497e-05,\n  7.600064936952291,\n  12.492102024675049,\n  0.01835806177392501,\n  0.012685911771409467,\n  0.001009786028927451,\n  0.003485358049971202,\n  0.0009111182551995163,\n  0.0006405838020076363,\n  -36.191181538089175,\n  4.9750908402217285e-06,\n  0.009520566435955282]]\n\n\nfrom olfactorybulb.database import *\nimport os,sys\nfrom neuronunit.tests.olfactory_bulb.publications import *\nfrom neuronunit.tests.olfactory_bulb.tests import *\nfrom neuronunit.models.neuron_cell import NeuronCellModel\nfrom sciunit.suites import TestSuite\nfrom pandas import DataFrame\nimport quantities as pq\nfrom neuronunit.tests.olfactory_bulb.utilities import cache\nfrom linetimer import CodeTimer\nimport string, math\nfrom scipy import optimize\nimport numpy as np\nimport matplotlib.pyplot as plt\n#import smt\n#from smt.surrogate_models.genn import GENN, load_smt_data\nfrom scipy import optimize\nimport linetimer\nimport multiprocessing\nfrom multiprocessing import Pool, TimeoutError\nfrom sciunit.scores import ZScore\n\ncell_type = 'mc'\n\n# Load tests\nmeasurements = Measurement\\\n    .select(Measurement)\\\n    .join(Property)\\\n    .switch(Measurement)\\\n    .join(Source)\\\n    .where((Measurement.property.type == \"Electrophysiology\") & (Measurement.property.id.startswith(cell_type+'_')))\\\n    .order_by(Measurement.property.id)\n\nproperties = {}\n\nfor m in measurements:\n    test_generic = str(m.property.test_class_generic)\n    pub = str(m.source.publication_class).strip()\n    class_name = test_generic+pub\n    \n    if test_generic not in properties:\n        properties[test_generic] = []\n    \n    globals()[class_name] = type(class_name, \n                                 (eval(pub), eval(test_generic)), \n                                 {})\n    \n    print('creating specific test class: ' + class_name)\n    \n    test_instance = eval(class_name)(observation={\"mean\": m.mean * eval(m.property.units), \"std\": m.std * eval(m.property.units), \"n\": m.n})\n    \n    properties[test_generic].append(test_instance)\n    \n    \n# Load model classes\nmodel_classes = list(CellModel\\\n                    .select(CellModel)\\\n                    .where(CellModel.cell_type == cell_type.upper())             \n                     )\nfor i, m in enumerate(model_classes):\n    nmsp = string.join(m.isolated_model_class.split('.')[:-1],'.')\n    cls = m.isolated_model_class.split('.')[-1]\n\n    import_cmd = 'from '+nmsp+' import '+cls+' as Model'+str(i)\n    print(import_cmd)\n    exec(import_cmd)\n    \n# Create work item list\nwork_items = []\n\nfor model in model_classes:\n    work_items.append({\"model_class\": model.isolated_model_class })\n        \ndef get_suite_score(item):\n    results = item\n    results[\"properties\"] = {}\n    results[\"model_score\"] = 0\n    \n    import prev_ob_models\n    exec('cell = '+ str(item[\"model_class\"]) +'()')\n    \n    from neuron import h\n    ind = item[\"param_values\"]\n    \n    for pi, pv in enumerate(ind):\n        if params[pi][\"attr\"] == \"tau_CaPool\":\n            setattr(h, params[pi][\"attr\"], pv)\n        else:\n            for param_list in params[pi][\"lists\"]:\n                for sec in getattr(cell.cell, param_list):\n                    setattr(sec, params[pi][\"attr\"], pv)\n\n    model = NeuronCellModel(cell.soma(0.5),name=cell.__class__.__module__+'.'+cell.__class__.__name__+'|'+str(ind))\n\n\n    for prop in properties.keys():\n        \n        if prop not in results[\"properties\"]:\n            results[\"properties\"][prop] = { \"tests\": {}, \"total_n\": 0, \"z_score_combined\": None}\n        \n        prop_tests = properties[prop]\n        \n        for prop_test in prop_tests:\n            \n            prop_test_result = {}\n            results[\"properties\"][prop][\"tests\"][prop_test.__class__.__name__] = prop_test_result          \n            \n            try:\n                #print('Starting', item, prop_test)\n                prediction = prop_test.generate_prediction(model)\n                #print('Finished', item, prop_test, prediction)\n\n            except:\n                import traceback\n                prediction = traceback.format_exc()\n                print(prediction)\n                \n            prop_test_result[\"observation\"] = prop_test.observation\n            prop_test_result[\"prediction\"] = prediction\n            \n            if type(prediction) != str:\n                z_score = (prediction - prop_test.observation[\"mean\"])\/prop_test.observation[\"std\"]\n                z_score = z_score.simplified\n            else:\n                z_score = 6.0 # errors are treated as 6 std deviation\n                \n            z_weighed = z_score * prop_test.observation[\"n\"]\n\n            prop_test_result[\"z_score\"] = z_score\n            prop_test_result[\"z_score_weighed\"] = z_weighed\n            \n            results[\"properties\"][prop][\"total_n\"] += prop_test.observation[\"n\"]\n            \n        results[\"properties\"][prop][\"z_score_combined\"] = sum([i[\"z_score_weighed\"] for i in results[\"properties\"][prop][\"tests\"].values()])\n        results[\"properties\"][prop][\"z_score_combined\"] \/= results[\"properties\"][prop][\"total_n\"]\n        \n        results[\"model_score\"] += results[\"properties\"][prop][\"z_score_combined\"].magnitude**2\n        \n    import math\n    results[\"model_score\"] = math.sqrt(results[\"model_score\"])\n\n    return results\n\ndef evaluate(ind):  \n    def do_work():\n        from prev_ob_models.Birgiolas2020.isolated_cells import MC\n        score = get_suite_score({\n            \"model_class\": \"prev_ob_models.Birgiolas2020.isolated_cells.MC\",\n            \"param_values\": ind\n        })\n        \n        return score[\"model_score\"],\n    \n    from multiprocess import Pool, TimeoutError\n    pool = Pool(processes = 1)\n    \n    try:\n        result = pool.apply_async(do_work).get(timeout=4*60)\n    except TimeoutError:\n        print('Simulation timed out')\n        pool.terminate()\n        result = 9*10.0,\n    except:\n        print('Error in simulation')\n        import traceback\n        print(traceback.format_exc())\n        pool.terminate()\n        result = 9*10.999,\n        \n    return result\n\nclass NoDaemonProcess(multiprocessing.Process):\n    # make 'daemon' attribute always return False\n    def _get_daemon(self):\n        return False\n    def _set_daemon(self, value):\n        pass\n    daemon = property(_get_daemon, _set_daemon)\n\n# We sub-class multiprocessing.pool.Pool instead of multiprocessing.Pool\n# because the latter is only a wrapper function, not a proper class.\nclass MyPool(multiprocessing.pool.Pool):\n    Process = NoDaemonProcess\n    \n    \ndef GA(suggested_pop=None, n=30, NGEN=30):\n    #genn.options['print_global'] = False\n\n    from deap import base, creator\n    import math\n\n    creator.create(\"FitnessMin\", base.Fitness, weights=(-1,))\n    creator.create(\"Individual\", list, fitness=creator.FitnessMin)\n\n    import random\n    from deap import tools\n\n    def random_indiv():\n        result = [random.random()] * len(params)\n        for i, pv in enumerate(result):\n            result[i] = (params[i][\"high\"]-params[i][\"low\"])*pv+params[i][\"low\"]\n        \n        return creator.Individual(result)\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", random_indiv)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n\n    def evaluate_surrogate(individual):\n        return genn.predict_values(np.array([individual])).flatten()[0],\n\n    lows = [p[\"low\"] for p in params]\n    highs = [p[\"high\"] for p in params]\n    \n    toolbox.register(\"mate\", tools.cxSimulatedBinaryBounded, eta=0.1, low=lows, up=highs)\n    toolbox.register(\"mutate\", tools.mutPolynomialBounded, eta=0.1, low=lows, up=highs, indpb=0.1)\n    toolbox.register(\"evaluate\", evaluate)\n\n\n\n    toolbox.register(\"select\", tools.selNSGA2, k=int(n*0.2))\n    if suggested_pop is None:\n        pop = toolbox.population(n=n)\n    else:\n        pop = [creator.Individual(i) for i in suggested_pop]\n        \n    CXPB, MUTPB = 1, 1\n    F_DIVERSITY = 0.5\n\n    # Evaluate the entire population\n    processes = 15   \n    pool = MyPool(processes = processes, maxtasksperchild=1)    \n    fitnesses = pool.map(toolbox.evaluate, pop)\n    pool.terminate()\n    pool.join()\n    \n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    for g in range(NGEN):\n        # Select the parents\n        elite = toolbox.select(pop)      \n\n        random_offspring = toolbox.population(n=int(n*F_DIVERSITY\/2.0))\n        diversity_offspring = random_offspring + tools.selRandom(pop, int(n*F_DIVERSITY\/2.0))        \n        elite_offspring = tools.selRandom(elite, n-len(elite)-len(diversity_offspring))\n\n        offspring = random_offspring + diversity_offspring + elite_offspring\n\n        # Clone the selected individuals\n        offspring = map(toolbox.clone, offspring)\n\n        # Apply crossover and mutation on the offspring\n        for child1, child2 in zip(offspring[::2], offspring[1::2]):\n            if random.random() < CXPB:\n                toolbox.mate(child1, child2)\n                del child1.fitness.values\n                del child2.fitness.values\n\n        for mutant in offspring:\n            if random.random() < MUTPB:\n                toolbox.mutate(mutant)\n                del mutant.fitness.values\n\n        # Evaluate the individuals with an invalid fitness\n        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]\n        \n        processes = max(1, multiprocessing.cpu_count()-1)\n        pool = MyPool(processes = processes, maxtasksperchild=1)    \n        fitnesses = pool.map(toolbox.evaluate, invalid_ind)\n        pool.terminate()\n        pool.join()        \n\n        for ind, fit in zip(invalid_ind, fitnesses):\n            ind.fitness.values = fit\n\n        # The population is entirely replaced by the parents + offspring\n        pop[:] = elite + offspring\n        \n        print(\"Generation\",g,\"out of\",NGEN,\"COMPLETE\")\n        print(np.min([i.fitness.values[0] for i in pop]))\n        \n    \n\n    return pop, pop[0], toolbox.evaluate(pop[0])\n\n\npop, pop0, sur_fit = GA(top, n=max(5,multiprocessing.cpu_count()-1), NGEN=1)\n\nimport deap\ntop = deap.tools.selNSGA2(pop,8)\ntop\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_337","text":"\n\n\"\"\"\n\n module to calculate welch t-statistics\n see copyright below\n\n\"\"\"\n\nimport warnings;\nwarnings.simplefilter(\"ignore\",DeprecationWarning)\n\nfrom math import log;\nfrom scipy import std;\nfrom scipy import mean;\nfrom math import sqrt;\nfrom sys import stderr\n\ndef stddev(arr):\n\tN=len(arr);\n\treturn sqrt((std(arr)**2)*N\/(N-1));\n\n\nimport numpy as n;\nimport scipy;\nimport scipy.stats;\n#from numpy.testing import NumpyTest, NumpyTestCase\n\n\ndef welchs_approximate_ttest(n1, mean1, sem1, \\\n                            n2, mean2, sem2):  #, alpha\n#    '''Welch''s approximate t-test for the difference of two means of\n#heteroscedasctic populations.\n\n#Implemented from Biometry, Sokal and Rohlf, 3rd ed., 1995, Box 13.4\n\n#:Parameters:\n#    n1 : int\n#        number of variates in sample 1\n#    n2 : int\n#        number of variates in sample 2\n#    mean1 : float\n#        mean of sample 1\n#    mean2 : float\n#        mean of sample 2\n#    sem1 : float\n#        standard error of mean1\n#    sem2 : float\n#        standard error of mean2\n#    alpha : float\n#        desired level of significance of test\n\n#:Returns:\n#    significant : bool\n#        True if means are significantly different, else False\n#    t_s_prime : float\n#        t_prime value for difference of means\n#    t_alpha_prime : float\n#        critical value of t_prime at given level of significance\n\n#Copyright (c) 2007, <NAME>\n\n#All rights reserved.\n\n#Redistribution and use in source and binary forms, with or without\n#modification, are permitted provided that the following conditions are met:\n\n #   * Redistributions of source code must retain the above copyright\n #   notice, this list of conditions and the following disclaimer.\n #   * Redistributions in binary form must reproduce the above copyright\n #   notice, this list of conditions and the following disclaimer in the\n #   documentation and\/or other materials provided with the distribution.\n #   * Neither the name of the University of Auckland, New Zealand nor\n #   the names of its contributors may be used to endorse or promote\n #   products derived from this software without specific prior written\n #   permission.\n\n#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n#\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n#OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n#SPECIAL,EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n#PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n#PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n#LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n#NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n#SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.'''\n    svm1 = sem1**2 * n1\n    svm2 = sem2**2 * n2\n    meandiff=mean1-mean2;\n    t_s_prime = meandiff\/n.sqrt(svm1\/n1+svm2\/n2)\n    sv1=sem1**2;\n    sv2=sem2**2;\n    upper=(sv1+sv2)**2\n    lower=(sv1**2)\/(n1-1)+(sv2**2)\/(n2-1)\n   \n    df=int(upper\/lower);\n\n    pval=scipy.stats.t.cdf(t_s_prime, df);\n    if(pval>0.5):\n\tpval=1.0-pval;\n    #t_alpha_df1 = scipy.stats.t.ppf(1-alpha\/2, n1 - 1)\n    #t_alpha_df2 = scipy.stats.t.ppf(1-alpha\/2, n2 - 1)\n    #t_alpha_prime = (t_alpha_df1 * sem1**2 + t_alpha_df2 * sem2**2) \/ \\\n     #               (sem1**2 + sem2**2)\n    return meandiff, df, t_s_prime, pval*2#, t_alpha_prime, abs(t_s_prime) > t_alpha_prime\n\n#and a test class as well...\n\ndef welchs_approximate_ttest_sd(n1, mean1, sd1,\\\n                            n2, mean2, sd2): #, alpha\n\treturn welchs_approximate_ttest(n1, mean1, sd1\/n.sqrt(n1), \\\n                            n2, mean2, sd2\/n.sqrt(n2)); #, alpha\n\n\ndef welchs_approximate_ttest_arr(arr1,arr2): #,alpha\n\tn1=len(arr1);\n\tn2=len(arr2);\n\tmean1=mean(arr1);\n\tmean2=mean(arr2);\n\tsd1=stddev(arr1);\n\tsd2=stddev(arr2);\n\treturn welchs_approximate_ttest_sd(n1,mean1,sd1,n2,mean2,sd2); #,alpha\n\ndef ttest(arr1, arr2):\n    return welchs_approximate_ttest_arr(arr1, arr2)[3]\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_339","text":"#srun --pty --mem=4000mb --gres=gpu:1  python saliency.py  > ~\/logs\/sal.log 2>&1 &\n\nfrom get_params import get_params\nimport sys, scipy.io, getopt\nimport os\nimport numpy as np\nimport matplotlib.pylab as plt\nimport pickle\n#import cv2, glob\nimport glob\n\ndef main(argv):\n    \n    params = get_params() # check get_params.py in the same directory to see the parameters\n    \n    try:\n      opts, args = getopt.getopt(argv,\"hr:o:s:c:g:\",[\"root=\",\"out=\",\"saliency_model=\",\"caffe_path=\", \"gpu=\"])\n    except getopt.GetoptError:\n      print 'ERROR'\n      sys.exit(2)\n    for opt, arg in opts:\n        if opt == '-h':\n              print 'saliency.py -r <root> -o <out> -s <saliency_model> -c <caffe_path> -g <gpu>'\n              sys.exit()\n        elif opt in (\"-r\", \"--root\"):\n              params['root'] = arg\n        elif opt in (\"-o\", \"--out\"):\n              params['out'] = arg\n        elif opt in (\"-s\", \"--saliency_model\"):\n              params['saliency_model'] = arg\n        elif opt in (\"-c\", \"--caffe_path\"):\n              params['caffe_path'] = arg\n        elif opt in (\"-g\", \"--gpu\"):\n              params['gpu'] = arg;\n              \n    sys.path.insert(0,os.path.join(params['caffe_path'],'python'))\n    import caffe\n    \n    compute = 'True' # sys.argv[1] # write 'true' or 'false' in case you want to compute or just visualize\n    \n    \n    if compute== 'true' or compute =='True':\n        \n        \n        deploy_file = os.path.join(params['saliency_model'],'deploy.prototxt')\n        model_file = os.path.join(params['saliency_model'],'model.caffemodel')\n        # I am using the mean file from caffenet...but I guess we could use a grey image as well ?\n        mean_file = '\/media\/HDD_2TB\/mcarne\/keyframe-extractor\/src\/Saliency\/deep\/meanfile.npy'\n        \n        if params['gpu'] == True:\n            caffe.set_mode_gpu()\n            print 'GPU mode selected'\n        else: \n            caffe.set_mode_cpu()\n            print 'CPU mode selected'\n            \n        net = caffe.Classifier(deploy_file, model_file, mean=np.load(mean_file).mean(1).mean(1), channel_swap=(2,1,0),raw_scale=255)\n        if not os.path.exists(params['out']):\n            os.makedirs(params['out'])\n        \n        for imagepath in glob.glob(params['root']+\"\/*.jpg\"):\n            print \"Procressing image...\"\n            scores = net.predict([caffe.io.load_image(imagepath)])    \n            feat = net.blobs['deconv1'].data\n            #feat = np.reshape(feat, (10,4096))\n            print feat, np.shape(feat)\n            #meanfeat = np.average( feat, axis = 0 ) \n            # saves to disk\n            fout = params['out']+'\/'+os.path.splitext(os.path.basename(imagepath))[0];\n            pickle.dump(feat,open(fout+'.p','wb'))\n            scipy.io.savemat(fout+'.mat', mdict={'isal': feat})\n\nif __name__ == \"__main__\":\n   main(sys.argv[1:])\n#else:\n    \n    \n    #feat = pickle.load(open('saliency.p','rb'))\n    #im = cv2.imread(imagepath)\n    #print np.shape(im)\n    #plt.imshow(np.array(feat).squeeze())\n\n    #feat = np.resize(feat,(576,768) )\n    #plt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_340","text":"import cvxopt\nimport cvxopt\nfrom cvxopt import solvers\nimport random\nimport matplotlib.pyplot as plt\nimport torch\nfrom autograd import grad\nfrom autograd import jacobian\nimport autograd.numpy as np\nimport autograd.numpy as jnp\nimport scipy.optimize as optim\nfrom scipy.optimize import minimize, Bounds,LinearConstraint\nfrom scipy.optimize import LinearConstraint,NonlinearConstraint\nfrom scipy.optimize import BFGS\n\n\nt = 0.02\nq_prev = None\n\ndevice = 'cpu'\nmodel = torch.load('models\/model_750_model_epoch_20000.pth', map_location=torch.device('cpu'))  # loaded trained model\nq_dim = 6  # q_dim is the dimension of joint space\nq_dim_changed = int(0.5 * q_dim)\n\n\n#value function defnation\nweight = []\nfor key in (model.keys()):\n    # print(key)\n    weight.append(model[key].cpu().numpy())  # load weight and bias\n\n\ndef leaky_relu(z):\n    return np.maximum(0.01 * z, z)\n\n\ndef softplus(z, beta=1):\n    return (1 \/ beta) * np.log(1 + np.exp(z * beta))\n\n\ndef assemble_lower_triangular_matrix(Lo, Ld):\n    Lo = Lo.squeeze(0)\n    Ld = Ld.squeeze(0)\n\n    assert (2 * Lo.shape[0] == (Ld.shape[0] ** 2 - Ld.shape[0]))\n    # pdb.set_trace()\n    #     diagonal_matrix = np.diagflat(Ld)\n    diagonal_matrix = np.identity(len(Ld)) * np.outer(np.ones(len(Ld)), Ld)\n\n    L = np.tril(np.ones(diagonal_matrix.shape)) - np.eye(q_dim_changed)\n\n    # Set off diagonals\n\n    L = np.array([[0, 0, 0], [1, 0, 0], [0, 0, 0]]) * Lo.reshape(3)[0] + np.array([[0, 0, 0], [0, 0, 0], [1, 0, 0]]) * \\\n        Lo.reshape(3)[1] + np.array([[0, 0, 0], [0, 0, 0], [0, 1, 0]]) * Lo.reshape(3)[2]\n    # print(\"L now : \", L)\n    # Add diagonals\n    L = L + diagonal_matrix\n    return L\n\n\ndef value(x1):\n    global weight, goal\n    fc1_w = weight[0]\n    fc1_b = weight[1]\n    fc2_w = weight[2]\n    fc2_b = weight[3]\n    fc_Ld_w = weight[4]\n    fc_Ld_b = weight[5]\n    fc_Lo_w = weight[6]\n    fc_Lo_b = weight[7]\n    #pdb.set_trace()\n    net_input = np.concatenate([np.squeeze(x1), np.squeeze(goal)], axis=0)\n    net_input = np.array([net_input])\n\n    z1 = np.dot(net_input, fc1_w.transpose()) + fc1_b\n    hidden1 = leaky_relu(z1)\n    z2 = np.dot(hidden1, fc2_w.transpose()) + fc2_b\n    hidden2 = leaky_relu(z2)\n    hidden3 = np.dot(hidden2, fc_Ld_w.transpose()) + fc_Ld_b\n    Ld = softplus(hidden3)\n    Lo = np.dot(hidden2, fc_Lo_w.transpose()) + fc_Lo_b\n    L = assemble_lower_triangular_matrix(Lo, Ld)\n\n    H = L @ L.transpose() + 1e-9 * np.eye(3)\n    return H\n\ngrad_value = grad(value)\njac_value= jacobian(value)\n\ndef fk_franka(q):\n    q_1 = q[0]\n    q_2 = q[1]\n    q_3 = q[2]\n    q_4 = q[3]\n    q_5 = q[4]\n    q_6 = q[5]\n    q_7 = q[6]\n\n    x = 0.0825 * jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) + 0.384 * jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(\n        q_2) - 0.0825 * jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + 0.316 * jnp.cos(q_1) * jnp.sin(\n        q_2) - 0.0825 * jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_2) * jnp.sin(q_3) + jnp.cos(q_3) * jnp.sin(q_1))) - 0.21 * jnp.cos(\n        q_6) * (\n                jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - 0.0825 * jnp.sin(\n        q_1) * jnp.sin(q_3) - 0.384 * jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_2) * jnp.sin(q_3) + jnp.cos(q_3) * jnp.sin(q_1))) + 0.088 * jnp.sin(\n        q_6) * (\n                jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)))\n    y = 0.0825 * jnp.cos(q_1) * jnp.sin(q_3) + 0.0825 * jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1) + 0.384 * jnp.cos(\n        q_4) * jnp.sin(q_1) * jnp.sin(q_2) - 0.0825 * jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (\n                jnp.cos(q_4) * (jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + jnp.sin(\n            q_1) * jnp.sin(q_2) * jnp.sin(q_4)) + jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_3) - jnp.cos(q_2) * jnp.sin(q_1) * jnp.sin(q_3))) - 0.21 * jnp.cos(\n        q_6) * (jnp.cos(q_4) * jnp.sin(q_1) * jnp.sin(q_2) - jnp.sin(q_4) * (\n            jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1))) - 0.0825 * jnp.sin(\n        q_1) * jnp.sin(q_2) * jnp.sin(q_4) + 0.316 * jnp.sin(q_1) * jnp.sin(q_2) - 0.384 * jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (\n                jnp.cos(q_4) * (jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + jnp.sin(\n            q_1) * jnp.sin(q_2) * jnp.sin(q_4)) + jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_3) - jnp.cos(q_2) * jnp.sin(q_1) * jnp.sin(q_3))) + 0.088 * jnp.sin(\n        q_6) * (\n                jnp.cos(q_4) * jnp.sin(q_1) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)))\n    z = 0.384 * jnp.cos(q_2) * jnp.cos(q_4) - 0.0825 * jnp.cos(q_2) * jnp.sin(q_4) + 0.316 * jnp.cos(\n        q_2) + 0.0825 * jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2) + 0.384 * jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(\n        q_4) - 0.0825 * jnp.cos(q_3) * jnp.sin(q_2) - 0.21 * jnp.cos(q_6) * (\n                jnp.cos(q_2) * jnp.cos(q_4) + jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(q_4)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_2) * jnp.sin(q_4) - jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2)) + jnp.sin(\n            q_2) * jnp.sin(q_3) * jnp.sin(q_5)) + 0.088 * jnp.sin(q_6) * (\n                jnp.cos(q_2) * jnp.cos(q_4) + jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(q_4)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_2) * jnp.sin(q_4) - jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2)) + jnp.sin(\n            q_2) * jnp.sin(q_3) * jnp.sin(q_5)) + 0.33\n    cartpos = np.array([x,y,z])\n    return cartpos\njac_fk = jacobian(fk_franka)\n\n\ndef traj_cost(trajectory):\n    cost = 0\n    cart_cost = 0\n    for i in range(len(trajectory) - 1):\n        cost += np.linalg.norm(np.asarray(trajectory[i]) - np.asarray(trajectory[i + 1]), ord=2)\n        # pdb.set_trace()\n        current = np.asarray(fk_franka(trajectory[i]))\n        next = np.asarray(fk_franka(trajectory[i+1]))\n        cart_cost += np.linalg.norm(current - next, ord=2)\n    return cost, cart_cost\n\n\ndef constraintfxn(qdot_x_next ):\n    global t, q_prev\n    q = qdot_x_next[:7]*t  + q_prev\n    q_1 = q[0]\n    q_2 = q[1]\n    q_3 = q[2]\n    q_4 = q[3]\n    q_5 = q[4]\n    q_6 = q[5]\n    q_7 = q[6]\n    x_next = qdot_x_next[7]\n    y_next = qdot_x_next[8]\n    z_next = qdot_x_next[9]\n\n    x = 0.0825 * jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) + 0.384 * jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(\n        q_2) - 0.0825 * jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + 0.316 * jnp.cos(q_1) * jnp.sin(\n        q_2) - 0.0825 * jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_2) * jnp.sin(q_3) + jnp.cos(q_3) * jnp.sin(q_1))) - 0.21 * jnp.cos(\n        q_6) * (\n                jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - 0.0825 * jnp.sin(\n        q_1) * jnp.sin(q_3) - 0.384 * jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_1) * jnp.sin(q_2) * jnp.sin(q_4) + jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3))) - jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_2) * jnp.sin(q_3) + jnp.cos(q_3) * jnp.sin(q_1))) + 0.088 * jnp.sin(\n        q_6) * (\n                jnp.cos(q_1) * jnp.cos(q_4) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.cos(q_2) * jnp.cos(q_3) - jnp.sin(q_1) * jnp.sin(q_3)))\n    y = 0.0825 * jnp.cos(q_1) * jnp.sin(q_3) + 0.0825 * jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1) + 0.384 * jnp.cos(\n        q_4) * jnp.sin(q_1) * jnp.sin(q_2) - 0.0825 * jnp.cos(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (\n                jnp.cos(q_4) * (jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + jnp.sin(\n            q_1) * jnp.sin(q_2) * jnp.sin(q_4)) + jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_3) - jnp.cos(q_2) * jnp.sin(q_1) * jnp.sin(q_3))) - 0.21 * jnp.cos(\n        q_6) * (jnp.cos(q_4) * jnp.sin(q_1) * jnp.sin(q_2) - jnp.sin(q_4) * (\n            jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1))) - 0.0825 * jnp.sin(\n        q_1) * jnp.sin(q_2) * jnp.sin(q_4) + 0.316 * jnp.sin(q_1) * jnp.sin(q_2) - 0.384 * jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (\n                jnp.cos(q_4) * (jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)) + jnp.sin(\n            q_1) * jnp.sin(q_2) * jnp.sin(q_4)) + jnp.sin(q_5) * (\n                        jnp.cos(q_1) * jnp.cos(q_3) - jnp.cos(q_2) * jnp.sin(q_1) * jnp.sin(q_3))) + 0.088 * jnp.sin(\n        q_6) * (\n                jnp.cos(q_4) * jnp.sin(q_1) * jnp.sin(q_2) - jnp.sin(q_4) * (\n                jnp.cos(q_1) * jnp.sin(q_3) + jnp.cos(q_2) * jnp.cos(q_3) * jnp.sin(q_1)))\n    z = 0.384 * jnp.cos(q_2) * jnp.cos(q_4) - 0.0825 * jnp.cos(q_2) * jnp.sin(q_4) + 0.316 * jnp.cos(\n        q_2) + 0.0825 * jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2) + 0.384 * jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(\n        q_4) - 0.0825 * jnp.cos(q_3) * jnp.sin(q_2) - 0.21 * jnp.cos(q_6) * (\n                jnp.cos(q_2) * jnp.cos(q_4) + jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(q_4)) + 0.088 * jnp.cos(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_2) * jnp.sin(q_4) - jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2)) + jnp.sin(\n            q_2) * jnp.sin(q_3) * jnp.sin(q_5)) + 0.088 * jnp.sin(q_6) * (\n                jnp.cos(q_2) * jnp.cos(q_4) + jnp.cos(q_3) * jnp.sin(q_2) * jnp.sin(q_4)) + 0.21 * jnp.sin(q_6) * (\n                jnp.cos(q_5) * (jnp.cos(q_2) * jnp.sin(q_4) - jnp.cos(q_3) * jnp.cos(q_4) * jnp.sin(q_2)) + jnp.sin(\n            q_2) * jnp.sin(q_3) * jnp.sin(q_5)) + 0.33\n    pos_residual = np.array([x - x_next,y-y_next,z - z_next])\n    return pos_residual\njac_constraint = jacobian(constraintfxn)\n\n\n\ndef costfxn(solverVariable,x_pos,goal):\n  diff = solverVariable[7:] - goal\n  v = value(x_pos)\n  cost = np.matmul(diff.transpose(),np.matmul(v, diff ))\n  w_des_vel = 0.002\n  smoothness_cost = np.sum(solverVariable[0:7]**2,axis = 0)\n  #print(f\"cost = {cost}, smoothness = {smoothness_cost}\")\n  return np.add(cost , w_des_vel*smoothness_cost)\njac_cost = jacobian(costfxn)   #jaccost has a shape of (3,)\n\n\ndef trajMetricBased(init_joint,start_cart,end_cartesian):\n    global t,q_prev,goal\n    # print(\"Start : \",start_cart)\n    # print(\"Goal : \", end_cartesian)\n    goal = np.squeeze(end_cartesian)\n    x_des  = end_cartesian\n    num_dof = 7\n    qdot = np.zeros(num_dof)  ########## initial velocity\n    qdotprev = np.zeros(num_dof)\n    q_min = np.array([-165, -100, -165, -165, -165, -1.0, -165]) * np.pi \/ 180\n    #q_min = q_min.reshape(7,1)\n    q_max = np.array([165, 101, 165, 1.0, 165, 214, 165]) * np.pi \/ 180\n    #q_max = q_max.reshape(7,1)\n\n\n    qdot_max = np.array([2.1750\t,2.1750\t,2.1750\t,2.1750,\t2.6100,\t2.6100,\t2.6100])\n    qdot_min = -1*qdot_max\n    qacc_max = np.array([15,\t7.5,\t10\t,12.5\t,15\t,20,\t20])\n    qacc_min = -1*qacc_max\n\n    x_pos = np.asarray(fk_franka(init_joint))  ########### initial positions\n\n    q = init_joint\n    q_prev = init_joint\n      ######### delta t for which the computed velocity is commanded to the robot 3msec\n    x_next = fk_franka(qdot*t + q)\n\n    mpc_iter = 200\n\n    q_1 = []\n    q_2 = []\n    q_3 = []\n    q_4 = []\n    q_5 = []\n    q_6 = []\n    q_7 = []\n    cost_tracker = np.zeros(mpc_iter)\n    trajectory = []\n    qdottrajc =[]\n    #pdb.set_trace()\n    solverVariable = np.hstack((qdot,x_next))\n    x_min = -np.ones(3,)*np.Inf #fk_franka(q_min)\n    x_max = np.ones(3,)*np.Inf #fk_franka(q_max)\n    solver_minbounds= np.hstack((qdot_min , x_min))\n    solver_maxbounds = np.hstack((qdot_max , x_max))\n    Amat = np.identity(10)\n    Bmat = np.identity(10)\n    for i in range(0, mpc_iter):\n        # print(f\"mpc-itr={i}\")\n        if np.linalg.norm(x_pos - x_des) < 0.01:\n            break\n            #t = 0.003\n            # print(\"Without value velocity\",v_des)\n\n        bnds = Bounds(solver_minbounds,solver_maxbounds)\n        nonlinear_constraint = NonlinearConstraint(constraintfxn , np.zeros((3,)), np.zeros((3,)) , jac= jac_constraint, hess=BFGS() , )\n\n        linear_constraint_A = LinearConstraint(Amat*t, np.hstack((q_min-q_prev,x_min)), np.hstack((q_max-q_prev, x_max )))\n\n        linear_constraint_B = LinearConstraint(Bmat ,np.hstack((qacc_min*t + qdotprev,x_min)), np.hstack((qacc_max*t + qdotprev,x_max)))\n        defaultopts={ 'maxiter': 100, 'ftol': 1e-06, 'iprint': 1, 'disp': False, 'eps': 1.4901161193847656e-08, 'finite_diff_rel_step': None}\n        res = minimize(costfxn ,  solverVariable, args =(x_pos,goal) , method='SLSQP', jac=jac_cost,\n                constraints=[nonlinear_constraint,linear_constraint_A, linear_constraint_B], options=defaultopts ,bounds=bnds)  #TODO include linear constraints and smoothness cost\n        #changing args for slsq might help ? like tol ??\n        solverVariable = np.asarray(res['x']).squeeze()\n        cost_tracker[i] = np.linalg.norm(np.hstack((x_pos[0] - x_des[0], x_pos[1] - x_des[1], x_pos[2] - x_des[2])))\n        trajectory.append([q[0], q[1], q[2], q[3], q[4], q[5], q[6]])\n        q = q + solverVariable[0:7] * t\n        x_pos =  solverVariable[7:]\n        qdotprev = solverVariable[0:7]\n        q_prev = q\n        qdottrajc.append(qdotprev)\n    JointCost, CartCost = traj_cost(trajectory)\n    return JointCost, CartCost, cost_tracker, np.array(trajectory)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_342","text":"import warnings\nimport numpy as np\nfrom numpy.linalg import LinAlgError\nfrom scipy.optimize._numdiff import approx_derivative\nimport scipy.stats as stats\n\nfrom refnx.util import ErrorProp as EP\nfrom refnx._lib import flatten, approx_hess2\nfrom refnx._lib import unique as f_unique\nfrom refnx.dataset import Data1D\nfrom refnx.analysis import (\n    is_parameter,\n    Parameter,\n    possibly_create_parameter,\n    is_parameters,\n    Parameters,\n    Interval,\n    PDF,\n)\n\n\nclass BaseObjective:\n    \"\"\"Don't necessarily have to use Parameters, could use np.array\"\"\"\n\n    def __init__(\n        self,\n        p,\n        logl,\n        logp=None,\n        fcn_args=(),\n        fcn_kwds=None,\n        name=None,\n        weighted=True,\n    ):\n        self.name = name\n        self.parameters = p\n        self.nvary = len(p)\n        self._logl = logl\n        self._logp = logp\n        self.fcn_args = fcn_args\n        self.fcn_kwds = {}\n        # give the BaseObjective a default value, so that it can be used in a\n        # GlobalObjective\n        self.weighted = weighted\n        if fcn_kwds is not None:\n            self.fcn_kwds = fcn_kwds\n\n    def setp(self, pvals):\n        \"\"\"\n        Set the parameters from pvals\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        \"\"\"\n        self.parameters[:] = pvals\n\n    def nll(self, pvals=None):\n        \"\"\"\n        Negative log-likelihood function\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        Returns\n        -------\n        nll : float\n            negative log-likelihood\n\n        \"\"\"\n        vals = self.parameters\n        if pvals is not None:\n            vals = pvals\n\n        return -self.logl(vals)\n\n    def logp(self, pvals=None):\n        \"\"\"\n        Log-prior probability function\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        Returns\n        -------\n        logp : float\n            log-prior probability\n\n        \"\"\"\n        vals = self.parameters\n        if pvals is not None:\n            vals = pvals\n\n        if callable(self._logp):\n            return self._logp(vals, *self.fcn_args, **self.fcn_kwds)\n        return 0\n\n    def logl(self, pvals=None):\n        \"\"\"\n        Log-likelihood probability function\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        Returns\n        -------\n        logl : float\n            log-likelihood probability.\n\n        \"\"\"\n        vals = self.parameters\n        if pvals is not None:\n            vals = pvals\n\n        return self._logl(vals, *self.fcn_args, **self.fcn_kwds)\n\n    def logpost(self, pvals=None):\n        \"\"\"\n        Log-posterior probability function\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        Returns\n        -------\n        logpost : float\n            log-probability.\n\n        Notes\n        -----\n        The log probability is the sum is the sum of the log-prior and\n        log-likelihood probabilities. Does not set the parameter attribute.\n\n        \"\"\"\n        vals = self.parameters\n        if pvals is not None:\n            vals = pvals\n\n        logpost = self.logp(vals)\n        if not np.isfinite(logpost):\n            return -np.inf\n        logpost += self.logl(vals)\n        return logpost\n\n    def nlpost(self, pvals=None):\n        \"\"\"\n        Negative log-posterior function\n\n        Parameters\n        ----------\n        pvals : np.ndarray\n            Array containing the values to be tested.\n\n        Returns\n        -------\n        nlpost : float\n            negative log-posterior\n\n        \"\"\"\n        return -self.logpost(pvals)\n\n    def varying_parameters(self):\n        \"\"\"\n        Returns\n        -------\n        varying_parameters : np.ndarray\n            The parameters varying in this objective function.\n\n        \"\"\"\n        return self.parameters\n\n    def covar(self, target=\"nll\"):\n        \"\"\"\n        Estimates a covariance matrix based on numerical differentiation\n        of either the negative log-likelihood or negative log-posterior\n        probabilities.\n\n        Parameters\n        ----------\n        target : str, {\"nll\", \"nlpost\"}\n\n        Returns\n        -------\n        covar : np.ndarray\n            The covariance matrix for the fitting system\n\n        Notes\n        -----\n        Estimation of a covariance matrix can be susceptible to numeric\n        instabilities. Critically evaluate the matrix before further use.\n        \"\"\"\n        _pvals = np.array(self.varying_parameters())\n\n        if target == \"nll\":\n            fn = self.nll\n        elif target == \"nlpost\":\n            fn = self.nlpost\n\n        try:\n            # from statsmodels\n            # the output from this for the test in test_objective.covar\n            # is very similar to numdifftools.Hessian, or a chained version\n            # of approx_derivative\n            hess = approx_hess2(_pvals, fn)\n            covar = np.linalg.inv(hess)\n        except LinAlgError:\n            sz = np.size(_pvals, 0)\n            covar = np.full((sz, sz), np.inf)\n        finally:\n            self.setp(_pvals)\n\n        return covar\n\n\nclass Objective(BaseObjective):\n    \"\"\"\n    Objective function for using with curvefitters such as\n    `refnx.analysis.curvefitter.CurveFitter`.\n\n    Parameters\n    ----------\n    model : refnx.analysis.Model\n        the generative model function. One can also provide an object that\n        inherits `refnx.analysis.Model`.\n    data : refnx.dataset.Data1D\n        data to be analysed.\n    lnsigma : float or refnx.analysis.Parameter, optional\n        Used if the  experimental uncertainty (`data.y_err`) underestimated by\n        a constant fractional amount. The experimental uncertainty is modified\n        as:\n\n        `s_n**2 = y_err**2 + exp(lnsigma * 2) * model**2`\n\n        See `Objective.logl` for more details.\n    use_weights : bool\n        use experimental uncertainty in calculation of residuals and\n        logl, if available. If this is set to False, then you should also\n        set `self.lnsigma.vary = False`, it will have no effect on the fit.\n    transform : callable, optional\n        the model, data and data uncertainty are transformed by this\n        function before calculating the likelihood\/residuals. Has the\n        signature `transform(data.x, y, y_err=None)`, returning the tuple\n        (`transformed_y, transformed_y_err`).\n    logp_extra : callable, optional\n        user specifiable log-probability term. This contribution is in\n        addition to the log-prior term of the `model` parameters, and\n        `model.logp`, as well as the log-likelihood of the `data`. Has\n        signature:\n        `logp_extra(model, data)`. The `model` will already possess\n        updated parameters. Beware of including the same log-probability\n        terms more than once.\n    auxiliary_params : {sequence, Parameters}, optional\n        Extra Parameter objects that are involved with curvefitting, but\n        aren't directly included as part of the `model`. See notes for more\n        details.\n    name : str\n        Name for the objective.\n\n    Notes\n    -----\n    For parallelisation `logp_extra` needs to be picklable.\n\n    `auxiliary_params` are included in calculating the `Objective.logp`\n    term, are present in `Objective.varying_parameters()`, and are modified by\n    Curvefitter during an analysis. Their main purpose is to aid in making\n    constraints in models.\n    \"\"\"\n\n    def __init__(\n        self,\n        model,\n        data,\n        lnsigma=None,\n        use_weights=True,\n        transform=None,\n        logp_extra=None,\n        auxiliary_params=(),\n        name=None,\n    ):\n        self.model = model\n        # should be a Data1D instance\n        if isinstance(data, Data1D):\n            self.data = data\n        else:\n            self.data = Data1D(data=data)\n\n        self.lnsigma = lnsigma\n        if lnsigma is not None:\n            self.lnsigma = possibly_create_parameter(lnsigma, \"lnsigma\")\n\n        if isinstance(auxiliary_params, Parameters):\n            self.auxiliary_params = auxiliary_params\n        else:\n            self.auxiliary_params = Parameters(auxiliary_params)\n\n        self._use_weights = use_weights\n        self.transform = transform\n        self.logp_extra = logp_extra\n        self.name = name\n        if name is None:\n            self.name = id(self)\n\n    def __str__(self):\n        s = [\"{:_>80}\".format(\"\")]\n        s.append(\"Objective - {0}\".format(self.name))\n\n        # dataset name\n        if self.data.name is None:\n            s.append(\"Dataset = {0}\".format(self.data))\n        else:\n            s.append(\"Dataset = {0}\".format(self.data.name))\n\n        s.append(\"datapoints = {0}\".format(self.npoints))\n        s.append(\"chi2 = {0}\".format(self.chisqr()))\n        s.append(\"Weighted = {0}\".format(self.weighted))\n        s.append(\"Transform = {0}\".format(self.transform))\n        s.append(str(self.parameters))\n\n        return \"\\n\".join(s)\n\n    def __repr__(self):\n        return (\n            \"Objective({model!r}, {data!r},\"\n            \" lnsigma={lnsigma!r},\"\n            \" use_weights={_use_weights},\"\n            \" transform={transform!r},\"\n            \" logp_extra={logp_extra!r},\"\n            \" name={name!r})\".format(**self.__dict__)\n        )\n\n    @property\n    def weighted(self):\n        \"\"\"\n        **bool** Does the data have weights (`data.y_err`), and is the\n        objective using them?\n\n        \"\"\"\n        return self.data.weighted and self._use_weights\n\n    @weighted.setter\n    def weighted(self, use_weights):\n        self._use_weights = bool(use_weights)\n\n    @property\n    def npoints(self):\n        \"\"\"\n        **int** the number of points in the dataset.\n\n        \"\"\"\n        return self.data.y.size\n\n    def varying_parameters(self):\n        \"\"\"\n        Returns\n        -------\n        varying_parameters : refnx.analysis.Parameters\n            The varying Parameter objects allowed to vary during the fit.\n\n        \"\"\"\n        # create and return a Parameters object because it has the\n        # __array__ method, which allows one to quickly get numerical values.\n        p = Parameters()\n        p.data = list(f_unique(p for p in flatten(self.parameters) if p.vary))\n        return p\n\n    def _data_transform(self, model=None):\n        \"\"\"\n        Returns\n        -------\n        y, y_err, model: tuple of np.ndarray\n            The y data, its uncertainties, and the model, all put through the\n             transform.\n        \"\"\"\n        x = self.data.x\n        y = self.data.y\n\n        y_err = 1.0\n        if self.weighted:\n            y_err = self.data.y_err\n\n        if self.transform is None:\n            return y, y_err, model\n        else:\n            if model is not None:\n                model, _ = self.transform(x, model)\n\n            y, y_err = self.transform(x, y, y_err)\n            if self.weighted:\n                return y, y_err, model\n            else:\n                return y, 1, model\n\n    def generative(self, pvals=None):\n        \"\"\"\n        Calculate the generative (dependent variable) function associated with\n        the model.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        model : np.ndarray\n\n        \"\"\"\n        self.setp(pvals)\n        return self.model(self.data.x, x_err=self.data.x_err)\n\n    def residuals(self, pvals=None):\n        \"\"\"\n        Calculates the residuals for a given fitting system.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        residuals : np.ndarray\n            Residuals, `(data.y - model) \/ y_err`.\n\n        \"\"\"\n        self.setp(pvals)\n\n        model = self.model(self.data.x, x_err=self.data.x_err)\n        # TODO add in varying parameter residuals? (z-scores...)\n\n        y, y_err, model = self._data_transform(model)\n\n        if self.lnsigma is not None:\n            s_n = np.sqrt(\n                y_err * y_err + np.exp(2 * float(self.lnsigma)) * model * model\n            )\n        else:\n            s_n = y_err\n\n        return (y - model) \/ s_n\n\n    def chisqr(self, pvals=None):\n        \"\"\"\n        Calculates the chi-squared value for a given fitting system.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        chisqr : np.ndarray\n            Chi-squared value, `np.sum(residuals**2)`.\n\n        \"\"\"\n        # TODO reduced chisqr? include z-scores for parameters? DOF?\n        self.setp(pvals)\n        res = self.residuals(None)\n        return np.sum(res * res)\n\n    @property\n    def parameters(self):\n        \"\"\"\n        :class:`refnx.analysis.Parameters`, all the Parameters contained in the\n        fitting system.\n\n        \"\"\"\n        if is_parameter(self.lnsigma):\n            return self.lnsigma | self.auxiliary_params | self.model.parameters\n        elif len(self.auxiliary_params):\n            return self.auxiliary_params | self.model.parameters\n        else:\n            return self.model.parameters\n\n    def setp(self, pvals):\n        \"\"\"\n        Set the parameters from pvals.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        \"\"\"\n        if pvals is None:\n            return\n\n        # set here rather than delegating to a Parameters\n        # object, because it may not necessarily be a\n        # Parameters object\n        _varying_parameters = self.varying_parameters()\n        if len(pvals) == len(_varying_parameters):\n            for idx, param in enumerate(_varying_parameters):\n                param.value = pvals[idx]\n            return\n\n        # values supplied are enough to specify all parameter values\n        # even those that are repeated\n        flattened_parameters = list(flatten(self.parameters))\n        if len(pvals) == len(flattened_parameters):\n            for idx, param in enumerate(flattened_parameters):\n                param.value = pvals[idx]\n            return\n\n        raise ValueError(\n            f\"Incorrect number of values supplied ({len(pvals)})\"\n            f\", supply either the full number of parameters\"\n            f\" ({len(flattened_parameters)}, or only the varying\"\n            f\" parameters ({len(_varying_parameters)}).\"\n        )\n\n    def prior_transform(self, u):\n        \"\"\"\n        Calculate the prior transform of the system.\n\n        Transforms uniform random variates in the unit hypercube,\n        `u ~ uniform[0.0, 1.0)`, to the parameter space of interest, according\n        to the priors on the varying parameters.\n\n        Parameters\n        ----------\n        u : array-like\n            Size of the varying parameters\n\n        Returns\n        -------\n        pvals : array-like\n            Scaled parameter values\n\n        Notes\n        -----\n        If a parameter has bounds, `x ~ Unif[-10, 10)` then the scaling from\n        `u` to `x` is done as follows:\n\n        .. code-block:: python\n\n            x = 2. * u - 1.  # scale and shift to [-1., 1.)\n            x *= 10.  # scale to [-10., 10.)\n\n        \"\"\"\n        var_pars = self.varying_parameters()\n        pvals = np.empty(len(var_pars), dtype=np.float64)\n\n        for i, var_par in enumerate(var_pars):\n            pvals[i] = var_par.bounds.invcdf(u[i])\n\n        return pvals\n\n    def logp(self, pvals=None):\n        \"\"\"\n        Calculate the log-prior of the system\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        logp : float\n            log-prior probability\n\n        Notes\n        -----\n        The log-prior is calculated as:\n\n        .. code-block:: python\n\n            logp = np.sum(param.logp() for param in\n                             self.varying_parameters())\n\n        \"\"\"\n        self.setp(pvals)\n\n        logp = np.sum(\n            [\n                param.logp()\n                for param in f_unique(\n                    p for p in flatten(self.parameters) if p.vary\n                )\n            ]\n        )\n\n        if not np.isfinite(logp):\n            return -np.inf\n\n        return logp\n\n    def logl(self, pvals=None):\n        \"\"\"\n        Calculate the log-likelhood of the system\n\n        The major component of the log-likelhood probability is from the data.\n        Extra potential terms are added on from the Model, `self.model.logp`,\n        and the user specifiable `logp_extra` function.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        logl : float\n            log-likelihood probability\n\n        Notes\n        -----\n        The log-likelihood is calculated as:\n\n        .. code-block:: python\n\n            logl = -0.5 * np.sum(((y - model) \/ s_n)**2\n                                 + np.log(2 * pi * s_n**2))\n            logp += self.model.logp()\n            logp += self.logp_extra(self.model, self.data)\n\n        where\n\n        .. code-block:: python\n\n            s_n**2 = y_err**2 + exp(2 * lnsigma) * model**2\n\n        \"\"\"\n        self.setp(pvals)\n\n        model = self.model(self.data.x, x_err=self.data.x_err)\n\n        logl = 0.0\n\n        y, y_err, model = self._data_transform(model)\n\n        if self.lnsigma is not None:\n            var_y = (\n                y_err * y_err + np.exp(2 * float(self.lnsigma)) * model * model\n            )\n        else:\n            var_y = y_err ** 2\n\n        # TODO do something sensible if data isn't weighted\n        if self.weighted:\n            logl += np.log(2 * np.pi * var_y)\n\n        logl += (y - model) ** 2 \/ var_y\n\n        # nans play havoc\n        if np.isnan(logl).any():\n            raise RuntimeError(\"Objective.logl encountered a NaN.\")\n\n        # add on extra 'potential' terms from the model.\n        extra_potential = self.model.logp()\n\n        if self.logp_extra is not None:\n            extra_potential += self.logp_extra(self.model, self.data)\n\n        return -0.5 * np.sum(logl) + extra_potential\n\n    def nll(self, pvals=None):\n        \"\"\"\n        Negative log-likelihood function\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        nll : float\n            negative log-likelihood\n\n        \"\"\"\n        self.setp(pvals)\n        return -self.logl()\n\n    def logpost(self, pvals=None):\n        \"\"\"\n        Calculate the log-probability of the curvefitting system\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        logpost : float\n            log-probability\n\n        Notes\n        -----\n        The overall log-probability is the sum of the log-prior and\n        log-likelihood. The log-likelihood is not calculated if the log-prior\n        is impossible (`logp == -np.inf`).\n\n        \"\"\"\n        self.setp(pvals)\n        logpost = self.logp()\n\n        # only calculate the probability if the parameters have finite\n        # log-prior\n        if not np.isfinite(logpost):\n            return -np.inf\n\n        logpost += self.logl()\n        return logpost\n\n    def covar(self, target=\"residuals\"):\n        \"\"\"\n        Estimates the covariance matrix of the Objective.\n\n        Parameters\n        ----------\n        target : {\"residuals\", \"nll\", \"nlpost\"}\n            Specifies what approach should be used to estimate covariance.\n\n        Returns\n        -------\n        covar : np.ndarray\n            Covariance matrix\n\n        Notes\n        -----\n        For most purposes the Jacobian of the `'residuals'` should be used to\n        calculate the covariance matrix, estimated as J.T x J.\n        If an Objective cannot calculate residuals then the covariance matrix\n        can be estimated by inverting a Hessian matrix created from either the\n        `'nll'` or `'nlpost'` methods.\n        The default `'residuals'` approach falls back to `'nll'` if a problem\n        is experienced.\n        The default `'residuals'` setting is preferred as the other settings\n        can sometimes experience instabilities during Hessian estimation with\n        numerical differentiation.\n        \"\"\"\n        if target == \"residuals\":\n            try:\n                covar = self._covar_from_residuals()\n            except Exception:\n                # fallback to \"nll\"\n                target = \"nll\"\n\n        if target in [\"nll\", \"nlpost\"]:\n            covar = super().covar(target)\n\n        pvar = np.diagonal(covar).copy()\n        psingular = np.where(pvar == 0)[0]\n\n        if len(psingular) > 0:\n            var_params = self.varying_parameters()\n            singular_params = [var_params[ps] for ps in psingular]\n\n            raise LinAlgError(\n                \"The following Parameters have no effect on\"\n                \" Objective.residuals, please consider fixing\"\n                \" them.\\n\" + repr(singular_params)\n            )\n\n        return covar\n\n    def _covar_from_residuals(self):\n        _pvals = np.array(self.varying_parameters())\n\n        used_residuals_scaler = False\n\n        def fn_scaler(vals):\n            return np.squeeze(self.residuals(_pvals * vals))\n\n        try:\n            # we should be able to calculate a Jacobian for a parameter whose\n            # value is zero. However, the scaling approach won't work.\n            # This will force Jacobian calculation by unscaled parameters\n            if np.any(_pvals == 0):\n                raise FloatingPointError()\n\n            with np.errstate(invalid=\"raise\"):\n                jac = approx_derivative(fn_scaler, np.ones_like(_pvals))\n            used_residuals_scaler = True\n        except FloatingPointError:\n            jac = approx_derivative(self.residuals, _pvals)\n        finally:\n            # using approx_derivative changes the state of the objective\n            # parameters have to make sure they're set at the end\n            self.setp(_pvals)\n\n        # need to create this because GlobalObjective may not have\n        # access to all the datapoints being fitted.\n        n_datapoints = np.size(jac, 0)\n\n        # covar = J.T x J\n\n        # from scipy.optimize.minpack.py\n        # eliminates singular parameters\n        _, s, VT = np.linalg.svd(jac, full_matrices=False)\n        threshold = np.finfo(float).eps * max(jac.shape) * s[0]\n        s = s[s > threshold]\n        VT = VT[: s.size]\n        covar = np.dot(VT.T \/ s ** 2, VT)\n\n        if used_residuals_scaler:\n            # unwind the scaling.\n            covar = covar * np.atleast_2d(_pvals) * np.atleast_2d(_pvals).T\n\n        scale = 1.0\n        # scale by reduced chi2 if experimental uncertainties weren't used.\n        if not (self.weighted):\n            scale = self.chisqr() \/ (\n                n_datapoints - len(self.varying_parameters())\n            )\n\n        return covar * scale\n\n    def pgen(self, ngen=1000, nburn=0, nthin=1):\n        \"\"\"\n        Yield random parameter vectors from the MCMC samples. The objective\n        state is not altered.\n\n        Parameters\n        ----------\n        ngen : int, optional\n            the number of samples to yield. The actual number of samples\n            yielded is `min(ngen, chain.size)`\n        nburn : int, optional\n            discard this many steps from the start of the chain\n        nthin : int, optional\n            only accept every `nthin` samples from the chain\n\n        Yields\n        ------\n        pvec : np.ndarray\n            A randomly chosen parameter vector\n\n        \"\"\"\n        yield from self.parameters.pgen(ngen=ngen, nburn=nburn, nthin=nthin)\n\n    def plot(self, pvals=None, samples=0, parameter=None, fig=None):\n        \"\"\"\n        Plot the data\/model.\n\n        Requires matplotlib be installed.\n\n        Parameters\n        ----------\n        pvals : np.ndarray, optional\n            Numeric values for the Parameter's that are varying\n        samples: number\n            If the objective has been sampled, how many samples you wish to\n            plot on the graph.\n        parameter: refnx.analysis.Parameter\n            Creates an interactive plot for the Parameter in Jupyter. Requires\n            ipywidgets be installed. Use with %matplotlib notebook\/qt.\n        fig: Figure instance, optional\n            If `fig` is not supplied then a new figure is created. Otherwise\n            the graph is created on the current axes on the supplied figure.\n\n        Returns\n        -------\n        fig, ax : :class:`matplotlib.Figure`, :class:`matplotlib.Axes`\n            `matplotlib` figure and axes objects.\n\n        \"\"\"\n        self.setp(pvals)\n\n        if fig is None:\n            import matplotlib.pyplot as plt\n\n            fig = plt.figure()\n            ax = fig.add_subplot(111)\n        else:\n            ax = fig.gca()\n\n        y, y_err, model = self._data_transform(model=self.generative())\n\n        # add the data (in a transformed fashion)\n        if self.weighted:\n            ax.errorbar(\n                self.data.x,\n                y,\n                y_err,\n                color=\"blue\",\n                label=self.data.name,\n                marker=\"o\",\n                ms=3,\n                lw=0,\n                elinewidth=2,\n            )\n        else:\n            ax.scatter(self.data.x, y, color=\"blue\", s=3, label=self.data.name)\n\n        if samples > 0:\n            saved_params = np.array(self.parameters)\n            # Get a number of chains, chosen randomly, set the objective,\n            # and plot the model.\n            for pvec in self.pgen(ngen=samples):\n                y, y_err, model = self._data_transform(\n                    model=self.generative(pvec)\n                )\n\n                ax.plot(self.data.x, model, color=\"k\", alpha=0.01)\n\n            # put back saved_params\n            self.setp(saved_params)\n\n        # add the fit\n        generative_plot = ax.plot(self.data.x, model, color=\"red\", zorder=20)\n\n        if parameter is None:\n            return fig, ax\n\n        # create an interactive plot in a Jupyter notebook.\n        def f(val):\n            if parameter is not None:\n                parameter.value = float(val)\n            y, y_err, model = self._data_transform(model=self.generative())\n            generative_plot[0].set_data(self.data.x, model)\n            fig.canvas.draw()\n\n        import ipywidgets\n\n        return fig, ax, ipywidgets.interact(f, val=float(parameter))\n\n    def corner(self, **kwds):\n        \"\"\"\n        Corner plot of the chains belonging to the Parameters.\n        Requires the `corner` and `matplotlib` packages.\n\n        Parameters\n        ----------\n        kwds: dict\n            passed directly to the `corner.corner` function\n\n        Returns\n        -------\n        fig : :class:`matplotlib.Figure` object.\n        \"\"\"\n        import corner\n\n        var_pars = self.varying_parameters()\n        chain = np.array([par.chain for par in var_pars])\n        labels = [par.name for par in var_pars]\n        chain = chain.reshape(len(chain), -1).T\n        kwds[\"labels\"] = labels\n        kwds[\"quantiles\"] = [0.16, 0.5, 0.84]\n        return corner.corner(chain, **kwds)\n\n\nclass GlobalObjective(Objective):\n    \"\"\"\n    Global Objective function for simultaneous fitting with\n    `refnx.analysis.CurveFitter`\n\n    Parameters\n    ----------\n    objectives : list\n        list of :class:`refnx.analysis.Objective` objects\n\n    \"\"\"\n\n    def __init__(self, objectives):\n        self.objectives = objectives\n        weighted = [objective.weighted for objective in objectives]\n\n        self._weighted = np.array(weighted, dtype=bool)\n\n        if len(np.unique(self._weighted)) > 1:\n            raise ValueError(\n                \"All the objectives must be either weighted or\"\n                \" unweighted, you cannot have a mixture.\"\n            )\n\n    def __str__(self):\n        s = [\"{:_>80}\".format(\"\\n\")]\n        s.append(\"--Global Objective--\")\n        for obj in self.objectives:\n            s.append(str(obj))\n            s.append(\"\\n\")\n        return \"\\n\".join(s)\n\n    def __repr__(self):\n        return \"GlobalObjective({0})\".format(repr(self.objectives))\n\n    @property\n    def weighted(self):\n        \"\"\"\n        **bool** do all the datasets have y_err, and are all the objectives\n        wanting to use weights?\n\n        \"\"\"\n        return self._weighted.all()\n\n    @property\n    def npoints(self):\n        \"\"\"\n        **int** number of data points in all the objectives.\n\n        \"\"\"\n        npoints = 0\n        for objective in self.objectives:\n            npoints += objective.npoints\n        return npoints\n\n    def residuals(self, pvals=None):\n        \"\"\"\n        Concatenated residuals for each of the\n        :meth:`refnx.analysis.Objective.residuals`.\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        residuals : np.ndarray\n            Concatenated :meth:`refnx.analysis.Objective.residuals`\n\n        \"\"\"\n        self.setp(pvals)\n\n        residuals = []\n        for objective in self.objectives:\n            residual = objective.residuals()\n            residuals.append(residual)\n\n        return np.concatenate(residuals)\n\n    @property\n    def parameters(self):\n        \"\"\"\n        :class:`refnx.analysis.Parameters` associated with all the objectives.\n\n        \"\"\"\n        # TODO this is probably going to be slow.\n        # cache and update strategy?\n        p = Parameters(name=\"global fitting parameters\")\n\n        for objective in self.objectives:\n            p.append(objective.parameters)\n\n        return p\n\n    def logp(self, pvals=None):\n        \"\"\"\n        Calculate the log-prior of the system\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters, optional\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        logp : float\n            log-prior probability\n\n        \"\"\"\n        self.setp(pvals)\n\n        logp = 0.0\n        for objective in self.objectives:\n            logp += objective.logp()\n            # shortcut if one of the priors is impossible\n            if not np.isfinite(logp):\n                return -np.inf\n\n        return logp\n\n    def logl(self, pvals=None):\n        \"\"\"\n        Calculate the log-likelhood of the system\n\n        Parameters\n        ----------\n        pvals : array-like or refnx.analysis.Parameters\n            values for the varying or entire set of parameters\n\n        Returns\n        -------\n        logl : float\n            log-likelihood probability\n\n        \"\"\"\n        self.setp(pvals)\n        logl = 0.0\n\n        for objective in self.objectives:\n            logl += objective.logl()\n\n        return logl\n\n    def plot(self, pvals=None, samples=0, parameter=None, fig=None):\n        \"\"\"\n        Plot the data\/model for all the objectives in the GlobalObjective.\n\n        Matplotlib must be installed to use this method.\n\n        Parameters\n        ----------\n        pvals : np.ndarray, optional\n            Numeric values for the Parameter's that are varying\n        samples: number, optional\n            If the objective has been sampled, how many samples you wish to\n            plot on the graph.\n        parameter: refnx.analysis.Parameter, optional\n            Creates an interactive plot for the Parameter in Jupyter. Requires\n            ipywidgets be installed. Use with %matplotlib notebook\/qt.\n        fig: Figure instance, optional\n            If `fig` is not supplied then a new figure is created. Otherwise\n            the graph is created on the current axes on the supplied figure.\n\n        Returns\n        -------\n        fig, ax : :class:`matplotlib.Figure`, :class:`matplotlib.Axes`\n            `matplotlib` figure and axes objects.\n\n        \"\"\"\n\n        self.setp(pvals)\n\n        if fig is None:\n            import matplotlib.pyplot as plt\n\n            fig = plt.figure()\n            ax = fig.add_subplot(111)\n        else:\n            ax = fig.gca()\n\n        generative_plots = []\n\n        if samples > 0:\n            saved_params = np.array(self.parameters)\n\n            # Get a number of chains, chosen randomly, set the objectives,\n            # and plot the model.\n            for pvec in self.pgen(ngen=samples):\n                self.setp(pvec)\n\n                for objective in self.objectives:\n                    y, y_err, model = objective._data_transform(\n                        model=objective.generative()\n                    )\n\n                    ax.plot(objective.data.x, model, color=\"k\", alpha=0.01)\n\n            # put back saved_params\n            self.setp(saved_params)\n\n        for objective in self.objectives:\n            # add the data (in a transformed fashion)\n            y, y_err, model = objective._data_transform(\n                model=objective.generative()\n            )\n\n            if objective.weighted:\n                ax.errorbar(\n                    objective.data.x,\n                    y,\n                    y_err,\n                    label=objective.data.name,\n                    ms=3,\n                    lw=0,\n                    elinewidth=2,\n                    marker=\"o\",\n                )\n            else:\n                ax.scatter(objective.data.x, y, label=objective.data.name)\n\n            # add the fit\n            generative_plots.append(\n                ax.plot(objective.data.x, model, color=\"r\", lw=1.5, zorder=20)[\n                    0\n                ]\n            )\n\n        if parameter is None:\n            return fig, ax\n\n        # create an interactive plot in a Jupyter notebook.\n        def f(val):\n            if parameter is not None:\n                parameter.value = float(val)\n            for i, objective in enumerate(self.objectives):\n                y, y_err, model = objective._data_transform(\n                    model=objective.generative()\n                )\n\n                generative_plots[i].set_data(objective.data.x, model)\n            fig.canvas.draw()\n\n        import ipywidgets\n\n        return fig, ax, ipywidgets.interact(f, val=float(parameter))\n\n        return fig, ax\n\n\nclass Transform:\n    r\"\"\"\n    Mathematical transforms of numeric data.\n\n    Parameters\n    ----------\n    form : None or str\n        One of:\n\n            - 'lin'\n                No transform is made\n            - 'logY'\n                log10 transform\n            - 'YX4'\n                YX**4 transform\n            - 'YX2'\n                YX**2 transform\n            - None\n                No transform is made\n\n    Notes\n    -----\n    You ask for a transform to be carried out by calling the Transform object\n    directly.\n\n    >>> x = np.linspace(0.01, 0.1, 11)\n    >>> y = np.linspace(100, 1000, 11)\n    >>> y_err = np.sqrt(y)\n    >>> t = Transform('logY')\n    >>> ty, te = t(x, y, y_err)\n    >>> ty\n    array([2.        , 2.2787536 , 2.44715803, 2.56820172, 2.66275783,\n           2.74036269, 2.80617997, 2.86332286, 2.91381385, 2.95904139,\n           3.        ])\n\n    \"\"\"\n\n    def __init__(self, form):\n        types = [None, \"lin\", \"logY\", \"YX4\", \"YX2\"]\n        self.form = None\n\n        if form in types:\n            self.form = form\n        else:\n            raise ValueError(\n                \"The form parameter must be one of [None, 'lin',\"\n                \" 'logY', 'YX4', 'YX2']\"\n            )\n\n    def __repr__(self):\n        return \"Transform({0})\".format(repr(self.form))\n\n    def __call__(self, x, y, y_err=None):\n        \"\"\"\n        Calculate the transformed data\n\n        Parameters\n        ----------\n        x : array-like\n            x-values\n        y : array-like\n            y-values\n        y_err : array-like\n            Uncertainties in `y` (standard deviation)\n\n        Returns\n        -------\n        yt, et : tuple\n            The transformed data\n\n        Examples\n        --------\n        >>> x = np.linspace(0.01, 0.1, 11)\n        >>> y = np.linspace(100, 1000, 11)\n        >>> y_err = np.sqrt(y)\n        >>> t = Transform('logY')\n        >>> ty, te = t(x, y, y_err)\n        >>> ty\n        array([2.        , 2.2787536 , 2.44715803, 2.56820172, 2.66275783,\n               2.74036269, 2.80617997, 2.86332286, 2.91381385, 2.95904139,\n               3.        ])\n\n        \"\"\"\n        return self.__transform(x, y, y_err=y_err)\n\n    def __transform(self, x, y, y_err=None):\n        r\"\"\"\n        Transform the data passed in\n\n        Parameters\n        ----------\n        x : array-like\n\n        y : array-like\n\n        y_err : array-like\n\n        Returns\n        -------\n        yt, et : tuple\n            The transformed data\n        \"\"\"\n\n        if y_err is None:\n            etemp = np.ones_like(y)\n        else:\n            etemp = y_err\n\n        if self.form in [\"lin\", None]:\n            yt = np.copy(y)\n            et = np.copy(etemp)\n        elif self.form == \"logY\":\n            yt, et = EP.EPlog10(y, etemp)\n            if not np.isfinite(yt).all():\n                warnings.warn(\n                    \"Some of the transformed data was non-finite.\"\n                    \" Please check your datasets for points with zero or\"\n                    \" negative values.\",\n                    RuntimeWarning,\n                )\n        elif self.form == \"YX4\":\n            yt = y * np.power(x, 4)\n            et = etemp * np.power(x, 4)\n        elif self.form == \"YX2\":\n            yt = y * np.power(x, 2)\n            et = etemp * np.power(x, 2)\n        if y_err is None:\n            return yt, None\n        else:\n            return yt, et\n\n\ndef pymc3_model(objective):\n    \"\"\"\n    Creates a pymc3 model from an Objective.\n\n    Requires theano and pymc3 be installed. This is an experimental feature.\n\n    Parameters\n    ----------\n    objective: refnx.analysis.Objective\n\n    Returns\n    -------\n    model: pymc3.Model\n\n    Notes\n    -----\n    The varying parameters are renamed 'p0', 'p1', etc, as it's vital in pymc3\n    that all parameters have their own unique name.\n\n    \"\"\"\n    import pymc3 as pm\n    import theano.tensor as tt\n    from refnx._lib._pymc3 import _LogLikeWithGrad\n\n    basic_model = pm.Model()\n\n    pars = objective.varying_parameters()\n    wrapped_pars = []\n    with basic_model:\n        # Priors for unknown model parameters\n        for i, par in enumerate(pars):\n            name = \"p%d\" % i\n            p = _to_pymc3_distribution(name, par)\n            wrapped_pars.append(p)\n\n        # Expected value of outcome\n        try:\n            # Likelihood (sampling distribution) of observations\n            pm.Normal(\n                \"y_obs\",\n                mu=objective.generative,\n                sigma=objective.data.y_err,\n                observed=objective.data.y,\n            )\n        except Exception:\n            # Falling back, theano autodiff won't work on function object\n            theta = tt.as_tensor_variable(wrapped_pars)\n            logl = _LogLikeWithGrad(objective.logl)\n            pm.Potential(\"log-likelihood\", logl(theta))\n\n    return basic_model\n\n\ndef _to_pymc3_distribution(name, par):\n    \"\"\"\n    Create a pymc3 continuous distribution from a Bounds object.\n\n    Parameters\n    ----------\n    name : str\n        Name of parameter\n    par : refnx.analysis.Parameter\n        The parameter to wrap\n\n    Returns\n    -------\n    d : pymc3.Distribution\n        The pymc3 distribution\n\n    \"\"\"\n    import pymc3 as pm\n    import theano.tensor as T\n    from theano.compile.ops import as_op\n\n    dist = par.bounds\n    # interval and both lb, ub are finite\n    if isinstance(dist, Interval) and np.isfinite([dist.lb, dist.ub]).all():\n        return pm.Uniform(name, dist.lb, dist.ub)\n    # no bounds\n    elif (\n        isinstance(dist, Interval)\n        and np.isneginf(dist.lb)\n        and np.isinf(dist.lb)\n    ):\n        return pm.Flat(name)\n    # half open uniform\n    elif isinstance(dist, Interval) and not np.isfinite(dist.lb):\n        return dist.ub - pm.HalfFlat(name)\n    # half open uniform\n    elif isinstance(dist, Interval) and not np.isfinite(dist.ub):\n        return dist.lb + pm.HalfFlat(name)\n\n    # it's a PDF\n    if isinstance(dist, PDF):\n        dist_gen = getattr(dist.rv, \"dist\", None)\n\n        if isinstance(dist.rv, stats.rv_continuous):\n            dist_gen = dist.rv\n\n        if isinstance(dist_gen, type(stats.uniform)):\n            if hasattr(dist.rv, \"args\"):\n                p = pm.Uniform(\n                    name, dist.rv.args[0], dist.rv.args[1] + dist.rv.args[0]\n                )\n            else:\n                p = pm.Uniform(name, 0, 1)\n            return p\n\n        # norm from scipy.stats\n        if isinstance(dist_gen, type(stats.norm)):\n            if hasattr(dist.rv, \"args\"):\n                p = pm.Normal(name, mu=dist.rv.args[0], sigma=dist.rv.args[1])\n            else:\n                p = pm.Normal(name, mu=0, sigma=1)\n            return p\n\n    # not open, uniform, or normal, so fall back to DensityDist.\n    d = as_op(itypes=[T.dscalar], otypes=[T.dscalar])(dist.logp)\n    r = as_op(itypes=[T.dscalar], otypes=[T.dscalar])(dist.rvs)\n    p = pm.DensityDist(name, d, random=r)\n\n    return p\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_343","text":"<filename>DynaMETE_Rfunctions_FlexibleFunctions.py\n'''\nThis file defines all of the necessary functions for DynaMETE, including the transition functions and\nthe structure function R. This function does NOT include sums over n, since it is designed to be a \nmore flexible version incorporating different transition functions. This will be very slow for large N or E.\nIt also defines the METE constraint for beta, which is needed, and a function to obtain mete_lambdas.\n\nTo change the functional form of the transition functions, you need only change f, h, and\/or q, and the \ncorresponding function dfdt, dhdt, and\/or dqdt.\n\nThis version specifically replaces d0\/E_c n\/e^(-1\/3) with d0\/E_c n^2\/e^(-1\/3) to test adding a new degree of\nfreedom in n dependence.\n'''\n\n# Import\nimport numpy as np\nimport pandas as pd\nfrom scipy.optimize import fsolve\nfrom scipy import integrate\n\n# METE functions\ndef beta_constraint(b,s):\n    '''This is the beta constraint in METE with give state variables. Use this as a function call to get beta.\n    Inputs s as state variables, call S, N, or E\n    Also inputs beta\n    outputs beta constraint to minimize'''\n    return b*np.log(1\/(1-np.exp(-b)))-s['S']\/s['N']\n\ndef get_beta(s,b0=0.0001):\n    '''This returns beta from METE. Inputs s as state variables.'''\n    return fsolve(beta_constraint,b0,args=s)[0]\n\ndef mete_lambdas(s,b0=0.0001):\n    '''This returns the METE lambdas for a given set of state variables.\n    Inputs s as state variables, call S, N, or E\n    Optional input of an initial beta, if we know it's going to be somewhere other than small positive.\n    outputs array of lambdas'''\n    beta = get_beta(s,b0)\n    l2 = s['S']\/(s['E']-s['N']) \n    ls = np.array([beta-l2,l2,0,0,0])\n    return ls\n\n# Transition functions\n# The idea here is to make everything easy to change by changing only these functions.\n# For f\ndef fb0(s,p):\n    return p['b0']\ndef fd0(s,p):\n    return -p['d0']*s['E']\/p['Ec']\ndef fm0(s,p):\n    return p['m0']\/s['N']\ndef f(n,e,s,p):\n    '''Transition function for dN\/dt. n and e are microscopic variables.\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu '''\n    return (fb0(s,p)+fd0(s,p)*n)*n\/e**(1\/3)+fm0(s,p)*n\n\n# For h\ndef hw0(s,p):\n    return p['w0']\ndef hd0(s,p):\n    return -p['d0']*s['E']\/p['Ec']\ndef hw10(s,p):\n    b0i=0.0001\n    beta = get_beta(s,b0i)\n    return -p['w10']\/np.log(1\/beta)**(2\/3)\ndef hm0(s,p):\n    return p['m0']\/s['N']\ndef h(n,e,s,p):\n    '''Transition function for dE\/dt. n and e are microscopic variables.\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w1, Ec, or mu '''\n    return (hw0(s,p)+hd0(s,p)*n)*n*e**(2\/3)+hw10(s,p)*n*e+hm0(s,p)*n\n\n# For q\ndef qc(s,p):\n    return p['m0']*np.exp(-p['mu']*s['S']-np.euler_gamma)\ndef qd0(s,p):\n    return -s['S']*p['d0']*s['E']\/p['Ec']\ndef q(n,e,s,p):\n    '''Transition function for dS\/dt. n and e are microscopic variables.\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu\n    For now this doesn't implement speciation models, ie. s1=s2=0'''\n    # Set up kronecker delta in an easy way. Round n to nearest int, if it's 1 then include term\n    # I actually need this to be vectorized, so let's do it slightly differently.\n    # First check if n is scalar\n    if np.isscalar(n):\n        kn1 = int(np.rint(n))==1\n    else:\n        kn1 = np.zeros(len(n))\n        kn_arg = np.where(np.rint(n)==1) \n        # I included the rounded int here because really this kronecker delta can be defined in continuous space\n        # In that case there should also be a correction factor though, but let's ignore that.\n        # The good news here is that below we only pass in arange, which by default passes in integers\n        # So we should be ok as long as we are only using arange for passing in ranges of n\n        # That is because arange rounds the variable it takes in so it can take steps of length 1\n        kn1[kn_arg] = 1\n    return qc(s,p) + qd0(s,p)*kn1\/e**(1\/3)\n\n# Also need derivatives for lambda dynamics. Note that these have to be manually editted for alternate f,h,q\ndef dfdt(n,e,s,p,ds):\n    return fd0(s,p)\/s['E']*ds['dE']*n**2\/e**(1\/3) - fm0(s,p)*ds['dN']\/s['N']*n\n\ndef dhdt(n,e,s,p,ds):\n    return hd0(s,p)\/s['E']*ds['dE']*n**2*e**(2\/3) - hm0(s,p)*ds['dN']\/s['N']*n\n\ndef dqdt(n,e,s,p,ds):\n    # See q for how the kronecker delta works.\n    if np.isscalar(n):\n        kn1 = int(np.rint(n))==1\n    else:\n        kn1 = np.zeros(len(n))\n        kn_arg = np.where(np.rint(n)==1)\n        kn1[kn_arg] = 1\n    return -qc(s,p)*ds['dS']*p['mu'] + qd0(s,p)*(ds['dS']\/s['S']+ds['dE']\/s['E'])*kn1\/e**(1\/3)\n\n# R itself\ndef R(n,e,l,s,p):\n    '''Unnormalized struture function for DynaMETE.\n    n,e are microscopic variables.\n    l are lambdas\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu '''\n    return np.exp(-l[0]*n-l[1]*n*e-l[2]*f(n,e,s,p)-l[3]*h(n,e,s,p)-l[4]*q(n,e,s,p))\n\n# For calculating a single mean with specific powers of n and e\ndef mean_pow(npow,epow,l,s,p,z=1):\n    '''\n    This function returns the mean of n^npow*e^epow over the R function.\n    It is NOT normalized, but it does take in z as an optional argument to normalize.\n    This function uses quad integral over log e for each n then sums over n.\n    Note that npow=epow=0 corresponds to Z, so by default these are not normalized.\n    l are lambdas\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu\n    '''\n    nrange = np.arange(s['N'])+1\n    eint = integrate.quad_vec(lambda loge: np.exp(loge*(1+epow))*R(nrange,np.exp(loge),l,s,p),0,np.log(s['E']))[0]\n    return np.sum(nrange**npow*eint)\/z\n\n# For calculating a covariance with specific powers of n and e for each function\ndef cov_pow(npow,epow,l,s,p,z):\n    '''\n    This function returns the covariance of two functions with the form n^npow*e^epow over the R function.\n    You have to pass in the normalization so that things are faster than calculating normalization each time.\n    npow and epow should both be 2d arrays with the functions.\n    For example, if you want COV(n^2,ne), pass npow=[2,1], epow=[0,1]\n    This function uses quad integral over log e for each n then sums over n.\n    z is the normalization\n    l are lambdas\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu\n    '''\n    nrange = np.arange(s['N'])+1\n    # Get integral over both functions\n    ffeint = integrate.quad_vec(lambda loge: np.exp(loge*(1+np.sum(epow)))*R(nrange,np.exp(loge),l,s,p),0,np.log(s['E']))[0]\n    ff = np.sum(nrange**np.sum(npow)*ffeint)\/z\n    # Get integral over each function\n    f1f2 = 1\n    for nn,ee in zip(npow,epow):\n        feint = integrate.quad_vec(lambda loge: np.exp(loge*(1+ee))*R(nrange,np.exp(loge),l,s,p),0,np.log(s['E']))[0]\n        f1f2 *= np.sum(nrange**nn*feint)\/z\n    return ff-f1f2\n\n# For calculating a single mean over an arbitrary function\n# Use mean_pow for non-functions\ndef mean(func,l,s,p,*args,z=1):\n    '''\n    This function returns the mean of an arbitrary function over the R function.\n    It is NOT normalized, but it does take in z as an optional argument to normalize.\n    Because I put *args first, you have to use z=z0 if you want to put in a normalization.\n    The arbitrary function must take arguments of the form (n,e,s,p) for this to work.\n    This is the form of the f,h, and q functions above.\n    You can pass additional arguments as required for the function (ie. pass ds for df\/dt)\n    To pass in n or n*e, use lambda n,e,s,p: n or lambda n,e,s,p: n*e, or similar.\n    Alternatively, use mean_pow\n    This function uses quad integral over log e for each n then sums over n.\n    l are lambdas\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu\n    z is the normalization\n    '''\n    nrange = np.arange(s['N'])+1\n    # Below is to make this easier for lambda functions, but it isn't worth it. Just require s and p passed, \n    # and let other things be passed as args if needed.\n    # Check if we need args by looking at function passed in\n#    funcargs = func.__code__.co_argcount\n#    if funcargs >= 4:\n#        args = s,p,args\n    eint = integrate.quad_vec(lambda loge: np.exp(loge)*R(nrange,np.exp(loge),l,s,p)*func(nrange,np.exp(loge),s,p,*args),0,np.log(s['E']))[0]\n    return np.sum(eint)\/z\n\n# For calculating a covariance\n# Note if you want to do this with non-functions, use cov_pow\ndef cov(func1,func2,l,s,p,z,*args):\n    '''\n    This function returns the covariance of two arbitrary functions over the R function.\n    You have to pass in the normalization so that things are faster than calculating normalization each time.\n    The arbitrary functions must take arguments of the form (n,e,s,p) for this to work.\n    This is the form of the f,h, and q functions above.\n    You can pass additional arguments as required for the function (ie. pass ds for df\/dt)\n    To pass in n or n*e, use lambda n,e,s,p: n or lambda n,e,s,p: n*e, or similar.\n    This function uses quad integral over log e for each n then sums over n.\n    l are lambdas\n    s are state variables, call S, N, or E\n    p are parameters, call b0, d0, m0, w0, w10, Ec, or mu\n    z is the normalization\n    '''\n    nrange = np.arange(s['N'])+1\n    # Get integral over both functions\n    ffeint = integrate.quad_vec(lambda loge: np.exp(loge)*R(nrange,np.exp(loge),l,s,p)*func1(nrange,np.exp(loge),s,p,*args)*func2(nrange,np.exp(loge),s,p,*args),0,np.log(s['E']))[0]\n    ff = np.sum(ffeint)\/z\n    # Get integral over each function\n    f1f2 = 1\n    for func in [func1,func2]:\n        feint = integrate.quad_vec(lambda loge: np.exp(loge)*R(nrange,np.exp(loge),l,s,p)*func(nrange,np.exp(loge),s,p,*args),0,np.log(s['E']))[0]\n        f1f2 *= np.sum(feint)\/z\n    return ff-f1f2\n    \ndef get_dXdt(l,s,p):\n    '''\n    Returns the time derivatives of the state variables. This makes it easier than calling mean three times\n    every time I want to see the derivatives.\n    Inputs lambdas, state variables, and parameters.\n    Outputs a pandas series of ds.\n    '''\n    # Create storage\n    ds = pd.Series(np.zeros(3),index=['dS','dN','dE'])\n    # To normalize\n    z = mean_pow(0,0,l,s,p)\n    ds['dS'] = mean(q,l,s,p,z=z)\n    ds['dN'] = s['S']*mean(f,l,s,p,z=z)\n    ds['dE'] = s['S']*mean(h,l,s,p,z=z)\n    return ds\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_344","text":"<filename>data_analysis\/Statistical_Analysis.py\nimport cPickle\nimport numpy as np\nimport pandas as pd\nfrom statsmodels.stats import multitest\nfrom scipy.ndimage import gaussian_filter1d\nfrom scipy.stats import mannwhitneyu, binom_test, wilcoxon\n\n\nEXP_NAME = \"XENO_3\"\nPICKLE_DIR = \"\/home\/sam\/Projects\/research_code\/evosoro\/data_analysis\/results\"\n\ninverted = 0\nwith open('{0}\/XENO_3_Robustness_DataFrame_{1}.pickle'.format(PICKLE_DIR, inverted), 'rb') as handle:\n    df = cPickle.load(handle)\nX, Y, Z = df[\"TraceX\"], df[\"TraceY\"], df[\"TraceZ\"]\ntime = df[\"Time\"]\nX, Y, time = X[time < 61], Y[time < 61], time[time < 61]  # only use one minute in silico\nX, Y = (X[:len(X)*25\/32+1]-0.05*4)*2.5, (Y[:len(X)*25\/32+1]-0.05*4)*2.5\n\ninverted = 1\nwith open('{0}\/XENO_3_Robustness_DataFrame_{1}.pickle'.format(PICKLE_DIR, inverted), 'rb') as handle:\n    df_inv = cPickle.load(handle)\nX_inv, Y_inv, Z_inv = df_inv[\"TraceX\"], df_inv[\"TraceY\"], df_inv[\"TraceZ\"]\ntime_inv = df_inv[\"Time\"]\nX_inv, Y_inv, time_inv = X_inv[time_inv < 61], Y_inv[time_inv < 61], time_inv[time_inv < 61]\nX_inv, Y_inv = (X_inv[:len(X_inv)*25\/32+1]-0.05*4)*2.5, (Y_inv[:len(Y_inv)*25\/32+1]-0.05*4)*2.5\n\n\n# vivo_data = pd.read_csv(\"\/home\/sam\/Desktop\/vivo_data.csv\")\nvivo_data = pd.read_csv(\"..\/data_analysis\/vivo_data.csv\")  # additional cardiacBot\n\nvivo_data[\"X\"] -= vivo_data[\"Start_X\"]\nvivo_data[\"Y\"] -= vivo_data[\"Start_Y\"]\n\nX_vivo_inv, Y_vivo_inv = vivo_data[\"X\"][vivo_data[\"Upright\"] == 0], vivo_data[\"Y\"][vivo_data[\"Upright\"] == 0]\nvivo_time_inv = vivo_data[\"Time\"][vivo_data[\"Upright\"] == 0]\nvivo_run_inv = vivo_data[\"Run\"][vivo_data[\"Upright\"] == 0]\nvivo_robot_inv = vivo_data[\"Robot\"][vivo_data[\"Upright\"] == 0]\n\nX_vivo, Y_vivo = vivo_data[\"X\"][vivo_data[\"Upright\"] == 1], vivo_data[\"Y\"][vivo_data[\"Upright\"] == 1]\nvivo_time = vivo_data[\"Time\"][vivo_data[\"Upright\"] == 1]\nvivo_run = vivo_data[\"Run\"][vivo_data[\"Upright\"] == 1]\nvivo_robot = vivo_data[\"Robot\"][vivo_data[\"Upright\"] == 1]\n\n\nvivo_final_dist = []\nrobot = []\nrun = []\n\nfor n in range(1, len(vivo_time)):\n    if vivo_time.values[n] < vivo_time.values[n-1]:\n        vivo_final_dist += [(X_vivo.values[n-1]**2 + Y_vivo.values[n-1]**2)**0.5]\n        robot += [vivo_robot.values[n-1]]\n        run += [vivo_run.values[n-1]]\n\n    if n == len(vivo_time)-1:\n        vivo_final_dist += [(X_vivo.values[n-1]**2 + Y_vivo.values[n-1]**2)**0.5]\n        robot += [vivo_robot.values[n]]\n        run += [vivo_run.values[n]]\n\nvivo_final_dist_inv = []\nrobot_inv = []\nrun_inv = []\n\nfor n in range(1, len(vivo_time_inv)):\n    if vivo_time_inv.values[n] < vivo_time_inv.values[n-1]:\n        vivo_final_dist_inv += [(X_vivo_inv.values[n-1]**2 + Y_vivo_inv.values[n-1]**2)**0.5]\n        robot_inv += [vivo_robot.values[n-1]]\n        run_inv += [vivo_run.values[n-1]]\n\n    if n == len(vivo_time)-1:\n        vivo_final_dist_inv += [(X_vivo_inv.values[n-1]**2 + Y_vivo_inv.values[n-1]**2)**0.5]\n        robot_inv += [vivo_robot.values[n]]\n        run_inv += [vivo_run.values[n]]\n\n\ndiff = []\nfor bot, r, d in zip(robot, run, vivo_final_dist):\n    for bot_inv, r_inv, d_inv in zip(robot_inv, run_inv, vivo_final_dist_inv):\n        if bot == bot_inv:\n            if r == r_inv or (r_inv == 1 and bot < 3):\n                diff += [d-d_inv]\n\nprint len(np.unique(diff))\nprint len(diff), len(run)\np1 = wilcoxon(diff)[1]  # *3\nprint \"vivo \", p1\n\nsilico_final_dist = []\n\nfor n in range(1, len(X)):\n    if time.values[n] < time.values[n-1]:\n        silico_final_dist += [(X.values[n-1]**2 + Y.values[n-1]**2)**0.5]\n\n    if n == len(X)-1:\n        silico_final_dist += [(X.values[n-1]**2 + Y.values[n-1]**2)**0.5]\n\n\nsilico_final_dist_inv = []\n\nfor n in range(1, len(X_inv)):\n    if time_inv.values[n] < time_inv.values[n-1]:\n        silico_final_dist_inv += [(X_inv.values[n-1]**2 + Y_inv.values[n-1]**2)**0.5]\n\n    if n == len(X_inv)-1:\n        silico_final_dist_inv += [(X_inv.values[n-1]**2 + Y_inv.values[n-1]**2)**0.5]\n\n# print len(silico_final_dist), len(silico_final_dist_inv)\n\n# print \"silco 5x4 \", wilcoxon(silico_final_dist, silico_final_dist_inv[:len(silico_final_dist)*4\/5])[1]*3\n\np2 = wilcoxon(silico_final_dist, silico_final_dist_inv)[1]  # *3\nprint \"silco \", p2\n\n# p = []\n# for _ in range(5000):\n#     p += [wilcoxon(silico_final_dist, np.random.choice(silico_final_dist_inv, len(silico_final_dist)))[1]]\n# print \"boot slico \", np.mean(p)*3\n\n\n# print \"vivo \", wilcoxon(vivo_final_dist, vivo_final_dist_inv)[1]*3\n# print \"vivo \", wilcoxon(np.random.choice(vivo_final_dist, len(vivo_final_dist_inv)), vivo_final_dist_inv)[1]*3\n\n# p = []\n# for _ in range(5000):\n#     p += [wilcoxon(vivo_final_dist, np.random.choice(vivo_final_dist_inv, len(vivo_final_dist)))[1]]\n# print \"boot vivo \", np.mean(p)*3\n\n# print \"binom: \", binom_test(4, 5, 0.25)*3  # original 5\np3 = binom_test(5, 6, 0.25)  # *3  # with 6th\nprint \"binom: \", p3  # with 6th\nprint \"fdr: \", multitest.fdrcorrection([p1, p2, p3], alpha=0.0001, method='indep', is_sorted=False)\n\n\n# np.random.choice(vivo_final_dist, )\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_345","text":"import myo\nimport sys\nfrom threading import Thread\nimport time\nimport numpy as np\nimport os\nimport matplotlib\nmatplotlib.use('GTKAgg')\nimport scipy\n\nfrom math import ceil, floor\n\ne = []\nemg_correctmean = []\nemg_filtered = []\nemg_rectified = []\nemg_envelope = []\nnormalized = []\nimport config\ncount =0\nlastLine = \"\"\nimport scipy as sp\nfrom scipy import signal\nlow_pass = 4\nsfreq = 1000\n#delete training data from last run\nfrom sklearn.preprocessing import MinMaxScaler\n\nstart_time = time.time()\n#exit process\ndef buildData(name):\n\tm = myo.Myo(sys.argv[1] if len(sys.argv) >= 2 else None)\n\t_dir = os.path.join('\/home\/venkatesh\/Desktop', 'sub1')\n\n\n\tif not os.path.exists(_dir):\n\t    \tos.makedirs(_dir)\n\n\n\tf = open(\"tra\/sub1\/\" + name + \".txt\", \"a\")\n\n\n\t#Callback for EMG data from Myo (8 words)\n\tdef proc_emg(emg, moving, times=[]):\n\t\tglobal e,emg_correctmean,emg_filtered,emg_rectified,low_pass,sfreq,emg_envelope\n\t\te = emg\n\t\t#emg_correctmean = e - np.mean(e)\n\t\temg_correctmean = scipy.signal.detrend(e)\n\t\thigh = 20\/(1000\/2)\n\t\tlow = 450\/(1000\/2)\n\t\tb, a = sp.signal.butter(4, [high,low], btype='bandpass')\n\t\temg_filtered = sp.signal.filtfilt(b, a, e, method = 'gust')\n\t\temg_rectified = abs(emg_filtered)\n\t\tl = float(low_pass \/ (sfreq\/2))\n\t\tb2, a2 = sp.signal.butter(4, l, btype='lowpass')        \t\n\t\temg_envelope =sp.signal.filtfilt(b2, a2, emg_rectified,method = 'gust')\n\t\temg_envelope = emg_envelope * 100\n\n\n\t\t#print(emg_envelope)\t    \n\n\t#Callback for other motion data, including accelerometer and gycroscope \n\tdef proc_imu(quat, acc, gyro, times=[]):\n\t\tglobal q,a,g,b,t,c,count\n\t\tq = quat \n\t\ta = acc \t\n\t\tg = gyro\n\t\tif count < config.samples:\n\t\t\tif len(emg_envelope) > 0:\n\t\t\t\tc = list(emg_envelope)\n\t\t\t\tprint(str(c) + \"\\n\")\n\t\t\t\tf.write(str(c) + \"\\n\")\n\t\t\t\t#plt.plot(emg_rectified)\n\t\t\t\tcount = count + 1 \n\n\n\tm.connect()\n\tm.add_emg_handler(proc_emg)\n\tm.add_imu_handler(proc_imu)\n\n\tfor x in range(0,config.samples):\n\t\tm.run()\n\tm.disconnect()\n\n\nfor i in range(0,config.numGestures):\n\tthread = Thread(target = buildData, args = (\"s\" + str(i+9), ))\n\tthread.deamon = True\n\tthread.start()\n\tthread.join()\n\n\tprint (\"Next attempt\")\n\tinput(\"Press Enter to continue...\")\n\tcount = 0\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_346","text":"import numpy as np\r\nfrom scipy.interpolate import interp1d\r\n\r\ndef main_sun_fun(time,stellar_mass,tsat_XUV,beta_XUV,fsat):\r\n    \r\n    if stellar_mass == 1.0: \r\n        stellar_data = np.loadtxt('Baraffe3.txt',skiprows=31) # for reproducing sun exactly\r\n    else:\r\n        print (\"This version of code is only set up for solar mass stars\")\r\n        return [time*0,time*0,time*0,time*0]\r\n    \r\n    stellar_array=[]\r\n    for i in range(0,len(stellar_data[:,0])):\r\n        if stellar_data[i,0] == stellar_mass:\r\n            stellar_array.append(stellar_data[i,:])\r\n            \r\n    stellar_array=np.array(stellar_array)\r\n\r\n    min_time = np.min(stellar_array[:,1])\r\n    max_time = np.max(stellar_array[:,1])\r\n    \r\n    if (min_time>np.min(time) ) or (max_time<np.max(time)):\r\n        print (\"Problem: exceeding time range for stellar data\")   \r\n    \r\n    time_array = stellar_array[:,1]\r\n    \r\n    Total_Lum = (10**stellar_array[:,4])\r\n    \r\n    ratio_out = [] # For XUV ratio\r\n    for i in range(0,len(time_array)):\r\n        if time_array[i]<tsat_XUV:\r\n            ratio= fsat\r\n        else:\r\n            ratio = fsat*(time_array[i]\/tsat_XUV)**beta_XUV  \r\n        ratio_out.append(ratio)\r\n  \r\n    XUV_Lum = ratio_out*Total_Lum\r\n    \r\n    Total_fun = interp1d(time_array,Total_Lum)\r\n    XUV_fun = interp1d(time_array,XUV_Lum)\r\n    Relative_total_Lum = Total_fun(time)\r\n    Relative_XUV_lum = XUV_fun(time)\r\n    Absolute_total_Lum = Relative_total_Lum*3.828e26 \r\n    Absolute_XUV_Lum = Relative_XUV_lum*3.828e26\r\n    \r\n    return [Relative_total_Lum,Relative_XUV_lum,Absolute_total_Lum,Absolute_XUV_Lum ]\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_347","text":"\r\nfrom functools import partial\r\nimport copy\r\n\r\nimport numpy as np\r\nfrom scipy import optimize\r\n\r\nDEBUG = False\r\n\r\n\r\nclass Elliptic:\r\n    \"\"\"Generate an orthogonal curvilinear grid by solving the inverse form of\r\n    two laplace equations.\r\n    Source: Basic Structured Grid Generation, <NAME> and <NAME>\r\n    \"\"\"\r\n\r\n    def __init__(self, boundary):\r\n        \"\"\"Summary\r\n\r\n        Args:\r\n            boundary (dictionary): contains x,y-coordinates of all 4 boundaries\r\n        \"\"\"\r\n        self.xw = boundary['west'][0]\r\n        self.yw = boundary['west'][1]\r\n        self.xe = boundary['east'][0]\r\n        self.ye = boundary['east'][1]\r\n        self.xn = boundary['north'][0]\r\n        self.yn = boundary['north'][1]\r\n        self.xs = boundary['south'][0]\r\n        self.ys = boundary['south'][1]\r\n\r\n    def solver(self, solver_type, iterations):\r\n\r\n        # knowns\r\n        f_o = copy.copy(self.f[:, 0])\r\n        u_o = copy.copy(self.u[:, 0])\r\n\r\n        # extra parameters for 'function'\r\n        # are later wrapped with partial\r\n        etamax = copy.copy(self.etamax)\r\n\r\n        #\r\n        def F(unknowns, F_args=[etamax]):\r\n            \"\"\"Summary\r\n\r\n            Args:\r\n                unknowns (np.array): x, y\r\n\r\n            Returns:\r\n                TYPE: Description\r\n            \"\"\"\r\n\r\n            # unknowns\r\n            if DEBUG:\r\n                print('unknowns', unknowns)\r\n\r\n            # (x, y) = unknowns\r\n            x = unknowns[0: etamax]\r\n            y = unknowns[etamax:2 * etamax]\r\n\r\n            eq1 = np.zeros_like(x)\r\n            eq2 = np.zeros_like(x)\r\n\r\n            # boundary conditions\r\n            x[0] = 0.0\r\n            y[0] = 0.0\r\n\r\n            deta = 1.0\r\n            dgsi = 1.0\r\n\r\n            # array slicing for index j\r\n            # [1:] means index j\r\n            # [:-1] means index j-1\r\n\r\n            dxdgsi = (x[1:, :] - x[:-1, :]) \/ (2 * dgsi)\r\n            dydgsi = (y[1:, :] - y[:-1, :]) \/ (2 * dgsi)\r\n            dxdeta = (x[1:, :] - x[:-1, :]) \/ (2 * deta)\r\n            dydeta = (y[1:, :] - y[:-1, :]) \/ (2 * deta)\r\n\r\n            # components of the covariant metric tensor\r\n            g11 = dxdgsi**2 + dydgsi**2\r\n            g22 = dxdeta**2 + dydeta**2\r\n            g12 = dxdgsi * dxdeta + dydgsi * dydeta\r\n\r\n            a = g22 \/ dgsi**2\r\n            b = 2 * g22 \/ dgsi**2 + 2 * g11 \/ deta**2\r\n            c = a\r\n            d = g11 \/ deta**2 * (x[:, :-1] + x[:, 1:]) - \\\r\n                2 * g12 * (x[:-1, :-1] + x[1:, 1:] - x[1:, :-1] - x[:-1, 1:]) \\\r\n                \/ (4 * dgsi * deta)\r\n            e = g11 \/ deta**2 * (y[:, :-1] + y[:, 1:]) - \\\r\n                2 * g12 * (y[:-1, :-1] + y[1:, 1:] - y[1:, :-1] - y[:-1, 1:]) \\\r\n                \/ (4 * dgsi * deta)\r\n\r\n            # Winslow x\r\n            eq1[1:] = -a * x[1:, :] + b * x[:, :] - c * x[:-1, :] - d\r\n\r\n            # Winslow y\r\n            eq2[1:] = -a * y[1:, :] + b * y[:, :] - c * y[:-1, :] - e\r\n\r\n            # boundary conditions make up another 2 equations\r\n            # put them on the 0-th element of all 2 equations\r\n            eq1[0] = x[0]\r\n            eq2[0] = y[0]\r\n\r\n            return np.array([eq1, eq2]).ravel()\r\n\r\n        # initial guess\r\n        guess = np.array([f_o, u_o]).ravel()\r\n\r\n        F_partial = partial(F,\r\n                            F_args=[etamax])\r\n\r\n        solution = optimize.fsolve(F_partial, guess,\r\n                                   full_output=True, xtol=1e-06)\r\n\r\n        solver_message = solution[3]\r\n        print('  Solver: {}'.format(solver_message))\r\n\r\n        return solution, solver_message\r\n\r\n    def shift_profiles(self):\r\n\r\n        self.x[:, 0] = copy.copy(self.solution[0][0 *\r\n                                 self.etamax:1 * self.etamax])\r\n        self.y[:, 0] = copy.copy(self.solution[0][1 *\r\n                                 self.etamax:2 * self.etamax])\r\n\r\n    def main(self, solver_type='fsolve', iterations=10):\r\n\r\n        # initial velocity profile\r\n        self.boundary_conditions()\r\n\r\n        for self.nx in range(1, self.gsimax):\r\n            self.solution, self.solver_message = \\\r\n                self.solver(solver_type, iterations)\r\n            self.shift_profiles()\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_348","text":"## @ingroup Methods-Performance\n# propeller_range_endurance_speeds.py\n#\n# Created: Dec 2020, <NAME>\n# Modified: \n\n# ----------------------------------------------------------------------\n#  Imports\n# ----------------------------------------------------------------------\n\nfrom SUAVE.Core import Data\nimport numpy as np\nimport scipy as sp\n\nimport SUAVE\n\n# ----------------------------------------------------------------------\n#  Propeller Range and Endurance Speeds\n# ----------------------------------------------------------------------\n\n\ndef propeller_range_endurance_speeds(analyses,altitude,CL_max,up_bnd,delta_isa):\n        \"\"\" Computes L\/D max and CL^3\/2 \/ CD max at a given altitude. This runs a mini mission wrapped by an\n        optimizer to find the L\/D max. up_bnd is the fastest airspeed that the optimizer can try. The output is a\n        dictionary containing the maximum values as well as the airspeeds.\n\n        Assumptions:\n        No propulsion source is given\n\n\n        Source:\n        N\/A\n\n\n        Inputs:\n        analyses.atmosphere        [-]\n        analyses.aerodynamics      [-]\n        altitude                   [m]\n        CL_max                     [float]\n        up_bnd                     [m\/s]\n        delta_isa                  [deg C]\n\n        Outputs:\n        results.CL32.air_speed     [m\/s]\n        results.CL32.value         [-]\n        results.L_D_max.air_speed  [m\/s]\n        results.L_D_max.value      [-]\n\n\n        Properties Used:\n        N\/A\n        \"\"\"             \n\n\n        # setup a mission that runs a single point segment without propulsion\n        def mini_mission():\n        \n                # ------------------------------------------------------------------\n                #   Initialize the Mission\n                # ------------------------------------------------------------------\n                mission = SUAVE.Analyses.Mission.Sequential_Segments()\n                mission.tag = 'the_mission'\n        \n                # ------------------------------------------------------------------\n                #  Single Point Segment 1: constant Speed, constant altitude\n                # ------------------------------------------------------------------ \n                segment = SUAVE.Analyses.Mission.Segments.Single_Point.Set_Speed_Set_Altitude_No_Propulsion()\n                segment.tag = \"single_point\" \n                segment.analyses.extend(analyses) \n                segment.altitude              = altitude\n                segment.temperature_deviation = delta_isa\n        \n                # add to misison\n                mission.append_segment(segment)    \n        \n                return mission\n\n        # This is what's called by the optimizer for CL**3\/2 \/CD Max\n        def single_point_3_halves(X):\n\n                # Update the mission\n                mission.segments.single_point.air_speed = X\n\n                # Run the Mission      \n                point_results = mission.evaluate()    \n\n                CL = point_results.segments.single_point.conditions.aerodynamics.lift_coefficient\n                CD = point_results.segments.single_point.conditions.aerodynamics.drag_coefficient\n\n                three_halves = -(CL**(3\/2))\/CD # Negative because optimizers want to make things small\n\n                return three_halves\n\n\n        # This is what's called by the optimizer for L\/D Max\n        def single_point_LDmax(X):\n\n                # Modify the mission for the next iteration\n                mission.segments.single_point.air_speed = X\n\n                # Run the Mission      \n                point_results = mission.evaluate()    \n\n                CL = point_results.segments.single_point.conditions.aerodynamics.lift_coefficient\n                CD = point_results.segments.single_point.conditions.aerodynamics.drag_coefficient\n\n                L_D = -CL\/CD # Negative because optimizers want to make things small\n                \n                return L_D\n\n\n        # ------------------------------------------------------------------\n        #   Run the optimizer to solve\n        # ------------------------------------------------------------------    \n\n        # Setup the a mini mission\n        mission = mini_mission()\n\n        # Takeoff mass:\n        mass = analyses.aerodynamics.geometry.mass_properties.takeoff\n\n        # Calculate the stall speed\n        Vs = stall_speed(analyses,mass,CL_max,altitude,delta_isa)[0][0]\n\n        # The final results to save\n        results = Data()\n\n        # Wrap an optimizer around both functions to solve for CL**3\/2 \/CD max\n        outputs_32 = sp.optimize.minimize_scalar(single_point_3_halves,bounds=(Vs,up_bnd),method='bounded')    \n\n        # Pack the results\n        results.CL32 = Data()\n        results.CL32.air_speed = outputs_32.x\n        results.CL32.value     = -outputs_32.fun[0][0]\n\n        # Wrap an optimizer around both functions to solve for L\/D Max\n        outputs_ld = sp.optimize.minimize_scalar(single_point_LDmax,bounds=(Vs,up_bnd),method='bounded')    \n\n        # Pack the results\n        results.L_D_max = Data()\n        results.L_D_max.air_speed = outputs_ld.x\n        results.L_D_max.value     = -outputs_ld.fun[0][0]    \n\n        return results    \n\n\ndef stall_speed(analyses,mass,CL_max,altitude,delta_isa):\n\n        # Unpack\n        atmo  = analyses.atmosphere \n        S     = analyses.aerodynamics.geometry.reference_area\n        \n        # Calculations\n        atmo_values       = atmo.compute_values(altitude,delta_isa)\n        rho               = atmo_values.density\n        sea_level_gravity = atmo.planet.sea_level_gravity\n        \n        W = mass*sea_level_gravity \n        \n        V = np.sqrt(2*W\/(rho*S*CL_max))\n        \n        return V"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_349","text":"<filename>Python\/pervasiveheartmonitor\/pervasiveheartmonitor.py<gh_stars>10-100\nfrom statistics import mean\ndef is_numeric(txt):\n    try:\n        float(txt)\n        return True\n    except ValueError:\n        return False\n        \nwhile(True):\n    try:\n        line = input().split()\n        print(mean([float(x) for x in line if is_numeric(x)]), \" \".join([x for x in line if x.isalpha()]))\n    except EOFError:\n        break\n    \n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_350","text":"#!\/usr\/bin\/env python3\n\n\"\"\"\nThis module provides the basic lattice model as used in e.g. cluster expansion, lattice dynamics\n\"\"\"\n\n\nimport numpy as np\nimport logging\nimport scipy.sparse\nfrom collections import Counter\n\nfrom .cluster import Cluster\nfrom .atomic_model import AtomicModel\nfrom .util.mathtool import relativePosition\nfrom .util.tool import pad_right, matrix2text\nfrom _c_util import get_structure_ordering\nlogger = logging.getLogger(__name__)\n\n\nclass BasicLatticeModel(AtomicModel):\n    \"\"\"\n        A generic model with variables on the lattice:\n    \"\"\"\n    def __init__(self, prim, raw_clusters, irange=None, **kwargs):\n        \"\"\"\n\n        :param prim:\n        :param raw_clusters:\n        :return:\n        \"\"\"\n        self.clusters = raw_clusters\n        self.prim = prim\n        self.maxorder=kwargs['maxorder']\n        self.proper_range=kwargs['prange']\n        self.cluster_filter = kwargs['filter']\n        self.orbits = None\n        self.imp_range = irange\n\n\n    @classmethod\n    def from_file(cls, prim, clusf, **kwargs):\n        raw = Cluster.read_cluster(prim, clusf)\n        return cls(prim, raw, **kwargs)\n\n\n    def save_clusters(self, fname):\n        self.save_clusters_to_file(self.clusters, fname)\n\n    def save_clusters_to_file(self, clusters, fname):\n        scale = self.prim.lattice._scale\n        elements= self.prim.elements\n        sublat = self.prim.orbit_of_l\n        out_s = []\n        out_ijkl = []\n        for cl in clusters:\n            out_s.append(\"1\\n%.8f\\n%s\\n%s\\n\" % (cl.diameter\/scale, \" \".join([str(i) for i in cl.orders] +\n                                ([str(i[0]) for i in cl.id] if hasattr(cl, 'id') else [])), matrix2text(pad_right(\n                np.array(cl.frac_coords, dtype=object), (cl.order, 5)))))\n            out_ijkl.append(\", \".join([\"%d %d %d %d %s%d\"%tuple(i.tolist()+[elements[i[-1]],sublat[i[-1]]]) for i in cl._ijkls_np]))\n            out_ijkl[-1]+= \"  frac: \"+ matrix2text(cl.frac_coords, ' ')\n            out_ijkl[-1]+= \"  cart: \"+ matrix2text(cl.coords, ' ') \n        open(fname, \"w\").write(\"\\n\".join(out_s))\n        open(fname+'_ijkl', \"w\").write(\"\\n\".join(out_ijkl))\n\n\n    @classmethod\n    def generate_clusters(cls, prim, **kwargs):\n        \"\"\"\n        Generating PROPER clusters.\n        Iteratively generation starting from empty and point clusters\n        :param prim: Primitive cell\n        :return: LDModel with certain clusters\n        \"\"\"\n        sites = kwargs['sites'] if 'sites' in kwargs.keys() else list(range(prim.num_sites))\n        proper_range = kwargs['prange']\n        maxord = max([ord for ord in proper_range.keys() if proper_range[ord]>0])\n        raw= []\n        clus_per_ord = []\n        for ord in range(maxord+1):\n            clus_per_ord = cls.generate_n(prim, ord, proper_range[ord], clus_per_ord, sites)\n            raw.extend(clus_per_ord)\n        return cls(prim, raw, **kwargs)\n\n\n    def generate_improper(self):\n        \"\"\"\n\n        :return: Improper clusters\n        \"\"\"\n        improp = []\n        assert self.imp_range is not None, ValueError('improper range not specified')\n        for ord, cut in self.imp_range.items():\n            if ord <= 1:\n                continue\n            for clus in self.clusters:\n                if (clus.diameter <= cut) and (clus.order< ord) and clus.order >0:\n                    # print(\"extending\", ord, cut, clus)\n                    improp.extend(Cluster.improper_from_proper(clus, ord, self.prim))\n        print(\"  generated %d improper clusters\" %(len(improp)), self.tally_clusters(improp, 2, self.maxorder))\n        self.clusters.extend(improp)\n\n\n    def tally(self, minord=0):\n        return self.tally_clusters(self.clusters, minord, self.maxorder+1)\n\n    @staticmethod\n    def tally_clusters(clusters, minord=0, maxord=0):\n        return dict(Counter([c.order for c in clusters]))\n\n\n    @staticmethod\n    def generate_n(prim, n, cutoff, clus0, sites):\n        \"\"\"\n        Input:\n        prim cell\n        order n\n        cutoff for diameter of clusters\n        clus0 clusters at order n-1\n        :param sites: allowed sites in the primitive cell. Default all sites\n        \"\"\"\n        pts = [[0, 0, 0, l] for l in sites]\n        if n == 0:\n            uc = [Cluster([], prim)]\n        elif n == 1:\n            uc = [Cluster.from_ijkl([pt], prim) for pt in pts]\n            uc = Cluster.remove_equivalent_clusters(uc)\n            #assert len(uc) == prim.n_orb\n        elif n >= 2:\n            print(\"  generating order %d clusters...\"% (n))\n            uc = []\n            for clus in clus0:\n                if clus.diameter > cutoff:\n                    continue\n                ijkl0 = clus.ijkls\n                # each cluster is now sorted by the orbit (sub-lattice) type\n                max_id = prim.orbit_of_l[ijkl0[-1][-1]]\n                sumPts = prim.find_nb_cluster(np.array(clus.ijkls), cutoff)\n                clus_new = []\n                for pt_n in sumPts:\n                    pt = pt_n.tolist()\n                    if not pt[-1] in sites:\n                        continue\n                    if prim.orbit_of_l[pt[-1]] < max_id:\n                        continue\n                    if pt in ijkl0:\n                        continue\n                    clusSum = clus.append_site(pt)\n                    if clusSum.diameter > cutoff:\n                        continue\n                    clus_new.append(clusSum)\n                clus_new = Cluster.remove_equivalent_clusters(clus_new)\n                uc.extend(clus_new)\n            uc = Cluster.remove_equivalent_clusters(uc)\n        return uc\n\n\n\n\n\n    def __str__(self):\n        if self.orbits is None:\n            outs= [\"  No.  ord uniq  diam\"]\n            for i, c in enumerate(self.clusters):\n                outs.append(\"%4d %4d %4d %9.5f\" % (i, c.order, c.order_uniq, c.diameter))\n            return \"\\n\".join(outs)\n        else:\n            outs= [\"  No.  ord  uniq mult  diam\"]\n            for i, orb in enumerate(self.orbits):\n                c = orb.cluster\n                outs.append(\"%5d %4d %4d %4d %9.5f\" % (i, c.order, c.order_uniq, len(orb.clusters), c.diameter))\n            return \"\\n\".join(outs)\n\n\n    def cleanup(self):\n        \"\"\"\n        1. filter through clusters\n        2. move first atoms of each cluster to primitive cell\n        3. sort clusters\n        :return:\n        \"\"\"\n        self.clusters= list(filter(self.cluster_filter, self.clusters))\n        for i in range(len(self.clusters)):\n            self.clusters[i].move_to_prim()\n        self.clusters.sort()\n\n\n    def l_point_cls(self):\n        return [orb.cluster.ijkls[0][-1] for orb in self.orbits if orb.cluster.order==1]\n\n\n\n    def symmetrize(self):\n        self.Cmat = scipy.sparse.identity(self.ncorr_full)\n\n\n    @property\n    def ncorr(self): return self.Cmat.shape[0]\n\n\n    def prepare_index_full(self):\n    # implementations should set the number of correlations for each cluster. \n    # by default set to 1 per cluster\n        for orb in self.orbits:\n            if orb.ncorr_full<0:\n                print(\"WARNING: ncorr_full NOT set for cluster and set to 1:\",orb.cluster)\n                orb.ncorr_full = 1\n        self.orb_idx_full=np.cumsum([0]+[orb.ncorr_full for orb in self.orbits])\n        self.ncorr_full= self.orb_idx_full[-1]\n\n\n    def prepare_index(self):\n        npara_ord = [0]*(self.maxorder+1)\n        for orb in self.orbits:\n            npara_ord[orb.cluster.order]+= orb.ncorr_full\n        self.ord_idx=np.cumsum([0]+npara_ord)\n        self.orb_idx=self.orb_idx_full\n\n\n    def get_orbit_isotropy(self):\n        \"\"\"\n        1. Find orbit of each cluster, modulus lattice translation\n        2. Find isotropy group of each representative (first) cluster of an orbit\n        :return: list of [orbit, isotropy]\n            orbit is a list of Clusters\n            isotropy is list of [ig, relativePos]\n                ig = symmop index\n                relativePos indexing function under this symmop\n        \"\"\"\n        if self.orbits is None:\n            self.orbits = Cluster.clusters_to_orbit_isotropy(self.prim, self.clusters)\n        return self.orbits\n\n\n    def translate_to_supercell(self, sc, orb_idx=None, clus_idx=None):\n        \"\"\"\n\n        :param sc: SupercellStructure\n        :return: all clusters in the supercell. Each cluster is give as\n                [list of the indices of the vertices, i.d. of orbit, i.d. of symop]\n        orb_idx: default (None) to process all; explicit e.g. [0, 3, 5] to process selected few\n        clus_idx: default (None) to process all; explicit e.g. [0] to process selected few\n        \"\"\"\n        # natom = self.prim.num_sites\n\n        # def match_ordering(l1, l2):\n        #     \"\"\"\n        #     ordering such that l1[ordering] == l2\n        #     \"\"\"\n        #     n= len(l1)\n        #     ordering = list(range(n))\n\n\n        orb_range = orb_idx if orb_idx is not None else range(len(self.orbits))\n        allclus = []\n        for iorb in orb_range:\n            orbit = self.orbits[iorb]\n            clus_range = clus_idx if clus_idx is not None else range(len(orbit.clusters))\n            for ic in clus_range:\n                clus = orbit.clusters[ic]\n                ig = orbit.clusters_ig[ic]\n                allclus.extend([cx, iorb, ig, ic] for cx in self.translate_cluster_to_supercell(sc, clus))\n        return allclus\n\n    @staticmethod\n    def translate_cluster_to_supercell(sc, clus):\n        \"\"\"\n\n        :param sc: SupercellStructure\n        :return: all clusters in the supercell\n        \"\"\"\n        if clus.order == 0:\n            return [[]]*sc.n_cell\n        coords= clus.frac_coords\n        use_compiled_code = True\n        if use_compiled_code:\n            from f_util import f_util\n            allclus= f_util.tr_cl_sc(sc._ijkl.T, sc.sc_mat.T, sc.inv_sc_mat.T, sc.sc_ref.T, sc.prim.frac_coords.T, clus._ijkls_np.T).T-1\n        else:\n            allclus = [get_structure_ordering((coords+ijk[None,:]).dot(sc.inv_sc_mat), sc.frac_coords,0) for ijk in sc.ijk_ref]\n        return allclus\n\n\n    def identify_cluster(self, clus_in):\n        \"\"\"\n        Find if and which the input cluster matches the model clusters\n        :param clus_try:\n        :return: [matched cluster, iorb, ig, clus_sorted]\n        \"\"\"\n        for iorb, orb in enumerate(self.orbits):\n            # Quick return if not match obviously *)\n            if orb.cluster._must_differ(clus_in):\n                continue\n            # logger.debug(\"  proceed with %d\"%(iorb))\n            for ic, clus_match in enumerate(orb.clusters):\n                [flag, foundOrb] = clus_match.equivalent_by_lattranslation(clus_in.ijkls)\n                if flag:\n                    ig = orb.clusters_ig[ic]\n                    # logger.debug(\"debug>  sum \"+repr(clus_in)+\" == orbit %d cluster %d sym %d matching=\"%(iorb, ic, ig) +str(foundOrb))\n                    # logger.debug(\" calc FC Trans mem=\")#, MemoryInUse()\/1E6)\n                    return [True, iorb, ic, ig, relativePosition(clus_match.ijkls, foundOrb, dim=len(clus_in.orders))]\n        return [False, -1, -1, None, None]\n\n\n    def load_solution(self, sol_f):\n        return np.loadtxt(sol_f, ndmin=2)\n\n\n    def process_name_ord(self, name_ord, all_ord):\n        if len(name_ord) == 0:\n            name_ord = [['All', all_ord]]\n        else:\n            for i in name_ord:\n                try:\n                    i[1]= list(map(int, i[1]))\n                except:\n                    continue\n                if i[0][-6:].lower()=='except':\n                    i[1] = [j for j in all_ord if j not in i[1]]\n                else:\n                    i[1] = [j for j in i[1] if j in all_ord]\n        return name_ord\n\n\n    def get_submodels(self, name_ord, knownsol=None, **kwargs):\n        \"\"\"\n        :param name_ord: list of [name, fct order], e.g. pair 0,2\n                         or [name, filename] where filename is a matrix\n        :return: list of [name, matrix] defining the different fittings\n        \"\"\"\n        def down_select(o, sol0):\n            if isinstance(o, list):\n                return sum([list(range(self.ord_idx[i], self.ord_idx[i+1])) for i in o if i<=self.maxorder], [])\n            elif o=='except-known':\n                return np.where(sol0==0)[0]\n            else:\n                return np.loadtxt(o).reshape((-1))\n\n        all_ord=list(set([o.cluster.order for o in self.orbits]))\n        name_ord = self.process_name_ord(name_ord, all_ord)\n        print(\"No. of parameters\", {o: self.ord_idx[o+1]-self.ord_idx[o] for o in range(self.maxorder+1)})\n        sol0 = np.zeros(self.ncorr)\n        if knownsol:\n             print(\"  Reading previous solution from %s\"%(knownsol))\n             input_sol = self.load_solution(knownsol).reshape(-1)\n             sol0[:min(sol0.size, input_sol.size)] = input_sol[:min(sol0.size, input_sol.size)]\n        return [[nm,\n                scipy.sparse.identity(self.ncorr).tocsr()[:,\n                  down_select(o, sol0)], sol0]\n                for (nm, o) in name_ord]\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_351","text":"from sympy import zeros, symbols\nfrom lie_algebra import adf_g, lie_diff\nfrom sympy.printing import sstr\n\n\ndef from_control_affine_form(state_evolution, input_field, states):\n    return ControlSystem(state_evolution, input_field, states)\n\n\nclass ControlSystem:\n    def __init__(self, f, g, x):\n        self.f = f\n        self.g = g\n        self.x = x\n\n    def controllability_matrix(self):\n        n = len(self.f)\n        C = zeros(n)\n        for i in range(n):\n            C[:, i] = adf_g(self.f, self.g, self.x, i)  # TODO: improve performance\n        return C\n\n    def find_dependency(self):\n        n = len(self.f)\n        c = zeros(n, 1)\n        c[n - 1] = symbols('\\phi')\n        sol = (self.controllability_matrix().T).inv() * c\n        j = None\n        for i in range(n):\n            if sol[i] != 0:\n                j = i\n        return self.x[j]\n\n    def transformation(self):\n        n = len(self.f)\n        T = zeros(n, 1)\n        T[0] = self.find_dependency()\n        for i in range(1, n):\n            T[i] = lie_diff(T[i - 1], self.f, self.x)\n        return T\n\n    def beta(self):\n        T = self.transformation()\n        Lg_Tn = lie_diff(T[-1], self.g, self.x)\n        return 1 \/ Lg_Tn\n\n    def alpha(self):\n        T = self.transformation()\n        Lf_Tn = lie_diff(T[-1], self.f, self.x)\n        return self.beta() * Lf_Tn\n\n\n    def __str__(self):\n        return 'System(\\n' + sstr(self.f) + ',\\n' \\\n               + sstr(self.g) + ')'\n\n    def __repr__(self):\n        return sstr(self)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_338","text":"<filename>ratter\/material.py<gh_stars>0\nimport sympy as sp\n\n\nclass Material(object):\n    def __init__(self, name, refractive_index_value=None):\n        self.name = name\n        self.n_symbol = sp.Symbol(\"n_\"+name)\n        self.n_value = refractive_index_value\n\n    @property\n    def substitutions(self):\n        if self.n_value is None:\n            return []\n        else:\n            return [(self.n_symbol, self.n_value)]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_341","text":"<reponame>rgerkin\/psiz\n# -*- coding: utf-8 -*-\n# Copyright 2020 The PsiZ Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"Module for testing models.py.\"\"\"\n\nimport pytest\n\nimport numpy as np\nfrom scipy.stats import pearsonr\nimport tensorflow as tf\n\nimport psiz\n\n# model_inferred_best = {}\n        # val_loss_best = np.inf\n        # for i_restart in range(n_restart):\n        #     model_inferred = build_model(n_stimuli, n_dim)\n        #     model_inferred.compile(**compile_kwargs)\n\n        #     model_inferred.fit(\n        #         ds_obs_train, validation_data=ds_obs_val, epochs=epochs,\n        #         callbacks=callbacks, verbose=0\n        #     )\n\n        #     # d_train = model_inferred.evaluate(ds_obs_train, return_dict=True)\n        #     d_val = model_inferred.evaluate(ds_obs_val, return_dict=True)\n        #     # d_test = model_inferred.evaluate(ds_obs_test, return_dict=True)\n\n        #     if d_val['loss'] < val_loss_best:\n        #         val_loss_best = d_val['loss']\n        #         model_inferred_best = model_inferred\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_416","text":"<reponame>herrlich10\/mripy\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\nfrom __future__ import print_function, division, absolute_import, unicode_literals\nimport time\nimport numpy as np\nfrom scipy import optimize, stats\nfrom deepdish import io as dio\nfrom . import utils, math\n\n\ndef basis_vanBergen2015(s, n_channels=8, power=5):\n    '''\n    Parameters\n    ----------\n    s : 1D array, n_trials\n    \n    Returns\n    -------\n    fs : 2D array, n_channels * n_trials\n\n    References\n    ----------\n    {van Bergen2015}\n    '''\n    phi = np.arange(0, np.pi, np.pi\/n_channels)\n    fs = np.maximum(0, np.cos(2 * (s[np.newaxis,:] - phi[:,np.newaxis])))**power # n_channels * n_trials\n    return fs\n\n\ndef basis_Sprague2013(s, n_channels=6, spacing=2, center=None, size=None, power=7, dim=1, intercept=False):\n    '''\n    Parameters\n    ----------\n    s : 2D array, n_trials * dim | 1D array, n_trials\n    \n    Returns\n    -------\n    fs : 2D array, n_channels * n_trials\n\n    References\n    ----------\n    {Sprague2013}\n    '''\n    if size is None:\n        size = 5.8153\/2.0940 * spacing # Ratio is chosen to avoid high corr between channels while accomplish smooth recon\n    if center is None:\n        center = 0\n    centers = (np.arange(n_channels) - (n_channels-1)\/2) * spacing + center\n    if dim == 1:\n        r = np.abs(s[np.newaxis,:] - centers[:,np.newaxis]) # Distance from filter’s center\n    elif dim == 2:\n        X, Y = np.meshgrid(centers, centers)\n        centers = np.c_[X.ravel(), Y.ravel()] # 2D channel array is serialized in row-first order\n        r = np.linalg.norm(s.T[np.newaxis,...] - centers[...,np.newaxis], axis=1)\n    fs = np.where(r<size, (0.5*np.cos(r\/size*np.pi) + 0.5)**power, 0) # n_channels * n_trials\n    if intercept:\n        fs = np.vstack([fs, np.ones(len(s))]) # Learnable bias\n    return fs\n\n\nclass BaseModel(utils.Savable2):\n    # get_params() is required by sklearn\n    def get_params(self, deep=True):\n        raise NotImplementedError('** You must implement this method by yourself in your model.') # Abstrast method\n\n    # set_params() is required by sklearn\n    def set_params(self, **parameters):\n        for parameter, value in parameters.items():\n            setattr(self, parameter, value)\n        return self\n\n    def to_dict(self):\n        return {k: v for k, v in self.__dict__.items() if k.endswith('_')}\n\n    def from_dict(self, d):\n        self.__dict__.update(d)\n        return self\n\n\nclass ChannelEncodingModel(BaseModel):\n    def __init__(self, n_channels, basis_func, stimulus_domain, circular=False, verbose=2):\n        '''\n        After (Brouwer et al., 2009).\n        '''\n        self.n_channels = n_channels\n        self.basis_func = basis_func\n        self.stimulus_domain = stimulus_domain\n        self.circular = circular\n        self.verbose = verbose\n\n    # get_params() is required by sklearn\n    def get_params(self, deep=True):\n        return dict(n_channels=self.n_channels, basis_func=self.basis_func, \n            stimulus_domain=self.stimulus_domain, circular=self.circular)\n\n    def fit(self, X, y):\n        '''\n        Parameters\n        ----------\n        X : 2D array\n            n_trials * n_voxels BOLD response pattern\n            (e.g., beta for each trial, or delayed and detrended time points within block plateau)\n        y : 1D array\n            n_trials stimulus value (e.g., orientation, color)\n        '''\n        b = X.T # Voxel BOLD response, n_voxels * n_trials\n        s = y # Stimulus, n_trials\n        fs = self.basis_func(s) # Channel response, n_channels * n_trials\n        # Step 1: Estimate W by OLS regression\n        W = b @ fs.T @ math.pinv(fs @ fs.T) # Weight, n_voxels * n_channels\n        # Store params\n        self.W_ = W\n        return self # Required by sklearn\n\n    def predict(self, X, stimulus_domain=None, return_all=False):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        channel_resp = self.inverted_encoding(X) # n_trials * n_channels\n        evidence = self.correlation_inversion(X, stimulus_domain=None) # n_trials * n_domain\n        # y_map = stimulus_domain[np.argmax(evidence, axis=1)] # n_trials\n        y_map = stimulus_domain[math.median_argmax(evidence, axis=1)] # n_trials\n        # y_mean = np.sum(stimulus_domain * evidence, axis=1) \/ np.sum(evidence, axis=1) # n_trials\n        # y_std = np.sqrt(np.sum((stimulus_domain[np.newaxis,:] - y_mean[:,np.newaxis])**2 * evidence, axis=1) \\\n        #     \/ np.sum(evidence, axis=1)) # n_trials\n        # return (y_mean, y_std, y_map, evidence, channel_resp) if return_all else y_mean\n        return (y_map, evidence, channel_resp) if return_all else y_map\n\n    _pidx = 1 # Index of posterior (for MAP) if return_all\n\n    def pRF(self, stimulus_domain=None, method='ols', X=None, y=None):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        fs_domain = self.basis_func(stimulus_domain) # n_channels * n_domain\n        if method == 'ols':\n            pRF = self.W_ @ fs_domain # n_voxels * n_domain\n        elif method == 'ridge': \n            # After {Sprague2013}, to ensure that most of the pRFs were sufficiently unimodal\n            # However, the method doesn't seem to help much in my simulation...\n            b = X.T # Voxel BOLD response, n_voxels * n_trials\n            s = y # Stimulus, n_trials\n            fs = self.basis_func(s) # Channel response, n_channels * n_trials\n            n_trials = len(s) \n            # Find best lambda according to BIC\n            Ws = []\n            BICs = []\n            for lambda_ in np.logspace(-3, 3, 19):\n                M = fs.T @ math.pinv(fs @ fs.T + lambda_ * np.eye(self.n_channels)) # n_trials * n_channels\n                W = b @ M # Weight, n_voxels * n_channels\n                H = M @ fs # Projection (or \"hat\") matrix, n_trials * n_trials\n                df = np.trace(H) # Degrees of freedom for ridge (less than the number of predictors as in OLS)\n                RSS = np.sum((b @ H - b)**2) # Residual sum of squares\n                BIC = n_trials * np.log(RSS) + df * np.log(n_trials) # Scaling problem???\n                Ws.append(W)\n                BICs.append(BIC)\n            W_opt = Ws[np.argmin(BICs)]\n            pRF = W_opt @ fs_domain\n        return pRF # n_voxels * n_domain\n        \n    def inverted_encoding(self, X):\n        b = X.T # Voxel BOLD response, n_voxels * n_trials\n        fs = math.pinv(self.W_.T @ self.W_) @ self.W_.T @ b # Inverted channel response, n_channels * n_trials\n        return fs.T # n_trials * n_channels\n\n    def voxel_inversion(self, X, stimulus_domain=None):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        recon = X @ self.pRF(stimulus_domain=stimulus_domain) # n_trials * n_domain\n        recon \/= X.shape[1] # \/ n_voxels\n        return recon\n\n    def channel_inversion(self, X, stimulus_domain=None):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        fs_domain = self.basis_func(stimulus_domain) # n_channels * n_domain\n        fs_data = self.inverted_encoding(X) # n_trials * n_channels\n        recon = fs_data @ fs_domain # n_trials * n_domain\n        return recon\n\n    def correlation_inversion(self, X, stimulus_domain=None):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        # Iterate every possible stimulus in the domain\n        fs_domain = self.basis_func(stimulus_domain) # n_channels * n_domain\n        # Inverted encoding\n        fs_data = self.inverted_encoding(X) # n_trials * n_channels\n        # Correlation as evidence (similar to likelihood)\n        n_trials, n_domain = fs_data.shape[0], fs_domain.shape[1]\n        evidence = np.zeros([n_trials, n_domain]) # n_trials * n_domain\n        for tid in range(n_trials):\n            for did in range(n_domain):\n                evidence[tid,did] = np.corrcoef(fs_data[tid,:], fs_domain[:,did])[0,1]\n        return evidence\n\n\nclass BayesianChannelModel(BaseModel):\n    def __init__(self, n_channels='required', basis_func='required', stimulus_domain='required', circular=False, stimulus_prior=None, global_search=False, verbose=2):\n        '''\n        After (<NAME> et al., 2015).\n\n        Examples\n        --------\n        from mripy import encoding\n        from sklearn import model_selection, preprocessing, pipeline\n\n        stimulus_domain = np.linspace(0, pi, 181)\n        n_channels = 8\n        basis_func = lambda s: encoding.basis_vanBergen2015(s, n_channels=n_channels)\n        model = encoding.BayesianChannelModel(n_channels=n_channels, \n            basis_func=basis_func, stimulus_domain=stimulus_domain, circular=True)\n        model = pipeline.make_pipeline(preprocessing.StandardScaler(), model)\n        cv = model_selection.LeaveOneGroupOut() # One group of each run\n        y_hat = model_selection.cross_val_predict(model, X, y, groups, cv=cv, n_jobs=1)\n        '''\n        self.n_channels = n_channels\n        self.basis_func = basis_func\n        self.stimulus_domain = stimulus_domain\n        self.circular = circular\n        self.stimulus_prior = 1 if stimulus_prior is None else stimulus_prior # TODO: This should be refactored for CV\n        self.global_search = global_search\n        self.verbose = verbose\n\n    # get_params() is required by sklearn\n    def get_params(self, deep=True):\n        return dict(n_channels=self.n_channels, basis_func=self.basis_func, stimulus_domain=self.stimulus_domain,\n            circular=self.circular, stimulus_prior=self.stimulus_prior, global_search=self.global_search)\n\n    def fit(self, X, y):\n        '''\n        Parameters\n        ----------\n        X : 2D array\n            n_trials * n_voxels BOLD response pattern\n            (e.g., beta for each trial, or delayed and detrended time points within block plateau)\n        y : 1D array\n            n_trials stimulus value (e.g., orientation, color)\n        '''\n        b = X.T # Voxel BOLD response, n_voxels * n_trials\n        s = y # Stimulus, n_trials\n        fs = self.basis_func(s) # Channel response, n_channels * n_trials\n        # Step 1: Estimate W by OLS regression\n        # W = b @ fs.T @ np.linalg.inv(fs @ fs.T) # Weight, n_voxels * n_channels\n        # It is critical to use pinv() here instead of inv():\n        # 1) Result in much more accurate estimation for W, and hence tau, rho, sigma\n        # 2) Avoid \"LinAlgError: Singular matrix\" at `inv(fs @ fs.T)`\n        # 3) Avoid negative negloglikelihood (i.e., negative `slogdet(Omega)`) \n        #    and non positive semidefinite `Omega` (i.e., `all(eigvals(Omega)>0) == False`), \n        #    which could occur with randn W\n        # Note that Gilles used `np.linalg.lstsq()` here, which should be numerically adept.\n        W = b @ fs.T @ math.pinv(fs @ fs.T) # Weight, n_voxels * n_channels\n        # Store params\n        self.W_ = W\n        # Step 2: Estimate tau, rho, sigma by ML optimization (gradient-based)\n        z = b - W @ fs # n_voxels * n_trials\n        # Initial params\n        tau0 = np.std(b, axis=1)\n        rho0 = np.mean(np.corrcoef(b)[np.triu_indices(len(tau0), k=1)])\n        sigma0 = np.mean(np.std(fs, axis=1))\n        params0 = np.r_[tau0, rho0, sigma0\/5.0]\n        # bounds = np.c_[np.ones(len(params0))*1e-4, np.r_[tau0*5, 1, sigma0*5]]\n        bounds = np.c_[np.ones(len(params0))*1e-3, np.r_[tau0*5, 0.99, sigma0*5]]\n        # Conjugate gradient algorithm, due to lack of support for bounds, requires multi-start to avoid\/alleviate being trapped in local minima.\n        if self.verbose > 0:\n            print('>> Start maximum likelihood optimization...')\n        if self.global_search:\n            def accept_test(f_new, x_new, f_old, x_old):\n                Omega = self._calc_Omega(self.W_, x_new[:-2], x_new[-2], x_new[-1])\n                # is_pos_semi_def = np.all(np.linalg.eigvals(Omega) > 0)\n                # return (f_new < f_old and f_new > 0 and is_pos_semi_def)\n                is_singular = np.linalg.matrix_rank(Omega, hermitian=True) < Omega.shape[0]\n                return (f_new < f_old and f_new > 0 and not is_singular)\n            res = optimize.basinhopping(self._negloglikelihood, params0, accept_test=accept_test, \n                minimizer_kwargs=dict(args=(z, W), method='L-BFGS-B', jac=self._negloglikelihood_prime, bounds=bounds))\n        else:\n            class Counter(object):\n                def __init__(self, model, args):\n                    self.count = 0\n                    self.last_time = time.time()\n                    self.model = model\n                    self.args = args\n                def step(self, xk):\n                    self.count += 1\n                    # cost = self.model._negloglikelihood(xk, *self.args) # The pinv->svd here is too expensive...\n                    curr_time = time.time()\n                    duration = curr_time - self.last_time\n                    self.last_time = curr_time\n                    if self.model.verbose > 1:\n                        # print(f\"iter#{self.count:03d} ({utils.format_duration(duration)}): cost={cost:.4f}, tau[-3:]={xk[-5:-2]}, rho={xk[-2]:.4f}, sigma={xk[-1]:.4f}\")\n                        print(f\"iter#{self.count:03d} ({utils.format_duration(duration)}): tau[-3:]={xk[-5:-2]}, rho={xk[-2]:.4f}, sigma={xk[-1]:.4f}\")\n                    elif self.model.verbose == 1:\n                        print(f\"iter#{self.count:03d} ({utils.format_duration(duration)}): tau[-3:]={xk[-5:-2]}, rho={xk[-2]:.4f}, sigma={xk[-1]:.4f}\", end='\\r')\n            # res = optimize.minimize(self._negloglikelihood, params0, args=(z, W), method='L-BFGS-B', \n            #     jac=self._negloglikelihood_prime, bounds=bounds, callback=Counter(model=self, args=(z, W)).step)\n            res = optimize.minimize(self._negloglikelihood, params0, args=(z, W, True), method='L-BFGS-B', \n                jac=True, bounds=bounds, callback=Counter(model=self, args=(z, W)).step)\n        params = res.x\n        if self.verbose > 0:\n            print(f\"cost={res.fun}, iter={res.nit}, func_eval={res.nfev}, success={res.success}, {res.message}\")\n            print(params0[-3:], '-->', params[-3:])\n        # Store params\n        self.tau_, self.rho_, self.sigma_ = params[:-2], params[-2], params[-1]\n        self._Omega = self._calc_Omega(self.W_, self.tau_, self.rho_, self.sigma_)\n        self._Omega_inv = math.pinv(self.Omega_) # Update cache\n        return self # Required by sklearn\n\n    # Cache backed properties (the \"if else\" construct is to prevent unnecessary expression evaluation)\n    Omega_ = property(lambda self: self.__dict__.setdefault('_Omega', None if hasattr(self, '_Omega') else self._calc_Omega(self.W_, self.tau_, self.rho_, self.sigma_)))\n    Omega_inv_ = property(lambda self: self.__dict__.setdefault('_Omega_inv', None if hasattr(self, '_Omega_inv') else math.pinv(self.Omega_)))\n\n    def predict(self, X, stimulus_domain=None, stimulus_prior=None, return_all=False):\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        stimulus_prior = self.stimulus_prior if stimulus_prior is None else stimulus_prior\n        posterior = self.bayesian_inversion(X, stimulus_domain=stimulus_domain, stimulus_prior=stimulus_prior) # n_trials * n_domain\n        y_map = stimulus_domain[np.argmax(posterior, axis=1)] # n_trials\n        # y_map = stimulus_domain[math.median_argmax(posterior, axis=1)] # n_trials\n        if self.circular:\n            y_mean = math.circular_mean(stimulus_domain, domain=stimulus_domain, weight=posterior, axis=1)\n            y_std = math.circular_std(stimulus_domain, domain=stimulus_domain, weight=posterior, axis=1)\n        else:\n            y_mean = np.sum(stimulus_domain * posterior, axis=1) \/ np.sum(posterior, axis=1) # n_trials\n            y_std = np.sqrt(np.sum((stimulus_domain[np.newaxis,:] - y_mean[:,np.newaxis])**2 * posterior, axis=1) \\\n                \/ np.sum(posterior, axis=1)) # n_trials\n        return (y_mean, y_std, y_map, posterior) if return_all else y_mean\n\n    _pidx = 3 # Index of posterior (for MAP) if return_all\n\n    def loglikelihood(self, X, y):\n        b = X.T\n        s = y\n        fs = self.basis_func(s)\n        z = b - self.W_ @ fs\n        return self._calc_L(z, self.W_, self.tau_, self.rho_, self.sigma_)\n\n    def bayesian_inversion(self, X, stimulus_domain=None, stimulus_prior=None, density=True):\n        '''\n        Parameters\n        ----------\n        X : 2D array, n_trials * n_voxels\n        stimulus_domain : 1D array, n_domain\n        stimulus_prior : 2D array, n_trials * n_domain (or 1D array, n_domain)\n            None for a flat stimulus prior, same for all trials.\n\n        Returns\n        -------\n        posterior : 2D array, n_trials * n_domain\n        '''\n        stimulus_domain = self.stimulus_domain if stimulus_domain is None else stimulus_domain\n        stimulus_prior = self.stimulus_prior if stimulus_prior is None else stimulus_prior\n        b = X.T[:,np.newaxis,:] # n_voxels * n_domain * n_trials\n        fs = self.basis_func(stimulus_domain) # n_channels * n_domain\n        predicted_mean_resp = (self.W_ @ fs)[...,np.newaxis] # n_voxels * n_domain * n_trials\n        z = b - predicted_mean_resp\n        # # mv_norm = stats.multivariate_normal(np.zeros(self.Omega_.shape[0]), self.Omega_)\n        # mv_norm = stats.multivariate_normal(np.zeros(self.Omega_.shape[0]), self.Omega_, allow_singular=True)\n        # # likelihood = mv_norm.pdf(z.T) # n_trials * n_domain\n        # # posterior = likelihood * stimulus_prior # n_trials * n_domain\n        # # posterior \/= np.sum(posterior, axis=1, keepdims=True)\n        # # The above code will underflow\n        # loglikelihood = mv_norm.logpdf(z.T) # n_trials * n_domain\n        # The following implementation is 10x faster than stats.multivariate_normal:D\n        loglikelihood = math.gaussian_logpdf(z.T, np.zeros(self.Omega_.shape[0]), self.Omega_, cov_inv=self.Omega_inv_) # n_trials * n_domain\n        logposterior = loglikelihood + np.log(stimulus_prior) # n_trials * n_domain\n        posterior = math.normalize_logP(logposterior, axis=1)\n        if density:\n            posterior \/= stimulus_domain[-1] - stimulus_domain[0]\n        return posterior\n\n    def _negloglikelihood(self, params, z, W, return_prime=False):\n        tau, rho, sigma = params[:-2], params[-2], params[-1]\n        if not return_prime:\n            return -self._calc_L(z, W, tau, rho, sigma)\n        else:\n            Omega = self._calc_Omega(W, tau, rho, sigma)\n            Omega_inv = math.pinv(Omega) # np.linalg.pinv() may encounter \"LinAlgError: SVD did not converge\" for some matrices\n            L = -self._calc_L(z, W, tau, rho, sigma, Omega=Omega, Omega_inv=Omega_inv)\n            L_prime = self._negloglikelihood_prime(params, z, W, Omega=Omega, Omega_inv=Omega_inv)\n            return L, L_prime\n\n    def _negloglikelihood_prime(self, params, z, W, Omega=None, Omega_inv=None):\n        tau, rho, sigma = params[:-2], params[-2], params[-1]\n        Omega = self._calc_Omega(W, tau, rho, sigma) if Omega is None else Omega\n        dL_dOmega = self._dL_dOmega(z, Omega, chain=True, Omega_inv=Omega_inv)\n        tau_prime = self._dL_dtau(z, Omega, W, tau, rho, sigma, dL_dOmega=dL_dOmega)\n        rho_prime = self._dL_drho(z, Omega, W, tau, rho, sigma, dL_dOmega=dL_dOmega)\n        sigma_prime = self._dL_dsigma(z, Omega, W, tau, rho, sigma, dL_dOmega=dL_dOmega)\n        # print(f\"{tau_prime[-3:]}, {rho_prime}, {sigma_prime}\")\n        return -np.r_[tau_prime, rho_prime, sigma_prime]\n\n    def _negloglikelihood_prime_numerical(self, params, z, W, h=1e-6):\n        Hs = np.eye(len(params)) * h\n        return np.array([(self._negloglikelihood(params+H, z, W) - self._negloglikelihood(params-H, z, W)) \/ (2*h) for H in Hs])\n\n    def _test_gradient(self, n_channels=6, n_voxels=10, n_trials=7):\n        z = np.random.randn(n_voxels, n_trials)\n        W = np.random.rand(n_voxels, n_channels)\n        tau = np.random.rand(n_voxels)\n        rho = 0.5\n        sigma = 0.1\n        params = np.r_[tau, rho, sigma]\n        np.testing.assert_allclose(self._negloglikelihood_prime(params, z, W), \n            self._negloglikelihood_prime_numerical(params, z, W), rtol=1e-6)\n\n    def _test_loglikelihood(self, n_channels=6, n_voxels=10, n_trials=7):\n        z = np.random.randn(n_voxels, n_trials)\n        W = np.random.rand(n_voxels, n_channels)\n        tau = np.random.rand(n_voxels)\n        rho = 0.5\n        sigma = 0.1\n        mv_norm = stats.multivariate_normal(np.zeros(n_voxels), self._calc_Omega(W, tau, rho, sigma))\n        np.testing.assert_allclose(self._calc_L(z, W, tau, rho, sigma),\n            np.sum(mv_norm.logpdf(z.T)), rtol=1e-6)\n\n    def _calc_Omega(self, W, tau, rho, sigma):\n        return (rho + (1-rho)*np.eye(len(tau))) * np.outer(tau, tau) + sigma**2 * W@W.T\n\n    def _calc_L(self, z, W, tau, rho, sigma, Omega=None, Omega_inv=None):\n        '''\n        L = log(p(b|s; W, Omega))\n        z = b - W @ fs\n        '''\n        Omega = self._calc_Omega(W, tau, rho, sigma) if Omega is None else Omega\n        M = math.pinv(Omega) if Omega_inv is None else Omega_inv # Although (4x) slower than inv, pinv is preferred in the numerical world (=inv if invertible and well conditioned)\n        n_voxels, n_trials = z.shape\n        # For a single sample: -0.5 * (z.T @ M @ z + np.log(np.linalg.det(Omega)) + n_voxels*np.log(2*np.pi))\n        # May also use (by Gilles): np.sum(stats.multivariate_normal(np.zeros(n_voxels), Omega).logpdf(z.T))\n        # This is less numerically robust: -0.5 * (np.trace(z.T @ M @ z) + n_trials*np.log(np.linalg.det(Omega)) + n_trials*n_voxels*np.log(2*np.pi))\n        # return -0.5 * (np.trace(z.T @ M @ z) + n_trials*np.prod(np.linalg.slogdet(Omega)) + n_trials*n_voxels*np.log(2*np.pi))\n        return -0.5 * ((z * (M @ z)).sum() + n_trials*np.prod(np.linalg.slogdet(Omega)) + n_trials*n_voxels*np.log(2*np.pi))\n        \n    def _dL_dOmega(self, z, Omega, chain=False, Omega_inv=None):\n        M = math.pinv(Omega) if Omega_inv is None else Omega_inv # Although (4x) slower than inv, pinv is preferred in the numerical world (=inv if invertible and well conditioned)\n        n_voxels, n_trials = z.shape\n        # deriv = 0.5 * (M.T @ np.outer(z, z) @ M.T - M.T)\n        # For a single sample: deriv = 0.5 * (M @ np.outer(z, z) @ M - M) # M.T == M\n        deriv = 0.5 * (M @ z @ z.T @ M - n_trials*M)\n        if chain:\n            return deriv\n        else:\n            return (2 - np.eye(n_voxels)) * deriv\n\n    def _dL_dtau(self, z, Omega, W, tau, rho, sigma, dL_dOmega=None):\n        N = len(tau)\n        dL_dOmega = self._dL_dOmega(z, Omega, chain=True) if dL_dOmega is None else dL_dOmega\n        # deriv = np.zeros(N)\n        # for n in range(N):\n        #     e = np.zeros(N)\n        #     e[n] = 1\n        #     dOmega_dtau_n = (rho+(1-rho)*np.eye(N)) * (np.outer(e, tau) + np.outer(tau, e))\n        #     # deriv[n] = np.trace(dL_dOmega @ dOmega_dtau_n)\n        #     # The above expression is wasteful, trace(A@B) == sum(A*B.T), and Einstein summation is even faster (but numerically less stable???)\n        #     deriv[n] = np.einsum('ij,ji->', dL_dOmega, dOmega_dtau_n)\n        # This function is the bottleneck after cProfile.run()\n        # https:\/\/stackoverflow.com\/questions\/18854425\/what-is-the-best-way-to-compute-the-trace-of-a-matrix-product-in-numpy\n        A = dL_dOmega * (rho+(1-rho)*np.eye(N)).T\n        # deriv = (A*tau).sum(axis=1) + (A*tau[:,np.newaxis]).sum(axis=0)\n        deriv = 2 * (A*tau).sum(axis=1) # A should be symmetric matrix\n        return deriv\n\n    def _dL_drho(self, z, Omega, W, tau, rho, sigma, dL_dOmega=None):\n        dL_dOmega = self._dL_dOmega(z, Omega, chain=True) if dL_dOmega is None else dL_dOmega\n        dOmega_drho = (1 - np.eye(len(tau))) * np.outer(tau, tau)\n        # return np.trace(dL_dOmega @ dOmega_drho)\n        return (dL_dOmega * dOmega_drho.T).sum()\n\n    def _dL_dsigma(self, z, Omega, W, tau, rho, sigma, dL_dOmega=None):\n        dL_dOmega = self._dL_dOmega(z, Omega, chain=True) if dL_dOmega is None else dL_dOmega\n        dOmega_dsigma = W@W.T * 2*sigma\n        # return np.trace(dL_dOmega @ dOmega_dsigma)\n        return (dL_dOmega * dOmega_dsigma.T).sum()\n\n\nclass EnsembleModel(BaseModel):\n    def __init__(self, n_ensemble=10, base_model='required', pred_method=None, pred_options=None):\n        # Cannot use 1) **kwargs; 2) class as argument. Use instance instead (__class__ + get_params).\n        # Otherwise you may get the misleading \"TypeError: get_params() missing 1 required positional argument: 'self'\".\n        # Also cannot modify any argument, otherwise sklearn's clone() method will complain during cross-validation.\n        self.n_ensemble = n_ensemble\n        self.base_model = base_model\n        self.pred_method = pred_method\n        self.pred_options = pred_options\n\n    # get_params() is required by sklearn\n    def get_params(self, deep=True):\n        return dict(n_ensemble=self.n_ensemble, base_model=self.base_model,\n            pred_method=self.pred_method, pred_options=self.pred_options)\n\n    def fit(self, X, y):\n        # Perform argument validation here (as recommended by sklearn) so that get_params() and __init__() have the same effect \n        # This is refactored so that load() can work without fit()\n        self._set_default_params()\n        self.models_ = [self.base_model.__class__(**self.base_model.get_params()).fit(X[:,k::self.n_ensemble], y) for k in range(self.n_ensemble)]\n        return self # Required by sklearn\n\n    def predict(self, X, method=None, options=None, return_all=False, pred_kws=None):\n        method = self.pred_method if method is None else method\n        options = self.pred_options if options is None else options\n        pred_kws = dict(dict(return_all=(True if method in ['map'] else False)), **({} if pred_kws is None else pred_kws))\n        preds = [model.predict(X[:,k::self.n_ensemble], **pred_kws) for k, model in enumerate(self.models_)]\n        if method == 'mean':\n            y_hat = np.mean([pred[0] if isinstance(pred, tuple) else pred for pred in preds], axis=0)\n        elif method == 'map':\n            stimulus_domain = pred_kws['stimulus_domain'] if 'stimulus_domain' in pred_kws else self.base_model.get_params()['stimulus_domain']\n            posterior = np.mean([prep[options['pidx']] for prep in preds], axis=0)\n            y_hat = stimulus_domain[np.argmax(posterior, axis=1)]\n        return (y_hat, preds) if return_all else y_hat\n\n    def _set_default_params(self):\n        if self.pred_method is None:\n            self.pred_method = 'map' if hasattr(self.base_model, '_pidx') else 'mean' \n        self.pred_options = dict(dict(pidx=(self.base_model._pidx if hasattr(self.base_model, '_pidx') else -1)), \n            **({} if self.pred_options is None else self.pred_options))\n\n    def to_dict(self):\n        d = super().to_dict()\n        d['models_'] = [model.to_dict() for model in d['models_']]\n        return d\n\n    def from_dict(self, d):\n        self._set_default_params()\n        d['models_'] = [self.base_model.__class__(**self.base_model.get_params()).from_dict(model) for model in d['models_']]\n        self.__dict__.update(d)\n        return self\n\n\ndef shift_distribution(d, stimulus_domain, center_on=None, circular=True):\n    '''\n    Parameters\n    ----------\n    d : n_trials * n_domain\n    '''\n    if center_on is not None:\n        tgt_idx = len(stimulus_domain)\/\/2\n        src_idx = np.argmin(np.abs(center_on[:,np.newaxis] - stimulus_domain[np.newaxis,:]), axis=-1)\n        shift_idx = tgt_idx - src_idx\n    shifted = np.zeros_like(d)\n    for k, dd in enumerate(d):\n        dd = np.roll(dd, shift_idx[k])\n        if not circular:\n            if shift_idx[k] >= 0:\n                dd[:shift_idx[k]] = np.nan\n            else:\n                dd[shift_idx[k]:] = np.nan\n        shifted[k,:] = dd\n    return shifted\n\n\ndef discretize_prediction(y_pred, targets, circular_domain=None):\n    '''\n    Discretize continous prediction to the nearest target.\n    Can handle irregular target grid and also circular domain.\n\n    E.g.,\n    y_pred = encoding.discretize_prediction(y_hat, arange(8)\/8*pi, circular_domain=[0, pi])\n    correct = encoding.circular_correct(y_true, y_hat, domain=[0, pi], n_targets=8)\n    assert(allclose(mean(y_pred==y_true), mean(correct)))\n    '''\n    if circular_domain: # Circular domain\n        D = circular_domain[-1] - circular_domain[0] # Domain size\n        augmented = np.r_[targets, D+targets[0]]\n    else: # Non circular domain\n        augmented = targets\n    idx = np.argmin(np.abs(y_pred[:,np.newaxis] - augmented[np.newaxis,:]), axis=-1) % len(targets)\n    return targets[idx]\n\n\ndef circular_correct(y_true, y_pred, domain=None, n_targets=None, tolerance=None, return_dist=False):\n    if domain is None:\n        domain = [0, 2*np.pi]\n    D = domain[-1] - domain[0] # Domain size\n    if n_targets is None:\n        if tolerance is None:\n            raise ValueError('You must provide either \"n_targets\" or \"tolerance\".')\n        else:\n            d = tolerance\n    else:\n        d = D \/ n_targets \/ 2\n    dist = np.abs(y_pred - y_true)\n    dist = np.minimum(dist, D-dist)\n    correct = (dist < d)\n    return (correct, dist) if return_dist else correct\n\n\nif __name__ == '__main__':\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_417","text":"#!\/usr\/bin\/env python3\n\nimport roslib; roslib.load_manifest('freemovr_engine')\nimport rospy\n\nimport os\nimport argparse\n\nimport numpy as np\nimport scipy.misc\n\nimport freemovr_engine.srv\nimport freemovr_engine.display_client as display_client\n\ndef show_image(ds,viewport,fname,white,black,rgb,pixel, ptsize, scale=False):\n    rospy.init_node('show_image')\n\n    dsc = display_client.DisplayServerProxy(ds,wait=True)\n    dsc.enter_2dblit_mode()\n\n    if viewport:\n        mask = dsc.get_virtual_display_mask(viewport)\n    else:\n        mask = None\n\n    if rgb != (-1,-1,-1):\n        arr = dsc.new_image(rgb, mask)\n    elif white:\n        arr = dsc.new_image(dsc.IMAGE_COLOR_WHITE, mask)\n    elif black:\n        arr = dsc.new_image(dsc.IMAGE_COLOR_BLACK, mask)\n    else:\n        arr = scipy.misc.imread(fname)\n        if arr.shape!=(dsc.height,dsc.width):\n            arr = arr[0:min(dsc.height,arr.shape[0]),0:min(dsc.width,arr.shape[1]),:]\n        if mask != None:\n            masks = np.dstack([mask for i in range(0,arr.shape[-1])])\n            if arr.shape != masks.shape:\n                arr = np.resize(arr, masks.shape)\n            arr *= masks\n\n    if pixel and (white or black or (rgb != (-1,-1,-1))):\n        col,row = map(int,pixel.split(','))\n\n        if white:\n            arr = dsc.new_image(dsc.IMAGE_COLOR_BLACK, mask)\n            rgb = (dsc.IMAGE_COLOR_WHITE, dsc.IMAGE_COLOR_WHITE, dsc.IMAGE_COLOR_WHITE)\n        elif black:\n            arr = dsc.new_image(dsc.IMAGE_COLOR_WHITE, mask)\n            rgb = (dsc.IMAGE_COLOR_BLACK, dsc.IMAGE_COLOR_BLACK, dsc.IMAGE_COLOR_BLACK)\n        else:\n            arr = dsc.new_image(dsc.IMAGE_COLOR_BLACK, mask)\n\n        for i,c in enumerate(rgb):\n            arr[row-ptsize:row+ptsize,col-ptsize:col+ptsize,i] = c\n\n    if scale:\n        orig_aspect = arr.shape[1]\/float(arr.shape[0]) # w\/h\n        native_aspect = dsc.width\/float(dsc.height)\n        if native_aspect >= orig_aspect:\n            # display is wider than image\n            new_shape_height_h = int(dsc.width\/float(orig_aspect))\n            new_shape_full = new_shape_height_h, dsc.width\n\n        else:\n            # display is taller than image\n\n            new_shape_wide_w = int(orig_aspect*dsc.height)\n            new_shape_full = dsc.height, new_shape_wide_w\n        new_image = scipy.misc.imresize( arr, new_shape_full )\n        arr = new_image[:dsc.height, :dsc.width]\n    dsc.show_pixels(arr)\n\ndef main():\n    wd = roslib.packages.get_pkg_dir('freemovr_engine')\n    default_fname = os.path.join(wd,'data','vienna-morning.jpg')\n\n    parser = argparse.ArgumentParser()\n    parser.add_argument('fname',nargs='?',default=default_fname)\n    parser.add_argument('--rgb', help='RGB tuple r,g,b (float, 0...1)', default=\"-1,-1,-1\")\n    parser.add_argument('--white', action='store_true', help='show a white screen')\n    parser.add_argument('--black', action='store_true', help='show a black screen')\n    parser.add_argument('--viewport', type=str, help='only show on this viewport')\n    parser.add_argument(\n        '--display-server', type=str, metavar='\/display_server', required=True, help=\\\n        'the path of the display server to configure')\n    parser.add_argument('--pixel', type=str, help='light this pixel', metavar='x,y')\n    parser.add_argument('--scale', action='store_true', help='scale the image to fullscreen')\n    parser.add_argument('--pxsize', type=int, default=2)\n\n    argv = rospy.myargv()\n    args = parser.parse_args(argv[1:])\n\n    show_image(args.display_server, args.viewport, args.fname,\n            args.white,\n            args.black,\n            tuple(map(int,args.rgb.split(','))),\n            args.pixel,\n            args.pxsize,\n            scale = args.scale,\n    )\n\nif __name__=='__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_418","text":"<reponame>sillyemperor\/langstudy\nimport os.path\nBASE_DIR = os.path.dirname(os.path.abspath(__file__))\nimport pprint\nimport numpy as np\nimport imageio\nfrom scipy import signal as sg\nimport cifar\n\n\nmeta = cifar.unpickle(os.path.join(BASE_DIR, '..\/data\/cifar-100-python\/meta'))\n\n# pprint.pprint(meta)\n\nmeta_label_names = meta[b'fine_label_names']\n\n# pprint.pprint(len(meta_label_names))\n#\ntest = cifar.unpickle(os.path.join(BASE_DIR, '..\/data\/cifar-100-python\/test'))\n# pprint.pprint(test) #batch_label,coarse_labels,data,filenames,fine_labels\n\n# pprint.pprint(test.keys())  # dict_keys([b'filenames', b'batch_label', b'fine_labels', b'coarse_labels', b'data'])\n#\n# label_ids = test[b'fine_labels']\n# pprint.pprint([min(label_ids), max(label_ids)])\n# label_names = list(map(lambda i:meta_label_names[i], label_ids))\n# # pprint.pprint(label_names)\n#\n# mdata = test[b'data'];\n\n# for id in range(mdata.size):\n#     cifar.save_jpg(mdata, label_names, id)\n#     break\n\ntrain = cifar.unpickle(os.path.join(BASE_DIR, '..\/data\/cifar-100-python\/train'))\npprint.pprint(train[b'fine_labels'])"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_419","text":"<reponame>spicella\/Intro_to_ComplexSystems-Kuramoto\nimport os\nfrom sympy import *\nimport pandas as pd\nimport numpy as np\nimport scipy.fftpack\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nplt.style.use(\"seaborn-paper\")\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\n\n\n\ndef find_nearest(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return idx\n\ndef find_nearest_value(array, value):\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return array[idx]\n\n\n# ## Canvas palette\n\n# In[2]:\n\n\n#Canvas for single plot\nx = np.linspace(0,10,100)\ny = np.sin(x)\nplt.figure(figsize=[14,6])\nplt.grid(True)\nplt.title(\"Change-me!\",fontsize=20)\nplt.plot(x,y,label=\"testvalue\")\nplt.legend(fontsize=16)\nplt.xlabel(\"XLABEL (unit)\",fontsize=18)\nplt.ylabel(\"YLABEL (unit)\",fontsize=18)\nplt.show()\n\n\n# In[3]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0].grid(True)\naxes[0].plot(x,y,label=\"testvalue\")\naxes[0].legend(fontsize=16)\naxes[0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0].legend(fontsize=16)\naxes[0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[1].grid(True)\naxes[1].plot(x,y,label=\"testvalue\")\naxes[1].legend(fontsize=16)\naxes[1].set_title(\"TESTTITLE\",fontsize=18)\naxes[1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[1].legend(fontsize=16)\naxes[1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# In[4]:\n\n\n#Canvas for side by side\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(14,6))\nfig.suptitle(\"test\",y=1.05,fontsize=20)\n\naxes[0,0].grid(True)\naxes[0,0].plot(x,y,label=\"testvalue\")\naxes[0,0].legend(fontsize=16)\naxes[0,0].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,0].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,0].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,0].legend(fontsize=16)\naxes[0,0].tick_params(axis='both', which='major', labelsize=15)\n\n\naxes[0,1].grid(True)\naxes[0,1].plot(x,y,label=\"testvalue\")\naxes[0,1].legend(fontsize=16)\naxes[0,1].set_title(\"TESTTITLE\",fontsize=18)\naxes[0,1].set_xlabel(\"XLABEL (unit)\",fontsize=18)\naxes[0,1].set_ylabel(\"YLABEL (unit)\",fontsize=18)\naxes[0,1].legend(fontsize=16)\naxes[0,1].tick_params(axis='both', which='major', labelsize=15)\n\nfig.tight_layout()\nplt.show()\n\n\n# ## Read data\n\n# In[2]:\n\n\n#Folder and paths definitions\nmain_path  = os.getcwd()\ndatafolder_path = main_path+\"\/results\"\nresults_dir = \"\/output_py\" \noutput_dir = main_path+results_dir\ntry:\n    os.mkdir(output_dir)\nexcept OSError:\n    print (\"Creation of the directory %s failed\" % results_dir)\nelse:\n    print (\"Successfully created the directory %s \" % results_dir)\n\n\n# In[27]:\n\n\nKvalues = np.linspace(0,6,30)\nKvalues = np.around(Kvalues, decimals=3)\n\n\n# In[28]:\n\n\npvalues = [0, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, .95, 1]\n\n\n# In[9]:\n\n\n#Create dataframe dictionary. For each entry, first value is the K of the dataframe (second value)\ndata = []\nfor i in range(0,len(Kvalues)):\n    for j in pvalues:\n        filename = datafolder_path + \"\/WS_gfreq_uphase_N2000_NOMF_T20000_dt0.0100_nruns10_K%.3f_p=%.3f.tsv\"%(Kvalues[i],j)\n        #cols refers to timestep, avgmod, stdmod, avgphase,stdphase (of order parameter)\n        df = pd.read_csv(filename,sep=\"\\t\",header=None)\n        data.append([Kvalues[i],j,df])\n    \n\n\n# In[10]:\n\n\n#data[0][x]#, x=0=> K, x=1=>p, x=2=> df \n\n\n# In[11]:\n\n\ndef rinf_avg(df):\n    lasts = df[1][int(T*.9):-1]\n    return np.mean(lasts)\n\ndef rinf_std(df):\n    lasts = df[1][int(T*.9):-1]\n    return np.std(lasts)\n\n\n# In[12]:\n\n\nK_plot = []\np_plot = []\nr_inf_avg = []\nr_inf_std = []\nfor i in range(0,len(data)):\n    t_plot = data[i][2][0]\n    K_plot.append(data[i][0])\n    p_plot.append(data[i][1])\n    r_inf_avg.append(rinf_avg(data[i][2]))\n    r_inf_std.append(rinf_std(data[i][2]))\n\n\n# In[29]:\n\n\nr_inf_mat = np.zeros(shape=[len(pvalues),len(Kvalues)])\nfor i in range(0,len(data)):\n    r_inf_mat[find_nearest(pvalues, data[i][1])][find_nearest(Kvalues, data[i][0])] = rinf_avg(data[i][2])\n\nplt.figure(figsize=[10,10])\nax = plt.gca()\n#name = \"Kuramoto oscillators on Watts-Strogatz network \\n N = %d, r = %d, dt = %.3f, %s, n_runs = %d\\n$r_{\\\\infty}$\"%(N,2,dt,freq_plot, n_runs)\n\nim = plt.imshow(r_inf_mat)\nplt.title(\"Kuramoto oscillators on Watts-Strogatz network\\n N=%d, $r_{WS}$=%d, T=%d, dt=%.3f, %s, n_runs=%d\\n $r_{\\\\infty}$\"%(N,3,T,dt,freq_plot,n_runs),fontsize=20)\n\nplt.yticks(np.linspace(0,len(pvalues)-1,len(pvalues)),pvalues)\nplt.ylabel(\"p\",fontsize=18,rotation=0)\nplt.xticks(np.linspace(0,len(Kvalues)-1,len(Kvalues)),Kvalues,rotation=45)\nplt.xlabel(\"K\",fontsize=18)\n\ndivider = make_axes_locatable(ax)\ncax = divider.append_axes(\"right\", size=\"5%\", pad=0.15)\ncbar = plt.colorbar(im, cax=cax)\n\nplt.tight_layout()\nplt.savefig(output_dir+config_name+\"WS_rinf_heatmap.png\")\n\nplt.show()\n\n\n# In[14]:\n\n\nKcs_df = pd.DataFrame([p_plot,K_plot,r_inf_avg,r_inf_std]).T\n\n\n# In[15]:\n\n\nKcs_df = Kcs_df.sort_values(by=[0,1])\n\n\n# In[31]:\n\n\nKc_plot = []\n\nfor i in range(0,len(pvalues)):\n\n    idx_kc = find_nearest(Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)][2],.5)\n    rinf_value = find_nearest_value(Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)][2],.5)\n    df = Kcs_df[0+i*len(Kvalues)+1:len(Kvalues)*(i+1)]\n    df = df.reset_index(inplace = False) \n    Kc_plot.append([pvalues[i],df[1].iloc[idx_kc]])\n    print(\"prob\",pvalues[i],\", rinf %.3f\"%(rinf_value),\", K\",df[1].iloc[idx_kc])\nKc_plot = pd.DataFrame(Kc_plot, columns=[\"p\",\"Kc\"])\n\n\n# In[54]:\n\n\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import curve_fit\n\n\n# In[55]:\n\n\ndef func(x, a, b):\n    return a+ b\/x\n\n\n# In[66]:\n\n\npopt, pcov = curve_fit(func, Kc_plot[\"p\"][2:],Kc_plot[\"Kc\"][2:], p0=[1.6,2])\npopt\n\n\n# In[70]:\n\n\nx_fit = np.linspace(Kc_plot[\"p\"][2],1,100)\ny_fit = func(x_fit,popt[0],popt[1])\n\n\n# In[94]:\n\n\nplt.figure(figsize=[14,6])\nplt.grid(True,alpha=.3)\nplt.title(\"Kuramoto oscillators on Watts-Strogatz network\\n N=%d, $r_{WS}$=%d, T=%d, dt=%.3f, %s, n_runs=%d\\n $K_{c}(p)$\"%(N,3,T,dt,freq_plot,n_runs),fontsize=20)\nplt.plot(x_fit,y_fit,label=\"y(p) = a + $\\\\frac{b}{p}$ fit\")\nplt.plot(Kc_plot[\"p\"],Kc_plot[\"Kc\"],c='b',marker='o',markersize=12,ls='',label=\"Raw Data\")\nplt.plot(Kc_plot[\"p\"][2:],Kc_plot[\"Kc\"][2:],c='r',marker='o',markersize=9,ls='--',linewidth=.7,label=\"Fitted Data\")\nplt.xticks(pvalues,pvalues)\nplt.xlabel(\"p\",fontsize=18,rotation=0)\nplt.yticks(Kvalues,Kvalues)\nplt.ylim(min(Kc_plot[\"Kc\"])*.85,max(Kc_plot[\"Kc\"])*1.1)\nplt.legend(fontsize=18)\n\nplt.text(.5,4,\"a = %.4f$\\pm$%.4f, b = %.4f$\\pm$%.4f\"%(popt[0],pcov[0,0],popt[1],pcov[1,1]),fontsize=20)\n\nplt.tight_layout()\nplt.savefig(output_dir+config_name+\"WS_Kc(p).png\")\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_420","text":"<filename>sdt_metrics\/plotting\/_roc_plot.py\nfrom __future__ import print_function\r\nfrom __future__ import division\r\n\r\n# Copyright (c) 2012, <NAME> [see LICENSE.txt]\r\n\r\nimport pylab\r\nimport numpy as np\r\nimport scipy\r\n\r\nfrom numpy import pi\r\nfrom scipy.stats import norm\r\n\r\nimport sdt_metrics\r\nfrom .._sdt_metrics import ltqnorm,HI,MI,CR,FA\r\nfrom ._mult_roc_plot import mult_roc_plot\r\n\r\n_normdist = lambda x : np.exp(-x**2\/2.)\/np.sqrt(2*pi)\r\n\r\ndef roc_plot(*args, **kwds):\r\n    \"\"\"\r\n    Receiver Operating Characteristic (ROC) Plot\r\n\r\n       args:\r\n          1 argument:\r\n             sdt_metrics.SDT object\r\n          \r\n          2 arguments:\r\n             pHI\r\n             pFA\r\n             \r\n          4 arguments:\r\n             hit count\r\n             miss count\r\n             correction rejection count\r\n             false alarm count\r\n\r\n       kwds:\r\n          metric: dprime, aprime, amzs (default is dprime)\r\n          \r\n          isopleths: None, beta, c, bppd, bmz\r\n          \r\n          fname: outputname\r\n          \r\n          dpi: resolution of plot\r\n    \"\"\"\r\n    # wrap mult_roc_plot\r\n    if len(args) == 1:\r\n        mult_roc_plot([args[0],''], **kwds)    \r\n    else:\r\n        mult_roc_plot([args,''], **kwds)\r\n        \r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_421","text":"\"\"\"\nAn interative GUI designed for a low pass filter\nauthor: <NAME>\nyear: 2016\n\"\"\"\n\n\n\n\nfrom Tkinter import *\nimport matplotlib\nmatplotlib.use('TkAgg')\nfrom numpy import arange, sin, pi\nfrom matplotlib.figure import Figure\nfrom matplotlib.backends.backend_tkagg import FigureCanvasTkAgg\nimport FileDialog\nimport scipy.signal as signal\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tkMessageBox\nimport tkFileDialog\n\nnp.set_printoptions(suppress=True) # surpress scientific notation\n\ndef main():\n\troot = Tk()\n\troot.wm_title(\"FIR low pass filter\")\n\t# making the grid\n\t\n\t#main frame\n\tframe = Frame(root)\n\tframe.pack(fill=BOTH,expand=YES)\n\t\n\t#left side of gui\n\tleftframe = Frame(frame, bd=20)\n\tleftframe.pack(side=TOP,fill=X,expand=YES)\n\n\t#entry = Entry(leftframe)\n        #entry.grid(row=0, columnspan=3, sticky=W+E)\n\n\n\t# add some widgets\n\tL1 = Label(leftframe, text=\"Number of coeffs\",bd=12,font=(\"arial\", \"11\", \"normal\"))\n\tL1.grid( row = 0, column = 0)\n\tttp1 = CreateToolTip(L1, \"The number of coefficents that will \\n be used in windowing\")\n\n\t#L2 = Label(leftframe, text=\"Nqyst freq\",bd=12,font=(\"arial\", \"11\", \"normal\"))\n\t#L2.grid( row = 0, column = 1)\n\tL4 = Label(leftframe, text=\"Width\",bd=12,font=(\"arial\", \"11\", \"normal\"))\n\tL4.grid( row = 0, column = 1)\n\tttp2 = CreateToolTip(L4, \"The effective width of the transistion region\")\n\n\tL3 = Label(leftframe, text=\"Cut off\",bd=12,font=(\"arial\", \"11\", \"normal\"))\n\tL3.grid( row = 0, column = 2)\n\tttp3 = CreateToolTip(L3, \"The cut off point of the window (-3dB)\")\n\t\n\t\n\t\n\tcoeff_entry = Entry(leftframe, bd =6,justify='center')\n\tcoeff_entry.grid( row = 1, column = 0)\n\n\t#nyqst_entry = Entry(leftframe, bd =6,justify='ctkFileDialogenter')\n\t#nyqst_entry.grid( row = 1, column = 1)\n\t\n\twidth_entry = Entry(leftframe, bd =6,justify='center')\n\twidth_entry.grid( row = 1, column = 1)\n\t\n\tcutoff_entry = Entry(leftframe, bd =6,justify='center')\n\tcutoff_entry.grid( row = 1, column = 2)\n\n\t\n\n\tvariable = StringVar(root)\n\tvariable.set(\"Window\") # default value\n\tw = OptionMenu(leftframe, variable, \"boxcar\", \"triang\", \"blackman\", \"hamming\", \"hann\", \"bartlett\", \"flattop\", \"parzen\", \"bohman\", \"blackmanharris\", \"nuttall\", \"barthann\", \n\t\t\"kaiser (needs beta)\", \"gaussian (needs standard deviation)\", \"general_gaussian (needs power, width)\", \n\t\t\"slepian (needs width)\", \"chebwin (needs attenuation)\", \"exponential (needs decay scale)\", \"tukey (needs taper fraction)\")\n\tw.grid(row = 4,column = 0,pady=(10, 10))\n\n\toption1_entry = Entry(leftframe, bd =6,justify='center',state=DISABLED)\n\toption1_entry.grid( row = 4, column = 1,pady=(20, 10))\n\toption2_entry = Entry(leftframe, bd =6,justify='center',state=DISABLED)\n\toption2_entry.grid( row = 4, column = 2,pady=(20, 10))\t\n\t\n\tdef option_changed(*args):\n\t\topt = variable.get()\n\t\tprint opt\n\t\tif \"kaiser\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\tif \"gaussian\" in opt and \"_\" not in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\tif \"general_gaussian\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"normal\")\n\t\t\treturn 0\n\t\tif \"slepian\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\tif \"chewbin\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\tif \"exponential\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\tif \"tukey\" in opt:\n\t\t\toption1_entry.configure(state = \"normal\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\t\treturn 0\n\t\telse:\n\t\t\toption1_entry.configure(state = \"disabled\")\n\t\t\toption2_entry.configure(state = \"disabled\")\n\t\n\n\tvariable.trace(\"w\", option_changed)\n\tdef graph(b,a=1):\n\t\t\t#make a graph\n\t\t\tw,h = signal.freqz(b,a)\n\t\t\th_dB = 20 * np.log10 (abs(h))\n\t\t\tplt.figure()\n\t\t\t#plt.subplot(311)\n\t\t\tplt.plot(w\/max(w),h_dB)\n\t\t\tplt.ylim(-150, 5)\n\t\t\tplt.ylabel('Magnitude (db)')\n\t\t\tplt.xlabel(r'Normalized Frequency (x$\\pi$rad\/sample)')\n\t\t\tplt.title(r'Frequency response')\n\t\t\tplt.show()\n\t\t\tplt.figure()\n\t\t\tl = len(b)\n\t\t\timpulse = np.repeat(0.,l); impulse[0] =1.\n\t\t\tx = arange(0,l)\n\t\t\tresponse = signal.lfilter(b,a,impulse)\n\t\t\t#plt.subplot(312)\n\t\t\tplt.stem(x, response)\n\t\t\tplt.ylabel('Amplitude')\n\t\t\tplt.xlabel(r'n (samples)')\n\t\t\tplt.title(r'Impulse response')\n\t\t\tplt.show()\n\t\t\t#plt.figure()\n\t\t\t#plt.subplot(313)\n\t\t\t#step = np.cumsum(response)\n\t\t\t#plt.stem(x, step)\n\t\t\t#plt.ylabel('Amplitude')\n\t\t\t#plt.xlabel(r'n (samples)')\n\t\t\t#plt.title(r'Step response')\n\t\t\t#plt.subplots_adjust(hspace=0.5)\n\t\t\t#plt.show()\n\t\t\treturn 1\n\n\t\n\n\tdef run():\n\t\t\"\"\"\n\t\tFunction of the run button\n\n\t\t\"\"\"\n\t\tnumtaps = coeff_entry.get() # number of coeffs\n\t\t# check to see if number\n\t\tif numtaps.isdigit() == False:\n\t\t\ttkMessageBox.showinfo( \"ERROR\",\"Coefficent entry is not an integer number\",icon=\"error\")\n\t\t\treturn 0\n\t\telse:\n\t\t\tnumtaps = float(numtaps)\n\n\t\tmywindow = variable.get() #cut off is the normalised cut off in terms of nqy\n\t\t# window is the function\n\t\tmywindow = str(mywindow)\n\t\tmylist = [\"kaiser\",\"slepian\",\"chewbin\",\"exponential\",\"tukey\" ]\n\t\tif any(x in mywindow for x in mylist):\n\t\t\tfor x in mylist:\n\t\t\t\tif x in mywindow:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tmynum = float(option1_entry.get())\n\t\t\t\t\t\tmywindow  = (str(x), mynum)\n\t\t\t\t\texcept:\n\t\t\t\t\t\ttkMessageBox.showinfo( \"ERROR\",\"window entry not a number\",icon=\"error\")\n\t\t\t\t\t\treturn 0\n\n\t\telif \"gaussiantkFileDialog\" in mywindow and \"general\" not in mywindow:\n\t\t\ttry:\n\t\t\t\tmynum = float(option1_entry.get())\n\t\t\t\tmywindow  = (\"gaussian\", mynum)\n\t\t\texcept:\n\t\t\t\ttkMessageBox.showinfo( \"ERROR\",\"window entry not a number\",icon=\"error\")\n\t\telif \"general_gaussian\" in mywindow:\n\t\t\ttry:\n\t\t\t\tmynum = float(option1_entry.get())\n\t\t\t\tmynum2 = float(option2_entry.get())\n\t\t\t\tmywindow  = (\"general_gaussian\", mynum,mynum2)\n\t\t\texcept:\n\t\t\t\ttkMessageBox.showinfo( \"ERROR\",\"one of the window entry not a number\",icon=\"error\")\n\t\t\t\treturn 0\t\t\t\t\n\t\telse:\n\t\t\tmywindow = mywindow\n\t\t\t\n\n\t\tmycutoff = cutoff_entry.get()\n\n\n\t\ttry:\n\t\t\tfloat(mycutoff)\n\t\t\tmycutoff = float(mycutoff)\n\t\texcept:\n\t\t\ttkMessageBox.showinfo( \"ERROR\",\"Cut off entry is not a floating point number\",icon=\"error\")\n\t\t\treturn 0\n\n\t\tmywidth = width_entry.get()\n\t\ttry:\n\t\t\tfloat(mywidth)\n\t\t\tmycutoff = float(mywidth)\n\t\texcept:\n\t\t\ttkMessageBox.showinfo( \"ERROR\",\"Width entry is not a floating point number\",icon=\"error\")\n\t\t\treturn 0\n\t\t# options = boxcar, triang, blackman, hamming, hann, bartlett, flattop, parzen, bohman, blackmanharris, nuttall, barthann, \n\t\t#kaiser (needs beta), gaussian (needs standard deviation), general_gaussian (needs power, width), \n\t\t#slepian (needs width), chebwin (needs attenuation), exponential (needs decay scale), tukey (needs taper fraction)\n\n\t\tfir_coeff = signal.firwin(numtaps, cutoff = mycutoff, window = mywindow, nyq = 1000, width = mywidth) #\n\t\tplt.ion()\n\t\tgraph(fir_coeff)\n\t\tT1.delete(\"1.0\",END) # clear text\n\t\tmymulti = Multi_entry.get()\n\t\tif mymulti is not None:\n\t\t\tif mymulti.isdigit():\n\t\t\t\tmymulti = float(mymulti)\n\t\t\t\t#fir_coeff = fir_coeff.tolist()\n\t\t\t\tcoeff_sum = np.sum(fir_coeff)\n\t\t\t\tfir_coeff = fir_coeff\/coeff_sum\n\t\t\t\tfir_coeff = np.rint(fir_coeff*mymulti)\n\t\t\t\tfir_coeff = fir_coeff.astype(int)\n\t\t\t\t\n\t\t\t\t#for x in fir_coeff:\n\t\t\t\t#\tprint type(x)\n\t\t\t\t#fir_coeff = [ x*mymulti for x in fir_coeff ]\n\t\t\t\t\n\t\tT1.insert(END, fir_coeff)\n\t\treturn 1\n\t\n\tMultiLabel = Label(leftframe, text=\"Multiply\",bd=12,font=(\"arial\", \"11\", \"normal\"))\n\tMultiLabel.grid( row = 5, column = 0)\n\t\n\tMulti_entry = Entry(leftframe, bd =6,justify='center')\n\tMulti_entry.grid( row = 5, column = 1)\t\t\n\n\trun_button = Button(leftframe, text =\"Run\",command=run)\n\trun_button.grid(row = 5,column = 2,pady=(20, 10))\n\tT1 = Text(leftframe, height=7)\n\tT1.grid(row = 6, column = 0, columnspan = 3)\n\tS = Scrollbar(leftframe)\n\tS.grid(row = 6, column = 3, sticky=NS)\n\tT1.config(yscrollcommand=S.set)\n\tS.config(command=T1.yview)\n\troot.mainloop()\n\n\t\n\n\nclass CreateToolTip(object):\n    '''\n    create a tooltip for a given widget\n    '''\n    def __init__(self, widget, text='widget info'):\n        self.widget = widget\n        self.text = text\n        self.widget.bind(\"<Enter>\", self.enter)\n        self.widget.bind(\"<Leave>\", self.close)\n    def enter(self, event=None):\n        x = y = 0\n        x, y, cx, cy = self.widget.bbox(\"insert\")\n        x += self.widget.winfo_rootx() + 25\n        y += self.widget.winfo_rooty() - 50\n        # creates a toplevel window\n        self.tw = Toplevel(self.widget)\n        # Leaves only the label and removes the app window\n        self.tw.wm_overrideredirect(True)\n        self.tw.wm_geometry(\"+%d+%d\" % (x, y))\n        label = Label(self.tw, text=self.text, justify='left',\n                       background='lightgrey', relief='solid', borderwidth=3,\n                       font=(\"arial\", \"12\", \"normal\"))\n        label.pack(ipadx=1)\n    def close(self, event=None):\n        if self.tw:\n            self.tw.destroy()\n\n\nif __name__ == '__main__':\n\tmain() # run the program\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_422","text":"<filename>notebooks\/sCSC.py\n# Python 3 file to generate sCSC dendrogram\n# <NAME>, <NAME>, and <NAME>\n# Stanford University\n# 2017-2018\n# Instructions: Execute this code in the terminal, e.g.\n# >>> python3 sCSC.py protein_g_adjmat.npy 7 my_directory\n# Adjacency matrix must be in numpy format\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os, sys, pickle\n\n# The following was written using SciPy Version 0.19.1\nimport scipy.linalg\nfrom scipy.cluster.hierarchy import average, linkage, fcluster\nfrom scipy.spatial.distance import pdist\n\n# Compute the color field and obtains the\n# user-specified number of eigenvectors\ndef get_eigenvectors_for_dendrogram(adjacency_matrix,\n                                    numeigvecs):\n    A = adjacency_matrix\n\n    # Create column vector of row-sums of adjacency matrix\n    Adegree = np.sum(A, axis=1)\n\n    # Create diagonal degree matrix with row-sums of adjacency matrix\n    DD = np.diag(Adegree)\n\n    # Create graph Laplacian\n    L = DD - A \n\n    # Compute eigenvectors and eigenvalues of generalized eigenvalue problem. \n    eigval, eigvec = scipy.linalg.eig(L, DD)\n\n    # Sort eigenvalues in decending order\n    lambdaindex = np.argsort(eigval)[::-1]\n    sortedeigs = eigval[lambdaindex]\n\n    # Sort eigenvectors in order corresponding to sorted eigenvalues\n    CSC_fullset = eigvec[:, lambdaindex]\n    \n    # Select number of eigenvectors to include in dendrogram analysis\n    evec = CSC_fullset[:,:numeigvecs]\n    \n    # This normalization makes results consistent with matlab\n    for ind, ev in enumerate(evec.T):\n        constant = np.matmul(np.matmul(ev.T, DD), ev)\n        evec[:,ind] = ev\/np.sqrt(constant)\n    \n    return evec, L\n\n# Obtain binary codes for each orthogonal process\n# using agglomerative hierarchical clustering\ndef get_binary_codes(evec, numeigvecs):\n    binary = np.empty(evec.shape)\n\n    #Loop through eigenvectors to create binary code for each state in dataset\n    for col in np.arange(numeigvecs):\n\n        # Create agglomerative hierarchical tree using average linkage\n        p = pdist([[x] for x in evec[:,col]])\n        lnk = linkage(p, 'average')\n\n        # Assign value of 1 or 2 to each state state depending on membership\n        # in bifurcated tree\n        T = fcluster(lnk, criterion='maxclust', t=2) - 1\n\n        binary[:, col] = T\n        \n    return binary\n\n# Initialize the matrices that will be used\n# to plot the dendrogram and a dictionary that will\n# store cluster assignments\ndef initialize_dendrogram_matrices(numeigvecs):\n    # Initialize matrix containing length of each dendrogram branch\n    groupdist = np.zeros([2 ** (numeigvecs),numeigvecs])\n\n    # Initialize matrix containing x coordinates of each dendrogram node\n    plotcoordsx = np.zeros([2 ** (numeigvecs),numeigvecs])\n\n    # Initialize matrix containing y coordinates of each dendrogram node\n    plotcoordsy = np.zeros([2 ** (numeigvecs),numeigvecs])\n    \n    return groupdist, plotcoordsx, plotcoordsy, {}\n\n# Get subgroup information\ndef get_subgroup_similarity(evec, L, binary, combos, split, index_dict):\n    n = evec.shape[0]\n    \n    # Create binary code for group 1 of a pair of branches\n    group1 = np.array([int(x) for x in np.binary_repr(combos, split+1)])\n\n    # Create binary code for group 2 of a pair of branches\n    group2 = np.array([int(x) for x in np.binary_repr(combos+1, split+1)])\n\n    # Create string-compatible version of binary code for group 1 for plotting\n    g1label = np.binary_repr(combos, split+1)\n\n    # Create strong-compatible version of binary code for group 2 for plotting\n    g2label = np.binary_repr(combos+1, split+1)\n\n    # Initialize eigenvector for current level of dendrogram\n    Xgroup = evec[:,split]\n\n    # Remove eigenvector elements not in in group 1 or group 2\n    not_in_g1 = np.delete(np.arange(n), np.where((binary[:,:split+1][:]==group1).all(1)))\n    not_in_g2 = np.delete(np.arange(n), np.where((binary[:,:split+1][:]==group2).all(1)))\n    Xgroup = np.delete(Xgroup, np.intersect1d(not_in_g1, not_in_g2))\n\n    # Initialize graph Laplacian \n    Lgroup = L\n\n    # Remove columns not in group 1 or group 2\n    Lgroup = np.delete(Lgroup, np.intersect1d(not_in_g1, not_in_g2), axis=0)\n\n    # Remove rows not in group 1 or group 2\n    Lgroup = np.delete(Lgroup, np.intersect1d(not_in_g1, not_in_g2), axis=1)\n\n    # Calculate number of states in group 1\n    Z1count = sum((binary[:,:split+1][:]==group1).all(1))\n\n    # If group 1 is occupied by any states\n    if Z1count > 0:\n        # Calculate dissimilarity metric for states in groups 1 and 2\n        Z1 = np.matmul(np.matmul(Xgroup.transpose(), Lgroup), Xgroup)\n        \n        index_dict[g1label] = [i for i, x in enumerate(\n                               (binary[:,:split+1][:]==group1).all(1))\n                               if x]\n\n    else:\n        # dissimilarity metric is undefined if group 1 is unoccupied\n        Z1 = np.nan\n\n    # Calculate number of states in group 2\n    Z2count = sum((binary[:,:split+1][:]==group2).all(1))\n\n    # if group 2 is occupied by any states\n    if Z2count > 0:\n        # Calculate dissimilarity metric for states in groups 1 and 2\n        Z2 = np.matmul(np.matmul(Xgroup.transpose(), Lgroup), Xgroup)\n        \n        index_dict[g2label] = [i for i, x in enumerate(\n                               (binary[:,:split+1][:]==group2).all(1))\n                               if x]\n\n    else:\n        # Dissimilarity metric is undefined if group 2 is unoccupied\n        Z2 = np.nan\n    \n    return g1label, g2label, Z1count, Z2count, Z1, Z2, index_dict\n\n# Helper function for plotting lines\ndef plot_line(x1, x2, y1, y2, count, adjacency_matrix, maxlinewidth,\n              style='-o', color='black', markerfacecolor='black',\n              markeredgecolor='black'):\n    plt.plot([x1, x2], [y1, y2], style, color=color,\n             markerfacecolor=markerfacecolor,\n             markeredgecolor=markeredgecolor,\n             linewidth=maxlinewidth*(count\/len(adjacency_matrix[:,1])))\n\n# Plot the next level of the dendrogram\ndef plot_next_dendrogram_split(plotcoordsx, plotcoordsy, row, split, adjacency_matrix,\n                               g1label, g2label, Z1count, Z2count, Z1, Z2,\n                               figsize=(14,8), lineangle=np.pi\/4, maxlinewidth=15):\n    \n    A = adjacency_matrix\n    \n    xrel1 = -Z1*np.sin(lineangle)\n    xrel2 = Z2*np.sin(lineangle)\n\n    yrel1 = -Z1*np.cos(lineangle)\n    yrel2 = -Z2*np.cos(lineangle)\n    \n    if split == 0:\n        plotcoordsx[row, split] = xrel1\n        plotcoordsx[row+1, split] = xrel2\n\n        plotcoordsy[row, split] = yrel1\n        plotcoordsy[row+1, split] = yrel2\n\n        fig, ax = plt.subplots(figsize=figsize)\n\n        plot_line(0, plotcoordsx[row, split], 0, plotcoordsy[row, split],\n                  Z1count, adjacency_matrix, maxlinewidth)\n        \n        plot_line(0, plotcoordsx[row+1, split], 0, plotcoordsy[row+1, split],\n                  Z2count, adjacency_matrix, maxlinewidth)\n\n        plt.text(plotcoordsx[row, split],\n                 np.mean([0, plotcoordsy[row, split]]),\n                 g1label, fontsize=12)\n        \n        plt.text(plotcoordsx[row+1, split],\n                 np.mean([0, plotcoordsy[row+1, split]]),\n                 g2label, fontsize=12)\n\n        plt.text(plotcoordsx[row, split], plotcoordsy[row, split],\n                 '     '+str(Z1count), color='red',\n                 fontsize=12)\n        \n        plt.text(plotcoordsx[row+1, split], plotcoordsy[row+1, split],\n                 '     '+str(Z2count), color='red',\n                 fontsize=12)\n        \n    else:\n        plotcoordsx[row, split] = xrel1 + plotcoordsx[int((row+1)\/2), split-1]\n        plotcoordsx[row+1, split] = xrel2 + plotcoordsx[int((row+1)\/2), split-1]\n\n        plotcoordsy[row, split] = yrel1 + plotcoordsy[int((row+1)\/2), split-1]\n        plotcoordsy[row+1, split] = yrel2 + plotcoordsy[int((row+1)\/2), split-1]\n\n        plot_line(plotcoordsx[int((row+1)\/2), split-1],\n                  plotcoordsx[row, split],\n                  plotcoordsy[int((row+1)\/2), split-1],\n                  plotcoordsy[row, split],\n                  Z1count, adjacency_matrix, maxlinewidth)\n\n        plot_line(plotcoordsx[int((row+1)\/2), split-1],\n                  plotcoordsx[row+1, split],\n                  plotcoordsy[int((row+1)\/2), split-1],\n                  plotcoordsy[row+1, split],\n                  Z2count, adjacency_matrix, maxlinewidth)\n\n        if not np.isnan(plotcoordsx[row, split]):\n            plt.text(plotcoordsx[row, split],\n                     np.mean([plotcoordsy[int((row+1)\/2), split-1],\n                     plotcoordsy[row, split]]), g1label, fontsize=12)\n\n            plt.text(plotcoordsx[row, split], plotcoordsy[row, split],\n                     '     '+str(Z1count), color='red', fontsize=12)\n\n        if not np.isnan(plotcoordsx[row+1, split]):\n            plt.text(plotcoordsx[row+1, split],\n                     np.mean([plotcoordsy[int((row+1)\/2), split-1],\n                     plotcoordsy[row+1, split]]), g2label, fontsize=12)\n\n            plt.text(plotcoordsx[row+1, split], plotcoordsy[row+1, split],\n                     '     '+str(Z2count), color='red', fontsize=12)\n                    \n    return plotcoordsx, plotcoordsy\n\nif __name__ == '__main__':\n    if len(sys.argv) < 4:\n        print('Usage:')\n        print('   python3 sCSC.py [adjaency matrix] [num eigvecs] ' +\n              '[directory for files]')\n        sys.exit(0)\n    else:\n        adj_mat_file = sys.argv[1]\n        numeigvecs = int(sys.argv[2])\n        direc = sys.argv[3]\n\n    print('Loading adjacency matrix...')\n    try:\n        adjacency_matrix = np.load(adj_mat_file)\n    except:\n        raise RuntimeError('Adjacency matrix file must be a numpy array.')\n\n    # Obtain eigenvectors for clustering and graph Laplacian\n    evec, L = get_eigenvectors_for_dendrogram(adjacency_matrix, numeigvecs)\n\n    # Get binary codes for each orthogonal process\n    binary = get_binary_codes(evec, numeigvecs)\n\n    # Initialize dendrogram matrices\n    groupdist, plotcoordsx, plotcoordsy, index_dict = initialize_dendrogram_matrices(numeigvecs)\n\n    # Loop through eigenvectors, from largest to last one included in analysis\n    print('Constructing sCSC dendrogram...')\n    for split in np.arange(numeigvecs):\n        # Output current dendrogram level\n        print(\"  Split %i of %i\" % (split+1, numeigvecs))\n        \n        # Initialize level of dendrogram\n        row = 0\n        \n        # Loop through binary codes\n        for combos in np.arange(0, 2**(split+1), 2):\n            g1label, g2label, Z1count, Z2count, Z1, Z2, index_dict = get_subgroup_similarity(\n                                                    evec, L, binary, combos, split, index_dict)\n            \n            # Record dissimilarity metric for group 1\n            groupdist[row, split] = Z1\n        \n            # Record dissimilarity metric for group 2\n            groupdist[row+1, split] = Z2\n            \n            # Plot this level of the dendrogram\n            plotcoordsx, plotcoordsy = plot_next_dendrogram_split(\n                                       plotcoordsx, plotcoordsy, row, split, adjacency_matrix,\n                                       g1label, g2label, Z1count, Z2count, Z1, Z2)\n        \n            # Advance dendrogram level counter\n            row = row + 2\n\n    # Optionally add plot specifications\n    plt.xticks(fontsize=12)\n    plt.yticks(fontsize=12)\n    plt.tight_layout()\n\n    # Make sure directory exists\n    try:\n        os.stat(direc)\n        print('Writing files to existing directory %s...' % direc)\n    except:\n        os.mkdir(direc)\n        print('Creating new directory %s...' % direc)\n\n    # Save figure\n    dend_filename = direc  + '\/dendrogram.pdf'\n    print('Saving dendrogram to %s...' % dend_filename)\n    plt.savefig(dend_filename)\n\n    # Export sCSC Dendrogram distance matrix\n    dist_filename = direc + '\/groupdist.npy'\n    print('Saving distance matrix to %s...' % dist_filename)\n    np.save(dist_filename, groupdist)\n\n    # Save dictionary of member indices\n    index_filename = direc  + '\/index_dict.pkl'\n    print('Saving index dictionary to %s...' % index_filename)\n    with open(index_filename, 'wb') as f:\n        pickle.dump(index_dict, f)\n\n    print('Done.')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_424","text":"<reponame>willyspinner\/High-Performance-Face-Recognition<filename>src\/ResNet\/CASIA_WEB_FACE.PyTorch\/data_loader.py\nimport collections\nimport os.path as osp\n# from __future__ import division\n\nimport numpy as np\nimport PIL.Image\nimport scipy.io\nimport skimage\nimport skimage.color as color\nfrom skimage.transform import rescale\nfrom skimage.transform import resize\nimport torch\nfrom torch.utils import data\n\n\n\nDEBUG = False\n\n\n\nclass DemoFaceDataset(data.Dataset):\n    '''\n        Dataset subclass for demonstrating how to load images in PyTorch.\n\n    '''\n\n    # -----------------------------------------------------------------------------\n    def __init__(self, root, split='train', set='tiny', im_size=250):\n    # -----------------------------------------------------------------------------\n        '''\n            Parameters\n            ----------\n            root        -   Path to root of ImageNet dataset\n            split       -   Either 'train' or 'val'\n            set         -   Can be 'full', 'small' or 'tiny' (5 images)\n        ''' \n        self.root = root  # E.g. '...\/ImageNet\/images' or '...\/vgg-face\/images'\n        self.split = split\n        self.files = collections.defaultdict(list)\n        self.im_size = im_size # scale image to im_size x im_size\n        self.set = set\n\n        if set == 'small':\n            raise NotImplementedError()\n            \n        elif set == 'tiny':\n            # DEBUG: 5 images\n            files_list = osp.join(root, 'tiny_face_' + self.split + '.txt')\n\n        elif set == 'full':\n            raise NotImplementedError()\n\n        else:\n        \traise ValueError('Valid sets: `full`, `small`, `tiny`.')\n\n        assert osp.exists(files_list), 'File does not exist: %s' % files_list\n\n        imfn = []\n        with open(files_list, 'r') as ftrain:\n            for line in ftrain:\n                imfn.append(osp.join(root, line.strip()))\n        self.files[split] =  imfn\n\n\n    # -----------------------------------------------------------------------------\n    def __len__(self):\n    # -----------------------------------------------------------------------------\n        return len(self.files[self.split])\n\n\n    # -----------------------------------------------------------------------------\n    def __getitem__(self, index):\n    # -----------------------------------------------------------------------------\n        img_file = self.files[self.split][index]\n        img = PIL.Image.open(img_file)\n\n        # HACK: for non-RGB images - 4-channel CMYK or 1-channel grayscale\n        if len(img.getbands()) != 3:\n            while len(img.getbands()) != 3:\n                index -= 1\n                img_file = self.files[self.split][index] # if -1, wrap-around\n                img = PIL.Image.open(img_file)\n\n        if self.im_size > 0:\n        \t# Scales image to a square of default size 250x250\n        \tscaled_dim = (self.im_size.astype(np.int32), \n        \t\t\t\t  self.im_size.astype(np.int32))\n        \timg = img.resize(scaled_dim, PIL.Image.BILINEAR)\n\n        label = 1 # TODO: read in a class label for each image\n\n        img = np.array(img, dtype=np.uint8)\n        im_out = torch.from_numpy(im_out).float()\n        im_out = im_out.permute(2,0,1) # C x H x W\n\n        return im_out, label\n\n\n\nclass LFWDataset(data.Dataset):\n    '''\n        Dataset subclass for loading LFW images in PyTorch.\n        This returns multiple images in a batch.\n    '''\n\n    def __init__(self, path_list, issame_list, transforms, split = 'test'):\n        '''\n            Parameters\n            ----------\n            path_list    -   List of full path-names to LFW images\n        ''' \n        self.files = collections.defaultdict(list)\n        self.split = split\n        self.files[split] =  path_list\n        self.pair_label = issame_list\n        self.transforms = transforms\n\n    def __len__(self):\n        return len(self.files[self.split])\n\n    def __getitem__(self, index):\n        img_file = self.files[self.split][index]\n        img = PIL.Image.open(img_file)\n        if DEBUG:\n            print(img_file)\n        im_out = self.transforms(img)\n        return im_out\n\n\n\nclass IJBADataset(data.Dataset):\n    '''\n        Dataset subclass for loading IJB-A images in PyTorch.\n        This returns multiple images in a batch.\n        Path_list -- full paths to cropped images saved as <sighting_id>.jpg \n    '''\n    def __init__(self, path_list, transforms, split=1):\n        '''\n            Parameters\n            ----------\n            path_list    -   List of full path-names to IJB-A images of one split  \n        ''' \n        self.files = collections.defaultdict(list)\n        self.split = split\n        self.files[split] =  path_list\n        self.transforms = transforms\n\n    def __len__(self):\n        return len(self.files[self.split])\n\n    def __getitem__(self, index):\n        img_file = self.files[self.split][index]\n        img = PIL.Image.open(img_file)\n        if not img.mode == 'RGB':\n            img = img.convert('RGB')\n        if DEBUG:\n            print(img_file)\n        im_out = self.transforms(img)\n        return im_out\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_425","text":"\"\"\"\n\n.. _multi-taper-coh:\n\n\n================================\nMulti-taper coherence estimation\n================================\n\n\nCoherence estimation can be done using windowed-spectra. This is the method\nused in the example :ref:`resting-state`. In addition, multi-taper spectral\nestimation can be used in order to calculate coherence and also confidence\nintervals for the coherence values that result (see :ref:`multi-taper-psd`)\n\n\nThe data analyzed here is an fMRI data-set contributed by <NAME>. The\ndata is taken from a single subject in a\"resting-state\" scan, in which subjects\nare fixating on a cross and maintaining alert wakefulness, but not performing\nany other behavioral task.\n\nWe start by importing modules\/functions we will use in this example and define\nvariables which will be used as the sampling interval of the TimeSeries\nobjects and as upper and lower bounds on the frequency range analyzed:\n\n\"\"\"\n\nimport os\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.mlab import csv2rec\nimport scipy.stats.distributions as dist\nfrom scipy import fftpack\n\nimport nitime\nfrom nitime.timeseries import TimeSeries\nfrom nitime import utils\nimport nitime.algorithms as alg\nimport nitime.viz\nfrom nitime.viz import drawmatrix_channels\nfrom nitime.analysis import CoherenceAnalyzer, MTCoherenceAnalyzer\n\nTR = 1.89\nf_ub = 0.15\nf_lb = 0.02\n\n\"\"\"\n\nWe read in the data into a recarray from a csv file:\n\n\"\"\"\n\ndata_path = os.path.join(nitime.__path__[0], 'data')\n\ndata_rec = csv2rec(os.path.join(data_path, 'fmri_timeseries.csv'))\n\n\n\"\"\"\n\nThe first line in the file contains the names of the different brain regions\n(or ROI = regions of interest) from which the time-series were derived. We\nextract the data into a regular array, while keeping the names to be used later:\n\n\"\"\"\n\nroi_names = np.array(data_rec.dtype.names)\nnseq = len(roi_names)\nn_samples = data_rec.shape[0]\ndata = np.zeros((nseq, n_samples))\n\nfor n_idx, roi in enumerate(roi_names):\n    data[n_idx] = data_rec[roi]\n\n\n\"\"\"\n\nWe normalize the data in each of the ROIs to be in units of % change:\n\n\"\"\"\n\npdata = utils.percent_change(data)\n\n\"\"\"\n\nWe start by performing the detailed analysis, but note that a significant\nshort-cut is presented below, so if you just want to know how to do this\n(without needing to understand the details), skip on down.\n\nWe start by defining how many tapers will be used and calculate the values of\nthe tapers and the associated eigenvalues of each taper:\n\n\"\"\"\n\nNW = 4\nK = 2 * NW - 1\n\ntapers, eigs = alg.dpss_windows(n_samples, NW, K)\n\n\"\"\"\n\nWe multiply the data by the tapers and derive the fourier transform and the\nmagnitude of the squared spectra (the power) for each tapered time-series:\n\n\"\"\"\n\n\ntdata = tapers[None, :, :] * pdata[:, None, :]\ntspectra = fftpack.fft(tdata)\n## mag_sqr_spectra = np.abs(tspectra)\n## np.power(mag_sqr_spectra, 2, mag_sqr_spectra)\n\n\n\"\"\"\n\nCoherence for real sequences is symmetric, so we calculate this for only half\nthe spectrum (the other half is equal):\n\n\"\"\"\n\nL = n_samples \/\/ 2 + 1\nsides = 'onesided'\n\n\"\"\"\n\nWe estimate adaptive weighting of the tapers, based on the data (see\n:ref:`multi-taper-psd` for an explanation and references):\n\n\"\"\"\n\nw = np.empty((nseq, K, L))\nfor i in range(nseq):\n    w[i], _ = utils.adaptive_weights(tspectra[i], eigs, sides=sides)\n\n\n\"\"\"\n\nWe proceed to calculate the coherence. We initialize empty data containers:\n\n\"\"\"\n\ncsd_mat = np.zeros((nseq, nseq, L), 'D')\npsd_mat = np.zeros((2, nseq, nseq, L), 'd')\ncoh_mat = np.zeros((nseq, nseq, L), 'd')\ncoh_var = np.zeros_like(coh_mat)\n\n\n\"\"\"\n\nLooping over the ROIs:\n\n\"\"\"\n\nfor i in range(nseq):\n    for j in range(i):\n\n        \"\"\"\n\n        We calculate the multi-tapered cross spectrum between each two\n        time-series:\n\n        \"\"\"\n\n        sxy = alg.mtm_cross_spectrum(\n           tspectra[i], tspectra[j], (w[i], w[j]), sides='onesided'\n         )\n\n        \"\"\"\n\n        And the individual PSD for each:\n\n        \"\"\"\n\n        sxx = alg.mtm_cross_spectrum(\n           tspectra[i], tspectra[i], w[i], sides='onesided'\n           )\n        syy = alg.mtm_cross_spectrum(\n           tspectra[j], tspectra[j], w[j], sides='onesided'\n           )\n\n        psd_mat[0, i, j] = sxx\n        psd_mat[1, i, j] = syy\n\n        \"\"\"\n\n        Coherence is : $Coh_{xy}(\\lambda) = \\frac{|{f_{xy}(\\lambda)}|^2}{f_{xx}(\\lambda) \\cdot f_{yy}(\\lambda)}$\n\n        \"\"\"\n\n        coh_mat[i, j] = np.abs(sxy) ** 2\n        coh_mat[i, j] \/= (sxx * syy)\n        csd_mat[i, j] = sxy\n\n        \"\"\"\n\n        The variance from the different samples is calculated using a jack-knife\n        approach:\n\n        \"\"\"\n\n        if i != j:\n            coh_var[i, j] = utils.jackknifed_coh_variance(\n               tspectra[i], tspectra[j], eigs, adaptive=True,\n               )\n\n\n\"\"\"\n\nThis measure is normalized, based on the number of tapers:\n\n\"\"\"\n\ncoh_mat_xform = utils.normalize_coherence(coh_mat, 2 * K - 2)\n\n\n\"\"\"\n\nWe calculate 95% confidence intervals based on the jack-knife variance\ncalculation:\n\n\"\"\"\n\nt025_limit = coh_mat_xform + dist.t.ppf(.025, K - 1) * np.sqrt(coh_var)\nt975_limit = coh_mat_xform + dist.t.ppf(.975, K - 1) * np.sqrt(coh_var)\n\n\nutils.normal_coherence_to_unit(t025_limit, 2 * K - 2, t025_limit)\nutils.normal_coherence_to_unit(t975_limit, 2 * K - 2, t975_limit)\n\nif L < n_samples:\n    freqs = np.linspace(0, 1 \/ (2 * TR), L)\nelse:\n    freqs = np.linspace(0, 1 \/ TR, L, endpoint=False)\n\n\n\"\"\"\n\nWe look only at frequencies between 0.02 and 0.15 (the physiologically\nrelevant band, see http:\/\/imaging.mrc-cbu.cam.ac.uk\/imaging\/DesignEfficiency:\n\n\"\"\"\n\nfreq_idx = np.where((freqs > f_lb) * (freqs < f_ub))[0]\n\n\"\"\"\n\nWe extract the coherence and average over all these frequency bands:\n\n\"\"\"\n\ncoh = np.mean(coh_mat[:, :, freq_idx], -1)  # Averaging on the last dimension\n\n\n\"\"\"\n\nThe next line calls the visualization routine which displays the data\n\n\"\"\"\n\n\nfig01 = drawmatrix_channels(coh,\n                            roi_names,\n                            size=[10., 10.],\n                            color_anchor=0,\n                            title='MTM Coherence')\n\n\n\"\"\"\n\n.. image:: fig\/multi_taper_coh_01.png\n\nNext we perform the same analysis, using the nitime object oriented interface.\n\nWe start by initializing a TimeSeries object with this data and with the\nsampling_interval provided above. We set the metadata 'roi' field with the ROI\nnames.\n\n\n\"\"\"\n\nT = TimeSeries(pdata, sampling_interval=TR)\nT.metadata['roi'] = roi_names\n\n\n\"\"\"\n\nWe initialize an MTCoherenceAnalyzer object with the TimeSeries object\n\n\"\"\"\n\nC2 = MTCoherenceAnalyzer(T)\n\n\"\"\"\n\nThe relevant indices in the Analyzer object are derived:\n\n\"\"\"\n\nfreq_idx = np.where((C2.frequencies > 0.02) * (C2.frequencies < 0.15))[0]\n\n\n\"\"\"\nThe call to C2.coherence triggers the computation and this is averaged over the\nfrequency range of interest in the same line and then displayed:\n\n\"\"\"\n\ncoh = np.mean(C2.coherence[:, :, freq_idx], -1)  # Averaging on the last dimension\nfig02 = drawmatrix_channels(coh,\n                            roi_names,\n                            size=[10., 10.],\n                            color_anchor=0,\n                            title='MTCoherenceAnalyzer')\n\n\n\"\"\"\n\n.. image:: fig\/multi_taper_coh_02.png\n\n\nFor comparison, we also perform the analysis using the standard\nCoherenceAnalyzer object, which does the analysis using Welch's windowed\nperiodogram, instead of the multi-taper spectral estimation method (see\n:ref:`resting_state` for a more thorough analysis of this data using this\nmethod):\n\n\"\"\"\n\nC3 = CoherenceAnalyzer(T)\n\nfreq_idx = np.where((C3.frequencies > f_lb) * (C3.frequencies < f_ub))[0]\n\n#Extract the coherence and average across these frequency bands:\ncoh = np.mean(C3.coherence[:, :, freq_idx], -1)  # Averaging on the last dimension\nfig03 = drawmatrix_channels(coh,\n                            roi_names,\n                            size=[10., 10.],\n                            color_anchor=0,\n                            title='CoherenceAnalyzer')\n\n\n\"\"\"\n\n.. image:: fig\/multi_taper_coh_03.png\n\n\nplt.show() is called in order to display the figures:\n\n\n\"\"\"\n\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_426","text":"<reponame>Mingoose\/WriteNoise<filename>app.py\nfrom flask import Flask, render_template, url_for, request, send_file\nimport scipy.io.wavfile\nimport math\nfrom PIL import Image\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os\nimport sys\napp = Flask(__name__)\nos.makedirs(os.path.join(app.instance_path, 'htmlfi'), exist_ok=True)\n\n\n@app.route('\/')\ndef index():\n    return render_template('index.html')\n\n@app.route('\/generic', methods = ['POST', 'GET'])\ndef generic():\n    if request.method == 'POST':\n        uploaded_file = request.files['file']\n        if uploaded_file.filename != '':\n            uploaded_file.save('input.wav')\n            wavtoPNG('input.wav')\n        return render_template('generic.html')\n    return render_template('generic.html')\n\ndef wavtoPNG(wavfile):\n    def sigmoid(x): # condense variables down to 0<x<1   \n        if x < -700:\n            x = -700\n \n        ans = 1\/(1 + math.e ** (-x))\n    \n        return ans\n        \n    def soundToColor(x):\n        a = x\/\/256\n        b = x%256\n        a = min(a,255)\n        b = min(b,255)\n        a = int(a)\n        b = int(b)\n        return a,b\n\n    def stupidBinary(x):\n        print(type(x),file=sys.stderr)\n        r = \"0b\"\n        g = \"0b\"\n        b = \"0b\"\n        a = 255\n        r += x[-9] + x[-6] + x[-12] + x[-15] + x[-1] + \"0\"*3\n        g += x[-8] + x[-5] + x[-11] + x[-14] + x[-3] + \"0\"*3\n        b += x[-7] + x[-4] + x[-10] + x[-13] + x[-2] + \"0\"*3\n        if x[0] == \"-\":\n            a = 128\n        r = int(r,2)\n        g = int(g,2)\n        b = int(b,2)\n        return(r,g,b,a)\n\n\n    out = scipy.io.wavfile.read(wavfile, mmap=False) # read file\n    a,b = out\n    print(out)\n    #plt.plot(b, label=\"Sound Data\")\n    #plt.legend()\n    #plt.xlabel(\"Time [s]\")\n    #plt.ylabel(\"Amplitude\")\n    #plt.show()\n    list1 = b.tolist()\n    list2 = []\n\n    if isinstance(list1[0],list): # if 2d array average elements in subarrays to make 1d array\n        for i in range(len(list1)):\n            total = 0\n            for j in range(len(list1[i])):\n                total += list1[i][j]\n            list2.append(total\/len(list1[i]))\n        \n    if isinstance(list1[0],list):\n        list1 = list2\n    \n\n    for i in range(len(list1)):#turn list into binary\n        list1[i] = bin(int(list1[i]))\n        indB = list1[i].index(\"b\") + 1\n        binary = list1[i][indB:]\n        binary = binary.zfill(16)\n        list1[i] = list1[i][:indB] + binary\n    \n    \n#for i in range(len(list1)):\n#    list1[i] = int(255*sigmoid(list1[i])) # compressing array down to 0<x255\n\n#for i in range(len(list1)):\n #   list1[i] += 32768\n   \n\n    img = Image.new('RGBA',(300,300)) # image creation -- 300,300 is arbitrary\n    pixels = img.load()\n    count = 0\n\n    for i in range(img.size[0]):\n        for j in range(img.size[1]):\n            (r,g,b,a) = stupidBinary(list1[count])\n            pixels[i,j] = (r,g,b,a) # setting rgb values equal to values from list1\n            count += 1\n        \n\n    print(\"done\")\n    img.show()\n    img.save(\"output.png\")\n    # send_file('output.png', as_attachment=True, attachment_filename='output_photo.png')\n    return render_template('index.html')\n\nif __name__ == \"__main__\":\n    app.run(debug=True)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_427","text":"<gh_stars>1-10\n\"\"\"\n\nhttps:\/\/en.wikipedia.org\/wiki\/Orthogonal_coordinates\nhttps:\/\/en.wikipedia.org\/wiki\/Covariance_and_contravariance_of_vectors\nhttps:\/\/en.wikipedia.org\/wiki\/Log-polar_coordinates\nhttps:\/\/en.wikipedia.org\/wiki\/Parabolic_coordinates\nhttps:\/\/en.wikipedia.org\/wiki\/Jacobian_matrix_and_determinant\nhttps:\/\/archive.lib.msu.edu\/crcmath\/math\/math\/p\/p055.htm\nhttps:\/\/en.wikiversity.org\/wiki\/PlanetPhysics\/Transformation_Between_Cartesian_Coordinates_and_Polar_Coordinates\nhttps:\/\/en.wikipedia.org\/wiki\/Elliptic_coordinate_system\nhttps:\/\/en.wikipedia.org\/wiki\/Bipolar_coordinates\nhttps:\/\/www.researchgate.net\/publication\/309803947_A_Note_on_Elliptic_Coordinates\n\n\"\"\"\n\nfrom sympy import *\nfrom sympy.abc import *\n\n\"\"\"\n\nThe matrix for the coordinate transform are not unique, we can parameterize it in some other way.\nDepending on the parameterization, the determinants are different even though the matrix transform gives the same formula at the end.\nIf we want consistency, we like the transformation to and from to preserve the determinant, though the determinant can be 0 for the most part,\nsince in a different coordinate system orientation\/volumes are usually not preserved.\n\nThese coordinate transformation from one coordinate to another are not constant values, so writing it as a matrix doesn't have advantages.\nIf the values were constant we can think of them as a transformation in that coordinate system rather than going to a different coordinate system.\n\nCartesian <-> Polar\nr = sqrt(x^2 + y^2)\nt = atan2(y, x)\n\nx = r*cos(t)\ny = r*sin(t)\n\nCartesian <-> Log Polar\np = log(sqrt(x^2 + y^2))\nt = atan2(y, x)\n\nx = e^p*cos(t)\ny = e^p*sin(t)\n\nCartesian <-> Parabolic\nx = s*t\ny = 0.5*(s*s - t*t)\n\ns = sqrt(sqrt(x^2 + y^2) + y)\nt = sqrt(sqrt(x^2 + y^2) - y)\n\nCartesian <-> Elliptic\n\nLet c be a fixed constant\nu >= 0\n0 <= v <= 2*pi\nx = c*cosh(u)*sinh(v)\ny = c*sinh(u)*sin(v)\n\nB = x^2 + y^2 - c^2\nd = sqrt(B^2 + 4*c^2*y^2)\ne = 2*c^2\np = (-B+d)\/e\nq = (-B-d)\/e\nu = 0.5*ln(1 - 2*q + 2*sqrt(q^2 - q))\n\nv0 = asin(sqrt(p))\nv = v0        [x >= 0, y >= 0]\nv = pi - v0   [x < 0, y >= 0]\nv = pi + v0   [x <= 0, y < 0]\nv = 2*pi - v0 [x > 0, y < 0]\n\n\"\"\"\ndef test_coordinate_matrix():\n    print(\"Coordinate Transformation Matrix\\n\")\n    \n    l = 0.5*sqrt(x**2 + y**2)\n    t = 0.5*atan(y\/x)\n    M = Matrix([[l\/x, l\/y], [t\/x, t\/y]])\n    v = Matrix([x, y])\n    print(\"Cartesian to Polar det(M)={}\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n    M = Matrix([[cos(theta), 0], [sin(theta), 0]])\n    v = Matrix([r, t])\n    print(\"Polar to Cartesian det(M)={}.\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n    l = log(sqrt(x**2 + y**2))\/2\n    M = Matrix([[l\/x, l\/y], [t\/x, t\/y]])\n    v = Matrix([x, y])\n    print(\"Cartesian to Log Polar det(M)={}\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n    M = Matrix([[exp(phi)*cos(theta)\/phi, 0], [exp(phi)*sin(theta)\/phi, 0]])\n    v = Matrix([phi, theta])\n    print(\"Log Polar to Cartesian det(M)={}\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n    a = 0.5*sigma*tau\n    b = 0.25*(sigma**2 - tau**2)\n    M = Matrix([[a\/sigma, a\/tau], [b\/sigma, b\/tau]])\n    v = Matrix([sigma, tau])\n    print(\"Parabolic to Cartesian det(M)={}\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n    print(\"Cartesian to Parabolic det(M)={}\".format(M.det()))\n    a = sqrt(x**2 + y**2)\n    b = 0.5*sqrt(a + y)\n    c = 0.5*sqrt(a - y)\n    M = Matrix([[b\/x, b\/y], [c\/x, c\/y]])\n    v = Matrix([x, y])\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\\n\")\n\n\"\"\"\n\nGiven a coordinate system, we want to generate a transformation matrix that transforms a covariant vector\nThe general matrix can be generated using the following method:\n\nGiven a coordinate system of N variables, we want to transform it into another system of N variables, hence\nwe will have a NxN matrix we shall call A\n\nAij = partial derivative of the ith variable in the second coordinate system with respect to the jth derivative in the first derivative\n\nFor example, for polar to cartesian we have two variables:\n(r, theta) -> (x, y)\n\nA11 = (x, r)\nA12 = (x, theta)\nA21 = (y, r)\nA21 = (y, theta)\n\nWe calculate the partial derivative of those variables and fill the matrix, in general they are also not constant values but some function\n\nIf they were just constant values, the matrix transform will be just be inverse of that matrix.\nThis matrix is also known as the jacobian matrix and its determinant is known as the jacobian determinant.\n\n\"\"\"\n\ndef test_contravariant_matrix():\n    print(\"Contravariant Vector Transformation Matrix\\n\")\n\n    l = sqrt(x**2 + y**2)\n    M = Matrix([[x\/l, y\/l], [-y\/l**2, x\/l**2]])\n    v = Matrix([x, y])\n    print(\"Cartesian to Polar det(M)={}\".format(M.det()))\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\")\n    \n    print(\"Polar to Cartesian det(M)={}\".format(M.det()))\n    M = Matrix([[cos(theta), -r*sin(theta)], [sin(theta), r*cos(theta)]])\n    v = Matrix([r, theta])\n    pprint(simplify(M))\n    pprint(simplify(M@v))\n    print(\"\")\n\ntest_coordinate_matrix()\ntest_contravariant_matrix()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_428","text":"<reponame>erikhvatum\/wautofocuser\n# The MIT License (MIT)\n#\n# Copyright (c) 2014 WUSTL ZPLAB\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n#\n# Authors: <NAME> <<EMAIL>>\n\nimport collections\nfrom misc.image_from_multi_image_statistics import generate_running_percentile_difference\nimport math\nfrom misc.pca import pca_decompose\nimport numpy\nfrom pathlib import Path\nimport scipy.ndimage\nimport scipy.ndimage.morphology\nimport skimage.exposure\nimport skimage.measure\nimport skimage.morphology\nimport skimage.io as skio\nimport sklearn.linear_model\nimport sklearn.neighbors\nimport sklearn.svm\nfor function in ('imread', 'imsave', 'imread_collection'):\n    skio.use_plugin('freeimage', function)\nimport multiprocessing\nimport pickle\nimport sys\n\ndef generate__bf_bgs_masks__fluo_running_differences__bfs__composites(dpath, bgs_mask_alpha=0.3333, running_difference_alpha=0.3333, percentile=20, run_length=10, crop=None):\n    if bgs_mask_alpha > 1 or bgs_mask_alpha < 0 \\\n       or running_difference_alpha > 1 or running_difference_alpha < 0 \\\n       or bgs_mask_alpha + running_difference_alpha > 1:\n        raise ValueError('bgs_mask_alpha and running_difference_alpha must be in the range [0, 1], as must their sum.')\n    dpath = Path(dpath)\n    imfpaths = list((dpath \/ 'bestfmvs').glob('*.PNG'))\n    indexes = sorted([int(imfpath.stem) for imfpath in imfpaths])\n    fluo_running_percentile_difference_generator = generate_running_percentile_difference(percentile, run_length, crop)\n    next(fluo_running_percentile_difference_generator)\n    for index in indexes:\n        try:\n            mask = skio.imread(str(dpath \/ 'MixtureOfGaussianV2BGS' \/ '{}.png'.format(index)))\n        except ValueError as ve:\n            continue\n        if (mask == 255).all():\n            continue\n        fluo = skio.imread(str(dpath \/ 'fluos' \/ '{}.PNG'.format(index)))\n        if crop:\n            mask = mask[:crop[0], :crop[1]]\n            fluo = fluo[:crop[0], :crop[1]]\n        fluo_difference = fluo_running_percentile_difference_generator.send(fluo)\n        if fluo_difference is None:\n            yield\n            continue\n        im = skio.imread(str(dpath \/ 'bestfmvs' \/ '{}.PNG'.format(index)))\n        if crop:\n            im = im[:crop[0], :crop[1]]\n        yield ( \\\n               ( \\\n                ((im.astype(numpy.float32) - im.min()) \/ im.max()) * (1 - bgs_mask_alpha - running_difference_alpha) + \\\n                (mask > 0).astype(numpy.float32) * bgs_mask_alpha + \\\n                (fluo_difference > 2500).astype(numpy.float32) * running_difference_alpha \\\n               ) * 65535 \\\n              ).astype(numpy.uint16)\n\ndef fill_voids(mask, max_pixel_count_void_to_fill):\n    mask = mask.copy()\n    void_labels = skimage.measure.label(~mask)\n    void_regions = skimage.measure.regionprops(void_labels)[1:]\n    void_regions.sort(key=lambda region: region.area)\n    for void_region in void_regions:\n        if void_region.area > max_pixel_count_void_to_fill:\n            break\n        y, x = void_region.coords[0]\n        if mask[y, x]:\n            # Skip island\n            continue\n        # Fill void\n        mask[void_labels == void_region.label] = True\n    return mask\n\ndef generate_masks(dpath, percentile=0, run_length=10, d_threshold=3000, max_void_fill=3000, crop=(2160,2560)):\n    def make_mask(im):\n        mask = im > d_threshold\n        mask = scipy.ndimage.binary_dilation(mask, iterations=5)\n        mask = fill_voids(mask, max_void_fill)\n        return scipy.ndimage.binary_erosion(mask, iterations=4)\n    dpath = Path(dpath)\n    imfpaths = list((dpath \/ 'bestfmvs').glob('*.PNG'))\n    indexes = sorted([int(imfpath.stem) for imfpath in imfpaths])\n    del imfpaths\n    bf_rpdg = generate_running_percentile_difference(100 - percentile, run_length)\n    fluo_rpdg = generate_running_percentile_difference(percentile, run_length)\n    next(bf_rpdg)\n    next(fluo_rpdg)\n    for index in indexes:\n        bf = skio.imread(str(dpath \/ 'bestfmvs' \/ '{}.PNG'.format(index)))\n        fluo = skio.imread(str(dpath \/ 'fluos' \/ '{}.PNG'.format(index)))\n        if crop:\n            bf = bf[:crop[0], :crop[1]]\n            fluo = fluo[:crop[0], :crop[1]]\n        bf = bf_rpdg.send(bf)\n        fluo = fluo_rpdg.send(fluo)\n        if bf is None:\n            yield None\n            continue\n        bf = make_mask(bf)\n        fluo = make_mask(fluo)\n        yield bf & fluo\n\ndef generate__bf_running_differences__fluo_running_differences__bfs__composites(dpath, bf_mask_alpha=0.3333, fluo_mask_alpha=0.3333, percentile=0, run_length=10, crop=None):\n    if bf_mask_alpha > 1 or bf_mask_alpha < 0 \\\n       or fluo_mask_alpha > 1 or fluo_mask_alpha < 0 \\\n       or bf_mask_alpha + fluo_mask_alpha > 1:\n        raise ValueError('bf_mask_alpha and fluo_mask_alpha must be in the range [0, 1], as must their sum.')\n    dpath = Path(dpath)\n    imfpaths = list((dpath \/ 'bestfmvs').glob('*.PNG'))\n    indexes = sorted([int(imfpath.stem) for imfpath in imfpaths])\n    del imfpaths\n    bf_rpdg = generate_running_percentile_difference(100 - percentile, run_length)\n    fluo_rpdg = generate_running_percentile_difference(percentile, run_length)\n    next(bf_rpdg)\n    next(fluo_rpdg)\n    for index in indexes:\n        try:\n            bf = skio.imread(str(dpath \/ 'bestfmvs' \/ '{}.PNG'.format(index)))\n        except ValueError as ve:\n            continue\n        fluo = skio.imread(str(dpath \/ 'fluos' \/ '{}.PNG'.format(index)))\n        if crop:\n            mask = mask[:crop[0], :crop[1]]\n            fluo = fluo[:crop[0], :crop[1]]\n        fluo_difference = fluo_rpdg.send(fluo)\n        if fluo_difference is None:\n            yield\n            continue\n        im = skio.imread(str(dpath \/ 'bestfmvs' \/ '{}.PNG'.format(index)))\n        if crop:\n            im = im[:crop[0], :crop[1]]\n        yield ( \\\n               ( \\\n                ((im.astype(numpy.float32) - im.min()) \/ im.max()) * (1 - bgs_mask_alpha - running_difference_alpha) + \\\n                (mask > 0).astype(numpy.float32) * bgs_mask_alpha + \\\n                (fluo_difference > 2500).astype(numpy.float32) * running_difference_alpha \\\n               ) * 65535 \\\n              ).astype(numpy.uint16)\n\ndef overlay__masks__bfs__in_flipbook(dpath, rw, mask_alpha, mask_name='masks'):\n    dpath = Path(dpath)\n    imfpaths = list((dpath \/ 'bestfmvs').glob('*.PNG'))\n    indexes = sorted([int(imfpath.stem) for imfpath in imfpaths])\n    cs = []\n    for index in indexes:\n        try:\n            mask = skio.imread(str(dpath \/ mask_name \/ '{}.png'.format(index)))[:2160,:2560]\n        except ValueError as ve:\n            try:\n                mask = skio.imread(str(dpath \/ mask_name \/ '{:04}.png'.format(index)))[:2160,:2560]\n            except ValueError as ve:\n                continue\n        if not (mask == 255).all():\n            im = skio.imread(str(dpath \/ 'bestfmvs' \/ '{}.PNG'.format(index)))[:2160,:2560]\n            cs.append((((im.astype(numpy.float32) \/ 65535) * (1 - mask_alpha) + (mask > 0).astype(numpy.float32) * mask_alpha)*65535).astype(numpy.uint16))\n    rw.showImagesInNewFlipper(cs)\n\ndef make_multiclassifier_data_and_targets(im_fpath, mask_set_fpath, patch_width=9, background_sample_count=2000, worm_interior_sample_count=400, worm_wall_sample_count=100,\n                                     pca_pcs=None, pca_means=None):\n    mask_set_fpath_str = str(mask_set_fpath)\n    imf = skimage.exposure.equalize_adapthist(skio.imread(str(im_fpath))).astype(numpy.float32)\n    if imf.max() > 1:\n        # For some reason, skimage.exposure.equalize_adapthist rescales to [0, 1] on OS X but not on Linux.\n        # [0, 1] scaling is desired.\n        imf -= imf.min()\n        imf \/= imf.max()\n    masks = [\n        ('_worm_interior.png', worm_interior_sample_count, 1),\n        ('_worm_wall.png', worm_wall_sample_count, 2),\n        ('_valid_exterior.png', background_sample_count, 0)]\n    labels = []\n    vectors = []\n    for mask_fpath_suffix, sample_count, label in masks:\n        coords = select_random_coords_in_mask(mask_set_fpath_str + mask_fpath_suffix, sample_count)\n        for coord in coords:\n            vector = make_patch_feature_vector(imf, patch_width, coord)\n            labels.append(label)\n            vectors.append(vector)\n    if pca_pcs is not None:\n        vectors = pca_decompose(vectors, pca_pcs, pca_means)\n    else:\n        vectors = numpy.array(vectors)\n    return vectors, numpy.array(labels)\n\nif __name__ == '__main__':\n    def _worker_process_function(dpath, percentile, run_length, d_threshold, max_void_fill, crop):\n        mask_dpath = dpath \/ 'masks'\n        if not mask_dpath.exists():\n            mask_dpath.mkdir()\n        for idx, mask in enumerate(generate_masks(dpath, percentile, run_length, d_threshold, max_void_fill, crop)):\n            if mask is None:\n                continue\n            skio.imsave(str(mask_dpath \/ '{:04}.png'.format(idx)), mask.astype(numpy.uint8) * 255)\n\n    def _process_exception_callback(process_exception):\n        print('warning: worker failed with exception:', process_exception)\n\n    import argparse\n    import os\n    argparser = argparse.ArgumentParser(description='Experiment01_a data and target set generator.')\n    argparser.add_argument('--wellDevelopmentalSuccessDb',\n                           default=Path(os.path.expanduser('~')) \/ 'Data' \/ 'experiment01_a' \/ 'well_developmental_success_db.pickle',\n                           type=Path)\n    argparser.add_argument('--experiment01_a',\n                           default=Path(os.path.expanduser('~')) \/ 'Data' \/ 'experiment01_a',\n                           type=Path)\n    argparser.add_argument('--percentile', default=0, type=float)\n    argparser.add_argument('--run-length', default=10, type=int)\n    argparser.add_argument('--d-threshold', default=3000, type=int)\n    argparser.add_argument('--max-void-fill', default=3000, type=int)\n    argparser.add_argument('--crop', default='None', type=str, help='Specify a 2 element tuple (y, x), or None to disable')\n    args = argparser.parse_args()\n    with open(str(args.wellDevelopmentalSuccessDb), 'rb') as f:\n        well_developmental_success_db = pickle.load(f)\n    with multiprocessing.Pool(multiprocessing.cpu_count() + 1) as pool:\n        async_results = []\n        for p, s in sorted(well_developmental_success_db.items(), key=lambda v: v[0]):\n            if s != 'LittleOrNone':\n                async_results.append(pool.apply_async(_worker_process_function,\n                                                      (args.experiment01_a \/ p.parts[-1],\n                                                       args.percentile,\n                                                       args.run_length,\n                                                       args.d_threshold,\n                                                       args.max_void_fill,\n                                                       eval(args.crop)),\n                                                      error_callback=_process_exception_callback))\n        pool.close()\n        pool.join()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_429","text":"<gh_stars>1-10\n\"\"\"\nThis class stores a dense list of sparse matrices. For external memory \nusage, it writes each sparse matrix to a matrix market format file in a\ndirectory. Then, that directory is gzipped to make the file a bit portable.\n\"\"\"\n\nimport os\nimport shutil\nimport tarfile\n\nimport pyllars.utils as utils\n\nimport numpy as np\nimport scipy.io\nimport scipy.sparse\n\n# tolerance value for checking equality\ntolerance = 1e-10\n\nclass ExternalSparseMatrixList:\n    def __init__(self, size, tarfile_contents=None, tarfile_names=None):\n        self.sparse_matrix_list = [None] * size\n        self.tarfile_contents = tarfile_contents\n        self.tarfile_names = tarfile_names\n\n    def __getitem__(self, key):\n        # check if we should try to fetch this\n        if (self.sparse_matrix_list[key] is None) and (self.tarfile_contents is not None):\n            fn = '{}.mtx'.format(key)\n            if fn in self.tarfile_names:\n                f = self.tarfile_contents.extractfile(fn)\n                m = scipy.io.mmread(f)\n                self[key] = scipy.sparse.csr_matrix(m)\n            else:\n                self[key] = scipy.sparse.csr_matrix((1,0))\n\n        return self.sparse_matrix_list[key]\n\n    def __setitem__(self, key, item):\n        self.sparse_matrix_list[key] = item\n\n    def write(self,filename, overwrite=False):\n        # first, strip the compression ending, if present\n        filename = filename.replace('.tar.gz', '')\n        filename = filename.replace('.tgz', '')\n\n        # check that the path is safe\n        if os.path.exists(filename) and not overwrite:\n            raise OSError(\"Attempting to overwrite existing file: '{}'\".format(filename))\n\n        if os.path.exists(filename):\n            if os.path.isfile(filename):\n                os.remove(filename)\n            else:\n                shutil.rmtree(filename)\n\n        # create the folder\n        os.makedirs(filename)\n\n        # first, write the metadata (just the size)\n        fn = os.path.join(filename, \"meta.txt\")\n        with open(fn, 'w') as f:\n            f.write(str(len(self)))\n\n        # write each matrix in MM format\n        for i in range(len(self.sparse_matrix_list)):\n            sm = self.sparse_matrix_list[i]\n            if sm is None:\n                continue\n            fn = os.path.join(filename, str(i))\n            scipy.io.mmwrite(fn, sm)\n\n        # create the tgz file\n        fn = '{}.tar.gz'.format(filename)\n        tar = tarfile.open(fn, \"w:gz\")\n        tar.add(filename, arcname='')\n        tar.close()\n\n        # remove the folder\n        shutil.rmtree(filename)\n\n        # and rename the tgz file\n        os.rename(fn, filename)\n\n    def __len__(self):\n        return len(self.sparse_matrix_list)\n    \n    def __eq__(self, other):\n        # make sure they are the same size\n        if len(self) != len(other):\n            return False\n        \n        # check that each element is equal\n        for i in range(len(self)):\n            diff = self[i] - other[i]\n            if diff.nnz != 0:\n                # check if the nonzero values exceed the tolerance\n                nonzeros = diff[diff.nonzero()]\n                nonzeros = np.squeeze(np.asarray(nonzeros))\n                for nz in nonzeros:\n                    if np.abs(nz) > tolerance:\n                        return False\n                        \n        # the all elements are equal\n        return True\n\n    def sum(self):\n        \"\"\" This method calculates the sum of all matrices in the list.\n\n        Returns:\n            dtype: the sum of all matrices\n        \"\"\"\n        s = sum(matrix.sum() for matrix in self.sparse_matrix_list if matrix is not None)\n        return s\n\n\n    def max_len(self, axis=1):\n        \"\"\" This method finds the maximum size of any matrix along the given \n            axis. Presumably, this is for use by the to_sparse_matrix method,\n            but it could have other uses.\n            \n            Args:\n                axis (int): 0 for rows, 1 for columns (i.e., matrix.shape[axis])\n\n            Returns:\n                int: the maximum length along the given axis of any matrix.\n        \"\"\"\n        l = list(matrix.shape[axis] for matrix in self.sparse_matrix_list if matrix is not None)\n        if len(l) == 0:\n            return 0\n\n        max_len = max(l)\n        return max_len\n\n    def to_sparse_matrix(self, min_cols=None):\n        \"\"\" This method attempts to convert the sparse matrix list into a\n            single sparse matrix. This operation iterates over the columns\n            of the first row of each matrix. So it is only sensible if the\n            matrix list consists of a set of column vectors.\n\n            For some cases, the number of columns in the matrix should exceed\n            the number of columns in the longest matrix. If this is the case,\n            the number of columns can be specified.\n            \n            NOTE: This method does not do any type checking.\n\n            Returns:\n                scipy.sparse matrix: A sparse matrix in which each item in\n                    the list is treated as a row in the matrix\n\n                    OR\n\n                    None, if the list contains no items\n        \"\"\"\n        # create a 2d numpy array that contains all of the rows\n        max_len = self.max_len()\n\n        if (min_cols is not None) and (max_len < min_cols):\n            max_len = min_cols\n\n        # determine the dtype\n        dtype = None\n        for i in range(len(self)):\n            if self[i] is not None:\n                dtype = self[i].dtype\n                break\n\n        # make sure we found something\n        if dtype is None:\n            return None\n\n        sparse_matrix = scipy.sparse.lil_matrix((len(self), max_len), dtype=dtype)\n        \n        # transfer all of the values over to the sparse array\n        for i in range(len(self)):\n            sv = self[i]\n            if sv is None:\n                continue\n\n            sv = sv.tocoo()\n\n            for j,k,v in zip(sv.row, sv.col, sv.data):\n                sparse_matrix[i,k] = v\n\n        return sparse_matrix \n\ndef lazy_read_external_sparse_matrix_list(filename):\n\n    # open the gzipped tar file\n    contents = tarfile.open(filename, \"r:gz\")\n    names = contents.getnames()\n\n    # read the meta file\n    fn = 'meta.txt'\n    f = contents.extractfile(fn)\n    size = int(f.readline())\n    f.close()\n\n    # create the container\n    esml = ExternalSparseMatrixList(size, tarfile_contents=contents, tarfile_names=names)\n    return esml\n\ndef read_external_sparse_matrix_list(filename):\n    # open the gzipped tar file\n    contents = tarfile.open(filename, \"r:gz\")\n    names = contents.getnames()\n\n    # read the meta file\n    fn = 'meta.txt'\n    f = contents.extractfile(fn)\n    size = int(f.readline())\n    f.close()\n\n    # create the container\n    esml = ExternalSparseMatrixList(size)\n\n    # read in each sparse matrix\n    for i in range(size):\n        fn = '{}.mtx'.format(i)\n\n        if fn in names:\n            f = contents.extractfile(fn)\n            m = scipy.io.mmread(f)\n            esml[i] = scipy.sparse.csr_matrix(m)\n        else:\n            esml[i] = scipy.sparse.csr_matrix((1,0))\n\n    return esml\n\ndef concatenate(lists):\n    total_size = 0\n    for l in lists:\n        total_size += len(l)\n\n    joined_list = ExternalSparseMatrixList(total_size)\n    index = 0\n    for i in range(len(lists)):\n        l = lists[i]\n        for j in range(len(l)):\n            # convert just to make absolutely sure this is a sparse matrix\n            joined_list[index] = scipy.sparse.lil_matrix(l[j])\n            index += 1\n\n    return joined_list\n\ndef to_sparse_matrix(list_of_sparse_row_vectors):\n    \"\"\" This function converts a list of sparse row vectors, i.e., sparse\n        matrices with a shape like (1, X), into a single sparse matrix. Each\n        row of the resulting matrix corresponds to the respective sparse row\n        vector in the input list.\n\n        Args:\n            list_of_sparse_row_matrices (list of scipy.sparse): a list of scipy\n                sparse matrices with shape (1,X).\n\n        Returns:\n            scipy.sparse.lil_matrix: a sparse matrix in which the rows\n                correspond to the vectors in the list. The dimension of the\n                matrix is (N, Y), where N is the number of items in the list\n                and Y is the largest size of any input matrix.\n\n        Imports:\n            logging\n\n        Raises:\n            ValueError: if any of the input matrices do not have a shape of\n                the form (1, X)\n    \"\"\"\n    import logging\n\n    esml = ExternalSparseMatrixList(len(list_of_sparse_row_vectors))\n\n    msg = \"Copying sparse row vectors to sparse matrix list\"\n    logging.info(msg)\n\n    for i, sparse_row_vector in enumerate(list_of_sparse_row_vectors):\n        if sparse_row_vector.shape[0] != 1:\n            msg = (\"list_of_sparse_row_vectors[{}] did not have the correct shape. \"\n                \"Expected something of the form (1,X); found: ({},{})\".format(i,\n                sparse_row_vector.shape[0], sparse_row_vector.shape[1]))\n            raise ValueError(msg)\n\n        esml[i] = sparse_row_vector\n\n    msg = \"Converting matrix list to single sparse matrix\"\n    logging.info(msg)\n\n    sparse_matrix = esml.to_sparse_matrix()\n\n    return sparse_matrix\n\n\n\ndef main():\n    # create a random sparse matrix list\n    esml = ExternalSparseMatrixList(3)\n    for i in range(3):\n        esml[i] = scipy.sparse.rand(8, 4, density=0.4)\n\n    # write it to disk\n    esml.write('test_esml', True)\n\n    # read it back\n    esml_read = read_external_sparse_matrix_list('test_esml')\n    \n    # make sure they are equal\n    assert(esml_read == esml)\n\n    print(\"TEST SUCCEEDED: The created sparse matrix list and the one read \"\n        \"from disk are equal.\")\n\nif __name__ == '__main__':\n    main()\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_430","text":"<gh_stars>0\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import signal\nimport math\n\n# def butter_highpass_filter(f_s, f_pass, f_stop, fs = 0.5, td = 1, g_pass = 1, g_stop = 50, wc = None):\n#     \"\"\"\n#     Return explanation:\n#     N: number of orders\n#     b: numerator of the Filter\n#     a: denominator of the filter\n#     \"\"\"\n#     wp = f_pass \/ (f_s \/ 2)\n#     ws = f_stop \/ (f_s \/ 2)\n#     omega_p = (2 \/ td) * np.tan(wp \/ 2)\n#     omega_s = (2 \/ td) * np.tan(ws \/ 2)\n#     # Find the order and natural frequency of the highpass filter\n#     N, wn = signal.buttord(omega_p, omega_s, g_pass, g_stop, analog = True)\n#     # Find the Gain of the highpass filter\n#     if wc:\n#         b, a = signal.butter(N, wc, btype = 'high', analog = True)\n#         wn = wc\n#     else:\n#         b, a = signal.butter(N, wn, btype = 'high', analog = True)\n#     return N, b, a, wn\n\ndef butter_highpass_filter(fs, fc, order = 5):\n    \"\"\"\n    Function explanation:\n    fs: sampling rate\n    fc: cutoff frequency\n    order: Number of orders\n    Return: denominator and numerator of the filter's transfer function\n    \"\"\"\n    nyq = 0.5 * fs\n    normal_fc = fc \/ nyq\n    b, a = signal.butter(order, normal_fc, btype = 'high', analog = False)\n    return b, a\n\ndef butter_bandpass_filter(fs, lowcut, highcut, order = 5):\n    \"\"\"\n    Function explanation:\n    fs: sampling rate\n    lowcut: lowcut Frequency\n    highcut:highcut Frequency\n    order: Number of orders\n    Return: denominator and numerator of the filter's transfer function\n    \"\"\"\n    nyq = 0.5 * fs\n    low = lowcut \/ nyq\n    high = highcut \/ nyq\n    b, a = butter(order, [low, high], btype = 'band', analog = False)\n    return b, a\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_423","text":"from __future__ import with_statement\nfrom __future__ import division\nfrom __future__ import absolute_import\nimport numpy as np\nimport tensorflow as tf\nimport scipy.signal\nfrom gym.spaces import Box, Discrete\n\nEPS = 1e-8\n\ndef combined_shape(length, shape=None):\n    if shape is None:\n        return (length,)\n    if(np.isscalar(shape)):\n        return (length, shape)\n    else:\n        l = list(shape)\n        l.insert(0, length)\n        l = tuple(l)\n        return l\n#        tp = (length, shape)\n#        return convert([element for tupl in tp for element in tupl])\n\ndef placeholder(dim=None):\n    return tf.placeholder(dtype=tf.float32, shape=combined_shape(None,dim))\n\ndef placeholders(*args):\n    return [placeholder(dim) for dim in args]\n\ndef placeholder_from_space(space):\n    if isinstance(space, Box):\n        return placeholder(space.shape)\n    elif isinstance(space, Discrete):\n        return tf.placeholder(dtype=tf.int32, shape=(None,))\n    raise NotImplementedError\n\ndef placeholders_from_spaces(*args):\n    return [placeholder_from_space(space) for space in args]\n\ndef mlp(x, hidden_sizes=(32,), activation=tf.tanh, output_activation=None):\n    for h in hidden_sizes[:-1]:\n        x = tf.layers.dense(x, units=h, activation=activation)\n    x = tf.layers.dense(x, units=hidden_sizes[-1], activation=output_activation)\n    return x\n\ndef get_vars(scope=u''):\n    return [x for x in tf.trainable_variables() if scope in x.name]\n\ndef count_vars(scope=u''):\n    v = get_vars(scope)\n    return sum([np.prod(var.shape.as_list()) for var in v])\n\ndef gaussian_likelihood(x, mu, log_std):\n    pre_sum = -0.5 * (((x-mu)\/(tf.exp(log_std)+EPS))**2 + 2*log_std + np.log(2*np.pi))\n    return tf.reduce_sum(pre_sum, axis=1)\n\ndef discount_cumsum(x, discount):\n    u\"\"\"\n    magic from rllab for computing discounted cumulative sums of vectors.\n\n    input:\n        vector x,\n        [x0,\n         x1,\n         x2]\n\n    output:\n        [x0 + discount * x1 + discount^2 * x2,\n         x1 + discount * x2,\n         x2]\n    \"\"\"\n    return scipy.signal.lfilter([1], [1, float(-discount)], x[::-1], axis=0)[::-1]\n\ndef nextOrderPolynomial(x, length, lastOrderPolynomial, incrementList):\n    #empty list for next order\n    nextOrderPolynomial = []\n\n    for i in xrange(length):\n        for j in xrange(incrementList[i]):\n            nextOrderPolynomial.append(tf.multiply(x[:,i],lastOrderPolynomial[j]))\n\n    return nextOrderPolynomial\n\ndef nextIncrementList(incrementList):\n    nextIncrementList = [1]\n    for i in xrange(len(incrementList)-1):\n        nextIncrementList.append(nextIncrementList[i]+incrementList[i+1])\n    return nextIncrementList\n\n\ndef polynomial(x, order, u_dim):\n    u\"\"\" Computes u, a polynomial function of x (for each row of x).\n    Polynomial will be composed of monomials of degree up to and including\n    the specified 'order'.\n    \"\"\"\n    NUM_STATE_DIMS = x.get_shape().as_list()[-1]\n\n    print u\"Generating monomials...\"\n    FullPolynomial = []\n    z = tf.ones_like(x[:,0])\n    FullPolynomial.append(z)\n    incrementList = []\n    lastPolynomial = []\n    for i in xrange(NUM_STATE_DIMS):\n        incrementList.append(i+1)\n        lastPolynomial.append(x[:,i])\n\n\n    #generate full polynomial\n    FullPolynomial.extend(lastPolynomial)\n    for i in xrange(order - 1):\n        nextPolynomial = nextOrderPolynomial(x,NUM_STATE_DIMS,lastPolynomial,incrementList)\n        FullPolynomial.extend(nextPolynomial)\n        incrementList = nextIncrementList(incrementList)\n        lastPolynomial = nextPolynomial\n    print u\"number of monomials: \", len(FullPolynomial)\n    print u\"...done!\"\n\n\n    # Now declare tf variables for the coefficients of all these monomials.\n    coeffs = tf.get_variable(u\"polynomial_coefficients\",\n                             initializer=tf.zeros((len(FullPolynomial), u_dim)),dtype=tf.float32)\n\n    FullPolynomial = tf.transpose(tf.stack(FullPolynomial))\n\n    # Compute polynomial output for each state.\n    action = tf.matmul(FullPolynomial,coeffs)\n    return action\n\nu\"\"\"\nPolicies\n\"\"\"\n\n\ndef mlp_categorical_policy(x, a, hidden_sizes, activation, output_activation, action_space):\n    act_dim = action_space.n\n    logits = mlp(x, list(hidden_sizes)+[act_dim], activation, None)\n    logp_all = tf.nn.log_softmax(logits)\n    pi = tf.squeeze(tf.multinomial(logits,1), axis=1)\n    logp = tf.reduce_sum(tf.one_hot(a, depth=act_dim) * logp_all, axis=1)\n    logp_pi = tf.reduce_sum(tf.one_hot(pi, depth=act_dim) * logp_all, axis=1)\n    return pi, logp, logp_pi\n\n\ndef mlp_gaussian_policy(x, a, hidden_sizes, activation, output_activation, action_space):\n    act_dim = a.shape.as_list()[-1]\n    mu = mlp(x, list(hidden_sizes)+[act_dim], activation, output_activation)\n    log_std = tf.get_variable(name=u'log_std', initializer=-0.5*np.ones(act_dim, dtype=np.float32))\n    std = tf.exp(log_std)\n    pi = mu + tf.random_normal(tf.shape(mu)) * std\n    logp = gaussian_likelihood(a, mu, log_std)\n    logp_pi = gaussian_likelihood(pi, mu, log_std)\n    return pi, logp, logp_pi\n\ndef polynomial_gaussian_policy(x, a, order, action_space):\n    act_dim = a.shape.as_list()[-1]\n    mu = polynomial(x, order, act_dim)\n    log_std = tf.get_variable(name=u'log_std', initializer=-1.5*np.ones(act_dim, dtype=np.float32))\n    std = tf.exp(log_std)\n    pi = mu + tf.random_normal(tf.shape(mu)) * std\n    logp = gaussian_likelihood(a, mu, log_std)\n    logp_pi = gaussian_likelihood(pi, mu, log_std)\n    return pi, logp, logp_pi\n\n\nu\"\"\"\nActor-Critics\n\"\"\"\ndef mlp_actor_critic(x, a, hidden_sizes=(64,64), activation=tf.tanh,\n                     output_activation=None, policy=None, action_space=None):\n\n    # default policy builder depends on action space\n    if policy is None and isinstance(action_space, Box):\n        policy = mlp_gaussian_policy\n    elif policy is None and isinstance(action_space, Discrete):\n        policy = mlp_categorical_policy\n\n    with tf.variable_scope(u'pi'):\n        pi, logp, logp_pi = policy(x, a, hidden_sizes, activation, output_activation, action_space)\n    with tf.variable_scope(u'v'):\n        # DFK modified: want unbiased gradient estimate, so replacing MLP with\n        # zero (for all states).\n        # TODO(@eric): figure out how to do this right and not just multiply by zero.\n        #v = tf.zeros_like(x)\n        v = 0.0 * tf.squeeze(mlp(x, list(hidden_sizes)+[1], activation, None), axis=1)\n    return pi, logp, logp_pi, v\n\ndef polynomial_actor_critic(x, a, order, policy=None, action_space=None):\n    # default policy builder depends on action space\n    if policy is None and isinstance(action_space, Box):\n        policy = polynomial_gaussian_policy\n    elif policy is None and isinstance(action_space, Discrete):\n        assert(False)\n\n    with tf.variable_scope(u'pi',reuse=tf.AUTO_REUSE):\n        pi, logp, logp_pi = policy(x, a, order, action_space)\n    with tf.variable_scope(u'v',reuse=tf.AUTO_REUSE):\n        # DFK modified: want unbiased gradient estimate, so replacing MLP with\n        # zero (for all states).\n        # TODO(@eric): figure out how to do this right and not just multiply by zero.\n        v = 0.0 * tf.squeeze(mlp(x, list((1,1))+[1], tf.tanh, None), axis=1)\n    return pi, logp, logp_pi, v\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_431","text":"#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\nimport math\nimport os\nimport pickle\n\nimport matplotlib\nimport matplotlib.gridspec as gridspec\nimport numpy as np\nimport scipy\nfrom mat4py import loadmat\nfrom matplotlib import pyplot as plt\nfrom mpl_toolkits.mplot3d.art3d import Poly3DCollection\n\nimport plotly.graph_objects as go\nfrom plotly.subplots import make_subplots\n\nimport time\nimport multiprocessing as mp\n\nimport plotly.offline as py\nimport plotly.graph_objs as go\nfrom matplotlib import cm\n\nfrom dependencies import ROOTDIR\nfrom utils.HelperFunctions import Output, Configuration, Imaging\n\n\nclass PlotRoutines: #  656 lines so far\n    \"\"\"Plots results from the electrode reconstruction\/model creation in order to validate the results\"\"\"\n\n    def __init__(self, subject, inputfolder=''):\n        self.cfg = Configuration.load_config(ROOTDIR)\n        self.debug=False\n        GetData()\n        # TODO: new order with a) get 'static data' such as background, trajectory, lead_model, b) plot all results.\n        # TODO: c) include some variable data (markers, rotation) and add some callback functions in form of arrows\n\n        # Get static data, that is lead data, backgrounds and trajectories\n        filename_leadmodel = os.path.join(inputfolder, 'elecModels_' + subject + '.pkl')\n        lead_data_raw, intensityProfiles, skelSkalms = self.load_leadModel(inputfolder, filename=filename_leadmodel)\n        lead_data, sides = self.estimate_hemisphere(lead_data_raw) # determines which side is used in lead_data\n        lead_model, default_positions, default_coordinates = GetData.get_default_lead(lead_data_raw[0])  # all in [mm]\n\n        # Get initial data for both leads\n        marker, coordinates, trajectory, resize, emp_dist = [{} for _ in range(5)]\n        for hemisphere in sides:\n            marker[hemisphere], coordinates[hemisphere], trajectory[hemisphere], resize[hemisphere] = \\\n                GetData.get_leadModel(self, lead_data[hemisphere], default_positions, default_coordinates, side=hemisphere)\n            _, emp_dist[hemisphere] = GetData.resize_coordinates(self, coordinates[hemisphere], lead_data[hemisphere])\n            _, lead_data[hemisphere]['trajectory'], _, marker_temp = \\\n                GetData.resolve_coordinates(self, marker[hemisphere], default_coordinates, default_positions,\n                                            lead_data[hemisphere], resize_bool=resize[hemisphere],\n                                            rszfactor=emp_dist[hemisphere]) # This part doesn't do anything meaningful!\n\n        # Get data for xy-plane estimation\/plot\n        intensity_matrix, bounding_box, fitvolume = GetData.multiprocessing_xyplanes(self, lead_data, trajectory)\n\n        # Start plotting the 'fixed parts', that is lead model (left) and CT intensitiy planes (middle)\n        # fig, grid = self.create_figure()\n        # fig, layout = self.create_figure_plotly()\n        layout = self.create_figure_plotly()\n        data = []\n        data = self.plotCTintensitiesPlotLy(intensity_matrix['left'], fitvolume['left'], data)\n\n        fig = go.Figure(\n            data=data,\n            layout=layout)\n        fig.show()\n        # https:\/\/community.plotly.com\/t\/moving-the-location-of-a-graph-point-interactively\/7161\/2 # TODO Next steps\n        # CTintensitiesLeft = fig.add_subplot(grid[0:3,0], facecolor='None', projection='3d')\n        # CTintensitiesLeft = self.plotCTintensitiesNEW(CTintensitiesLeft, intensity_matrix['left'],\n        #                                              bounding_box['left'], fitvolume['left'], trajectory['left'])\n\n        # CTintensitiesRight = fig.add_subplot(grid[0:,2:3], facecolor='None', projection='3d')\n\n        self.interactive_plot(lead_data['right'], intensityProfiles, skelSkalms)\n\n    @staticmethod\n    def estimate_hemisphere(lead_data):\n        \"\"\"estimates the available sides and returns a list of all available leads; as all data is in LPS (Left,\n        Posterior, Superior) so that side can be deduced from trajectory\"\"\"\n\n        sides = []\n        renamed_lead_data = dict()\n        for info in lead_data:\n            side_temp = 'right' if not info['trajectory'][0, 0] > info['trajectory'][-1, 0] else 'left'\n            renamed_lead_data[side_temp] = info\n            sides.append(side_temp)\n        return renamed_lead_data, sides\n\n    def create_figure(self, num_cols=2, num_rows=2):\n        \"\"\"creates a figure which is filled with content in later steps\"\"\"\n        fig = plt.figure(facecolor=np.append(np.array([.64] * 3), .25), frameon=False)\n        col_width = [5, 1]\n        row_height = [5, 1]\n        grid = gridspec.GridSpec(ncols=int(num_cols), nrows=int(num_rows), figure=fig, width_ratios=col_width,\n                                 height_ratios=row_height, hspace=0.08, wspace=0.1)\n        return fig, grid\n\n    def create_figure_plotly(self, num_cols=3, num_rows=1):\n        \"\"\"creates a figure which is filled with content in later steps\"\"\"\n        #fig = make_subplots(\n        #    rows=num_rows, cols=num_cols,\n        #    column_widths=[0.6, 0.4],\n        #    row_heights=[0.4, 0.6],\n        #    specs=[[{'is_3d': True}, {'is_3d': True}, {'is_3d': False}]],\n        #    subplot_titles=['model', 'data', 'xplane'])\n\n        axis = dict(showbackground=True,\n                    backgroundcolor=\"rgb(230, 230,230)\",\n                    gridcolor=\"rgb(255, 255, 255)\",\n                    zerolinecolor=\"rgb(255, 255, 255)\",\n                    )\n\n        layout = go.Layout(\n            width=700,\n            height=700,\n            # scene=go.layout.Scene(xaxis=go.layout.XAxis(axis),\n            #               yaxis=go.layout.YAxis(axis),\n            #               zaxis=go.layout.ZAxis(axis, range=[-2, 2]),\n            #               aspectratio=dict(x=1, y=1, z=1),\n            #               ),\n        )\n\n#        return fig, layout\n        return layout\n\n    def interactive_plot(self, lead_data, intensityProfiles, skelSkalms):\n        \"\"\" Start plotting routine according to Lead-DBS implementation [ea_autocoord and ea_manualreconstruction]\"\"\"\n\n        lead_model, default_positions, default_coordinates = GetData.get_default_lead(lead_data)  # all in [mm]\n\n        # Get estimated positions, coordinates, rotation information and markers for leads\n        marker, coordinates, trajectory, resize = GetData.get_leadModel(self, lead_data, default_positions,\n                                                                        default_coordinates, 'right')\n\n        #TODO: elecModels should be updated somehow\n\n        coords_temp, emp_dist = GetData.resize_coordinates(self, coordinates, lead_data)\n        mean_empdist = np.mean(emp_dist)\n\n        _, lead_data['trajectory'], _, marker_temp = \\\n            GetData.resolve_coordinates(self, marker, default_coordinates, default_positions, lead_data,\n                                        resize_bool=resize, rszfactor=mean_empdist)\n        lead_data = GetData.leadInformation_update(marker_temp, lead_data) # TODO doesn't make sense as markers donÄt change at this point\n\n        # Start plotting\n        # fig = plt.figure(facecolor=self.getbgsidecolor(side=0), tight_layout=True) # TODO: is it really the side, what is this color actually\n        fig = plt.figure(facecolor=np.append(np.array([.64] * 3), .25), tight_layout=True)  # TODO: is it really the side, what is this color actually\n\n        #fig.set_tight_layout(True)\n        width = [1, 10, 10, 1]\n        height = [1, 25, 1]\n        grid = gridspec.GridSpec(ncols=4, nrows=3, figure=fig, width_ratios=width, height_ratios=height,\n                                 hspace=0.08, wspace=0.1)\n\n        grid_indices = [(0,-1), (0,-1)]\n        self.plotCTintensities(lead_data, coordinates, trajectory, fig, grid, grid_indices)\n\n        grid_indices = [(-1), (-1)]\n        self.plot_leadInformation(lead_data, mean_empdist, fig, grid, grid_indices)\n\n        self.plotCTaxial(lead_data, fig, grid, cmap='gist_gray')\n        self.plot_leadModel(lead_model, fig, grid)\n\n    @staticmethod\n    def get_the_slice(x, y, z, surfacecolor, colorscale='gray', showscale=False):\n        return go.Surface(x=x,  # https:\/\/plot.ly\/python\/reference\/#surface\n                          y=y,\n                          z=z,\n                          surfacecolor=surfacecolor,\n                          colorscale=colorscale,\n                          showscale=showscale,\n                          name=\"\")\n\n\n    def plotCTintensitiesPlotLy(self, intensity_matrix, fitvolume, data):\n        \"\"\"function plotting perpendicular images of the intensities obtained from trajectory coordinates; separate\n        function needed here as changes occur in trejectories\/markers\"\"\"\n\n        for idx, (direction, intensity) in enumerate(intensity_matrix.items()):\n            matrix2plot = (intensity - np.min(intensity)) \/ (np.max(intensity) - np.min(intensity))  # Prepare data!\n            X, Y, Z = fitvolume[direction][0, :, :], fitvolume[direction][1, :, :], fitvolume[direction][2, :, :]\n            slice_temp = self.get_the_slice(X,Y,Z, matrix2plot)\n            data.append(slice_temp)\n\n        return data\n\n        # TODO this part goes somewhere else as it is the dynamic part to be changed by using arrows\n        # for c in coordinates:\n        #     self.plot_coordinates(c, mainax1, marker='p', s=250)\n\n        # Start plotting the markers for the 'head' and 'tail' of the lead\n        # marker_plot = dict([(k, r) for k, r in lead_model.items() if k.startswith('marker')])\n        # self.plot_coordinates(marker_plot[\"markers_head\"], mainax1, marker='o', facecolor='g', edgecolor='g',\n        #                      linewidth=1.5)\n        # self.plot_coordinates(marker_plot[\"markers_tail\"], mainax1, marker='o', facecolor='r', edgecolor='r',\n        #                      linewidth=1.5)\n        # mainax1.set_zlim(np.multiply(mainax1.get_zlim(), [1, .98]))\n\n    @staticmethod\n    def color_plotsurface(imat2plot, cmap='gist_gray', alpha=1):\n        \"\"\"defines a colormap which is used for plotting data later \"\"\"\n        import matplotlib.cm as cm\n        from matplotlib import colors as colors\n\n        color_dimension = imat2plot  # change to desired fourth dimension\n        minn, maxx = color_dimension.min(), color_dimension.max()\n        norm = matplotlib.colors.Normalize(minn, maxx)\n        m = cm.ScalarMappable(norm=norm, cmap=cmap)\n        m.set_array([])\n        fcolors = m.to_rgba(color_dimension)\n        fcolors[:,:,-1] = np.ones((fcolors[:,:,-1].shape))*alpha\n\n        return fcolors\n\n    @staticmethod\n    def plot_coordinates(coordinates, axis, marker='', s=25, facecolor='k', linewidth=1.5, edgecolor=[.9]*3):\n        \"\"\"plots all coordinates of the electrodes estimated from the lead model\"\"\"\n\n        axis.scatter(coordinates[0], coordinates[1], coordinates[2], s=s, c=facecolor, edgecolor=edgecolor,\n                     marker=marker, linewidth=linewidth)\n\n    @staticmethod\n    def plot_leadInformation(lead_data, mean_empdist, fig, grid, grid_indices):\n        \"\"\"plots lead information in the lower right corner\"\"\"\n\n        axis = fig.add_subplot(grid[grid_indices[0], grid_indices[1]], facecolor='None')\n        fig.tight_layout()\n        axis.set_axis_off()\n        axis.set_facecolor('None')\n\n        stn_direction = 'right' if not lead_data['trajectory'][0, 0] > lead_data['trajectory'][-1, 0] else 'left'\n        text2plot = 'Lead: {} STN \\nLead spacing: {:.2f} mm\\nRotation:  {} ' \\\n                    'deg'.format(stn_direction, mean_empdist, lead_data['rotation'])\n        axis.text(.6, .25, text2plot, horizontalalignment='center',fontsize=12, ha='center', va='center',\n                  bbox=dict(boxstyle='circle', facecolor='#D8D8D8', ec=\"0.5\", pad=0.5, alpha=1), fontweight='bold')\n\n    def plotCTaxial(self, lead_data, fig, grid, cmap='gist_gray'):\n        \"\"\"function plotting axial sclices at the level of head and tail markers\"\"\"\n\n        print(\"\\t...extracting axial slices for corresponding markers of CTimaging\\t...\")\n        marker_of_interest = ['markers_head', 'markers_tail']\n        marker_plot = dict([(k, r) for k, r in lead_data.items() if k.startswith('marker') and\n                            any(z in k for z in marker_of_interest)])\n        color_specs = ['g', 'r']\n        item = -1\n        for marker, coordinates in marker_plot.items():\n            item += 1\n            intensity_matrix, bounding_box, _ = self.get_axialplanes(coordinates, lead_data=lead_data,\n                                                                     window_size=15, resolution=.5)\n            transversal_axis = fig.add_subplot(grid[item, -1], facecolor='None')\n            transversal_axis.imshow(intensity_matrix, cmap=cmap, extent=[np.min(bounding_box, axis=1)[0],\n                                                                         np.max(bounding_box, axis=1)[0],\n                                                                         np.min(bounding_box, axis=1)[1],\n                                                                         np.max(bounding_box, axis=1)[1]],\n                                    interpolation='bicubic')\n            transversal_axis.set_axis_off()\n            transversal_axis.set_facecolor('None')\n\n            transversal_axis.scatter(coordinates[0], coordinates[1], s=200, c=color_specs[item],\n                                     edgecolor=color_specs[item], marker='x', linewidth=1.5)\n\n        grid.tight_layout(fig)\n\n    @staticmethod\n    def plot_leadModel(lead_model, fig, grid, lead_data, colors=[.3, .5], items2plot=['insulation', 'contacts']):\n        \"\"\"Plots schematic lead model at the left side in order to visualise what it should look like \"\"\"\n\n        leadModelSubplot = fig.add_subplot(grid[0:, 0], facecolor='None', projection='3d')\n        lead_plot = dict([(k, r) for k, r in lead_model.items() if any(z in k for z in items2plot)])\n        max_coords, min_coords = [[] for _ in range(2)]\n\n        for idx, item in enumerate(items2plot):\n            for idx_vertices in (range(0, len(lead_plot[item]['vertices']))):\n                verts_temp = np.array(lead_plot[item]['vertices'][idx_vertices]) - 1\n                faces_temp = np.array(lead_plot[item]['faces'][idx_vertices]) - 1\n                mesh = Poly3DCollection(verts_temp[faces_temp], facecolors=[colors[idx]] * 3, edgecolor='none',\n                                        rasterized=True)\n                leadModelSubplot.add_collection(mesh)\n\n                if item == 'contacts':\n                    max_coords.append(np.max(verts_temp[faces_temp], axis=1))\n                    min_coords.append(np.min(verts_temp[faces_temp], axis=1))\n\n        marker = {k: [] for k in ['head', 'tail']}\n        if lead_data['left']['model'] == 'Boston Vercise Directional':\n            for n in range(3):\n                marker['tail'].append(lead_model['tail_position'][n])\n                marker['head'].append(lead_model['tail_position'][n])\n            marker['tail'][2] = np.min(min_coords[0])\n        else:\n            for n in range(3):\n                marker['tail'].append(lead_model['tail_position'][n])\n                marker['head'].append(lead_model['head_position'][n])\n\n        color = ['r', 'g']\n        for idx, loc in enumerate(['head', 'tail']):\n            leadModelSubplot.scatter(marker[loc][0] - 1, marker[loc][1] - 2, marker[loc][2],c=color[idx], s=25)\n\n        leadModelSubplot.set_zlim([0, 15])\n        leadModelSubplot.set_ylim(-4, 4)\n        leadModelSubplot.set_xlim(-4, 4)\n        leadModelSubplot.set_facecolor('None')\n        leadModelSubplot.view_init(elev=0, azim=-120)\n        leadModelSubplot.set_axis_off()\n        # grid.tight_layout(fig) # TODO is this necessary?\n\n    def get_xyplanes(self, trajectory, lead_model, limits=[(-4,4),(-4,4),(-10,20)], sample_width=10,\n                     direction=['sag', 'cor']):\n        # TODO: this was moved into the GetData class and MUST be removed\n        hd_trajectories = self.interpolate_trajectory(trajectory, resolution=10) # TODO: rename traj to trajectory after assigning in function\n\n        slices = {k: [] for k in direction}\n        imat = {k: [] for k in direction}\n        fitvolume = {k: [] for k in direction}\n        bounding_box = {k: [] for k in direction}\n\n        for idx, plane in enumerate(direction):\n            slices[plane] = list(range(limits[idx][0], limits[idx][1]+1, 1))\n            imat[plane], fitvolume[plane] = self.resample_CTplanes(hd_trajectories, plane, lead_model, resolution=.35)\n\n            span_vector = [sample_width, 0, 0] if plane != 'sag' else [0, sample_width, 0]\n\n            idx = [0, -1]\n            bounding_box_coords = []\n            for k in idx:\n                bounding_box_coords.append(hd_trajectories[k,:]-span_vector)\n                bounding_box_coords.append(hd_trajectories[k, :] + span_vector)\n            bounding_box_coords = np.array(bounding_box_coords)\n\n            axes_name = ['xx', 'yy', 'zz']\n            box = {k: [] for k in axes_name}\n            for i, dim in enumerate(axes_name):\n                box[dim] = bounding_box_coords.T[i,:].tolist()\n\n            bounding_box[plane] = box\n\n        return imat, bounding_box, fitvolume\n\n    def get_axialplanes(self, marker_coordinates, lead_data, window_size=15, resolution=.5):\n        \"\"\"returns a plane at a specific window with a certain direction\"\"\"\n\n        if lead_data['transformation_matrix'].shape[0] == 3:\n            lead_data['transformation_matrix'] = np.eye(4)*lead_data['transformation_matrix'][0,0]\n            lead_data['transformation_matrix'][-1,-1] = 1\n        transformation_matrix = lead_data['transformation_matrix']\n        transformation_matrix = np.eye(4)\n\n        bounding_box_coords = []\n        for k in range(2):\n            bounding_box_coords.append(np.arange(start=marker_coordinates[k]-window_size,\n                                                 stop=marker_coordinates[k]+window_size, step=resolution))\n        bounding_box_coords.append(np.repeat(marker_coordinates[-1], len(bounding_box_coords[1])))\n        bounding_box = np.array(bounding_box_coords)\n\n        meshX, meshY = np.meshgrid(bounding_box[0,:], bounding_box[1,:])\n        meshZ = np.repeat(bounding_box[-1,0], len(meshX.flatten()))\n        fitvolume_orig = np.array([meshX.flatten(), meshY.flatten(), meshZ.flatten(), np.ones(meshX.flatten().shape)])\n        fitvolume = np.linalg.solve(transformation_matrix, fitvolume_orig)\n        resampled_points = PlotRoutines.interpolate_CTintensities(lead_data, fitvolume)\n        imat = np.reshape(resampled_points, (meshX.shape[0], -1), order='F')\n\n        return imat, bounding_box, fitvolume\n\n    @staticmethod\n    def resample_CTplanes(hd_trajectories, direction, lead_data, resolution=.2, sample_width=10, use_transformation_matrix=False):\n        \"\"\"Function resampling intesities of the source imaging to a grid which is later used to visualise the\n        leads. [ea_mancor_updatescene lines 264f]\"\"\"\n\n        direction = ''.join(direction) if type(direction) == list else direction  # in case direction is entered as list\n\n        if use_transformation_matrix:  #  not necessary as all data in cDBS stay within the LPS coordinate system\n            if lead_data['transformation_matrix'].shape[0] == 3:\n                lead_data['transformation_matrix'] = np.eye(4)*lead_data['transformation_matrix'][0,0]\n                lead_data['transformation_matrix'][-1,-1] = 1\n            transformation_matrix = lead_data['transformation_matrix']\n        else:\n            transformation_matrix = np.eye(4)\n\n        xvec = np.arange(start=-sample_width, stop=sample_width+resolution, step=resolution)\n        meanfitline = np.vstack((hd_trajectories.T, np.ones(shape=(1, hd_trajectories.T.shape[1])))) # needed for transformation\n        addvolume = np.tile(xvec,(len(meanfitline.T),1))\n\n        fitvolume = []\n        for t in range(4):\n            fitvolume.append(np.tile(meanfitline[t,:], xvec.shape).reshape(xvec.shape[0], meanfitline.shape[1]).T)\n        fitvolume_orig = np.stack(fitvolume)\n\n        if direction == 'cor':\n            fitvolume_orig[0,:,:] += addvolume\n        elif direction == 'sag':\n            fitvolume_orig[1, :, :] += addvolume\n        elif direction == 'tra':\n            fitvolume_orig[2, :, :] += addvolume\n\n        fitvolume = np.linalg.solve(transformation_matrix, np.reshape(fitvolume_orig, (4, -1), order='F'))\n        resampled_points = PlotRoutines.interpolate_CTintensities(lead_data, fitvolume)\n        imat = np.reshape(resampled_points, (meanfitline.shape[1], -1), order='F')\n\n        return imat, fitvolume_orig\n\n    # ========================================    Interpolations   ========================================\n    @staticmethod\n    def interpolate_trajectory(orig_trajectory, resolution=20):\n        \"\"\"interpolates between trajectory points thus creating a „high resolution“ version of it\"\"\"\n\n        hd_trajectory = []\n        for idx in range(np.array(orig_trajectory).shape[1]):\n            f = scipy.interpolate.interp1d(np.linspace(start=1, stop=50), np.array(orig_trajectory)[:, idx])\n            hd_trajectory.append(f(np.linspace(start=1, stop=50, num=(-1 + len(orig_trajectory[:, idx]))\n                                                                     * resolution + 1)))\n        return np.stack(hd_trajectory).T\n\n    def interpolate_CTintensities(lead_model, fitvolume):\n        import SimpleITK as sitk\n\n        img = sitk.ReadImage(os.path.join(*lead_model['filenameCTimaging']))\n        physical_points = list(map(tuple, fitvolume[0:3,:].T))\n        #physical_points = physical_points[0:5]\n        num_samples = len(physical_points)\n        physical_points = [img.TransformContinuousIndexToPhysicalPoint(pnt) for pnt in physical_points]\n\n        #interp_grid_img = sitk.Image((len(physical_points) *([1] * (img.GetDimension() - 1))), sitk.sitkUInt8)\n        interp_grid_img = sitk.Image([num_samples] + [1] * (img.GetDimension() - 1), sitk.sitkUInt8)\n        displacement_img = sitk.Image([num_samples] + [1] * (img.GetDimension() - 1), sitk.sitkVectorFloat64,\n                                      img.GetDimension())\n\n        for i, pnt in enumerate(physical_points):\n            displacement_img[[i] + [0] * (img.GetDimension() - 1)] = np.array(pnt) - np.array(\n                interp_grid_img.TransformIndexToPhysicalPoint([i] + [0] * (img.GetDimension() - 1)))\n\n        interpolator_enum = sitk.sitkLinear\n        default_output_pixel_value = 0.0\n        output_pixel_type = sitk.sitkFloat32 if img.GetNumberOfComponentsPerPixel() == 1 else sitk.sitkVectorFloat32\n        resampled_temp = sitk.Resample(img, interp_grid_img, sitk.DisplacementFieldTransform(displacement_img),\n                                       interpolator_enum, default_output_pixel_value, output_pixel_type)\n\n        resampled_points = [resampled_temp[x,0,0] for x in range(resampled_temp.GetWidth())]\n        debug = False\n        if debug:\n            for i in range(resampled_temp.GetWidth()):\n                print(str(img.TransformPhysicalPointToContinuousIndex(physical_points[i])) + ': ' + str(resampled_temp[[i] + [0] * (img.GetDimension() - 1)]) + '\\n')\n\n        return np.array(resampled_points)\n\n    # ====================    General Helper Functions for manual correction   ====================\n    @staticmethod\n    def load_leadModel(inputdir, filename):\n        \"\"\"Function loading results from [preprocLeadCT.py] which emulates the PaCER toolbox\"\"\"\n\n        if not inputdir:\n            Output.msg_box(text=\"No input folder provided, please double-check!\", title=\"Missing input folder\")\n            return\n        elif not os.path.isfile(filename):\n            Output.msg_box(text=\"Models for electrode unavailable, please run detection first!\",\n                           title=\"Models not available\")\n            return\n        else:\n            with open(filename, \"rb\") as model: # roughly ea_loadreconstruction in the LeadDBS script\n                lead_models = pickle.load(model)\n                intensityProfiles = pickle.load(model)\n                skelSkalms = pickle.load(model)\n\n        return lead_models, intensityProfiles, skelSkalms\n\n    @staticmethod\n    def save_leadModel(lead_models, intensityProfiles, skelSkalms, filename=''):\n\n        if not filename:\n            Output.msg_box(text='No filename for saving lead model provided', title='No filename provided')\n            return\n\n        with open(filename, \"wb\") as f:\n            pickle.dump(lead_models, f)\n            pickle.dump(intensityProfiles, f)\n            pickle.dump(skelSkalms, f)\n\n    # ====================    Helper Functions fpr plotting Data   ====================\n    @staticmethod\n    def getbgsidecolor(side, xray=False):\n        \"\"\" \"\"\"\n        from matplotlib import colors\n\n        line_cols = matplotlib.cm.get_cmap('Set1', 64) # TODO: maybe a cmap would make sense\n        line_cols = colors.rgb_to_hsv(line_cols(np.linspace(0, 1, 64))[:,0:3])\n        line_cols[:,-1] = line_cols[:,-1]\/3\n        if xray:\n            line_cols[:, 1] = line_cols[:, 1] \/ 1.5\n            line_cols[:, 2] = line_cols[:, 2] * 1.5\n\n        line_cols = colors.hsv_to_rgb(line_cols)\n        col = line_cols[side,:] # TODO: why on earth is this so complicated to get these colors\n\n        return col\n\nclass GetData:\n    def __init__(self, parent=PlotRoutines):\n        self.parent = parent\n\n    @staticmethod\n    def leadInformation_update(information2update, lead_data):\n        \"\"\"replaces values of lead_models with updated values; information2update can be marker, rotation, etc.\"\"\"\n\n        for key_name, val in information2update.items():\n            lead_data[key_name] = val\n        return lead_data\n\n    # ===================================    Functions related with coordinates   ===================================\n    def resize_coordinates(self, lead_coords, lead_data):\n        \"\"\"function which enables resizing cooridnates (e.g. 8 contacts to 4 contacts if needed; additional\n        functionality contains \"\"\"\n\n        if lead_data['model'] == 'Boston Vercise Directional' or 'St Jude 6172' or 'St Jude 6173':\n            coordinates = np.zeros((4, 3))\n            coordinates[0, :] = lead_coords[0, :]\n            coordinates[1, :] = np.mean(lead_coords[1: 4, :], axis=0)\n            coordinates[2, :] = np.mean(lead_coords[4: 7, :], axis=0)\n            coordinates[3, :] = lead_coords[7, :]\n\n            emp_dist = GetData.lead_dist(coords=coordinates)\n        else:\n            coordinates = lead_coords\n            emp_dist = GetData.lead_dist(coords=coordinates, factor=lead_data['numel'])\n\n        return coordinates, emp_dist\n\n    @staticmethod\n    def lead_dist(coords, factor=3):\n        \"\"\"calculate lead distances according to its coordinates\"\"\"\n\n        spatial_distance = scipy.spatial.distance.cdist(coords, coords, 'euclidean')\n        emp_dist = np.sum(np.sum(np.tril(np.triu(spatial_distance, 1), 1))) \/ factor\n\n        return emp_dist\n\n    def resolve_coordinates(self, marker, lead_coords_mm, lead_positions, lead_data, resize_bool=False, rszfactor=0):\n        \"\"\"emulates the function from Lead-DBS ea_resolvecoords; unlike in Lead DBS this is done one at a time cf.\n        https:\/\/github.com\/netstim\/leaddbs\/blob\/master\/templates\/electrode_models\/ea_resolvecoords.m\"\"\"\n\n        if resize_bool:\n            can_dist = np.linalg.norm(lead_positions[\"head_position\"] - lead_positions[\"tail_position\"])\n            coords_temp, can_eldist = GetData.resize_coordinates(self, lead_coords_mm, lead_data)\n\n            stretch = can_dist * (rszfactor \/ can_eldist) if rszfactor != 0 else can_dist\n            vec = np.divide((marker[\"markers_tail\"] - marker[\"markers_head\"]),\n                            np.linalg.norm(marker[\"markers_tail\"] - marker[\"markers_head\"]))\n            marker[\"markers_tail\"] = marker[\"markers_head\"] + vec * stretch\n\n        coords, traj_vector, trajectory, can_eldist = [[] for _ in range(4)]\n        if not marker[\"markers_head\"].size==0:\n            M = np.stack((np.append(marker[\"markers_head\"], 1), np.append(marker[\"markers_tail\"], 1),\n                          np.append(marker[\"markers_x\"], 1), np.append(marker[\"markers_y\"], 1)))\n            E = np.stack((np.append(lead_positions[\"head_position\"], 1), np.append(lead_positions[\"tail_position\"], 1),\n                          np.append(lead_positions[\"x_position\"], 1), np.append(lead_positions[\"y_position\"], 1)))\n            X = np.linalg.lstsq(E, M, rcond=None)\n\n            coords_mm = np.concatenate([lead_coords_mm, np.ones(shape=(lead_coords_mm.shape[0],1))], axis=1)\n            coords = (coords_mm @ X[0]).T\n            coords = coords[0: 3,:].T\n\n            traj_vector = (marker[\"markers_tail\"] - marker[\"markers_head\"]) \/ \\\n                          np.linalg.norm(marker[\"markers_tail\"] - marker[\"markers_head\"])\n\n            trajectory = np.stack((marker[\"markers_head\"] - traj_vector*5, marker[\"markers_head\"] + traj_vector*25))\n            trajectory = np.array((np.linspace(trajectory[0, 0], trajectory[1, 0], num=50),\n                                   np.linspace(trajectory[0, 1], trajectory[1, 1], num=50),\n                                   np.linspace(trajectory[0, 2], trajectory[1, 2], num=50))).T\n\n        return coords, trajectory, can_eldist, marker\n\n    # ===================================    Functions in combination with leads   ===================================\n    @staticmethod\n    def get_default_lead(lead_data):\n        \"\"\"obtains default lead properties according to the model proposed in the PaCER algorithm @ .\/template\"\"\"\n\n        if lead_data['model'] == 'Boston Vercise Directional': # load mat-file to proceed\n            mat_filename = 'boston_vercise_directed.mat'\n            lead_model = loadmat(os.path.join(ROOTDIR, 'ext', 'LeadDBS', mat_filename), 'r')['electrode']\n            default_positions = {x: np.hstack(vals) for x, vals in lead_model.items() if x.endswith('position')}\n            default_coordinates = np.array(lead_model['coords_mm'])  # in [mm]\n        else:\n            Output.msg_box(text=\"Lead type not yet implemented.\", title=\"Lead type not implemented\")\n            return\n\n        return lead_model, default_positions, default_coordinates\n\n    def get_leadModel(self, lead_data, default_positions, default_coordinates, side, resize=False):\n        \"\"\" reads and estimates all necessary markers and trajectories for the corresponding lead model \"\"\"\n        print(\"\\t... reading lead data properties for {} side and estimating rotation\".format(side))\n\n        marker_unprocessed = dict([(k, r) for k, r in lead_data.items() if k.startswith('marker')])\n\n        if not (lead_data['first_run'] and lead_data['manual_correction']):\n            resize = True  # TODO: Not sure if this is doing the job; some warning\/information should be displayed that > first run\n            lead_data['first_run'] = False\n\n        _, lead_data['trajectory'], _, marker_temp = \\\n            GetData.resolve_coordinates(self, marker_unprocessed, default_coordinates, default_positions, lead_data,\n                                        resize_bool=resize)\n\n        lead_data['rotation'] = GetData.initialise_rotation(lead_data, marker_temp)\n        xvec, yvec, lead_data['rotation'], marker_rotation = GetData.estimate_rotation(lead_data, marker_temp)\n        lead_data = GetData.leadInformation_update(marker_rotation, lead_data)\n\n        if xvec.size == 0 or yvec.size == 0:\n            xvec, yvec, lead_data['rotation'], marker_rotation = GetData.estimate_rotation(lead_data, marker_rotation)\n            lead_data = GetData.leadInformation_update(marker_rotation, lead_data)\n\n        options2process = {'xvec': [1, 0, 0], 'yvec': [0, 1, 0]}\n        unrot = {k: [] for k in options2process.keys()}\n        for key in options2process:\n            vec_temp = np.cross(lead_data[\"normtraj_vector\"], options2process[key])\n            unrot[key] = np.divide(vec_temp, np.linalg.norm(vec_temp))\n\n        marker = dict([(k, r) for k, r in lead_data.items() if k.startswith('marker')])\n        coordinates, trajectory, _, _ = GetData.resolve_coordinates(self, marker, default_coordinates,\n                                                                    default_positions, lead_data, resize_bool=False)  # ea_mancor_updatescene line 144\n        return marker, coordinates, trajectory, resize\n\n    def worker_xy_planes(self, traj, lead, dimension, side, IM_dict, BB_dict, FV_dict, queue):\n        print(\"\\t...extracting intensities for CTimages @ {} side\\t...\".format(side))\n        queue.put('.')\n        intensity_matrix, bounding_box, fitvolume = GetData.get_xyplanes(self, trajectory=traj, lead_model=lead,\n                                                                         direction=dimension)\n        IM_dict[side] = intensity_matrix\n        BB_dict[side] = bounding_box\n        FV_dict[side] = fitvolume\n\n    def multiprocessing_xyplanes(self, lead_data, trajectory, dimension=['sag', 'cor']):\n        \"\"\"extracts the intensities corresponding to the CTimaging, which is used as 'background' in the figure\"\"\"\n\n        queue = mp.Queue()\n        start_multi = time.time()\n        manager = mp.Manager()\n        IM_dict, BB_dict, FV_dict = manager.dict(), manager.dict(), manager.dict()\n        processes = [mp.Process(target=GetData.worker_xy_planes,\n                                args=(self, trajectory[side], lead_data[side], dimension, side,\n                                      IM_dict, BB_dict, FV_dict, queue))\n                     for side in trajectory.keys()]\n        _ = [p.start() for p in processes]\n\n        #while any([p.is_alive() for p in processes]):\n        #    while not queue.empty():\n        #        status = queue.get()\n        #        #print(\"{}\".format(status))\n        #    time.sleep(0.1)\n\n        _ = [p.join(timeout=1) for p in processes]\n        _ = [queue.get() for p in processes]\n\n        print(\"\\n\\tIntensities successfully extracted for {} side(s) in \"\n              \"{:.2f} secs\".format(len(list(trajectory.keys())), time.time() - start_multi))\n\n        return IM_dict, BB_dict, FV_dict\n\n    def multiprocessing_xyplanesPOOL(self, lead_data, trajectory, dimension=['sag', 'cor']):\n        \"\"\"extracts the intensities corresponding to the CTimaging, which is used as 'background' in the figure\"\"\"\n\n        start_multi = time.time()\n        manager = mp.Manager()\n        queue = mp.Queue()\n        IM_dict, BB_dict, FV_dict = manager.dict(), manager.dict(), manager.dict()\n        pool = mp.Pool(processes=4)\n        processes = [pool.apply_async(func=GetData.worker_xy_planes,\n                                      args=(self, trajectory[side], lead_data[side], dimension, side,\n                                            IM_dict, BB_dict, FV_dict, queue, ))\n                     for side in trajectory.keys()]\n        pool.close()\n        pool.join()\n        final_result = [process.get() for process in processes]\n\n        # prevent adding anything more to the queue and wait for queue to empty\n        #_ = [p.start() for p in processes]\n        #_ = [p.join(timeout=1) for p in processes]\n\n        print(\"\\n\\tIntensities successfully extracted for {} side(s) in \"\n              \"{:.2f} secs\".format(len(list(trajectory.keys())), time.time() - start_multi))\n\n        return IM_dict, BB_dict, FV_dict\n\n\n    def get_xyplanes(self, trajectory, lead_model, limits=[(-4,4),(-4,4),(-10,20)], sample_width=10,\n                     direction=['sag', 'cor']):\n        # TODO: this was moved into the GetData class and MUST be removed\n        hd_trajectories = Imaging.interpolate_trajectory(trajectory, resolution=10) # TODO: rename traj to trajectory after assigning in function\n\n        slices = {k: [] for k in direction}\n        imat = {k: [] for k in direction}\n        fitvolume = {k: [] for k in direction}\n        bounding_box = {k: [] for k in direction}\n\n        for idx, plane in enumerate(direction):\n            slices[plane] = list(range(limits[idx][0], limits[idx][1]+1, 1))\n            imat[plane], fitvolume[plane] = self.resample_CTplanes(hd_trajectories, plane, lead_model, resolution=.35)\n\n            span_vector = [sample_width, 0, 0] if plane != 'sag' else [0, sample_width, 0]\n\n            idx = [0, -1]\n            bounding_box_coords = []\n            for k in idx:\n                bounding_box_coords.append(hd_trajectories[k,:]-span_vector)\n                bounding_box_coords.append(hd_trajectories[k, :] + span_vector)\n            bounding_box_coords = np.array(bounding_box_coords)\n\n            axes_name = ['xx', 'yy', 'zz']\n            box = {k: [] for k in axes_name}\n            for i, dim in enumerate(axes_name):\n                box[dim] = bounding_box_coords.T[i,:].tolist()\n\n            bounding_box[plane] = box\n\n        return imat, bounding_box, fitvolume\n\n    # ==============================    Functions related to estimation of rotation   ==============================\n    @staticmethod\n    def initialise_rotation(lead_model, marker):\n        \"\"\"script iniitalising the estimation of rotation angles; necessary as at the beginning there is no\n        information available; This function is followed by estimate_rotation.py (see below)\"\"\"\n\n        if lead_model['manual_correction'] and not lead_model['rotation']:\n            vec_temp = marker['markers_y'] - marker['markers_head']\n            vec_temp[2] = 0\n            vec_temp = np.divide(vec_temp, np.linalg.norm(vec_temp))\n            initial_rotation = np.degrees(math.atan2(np.linalg.norm(np.cross([0,1,0], vec_temp)),\n                                                     np.dot([0,1,0], vec_temp)))\n            if marker['markers_y'][0] > marker['markers_head'][0]:\n                initial_rotation = - initial_rotation\n            rotation = initial_rotation\n        elif not lead_model['manual_correction'] and not lead_model['rotation']:\n            rotation = 0\n\n        return rotation\n\n    @staticmethod\n    def estimate_rotation(lead_models, marker):\n        \"\"\"determination of rotation according to markers provided; follows steps in ea_mancor_updatescene of\n         Lead-DBS package (cf. https:\/\/github.com\/ningfei\/lead\/blob\/develop\/ea_mancor_updatescene.m) \"\"\"\n\n        rotation, normtrajvector = lead_models['rotation'], lead_models[\"normtraj_vector\"]\n\n        yvec = np.zeros((3,1))\n        yvec[0] = -np.cos(0) * np.sin(np.deg2rad(rotation))\n        yvec[1] = (np.cos(0) * np.cos(np.deg2rad(rotation))) + (np.sin(0) * np.sin(np.deg2rad(rotation)) * np.sin(0))\n        yvec[2] = (-np.sin(0) * np.cos(np.deg2rad(rotation))) + (np.cos(0) * np.sin(np.deg2rad(rotation)) * np.sin(0))\n\n        xvec = np.cross(yvec.T, [0,0,1])\n        xvec = xvec - (np.dot(xvec, normtrajvector) \/ np.linalg.norm(normtrajvector)**2) * normtrajvector\n        xvec = np.divide(xvec, np.linalg.norm(xvec))\n        yvec = -np.cross(xvec, normtrajvector)\n\n        marker['markers_x'] = marker['markers_head'] + (xvec * lead_models['lead_diameter'] \/ 2)\n        marker['markers_y'] = marker['markers_head'] + (yvec * lead_models['lead_diameter'] \/ 2)\n\n        return xvec, yvec, rotation, marker\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_48","text":"<reponame>MayerJohannes\/Klimamodelle\n# \tValidation of the analog-method results using spartacus RR\n#\t<NAME>, <NAME>\n#\tKlimamodelle SS19\n#\tversion:\t2019-07-23\n# \n#\tExecute:\n#\t\tpython3 04-validation_iterate.py --save\n\n\nimport numpy as np\nimport xarray as xr\nimport dask\nimport matplotlib.pylab as plt\nimport iris\nfrom eofs.xarray import Eof\nfrom scipy.signal import detrend\nfrom eofs.multivariate.iris import MultivariateEof\nimport datetime\nimport cartopy.crs as ccrs\nimport matplotlib.pyplot as plt\nimport argparse\nimport csv\nimport scipy as sp\nimport pandas as pd\nimport numpy.ma as ma\n\n# Parse target day as argument\nparser = argparse.ArgumentParser(description='man')\nparser.add_argument('--save', action='store_true', dest='ssave', help='save output')\nargs = parser.parse_args()\nssave = args.ssave\n\n# Spartacus first and last year\nsyear = 1961\neyear = 2017\n\n\n# Load date list (= EOF.py output)\nwith open('datelist-v4.csv', 'r') as f:\n\treader = csv.reader(f)\n\tyour_list = list(reader)\n\nif ssave: file1 = csv.writer(open(\"corrcoef-2.csv\",\"w\"))\n\n# Iterate over all entries\nmax_cc = 0\nfor istr in your_list:\n\t#if istr[0] == TD: break\n\n\tstr_td = istr[0] #'1981-01-01'\n\tstr_a1 = istr[1] #'2005-01-02'\n\tstr_a2 = istr[2] #'2012-01-04'\n\n\t# Target day\n\tyear_td = str_td[:4]\n\n\t# Analogon 1\n\tyear_a1 = str_a1[:4]\n\n\t# Analogon 2\n\tyear_a2 = str_a2[:4]\n\n\n\tif int(year_td) < syear or  int(year_a1) < syear or int(year_a2) < syear: continue\n\tif int(year_td) > eyear or  int(year_a1) > eyear or int(year_a2) > eyear: continue\n\n\tifile_td = '\/home\/johannes\/klimamodelle\/data\/spartacus_rr\/RR'+year_td+'.nc'\n\tifile_a1 = '\/home\/johannes\/klimamodelle\/data\/spartacus_rr\/RR'+year_a1+'.nc'\n\tifile_a2 = '\/home\/johannes\/klimamodelle\/data\/spartacus_rr\/RR'+year_a2+'.nc'\n\n\tidata_td = xr.open_mfdataset(ifile_td,chunks={'time': 366})\n\tidata_a1 = xr.open_mfdataset(ifile_a1,chunks={'time': 366})\n\tidata_a2 = xr.open_mfdataset(ifile_a2,chunks={'time': 366})\n\n\ttd_field = idata_td.sel(time=slice(str_td,str_td))\n\ta1_field = idata_a1.sel(time=slice(str_a1,str_a1))\n\ta2_field = idata_a2.sel(time=slice(str_a2,str_a2))\n\n\ttd_values = td_field.RR.values[:,:][0]\n\ta1_values = a1_field.RR.values[:,:][0]\n\ta2_values = a2_field.RR.values[:,:][0]\n\n\n\t# np.ravel : array to vector transformation\n\t# masked_invalid : Mask an array where invalid values occur\n\t# ma.corrcoef : compute corr coeff. matrix, considers missing values\n\n\t# Correlation TD and best analogon\n\tcc_a1 = ma.corrcoef(ma.masked_invalid(np.ravel(td_values)), ma.masked_invalid(np.ravel(a1_values)))[0,1]\n\n\t# Correlation TD and second best analogon\n\tcc_a2 = ma.corrcoef(ma.masked_invalid(np.ravel(td_values)), ma.masked_invalid(np.ravel(a2_values)))[0,1]\n\tprint(str_td, cc_a1, cc_a2)\n\n\t# Write output\n\tif ssave: file1.writerow([str_td, cc_a1, cc_a2])\n\n\t# Compute largest correlation coefficient\n\tif cc_a1 > max_cc: \n\t\tmax_cc = cc_a1\n\t\tmax_td = str_td[:]\n\n\tif cc_a2 > max_cc: \n\t\tmax_cc = cc_a2\n\t\tmax_td = str_td\n\nprint(max_cc,max_td)\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_52","text":"<gh_stars>10-100\n\"\"\"\nFunctions for estimating expectations using frequentist control-variate Monte-Carlo based methods such as multi-level Monte-Carlo, control-variate Monte-Carlo, and approximate control-variate Monte-Carlo.\n\"\"\"\nfrom pyapprox.probability_measure_sampling import \\\n    generate_independent_random_samples\nfrom pyapprox.utilities import get_correlation_from_covariance\nimport numpy as np\nimport os\nfrom scipy.optimize import minimize\ntry:\n    # use torch to compute gradients for sample allocation optimization\n    import torch\n    use_torch = True\nexcept:\n    #msg = 'Could not import Torch'\n    # print(msg)\n    use_torch = False\n\nimport copy\nfrom pyapprox.utilities import get_all_sample_combinations\nfrom functools import partial\n\n\ndef compute_correlations_from_covariance(cov):\n    \"\"\"\n    Compute the correlation matrix of a covariance matrix.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    Returns\n    -------\n    corr : np.ndarray (nmodels,nmodels)\n        The correlation matrix\n    \"\"\"\n    corr_sqrt = np.diag(1\/np.sqrt((np.diag(cov))))\n    corr = np.dot(corr_sqrt, np.dot(cov, corr_sqrt))\n    return corr\n\n\ndef standardize_sample_ratios(nhf_samples, nsample_ratios):\n    \"\"\"\n    Ensure num high fidelity samples is positive (>0) and then recompute \n    sample ratios. This is useful when num high fidelity samples and \n    sample ratios are computed by an optimization process. This function \n    is useful for optimization problems with a numerical or analytical \n    solution.\n\n    Parameters\n    ----------\n    nhf_samples : integer\n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, \n        i=1,...,nmodels-1\n\n    Returns\n    -------\n    nhf_samples : integer\n        The corrected number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The corrected sample ratios\n    \"\"\"\n    nsamples = np.array([r*nhf_samples for r in nsample_ratios])\n    nhf_samples = int(max(1, np.floor(nhf_samples)))\n    nsample_ratios = np.floor(nsamples)\/nhf_samples\n    #nhf_samples = int(max(1,np.round(nhf_samples)))\n    #nsample_ratios = [max(np.round(nn\/nhf_samples),0) for nn in nsamples]\n    return nhf_samples, np.asarray(nsample_ratios)\n\n\ndef get_variance_reduction(get_rsquared, cov, nsample_ratios):\n    r\"\"\"\n    Compute the variance reduction:\n\n    .. math:: \\gamma = 1-r^2\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, i=1,...,nmodels-1\n\n    Returns\n    -------\n    gamma : float\n        The variance reduction\n    \"\"\"\n    return 1-get_rsquared(cov, nsample_ratios)\n\n\ndef get_control_variate_rsquared(cov):\n    r\"\"\"\n    Compute :math:`r^2` used to compute the variance reduction of \n    control variate Monte Carlo\n\n    .. math:: \\gamma = 1-r^2, \\qquad     r^2 = c^TC^{-1}c\n\n    where c is the first column of C\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    Returns\n    -------\n    rsquared : float\n        The value  :math:`r^2`\n    \"\"\"\n    nmodels = cov.shape[0]\n    rsquared = cov[0, 1:].dot(np.linalg.solve(cov[1:, 1:], cov[1:, 0]))\n    rsquared \/= cov[0, 0]\n    return rsquared\n\n\ndef get_rsquared_mfmc(cov, nsample_ratios):\n    r\"\"\"\n    Compute r^2 used to compute the variance reduction  of \n    Multifidelity Monte Carlo (MFMC)\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, i=1,...,nmodels-1\n\n    Returns\n    -------\n    rsquared : float\n        The value r^2\n    \"\"\"\n    nmodels = cov.shape[0]\n    assert len(nsample_ratios) == nmodels-1\n    rsquared = (nsample_ratios[0]-1)\/(nsample_ratios[0])*cov[0, 1]\/(\n        cov[0, 0]*cov[1, 1])*cov[0, 1]\n    for ii in range(1, nmodels-1):\n        p1 = (nsample_ratios[ii]-nsample_ratios[ii-1])\/(\n            nsample_ratios[ii]*nsample_ratios[ii-1])\n        p1 *= cov[0, ii+1]\/(cov[0, 0]*cov[ii+1, ii+1])*cov[0, ii+1]\n        rsquared += p1\n    return rsquared\n\n\ndef get_rsquared_mlmc(cov, nsample_ratios, pkg=np):\n    r\"\"\"\n    Compute r^2 used to compute the variance reduction of \n    Multilevel Monte Carlo (MLMC)\n\n    See Equation 2.24 in ARXIV paper where alpha_i=-1 for all i\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, \n        i=1,...,nmodels-1.\n        The values r_i correspond to eta_i in Equation 2.24\n\n    Returns\n    -------\n    gamma : float\n        The variance reduction\n    \"\"\"\n    nmodels = cov.shape[0]\n    assert len(nsample_ratios) == nmodels-1\n    gamma = 0.0\n    rhat = pkg.ones(nmodels)\n    for ii in range(1, nmodels):\n        rhat[ii] = nsample_ratios[ii-1] - rhat[ii-1]\n\n    for ii in range(nmodels-1):\n        vardelta = cov[ii, ii] + cov[ii+1, ii+1] - 2*cov[ii, ii+1]\n        gamma += vardelta \/ (rhat[ii])\n\n    v = cov[nmodels-1, nmodels-1]\n    gamma += v \/ (rhat[-1])\n\n    gamma \/= cov[0, 0]\n    return 1-gamma\n\n\ndef get_mlmc_control_variate_weights(nmodels):\n    r\"\"\"\n    Get the weights used by the MLMC control variate estimator\n\n    Returns\n    -------\n    weights : np.ndarray (nmodels-1)\n        The control variate weights\n    \"\"\"\n    return -np.ones(nmodels-1)\n\n\ndef compute_approximate_control_variate_mean_estimate(weights, values):\n    r\"\"\"\n    Use approximate control variate Monte Carlo to estimate the mean of \n    high-fidelity data with low-fidelity models with unknown means\n\n    Parameters\n    ----------\n    values : list (nmodels)\n        Each entry of the list contains\n\n        values0 : np.ndarray (num_samples_i0,num_qoi)\n           Evaluations  of each model\n           used to compute the estimator :math:`Q_{i,N}` of \n\n        values1: np.ndarray (num_samples_i1,num_qoi)\n            Evaluations used compute the approximate \n            mean :math:`\\mu_{i,r_iN}` of the low fidelity models.\n\n    weights : np.ndarray (nmodels-1)\n        the control variate weights\n\n    Returns\n    -------\n    est : float\n        The control variate estimate of the mean\n    \"\"\"\n    nmodels = len(values)\n    assert len(values) == nmodels\n    # high fidelity monte carlo estimate of mean\n    est = values[0][0].mean()\n    for ii in range(nmodels-1):\n        est += weights[ii]*(values[ii+1][0].mean()-values[ii+1][1].mean())\n    return est\n\n\ndef compute_control_variate_mean_estimate(weights, values, lf_means):\n    r\"\"\"\n    Use control variate Monte Carlo to estimate the mean of \n    high-fidelity data with low-fidelity models with known means\n\n    Parameters\n    ----------\n    values : list (nmodels)\n        Each entry of the list contains\n\n        values0 : np.ndarray (num_samples_i0,num_qoi)\n           Evaluations  of each model\n           used to compute the estimator :math:`Q_{i,N}` of \n\n    weights : np.ndarray (nmodels-1)\n        the control variate weights\n\n\n    lf_means : np.ndarray (nmodels-1):\n        The known means of the low fidelity models\n\n    Returns\n    -------\n    est : float\n        The control variate estimate of the mean\n    \"\"\"\n    nmodels = len(values)\n    assert len(values) == nmodels\n    # high fidelity monte carlo estimate of mean\n    est = values[0].mean()\n    for ii in range(nmodels-1):\n        est += weights[ii]*(values[ii+1].mean()-lf_means[ii])\n    return est\n\n\ndef allocate_samples_mfmc(cov, costs, target_cost, standardize=True):\n    r\"\"\"\n    Determine the samples to be allocated to each model when using MFMC\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    costs : np.ndarray (nmodels)\n        The relative costs of evaluating each model\n\n    target_cost : float\n        The total cost budget\n\n    standardize : boolean\n        If true make sure that nhf_samples is an integer and that \n        nhf_samples*nsamples_ratios are integers. False is only ever used \n        for testing.\n\n    Returns\n    -------\n    nhf_samples : integer \n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i=r_i*nhf_samples, i=1,...,nmodels-1\n\n    log10_variance : float\n        The base 10 logarithm of the variance of the estimator\n    \"\"\"\n\n    nmodels = cov.shape[0]\n    corr = compute_correlations_from_covariance(cov)\n    I = np.argsort(np.absolute(corr[0, 1:]))[::-1]\n    if not np.allclose(I, np.arange(nmodels-1)):\n        msg = 'Models must be ordered with decreasing correlation with '\n        msg += 'high-fidelity model'\n        raise Exception(msg)\n\n    # for ii in range(nmodels-2):\n    #     corr_ratio = (corr[0, ii]**2 - corr[0, ii+1]**2)\/(\n    #         corr[0, ii+1]**2 - corr[0, ii+2]**2)\n    #     cost_ratio = costs[ii] \/ costs[ii+1]\n    #     #print(ii, cost_ratio, corr_ratio, corr[0, ii:ii+3]**2,\n    #     #corr[0, ii:ii+2], costs[ii:ii+2])\n    #     assert cost_ratio > corr_ratio, (cost_ratio, corr_ratio)\n        \n    # ii = nmodels-2\n    # corr_ratio = (corr[0, ii]**2 - corr[0, ii+1]**2)\/(corr[0, ii+1]**2)\n    # cost_ratio = costs[ii] \/ costs[ii+1]\n    # # print(cost_ratio, corr_ratio)\n    # assert cost_ratio > corr_ratio, (cost_ratio, corr_ratio)\n\n    r = []\n    for ii in range(nmodels-1):\n        # Step 3 in Algorithm 2 in Peherstorfer et al 2016\n        num = costs[0] * (corr[0, ii]**2 - corr[0, ii+1]**2)\n        den = costs[ii] * (1 - corr[0, 1]**2)\n        r.append(np.sqrt(num\/den))\n\n    num = costs[0]*corr[0, -1]**2\n    den = costs[-1] * (1 - corr[0, 1]**2)\n    r.append(np.sqrt(num\/den))\n\n    # Step 4 in Algorithm 2 in Peherstorfer et al 2016\n    nhf_samples = target_cost \/ np.dot(costs, r)\n    nhf_samples = max(nhf_samples, 1)\n    nsample_ratios = r[1:]\n\n    if standardize:\n        nhf_samples, nsample_ratios = standardize_sample_ratios(\n            nhf_samples, nsample_ratios)\n\n    gamma = get_variance_reduction(get_rsquared_mfmc, cov, nsample_ratios)\n    log10_variance = np.log10(gamma)+np.log10(cov[0, 0])-np.log10(\n        nhf_samples)\n\n    return nhf_samples, np.atleast_1d(nsample_ratios), log10_variance\n\n\ndef allocate_samples_mlmc(cov, costs, target_cost, standardize=True):\n    r\"\"\"\n    Determine the samples to be allocated to each model when using MLMC\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity \n        model is the first model, i.e its variance is cov[0,0]\n\n    costs : np.ndarray (nmodels)\n        The relative costs of evaluating each model\n\n    target_cost : float\n        The total cost budget\n\n    standardize : boolean\n        If true make sure that nhf_samples is an integer and that \n        nhf_samples*nsamples_ratios are integers. False is only ever used \n        for testing.\n\n\n    Returns\n    -------\n    nhf_samples : integer \n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, \n        i=1,...,nmodels-1. For model i>0 nsample_ratio*nhf_samples equals\n        the number of samples in the two different discrepancies involving\n        the ith model.\n\n    log10_variance : float\n        The base 10 logarithm of the variance of the estimator\n    \"\"\"\n    nmodels = cov.shape[0]\n    sum1 = 0.0\n    nsamples = []\n    vardeltas = []\n    for ii in range(nmodels-1):\n        # compute the variance of the discrepancy\n        vardelta = cov[ii, ii] + cov[ii+1, ii+1] - 2*cov[ii, ii+1]\n        vardeltas.append(vardelta)\n        # compute the variance * cost\n        vc = vardelta * (costs[ii] + costs[ii+1])\n        # compute the unnormalized number of samples\\\n        # these values will be normalized by lamda later\n        nsamp = np.sqrt(vardelta \/ (costs[ii] + costs[ii+1]))\n        nsamples.append(nsamp)\n        sum1 += np.sqrt(vc)\n    I = np.argsort(vardeltas)\n    #assert np.allclose(I,np.arange(nmodels-1))\n\n    # compute information for lowest fidelity model\n    v = cov[nmodels-1, nmodels-1]\n    c = costs[nmodels-1]\n    nsamples.append(np.sqrt(v\/c))\n    sum1 += np.sqrt(v*c)\n\n    # compute the ML estimator variance from the target cost\n    variance = sum1**2 \/ target_cost\n    # compute the lagrangian parameter\n    sqrt_lamda = sum1\/variance\n    # compute the number of samples allocated to resolving each\n    # discrepancy.\n    nl = [sqrt_lamda * n for n in nsamples]\n\n    # compute the number of samples allocated to each model. For\n    # all but the highest fidelity model we need to collect samples\n    # from two discrepancies.\n    nhf_samples = nl[0]\n    nsample_ratios = []\n    for ii in range(1, nmodels-1):\n        nsample_ratios.append((nl[ii-1] + nl[ii])\/nl[0])\n    if nmodels > 1:\n        nsample_ratios.append((nl[-2]+nl[-1])\/nl[0])\n\n    nsample_ratios = np.asarray(nsample_ratios)\n\n    if standardize:\n        nhf_samples = max(nhf_samples, 1)\n        nhf_samples, nsample_ratios = standardize_sample_ratios(\n            nhf_samples, nsample_ratios)\n    gamma = get_variance_reduction(get_rsquared_mlmc, cov, nsample_ratios)\n    log10_variance = np.log10(gamma)+np.log10(cov[0, 0])-np.log10(\n        nhf_samples)\n    # print(log10_variance)\n    if np.isnan(log10_variance):\n        raise Exception('MLMC variance is NAN')\n    return nhf_samples, np.atleast_1d(nsample_ratios), log10_variance\n\n\ndef get_lagrange_multiplier_mlmc(cov, costs, nhf_samples):\n    r\"\"\"\n    Given an optimal sample allocation recover the optimal value of the \n    Lagrange multiplier. This is only used for testing\n    \"\"\"\n    ii = 0  # 0th discrepancy\n    var_delta = cov[ii, ii] + cov[ii+1, ii+1] - 2*cov[ii, ii+1]\n    cost_delta = (costs[ii] + costs[ii+1])\n    lagrange_mult = nhf_samples**2\/(var_delta\/cost_delta)\n    return lagrange_mult\n\n\ndef get_discrepancy_covariances_IS(cov, nsample_ratios, pkg=np):\n    r\"\"\"\n    Get the covariances of the discrepancies :math:`\\delta` \n    between each low-fidelity model and its estimated mean when the same \n    :math:`N` samples are used to compute the covariance between each models \n    and :math:`N-r_\\alpha` samples are allocated to \n    estimate the low-fidelity means, and each of these sets are drawn\n    independently from one another.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The estimated covariance between each model.\n\n    nsample_ratios : iterable (nmodels-1)\n        The sample ratioss :math:`r_\\alpha>1` for each low-fidelity model\n\n    pkg : package (optional)\n        A python package (numpy or torch) used to store the covariances.\n\n    Results\n    -------\n    CF : np.ndarray (nmodels-1,nmodels-1)\n        The matrix of covariances between the discrepancies :math:`\\delta`\n\n    cf : np.ndarray (nmodels-1)\n        The vector of covariances between the discrepancies and the \n        high-fidelity model.\n    \"\"\"\n    nmodels = cov.shape[0]\n    F = pkg.zeros((nmodels-1, nmodels-1), dtype=pkg.double)\n    for ii in range(nmodels-1):\n        F[ii, ii] = (nsample_ratios[ii]-1)\/nsample_ratios[ii]\n        for jj in range(ii+1, nmodels-1):\n            F[ii, jj] = (nsample_ratios[ii]-1)\/nsample_ratios[ii] * (\n                nsample_ratios[jj]-1)\/nsample_ratios[jj]\n            F[jj, ii] = F[ii, jj]\n\n    CF = cov[1:, 1:] * F\n    cf = pkg.diag(F) * cov[1:, 0]\n    return CF, cf\n\n\ndef get_discrepancy_covariances_MF(cov, nsample_ratios, pkg=np):\n    r\"\"\"\n    Get the covariances of the discrepancies :math:`\\delta` \n    between each low-fidelity model and its estimated mean using the MFMC\n    sampling strategy.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The estimated covariance between each model.\n\n    nsample_ratios : iterable (nmodels-1)\n        The sample ratioss :math:`r_\\alpha>1` for each low-fidelity model\n\n    pkg : package (optional)\n        A python package (numpy or torch) used to store the covariances.\n\n    Results\n    -------\n    CF : np.ndarray (nmodels-1,nmodels-1)\n        The matrix of covariances between the discrepancies :math:`\\delta`\n\n    cf : np.ndarray (nmodels-1)\n        The vector of covariances between the discrepancies and the \n        high-fidelity model.\n    \"\"\"\n    nmodels = cov.shape[0]\n    F = pkg.zeros((nmodels-1, nmodels-1), dtype=pkg.double)\n    for ii in range(nmodels-1):\n        for jj in range(nmodels-1):\n            rr = min(nsample_ratios[ii], nsample_ratios[jj])\n            F[ii, jj] = (rr - 1) \/ rr\n\n    CF = cov[1:, 1:] * F\n    cf = pkg.diag(F) * cov[1:, 0]\n    return CF, cf\n\n\ndef get_discrepancy_covariances_KL(cov, nsample_ratios, K, L, pkg=np):\n    r\"\"\"\n    Get the covariances of the discrepancies :math:`\\delta` \n    between each low-fidelity model and its estimated mean using the MFMC\n    sampling strategy and the ACV KL estimator.\n\n    The ACV-KL estimator partitions all of the control variates into two \n    groups; the first K variables form a K -level approximate control \n    variate, and the last :math:`M-K` variables are used to reduce the variance\n    of estimating :math:`\\mu_L` some :math:`L \\le K` . The resulting estimator \n    accelerates convergence to OCV-K , and L provides a degree of freedom \n    for targeting a control variate level that contributes the greatest to \n    the estimator variance.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The estimated covariance between each model.\n\n    nsample_ratios : iterable (nmodels-1)\n        The sample ratioss :math:`r_\\alpha>1` for each low-fidelity model\n\n    K : integer (K<=nmodels-1)\n        The number of effective control variates.\n\n    L : integer (1<=L<=K+1)\n        The id of the models whose mean is being targeted by the \n        remaining nmodels-K low fidelity models. \n\n    pkg : package (optional)\n        A python package (numpy or torch) used to store the covariances.\n\n    Results\n    -------\n    CF : np.ndarray (nmodels-1,nmodels-1)\n        The matrix of covariances between the discrepancies :math:`\\delta`\n\n    cf : np.ndarray (nmodels-1)\n        The vector of covariances between the discrepancies and the \n        high-fidelity model.\n    \"\"\"\n    nmodels = cov.shape[0]\n    assert L <= K+1 and L >= 1 and K < nmodels\n    K, L = K-1, L-1\n    F = pkg.zeros((nmodels-1, nmodels-1), dtype=pkg.double)\n    rs = nsample_ratios\n    for ii in range(nmodels-1):\n        if ii <= K:\n            F[ii, ii] = (rs[ii]-1)\/(rs[ii]+1e-20)\n        else:\n            F[ii, ii] = (rs[ii]-rs[L])\/(rs[ii]*rs[L])\n        for jj in range(ii+1, nmodels-1):\n            if (ii <= K) and (jj <= K):\n                ri = min(rs[ii], rs[jj])\n                F[ii, jj] = (ri - 1) \/ (ri + 1e-20)\n            elif (jj > K) and (ii > K):\n                ri = min(rs[ii], rs[jj])\n                t1 = (rs[ii]-rs[L])*(rs[jj]-rs[L])\/(rs[ii]*rs[jj]*rs[L]\n                                                    + 1e-20)\n                t2 = (ri - rs[L]) \/ (rs[ii] * rs[jj] + 1e-20)\n                F[ii, jj] = t1 + t2\n            elif (ii > L) and (ii <= K) and (jj > K):\n                F[ii, jj] = (rs[ii] - rs[L]) \/ (rs[ii] * rs[L] + 1e-20)\n            elif (jj > L) and (jj <= K) and (ii > K):\n                F[ii, jj] = (rs[jj] - rs[L]) \/ (rs[jj] * rs[L] + 1e-20)\n            else:\n                F[ii, jj] = 0.0\n            F[jj, ii] = F[ii, jj]\n\n    CF = cov[1:, 1:] * F\n    cf = pkg.diag(F) * cov[1:, 0]\n    return CF, cf\n\n\ndef get_control_variate_weights(cov):\n    r\"\"\"\n    Get the weights used by the control variate estimator with known low \n    fidelity means.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The estimated covariance between each model.\n\n    Returns\n    -------\n    weights : np.ndarray (nmodels-1)\n        The control variate weights\n    \"\"\"\n    weights = -np.linalg.solve(cov[1:, 1:], cov[0, 1:])\n    return weights\n\n\ndef get_approximate_control_variate_weights(cov, nsample_ratios,\n                                            get_discrepancy_covariances):\n    r\"\"\"\n    Get the weights used by the approximate control variate estimator.\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The estimated covariance between each model.\n\n    nsample_ratios : iterable (nmodels-1)\n        The sample ratioss :math:`r_\\alpha>1` for each low-fidelity model\n\n    get_discrepancy_covariances : callable\n        Function with signature get_discrepancy_covariances(cov,nsample_ratios)\n        which returns the covariances between the discrepancies betweem the \n        low-fidelity models and their approximated mean.\n\n    Returns\n    -------\n    weights : np.ndarray (nmodels-1)\n        The control variate weights\n    \"\"\"\n    CF, cf = get_discrepancy_covariances(cov, nsample_ratios)\n    weights = -np.linalg.solve(CF, cf)\n    return weights\n\n\ndef get_rsquared_acv(cov, nsample_ratios, get_discrepancy_covariances):\n    r\"\"\"\n    Compute r^2 used to compute the variance reduction  of \n    Approximate Control Variate Algorithms \n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest fidelity model\n        is the first model, i.e its variance is cov[0,0]\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, i=1,...,nmodels-1\n\n    get_discrepancy_covariances : callable\n        Function that returns the covariances of the control variate \n        discrepancies. Functions must have the signature \n        CF,cf = get_discrepancy_covariances(cov,nsample_ratios)\n\n    Returns\n    -------\n    rsquared : float\n        The value r^2\n    \"\"\"\n    CF, cf = get_discrepancy_covariances(cov, nsample_ratios)\n    if type(cov) == np.ndarray:\n        try:\n            rsquared = np.dot(cf, np.linalg.solve(CF, cf))\/cov[0, 0]\n        except:\n            return np.array([0.0])*nsample_ratios[0]\n    else:\n        try:\n            rsquared = torch.dot(cf, torch.mv(torch.inverse(CF), cf))\/cov[0, 0]\n        except:\n            #print(\"Error computing inverse of CF\")\n            return torch.tensor([0.0], dtype=torch.double)*nsample_ratios[0]\n    return rsquared\n\n\ndef acv_sample_allocation_sample_ratio_constraint(ratios, *args):\n    ind = args[0]\n    return ratios[ind] - ratios[ind-1]\n\n\ndef generate_samples_and_values_acv_IS(nhf_samples, nsample_ratios,\n                                       functions, generate_samples):\n    nmodels = len(nsample_ratios)+1\n    if not callable(functions):\n        assert len(functions) == nmodels\n    samples1 = [generate_samples(nhf_samples)]*nmodels\n    samples2 = [None]+[np.hstack(\n        [samples1[ii+1], generate_samples(int(nhf_samples*r-nhf_samples))])\n        for ii, r in enumerate(nsample_ratios)]\n    if not callable(functions):\n        values2 = [None]+[f(s) for f, s in zip(functions[1:], samples2[1:])]\n        values1 = [functions[0](samples1[0])]\n        values1 += [values2[ii][:nhf_samples] for ii in range(1, nmodels)]\n    else:\n        nsamples2 = [0]\n        samples_with_id = np.vstack([samples1[0], np.zeros((1, nhf_samples))])\n        for ii in range(1, nmodels):\n            samples2_ii = np.vstack(\n                [samples2[ii], ii*np.ones((1, samples2[ii].shape[1]))])\n            nsamples2.append(samples2[ii].shape[1])\n            samples_with_id = np.hstack([\n                samples_with_id, samples2_ii])\n        values_flattened = functions(samples_with_id)\n        values1 = [values_flattened[:nhf_samples]]\n        values2 = [None]\n        cnt = nhf_samples\n        for ii in range(1, nmodels):\n            values1.append(values_flattened[cnt:cnt+nhf_samples])\n            values2.append(values_flattened[cnt:cnt+nsamples2[ii]])\n            cnt += nsamples2[ii]\n\n    samples = [[s1, s2] for s1, s2 in zip(samples1, samples2)]\n    values = [[v1, v2] for v1, v2 in zip(values1, values2)]\n    return samples, values\n\n\ndef generate_samples_and_values_mlmc(nhf_samples, nsample_ratios, functions,\n                                     generate_samples):\n    r\"\"\"\n    Parameters\n    ==========\n    nhf_samples : integer\n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, i=1,...,nmodels-1\n\n    functions : list of callables\n        The functions used to evaluate each model\n\n    generate_samples : callable\n        Function used to generate realizations of the random variables\n\n    Returns\n    =======\n\n    \"\"\"\n    nmodels = len(nsample_ratios)+1\n    if not callable:\n        assert nmodels == len(functions)\n    assert np.all(nsample_ratios >= 1)\n    samples1 = [generate_samples(nhf_samples)]\n    samples2 = [None]\n    prev_samples = samples1[0]\n    for ii in range(nmodels-1):\n        total_samples = nsample_ratios[ii] * nhf_samples\n        assert total_samples\/int(total_samples) == 1.0\n        total_samples = int(total_samples)\n        samples1.append(prev_samples)\n        nnew_samples = total_samples - prev_samples.shape[1]\n        samples2.append(generate_samples(nnew_samples))\n        prev_samples = samples2[-1]\n\n    if not callable(functions):\n        values1 = [functions[0](samples1[0])]\n        values2 = [None]\n        for ii in range(1, nmodels):\n            values1.append(functions[ii](samples1[ii]))\n            values2.append(functions[ii](samples2[ii]))\n    else:\n        samples_with_id = np.vstack([samples1[0], np.zeros((1, nhf_samples))])\n        nsamples1 = [nhf_samples]\n        nsamples2 = [0]\n        for ii in range(1, nmodels):\n            samples1_ii = np.vstack(\n                [samples1[ii], ii*np.ones((1, samples1[ii].shape[1]))])\n            samples2_ii = np.vstack(\n                [samples2[ii], ii*np.ones((1, samples2[ii].shape[1]))])\n            nsamples1.append(samples1[ii].shape[1])\n            nsamples2.append(samples2[ii].shape[1])\n            samples_with_id = np.hstack([\n                samples_with_id, samples1_ii, samples2_ii])\n        values_flattened = functions(samples_with_id)\n        values1 = [values_flattened[:nsamples1[0]]]\n        values2 = [None]\n        cnt = nsamples1[0]\n        for ii in range(1, nmodels):\n            values1.append(values_flattened[cnt:cnt+nsamples1[ii]])\n            cnt += nsamples1[ii]\n            values2.append(values_flattened[cnt:cnt+nsamples2[ii]])\n            cnt += nsamples2[ii]\n\n    samples = [[s1, s2] for s1, s2 in zip(samples1, samples2)]\n    values = [[v1, v2] for v1, v2 in zip(values1, values2)]\n\n    return samples, values\n\n\ndef get_mfmc_control_variate_weights(cov):\n    weights = -cov[0, 1:]\/np.diag(cov[1:, 1:])\n    return weights\n\n\ndef validate_nsample_ratios(nhf_samples, nsample_ratios):\n    r\"\"\"\n    Check that nsample_ratios* nhf_samples are all integers\n    and that nsample_ratios are all larger than 1\n    \"\"\"\n    nmodels = len(nsample_ratios)+1\n    assert np.all(nsample_ratios >= 1)\n    # check nhf_samples is an integer\n    assert nhf_samples\/int(nhf_samples) == 1.0\n    # convert to int if a float because numpy random assumes nsamples\n    # is an int\n    nhf_samples = int(nhf_samples)\n    nlf_samples = nhf_samples*nsample_ratios\n    for ii in range(nmodels-1):\n        assert np.allclose(\n            nlf_samples[ii]\/int(nlf_samples[ii]), 1.0, atol=1e-5)\n    nlf_samples = np.asarray(nlf_samples, dtype=int)\n    return nlf_samples\n\n\ndef generate_samples_and_values_acv_KL(nhf_samples, nsample_ratios, functions,\n                                       generate_samples, K, L):\n    r\"\"\"\n\n    K : integer (K<=nmodels-1)\n        The number of effective control variates.\n\n    L : integer (1<=L<=K+1)\n        The id of the models whose mean is being targeted by the \n        remaining nmodels-K low fidelity models. \n    \"\"\"\n    nsample_ratios = np.asarray(nsample_ratios)\n    nlf_samples = validate_nsample_ratios(nhf_samples, nsample_ratios)\n    nmodels = nsample_ratios.shape[0]+1\n    assert L <= K+1 and L >= 1 and K < nmodels\n    K, L = K-1, L-1\n\n    max_nsamples = nlf_samples.max()\n    samples = generate_samples(max_nsamples)\n    samples1 = [samples[:, :nhf_samples]]\n    samples2 = [None]\n    nprev_samples1 = nhf_samples\n    nprev_samples_total = nhf_samples\n    for ii in range(1, nmodels):\n        samples1.append(samples[:, :nprev_samples1])\n        samples2.append(samples[:, :nlf_samples[ii-1]])\n        if (ii <= K):\n            nprev_samples1 = nhf_samples\n        else:\n            nprev_samples1 = nlf_samples[L]\n        nprev_samples_total = nlf_samples[ii-1]\n\n    if not callable(functions):\n        values1 = [functions[0](samples1[0])]\n        values2 = [None]\n        for ii in range(1, nmodels):\n            values_ii = functions[ii](samples2[ii])\n            values1.append(values_ii[:samples1[ii].shape[1]])\n            values2.append(values_ii)\n    else:\n        # collect all samples assign an id and then evaluate in one batch\n        # this can be faster if functions is something like a pool model\n        samples_with_id = np.vstack([samples1[0], np.zeros((1, nhf_samples))])\n        for ii in range(1, nmodels):\n            samples_with_id = np.hstack([\n                samples_with_id,\n                np.vstack(\n                    [samples2[ii], ii*np.ones((1, samples2[ii].shape[1]))])])\n        assert samples_with_id.shape[1] == nhf_samples+np.sum(nlf_samples)\n\n        values_flattened = functions(samples_with_id)\n        values1 = [values_flattened[:nhf_samples]]\n        values2 = [None]\n        nprev_samples1 = nhf_samples\n        nprev_samples_total = nhf_samples\n        cnt = nhf_samples\n        for ii in range(1, nmodels):\n            values1.append(values_flattened[cnt:cnt+nprev_samples1])\n            values2.append(values_flattened[cnt:cnt+nlf_samples[ii-1]])\n            cnt += nlf_samples[ii-1]\n            if (ii <= K):\n                nprev_samples1 = nhf_samples\n            else:\n                nprev_samples1 = nlf_samples[L]\n            nprev_samples_total = nlf_samples[ii-1]\n        assert cnt == values_flattened.shape[0]\n\n    samples = [[s1, s2] for s1, s2 in zip(samples1, samples2)]\n    values = [[v1, v2] for v1, v2 in zip(values1, values2)]\n\n    return samples, values\n\n\ndef generate_samples_and_values_mfmc(nhf_samples, nsample_ratios, functions,\n                                     generate_samples, acv_modification=False):\n    r\"\"\"\n    Parameters\n    ==========\n    nhf_samples : integer\n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i = r_i*nhf_samples, i=1,...,nmodels-1\n\n    functions : list of callables\n        The functions used to evaluate each model\n\n    generate_samples : callable\n        Function used to generate realizations of the random variables\n\n    Returns\n    =======\n    samples : list \n        List containing the samples :math:`\\mathcal{Z}_{i,1}` and \n        :math:`\\mathcal{Z}_{i,2}` for each model :math:`i=0,\\ldots,M-1`.\n        The list is [[:math:`\\mathcal{Z}_{0,1}`,:math:`\\mathcal{Z}_{0,2}`],...,[:math:`\\mathcal{Z}_{M-1,1}`,:math:`\\mathcal{Z}_{M-1,2}`]], \n        where :math:`M` is the number of models\n\n    values : list \n        Model values at the points in samples\n\n    \"\"\"\n    nsample_ratios = np.asarray(nsample_ratios)\n    nlf_samples = validate_nsample_ratios(nhf_samples, nsample_ratios)\n    nmodels = nsample_ratios.shape[0]+1\n\n    max_nsamples = nlf_samples.max()\n    samples = generate_samples(max_nsamples)\n    samples1 = [samples[:, :nhf_samples]]\n    samples2 = [None]\n    nprev_samples = nhf_samples\n    for ii in range(1, nmodels):\n        samples1.append(samples[:, :nprev_samples])\n        samples2.append(samples[:, :nlf_samples[ii-1]])\n        if acv_modification:\n            nprev_samples = nhf_samples\n        else:\n            nprev_samples = samples2[ii].shape[1]\n\n    if not callable(functions):\n        values1 = [functions[0](samples1[0])]\n        values2 = [None]\n        for ii in range(1, nmodels):\n            values_ii = functions[ii](samples2[ii])\n            values1.append(values_ii[:samples1[ii].shape[1]])\n            values2.append(values_ii)\n    else:\n        # collect all samples assign an id and then evaluate in one batch\n        # this can be faster if functions is something like a pool model\n        samples_with_id = np.vstack([samples1[0], np.zeros((1, nhf_samples))])\n        for ii in range(1, nmodels):\n            samples_with_id = np.hstack([\n                samples_with_id,\n                np.vstack(\n                    [samples2[ii], ii*np.ones((1, samples2[ii].shape[1]))])])\n        values_flattened = functions(samples_with_id)\n        values1 = [values_flattened[:nhf_samples]]\n        values2 = [None]\n        nprev_samples = nhf_samples\n        cnt = nhf_samples\n        for ii in range(1, nmodels):\n            values1.append(values_flattened[cnt:cnt+nprev_samples])\n            values2.append(values_flattened[cnt:cnt+nlf_samples[ii-1]])\n            cnt += nlf_samples[ii-1]\n            if acv_modification:\n                nprev_samples = nhf_samples\n            else:\n                nprev_samples = samples2[ii].shape[1]\n    assert cnt == values_flattened.shape[0]\n    assert cnt == nhf_samples + np.sum(nlf_samples)\n\n    samples = [[s1, s2] for s1, s2 in zip(samples1, samples2)]\n    values = [[v1, v2] for v1, v2 in zip(values1, values2)]\n\n    return samples, values\n\n\ndef acv_sample_allocation_cost_constraint(ratios, nhf, costs, target_cost):\n    cost = nhf*(costs[0] + np.dot(ratios, costs[1:]))\n    return target_cost - cost\n\n\ndef acv_sample_allocation_cost_constraint_all(ratios, costs, target_cost):\n    nhf, rats = ratios[0], ratios[1:]\n    cost = nhf*(costs[0] + np.dot(rats, costs[1:]))\n    return target_cost - cost\n\n\ndef acv_sample_allocation_cost_constraint_jacobian_all(ratios, costs,\n                                                       target_cost):\n    nhf, rats = ratios[0], ratios[1:]\n    jac = costs.copy().astype(float)\n    jac[0] += np.dot(rats, costs[1:])\n    jac[1:] *= nhf\n    return -jac\n\n\ndef acv_sample_allocation_objective(estimator, nsample_ratios):\n    if use_torch:\n        ratios = torch.tensor(nsample_ratios)\n        gamma = estimator.variance_reduction(ratios)\n        gamma = torch.log10(gamma)\n        return gamma.item()\n    else:\n        gamma = estimator.variance_reduction(ratios)\n        gamma = np.log10(gamma)\n        return gamma\n\n\ndef acv_sample_allocation_jacobian_torch(estimator, nsample_ratios):\n    ratios = torch.tensor(nsample_ratios, dtype=torch.double)\n    ratios.requires_grad = True\n    gamma = estimator.variance_reduction(ratios)\n    gamma = torch.log10(gamma)\n    gamma.backward()\n    grad = ratios.grad.numpy().copy()\n    ratios.grad.zero_()\n    return grad\n\n\ndef acv_sample_allocation_objective_all(estimator, x):\n    if use_torch:\n        xrats = torch.tensor(x, dtype=torch.double)\n        xrats.requires_grad = True\n    else:\n        xrats = x\n    nhf, ratios = xrats[0], xrats[1:]\n    # TODO make this consistent with other objective which does not use\n    # variance as is used below. It is necessary here because need to include\n    # the impact of nhf on objective\n    # print(xrats)\n    gamma = estimator.variance_reduction(ratios) * estimator.cov[0, 0] \/ nhf\n    if use_torch:\n        gamma = torch.log10(gamma)\n        return gamma.item()\n    return np.log10(gamma)\n\n\ndef acv_sample_allocation_jacobian_all_torch(estimator, x):\n    xrats = torch.tensor(x, dtype=torch.double)\n    xrats.requires_grad = True\n    nhf, ratios = xrats[0], xrats[1:]\n    gamma = estimator.variance_reduction(ratios)*estimator.cov[0, 0]\/nhf\n    gamma = torch.log10(gamma)\n    gamma.backward()\n    grad = xrats.grad.numpy().copy()\n    xrats.grad.zero_()\n    return grad\n\n\ndef acv_sample_allocation_objective_all_lagrange(estimator, x):\n    if use_torch:\n        xrats = torch.tensor(x, dtype=torch.double)\n        xrats.requires_grad = True\n    nhf, ratios, lagrange_mult = xrats[0], xrats[1:-1], xrats[-1]\n    gamma = estimator.variance_reduction(ratios)*estimator.cov[0, 0]\/nhf\n    total_cost = estimator.costs[0]*nhf + estimator.costs[1:].dot(\n        ratios*nhf)\n    obj = lagrange_mult*gamma+total_cost\n    if use_torch:\n        obj = torch.log10(obj)\n        return obj.item()\n    else:\n        return np.log10(obj)\n\n\ndef acv_sample_allocation_jacobian_all_lagrange_torch(estimator, x):\n    xrats = torch.tensor(x, dtype=torch.double)\n    xrats.requires_grad = True\n    nhf, ratios, lagrange_mult = xrats[0], xrats[1:-1], xrats[-1]\n    gamma = estimator.variance_reduction(ratios)*estimator.cov[0, 0]\/nhf\n    total_cost = estimator.costs[0]*nhf+estimator.costs[1:].dot(\n        ratios*nhf)\n    obj = lagrange_mult*gamma+total_cost\n    obj = torch.log10(obj)\n    obj.backward()\n    grad = xrats.grad.numpy().copy()\n    xrats.grad.zero_()\n    return grad\n\n\ndef get_allocate_samples_acv_trust_region_constraints(costs, target_cost):\n    from scipy.optimize import NonlinearConstraint\n    nonlinear_constraint = NonlinearConstraint(\n        partial(acv_sample_allocation_cost_constraint_all,\n                costs=costs, target_cost=target_cost), 0, 0)\n    return [nonlinear_constraint]\n\n\ndef solve_allocate_samples_acv_trust_region_optimization(\n        estimator, costs, target_cost, initial_guess, optim_options):\n    nmodels = costs.shape[0]\n    constraints = get_allocate_samples_acv_trust_region_constraints(\n        costs, target_cost)\n    if optim_options is None:\n        tol = 1e-10\n        optim_options = {'verbose': 1, 'maxiter': 1000,\n                         'gtol': tol, 'xtol': 1e-4*tol, 'barrier_tol': tol}\n    from scipy.optimize import Bounds\n    lbs, ubs = [1]*nmodels, [np.inf]*nmodels\n    bounds = Bounds(lbs, ubs)\n    jac = None\n    if use_torch:\n        jac = estimator.jacobian\n    opt = minimize(estimator.objective, initial_guess, method='trust-constr',\n                   jac=jac,  # hess=self.objective_hessian,\n                   constraints=constraints, options=optim_options,\n                   bounds=bounds)\n    if opt.success == False:\n        raise Exception('Trust-constr optimizer failed')\n    return opt\n\n\ndef get_initial_guess(initial_guess, cov, costs, target_cost):\n    if initial_guess is None:\n        nhf_samples_init, nsample_ratios_init = allocate_samples_mfmc(\n            cov, costs, target_cost, standardize=True)[:2]\n        initial_guess = np.concatenate(\n            [[nhf_samples_init], nsample_ratios_init])\n    return initial_guess\n\n\ndef solve_allocate_samples_acv_slsqp_optimization(\n        estimator, costs, target_cost, initial_guess, optim_options):\n    nmodels = len(costs)\n    # alex had these bounds and constraints\n    # bounds = [(1,np.inf)] + [(2, np.inf)]*(nmodels-1)\n    # cons = [dict({'type':'ineq',\n    #             'fun':acv_sample_allocation_cost_constraint_all,\n    #             'args':(costs, target_cost)})]\n    # for jj in range(2,nmodels-1):\n    #     cons.append( dict({'type':'ineq',\n    #                        'fun':acv_sample_allocation_ratio_constraint_all,\n    #                        'args':[jj]}))\n    if optim_options is None:\n        optim_options = {'disp': True, 'ftol': 1e-8,\n                         'maxiter': 10000, 'iprint': 0}\n        # set iprint=2 to printing iteration info\n\n    bounds = [(1, np.inf)] + [(1.1, np.inf)]*(nmodels-1)\n    cons = [{'type': 'eq',\n             'fun': acv_sample_allocation_cost_constraint_all,\n             'jac': acv_sample_allocation_cost_constraint_jacobian_all,\n             'args': (np.asarray(costs), target_cost)}]\n\n    jac = None\n    if use_torch:\n        jac = estimator.jacobian\n    opt = minimize(\n        estimator.objective, initial_guess,\n        method='SLSQP', jac=jac, bounds=bounds,\n        constraints=cons,\n        options=optim_options)\n    if opt.success == False:\n        print(opt)\n        raise Exception('SLSQP optimizer failed'+f'{opt}')\n    return opt\n\n\ndef allocate_samples_acv(cov, costs, target_cost, estimator,\n                         standardize=True, initial_guess=None,\n                         optim_options=None, optim_method='SLSQP'):\n    r\"\"\"\n    Determine the samples to be allocated to each model\n\n    Parameters\n    ----------\n    cov : np.ndarray (nmodels,nmodels)\n        The covariance C between each of the models. The highest \n        fidelity model is the first model, i.e its variance is cov[0,0]\n\n    costs : np.ndarray (nmodels)\n        The relative costs of evaluating each model\n\n    target_cost : float\n        The total cost budget\n\n    Returns\n    -------\n    nhf_samples : integer \n        The number of samples of the high fidelity model\n\n    nsample_ratios : np.ndarray (nmodels-1)\n        The sample ratios r used to specify the number of samples of the \n        lower fidelity models, e.g. N_i=r_i*nhf_samples,i=1,...,nmodels-1\n\n    log10_variance : float\n        The base 10 logarithm of the variance of the estimator\n    \"\"\"\n    initial_guess = get_initial_guess(\n        initial_guess, cov, costs, target_cost)\n    if optim_method == 'trust-constr':\n        opt = solve_allocate_samples_acv_trust_region_optimization(\n            estimator, costs, target_cost, initial_guess, optim_options)\n    else:\n        opt = solve_allocate_samples_acv_slsqp_optimization(\n            estimator, costs, target_cost, initial_guess, optim_options)\n    nhf_samples, nsample_ratios = opt.x[0], opt.x[1:]\n\n    if standardize:\n        nhf_samples, nsample_ratios = standardize_sample_ratios(\n            nhf_samples, nsample_ratios)\n    var = estimator.get_variance(nhf_samples, nsample_ratios)\n    log10_var = np.log10(var.item())\n    return nhf_samples, nsample_ratios, log10_var\n\n\ndef get_rsquared_acv_KL_best(cov, nsample_ratios):\n    r\"\"\" \n    \"\"\"\n    nmodels = cov.shape[1]\n    opt_rsquared = -1\n    KL = None\n    for K in range(1, nmodels):\n        for L in range(1, K+1):\n            get_discrepancy_covariances = partial(\n                get_discrepancy_covariances_KL, K=K, L=L)\n            get_rsquared = partial(\n                get_rsquared_acv,\n                get_discrepancy_covariances=get_discrepancy_covariances)\n            rsquared = get_rsquared(cov, nsample_ratios)\n            # print(K,L,rsquared)\n            if rsquared > opt_rsquared:\n                opt_rsquared = rsquared\n                KL = (K, L)\n    return opt_rsquared\n\n\ndef allocate_samples_acv_best_kl(cov, costs, target_cost, standardize=True,\n                                 initial_guess=None, optim_options=None,\n                                 optim_method='SLSQP'):\n    nmodels = len(costs)\n    sol, KL, opt_log10_var = None, None, np.inf\n\n    for K in range(1, nmodels):\n        for L in range(1, K+1):\n            estimator = ACVMFKL(cov, costs, target_cost, K, L)\n            nhf_samples, nsample_ratios, log10_var = allocate_samples_acv(\n                cov, costs, target_cost, estimator, standardize,\n                initial_guess, optim_options, optim_method)\n            #print(\"K, L = \", K, L)\n            #print(\"\\t \", log10_var)\n            if log10_var < opt_log10_var:\n                opt_log10_var = log10_var\n                sol = (nhf_samples, nsample_ratios)\n                KL = (K, L)\n\n    return sol[0], sol[1], opt_log10_var\n\n\nclass ModelEnsemble(object):\n    r\"\"\"\n    Wrapper class to allow easy one-dimensional \n    indexing of models in an ensemble.\n    \"\"\"\n\n    def __init__(self, functions, names=None):\n        r\"\"\"\n        Parameters\n        ----------\n        functions : list of callable\n            A list of functions defining the model ensemble. The functions must\n            have the call signature values=function(samples)\n        \"\"\"\n        self.functions = functions\n        self.nmodels = len(self.functions)\n        if names is None:\n            names = ['f%d' % ii for ii in range(self.nmodels)]\n        self.names = names\n\n    def __call__(self, samples):\n        r\"\"\"\n        Evaluate a set of models at a set of samples\n\n        Parameters\n        ----------\n        samples : np.ndarray (nvars+1,nsamples)\n            Realizations of a multivariate random variable each with an \n            additional scalar model id indicating which model to evaluate.\n\n        Returns\n        -------\n        values : np.ndarray (nsamples,nqoi)\n            The values of the models at samples\n        \"\"\"\n        model_ids = samples[-1, :]\n        # print(model_ids.max(),self.nmodels)\n        assert model_ids.max() < self.nmodels\n        active_model_ids = np.unique(model_ids).astype(int)\n        active_model_id = active_model_ids[0]\n        I = np.where(model_ids == active_model_id)[0]\n        values_0 = self.functions[active_model_id](samples[:-1, I])\n        assert values_0.ndim == 2\n        nqoi = values_0.shape[1]\n        values = np.empty((samples.shape[1], nqoi))\n        values[I, :] = values_0\n        for ii in range(1, active_model_ids.shape[0]):\n            active_model_id = active_model_ids[ii]\n            I = np.where(model_ids == active_model_id)[0]\n            values[I] = self.functions[active_model_id](samples[:-1, I])\n        return values\n\n\ndef estimate_model_ensemble_covariance(npilot_samples, generate_samples,\n                                       model_ensemble):\n    r\"\"\"\n    Estimate the covariance of a model ensemble from a set of pilot samples\n\n    Parameters\n    ----------\n    npilot_samples : integer\n        The number of samples used to estimate the covariance\n\n    generate_samples : callable\n        Function used to generate realizations of the random variables with \n        call signature samples = generate_samples(npilot_samples)\n\n    model_emsemble : callable\n        Function that takes a set of samples and models ids and evaluates\n        a set of models. See ModelEnsemble.\n        call signature values = model_emsemble(samples)\n\n    Returns\n    -------\n    cov : np.ndarray (nqoi,nqoi)\n        The covariance between the model qoi\n\n    pilot_random_samples : np.ndarray (nvars,npilot_samples)\n        The random samples used to compute the covariance. These samples \n        DO NOT have a model id\n\n    pilot_values : np.ndaray (npilot_samples,nmodels)\n        The values of each model at the pilot samples\n    \"\"\"\n    # generate pilot samples\n    pilot_random_samples = generate_samples(npilot_samples)\n    config_vars = np.arange(model_ensemble.nmodels)[np.newaxis, :]\n    # append model ids to pilot smaples\n    pilot_samples = get_all_sample_combinations(\n        pilot_random_samples, config_vars)\n    # evaluate models at pilot samples\n    pilot_values = model_ensemble(pilot_samples)\n    pilot_values = np.reshape(\n        pilot_values, (npilot_samples, model_ensemble.nmodels))\n    # compute covariance\n    cov = np.cov(pilot_values, rowvar=False)\n    return cov, pilot_random_samples, pilot_values\n\n\nclass ACVMF(object):\n    def __init__(self, cov, costs):\n        self.cov = cov\n        self.costs = costs\n        if use_torch:\n            self.cov = torch.tensor(np.copy(self.cov), dtype=torch.double)\n            self.costs = torch.tensor(np.copy(self.costs), dtype=torch.double)\n\n        # self.objective_fun = partial(\n        #    acv_sample_allocation_objective,self)\n        # self.jacobian_fun = partial(\n        #    acv_sample_allocation_jacobian,self)\n        self.objective_fun_all = partial(\n            acv_sample_allocation_objective_all, self)\n        if use_torch:\n            self.jacobian_fun_all = partial(\n                acv_sample_allocation_jacobian_all_torch, self)\n        else:\n            self.jacobian_fun_all = None\n\n    def get_rsquared(self, nsample_ratios):\n        if use_torch:\n            pkg = torch\n        else:\n            pkg = np\n        rsquared = get_rsquared_acv(\n            self.cov, nsample_ratios,\n            partial(get_discrepancy_covariances_MF, pkg=pkg))\n        try:\n            return rsquared.numpy()\n        except:\n            return rsquared\n\n    def variance_reduction(self, nsample_ratios):\n        \"\"\"\n        This is not the variance reduction relative to the equivalent\n        Monte Carlo estimator. A variance reduction can be smaller than\n        one and still correspond to a multi-fidelity estimator that\n        has a larger variance than the single fidelity Monte Carlo \n        that uses the equivalent number of high-fidelity samples\n        \"\"\"\n        return 1-self.get_rsquared(nsample_ratios)\n\n    def objective(self, x):\n        return self.objective_fun_all(x)\n\n    def jacobian(self, x):\n        return self.jacobian_fun_all(x)\n\n    def allocate_samples(self, target_cost, **kwargs):\n        return allocate_samples_acv(self.cov, self.costs, target_cost, self,\n                                    **kwargs)\n\n    def get_nsamples(self, nhf_samples, nsample_ratios):\n        return np.concatenate([[nhf_samples], nsample_ratios*nhf_samples])\n\n    def get_variance(self, nhf_samples, nsample_ratios):\n        gamma = self.variance_reduction(nsample_ratios)\n        return gamma*self.get_covariance()[0, 0]\/nhf_samples\n\n    def generate_data(self, nhf_samples, nsample_ratios, generate_samples,\n                      model_ensemble):\n        return generate_samples_and_values_mfmc(\n            nhf_samples, nsample_ratios, model_ensemble,\n            generate_samples, acv_modification=True)\n\n    def get_covariance(self):\n        try:\n            return self.cov.numpy()\n        except:\n            return self.cov\n\n    def __call__(self, values):\n        eta = get_mfmc_control_variate_weights(self.get_covariance())\n        return compute_approximate_control_variate_mean_estimate(eta, values)\n\n\nclass MC(object):\n    def __init__(self, cov, costs):\n        self.costs = costs\n        self.cov = cov\n\n    def get_variance(self, nhf_samples, nsample_ratios):\n        return self.cov[0, 0]\/nhf_samples\n\n    def allocate_samples(self, target_cost):\n        return np.floor(target_cost\/self.costs[0]), None, None\n\n    def get_nsamples(self, nhf_samples, nsample_ratios):\n        return np.concatenate([[nhf_samples], np.zeros(self.cov.shape[0]-1)])\n\n    def generate_data(self, nhf_samples, nsample_ratios, generate_samples,\n                      model_ensemble):\n        samples = generate_samples(int(nhf_samples))\n        if not callable(model_ensemble):\n            values = model_ensemble[0](samples)\n        else:\n            samples_with_id = np.vstack(\n                [samples, np.zeros((1, int(nhf_samples)))])\n            values = model_ensemble(samples_with_id)\n        return samples, values\n\n    def __call__(self, values):\n        return values.mean()\n\n\nclass ACVMFKL(ACVMF):\n    def __init__(self, cov, costs, target_cost, K, L):\n        self.K, self.L = K, L\n        super().__init__(cov, costs)\n\n    def get_rsquared(self, nsample_ratios):\n        if use_torch:\n            pkg = torch\n        else:\n            pkg = np\n        return get_rsquared_acv(\n            self.cov, nsample_ratios,\n            partial(get_discrepancy_covariances_KL, K=self.K, L=self.L,\n                    pkg=pkg))\n\n\nclass ACVMFKLBest(ACVMF):\n\n    def get_rsquared(self, nsample_ratios):\n        return get_rsquared_acv_KL_best(self.cov, nsample_ratios)\n\n    def allocate_samples(self, target_cost):\n        return allocate_samples_acv_best_kl(\n            self.cov, self.costs, target_cost, standardize=True,\n            initial_guess=None, optim_options=None,\n            optim_method='SLSQP')\n\n\nclass MFMC(ACVMF):\n    def __init__(self, cov, costs):\n        super().__init__(cov, costs)\n\n    def get_rsquared(self, nsample_ratios):\n        rsquared = get_rsquared_mfmc(self.get_covariance(), nsample_ratios)\n        return rsquared\n\n    def allocate_samples(self, target_cost):\n        return allocate_samples_mfmc(\n            self.get_covariance(), self.costs, target_cost)\n\n\nclass MLMC(ACVMF):\n    def use_lagrange_formulation(self, flag):\n        r\"\"\"For testing purposes only\"\"\"\n        if flag:\n            self.objective_fun_all = partial(\n                acv_sample_allocation_objective_all_lagrange, self)\n            self.jacobian_fun_all = partial(\n                acv_sample_allocation_jacobian_all_lagrange_torch, self)\n        else:\n            self.objective_fun_all = partial(\n                acv_sample_allocation_objective_all, self)\n            self.jacobian_fun_all = partial(\n                acv_sample_allocation_jacobian_all_torch, self)\n\n        if not use_torch:\n            self.jacobian_fun_all = None\n\n    def get_rsquared(self, nsample_ratios):\n        if use_torch:\n            pkg = torch\n        else:\n            pkg = np\n        rsquared = get_rsquared_mlmc(self.cov, nsample_ratios, pkg)\n        if use_torch:\n            rsquared = rsquared.numpy()\n        return rsquared\n\n    def allocate_samples(self, target_cost):\n        return allocate_samples_mlmc(self.cov, self.costs, target_cost)\n\n\ndef compute_single_fidelity_and_approximate_control_variate_mean_estimates(\n        nhf_samples, nsample_ratios,\n        model_ensemble, generate_samples,\n        generate_samples_and_values, cov,\n        get_cv_weights, seed):\n    r\"\"\"\n    Compute the approximate control variate estimate of a high-fidelity\n    model from using it and a set of lower fidelity models. \n    Also compute the single fidelity Monte Carlo estimate of the mean from\n    only the high-fidelity data.\n\n    Notes\n    -----\n    To create reproducible results when running numpy.random in parallel\n    must use RandomState. If not the results will be non-deterministic.\n    This is happens because of a race condition. numpy.random.* uses only\n    one global PRNG that is shared across all the threads without\n    synchronization. Since the threads are running in parallel, at the same\n    time, and their access to this global PRNG is not synchronized between\n    them, they are all racing to access the PRNG state (so that the PRNG's\n    state might change behind other threads' backs). Giving each thread its\n    own PRNG (RandomState) solves this problem because there is no longer\n    any state that's shared by multiple threads without synchronization.\n    Also see new features\n    https:\/\/docs.scipy.org\/doc\/numpy\/reference\/random\/parallel.html\n    https:\/\/docs.scipy.org\/doc\/numpy\/reference\/random\/multithreading.html\n    \"\"\"\n    random_state = np.random.RandomState(seed)\n    local_generate_samples = partial(\n        generate_samples, random_state=random_state)\n    samples, values = generate_samples_and_values(\n        nhf_samples, nsample_ratios, model_ensemble, local_generate_samples)\n    # compute mean using only hf data\n    hf_mean = values[0][0].mean()\n    # compute ACV mean\n    eta = get_cv_weights(cov, nsample_ratios)\n    acv_mean = compute_approximate_control_variate_mean_estimate(eta, values)\n    return hf_mean, acv_mean\n\n\ndef estimate_variance_reduction(model_ensemble, cov, generate_samples,\n                                allocate_samples, generate_samples_and_values,\n                                get_cv_weights, get_rsquared=None,\n                                ntrials=1e3, max_eval_concurrency=1,\n                                target_cost=None, costs=None):\n    r\"\"\"\n    Numerically estimate the variance of an approximate control variate estimator\n    and compare its value to the estimator using only the high-fidelity data.\n\n    Parameters\n    ----------\n    ntrials : integer\n        The number of times to compute estimator using different randomly \n        generated set of samples\n\n    max_eval_concurrency : integer\n        The number of processors used to compute realizations of the estimators,\n        which can be run independently and in parallel.\n    \"\"\"\n\n    M = cov.shape[0]-1  # number of lower fidelity models\n    if costs is None:\n        costs = np.asarray([100\/\/2**ii for ii in range(M+1)])\n    if target_cost is None:\n        target_cost = int(1e4)\n\n    nhf_samples, nsample_ratios = allocate_samples(\n        cov, costs, target_cost)[:2]\n\n    ntrials = int(ntrials)\n    from multiprocessing import Pool\n    pool = Pool(max_eval_concurrency)\n    func = partial(\n        compute_single_fidelity_and_approximate_control_variate_mean_estimates,\n        nhf_samples, nsample_ratios, model_ensemble, generate_samples,\n        generate_samples_and_values, cov, get_cv_weights)\n    if max_eval_concurrency > 1:\n        assert int(os.environ['OMP_NUM_THREADS']) == 1\n        means = np.asarray(pool.map(func, [ii for ii in range(ntrials)]))\n    else:\n        means = np.empty((ntrials, 2))\n        for ii in range(ntrials):\n            means[ii, :] = func(ii)\n\n    numerical_var_reduction = means[:, 1].var(axis=0)\/means[:, 0].var(axis=0)\n    if get_rsquared is not None:\n        true_var_reduction = 1-get_rsquared(cov[:M+1, :M+1], nsample_ratios)\n        return means, numerical_var_reduction, true_var_reduction\n\n    return means, numerical_var_reduction\n\n\ndef get_mfmc_control_variate_weights_pool_wrapper(cov, nsamples):\n    r\"\"\"\n    Create interface that adhears to assumed api for variance reduction check\n    cannot be defined as a lambda locally in a test when using with \n    multiprocessing pool because python cannot pickle such lambda functions\n    \"\"\"\n    return get_mfmc_control_variate_weights(cov)\n\n\ndef get_mlmc_control_variate_weights_pool_wrapper(cov, nsamples):\n    r\"\"\"\n    Create interface that adhears to assumed api for variance reduction check\n    cannot be defined as a lambda locally in a test when using with \n    multiprocessing pool because python cannot pickle such lambda functions\n    \"\"\"\n    return get_mlmc_control_variate_weights(cov.shape[0])\n\n\ndef plot_acv_sample_allocation(nsamples_history, costs, labels, ax):\n    def autolabel(ax, rects, labels):\n        # Attach a text label in each bar in *rects*\n        for rect, label in zip(rects, labels):\n            ax.annotate(label,\n                        xy=(rect.get_x() + rect.get_width()\/2,\n                            rect.get_y() + rect.get_height()\/2),\n                        xytext=(0, -10),  # 3 points vertical offset\n                        textcoords=\"offset points\",\n                        ha='center', va='bottom')\n\n    nsamples_history = np.asarray(nsamples_history)\n    xlocs = np.arange(nsamples_history.shape[0])\n    nmodels = nsamples_history.shape[1]\n\n    cnt = 0\n    total_costs = nsamples_history.dot(costs)\n    for ii in range(nmodels):\n        rel_cost = nsamples_history[:, ii]*costs[ii]\n        rel_cost \/= total_costs\n        rects = ax.bar(xlocs, rel_cost, bottom=cnt, edgecolor='white',\n                       label=labels[ii])\n        autolabel(ax, rects, ['$%d$' % int(n)\n                              for n in nsamples_history[:, ii]])\n        cnt += rel_cost\n    ax.set_xticks(xlocs)\n    ax.set_xticklabels(['$%d$' % t for t in total_costs])\n    ax.set_xlabel(r'$\\mathrm{Total}\\;\\mathrm{Cost}$')\n    # \/ $N_\\alpha$')\n    ax.set_ylabel(\n        r'$\\mathrm{Percentage}\\;\\mathrm{of}\\;\\mathrm{Total}\\;\\mathrm{Cost}$')\n    ax.legend(loc=[0.925, 0.25])\n\n\ndef get_pilot_covariance(nmodels, variable, model_ensemble, npilot_samples):\n    \"\"\"\n    Parameters\n    ----------\n    nmodels : integer\n        The number of information sources\n\n    variable : :class:`pyapprox.variable.IndependentMultivariateRandomVariable`\n        Object defining the nvar uncertain random variables. \n        Samples will be drawn from its joint density.\n\n    model_ensemble : callable\n        Function with signature\n\n        ``model_ensemble(samples) -> np.ndarray (nsamples,1)``\n\n        where samples is a np.ndarray with shape (nvars+1,nsamples) \n\n    npilot_samples : integer\n        The number of samples used to compute correlations\n\n    Returns\n    -------\n    cov_matrix : np.ndarray (nmodels,nmodels)\n        The covariance between each information source\n\n    pilot_samples : np.ndarray (nvars+1,nsamples)\n        The samples used to evaluate each information source when computing\n        correlations\n\n    pilot_values : np.ndarray (nsamples,nmodels)\n        The values of each information source at the pilot samples\n    \"\"\"\n    pilot_samples = generate_independent_random_samples(\n        variable, npilot_samples)\n    config_vars = np.arange(nmodels)[np.newaxis, :]\n    pilot_samples = get_all_sample_combinations(\n        pilot_samples, config_vars)\n    pilot_values = model_ensemble(pilot_samples)\n    pilot_values = np.reshape(\n        pilot_values, (npilot_samples, model_ensemble.nmodels))\n    cov_matrix = np.cov(pilot_values, rowvar=False)\n    return cov_matrix, pilot_samples, pilot_values\n\n\ndef bootstrap_monte_carlo_estimator(values, nbootstraps=10, verbose=True):\n    \"\"\"\n    Approxiamte the variance of the Monte Carlo estimate of the mean using \n    bootstraping\n\n    Parameters\n    ----------\n    values : np.ndarry (nsamples,1)\n        The values used to compute the mean\n\n    nbootstraps : integer\n        The number of boostraps used to compute estimator variance\n\n    verbose:\n        If True print the estimator mean and +\/- 2 standard deviation interval\n\n    Returns\n    -------\n    bootstrap_mean : float\n        The bootstrap estimate of the estimator mean\n\n    bootstrap_variance : float\n        The bootstrap estimate of the estimator variance\n    \"\"\"\n    values = values.squeeze()\n    assert values.ndim == 1\n    nsamples = values.shape[0]\n    bootstrap_values = np.random.choice(\n        values, size=(nsamples, nbootstraps), replace=True)\n    bootstrap_means = bootstrap_values.mean(axis=0)\n    bootstrap_mean = bootstrap_means.mean()\n    bootstrap_variance = np.var(bootstrap_means)\n    if verbose:\n        print('No. samples', values.shape[0])\n        print('Mean', bootstrap_mean)\n        print('Mean +\/- 2 sigma', [bootstrap_mean-2*np.sqrt(\n            bootstrap_variance), bootstrap_mean+2*np.sqrt(bootstrap_variance)])\n\n    return bootstrap_mean, bootstrap_variance\n\n\ndef bootstrap_mfmc_estimator(values, weights, nbootstraps=10,\n                             verbose=True, acv_modification=True):\n    r\"\"\"\n    Boostrap the approximate MFMC estimate of the mean of \n    high-fidelity data with low-fidelity models with unknown means\n\n    Parameters\n    ----------\n    values : list (nmodels)\n        The evaluations of each information source seperated in form\n        necessary for control variate estimators. \n        Each entry of the list contains\n\n        values0 : np.ndarray (num_samples_i0,num_qoi)\n           Evaluations  of each model\n           used to compute the estimator :math:`Q_{i,N}` of \n\n        values1: np.ndarray (num_samples_i1,num_qoi)\n            Evaluations used compute the approximate \n            mean :math:`\\mu_{i,r_iN}` of the low fidelity models.\n\n    weights : np.ndarray (nmodels-1)\n        The control variate weights\n\n    nbootstraps : integer\n        The number of boostraps used to compute estimator variance\n\n    verbose:\n        If True print the estimator mean and +\/- 2 standard deviation interval\n\n    Returns\n    -------\n    bootstrap_mean : float\n        The bootstrap estimate of the estimator mean\n\n    bootstrap_variance : float\n        The bootstrap estimate of the estimator variance\n    \"\"\"\n    assert acv_modification\n    nmodels = len(values)\n    assert len(values) == nmodels\n    # high fidelity monte carlo estimate of mean\n    bootstrap_means = []\n    for jj in range(nbootstraps):\n        vals = values[0][0]\n        nhf_samples = vals.shape[0]\n        I1 = np.random.choice(\n            np.arange(nhf_samples), size=(nhf_samples), replace=True)\n        est = vals[I1].mean()\n        nprev_samples = nhf_samples\n        for ii in range(nmodels-1):\n            vals1 = values[ii+1][0]\n            nsamples1 = vals1.shape[0]\n            vals2 = values[ii+1][1]\n            nsamples2 = vals2.shape[0]\n            assert nsamples1 == nhf_samples\n            I2 = np.random.choice(\n                np.arange(nhf_samples, nsamples2), size=(nsamples2-nhf_samples),\n                replace=True)\n            # maks sure same shared samples are still used.\n            vals2_boot = np.vstack([vals2[I1], vals2[I2]])\n            est += weights[ii]*(vals1[I1].mean()-vals2_boot.mean())\n            if acv_modification:\n                nprev_samples = nhf_samples\n            else:\n                nprev_samples = nsamples2\n        bootstrap_means.append(est)\n    bootstrap_means = np.array(bootstrap_means)\n    bootstrap_mean = np.mean(bootstrap_means)\n    bootstrap_variance = np.var(bootstrap_means)\n    return bootstrap_mean, bootstrap_variance\n\n\ndef compute_covariance_from_control_variate_samples(values):\n    r\"\"\"\n    Compute the covariance between information sources from a set\n    of evaluations of each information source.\n\n    Parameters\n    ----------\n    values : list (nmodels)\n        The evaluations of each information source seperated in form\n        necessary for control variate estimators. \n        Each entry of the list contains\n\n        values0 : np.ndarray (num_samples_i0,num_qoi)\n           Evaluations  of each model\n           used to compute the estimator :math:`Q_{i,N}` of\n\n        values1: np.ndarray (num_samples_i1,num_qoi)\n            Evaluations used compute the approximate \n             mean :math:`\\mu_{i,r_iN}` of the low fidelity models.\n\n    Returns\n    -------\n    cov : np.ndarray (nmodels)\n        The covariance between the information sources\n    \"\"\"\n    shared_samples_values = np.hstack(\n        [v[0].squeeze()[:, np.newaxis] for v in values])\n    cov = np.cov(shared_samples_values, rowvar=False)\n    # print(cov,'\\n',cov_matrix)\n    return cov\n\n\ndef compare_estimator_variances(target_costs, estimators, cov_matrix, model_costs):\n    variances, nsamples_history = [], []\n    for target_cost in target_costs:\n        for estimator in estimators:\n            est = estimator(cov_matrix, model_costs)\n            nhf_samples, nsample_ratios = est.allocate_samples(target_cost)[:2]\n            variances.append(est.get_variance(nhf_samples, nsample_ratios))\n            nsamples_history.append(\n                est.get_nsamples(nhf_samples, nsample_ratios))\n    variances = np.asarray(variances)\n    nsamples_history = np.asarray(nsamples_history)\n    return nsamples_history, variances\n\n\ndef plot_estimator_variances(nsamples_history, variances, model_costs,\n                             est_labels, ax, ylabel=None):\n    linestyles = ['-', '--', ':', '-.']\n    nestimators = len(est_labels)\n    assert len(nsamples_history) == len(variances)\n    assert len(nsamples_history) % nestimators == 0\n    for ii in range(nestimators):\n        est_total_costs = np.array(nsamples_history[ii::nestimators]).dot(\n            model_costs)\n        est_variances = variances[ii::nestimators]\n        ax.loglog(est_total_costs, est_variances, ':', label=est_labels[ii],\n                  ls=linestyles[ii])\n    if ylabel is None:\n        ylable = r'$\\mathrm{Estimator\\;Variance}$'\n    ax.set_xlabel(r'$\\mathrm{Target\\;Cost}$')\n    ax.set_ylabel(ylabel)\n    ax.legend()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_53","text":"<reponame>jjhenkel\/dockerizeme\nimport numpy as np\nfrom noise import pnoise2, pnoise3\nfrom scipy.ndimage.filters import gaussian_filter, gaussian_filter1d\n\ndef center_and_scale(drawing):\n    \"\"\"\n    Translate an entire drawing to the mean location of the points,\n    then scale the drawing to fit within +\/-1.\n    \"\"\"\n    all_points = np.vstack(drawing)\n    meanxy = np.mean(all_points, axis=0)\n    minxy = np.min(all_points, axis=0) - meanxy\n    maxxy = np.max(all_points, axis=0) - meanxy\n    max_range = np.max(np.abs((minxy, maxxy)))\n    return [(stroke - meanxy) \/ max_range for stroke in drawing]\n\ndef get_noise_seed(seed=None):\n    if seed is None:\n        return np.random.rand(1) * 100000\n    else:\n        return seed\n    \ndef noise_xy(points, scale=0.1, frequency=0.5, octaves=3, seed=None):\n    \"\"\"\n    Generate a number of x,y points using Perlin noise.\n    \"\"\"\n    seed = get_noise_seed(seed)\n    tn = np.linspace(seed, seed + frequency, points)\n    x = [pnoise2(0, float(t), octaves) * scale for t in tn]\n    y = [pnoise2(1, float(t), octaves) * scale for t in tn]\n    return x, y\n\ndef jitter_stroke(stroke, scale):\n    \"\"\"\n    Jitter the points in a stroke with Perlin noise.\n    \"\"\"\n    n = len(stroke)\n    x, y = noise_xy(n, scale=scale)\n    offsets = np.vstack([x, y])\n    return stroke + offsets.T\n\ndef jitter(drawing, scale=0.1):\n    \"\"\"\n    Jitter an entire drawing by jittering each stroke with Perlin noise.\n    \"\"\"\n    return [jitter_stroke(stroke, scale) for stroke in drawing]\n\ndef warp_stroke(stroke, scale=0.5, frequency=0.5, octaves=3, seed=None):\n    \"\"\"\n    Warp a stroke by applying a Perlin noise deformation field.\n    \"\"\"\n    seed = get_noise_seed(seed)\n    offsets = [[pnoise3(0 + seed, x, y, 3), pnoise3(1 + seed, x, y, 3)] for x, y in (stroke * frequency)]\n    return stroke + np.asarray(offsets) * scale\n    \ndef warp(drawing, scale=0.5, frequency=0.5, octaves=3, seed=None):\n    \"\"\"\n    Warp a drawing by applying a Perlin noise deformation field.\n    \"\"\"\n    seed = get_noise_seed(seed)\n    return [warp_stroke(stroke, scale=scale, frequency=frequency, octaves=octaves, seed=seed) for stroke in drawing]\n\ndef smooth_position_stroke(stroke, sigma=1):\n    \"\"\"\n    Smooth a stroke with a Gaussian filter.\n    This smooths things in \"sample space\" rather than \"real space\".\n    \"\"\"\n    stroke[:,0] = gaussian_filter1d(stroke[:,0], sigma=sigma, mode='nearest')\n    stroke[:,1] = gaussian_filter1d(stroke[:,1], sigma=sigma, mode='nearest')\n    return stroke\n    \ndef smooth_position(drawing, sigma=1):\n    \"\"\"\n    Smooth all the strokes in a drawing with a Gaussian filter.\n    This smooths things in \"sample space\" rather than \"real space\".\n    \"\"\"\n    sigma = np.abs(sigma * np.random.randn(1))\n    return [smooth_position_stroke(stroke, sigma=sigma) for stroke in drawing]\n\ndef smooth_velocity_stroke(stroke, sigma=1):\n    \"\"\"\n    Smooth a stroke by smoothing the derivative rather than the points directly.\n    \"\"\"\n    x = stroke[:,0]\n    y = stroke[:,1]\n    xd = gaussian_filter1d(np.diff(x), sigma=sigma, mode='nearest')\n    yd = gaussian_filter1d(np.diff(y), sigma=sigma, mode='nearest')\n    stroke[1:,0] = x[0] + np.cumsum(xd)\n    stroke[1:,1] = y[0] + np.cumsum(yd)\n    return stroke\n    \ndef smooth_velocity(drawing, sigma=1):\n    \"\"\"\n    Smooth a drawing by smoothing the derivative rather than the points directly.\n    \"\"\"\n    sigma = np.abs(sigma * np.random.randn(1))\n    return [smooth_velocity_stroke(stroke, sigma=sigma) for stroke in drawing]\n\ndef jitter_scale(drawing, overall_sigma=0.1, aspect_sigma=0.05):\n    \"\"\"\n    Scale an entire drawing about 0,0 by a random gaussian.\n    \"\"\"\n    scale = (1 + np.random.randn(1) * overall_sigma) + np.random.randn(2) * aspect_sigma\n    return [stroke * scale for stroke in drawing]\n\ndef jitter_translate(drawing, sigma=0.10):\n    \"\"\"\n    Translate an entire drawing by a random gaussian.\n    \"\"\"\n    translate = np.random.randn(2) * sigma\n    return [stroke + translate for stroke in drawing]\n\ndef create_rotation_matrix(theta):\n    c, s = np.cos(theta), np.sin(theta)\n    return np.array([[c, -s], [s, c]])\n\ndef jitter_rotate(drawing, sigma=0.2):\n    \"\"\"\n    Rotate an entire drawing about 0,0 by a random gaussian.\n    \"\"\"\n    rotation = np.random.randn(1) * sigma\n    matrix = create_rotation_matrix(rotation)\n    return [np.dot(stroke, matrix).squeeze() for stroke in drawing]\n\ndef jitter_translate_stroke(drawing, sigma=0.02):\n    \"\"\"\n    Translate each stroke in a drawing by a random gaussian.\n    \"\"\"\n    return [stroke + np.random.randn(2) * sigma for stroke in drawing]\n\ndef jitter_scale_stroke(drawing, sigma=0.05):\n    \"\"\"\n    Scale each stroke in a drawing about the center of each stroke by a random gaussian.\n    \"\"\"\n    centers = [np.mean(stroke) for stroke in drawing]\n    return [((stroke - center) * (1 + np.random.randn(2) * sigma)) + center\n            for center, stroke in zip(centers, drawing)]\n\ndef jitter_rotate_stroke(drawing, sigma=0.2):\n    \"\"\"\n    Rotate each stroke in a drawing about the center of each stroke by a random gaussian.\n    \"\"\"\n    rotation = np.random.randn(1) * sigma\n    matrix = create_rotation_matrix(rotation)\n    centers = [np.mean(stroke) for stroke in drawing]\n    return [np.dot(stroke - center, matrix).squeeze() + center\n            for center, stroke in zip(centers, drawing)]\n\ndef shuffle_strokes(drawing, amount=0.25):\n    \"\"\"\n    Randomly swap the order of a percentage of the strokes in a drawing.\n    May swap less than the given percentage if it undoes a previous swap.\n    \"\"\"\n    n = len(drawing)\n    stroke_indices = np.arange(n)\n    shuffle_count = int(n * amount)\n    for i in range(shuffle_count):\n        i0 = np.random.randint(n)\n        i1 = np.random.randint(n)\n        temp = stroke_indices[i0]\n        stroke_indices[i0] = stroke_indices[i1]\n        stroke_indices[i1] = temp\n    return [drawing[i] for i in stroke_indices]\n\ndef reverse_strokes(drawing, amount=0.25):\n    \"\"\"\n    Randomly reverse the direction of a percentage of the strokes in a drawing.\n    \"\"\"\n    n = len(drawing)\n    indices = np.arange(n)\n    np.random.shuffle(indices)\n    flip_n = int(amount * n)\n    flip_indices = indices[:flip_n]\n    flips = [i in flip_indices for i in range(n)]\n    return [np.flipud(stroke) if flip else stroke for flip, stroke in zip(flips, drawing)]"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_54","text":"<gh_stars>0\nimport numpy as np\r\nimport threading\r\nfrom pycrazyswarm import *\r\nimport time\r\nimport scipy as sp\r\n\r\n# 飞控常数\r\nTAKEOFFTIME = 2.0\r\nRADII = 0.7\r\nHOVERTIME = 3.0\r\nCATIME = 1.0\r\n\r\n# cf是否避障标志位\r\ncf_flag = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0}\r\n\r\n# 航点类\r\nclass Waypoint:\r\n    def __init__(self, agent, x, y, z, arrival, duration):\r\n        self.agent = agent\r\n        self.x = x\r\n        self.y = y\r\n        self.z = z\r\n        self.arrival = arrival\r\n        self.duration = duration\r\n\r\n    def __lt__(self, other):\r\n        return self.arrival < other.arrival\r\n\r\n    def __repr__(self):\r\n        return \"Ag {} at {} s. [{}, {}, {}]\".format(self.agent, self.arrival, self.x, self.y, self.z)\r\n\r\n# 载入数据\r\ndef load_waypoint(filepath):\r\n    # load csv file\r\n    data = np.loadtxt(filepath, skiprows=1, delimiter=',')\r\n    data[data[:, 0].argsort()]\r\n\r\n    # convert to internal data structure\r\n    waypoints = []\r\n    lastAgent = None\r\n    for row in data:\r\n        if lastAgent is None or lastAgent != row[0]:\r\n            lastTime = 0.0\r\n        waypoints.append(Waypoint(int(row[0]), row[1], row[2], row[3], row[4], row[4] - lastTime))\r\n        lastTime = row[4]\r\n        lastAgent = int(row[0])\r\n\r\n    # sort waypoints by arrival time\r\n    waypoints.sort()\r\n\r\n    return waypoints\r\n\r\n# 第一版\r\n# def obstacle_avoidance(cfs, tello, radii):\r\n#     while(1):\r\n#         for cf in cfs:\r\n#             dist = np.sqrt((cf.state.pos.x - tello.state.pos.x)**2 + (cf.state.pos.y - tello.state.pos.y)**2\r\n#             + (cf.state.pos.z - tello.state.pos.z)**2)\r\n#             if dist < radii:\r\n#                 pos = [cf.state.pos.x, cf.state.pos.y, cf.state.pos.z + 1.0]\r\n#                 cf.goTo(pos, 0, 1.0)\r\n\r\n# 避障线程函数\r\n# 不能在避障过程中继续检测\r\ndef collision_avoidance(cf_ca, tello_ca, radii_ca):\r\n    while(1):\r\n        dist = np.sqrt((cf_ca.state.pos.x - tello_ca.state.pos.x)**2 + (cf_ca.state.pos.y - tello_ca.state.pos.y)**2\r\n                       + (cf_ca.state.pos.z - tello_ca.state.pos.z)**2)\r\n        if dist < radii_ca:\r\n            cf_flag[cf_ca.id] = 1\r\n            dz = 1 if tello_ca.state.pos.z <= cf_ca.state.pos.z else -1\r\n            pos_ca = [cf_ca.state.pos.x, cf_ca.state.pos.y, cf_ca.state.pos.z + 1.0*dz]\r\n            cf_ca.goTo(pos_ca, 0, CATIME)\r\n            # timeHelper.sleep(CATIME)\r\n            time.sleep(CATIME)\r\n            dx = 1 if tello_ca.state.pos.x <= cf_ca.state.pos.x else -1\r\n            dy = 1 if tello_ca.state.pos.y <= cf_ca.state.pos.y else -1\r\n            pos_ca = [cf_ca.state.pos.x + 1.0*dx, cf_ca.state.pos.y + 1.0*dy, cf_ca.state.pos.z]\r\n            # cf_ca.goTo(pos_ca, 0, CATIME)\r\n            # timeHelper.sleep(CATIME)\r\n            # timeHelper.sleep(HOVERTIME)\r\n            time.sleep(HOVERTIME)\r\n            cf_flag[cf_ca.id] = 0\r\n\r\n\r\nif __name__ == \"__main__\":\r\n    # load data\r\n    waypoints = load_waypoint(\"waypoints6_high.csv\")\r\n\r\n    # load cf\r\n    swarm = Crazyswarm()\r\n    timeHelper = swarm.timeHelper\r\n    allcfs = swarm.allcfs\r\n    cfs = allcfs.crazyflies\r\n    cf1, cf2, cf3, cf4, cf5, cf6, cf7 = allcfs.crazyflies\r\n    cf7.setLEDColor(1, 0.5, 0.5)\r\n\r\n    # collision avoidance\r\n    thread_ca_cf1 = threading.Thread(target=collision_avoidance, args=(cf1, cf7, RADII))\r\n    thread_ca_cf2 = threading.Thread(target=collision_avoidance, args=(cf2, cf7, RADII))\r\n    thread_ca_cf3 = threading.Thread(target=collision_avoidance, args=(cf3, cf7, RADII))\r\n    thread_ca_cf4 = threading.Thread(target=collision_avoidance, args=(cf4, cf7, RADII))\r\n    thread_ca_cf5 = threading.Thread(target=collision_avoidance, args=(cf5, cf7, RADII))\r\n    thread_ca_cf6 = threading.Thread(target=collision_avoidance, args=(cf6, cf7, RADII))\r\n    thread_ca_cf1.start()\r\n    thread_ca_cf2.start()\r\n    thread_ca_cf3.start()\r\n    thread_ca_cf4.start()\r\n    thread_ca_cf5.start()\r\n    thread_ca_cf6.start()\r\n    # thread_ca.join()\r\n\r\n    # patrol\r\n    allcfs.takeoff(targetHeight=1.0, duration=TAKEOFFTIME)\r\n    timeHelper.sleep(TAKEOFFTIME)\r\n    lastTime = 0.0\r\n\r\n    while(1):\r\n        for waypoint in waypoints:\r\n            cf = allcfs.crazyfliesById[waypoint.agent]\r\n            if cf_flag[cf.id] == 1:\r\n                waypoint.arrival = waypoint.arrival + 10.0\r\n                continue\r\n            if waypoint.arrival == 0:\r\n                pos = [waypoint.x, waypoint.y, waypoint.z]\r\n                cf.goTo(pos, 0, 2.0)\r\n            elif waypoint.duration > 0:\r\n                timeHelper.sleep(waypoint.arrival - lastTime)\r\n                lastTime = waypoint.arrival\r\n                pos = [waypoint.x, waypoint.y, waypoint.z]\r\n                cf.goTo(pos, 0, waypoint.duration)\r\n            waypoint.arrival = waypoint.arrival + 10.0\r\n\r\n    # land\r\n    allcfs.land(targetHeight=0.02, duration=2.0)\r\n    timeHelper.sleep(2.0)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_55","text":"\"\"\"Tests for the n2j.trainval_data.graphs.cosmodc2_graph.CosmoDC2Graph class\n\n\"\"\"\n\nimport os\nimport unittest\nimport shutil\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\nfrom n2j.inference.inference_manager import InferenceManager\nimport n2j.data as in_data\n\n\nclass TestInferenceManager(unittest.TestCase):\n    \"\"\"A suite of tests verifying CosmoDC2Graph class methods\n\n    \"\"\"\n\n    @classmethod\n    def setUpClass(cls):\n        \"\"\"InferenceManager object to test\n\n        \"\"\"\n        infer_obj = InferenceManager('cuda',\n                                     out_dir='inf_results\/E3',\n                                     checkpoint_dir='results\/E3',\n                                     seed=1028)\n        cls.infer_obj = infer_obj\n\n    def test_load_dataset(self):\n        if True:\n            return\n        features = ['galaxy_id', 'ra', 'dec', 'redshift']\n        features += ['ra_true', 'dec_true', 'redshift_true']\n        features += ['ellipticity_1_true', 'ellipticity_2_true']\n        features += ['bulge_to_total_ratio_i']\n        features += ['ellipticity_1_bulge_true', 'ellipticity_1_disk_true']\n        features += ['ellipticity_2_bulge_true', 'ellipticity_2_disk_true']\n        features += ['shear1', 'shear2', 'convergence']\n        features += ['size_bulge_true', 'size_disk_true', 'size_true']\n        features += ['mag_{:s}_lsst'.format(b) for b in 'ugrizY']\n        # Features to train on\n        sub_features = ['ra_true', 'dec_true']\n        # sub_features += ['size_true']\n        # sub_features += ['ellipticity_1_true', 'ellipticity_2_true']\n        sub_features += ['mag_{:s}_lsst'.format(b) for b in 'ugrizY']\n        IN_DIR = in_data.__path__[0]  # where raw data lies\n        TRAIN_HP = [10327]\n        VAL_HP = [10326]\n        N_TRAIN = [20000]\n        N_VAL = 1000\n        BATCH_SIZE = 1000  # min(N_TRAIN\/\/5, 50)\n\n        SUB_TARGET = ['final_kappa', ]  # 'final_gamma1', 'final_gamma2']\n        SUB_TARGET_LOCAL = ['stellar_mass', 'redshift']\n        norm_obj = scipy.stats.norm(loc=0.01, scale=0.03)\n        # Training\n        self.infer_obj.load_dataset(\n                                    dict(features=features,\n                                         raytracing_out_dirs=[os.path.join(IN_DIR, f'cosmodc2_{hp}\/Y_{hp}') for hp in TRAIN_HP],\n                                         healpixes=TRAIN_HP,\n                                         n_data=N_TRAIN,\n                                         aperture_size=1.0,\n                                         subsample_pdf_func=norm_obj.pdf,\n                                         stop_mean_std_early=False,\n                                         in_dir=IN_DIR),\n                                    sub_features=sub_features,\n                                    sub_target=SUB_TARGET,\n                                    sub_target_local=SUB_TARGET_LOCAL,\n                                    is_train=True,\n                                    batch_size=BATCH_SIZE,\n                                    rebin=False,\n                                    )\n        # Test\n        self.infer_obj.load_dataset(\n                                    dict(features=features,\n                                         raytracing_out_dirs=[os.path.join(IN_DIR, f'cosmodc2_{hp}\/Y_{hp}') for hp in VAL_HP],\n                                         healpixes=VAL_HP,\n                                         n_data=[N_VAL]*len(VAL_HP),\n                                         aperture_size=1.0,\n                                         in_dir=IN_DIR),\n                                    sub_features=sub_features,\n                                    sub_target=SUB_TARGET,\n                                    sub_target_local=SUB_TARGET_LOCAL,\n                                    is_train=False,\n                                    batch_size=N_VAL,  # FIXME: must be same as train\n                                    )\n\n    def test_configure_model(self):\n        pass\n\n    def test_load_checkpoint(self):\n        pass\n\n    def test_get_bnn_kappa(self):\n        pass\n\n    @classmethod\n    def tearDownClass(cls):\n        pass\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_56","text":"#!\/usr\/bin\/python\n\n# Copyright (c) 2012, <NAME> <<EMAIL>>\n# Licensed under the MIT license. See LICENSE.txt or \n# http:\/\/www.opensource.org\/licenses\/mit-license.php \n\nimport scipy\nimport scipy.io as sio\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nimport matplotlib.mlab as mlab\nimport numpy as np\n\nimport time\nimport cProfile\nimport argparse\n\nimport libbnp as bnp\n\nfrom dirHdpGenerative import *\nfrom hdpIncremental import *\n\nimport fileinput\n\nif __name__ == '__main__':\n\n  parser = argparse.ArgumentParser(description = 'hdp topic modeling of synthetic data')\n  parser.add_argument('-T', type=int, default=10, help='document level truncation')\n  parser.add_argument('-K', type=int, default=100, help='corpus level truncation')\n  parser.add_argument('-S', type=int, default=1, help='mini batch size')\n  #parser.add_argument('-D', type=int, default=500, help='number of documents to synthesize')\n  parser.add_argument('-H', type=int, default=1, help='number of held out documents for perplexity computation')\n  parser.add_argument('-N', type=int, default=100, help='number of words per document')\n  parser.add_argument('-Nw', type=int, default=10, help='alphabet size (how many different words)')\n  parser.add_argument('-a','--alpha', type=float, default=3.0, help='concentration parameter for document level')\n  parser.add_argument('-o','--omega', type=float, default=30.0, help='concentration parameter for corpus level')\n  parser.add_argument('-k','--kappa', type=float, default=0.9, help='forgetting rate for stochastic updates')\n  #parser.add_argument('-s', action='store_false', help='switch to make the program use synthetic data')\n  parser.add_argument('-g','--gibbs', action='store_true', help='switch to make the program use gibbs sampling instead of variational')\n  args = parser.parse_args()\n  print('args: {0}'.format(args))\n\n\n  #D = args.D #number of documents to process\n  D_te = args.H # (ho= held out) number of docs used for testing (perplexity)\n  N_d = args.N # max number of words per doc\n  Nw = args.Nw # how many different symbols are in the alphabet\n  kappa = args.kappa # forgetting rate\n  K = args.K # top level truncation\n  T = args.T # low level truncation\n  S = args.S # mini batch size\n  alpha = args.alpha # concentration on G_i\n  omega = args.omega # concentration on G_0\n  dirAlphas = np.ones(Nw)*1.1 # alphas for dirichlet base measure\n\n  print(\"---------------- Starting! --------------\")\n  \n  discrete = False\n  if discrete:\n    dataType='uint32'\n    hdp = HDP_var_Dir_inc(K,T,Nw,omega,alpha,dirAlphas)\n  else:\n    dataType='double'\n    hdp = HDP_var_NIW_inc(K,T,Nw,omega,alpha,np.ones((1,1))*(-5),2.1,np.ones((1,1))*5.1*3,2.1)\n\n  x=[]\n  x_tr=[]\n  x_te=[]\n  for line in fileinput.input():\n    if len(x_te) < D_te:\n      x_te.append(np.fromstring(line, dtype=dataType, sep=\" \"))\n    else:\n      x.append(np.fromstring(line, dtype=dataType, sep=\" \"))\n      #print('{}'.format(x[-1]))\n#    if len(x) >= S:\n#      print('----------')\n  hdp.updateEst(x,kappa,S,x_te)\n  x_tr.extend(x)\n  x=[]\n#    if len(x) >= S+2:\n#      print('----------')\n#      hdp.updateEst(x[0:-3],kappa,S,x_te=x[-2:-1])\n#      x_tr.extend(x[0:-3])\n#      x_te.extend(x[-2:-1])\n#      x=[]\n\n  hdp.loadHDPSample(x_tr,x_te, hdp.hdp_var)\n  #print('{}'.format(hdp.state['logP_w']))\n  hdp.save('incTest.mat')\n\n# -- make sure the saved model is saved and loaded correctly\n#  hdp2 = HDP_var_Dir_inc(K,T,Nw,omega,alpha,dirAlpha)\n  hdp2 = HDP_var_NIW_inc(K,T,Nw,omega,alpha,np.ones((1,1))*5,1,np.ones((1,1)),1)\n  hdp2.load('incTest.mat')\n  #print('{}'.format(hdp2.state['logP_w']))\n  hdp.stateEquals(hdp2)\n\n# -- plot some things\n  fig0=plt.figure(0)\n  imgplot=plt.imshow(hdp.docTopicsImg(),interpolation='nearest',cmap=cm.hot);\n  fig0.show()\n\n  if not discrete:\n\n    X=np.linspace(-20,20,100)\n    sig=np.sqrt(hdp.state['beta'][:,0])\n    mu=hdp.state['beta'][:,1]\n\n    fig1=plt.figure()\n    prop = hdp.state['sigV']\n    for i in range(0,mu.shape[0]):\n      plt.plot(X,prop[i]*mlab.normpdf(X,mu[i],sig[i]))\n    fig1.show()\n\n    toPlot = [0,1,2,3,4,100,101,102,103,104]\n    fig2=plt.figure()\n    for d in toPlot:\n      sigPi=hdp.state['sigPi'][d,:]\n      c = hdp.state['c'][d,:]\n      \n      Y=np.zeros(X.size)\n      c_u = np.unique(c)\n      sigPi_u = np.zeros(c_u.size)\n      for i in range(0,c_u.size):\n        sigPi_u[i] = np.sum(sigPi[c_u[i] == c])\n        Y += sigPi_u[i]*mlab.normpdf(X,mu[c_u[i]],sig[c_u[i]])\n      print('{}: c_u={}; sigPi_u={}'.format(d,c_u,sigPi_u))\n      \n      plt.subplot(2,1,d\/100)\n      plt.plot(X,Y)\n      plt.title(str(d))\n    \n      plt.plot(X,mlab.normpdf(X,np.mean(x_tr[d]), np.std(x_tr[d]) ),'r-')\n\n    fig2.show()\n      \n    \n\n\n#  symKLimg = hdp.symKLImg();\n#  print('logP_w:\\n{}'.format(hdp.state['logP_w']))\n#  print('symKLimg:\\n{}'.format(symKLimg))\n#  fig1=plt.figure(1)\n#  imgplot=plt.imshow(symKLimg,interpolation='nearest',cmap=cm.hot);\n#  plt.colorbar()\n#  fig1.show()\n#\n#  jsDimg = hdp.jsDImg();\n#  print('jsDimg:\\n{}'.format(jsDimg))\n#  fig2=plt.figure(2)\n#  imgplot=plt.imshow(jsDimg,interpolation='nearest',cmap=cm.hot);\n#  plt.colorbar()\n#  plt.show()\n\n  time.sleep(10000)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_57","text":"<reponame>engine74396\/bilibili_danmaku_spider<gh_stars>1-10\n# -*- coding：utf-8 -*-\r\n# __author__ = 'engine'\r\n# __time__ = '2018\/4\/19 21:39'\r\nimport re\r\nimport requests\r\nimport os\r\nfrom wordcloud import WordCloud,ImageColorGenerator\r\nimport jieba\r\nfrom scipy.misc import imread\r\nimport matplotlib.pyplot as plt\r\nimport random\r\n\r\n#弹幕爬取\r\nd = os.path.dirname(__file__)\r\n\r\nstart_url = input(\"输入B站视频地址：\")\r\nfile_path = r'text\\1.txt'\r\n\r\ndef get_flash_url(url):\r\n    html_1 = requests.get(url)\r\n    html_1.encoding = 'utf-8'\r\n    fl_num = re.findall('\"cid\":(.*?),\"page\":\\d,\"from\":\"vupload\"',html_1.text)[0]\r\n    flash_url =  'https:\/\/comment.bilibili.com\/'+str(fl_num)+'.xml'\r\n    return flash_url\r\n\r\ndef get_flash(url):\r\n    html = requests.get(url)\r\n    html.encoding = 'utf-8'\r\n    seg_list = re.findall('\">(.*?)<\/d>',html.text)\r\n    num = 0\r\n    with open(file_path, 'w',encoding='utf-8') as f:\r\n        for i in seg_list:\r\n            print(i)\r\n            f.write(i + '\\n')\r\n    f.close()\r\nb = get_flash_url(start_url)\r\nget_flash(b)\r\n\r\n#文本分析和词云制作\r\nstopwords = {}\r\nisCN = 1\r\n#在img的background_img中有三个已做好的jpg图像（作为背景）\r\nn = random.randint(1,3)\r\nbackground_img_path = r'img\/background_img\/'+str(n)+'.jpg'\r\ntext_path = 'text\/1.txt'\r\nfont_path = 'fonts\/YaHei.Consolas.1.11b.ttf'\r\nstopwords_path = 'stopwords.txt'\r\nimg_name1 = 'DefaultColor.png'\r\nimg_name2 = 'All_by_image.png'\r\n\r\n#可先自行添加相关词语\r\nmy_words_list = []\r\n\r\nback_img = imread(os.path.join(d,background_img_path))\r\n\r\n#词云属性\r\nwordcloud = WordCloud(\r\n    font_path=font_path,\r\n    background_color=\"white\",\r\n    max_words=300,\r\n    mask=back_img,\r\n    max_font_size=400,\r\n    random_state=42,\r\n    margin=4,\r\n    )\r\n\r\ndef add_word(list):\r\n    for item in list:\r\n        jieba.add_word(item)\r\n\r\nadd_word(my_words_list)\r\n\r\ntext = open(os.path.join(d,text_path),encoding='utf-8').read()\r\n\r\n#jieba分词与数据清洗\r\ndef jiebaClearText(text):\r\n    mywordlist = []\r\n    seg_list = jieba.cut(text, cut_all=False)\r\n    liststr = \"\/\".join(seg_list)\r\n    f_stop = open(stopwords_path)\r\n    try:\r\n        f_stop_text = f_stop.read()\r\n    finally:\r\n        f_stop.close()\r\n    f_stop_seg_list = f_stop_text.split('\\n')\r\n    for myword in liststr.split('\/'):\r\n        if not(myword.strip() in f_stop_seg_list) and len(myword.strip())>1:\r\n            mywordlist.append(myword)\r\n    return ' '.join(mywordlist)\r\n\r\nif isCN:\r\n    text = jiebaClearText(text)\r\n\r\nwordcloud.generate(text)\r\nimage_colors = ImageColorGenerator(back_img)\r\n#生成词云\r\nplt.imshow(wordcloud.recolor(color_func=image_colors))\r\nplt.axis(\"off\")\r\nplt.show()\r\nwordcloud.to_file(os.path.join(d,img_name2))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_58","text":"<filename>self_test\/scipy_test.py\n# -*- coding: utf-8 -*-\n\"\"\"\n演示stats模块的概率密度函数、直方图统计和累积分布函数。\n\"\"\"\nfrom scipy import stats\nimport numpy as np\nimport pylab as pl\n\nprint (stats.norm.stats())\nX = stats.norm(1.0, 2.0)\nprint (X.stats())\n\nx = X.rvs(size=10000)\nprint (np.mean(x), np.var(x))\n\nt = np.arange(-10, 10, 0.1)\n\npl.figure(figsize=(8, 3))\npl.subplot(121)\npl.plot(t, X.pdf(t))\np, t2 = np.histogram(x, bins=100, normed=True)\nt2 = (t2[:-1] + t2[1:])\/2\npl.plot(t2, p)\n\npl.subplot(122)\npl.plot(t, X.cdf(t))\npl.plot(t2, np.add.accumulate(p)*(t2[1]-t2[0]))\npl.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_59","text":"#!\/usr\/bin\/env python\n\nimport pandas as pd\nfrom sklearn.feature_selection import VarianceThreshold\nfrom scipy.stats import pearsonr\nimport matplotlib.pyplot as plt\n\ndef variance_demo():\n    data = pd.read_csv(\"f:\\\\git\\\\myGit\\\\Hadoop-Cluster-Easy\\\\AI001\\\\factor_returns.csv\")\n    print(data)\n\n    transfer = VarianceThreshold(threshold=1)\n    result = transfer.fit_transform(data.iloc[:,1:10])\n    print(\"删除低方差特征的结果:\\n\",result)\n    #print(\"形状:\\n\",transfer.)\n\n    print(\"形状:\\n\",result.shape)\n    return None\n\ndef pearsonr_demo():\n    data = pd.read_csv(\"f:\\\\git\\\\myGit\\\\Hadoop-Cluster-Easy\\\\AI001\\\\factor_returns.csv\")\n    factor = ['pe_ratio', 'pb_ratio', 'market_cap', 'return_on_asset_net_profit'\n    , 'du_return_on_equity', 'ev','earnings_per_share', 'revenue', 'total_expense']\n\n    for i in range(len(factor)):\n        for j in range(i,len(factor)-1):\n            print(\"指标%s与指标%s之间的相关性大小为%f\" % (factor[i],factor[j+1],pearsonr(data[factor[i]],data[factor[j+1]])[0]) )\n    \n    plt.figure(figsize=(20,8),dpi=100)\n    plt.scatter(data['revenue'],data['total_expense'])\n    plt.show()\n    \n    return None\n\n\n#variance_demo()\npearsonr_demo()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_60","text":"import csv\nimport torch\nimport logging\nimport imageio\nimport numpy as np\nimport functools\nfrom scipy.misc import imsave\nfrom tqdm import tqdm\nfrom pathlib import Path\n\nfrom src.runner.predictors.base_predictor import BasePredictor\nfrom src.utils import denormalize\n\n\nclass Dsb15VSRPredictor(BasePredictor):\n    \"\"\"The DSB15 predictor for the Video Super-Resolution.\n    Args:\n        saved_dir (str): The directory to save the predicted videos, images and metrics (default: None).\n        exported (bool): Whether to export the predicted video, images and metrics (default: False).\n    \"\"\"\n    def __init__(self, saved_dir=None, exported=False, **kwargs):\n        super().__init__(**kwargs)\n        if self.test_dataloader.batch_size != 1:\n            raise ValueError(f'The testing batch size should be 1. Got {self.test_dataloader.batch_size}.')\n\n        if exported:\n            self.saved_dir = Path(saved_dir)\n        self.exported = exported\n        self._denormalize = functools.partial(denormalize, dataset='dsb15')\n\n    def predict(self):\n        \"\"\"The testing process.\n        \"\"\"\n        self.net.eval()\n        trange = tqdm(self.test_dataloader,\n                      total=len(self.test_dataloader),\n                      desc='testing')\n\n        if self.exported:\n            videos_dir = self.saved_dir \/ 'videos'\n            imgs_dir = self.saved_dir \/ 'imgs'\n            csv_path = self.saved_dir \/ 'results.csv'\n\n            sr_imgs = []\n            tmp_sid = None\n            header = ['name'] + \\\n                     [metric_fn.__class__.__name__ for metric_fn in self.metric_fns] + \\\n                     [loss_fns.__class__.__name__ for loss_fns in self.loss_fns]\n            results = [header]\n\n        log = self._init_log()\n        count = 0\n        for batch in trange:\n            batch = self._allocate_data(batch)\n            inputs, targets, index = self._get_inputs_targets(batch)\n            T = len(inputs)\n            with torch.no_grad():\n                lr_path, hr_path = self.test_dataloader.dataset.data[index]\n                filename = lr_path.parts[-1].split('.')[0]\n                patient, _, sid = filename.split('_')\n                \n                outputs = self.net(inputs)\n                losses = self._compute_losses(outputs, targets)\n                loss = (losses.mean(dim=0) * self.loss_weights).sum()\n                metrics = self._compute_metrics(outputs, targets, patient)\n\n                if self.exported:\n                    filename = filename.replace('2d+1d', '2d').replace('sequence', 'slice')\n                    for t, _losses, _metrics in zip(range(T), losses, metrics):\n                        _losses = [loss.item() for loss in _losses]\n                        _metrics = [metric.item() for metric in _metrics]\n                        results.append([filename + f'_frame{t+1:0>2d}', *_metrics, *_losses])\n\n                    outputs = [self._denormalize(output) for output in outputs]\n                    sr_imgs = [output.squeeze().detach().cpu().numpy().astype(np.uint8)\n                               for output in outputs]\n\n                    # Save the video.\n                    output_dir = videos_dir \/ patient\n                    if not output_dir.is_dir():\n                        output_dir.mkdir(parents=True)\n                    self._dump_video(output_dir \/ f'{sid}.gif', sr_imgs)\n\n                    # Save the image.\n                    output_dir = imgs_dir \/ patient\n                    if not output_dir.is_dir():\n                        output_dir.mkdir(parents=True)\n                    for t, sr_img in enumerate(sr_imgs):\n                        img_name = sid.replace('sequence', 'slice') + f'_frame{t+1:0>2d}.png'\n                        imsave(output_dir \/ img_name, sr_img)\n\n            batch_size = self.test_dataloader.batch_size\n            self._update_log(log, batch_size, T, loss, losses, metrics)\n            count += batch_size * T\n            trange.set_postfix(**dict((key, f'{value \/ count: .3f}') for key, value in log.items()))\n\n        # Save the results.\n        if self.exported:\n            with open(csv_path, 'w', newline='') as csvfile:\n                writer = csv.writer(csvfile)\n                writer.writerows(results)\n\n        for key in log:\n            log[key] \/= count\n        logging.info(f'Test log: {log}.')\n\n    def _get_inputs_targets(self, batch):\n        \"\"\"Specify the data inputs and targets.\n        Args:\n            batch (dict): A batch of data.\n\n        Returns:\n            inputs (list of torch.Tensor): The data inputs.\n            targets (list of torch.Tensor): The data targets.\n            index (int): The index of the target path in the `dataloder.data`.\n        \"\"\"\n        return batch['lr_imgs'], batch['hr_imgs'], batch['index']\n\n    def _compute_losses(self, outputs, targets):\n        \"\"\"Compute the losses.\n        Args:\n            outputs (list of torch.Tensor): The model outputs.\n            targets (list of torch.Tensor): The data targets.\n\n        Returns:\n            losses (torch.Tensor): The computed losses.\n        \"\"\"\n        losses = []\n        for loss_fn in self.loss_fns:\n            losses.append(torch.stack([loss_fn(output, target) for output, target in zip(outputs, targets)]))\n        losses = torch.stack(losses, dim=1) # (T, #loss_fns)\n        return losses\n\n    def _compute_metrics(self, outputs, targets, name):\n        \"\"\"Compute the metrics.\n        Args:\n            outputs (list of torch.Tensor): The model outputs.\n            targets (list of torch.Tensor): The data targets.\n            name (str): The patient name.\n\n        Returns:\n            metrics (list of torch.Tensor): The computed metrics.\n        \"\"\"\n        outputs = list(map(self._denormalize, outputs))\n        targets = list(map(self._denormalize, targets))\n\n        metrics = []\n        for metric_fn in self.metric_fns:\n            if 'Cardiac' in metric_fn.__class__.__name__:\n                metrics.append(torch.stack([metric_fn(output, target, name) for output, target in zip(outputs, targets)]))\n            else:\n                metrics.append(torch.stack([metric_fn(output, target) for output, target in zip(outputs, targets)]))\n        metrics = torch.stack(metrics, dim=1) # (T, #metric_fns)\n        return metrics\n\n    def _update_log(self, log, batch_size, T, loss, losses, metrics):\n        \"\"\"Update the log.\n        Args:\n            log (dict): The log to be updated.\n            batch_size (int): The batch size.\n            T (int): The total number of the frames.\n            loss (torch.Tensor): The weighted sum of the computed losses.\n            losses (sequence of torch.Tensor): The computed losses.\n            metrics (sequence of torch.Tensor): The computed metrics.\n        \"\"\"\n        log['Loss'] += loss.item() * batch_size * T\n        for loss_fn, loss in zip(self.loss_fns, losses.mean(dim=0)):\n            log[loss_fn.__class__.__name__] += loss.item() * batch_size * T\n        for metric_fn, metric in zip(self.metric_fns, metrics.mean(dim=0)):\n            log[metric_fn.__class__.__name__] += metric.item() * batch_size * T\n\n    def _dump_video(self, path, imgs):\n        \"\"\"To dump the video by concatenate the images.\n        Args:\n            path (Path): The path to save the video.\n            imgs (list): The images to form the video.\n        \"\"\"\n        with imageio.get_writer(path) as writer:\n            for img in imgs:\n                writer.append_data(img)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_61","text":"<gh_stars>0\n#!\/usr\/bin\/env python\n\n\nfrom __future__ import print_function\nimport mdtraj as md\nimport numpy as np\nfrom scipy.spatial.distance import cdist, squareform\n\n\ndef pdb_to_nmr(resid):\n    '''\n    Convert from simulated PDB to NMR indexing.\n\n    The resulting index will match what is in `trajectory.pdb`. We use\n    the convention that a residue not present in the PDB file is `None`.\n\n    Restype\t\tNMR Index\t\tPDB Index\t\tNote\n    ALA         1               None            First protein residue\n    ASP         2               None\n    GLN         3               None\n    LEU         4               None\n    THR         5               1\n    ...\n    THR         146             142\n    ALA         147             None\n    LYS\t        148             None\n    CYS         149             None            Last protein residue\n\n    CA\n    CA\n    CA\n    CA\n\n    ALA         201             None            First peptide residue\n    ARG         202             147\n    ARG         203             148\n    ...\n    LEU         218             163\n    SER         219             164\n    SER         220             165             Last peptide residue\n    '''\n    resid = int(resid)\n    if resid >= 1 and resid <= 142:\n        return resid + 4\n    elif resid >= 147 and resid <= 165:\n        return resid + 55\n    else:\n        raise RuntimeError()\n\n\ntraj = md.load('trajectory.pdb')\n\nnitrogens = traj.topology.select('name N')\nspin_labels = traj.topology.select('name OND')\n\ndistances = np.zeros((len(nitrogens), len(spin_labels), traj.n_frames))\nfor i in range(traj.n_frames):\n    distances[:, :, i] = cdist(traj.xyz[i, nitrogens, :], traj.xyz[i, spin_labels, :])\n\n# do 1\/r^6 average\navg_distances = np.mean(distances**(-6.), axis=2)**(-1.0 \/ 6.0)\n\n\nwith open('average_distances.dat', 'w') as outfile:\n    for j, spin_atom_ind in enumerate(spin_labels):\n        for i, N_atom_ind in enumerate(nitrogens):\n            # +1 is to convert from zero-based indexing of mdtraj\n            # to 1-based index of PDB file\n            N_res = pdb_to_nmr(traj.topology.atom(N_atom_ind).residue.index + 1)\n            res_type = traj.topology.atom(N_atom_ind).residue.name\n            spin_res = pdb_to_nmr(traj.topology.atom(spin_atom_ind).residue.index + 1)\n\n            print('{}\\t{}\\t{}\\t{}'.format(spin_res, N_res, res_type,\n                                          avg_distances[i, j]), file=outfile)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_62","text":"from numpy.random import rand as d\nfrom scipy.signal import convolve2d as c\nimport matplotlib.pyplot as p\nfrom matplotlib.animation import FuncAnimation as F\nr=lambda:d(99,99);x,e=r(),r()-0.5;i=p.imshow(x,interpolation='bicubic')\ndef u(_):global x,e;e-=(e-r()+0.5)\/8;x=(c(x,[[0,1,0],[1,4,1],[0,1,0]],'same','wrap')+e)\/8;i.set_data(x);return i,\na=F(p.gcf(),u,interval=1,blit=True);p.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_63","text":"<gh_stars>0\nimport math\r\nimport os\r\nfrom distutils.dir_util import mkpath\r\nimport tensorlayer as tl\r\nimport matplotlib.pyplot as plt\r\nimport numpy as np\r\nfrom scipy.spatial.distance import cdist\r\nimport cv2\r\nimport tensorflow as tf\r\nimport _pickle as cPickle\r\nfrom pycocotools.coco import COCO, maskUtils\r\nfrom tensorlayer import logging\r\nfrom tensorlayer.files.utils import (del_file, folder_exists, maybe_download_and_extract)\r\n\r\nn_pos = 21\r\nhin = 320\r\nwin = 384\r\nhout = 40\r\nwout = 48\r\ndef get_pose_data_list(im_path, ann_path):\r\n    \"\"\"\r\n    train_im_path : image folder name\r\n    train_ann_path : coco json file name\r\n    \"\"\"\r\n    print(\"[x] Get pose data from {}\".format(im_path))\r\n    data = PoseInfo(im_path, ann_path, False)\r\n    imgs_file_list = data.get_image_list()\r\n    objs_info_list = data.get_joint_list()\r\n    mask_list = data.get_mask()\r\n    targets = list(zip(objs_info_list, mask_list))\r\n    if len(imgs_file_list) != len(objs_info_list):\r\n        raise Exception(\"number of images and annotations do not match\")\r\n    else:\r\n        print(\"{} has {} images\".format(im_path, len(imgs_file_list)))\r\n    return imgs_file_list, objs_info_list, mask_list, targets\r\ndef _data_aug_fn(image, ground_truth):\r\n    \"\"\"Data augmentation function.\"\"\"\r\n    ground_truth = cPickle.loads(ground_truth)\r\n    ground_truth = list(ground_truth)\r\n\r\n    annos = ground_truth[0]\r\n    mask = ground_truth[1]\r\n    h_mask, w_mask, _ = np.shape(image)\r\n    # mask\r\n    mask_miss = np.ones((h_mask, w_mask), dtype=np.uint8)\r\n\r\n    for seg in mask:\r\n        bin_mask = maskUtils.decode(seg)\r\n        bin_mask = np.logical_not(bin_mask)\r\n        mask_miss = np.bitwise_and(mask_miss, bin_mask)\r\n\r\n    ## image data augmentation\r\n    # # randomly resize height and width independently, scale is changed\r\n    # image, annos, mask_miss = tl.prepro.keypoint_random_resize(image, annos, mask_miss, zoom_range=(0.8, 1.2))# removed hao\r\n    # # random rotate\r\n    # image, annos, mask_miss = tl.prepro.keypoint_random_rotate(image, annos, mask_miss, rg=15.0)# removed hao\r\n    # # random left-right flipping\r\n    # image, annos, mask_miss = tl.prepro.keypoint_random_flip(image, annos, mask_miss, prob=0.5)# removed hao\r\n\r\n    M_rotate = tl.prepro.affine_rotation_matrix(angle=(-30, 30))  # original paper: -40~40\r\n    # M_flip = tl.prepro.affine_horizontal_flip_matrix(prob=0.5) # hao removed: bug, keypoints will have error\r\n    M_zoom = tl.prepro.affine_zoom_matrix(zoom_range=(0.5, 0.8))  # original paper: 0.5~1.1\r\n    # M_shear = tl.prepro.affine_shear_matrix(x_shear=(-0.1, 0.1), y_shear=(-0.1, 0.1))\r\n    M_combined = M_rotate.dot(M_zoom)\r\n    # M_combined = M_rotate.dot(M_flip).dot(M_zoom)#.dot(M_shear)\r\n    # M_combined = tl.prepro.affine_zoom_matrix(zoom_range=0.9) # for debug\r\n    h, w, _ = image.shape\r\n    transform_matrix = tl.prepro.transform_matrix_offset_center(M_combined, x=w, y=h)\r\n    image = tl.prepro.affine_transform_cv2(image, transform_matrix)\r\n    mask_miss = tl.prepro.affine_transform_cv2(mask_miss, transform_matrix, border_mode='replicate')\r\n    annos = tl.prepro.affine_transform_keypoints(annos, transform_matrix)\r\n\r\n    # random resize height and width together\r\n    # image, annos, mask_miss = tl.prepro.keypoint_random_resize_shortestedge(\r\n    #     image, annos, mask_miss, min_size=(hin, win), zoom_range=(0.95, 1.6)) # removed hao\r\n    # random crop\r\n    # image, annos, mask_miss = tl.prepro.keypoint_random_crop(image, annos, mask_miss, size=(hin, win))  # with padding # removed hao\r\n\r\n    image, annos, mask_miss = tl.prepro.keypoint_random_flip(image, annos, mask_miss, prob=0.5)\r\n    image, annos, mask_miss = tl.prepro.keypoint_resize_random_crop(image, annos, mask_miss, size=(hin, win))\r\n\r\n    height, width, _ = np.shape(image)\r\n    heatmap = get_heatmap(annos, height, width)\r\n    vectormap = get_vectormap(annos, height, width)\r\n    resultmap = np.concatenate((heatmap, vectormap), axis=2)\r\n    image = cv2.resize(image, (win,hin))\r\n    mask_miss = cv2.resize(mask_miss, (win,hin))\r\n    \r\n    image = np.array(image, dtype=np.float32)\r\n    img_mask = mask_miss.reshape(hin, win, 1)\r\n    image = image * np.repeat(img_mask, 3, 2)\r\n    \r\n    mask_miss = cv2.resize(mask_miss, (wout,hout))\r\n    resultmap = np.array(resultmap, dtype=np.float32)\r\n    mask_miss = np.array(mask_miss, dtype=np.float32)\r\n    return image, resultmap, mask_miss\r\n\r\n\r\ndef _map_fn(img_list, annos):\r\n    \"\"\"TF Dataset pipeline.\"\"\"\r\n    image = tf.read_file(img_list)\r\n    image = tf.image.decode_jpeg(image, channels=3)  # get RGB with 0~1\r\n    image = tf.image.convert_image_dtype(image, dtype=tf.float32)\r\n    # Affine transform and get paf maps\r\n    image, resultmap, mask = tf.py_func(_data_aug_fn, [image, annos], [tf.float32, tf.float32, tf.float32])\r\n\r\n    image = tf.reshape(image, [hin, win, 3])\r\n    resultmap = tf.reshape(resultmap, [hout, wout, n_pos * 3])\r\n    mask = tf.reshape(mask, [hout, wout, 1])\r\n\r\n    image = tf.image.random_brightness(image, max_delta=45.\/255.)   # 64.\/255. 32.\/255.)  caffe -30~50\r\n    image = tf.image.random_contrast(image, lower=0.5, upper=1.5)   # lower=0.2, upper=1.8)  caffe 0.3~1.5\r\n    # image = tf.image.random_saturation(image, lower=0.5, upper=1.5)\r\n    # image = tf.image.random_hue(image, max_delta=0.1)\r\n    image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0)\r\n\r\n    return image, resultmap, mask\r\ndef _mock_map_fn(img_list, annos):\r\n    \"\"\"TF Dataset pipeline.\"\"\"\r\n    image = tf.read_file(img_list)\r\n    image = tf.image.decode_jpeg(image, channels=3)  # get RGB with 0~1\r\n    \r\n    image = tf.image.convert_image_dtype(image, dtype=tf.float32)\r\n    image = tf.image.resize_images(image,(hin, win))\r\n    #image = np.ones((hin, win, 3), dtype=np.float32)\r\n    resultmap = np.ones((hout, wout, n_pos*3), dtype=np.float32)\r\n    mask = np.ones((hout, wout, 1), dtype=np.float32)\r\n\r\n    return image, resultmap, mask\r\n## read coco data\r\nclass CocoMeta:\r\n    \"\"\" Be used in PoseInfo. \"\"\"\r\n    limb = list(\r\n        zip(        \r\n        [2, 9,  10, 2,  12, 13, 2, 3, 4, 3,  2, 6, 7, 6,  2, 1,  1,  15, 16, 11,14],\r\n        [9, 10, 11, 12, 13, 14, 3, 4, 5, 17, 6, 7, 8, 18, 1, 15, 16, 17, 18, 20,19]))\r\n\r\n    def __init__(self, idx, img_url, img_meta, annotations, masks):\r\n        self.idx = idx\r\n        self.img_url = img_url\r\n        self.img = None\r\n        self.height = int(img_meta['height'])\r\n        self.width = int(img_meta['width'])\r\n        self.masks = masks\r\n        joint_list = []\r\n\r\n        for anno in annotations:\r\n            if anno.get('num_keypoints', 0) == 0:\r\n                continue\r\n\r\n            kp = np.array(anno['keypoints'])\r\n            xs = kp[0::3]\r\n            ys = kp[1::3]\r\n            vs = kp[2::3]\r\n            # if joint is marked\r\n            joint_list.append([(x, y) if v >= 1 else (-1000, -1000) for x, y, v in zip(xs, ys, vs)])\r\n\r\n        self.joint_list = []\r\n        # 对原 COCO 数据集的转换 其中第二位之所以不一样是为了计算 Neck 等于左右 shoulder 的中点\r\n        transform = list(\r\n            zip([1, 6, 7, 9, 11, 6, 8, 10, 13, 15, 17, 12, 14, 16, 3, 2, 5, 4,18,19],\r\n                [1, 7, 7, 9, 11, 6, 8, 10, 13, 15, 17, 12, 14, 16, 3, 2, 5, 4,18,19]))\r\n        for prev_joint in joint_list:\r\n            new_joint = []\r\n            for idx1, idx2 in transform:\r\n                j1 = prev_joint[idx1 - 1]\r\n                j2 = prev_joint[idx2 - 1]\r\n\r\n                if j1[0] <= 0 or j1[1] <= 0 or j2[0] <= 0 or j2[1] <= 0:\r\n                    new_joint.append((-1000, -1000))\r\n                else:\r\n                    new_joint.append(((j1[0] + j2[0]) \/ 2, (j1[1] + j2[1]) \/ 2))\r\n\r\n            # for background\r\n            new_joint.append((-1000, -1000))\r\n            if len(new_joint) != n_pos:\r\n                print('The Length of joints list should be 0 or 19 but actually:', len(new_joint))\r\n            self.joint_list.append(new_joint)\r\n\r\n\r\nclass PoseInfo:\r\n    \"\"\" Use COCO for pose estimation, returns images with people only. \"\"\"\r\n\r\n    def __init__(self, image_base_dir, anno_path, with_mask):\r\n        self.metas = []\r\n        # self.data_dir = data_dir\r\n        # self.data_type = data_type\r\n        self.image_base_dir = image_base_dir\r\n        self.anno_path = anno_path\r\n        self.with_mask = with_mask\r\n        self.coco = COCO(self.anno_path)\r\n        self.get_image_annos()\r\n        self.image_list = os.listdir(self.image_base_dir)\r\n\r\n    @staticmethod\r\n    def get_keypoints(annos_info):\r\n        annolist = []\r\n        for anno in annos_info:\r\n            adjust_anno = {'keypoints': anno['keypoints'], 'num_keypoints': anno['num_keypoints']}\r\n            annolist.append(adjust_anno)\r\n        return annolist\r\n\r\n    def get_image_annos(self):\r\n        \"\"\"Read JSON file, and get and check the image list.\r\n        Skip missing images.\r\n        \"\"\"\r\n        images_ids = self.coco.getImgIds()\r\n        len_imgs = len(images_ids)\r\n        for idx in range(len_imgs):\r\n\r\n            images_info = self.coco.loadImgs(images_ids[idx])\r\n            image_path = os.path.join(self.image_base_dir, images_info[0]['file_name'])\r\n            # filter that some images might not in the list\r\n            if not os.path.exists(image_path):\r\n                print(\"[skip] json annotation found, but cannot found image: {}\".format(image_path))\r\n                continue\r\n\r\n            annos_ids = self.coco.getAnnIds(imgIds=images_ids[idx])\r\n            annos_info = self.coco.loadAnns(annos_ids)\r\n            keypoints = self.get_keypoints(annos_info)\r\n\r\n            #############################################################################\r\n            anns = annos_info\r\n            prev_center = []\r\n            masks = []\r\n\r\n            # sort from the biggest person to the smallest one\r\n            if self.with_mask:\r\n                persons_ids = np.argsort([-a['area'] for a in anns], kind='mergesort')\r\n\r\n                for p_id in list(persons_ids):\r\n                    person_meta = anns[p_id]\r\n\r\n                    if person_meta[\"iscrowd\"]:\r\n                        masks.append(self.coco.annToRLE(person_meta))\r\n                        continue\r\n\r\n                    # skip this person if parts number is too low or if\r\n                    # segmentation area is too small\r\n                    if person_meta[\"num_keypoints\"] < 5 or person_meta[\"area\"] < 32 * 32:\r\n                        masks.append(self.coco.annToRLE(person_meta))\r\n                        continue\r\n\r\n                    person_center = [\r\n                        person_meta[\"bbox\"][0] + person_meta[\"bbox\"][2] \/ 2,\r\n                        person_meta[\"bbox\"][1] + person_meta[\"bbox\"][3] \/ 2\r\n                    ]\r\n\r\n                    # skip this person if the distance to existing person is too small\r\n                    too_close = False\r\n                    for pc in prev_center:\r\n                        a = np.expand_dims(pc[:2], axis=0)\r\n                        b = np.expand_dims(person_center, axis=0)\r\n                        dist = cdist(a, b)[0]\r\n                        if dist < pc[2] * 0.3:\r\n                            too_close = True\r\n                            break\r\n\r\n                    if too_close:\r\n                        # add mask of this person. we don't want to show the network\r\n                        # unlabeled people\r\n                        masks.append(self.coco.annToRLE(person_meta))\r\n                        continue\r\n\r\n            ############################################################################\r\n            total_keypoints = sum([ann.get('num_keypoints', 0) for ann in annos_info])\r\n            if total_keypoints > 0:\r\n                meta = CocoMeta(images_ids[idx], image_path, images_info[0], keypoints, masks)\r\n                self.metas.append(meta)\r\n\r\n        print(\"Overall get {} valid pose images from {} and {}\".format(\r\n            len(self.metas), self.image_base_dir, self.anno_path))\r\n\r\n    def load_images(self):\r\n        pass\r\n\r\n    def get_image_list(self):\r\n        img_list = []\r\n        for meta in self.metas:\r\n            img_list.append(meta.img_url)\r\n        return img_list\r\n\r\n    def get_joint_list(self):\r\n        joint_list = []\r\n        for meta in self.metas:\r\n            joint_list.append(meta.joint_list)\r\n        return joint_list\r\n\r\n    def get_mask(self):\r\n        mask_list = []\r\n        for meta in self.metas:\r\n            mask_list.append(meta.masks)\r\n        return mask_list\r\n\r\n\r\ndef get_heatmap(annos, height, width):\r\n    \"\"\"\r\n    Parameters\r\n    -----------\r\n    Returns\r\n    --------\r\n    \"\"\"\r\n\r\n    # 19 for coco, 15 for MPII\r\n    num_joints = n_pos\r\n\r\n    # the heatmap for every joints takes the maximum over all people\r\n    joints_heatmap = np.zeros((num_joints, height, width), dtype=np.float32)\r\n\r\n    # among all people\r\n    for joint in annos:\r\n        # generate heatmap for every keypoints\r\n        # loop through all people and keep the maximum\r\n\r\n        for i, points in enumerate(joint):\r\n            if points[0] < 0 or points[1] < 0:\r\n                continue\r\n            joints_heatmap = put_heatmap(joints_heatmap, i, points, 8.0)\r\n\r\n    # 0: joint index, 1:y, 2:x\r\n    joints_heatmap = joints_heatmap.transpose((1, 2, 0))\r\n\r\n    # background\r\n    joints_heatmap[:, :, -1] = np.clip(1 - np.amax(joints_heatmap, axis=2), 0.0, 1.0)\r\n\r\n    mapholder = []\r\n    for i in range(0, num_joints):\r\n        a = cv2.resize(np.array(joints_heatmap[:, :, i]), (wout,hout))\r\n        mapholder.append(a)\r\n    mapholder = np.array(mapholder)\r\n    joints_heatmap = mapholder.transpose(1, 2, 0)\r\n\r\n    return joints_heatmap.astype(np.float16)\r\n\r\n\r\ndef put_heatmap(heatmap, plane_idx, center, sigma):\r\n    \"\"\"\r\n    Parameters\r\n    -----------\r\n    Returns\r\n    --------\r\n    \"\"\"\r\n    center_x, center_y = center\r\n    _, height, width = heatmap.shape[:3]\r\n\r\n    th = 4.6052\r\n    delta = math.sqrt(th * 2)\r\n\r\n    x0 = int(max(0, center_x - delta * sigma + 0.5))\r\n    y0 = int(max(0, center_y - delta * sigma + 0.5))\r\n\r\n    x1 = int(min(width - 1, center_x + delta * sigma + 0.5))\r\n    y1 = int(min(height - 1, center_y + delta * sigma + 0.5))\r\n\r\n    exp_factor = 1 \/ 2.0 \/ sigma \/ sigma\r\n\r\n    ## fast - vectorize\r\n    arr_heatmap = heatmap[plane_idx, y0:y1 + 1, x0:x1 + 1]\r\n    y_vec = (np.arange(y0, y1 + 1) - center_y)**2  # y1 included\r\n    x_vec = (np.arange(x0, x1 + 1) - center_x)**2\r\n    xv, yv = np.meshgrid(x_vec, y_vec)\r\n    arr_sum = exp_factor * (xv + yv)\r\n    arr_exp = np.exp(-arr_sum)\r\n    arr_exp[arr_sum > th] = 0\r\n    heatmap[plane_idx, y0:y1 + 1, x0:x1 + 1] = np.maximum(arr_heatmap, arr_exp)\r\n    return heatmap\r\n\r\n\r\ndef get_vectormap(annos, height, width):\r\n    \"\"\"\r\n    Parameters\r\n    -----------\r\n    Returns\r\n    --------\r\n    \"\"\"\r\n    num_joints = n_pos\r\n\r\n    limb = list(zip(\r\n        [2, 9,  10, 2,  12, 13, 2, 3, 4, 3,  2, 6, 7, 6,  2, 1,  1,  15, 16, 11,14],\r\n        [9, 10, 11, 12, 13, 14, 3, 4, 5, 17, 6, 7, 8, 18, 1, 15, 16, 17, 18, 20,19]\r\n    ))\r\n\r\n    vectormap = np.zeros((num_joints * 2, height, width), dtype=np.float32)\r\n    counter = np.zeros((num_joints, height, width), dtype=np.int16)\r\n\r\n    for joint in annos:\r\n        if len(joint) != n_pos:\r\n            print('THE LENGTH IS NOT 19 ERROR:', len(joint))\r\n            limb = list(zip(\r\n            [2, 9,  10, 2,  12, 13, 2, 3, 4, 3,  2, 6, 7, 6,  2, 1,  1,  15, 16],\r\n            [9, 10, 11, 12, 13, 14, 3, 4, 5, 17, 6, 7, 8, 18, 1, 15, 16, 17, 18]\r\n            ))\r\n        for i, (a, b) in enumerate(limb):\r\n            a -= 1\r\n            b -= 1\r\n\r\n            v_start = joint[a]\r\n            v_end = joint[b]\r\n            # exclude invisible or unmarked point\r\n            if v_start[0] < -100 or v_start[1] < -100 or v_end[0] < -100 or v_end[1] < -100:\r\n                continue\r\n            vectormap = cal_vectormap(vectormap, counter, i, v_start, v_end)\r\n\r\n    vectormap = vectormap.transpose((1, 2, 0))\r\n    # normalize the PAF (otherwise longer limb gives stronger absolute strength)\r\n    nonzero_vector = np.nonzero(counter)\r\n\r\n    for i, y, x in zip(nonzero_vector[0], nonzero_vector[1], nonzero_vector[2]):\r\n\r\n        if counter[i][y][x] <= 0:\r\n            continue\r\n        vectormap[y][x][i * 2 + 0] \/= counter[i][y][x]\r\n        vectormap[y][x][i * 2 + 1] \/= counter[i][y][x]\r\n\r\n    mapholder = []\r\n    for i in range(0, n_pos * 2):\r\n        a = cv2.resize(np.array(vectormap[:, :, i]), (wout,hout))\r\n        mapholder.append(a)\r\n    mapholder = np.array(mapholder)\r\n    vectormap = mapholder.transpose(1, 2, 0)\r\n\r\n    return vectormap.astype(np.float16)\r\n\r\n\r\ndef cal_vectormap(vectormap, countmap, i, v_start, v_end):\r\n    \"\"\"\r\n    Parameters\r\n    -----------\r\n    Returns\r\n    --------\r\n    \"\"\"\r\n    _, height, width = vectormap.shape[:3]\r\n\r\n    threshold = 8\r\n    vector_x = v_end[0] - v_start[0]\r\n    vector_y = v_end[1] - v_start[1]\r\n    length = math.sqrt(vector_x**2 + vector_y**2)\r\n    if length == 0:\r\n        return vectormap\r\n\r\n    min_x = max(0, int(min(v_start[0], v_end[0]) - threshold))\r\n    min_y = max(0, int(min(v_start[1], v_end[1]) - threshold))\r\n\r\n    max_x = min(width, int(max(v_start[0], v_end[0]) + threshold))\r\n    max_y = min(height, int(max(v_start[1], v_end[1]) + threshold))\r\n\r\n    norm_x = vector_x \/ length\r\n    norm_y = vector_y \/ length\r\n\r\n    for y in range(min_y, max_y):\r\n        for x in range(min_x, max_x):\r\n            bec_x = x - v_start[0]\r\n            bec_y = y - v_start[1]\r\n            dist = abs(bec_x * norm_y - bec_y * norm_x)\r\n\r\n            # orthogonal distance is < then threshold\r\n            if dist > threshold:\r\n                continue\r\n            countmap[i][y][x] += 1\r\n            vectormap[i * 2 + 0][y][x] = norm_x\r\n            vectormap[i * 2 + 1][y][x] = norm_y\r\n\r\n    return vectormap\r\n\r\n\r\ndef fast_vectormap(vectormap, countmap, i, v_start, v_end):\r\n    \"\"\"\r\n    Parameters\r\n    -----------\r\n    Returns\r\n    --------\r\n    \"\"\"\r\n    _, height, width = vectormap.shape[:3]\r\n    _, height, width = vectormap.shape[:3]\r\n\r\n    threshold = 8\r\n    vector_x = v_end[0] - v_start[0]\r\n    vector_y = v_end[1] - v_start[1]\r\n\r\n    length = math.sqrt(vector_x**2 + vector_y**2)\r\n    if length == 0:\r\n        return vectormap\r\n\r\n    min_x = max(0, int(min(v_start[0], v_end[0]) - threshold))\r\n    min_y = max(0, int(min(v_start[1], v_end[1]) - threshold))\r\n\r\n    max_x = min(width, int(max(v_start[0], v_end[0]) + threshold))\r\n    max_y = min(height, int(max(v_start[1], v_end[1]) + threshold))\r\n\r\n    norm_x = vector_x \/ length\r\n    norm_y = vector_y \/ length\r\n\r\n    x_vec = (np.arange(min_x, max_x) - v_start[0]) * norm_y\r\n    y_vec = (np.arange(min_y, max_y) - v_start[1]) * norm_x\r\n\r\n    xv, yv = np.meshgrid(x_vec, y_vec)\r\n\r\n    dist_matrix = abs(xv - yv)\r\n    filter_matrix = np.where(dist_matrix > threshold, 0, 1)\r\n    countmap[i, min_y:max_y, min_x:max_x] += filter_matrix\r\n    for y in range(max_y - min_y):\r\n        for x in range(max_x - min_x):\r\n            if filter_matrix[y, x] != 0:\r\n                vectormap[i * 2 + 0, min_y + y, min_x + x] = norm_x\r\n                vectormap[i * 2 + 1, min_y + y, min_x + x] = norm_y\r\n    return vectormap\r\n\r\n\r\ndef draw_results(images, heats_ground, heats_result, pafs_ground, pafs_result, masks, name=''):\r\n    \"\"\"Save results for debugging.\r\n    Parameters\r\n    -----------\r\n    images : a list of RGB images\r\n    heats_ground : a list of keypoint heat maps or None\r\n    heats_result : a list of keypoint heat maps or None\r\n    pafs_ground : a list of paf vector maps or None\r\n    pafs_result : a list of paf vector maps or None\r\n    masks : a list of mask for people\r\n    \"\"\"\r\n    # interval = len(images)\r\n    for i in range(len(images)):\r\n        if heats_ground is not None:\r\n            heat_ground = heats_ground[i]\r\n        if heats_result is not None:\r\n            heat_result = heats_result[i]\r\n        if pafs_ground is not None:\r\n            paf_ground = pafs_ground[i]\r\n        if pafs_result is not None:\r\n            paf_result = pafs_result[i]\r\n        if masks is not None:\r\n            # print(masks.shape)\r\n            mask = masks[i, :, :, 0]\r\n            # print(mask.shape)\r\n            mask = mask[:, :, np.newaxis]\r\n            # mask = masks[:,:,:,0]\r\n            # mask = mask.reshape(hout, wout, 1)\r\n            mask1 = np.repeat(mask, n_pos, 2)\r\n            mask2 = np.repeat(mask, n_pos * 2, 2)\r\n            # print(mask1.shape, mask2.shape)\r\n        image = images[i]\r\n\r\n        fig = plt.figure(figsize=(8, 8))\r\n        a = fig.add_subplot(2, 3, 1)\r\n        plt.imshow(image)\r\n\r\n        if pafs_ground is not None:\r\n            a = fig.add_subplot(2, 3, 2)\r\n            a.set_title('Vectormap_ground')\r\n            vectormap = paf_ground * mask2\r\n            tmp2 = vectormap.transpose((2, 0, 1))\r\n            tmp2_odd = np.amax(np.absolute(tmp2[::2, :, :]), axis=0)\r\n            tmp2_even = np.amax(np.absolute(tmp2[1::2, :, :]), axis=0)\r\n\r\n            # tmp2_odd = tmp2_odd * 255\r\n            # tmp2_odd = tmp2_odd.astype(np.int)\r\n            plt.imshow(tmp2_odd, alpha=0.3)\r\n\r\n            # tmp2_even = tmp2_even * 255\r\n            # tmp2_even = tmp2_even.astype(np.int)\r\n            plt.colorbar()\r\n            plt.imshow(tmp2_even, alpha=0.3)\r\n\r\n        if pafs_result is not None:\r\n            a = fig.add_subplot(2, 3, 3)\r\n            a.set_title('Vectormap result')\r\n            if masks is not None:\r\n                vectormap = paf_result * mask2\r\n            else:\r\n                vectormap = paf_result\r\n            tmp2 = vectormap.transpose((2, 0, 1))\r\n            tmp2_odd = np.amax(np.absolute(tmp2[::2, :, :]), axis=0)\r\n            tmp2_even = np.amax(np.absolute(tmp2[1::2, :, :]), axis=0)\r\n            plt.imshow(tmp2_odd, alpha=0.3)\r\n\r\n            plt.colorbar()\r\n            plt.imshow(tmp2_even, alpha=0.3)\r\n\r\n        if heats_result is not None:\r\n            a = fig.add_subplot(2, 3, 4)\r\n            a.set_title('Heatmap result')\r\n            if masks is not None:\r\n                heatmap = heat_result * mask1\r\n            else:\r\n                heatmap = heat_result\r\n            tmp = heatmap\r\n            tmp = np.amax(heatmap[:, :, :-1], axis=2)\r\n\r\n            plt.colorbar()\r\n            plt.imshow(tmp, alpha=0.3)\r\n\r\n        if heats_ground is not None:\r\n            a = fig.add_subplot(2, 3, 5)\r\n            a.set_title('Heatmap ground truth')\r\n            if masks is not None:\r\n                heatmap = heat_ground * mask1\r\n            else:\r\n                heatmap = heat_ground\r\n            tmp = heatmap\r\n            tmp = np.amax(heatmap[:, :, :-1], axis=2)\r\n\r\n            plt.colorbar()\r\n            plt.imshow(tmp, alpha=0.3)\r\n\r\n        if masks is not None:\r\n            a = fig.add_subplot(2, 3, 6)\r\n            a.set_title('Mask')\r\n            # print(mask.shape, tmp.shape)\r\n            plt.colorbar()\r\n            plt.imshow(mask[:, :, 0], alpha=0.3)\r\n        # plt.savefig(str(i)+'.png',dpi=300)\r\n        # plt.show()\r\n\r\n        mkpath(config.LOG.vis_path)\r\n        plt.savefig(os.path.join(config.LOG.vis_path, '%s%d.png' % (name, i)), dpi=300)\r\n\r\n\r\ndef vis_annos(image, annos, name=''):\r\n    \"\"\"Save results for debugging.\r\n    Parameters\r\n    -----------\r\n    images : single RGB image\r\n    annos  : annotation, list of lists\r\n    \"\"\"\r\n\r\n    fig = plt.figure(figsize=(8, 8))\r\n    a = fig.add_subplot(1, 1, 1)\r\n\r\n    plt.imshow(image)\r\n    for people in annos:\r\n        for idx, jo in enumerate(people):\r\n            if jo[0] > 0 and jo[1] > 0:\r\n                plt.plot(jo[0], jo[1], '*')\r\n\r\n    mkpath(config.LOG.vis_path)\r\n    plt.savefig(os.path.join(config.LOG.vis_path, 'keypoints%s%d.png' % (name, i)), dpi=300)\r\n\r\n\r\ndef tf_repeat(tensor, repeats):\r\n    \"\"\"\r\n    Args:\r\n    input: A Tensor. 1-D or higher.\r\n    repeats: A list. Number of repeat for each dimension, length must be the same as the number of dimensions in input\r\n    Returns:\r\n    A Tensor. Has the same type as input. Has the shape of tensor.shape * repeats\r\n    \"\"\"\r\n\r\n    expanded_tensor = tf.expand_dims(tensor, -1)\r\n    multiples = [1] + repeats\r\n    tiled_tensor = tf.tile(expanded_tensor, multiples=multiples)\r\n    repeated_tesnor = tf.reshape(tiled_tensor, tf.shape(tensor) * repeats)\r\n\r\n    return repeated_tesnor"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_49","text":"from qiskit import QuantumCircuit, Aer, execute\nfrom utils.helper_funcs import *\nfrom utils.graph_funcs import *\nimport scipy\nimport numpy as np\n\n\ndef construct_qaoa_plus(P, G, params, barriers=False, measure=False):\n    assert (len(params) == 2*P), \"Number of parameters should be 2P\"\n\n    nq = len(G.nodes())\n    circ = QuantumCircuit(nq, name='q')\n\n    # Initial state\n    circ.h(range(nq))\n\n    gammas = [param for i, param in enumerate(params) if i % 2 == 0]\n    betas  = [param for i, param in enumerate(params) if i % 2 == 1]\n    for i in range(P):\n        # Phase Separator Unitary\n        for edge in G.edges():\n            q_i, q_j = edge\n            circ.rz(gammas[i] \/ 2, [q_i, q_j])\n            circ.cx(q_i, q_j)\n            circ.rz(-1 * gammas[i] \/ 2, q_j)\n            circ.cx(q_i, q_j)\n            if barriers:\n                circ.barrier()\n\n        # Mixing Unitary\n        for q_i in range(nq):\n            circ.rx(-2 * betas[i], q_i)\n\n    if measure:\n        circ.measure_all()\n\n    return circ\n\n\ndef expectation_value(counts, G, Lambda):\n    total_shots = sum(counts.values())\n    energy = 0\n    for bitstr, count in counts.items():\n        temp_energy = hamming_weight(bitstr)\n        for edge in G.edges():\n            q_i, q_j = edge\n            rev_bitstr = list(reversed(bitstr))\n            if rev_bitstr[q_i] == '1' and rev_bitstr[q_j] == '1':\n                temp_energy += -1 * Lambda\n\n        energy += count * temp_energy \/ total_shots\n\n    return energy\n\n\ndef solve_mis(P, G, Lambda):\n\n    backend = Aer.get_backend('qasm_simulator')\n\n    def f(params):\n        circ = construct_qaoa_plus(P, G, params, measure=True)\n\n        result = execute(circ, backend=backend, shots=8192).result()\n        counts = result.get_counts(circ)\n\n        return -1 * expectation_value(counts, G, Lambda)\n\n    init_params = np.random.uniform(low=0.0, high=2*np.pi, size=2*P)\n    out = scipy.optimize.minimize(f, x0=init_params, method='COBYLA')\n\n    return out\n\n\ndef get_ranked_probs(P, G, params, shots=8192):\n    circ = construct_qaoa_plus(P, G, params=params, measure=True)\n    result = execute(circ, backend=Aer.get_backend('qasm_simulator'), shots=shots).result()\n    counts = result.get_counts(circ)\n\n    probs = [(bitstr, counts[bitstr] \/ shots, is_indset(bitstr, G)) for bitstr in counts.keys()]\n    probs = sorted(probs, key=lambda p: p[1], reverse=True)\n\n    return probs\n\n\ndef get_approximation_ratio(out, P, G, shots=8192):\n    opt_mis = brute_force_search(G)[1]\n\n    circ = construct_qaoa_plus(P, G, params=out['x'], measure=True)\n    result = execute(circ, backend=Aer.get_backend('qasm_simulator'), shots=shots).result()\n    counts = result.get_counts(circ)\n\n    # Approximation ratio is computed using ONLY valid independent sets\n    # E(gamma, beta) = SUM_bitstrs { (bitstr_counts \/ total_shots) * hamming_weight(bitstr) } \/ opt_mis\n    numerator = 0\n    for bitstr, count in counts.items():\n        if is_indset(bitstr, G):\n            numerator += count * hamming_weight(bitstr) \/ shots\n    ratio = numerator \/ opt_mis\n\n    #ratio = sum([count * hamming_weight(bitstr) \/ shots for bitstr, count in counts.items() \\\n    #             if is_indset(bitstr, G)]) \/ opt_mis\n\n    return ratio\n\n\ndef top_strs(counts, G, top=5):\n    total_shots = sum(counts.values())\n    probs = [(bitstr, counts[bitstr] \/ total_shots) for bitstr in counts.keys()]\n    probs = sorted(probs, key=lambda p: p[1], reverse=True)\n    opt_mis = brute_force_search(G)[1]\n\n    for i in range(top):\n        ratio = hamming_weight(probs[i][0]) * probs[i][1] \/ opt_mis\n        print('{} ({}) -> {:.4f}%, Ratio = {:.4f}, Is MIS? {}'.format(probs[i][0], hamming_weight(probs[i][0]),\n                                                 probs[i][1] * 100, ratio, is_indset(probs[i][0], G)))\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_50","text":"\"\"\"Main module.\"\"\"\n\nimport numpy as np\nimport logging\n\nfrom scipy.signal import correlate as cor\nfrom scipy.interpolate import interp1d, CubicSpline\n\n__all__ = [\"TimeSync2_1\", \"TimeSyncException\"]\n\n\nclass TimeSyncException(Exception):\n    \"\"\"\n    Base exception for TimeSync class\n    \"\"\"\n\n    def __init__(self, msg):\n        self.msg = msg\n\n\nclass TimeSync:\n    \"\"\"\n    A class used to get time delay between two clocks by gyroscope measurements\n    ...\n    Attributes\n    ----------\n    xx1 : numpy array of shape (N,3)\n        3D angular velocities of the first gyro. for N timestamps\n    xx2 : numpy array of shape (M,3)\n        3D angular velocities of the second gyro. for M timestamps\n    t1 : numpy array of shape (N,)\n        timestamps of the first gyro. measurements\n    t2 : numpy array of shape (N,)\n        timestamps of the second gyro. measurements\n    do_resample : bool\n        flag to do resampling of angular velocities to equal and constant time grids\n        If False then timestamps are used only for estimation of sampling period\n    Methods\n    -------\n    #TOBEDONE\n    \"\"\"\n\n    def __init__(\n        self,\n        xx1,\n        xx2,\n        t1,\n        t2,\n        do_resample=True,\n    ):\n        self.xx1 = xx1\n        self.xx2 = xx2\n        self.t1 = t1\n        self.t2 = t2\n        self.do_resample = do_resample\n        self.M = None\n\n        self._dt = None\n        self._t1_new = None\n        self._t2_new = None\n        self._xx1_new = None\n        self._xx2_new = None\n\n        self._cor = None\n        self._time_delay = None\n\n        self._resample_complete = False\n        self._calibration_is_succeeded = False\n\n    @staticmethod\n    def __interp(t_old, f_old, t_new, kind=\"cubic\"):\n        interp_func = interp1d(\n            t_old, f_old, kind=kind, axis=0, bounds_error=False, fill_value=(0, 0)\n        )\n        return interp_func(t_new)\n\n    @property\n    def cor(self):\n        return self._cor\n\n    @property\n    def time_delay(self):\n        return self._time_delay\n\n    @property\n    def resample_complete(self):\n        return self._resample_complete\n\n    @property\n    def calibration_is_succeeded(self):\n        return self._calibration_is_succeeded\n\n    def _get_initial_index(self):\n        x1_temp = np.linalg.norm(self._xx1_new, axis=1)\n        x2_temp = np.linalg.norm(self._xx2_new, axis=1)\n        cross_cor = cor(x2_temp, x1_temp)\n        index_init = np.argmax(cross_cor)\n        return cross_cor, index_init\n\n    def _rearrange_data(self, index_init):\n        xx1_temp = self._xx1_new\n        xx2_temp = self._xx2_new\n\n        if index_init > 0:\n            xx1_temp = self._xx1_new[:-index_init]\n            xx2_temp = self._xx2_new[index_init:]\n        elif index_init < 0:\n            xx1_temp = self._xx1_new[-index_init:]\n            xx2_temp = self._xx2_new[:index_init]\n\n        size = min(xx1_temp.shape[0], xx2_temp.shape[0])\n\n        return xx1_temp[:size], xx2_temp[:size]\n\n    def __make_calibration(self, xx1_temp, xx2_temp):\n        try:\n            pseudoinverse = np.linalg.inv(np.matmul(xx1_temp.T, xx1_temp))\n        except np.linalg.LinAlgError:\n            logging.error(\n                \"Can't calibrate. Pseudoinverse is not defined. Keeping data the same\"\n            )\n            self._calibration_is_succeeded = False\n            return self._calibration_is_succeeded\n\n        self.M = np.matmul(np.matmul(xx2_temp.T, xx1_temp), pseudoinverse)\n        self.xx1_new = np.matmul(self.M, self._xx1_new.T).T\n        self._calibration_is_succeeded = True\n\n        return self._calibration_is_succeeded\n\n    @staticmethod\n    def __get_equation(cross_cor, index_init):\n        cubic_spline = CubicSpline(\n            np.arange(cross_cor.shape[0]), cross_cor, bc_type=\"natural\"\n        )\n        coefs = cubic_spline.c[:, index_init]\n        order = coefs.shape[0] - 1\n        derivative = coefs[-2]\n\n        if derivative < 0:\n            index_init -= 1\n            coefs = cubic_spline.c[:, index_init]\n\n        return order, coefs\n\n    @staticmethod\n    def __calculate_result(order, coefs):\n        # Solve qudratic equation to obtain roots\n        res = np.roots([(order - i) * coefs[i] for i in range(order)])\n        # Choose solution from roots.\n        if (\n            sum(\n                (order - i) * coefs[i] * ((res[0] + res[1]) \/ 2) ** (order - i - 1)\n                for i in range(order)\n            )\n            < 0\n        ):\n            res = np.min(res)\n        else:\n            res = np.max(res)\n\n        return res\n\n    def resample(self, step=None):\n        self._dt = step or np.min(\n            [np.mean(np.diff(self.t1)), np.mean(np.diff(self.t2))]\n        )\n\n        if self.do_resample:\n            self._t1_new = np.arange(self.t1[0], self.t1[-1] + self._dt, self._dt)\n            self._t2_new = np.arange(self.t2[0], self.t2[-1] + self._dt, self._dt)\n\n            self._xx1_new = self.__interp(self.t1, self.xx1, self._t1_new)\n            self._xx2_new = self.__interp(self.t2, self.xx2, self._t2_new)\n        else:\n            self._t1_new = self.t1\n            self._t2_new = self.t2\n            self._xx1_new = self.xx1\n            self._xx2_new = self.xx2\n\n        self._resample_complete = True\n\n    def obtain_delay(self):\n        if not self._resample_complete:\n            raise TimeSyncException(\"resample() has not called yet\")\n\n        shift = -self._xx1_new.shape[0] + 1\n        cross_cor, index_init = self._get_initial_index()\n        index_init += shift\n\n        xx1_temp, xx2_temp = self._rearrange_data(index_init)\n\n        self.__make_calibration(xx1_temp=xx1_temp, xx2_temp=xx2_temp)\n        cross_cor, index_init = self._get_initial_index()\n\n        order, coefs = self.__get_equation(cross_cor, index_init)\n        result = self.__calculate_result(order, coefs)\n\n        self._cor = cross_cor\n        self._time_delay = (index_init + shift + result) * self._dt\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_51","text":"# -*- coding: utf-8 -*-\n\"\"\"\nPlot results from compass-gait biped simulations.\n\"\"\"\n\nimport numpy as np\nimport scipy.io as io\n\nimport matplotlib.pyplot as plt\nfrom matplotlib import rcParams\nrcParams.update({'font.size': 24})\n\nfig_num = 0\n\nplt.close('all')\n\n#%% Plot the objective function.\n\n# Domain to use for plotting (also the domain used for learning):\nnum_pts_sample = 24\nx = np.linspace(0.08, 0.18, num_pts_sample)\n\n# Polynomial coefficients of CG biped objective\nfit = np.array([-660.1898, 556.5202, -186.4672, 34.1877, -3.4090, 0.1602])\n\nplt.figure(0, figsize = (8, 6))\n\nplt.plot(x, np.polyval(fit, x), linewidth = 3)\n\nplt.xlabel('Step length (m)')\nplt.ylabel('Cost of transport (J*s\/m)')\n\nplt.xticks([0.08, 0.13, 0.18])\nplt.yticks([0.020, 0.025, 0.030])\n\nplt.tight_layout()\n\n#%% Plot posteriors and posterior samples for different amounts of data.\nimport os\n\nfrom Preference_GP_learning import feedback    \n\nnum_samples_plot = 3    # Number of GP samples to draw on each plot\nnum_samples = 2         # We used pairwise preferences with Self-Sparring\n\n# Folder in which to save plots:\nsave_plots_folder = 'Plots\/'\n\nif not os.path.isdir(save_plots_folder):\n    os.mkdir(save_plots_folder)\n\n# Numbers of preferences at which to make a posterior plot:\npref_nums = [0, 5, 20, 75]\n\n# Load data from the first run:\nsave_folder = 'Compass_biped_results\/'\nrun_num = 0\ndata = io.loadmat(save_folder + 'Opt_' + str(num_samples) + '_samples_' \\\n                     + str(num_pts_sample) + '_pts_run_' + str(run_num) + '.mat')\n\nobj_values = data['objective_values'][0]\ndata_pt_idxs = data['data_pt_idxs']\nlabels = data['labels']\npreference_noise = data['preference_noise'][0][0]\nlengthscales = data['lengthscale'][0]\nsignal_variance = data['signal_variance'][0][0]\nGP_noise_var = data['GP_noise_var'][0][0]\n\n# Domain over which to optimize:\npoints_to_sample = x\n\n# Determine dimensionality of state space:\nif len(points_to_sample.shape) == 1:\n    state_dim = 1  \nelse:\n    state_dim = points_to_sample.shape[1]                  \n  \npoints_to_sample = points_to_sample.reshape((num_pts_sample, state_dim))\n\n# Instantiate the prior covariance matrix, using a squared exponential\n# kernel in each dimension of the input space:\nGP_prior_cov =  signal_variance * np.ones((num_pts_sample, num_pts_sample))   \n\nfor i in range(num_pts_sample):\n\n    pt1 = points_to_sample[i, :]\n    \n    for j in range(num_pts_sample):\n        \n        pt2 = points_to_sample[j, :]\n        \n        for dim in range(state_dim):\n            \n            lengthscale = lengthscales[dim]\n            \n            if lengthscale > 0:\n                GP_prior_cov[i, j] *= np.exp(-0.5 * ((pt2[dim] - pt1[dim]) \/ \\\n                            lengthscale)**2)\n                \n            elif lengthscale == 0 and pt1[dim] != pt2[dim]:\n                \n                GP_prior_cov[i, j] = 0\n \nGP_prior_cov += GP_noise_var * np.eye(num_pts_sample)\n       \nGP_prior_cov_inv = np.linalg.inv(GP_prior_cov)\n\nsampled_points = points_to_sample.flatten()\n\nfor i, pref_num in enumerate(pref_nums):\n    \n    print('Iter %i of %i' % (i + 1, len(pref_nums)))\n    \n    # Preference data to use for this plot:\n    X = data_pt_idxs[: pref_num, :]\n    y = labels[: pref_num, 1]\n    \n    # Update the Gaussian process preference model:\n    posterior_model = feedback(X, y, GP_prior_cov_inv, preference_noise)    \n    \n    # Load reward samples:\n    \"\"\"\n    NOTE: here is the code for actually generating the reward samples that will\n    be plotted. We saved several of them, so that they would not need to\n    be constantly resampled.\n    \n    from Preference_GP_learning import advance\n    \n    # Sample new points at which to query for a preference:\n    _, reward_models = advance(posterior_model, num_samples_plot)\n    #    io.savemat('Plotting_data\/Reward_samples_' + str(pref_num) + '_preferences.mat',\n    #      {'reward_samples': reward_models, 'sampled_points': sampled_points})\n    \"\"\"\n    \n    reward_models = io.loadmat('Plotting_data\/Reward_samples_' + str(pref_num) + \\\n                               '_preferences.mat')['reward_samples']\n\n    # Unpack model posterior:\n    post_mean = posterior_model['mean']\n    cov_evecs = np.real(posterior_model['cov_evecs'])\n    cov_evals = posterior_model['cov_evals']\n    \n    # Construct posterior covariance matrix:\n    post_cov = cov_evecs @ np.diag(cov_evals) @ np.linalg.inv(cov_evecs)\n    \n    # Posterior standard deviation at each point:\n    post_stdev = np.sqrt(np.diag(post_cov))\n    \n    plt.figure(figsize = (8, 6))\n    \n    # Plot posterior mean and standard deviation:\n    plt.plot(sampled_points, post_mean, color = 'blue', linewidth = 3)\n    plt.fill_between(sampled_points, post_mean - 2*post_stdev, \n                     post_mean + 2*post_stdev, alpha = 0.3, color = 'blue')\n    \n    # Plot posterior samples:\n    for j in range(num_samples_plot):\n        \n        reward_model = reward_models[j, :]\n        \n        plt.plot(sampled_points, reward_model, color = 'green',\n                 linestyle = '--', linewidth = 3)\n        \n    plt.ylim([-0.035, 0.043])\n    \n    plt.xlabel('Step length (m)')\n    plt.ylabel('Posterior Utility')\n    plt.xticks([0.08, 0.13, 0.18])\n    plt.yticks([-0.02, 0, 0.02, 0.04])\n    \n    if i == 0:\n        plt.legend(['Posterior', 'Posterior samples'], loc = 'upper left',\n                   fontsize = 23)\n    \n    plt.tight_layout()\n    \n#    plt.savefig(save_plots_folder + 'Compass_biped_2STD_' + str(pref_num) + \\\n#                '_preferences.png')\n    \n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_208","text":"<reponame>charlesblakemore\/opt_lev_analysis\nimport math, sys\nfrom scipy import integrate\nimport numpy as np\n\ngap = float(sys.argv[1])\nlam = float(sys.argv[2])\n\nprint(gap, lam)\n\n## calculate potential over cylindrical mass as function of position\n\nD = 5e-6 # diameter of bead (m)\nrhob = 2e3 # density bead (kg\/m^3)\nrhoa = 20e3 # density attractor\na = 20e-6 # length of attractor cube side (m)\n##gap = 7.5e-6 # gap between cube face and bead center\n\ndef dV(phi,theta,r):\n    return r**2 * math.sin(theta)\n\nalpha = 1.0\nG = 6.67398e-11 \n\ndef Fg(phi, theta, r, currx, curry, currz):\n    ## distance between r,theta,phi point and currx,curry,currz measured relative to center of cube at (gap + a\/2, 0, 0) \n    dx = r*math.sin(theta)*math.cos(phi) - (gap + a\/2.0 + currx)    \n    dy = r*math.sin(theta)*math.sin(phi) - curry\n    dz = r*math.cos(theta) - currz\n    dist = math.sqrt( dx**2 + dy**2 + dz**2 )        \n\n    return (alpha*G*rhoa\/dist)*math.exp(-dist\/lam)*rhob*dV(phi,theta,r)\n\ndef Fg_tot(z,y,x):\n    def Fg_curr(phi, theta,r):\n        return Fg(phi,theta,r,x,y,z)\n    f1 = integrate.tplquad(Fg_curr, 0.0, D\/2.0, lambda y: 0.0, lambda y: math.pi, lambda y,z: 0.0, lambda y,z: 2.0*math.pi)\n    return f1[0]\n\n\n\nintval = integrate.tplquad(Fg_tot, -a\/2.0, a\/2.0, lambda x: -a\/2.0, lambda x: a\/2.0, lambda x,y: -math.sqrt(a**2 - x**2), lambda x,y: math.sqrt(a**2 - x**2), epsabs=1e-4, epsrel=1e-4)\n    \nfname = 'lam_arr_pot_cyl_%.3f_%.3f.npy' % (gap*1e6,lam*1e6)\nnp.save(fname,intval)\n\n         \n                        \n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_209","text":"<gh_stars>1000+\n# coding=utf-8\n# Copyright 2018 The Google AI Language Team Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"IO Tools for supporting NQL.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n\nfrom __future__ import print_function\n\nfrom nql import symbol\nimport numpy\nimport scipy.sparse\nimport tensorflow.compat.v1 as tf\n\n\n\ndef lines_in(file_like):\n  \"\"\"Enumerate lines in a stream.\n\n  Call file_like's iterator method and iterate over that.  Will\n  skip any lines starting with # and blank lines.\n\n  Args:\n    file_like: An iterator over lines.\n\n  Yields:\n    a string for each line in the file or stream.\n  \"\"\"\n  for line in file_like:\n    if line[0] != '#' and line != '\\n':\n      yield line\n\n\ndef lines_in_all(files,\n                 lines):\n  \"\"\"Enumerate lines in multiple files.\n\n  Args:\n    files: If specified, a file-like or array of file-like objects.\n    lines: If specified, an array of strings.\n\n  Yields:\n    a string for each line in each file or string.\n  \"\"\"\n  if files:\n    file_set = files if isinstance(files, list) else [files]\n    for one_file in file_set:\n      for line in lines_in(one_file):\n        yield line\n  if lines:\n    for line in lines_in(lines):\n      yield line\n\n\ndef _read_numpy_item(input_file):\n  \"\"\"Read the item found in a numpy save file.\n\n  Args:\n    input_file: Filename string or FileLike object.\n\n  Returns:\n    The first item.\n  \"\"\"\n  if isinstance(input_file, str):\n    with tf.io.gfile.GFile(input_file, 'rb') as fh:\n      item = numpy.load(fh, allow_pickle=True).item()\n  else:\n    item = numpy.load(input_file, allow_pickle=True).item()\n  return item\n\n\ndef _write_numpy_item(output_file, item):\n  \"\"\"Write the item to a numpy save file.\n\n  Args:\n    output_file: Filename string or FileLike object.\n    item: Some object to save as the first item.\n  \"\"\"\n  if isinstance(output_file, str):\n    with tf.io.gfile.GFile(output_file, 'wb') as fh:\n      numpy.save(fh, item)\n  else:\n    numpy.save(output_file, item)\n\n\ndef read_sparse_matrix_dict(\n    input_file):\n  \"\"\"Read a dictionary of relations from a file.\n\n  Args:\n    input_file: Filename string or FileLike object.\n\n  Returns:\n    A dictionary mapping relation names to scipy sparse matrices.\n  \"\"\"\n  relation_dict = _read_numpy_item(input_file)\n  return {\n      rel_name: _numpy_dict_to_sparse_matrix(numpy_dict)\n      for rel_name, numpy_dict in relation_dict.items()\n  }\n\n\ndef write_sparse_tensor_dict(\n    output_file,\n    sparse_tensor_dict):\n  \"\"\"Write a dictionary of tf.SparseTensor values to a file.\n\n  Args:\n    output_file: Filename string or FileLike object.\n    sparse_tensor_dict: Map from relation name to tf.SparseTensor values.\n  \"\"\"\n  relation_dict = {\n      rel_name: _sparse_tensor_to_numpy_dict(sparse_tensor)\n      for rel_name, sparse_tensor in sparse_tensor_dict.items()\n  }\n  _write_numpy_item(output_file, relation_dict)\n\n\ndef read_symbol_table_dict(input_file,\n                           restrict_to = ()):  # pytype: disable=annotation-type-mismatch\n  \"\"\"Read a dictionary of SymbolTable values from a file.\n\n  Args:\n    input_file: Filename string or FileLike object.\n    restrict_to: If defined, a list of types to restrict to.\n\n  Returns:\n    A dictionary mapping type names to SymbolTable values.\n  \"\"\"\n  symbol_dict = _read_numpy_item(input_file)\n  return {\n      type_name: symbol.create_from_dict(symbol_table_dict)\n      for type_name, symbol_table_dict in symbol_dict.items()\n      if not restrict_to or type_name in restrict_to\n  }\n\n\ndef write_symbol_table_dict(\n    output_file,\n    symbol_table_dict,\n    restrict_to = ()\n):  # pytype: disable=annotation-type-mismatch\n  \"\"\"Write a dictionary of SymbolTable values to a file.\n\n  Args:\n    output_file: Filename string or FileLike object.\n    symbol_table_dict: Map from type_name to SymbolTable values.\n    restrict_to: If defined, a list of types to restrict to.\n  \"\"\"\n  output_dict = {\n      type_name: symbol_table.to_dict()\n      for type_name, symbol_table in symbol_table_dict.items()\n      if not restrict_to or type_name in restrict_to\n  }\n  _write_numpy_item(output_file, output_dict)\n\n\ndef _numpy_dict_to_sparse_matrix(\n    numpy_dict):\n  \"\"\"Convert a dictionary of numpy arrays into a scipy sparse matrix.\n\n  Args:\n    numpy_dict: A dictionary representing the data.\n\n  Returns:\n    A scipy sparse matrix representing the data.\n  \"\"\"\n  return scipy.sparse.coo_matrix((numpy_dict['values'],\n                                  (numpy_dict['rows'], numpy_dict['cols'])),\n                                 shape=numpy_dict['shape'],\n                                 dtype='float32').transpose()\n\n\ndef _sparse_tensor_to_numpy_dict(\n    sparse_tensor):\n  \"\"\"Convert a tf.SparseTensor into a dictionary of numpy arrays.\n\n  Args:\n    sparse_tensor: A SparseTensor of the trained relation.\n\n  Returns:\n    A dictionary representing the data.\n  \"\"\"\n  return {\n      'shape': sparse_tensor.dense_shape,\n      'rows': numpy.array(sparse_tensor.indices[:, 0]),\n      'cols': numpy.array(sparse_tensor.indices[:, 1]),\n      'values': numpy.array(sparse_tensor.values)\n  }\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_210","text":"<reponame>andycasey\/sick<filename>sick\/optimise.py<gh_stars>1-10\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n\n\"\"\" Generalised optimisation function. \"\"\"\n\nfrom __future__ import division, print_function\n\n__author__ = \"<NAME> <<EMAIL>>\"\n\nimport logging\nfrom time import time\n\nimport numpy as np\nimport scipy.optimize as op\n\nlogger = logging.getLogger(\"sick\")\n\n\ndef minimise(objective_function, p0, **kwargs):\n    \"\"\"\n    A safe, general minimisation function.\n    \"\"\"\n\n    p0 = np.array(p0)\n\n    op_kwargs = kwargs.copy()\n\n    # Which optimisation algorithm?\n    available_methods = (\"BFGS\", \"Nelder-Mead\", \"Powell\", \"CG\", \"TNC\")\n    method = op_kwargs.pop(\"method\", available_methods[0])\n    logger.debug(\"Optimising with {0} algorithm\".format(method))\n\n    op_kwargs.update({ \"callback\": None, \"full_output\": True, \"retall\": False })\n\n    def _drop_forbidden_keywords(op_kwds, allowed):\n        for keyword in set(op_kwds).difference(allowed):\n            logger.debug(\"Dropping optimisation keyword {0}: {1}\".format(\n                keyword, op_kwds.pop(keyword)))\n\n    t_init = time()\n    if method == \"Nelder-Mead\":\n        # Need to force some arguments.\n        # Optional arguments:\n        # xtol, ftol, maxiter, maxfun\n        _drop_forbidden_keywords(op_kwargs, (\"xtol\", \"ftol\", \"maxiter\", \n            \"maxfun\", \"full_output\", \"retall\", \"callback\", \"disp\"))\n\n        # Set defaults.\n        op_kwargs.setdefault(\"disp\", False)\n\n        x_opt, f_opt, num_iter, num_funcalls, warnflag \\\n            = op.fmin(objective_function, p0, **op_kwargs)\n\n        logger.debug(\"Number of iterations: {0}, number of function calls: {1}\"\\\n            .format(num_iter, num_funcalls))\n\n        if warnflag == 0:\n            logger.debug(\"Optimisation converged after {0:.1f} seconds.\".format(\n                time() - t_init))\n        else:\n            logger.warn(\"Optimisation failed: {0}\".format([\n                \"Maximum number of function evaluations.\",\n                \"Maximum number of iterations.\"][warnflag - 1]))\n\n    elif method == \"Powell\":\n        # Optional arguments: xtol, ftol, maxiter, maxfun\n        _drop_forbidden_keywords(op_kwargs, (\"xtol\", \"ftol\", \"maxiter\", \n            \"maxfun\", \"retall\", \"callback\", \"full_output\", \"disp\"))\n        \n        # Set defaults.\n        op_kwargs.setdefault(\"disp\", False)\n\n        x_opt, f_opt, direc, num_iter, num_funcalls, warnflag \\\n            = op.fmin_powell(objective_function, p0, **op_kwargs)\n\n        logger.debug(\"Number of iterations: {0}, number of function calls: {1}\"\\\n            .format(num_iter, num_funcalls))\n\n        if warnflag == 0:\n            logger.debug(\"Optimisation converged after {0:.1f} seconds.\".format(\n                time() - t_init))\n        else:\n            logger.warn(\"Optimisation failed: {0}\".format([\n                \"Maximum number of function evaluations.\",\n                \"Maximum number of iterations.\"][warnflag - 1]))\n\n    elif method == \"CG\":\n        # Optional arguments: gtol, norm, epsilon, maxiter.\n        _drop_forbidden_keywords(op_kwargs, (\"gtol\", \"norm\", \"epsilon\", \n            \"maxiter\", \"retall\", \"callback\", \"full_output\"))\n\n        x_opt, f_opt, num_funcalls, num_gradcalls, warnflag \\\n            = op.fmin_cg(objective_function, p0, **op_kwargs)\n\n        logger.debug(\"Number of function calls: {0}, gradient calls: {1}\"\\\n            .format(num_funcalls, num_gradcalls))\n\n        if warnflag == 0:\n            logger.debug(\"Optimisation converged after {0:.1f} seconds.\".format(\n                time() - t_init))\n        else:\n            logger.debug(\"Optimisation failed: {0}\".format([\n                \"Maximum number of iterations exceeded\",\n                \"Gradient and\/or function calls were not changing.\"\n                ][warnflag - 1]))\n\n    elif method == \"BFGS\":\n        # Since we have at least some boundaries, this will actually call\n        # the L-BFGS-B algorithm.\n        # Optional arguments: m, factr, pgtol, epsilon, maxfun, maxiter\n\n        _drop_forbidden_keywords(op_kwargs, (\"m\", \"factr\", \"pgtol\", \n            \"approx_grad\", \"epsilon\", \"disp\", \"iprint\", \"maxfun\", \"maxiter\"))\n\n        # Default\/required:\n        op_kwargs.setdefault(\"factr\", 10.0)\n        op_kwargs[\"approx_grad\"] = True\n        \n        # Because the parameters will vary by orders of magnitude, here we\n        # scale everything to the initial value so that the epsilon keyword\n        # makes some sense.\n\n        scale = p0.copy()\n        \n        def scaled_objective_function(theta):\n            return objective_function(theta.copy() * scale)\n\n        x_opt, f_opt, info_dict = op.fmin_l_bfgs_b(scaled_objective_function,\n            np.ones(p0.size, dtype=float), **op_kwargs)\n\n        # Rescale.\n        x_opt *= scale\n\n        g_opt = info_dict[\"grad\"]\n        num_iter = info_dict[\"nit\"]\n        num_funcalls = info_dict[\"funcalls\"]\n        warnflag = info_dict[\"warnflag\"]\n\n        logger.debug(\"Number of iterations: {0}, function calls: {1}\".format(\n            num_iter, num_funcalls))\n        if warnflag == 0:\n            logger.debug(\"Optimisation converged after {0:.1f} seconds.\".format(\n                time() - t_init))\n        else:\n            logger.warn(\"Optimisation failed: {0}\".format([\n                \"Too many function evaluations or iterations!\",\n                \"{0}\".format(info_dict.get(\"task\", None))][warnflag - 1]))\n    \n    elif method == \"TNC\":\n        # Optional arguments:   bounds, epsilon, scale, offset, messages, \n        #                       maxCGit, maxfun, eta, stepmx, accuracy, \n        #                       fmin, ftol, xtol, pgtol, rescale\n\n        _drop_forbidden_keywords(op_kwargs, (\"approx_grad\", \"bounds\", \"epsilon\",\n            \"scale\", \"offset\", \"messages\", \"maxCGit\", \"maxfun\", \"eta\", \"stepmx\",\n            \"accuracy\", \"fmin\", \"ftol\", \"xtol\", \"pgtol\", \"rescale\", \"disp\"))\n\n        # Required:\n        op_kwargs[\"approx_grad\"] = True\n\n        x_opt, num_funcalls, rc = op.fmin_tnc(objective_function, p0, \n            **op_kwargs)\n        \n        rcstring = {\n            -1: \"Infeasible (lower bound > upper bound)\",\n            0: \"Local minimum reached (|pg| ~= 0)\",\n            1: \"Converged (|f_n-f_(n-1)| ~= 0)\",\n            2: \"Converged (|x_n-x_(n-1)| ~= 0)\",\n            3: \"Max. number of function evaluations reached\",\n            4: \"Linear search failed\",\n            5: \"All lower bounds are equal to the upper bounds\",\n            6: \"Unable to progress\",\n            7: \"User requested end of minimization\"\n        }[rc]\n\n        logger.debug(\"Number of function calls: {0}, result: {1}\".format(\n            num_funcalls, rcstring))\n        if rc in (1, 2):\n            logger.debug(\"Optimisation converged after {0:.1f} seconds: {1}\"\\\n                .format(time() - t_init, rcstring))\n        else:\n            logger.warn(\"Optimisation failed: {0}\".format(rcstring))\n\n    else:\n        raise ValueError(\"optimisation algorithm {0} is not available \"\\\n            \"(available methods are {1})\".format(\n                method, \", \".join(available_methods)))\n\n\n    return x_opt"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_211","text":"<filename>calc_viscoelastic_parameters.py\n#! \/usr\/bin\/env python\r\n# The MIT License (MIT)\r\n#\r\n# Copyright (c) 2015, EPFL Reconfigurable Robotics Laboratory,\r\n#                     <NAME>, <EMAIL>\r\n#\r\n# Permission is hereby granted, free of charge, to any person obtaining a copy\r\n# of this software and associated documentation files (the \"Software\"), to deal\r\n# in the Software without restriction, including without limitation the rights\r\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\r\n# copies of the Software, and to permit persons to whom the Software is\r\n# furnished to do so, subject to the following conditions:\r\n#\r\n# The above copyright notice and this permission notice shall be included in\r\n# all copies or substantial portions of the Software.\r\n#\r\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n# THE SOFTWARE.\r\n\r\nimport argparse, time, sys\r\nimport numpy as np\r\nimport curve_fit as CF\r\nimport utility as U\r\nimport model_utility as MU\r\nfrom matplotlib import pyplot,axes\r\nimport scipy.interpolate as interp\r\n\r\n\r\n#--------------------------------------------------------------------------------\r\n# Create data plots.\r\n#   ax    = two axes handles to plot on.\r\n#   data  = dictionary of experimental datasets.\r\n#   popt  = optimal parameters to calculate fit lines.\r\n#   paperBOOL = it True, prepare an image suitable for a paper.\r\n#--------------------------------------------------------------------------------\r\ndef create_data_plots(ax,data,popt,xlim=[],paperBOOL=False):\r\n    NP = 2000\r\n    fvals = np.empty([NP,2])\r\n    M0 = popt[0]\r\n    t0 = np.abs(popt[1])\r\n\r\n    # Plot the experimental and fitted data.\r\n    if not paperBOOL: ax[0].set_title('Shear Modulus vs Time')\r\n    ax[0].plot(data[:,0]+t0,data[:,1],label='Experimental Data')\r\n    if xlim==[]:\r\n        x0,x1 = ax[0].get_xlim()\r\n        xlim = [0.0, 1.5*x1]\r\n    fvals[:,0] = np.linspace(xlim[0],xlim[1],NP)\r\n    fvals[:,1] = prony(fvals[:,0]-t0,*popt) # This offsets the t0 in the prony function, giving us back the regular values.\r\n    ax[0].plot(fvals[:,0],fvals[:,1],'r',label='Prony Fit')\r\n    # Plot the dimensionless data and fit.\r\n    # ax[1].plot(data[:,0],data[:,1]\/M0,'k-',label='Dimensionless Experimental Data')\r\n    # ax[1].plot(fvals[:,0],fvals[:,1]\/M0,'r-',label='Dimensionless Fit')\r\n\r\n    ax[0].set_adjustable('box-forced')\r\n    ax[1].set_adjustable('box-forced')\r\n    # Set the plot limits.\r\n    ylim = [min(fvals[:,1]),max(fvals[:,1])]\r\n    ylim[0] = ylim[0] - 0.1*np.diff(ylim)\r\n    ax[0].set_ylim(ylim)\r\n    ax[1].set_ylim(ylim[0]\/ylim[1],1.0)\r\n    # Set the aspect ratios to ensure the two plots line up.\r\n    if not paperBOOL:\r\n        ratio = 1.0\r\n        ax[0].set_aspect(ratio*np.diff(xlim)\/np.diff(ax[0].get_ylim()))\r\n        ax[1].set_aspect(ratio*np.diff(xlim)\/np.diff(ax[1].get_ylim()))\r\n    # ax[0].set_xscale('log')\r\n    ax[0].grid()\r\n    ax[0].set_xlabel('Time (s)')\r\n    ax[0].set_ylabel(r'Shear Modulus $\\left({}^N\\!\/{}_{mm^2}\\right)$')\r\n    ax[1].set_ylabel(r'Dimensionless Shear Modulus $\\left({}^G\\!\/{}_{G_0}\\right)$')\r\n    if paperBOOL: ax[0].legend(loc='upper right',frameon=False,framealpha=0)\r\n    pyplot.tight_layout()\r\n\r\n#--------------------------------------------------------------------------------\r\n# Create error plot.\r\n#   ax    = axis handle to plot on.\r\n#   data  = dictionary of experimental datasets.\r\n#   popt  = optimal parameters to calculate fit lines.\r\n#   R2    = overall R^2 fit error.\r\n#--------------------------------------------------------------------------------\r\ndef create_error_plot(ax,data,popt,R2):\r\n    M0 = popt[0]\r\n    t0 = np.abs(popt[1])\r\n    ax.set_title('Relative Errors ($R^2$='+str(R2)+')')\r\n    if not len(data)==0:\r\n        fvals = prony(data[:,0],*popt)\r\n        err = 100.0 * (data[:,1]-fvals)\/data[:,1]\r\n        ax.plot(data[:,0],err,'.b',label='Errors')\r\n        ax.grid()\r\n        ax.set_xlabel('Time (s)')\r\n        ax.set_ylabel('Error (%)')\r\n        xlim = ax.get_xlim()\r\n        ylim = ax.get_ylim()\r\n        ax.set_aspect(abs(xlim[1]-xlim[0])\/abs(ylim[1]-ylim[0])) # Square axis.\r\n\r\n    # Calculate the equilibrium modulus.\r\n    pterms = np.reshape(popt[2:],((len(popt)-2)\/2,2))\r\n    pdescr = str(popt[2:])+'\\nG_inst = '+str(M0)+'\\nG_equil = '+str(M0-np.sum(pterms[:,0]))+'\\nt0 = '+str(np.abs(popt[1]))\r\n    pyplot.figtext(0.5,0.02,pdescr,ha='center')\r\n    pyplot.tight_layout()\r\n\r\n\r\n#--------------------------------------------------------------------------------\r\n# Prony function, M(t) = M_equil + sum(M_i e^(-t\/tau_i))\r\n# Abaqus implements as: M(t) = M0 - sum(M_i*(1-e^(-t\/tau_i)))\r\n#   t     = time series.\r\n#   M0    = instantaneous modulus.\r\n#   args  = mi and taui, number depends on number of terms.\r\n#--------------------------------------------------------------------------------\r\ndef prony(t,M0,t0,*args):\r\n    Mt = np.ones(t.shape) * M0\r\n    t0 = np.abs(t0)\r\n    for i in range(0,len(args),2):\r\n        Mt = Mt - args[i]*(1.0-np.exp(-(t+t0)\/args[i+1]))\r\n    return Mt\r\n\r\n#--------------------------------------------------------------------------------\r\n# Calculate the parameters to fit a model to the experimental data.\r\n#   data       = experimental dataset.\r\n#   descr      = first part of filename.\r\n#   terms      = number of terms to use in the Prony series.\r\n#   poisson    = Poisson's ratio of material.\r\n#   num_points = number of random points to try for optimization start.\r\n#   ext        = image extension (with .).\r\n#--------------------------------------------------------------------------------\r\ndef calc_params(data,descr,terms,poisson,num_points,ext):\r\n    maxitr = 100    # Default = 100\r\n    nparams = 2*terms+2\r\n    print '---------------------------------------------------------'\r\n    print ' Calculating',str(terms)+'-term fit with',num_points,'guess(es)'\r\n    print '---------------------------------------------------------'\r\n    S_best = -1.0e8\r\n    iname = descr+'--'+str(terms)+'terms'+ext\r\n    title = 'Prony Series '+str(terms)+'-term Fit'\r\n    for i in range(num_points):\r\n        p0 = np.longdouble(np.random.random_sample(nparams))\r\n        p0[range(3,nparams,2)] = p0[range(3,nparams,2)] * 5.0\r\n        print '\\tStarting point '+str(i)\r\n        try:\r\n            if poisson==0.5:\r\n                popt = CF.curve_fit1_basinhopping(prony,data[:,0],data[:,1],p0,maxitr)\r\n            else:\r\n                # TODO - how to do the bulk fitting? Completely seperately?\r\n                U.print_error(\"Bulk fitting not yet supported, use nu=0.5\",True)\r\n                popt = CF.curve_fit2(prony,data[:,0],data[:,1],\r\n                                     prony,data[:,0],data[:,2],\r\n                                     p0,maxitr)\r\n        except Exception:\r\n            print '\\t\\tERROR:',sys.exc_info()[1]\r\n            continue\r\n        S = calculate_rsquared(data,poisson,popt)\r\n        print '\\t\\tRsquared: ',S\r\n        if S<=S_best: continue\r\n        if (popt[range(2,nparams,2)]\/popt[0] > 1.0).any():\r\n            print '\\t\\t** Good result, but invalid for Abaqus. Continuing... **'\r\n            continue\r\n        S_best = S\r\n        print '\\t\\tM0: ',popt[0]\r\n        print '\\t\\t** New Best Result. Updating Plots **'\r\n        # Plot results.\r\n        ax = []\r\n        fig = pyplot.figure(figsize=(10,6))\r\n        ax.append(fig.add_subplot(121))\r\n        ax.append(ax[0].twinx())\r\n        ax.append(fig.add_subplot(122))\r\n        create_data_plots(ax,data,popt)\r\n        create_error_plot(ax[2],data,popt,S)\r\n        pyplot.suptitle(title,fontweight=\"bold\")\r\n        pyplot.savefig(iname)\r\n        pyplot.close()\r\n        MU.write_viscomatfile(descr,popt[0],popt[2:])\r\n        params = np.concatenate((popt,[S_best]))\r\n    if S_best!=-1.0e8:\r\n        print '\\n\\tBest-fit Rsquared:',params[-1]\r\n    else:\r\n        U.print_error(\"No suitable fit found.\",False)\r\n        return np.zeros(nparams+1)\r\n    print '\\n\\n'\r\n    return params\r\n\r\n\r\n#--------------------------------------------------------------------------------\r\n# Calculate Rsquared.\r\n#--------------------------------------------------------------------------------\r\ndef calculate_rsquared(data,poisson,popt):\r\n    if len(data)==0: return 0.0\r\n    ydata = data[:,1]\r\n    yfit  = prony(data[:,0],*popt)\r\n    if poisson!=0.5:\r\n        ydata = np.hstack((ydata,data[:,2]))\r\n        yfit = np.hstack((yfit, prony(data[:,0],*popt)))\r\n    return CF.rsquared(ydata,yfit)\r\n\r\n\r\n#--------------------------------------------------------------------------------\r\n# Main.\r\n#--------------------------------------------------------------------------------\r\nif __name__ == \"__main__\":\r\n    tinit = time.time()\r\n    # Handle user input.\r\n    parser = argparse.ArgumentParser(description=\"Fit the given dataset to a viscoelastic Prony series.\",\r\n                                     epilog=\"Example: calc_viscoelastic_parameters.py 0.5 newdata uni.txt\")\r\n    parser.add_argument(\"-p\",\"--points\",type=int,default=15,help=\"Number of random starting points (default 30).\")\r\n    parser.add_argument(\"--datapoints\",type=int,default=500,help=\"The target number of datapoints to fit from each dataset (default 500).\")\r\n    parser.add_argument(\"--format\",choices=['png','eps'],help=\"Image format, default is png.\")\r\n    parser.add_argument(\"--terms\",nargs=2,type=int,default=[2,5],help=\"Range of terms to compare in Prony expansion, default is 3-9 (inclusive).\")\r\n    parser.add_argument(\"poisson\",type=float,help=\"Poisson's ratio.\")\r\n    parser.add_argument(\"descr\",help=\"Additional descriptive term to add to output file titles.\")\r\n    parser.add_argument(\"datafile\",help=\"Dataset to fit, consisting of (time, shear mod, bulk mod) columns.\")\r\n    args = parser.parse_args()\r\n    if args.format: fmt = '.'+args.format\r\n    else:           fmt = '.png'\r\n    # 'suppress' disables scientific notation for small numbers.\r\n    np.set_printoptions(precision=4,linewidth=130,suppress=True)\r\n    # np.seterr(all='raise')\r\n    pyplot.rc('savefig',dpi=300)\r\n    pyplot.rc('font',size=8)\r\n    pyplot.rc('mathtext',default='regular') # Don't use italics for mathmode.\r\n\r\n    # Read in the given datasets.\r\n    print '--------------------------------------------------------------------'\r\n    print ' Importing dataset...'\r\n    data = np.loadtxt(args.datafile,comments='#',delimiter=',',dtype=np.longdouble)\r\n    print '  Imported',data.shape[0],'datapoints.'\r\n\r\n    # dataF = interp.UnivariateSpline(data[:,0], data[:,1], k=3)\r\n    # dataS = np.zeros((args.datapoints,2))\r\n    # dataS[:,0] = np.linspace(min(data[:,0]),max(data[:,0]),args.datapoints)\r\n    # dataS[:,1] = dataF(dataS[:,0])\r\n    # data = dataS\r\n    # print '** Smoothed points, now',data.shape[0],'points. **'\r\n\r\n    # Calculate optimal parameters for several lengths of Prony expansions.\r\n    params = dict()\r\n    for i in range(args.terms[0],args.terms[1]+1):\r\n        params[i] = calc_params(data,args.descr,i,args.poisson,args.points,fmt)\r\n\r\n    print '--------------------------------------------------------------------'\r\n    print ' Results for Prony fits to Shear Modulus (G).'\r\n    print '--------------------------------------------------------------------'\r\n    np.set_printoptions(suppress=False)\r\n    for t,p in params.iteritems():\r\n        R2 = p[-1]\r\n        M0 = p[0]\r\n        t0 = p[1]\r\n        pronyM = np.reshape(p[2:-1],(t,2))\r\n        pronyM = pronyM[pronyM[:,1].argsort()]      # Sort the rows by time.\r\n        pronyM_nd = np.zeros(pronyM.shape)\r\n        pronyM_nd[:,0] = pronyM[:,0] \/ M0\r\n        pronyM_nd[:,1] = pronyM[:,1]\r\n        Me = M0-np.sum(pronyM[:,0])\r\n        print '* Parameters for '+str(t)+'-term fit.'\r\n        print 'Rsquared:',R2\r\n        print \"G_instantaneous:  {: 12f}\\t\\t\\t(dimless {: 12f})\".format(M0,M0\/M0)\r\n        print \"G_equilibrium:    {: 12f}\\t\\t\\t(dimless {: 12f})\".format(Me,Me\/M0)\r\n        print \"t_0 (seconds):    {: 12f}\".format(t0)\r\n        print 'Parameters (G_i, tau_i):\\t\\tDimensionless Parameters (g_i, tau_i):'\r\n        for r in range(pronyM.shape[0]):\r\n            print \"  {: 12f},  {: 12f}\\t\\t\\t{: 12f},  {: 12f}\".format(pronyM[r,0],pronyM[r,1],pronyM_nd[r,0],pronyM_nd[r,1])\r\n        print\r\n    print 'TOTAL TIME ELAPSED: ',U.time_elapsed(tinit)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_212","text":"import itertools\nfrom tqdm import tqdm\nfrom collections import Counter\nimport math\nfrom sympy import primefactors, sieve\nimport matplotlib.pyplot as plt\n\nfrom itertools import chain, combinations, combinations_with_replacement\nimport functools \n\nm = 970\n@functools.lru_cache(maxsize=10024)\ndef a(n):\n    if n < m:\n        return (int(n)**2) % m\n    if n % m == 0:\n        return a(n\/m)\n    else:\n        return a(n - math.floor(n\/m))\n\n\n\nif __name__ == \"__main__\":\n    s = [a(i) for i in range(1, 50_000)]\n    print(s)\n    plt.plot(s, ',')\n    plt.ylabel('some numbers')\n    plt.show()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_214","text":"from __future__ import division\nimport sys\nimport numpy\nimport pandas\nfrom scipy.stats import mannwhitneyu\nfrom statsmodels.stats.multitest import multipletests\n\nmetricsToUse = [\n    'first-contentful-paint',\n    'first-meaningful-paint',\n    'speed-index',\n    'total-blocking-time',\n    'estimated-input-latency',\n    'first-cpu-idle',\n    'time-to-interactive',\n    'network-requests',\n    'dom-size',\n    'lowest-time-to-widget',\n    'median-time-to-widget',\n]\n\n# Checks if all the entries in both arrays are identical\ndef check_if_all_the_same(a, b):\n    for i in range(min(len(a), len(b))):\n        if a[i] - b[i] != 0:\n            return False\n    return True\n\n\nif __name__ == \"__main__\":\n\n    Data = [\n        pandas.read_csv(sys.argv[1] + '1.csv'),\n        pandas.read_csv(sys.argv[1] + '2.csv'),\n        pandas.read_csv(sys.argv[1] + '3.csv'),\n        pandas.read_csv(sys.argv[1] + '4.csv'),\n        pandas.read_csv(sys.argv[1] + '5.csv'),\n        pandas.read_csv(sys.argv[1] + '6.csv'),\n        pandas.read_csv(sys.argv[1] + '7.csv'),\n        pandas.read_csv(sys.argv[1] + '8.csv'),\n        pandas.read_csv(sys.argv[1] + '9.csv'),\n        pandas.read_csv(sys.argv[1] + '10.csv'),\n        pandas.read_csv(sys.argv[1] + '11.csv'),\n        pandas.read_csv(sys.argv[1] + '12.csv'),\n        pandas.read_csv(sys.argv[1] + '13.csv'),\n        pandas.read_csv(sys.argv[1] + '14.csv'),\n    ]\n\n    pvals = []\n\n\n    for i in range(1, len(Data)):\n        print(\"\\n\")\n        print(\"Intervention \" + str(i))\n        previous = Data[i - 1]\n        current = Data[i]\n        for column in previous:\n            if column in metricsToUse and not check_if_all_the_same(previous[column], current[column]):\n                print(column + \": \" + str(\n                    mannwhitneyu(x=previous[column], y=current[column], use_continuity=False)))\n                _, pval = mannwhitneyu(x=previous[column], y=current[column], use_continuity=False)\n                pvals.append(pval)\n    \n        results = multipletests(pvals, alpha=0.05, method='fdr_bh')\n        for j in range(0, len(results[1])):\n            pval = results[1][j]\n            print(metricsToUse[j] + ': ' + str(pval))\n        pvals = []\n\n\n    print('Done!')\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_216","text":"<filename>fitting_py_code\/fitCylinder.py\nimport numpy as np\nfrom distance2cylinder import *\nfrom scipy.optimize import leastsq\nfrom scipy.optimize import least_squares\n\ndef fitCylinder(P, dx, dy, dz, px, py, pz, r):\n    '''\n    % Fit the cylinder to n 3D-points in P given the initial estimate of the cylinder\n    % Input: P, dx, dy, dz, px, py, pz, r\n    %     P : list of 3D-points, is of size n * 3\n    %     dx dy dz : vector indicates the axis of the cylinder\n    %     px py pz : a point on the rotational axis of the cylinder\n    %     r : the radius of the cylinder\n    % Output: dx dy dz px py pz r\n    :param P:\n    :param dx:\n    :param dy:\n    :param dz:\n    :param px:\n    :param py:\n    :param pz:\n    :param r:\n    :return:\n    '''\n    k = 1 \/ r\n    tmp1 = np.array([dx, dy, dz])\n    tmp2 = np.array([-px, -py, -pz])\n\n    t = np.inner(tmp1, tmp2)\/ np.linalg.norm(tmp1)\n    x = px + t * dx\n    y = py + t * dy\n    z = pz + t * dz\n    rho = np.sqrt(x ** 2 + y ** 2 + z ** 2) - r\n    phi = np.arctan2(y, x)\n    zeta = np.arccos(z \/ np.sqrt(x ** 2 + y ** 2 + z ** 2))\n    n_zeta = np.array([np.cos(phi) * np.cos(zeta), np.sin(phi) * np.cos(zeta), -np.sin(zeta)])\n    n_phi_bar = np.array([-np.sin(phi), np.cos(phi), 0])\n    cos_alpha = np.sum(tmp1 * n_zeta) \/ np.linalg.norm(tmp1)\n    sin_alpha = np.sum(tmp1 * n_phi_bar) \/ np.linalg.norm(tmp1)\n    alpha = np.arccos(cos_alpha) * np.sign(sin_alpha)\n    alpha = max(alpha, -np.pi)\n    alpha = min(alpha, np.pi)\n\n    #####Solve nonlinear least-squares (nonlinear data-fitting) problems\n    p0 = np.array([rho, phi, zeta, alpha, k])\n    out = least_squares(distance2cylinder, p0, jac=JacobianofCylinder, method='trf', bounds=([-np.inf, -np.pi, 0, -np.pi, 0],[np.inf,np.pi,np.pi,np.pi,np.inf]), args=([P]))\n    out = out.x\n    ####End\n\n    r = 1 \/ out[4]\n    px = (out[0] + r) * np.cos(out[1]) * np.sin(out[2])\n    py = (out[0] + r) * np.sin(out[1]) * np.sin(out[2])\n    pz = (out[0] + r) * np.cos(out[2])\n    dx = np.cos(out[1]) * np.cos(out[2]) * np.cos(out[3]) - np.sin(out[1]) * np.sin(out[3])\n    dy = np.sin(out[1]) * np.cos(out[2]) * np.cos(out[3]) + np.cos(out[1]) * np.sin(out[3])\n    dz = -np.sin(out[2]) * np.cos(out[3])\n\n    return dx, dy, dz, px, py, pz, r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_218","text":"'''Utility functions for performing fast SVD.'''\nimport scipy.linalg as linalg\nimport numpy as np\n\nfrom EigenPro import utils\n\n\ndef nystrom_kernel_svd(samples, kernel_fn, top_q):\n    \"\"\"Compute top eigensystem of kernel matrix using Nystrom method.\n\n    Arguments:\n        samples: data matrix of shape (n_sample, n_feature).\n        kernel_fn: tensor function k(X, Y) that returns kernel matrix.\n        top_q: top-q eigensystem.\n\n    Returns:\n        eigvals: top eigenvalues of shape (top_q).\n        eigvecs: (rescaled) top eigenvectors of shape (n_sample, top_q).\n    \"\"\"\n\n    n_sample, _ = samples.shape\n    kmat = kernel_fn(samples, samples).cpu().data.numpy()\n    scaled_kmat = kmat \/ n_sample\n    vals, vecs = linalg.eigh(scaled_kmat,\n                             eigvals=(n_sample - top_q, n_sample - 1))\n    eigvals = vals[::-1][:top_q]\n    eigvecs = vecs[:, ::-1][:, :top_q] \/ np.sqrt(n_sample)\n\n    return utils.float_x(eigvals), utils.float_x(eigvecs)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_219","text":"<gh_stars>10-100\nimport re\nimport statistics\nfrom collections import defaultdict\nfrom ...command import Command\nfrom ...commands.report import parse_logs, add_table_report_args, report_table\nfrom ...util import FatalError, Namespace\n\n\nclass SpecFindBadPrunNodesCommand(Command):\n    name = 'spec-find-bad-prun-nodes'\n    description = 'identify DAS-5 nodes with consistently high runtimes'\n\n    # highlight runtimes whose deviation from the mean exceeds 3 times the\n    # variance, but only if the percentage deviation is at least 2%\n    highlight_variance_deviation = 3\n    highlight_percent_threshold = 0.02\n\n    def add_args(self, parser):\n        targetarg = parser.add_argument('target', metavar='TARGET',\n                choices=self.targets,\n                help=' | '.join(self.targets))\n        rundirsarg = parser.add_argument('rundirs',\n                nargs='+', metavar='RUNDIR', default=[],\n                help='run directories to parse (results\/run.XXX)')\n\n        parser.add_argument('-i', '--instances', nargs='+',\n                metavar='INSTANCE', default=[], choices=self.instances,\n                help=' | '.join(self.instances))\n        parser.add_argument('--no-cache', action='store_false',\n                dest='cache',\n                help='cached results in the bottom of log files')\n        parser.add_argument('--refresh', action='store_true',\n                help='refresh cached results in logs')\n\n        add_table_report_args(parser)\n\n        try:\n            from argcomplete.completers import DirectoriesCompleter\n            targetarg.completer = self.complete_package\n            rundirsarg.completer = DirectoriesCompleter()\n        except ImportError:\n            pass\n\n    def run(self, ctx):\n        target = self.targets[ctx.args.target]\n        instances = self.instances.select(ctx.args.instances)\n        fancy = ctx.args.table == 'fancy'\n\n        # optional support for colored text\n        try:\n            if not fancy:\n                raise ImportError\n            from termcolor import colored\n        except ImportError:\n            def colored(text, *args, **kwargs):\n                return text\n\n        # parse result logs\n        results = parse_logs(ctx, target, instances, ctx.args.rundirs)\n\n        # compute aggregates\n        benchdata = defaultdict(lambda: defaultdict(Namespace))\n        node_zscores = defaultdict(lambda: defaultdict(list))\n        node_runtimes = defaultdict(list)\n        workload = None\n\n        for iname, iresults in results.items():\n            grouped = defaultdict(list)\n\n            for result in iresults:\n                grouped[result['benchmark']].append(result)\n                if workload is None:\n                    workload = result.get('workload', None)\n                elif result.get('workload', workload) != workload:\n                    raise FatalError('%s uses %s workload whereas previous '\n                                     'benchmarks use %s (logfile %s)' %\n                                     (result['benchmark'], result['workload'],\n                                      workload, result['outfile']))\n\n            for bench, bresults in grouped.items():\n                if len(bresults) <= 1:\n                    continue\n\n                if any(r['status'] != 'ok' for r in bresults):\n                    continue\n\n                # z-score per node\n                entry = benchdata[bench][iname]\n                runtimes = [r['runtime'] for r in bresults]\n                entry.rt_mean = statistics.mean(runtimes)\n                entry.rt_stdev = statistics.pstdev(runtimes)\n                entry.rt_variance = statistics.pvariance(runtimes)\n                entry.rt_median = statistics.median(runtimes)\n                for r in bresults:\n                    node = r['hostname']\n                    runtime = r['runtime']\n                    zscore = (runtime - entry.rt_mean) \/ entry.rt_stdev\n                    node_zscores[node][bench].append(zscore)\n                    node_rt = runtime, zscore, r['outfile']\n                    node_runtimes[(node, bench, iname)].append(node_rt)\n\n        # order nodes such that the one with the highest z-scores (the most\n        # deviating) come first\n        zmeans = {}\n        for hostname, benchscores in node_zscores.items():\n            allscores = []\n            for bscores in benchscores.values():\n                for score in bscores:\n                    allscores.append(score)\n            zmeans[hostname] = statistics.mean(allscores)\n        nodes = sorted(zmeans, key=lambda n: zmeans[n], reverse=True)\n\n        # show table with runtimes per node\n        header = [' node:\\n mean z-score:', '']\n        for node in nodes:\n            nodename = node.replace('node', '')\n            zscore = ('%.1f' % zmeans[node]).replace('0.', '.')\n            header.append(nodename + '\\n' + zscore)\n\n        data = []\n        high_devs = []\n\n        for bench, index in sorted(benchdata.items()):\n            for iname, entry in index.items():\n                row = [' ' + bench, iname]\n                for node in nodes:\n                    runtimes = node_runtimes[(node, bench, iname)]\n                    runtimes.sort(reverse=True)\n\n                    # highlight outliers to easily identify bad nodes\n                    highlighted = []\n                    for runtime, zscore, ofile in runtimes:\n                        rt = '%d' % round(runtime)\n                        deviation = runtime - entry.rt_mean\n                        deviation_ratio = abs(deviation) \/ entry.rt_mean\n\n                        if deviation ** 2 > entry.rt_variance * self.highlight_variance_deviation and \\\n                                deviation_ratio > self.highlight_percent_threshold:\n                            rt = colored(rt, 'red')\n                            high_devs.append((bench, node, iname, runtime, ofile))\n                        elif runtime == entry.rt_median:\n                            rt = colored(rt, 'blue', attrs=['bold'])\n\n                        highlighted.append(rt)\n\n                    row.append(','.join(highlighted))\n\n                data.append(row)\n\n        title = 'node runtimes'\n        if fancy:\n            title += ' (red = high deviation, blue = median)'\n        report_table(ctx, header, header, data, title)\n\n        # show measurements with high deviations in separate table with log file\n        # paths for easy access\n        if high_devs:\n            header = ['benchmark', 'node', 'instance', 'runtime', 'log file']\n            data = []\n            for bench, node, iname, runtime, ofile in high_devs:\n                nodename = node.replace('node', '')\n                opath = re.sub('^%s\/' % ctx.workdir, '', ofile)\n                data.append([bench, nodename, iname, runtime, opath])\n\n            print(file=ctx.args.outfile)\n            report_table(ctx, header, header, data, 'high deviations')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_220","text":"\"\"\"\n\nA class to carry localization data.\n\n\"\"\"\nimport copy\nimport logging\nimport time\nimport warnings\nfrom itertools import accumulate\n\nimport numpy as np\nimport pandas as pd\nfrom google.protobuf import json_format, text_format\n\ntry:\n    from scipy.spatial import QhullError\nexcept ImportError:\n    from scipy.spatial.qhull import QhullError  # needed for Python 3.7\n\nimport locan.data.hulls\nfrom locan import locdata_id  # is required to use locdata_id as global variable\nfrom locan.constants import PROPERTY_KEYS, PropertyKey\nfrom locan.data import metadata_pb2\nfrom locan.data.metadata_utils import _modify_meta, metadata_to_formatted_string\nfrom locan.data.region import Region, RoiRegion\n\n__all__ = [\"LocData\"]\n\nlogger = logging.getLogger(__name__)\n\n\nclass LocData:\n    \"\"\"\n    This class carries localization data, aggregated properties and meta data.\n\n    Data consist of individual elements being either localizations or other `LocData` objects. Both, localizations and\n    `Locdata` objects have properties. Properties come from the original data or are added by analysis procedures.\n\n    Parameters\n    ----------\n    references : LocData, list(LocData), None\n        A `LocData` reference or an array with references to `LocData` objects referring to the selected localizations\n        in dataset.\n    dataframe : pandas.DataFrame, None\n        Dataframe with localization data.\n    indices : slice object, list(int), None\n        Indices for dataframe in references that makes up the data. `indices` refers to index label, not position.\n    meta : locan.data.metadata_pb2.Metadata, dictionary\n        Metadata about the current dataset and its history.\n\n    Attributes\n    ----------\n    references : LocData, list(LocData), None\n        A LocData reference or an array with references to LocData objects referring to the selected localizations\n        in dataframe.\n    dataframe : pandas.DataFrame, None\n        Dataframe with localization data.\n    indices : slice object, list(int), None\n        Indices for dataframe in references that makes up the data.\n    meta : locan.data.metadata_pb2.Metadata\n        Metadata about the current dataset and its history.\n    properties : pandas.DataFrame\n        List of properties generated from data.\n    coordinate_labels : list of str\n        The available coordinate properties.\n    dimension : int\n        Number of coordinates available for each localization (i.e. size of `coordinate_labels`).\n    \"\"\"\n\n    count = 0\n    \"\"\"int: A counter for counting LocData instantiations (class attribute).\"\"\"\n\n    def __init__(\n        self, references=None, dataframe=pd.DataFrame(), indices=None, meta=None\n    ):\n        self.__class__.count += 1\n\n        self.references = references\n        self.dataframe = dataframe\n        self.indices = indices\n        self.meta = metadata_pb2.Metadata()\n        self.properties = {}\n\n        # regions and hulls\n        self._region = None\n        self._bounding_box = None\n        self._oriented_bounding_box = None\n        self._convex_hull = None\n        self._alpha_shape = None\n        self._inertia_moments = None\n\n        self.coordinate_labels = sorted(\n            list(\n                set(self.data.columns).intersection(\n                    {\"position_x\", \"position_y\", \"position_z\"}\n                )\n            )\n        )\n\n        self.dimension = len(self.coordinate_labels)\n\n        self._update_properties()\n\n        # meta\n        global locdata_id\n        locdata_id += 1\n        self.meta.identifier = str(locdata_id)\n\n        self.meta.creation_time.GetCurrentTime()\n        self.meta.source = metadata_pb2.DESIGN\n        self.meta.state = metadata_pb2.RAW\n\n        self.meta.element_count = len(self.data.index)\n        if \"frame\" in self.data.columns:\n            self.meta.frame_count = len(self.data[\"frame\"].unique())\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(self.meta, key, value)\n        else:\n            self.meta.MergeFrom(meta)\n\n    def _update_properties(self):\n        self.properties[\"localization_count\"] = len(self.data.index)\n\n        # property for mean spatial coordinates (centroids)\n        self.properties.update(dict(self.data[self.coordinate_labels].mean()))\n\n        self.bounding_box  # update self._bounding_box\n\n    def __del__(self):\n        \"\"\"Updating the counter upon deletion of class instance.\"\"\"\n        self.__class__.count -= 1\n\n    def __len__(self):\n        \"\"\"Return the length of data, i.e. the number of elements (localizations or collection elements).\"\"\"\n        return len(self.data.index)\n\n    def __getstate__(self):\n        \"\"\"Modify pickling behavior.\"\"\"\n        # Copy the object's state from self.__dict__ to avoid modifying the original state.\n        state = self.__dict__.copy()\n        # Serialize the unpicklable protobuf entries.\n        json_string = json_format.MessageToJson(\n            self.meta, including_default_value_fields=False\n        )\n        state[\"meta\"] = json_string\n        return state\n\n    def __setstate__(self, state):\n        \"\"\"Modify pickling behavior.\"\"\"\n        # Restore instance attributes.\n        self.__dict__.update(state)\n        # Restore protobuf class for meta attribute\n        self.meta = metadata_pb2.Metadata()\n        self.meta = json_format.Parse(state[\"meta\"], self.meta)\n\n    def __copy__(self):\n        \"\"\"\n        Create a shallow copy of locdata (keeping all references) with the following exceptions:\n        (i) The class variable `count` is increased for the copied LocData object.\n        (ii) Metadata keeps the original meta.creation_time while meta.modification_time and meta.history is updated.\n        \"\"\"\n        new_locdata = LocData(self.references, self.dataframe, self.indices, meta=None)\n        new_locdata._region = self._region\n        # meta\n        meta_ = _modify_meta(\n            self, new_locdata, function_name=\"LocData.copy\", parameter=None, meta=None\n        )\n        new_locdata.meta = meta_\n        return new_locdata\n\n    def __deepcopy__(self, memodict=None):\n        \"\"\"\n        Create a deep copy of locdata (including all references) with the following exceptions:\n        (i) The class variable `count` is increased for all deepcopied LocData objects.\n        (ii) Metadata keeps the original meta.creation_time while meta.modification_time and meta.history is updated.\n        \"\"\"\n        if memodict is None:\n            memodict = {}\n        new_locdata = LocData(\n            copy.deepcopy(self.references, memodict),\n            copy.deepcopy(self.dataframe, memodict),\n            copy.deepcopy(self.indices, memodict),\n            meta=None,\n        )\n        new_locdata._region = self._region\n        # meta\n        meta_ = _modify_meta(\n            self,\n            new_locdata,\n            function_name=\"LocData.deepcopy\",\n            parameter=None,\n            meta=None,\n        )\n        new_locdata.meta = meta_\n        return new_locdata\n\n    @property\n    def bounding_box(self):\n        \"\"\"Hull object: Return an object representing the axis-aligned minimal bounding box.\"\"\"\n        if self._bounding_box is None:\n            try:\n                self._bounding_box = locan.data.hulls.BoundingBox(self.coordinates)\n                self.properties[\"region_measure_bb\"] = self._bounding_box.region_measure\n                if self._bounding_box.region_measure:\n                    self.properties[\"localization_density_bb\"] = (\n                        self.properties[\"localization_count\"]\n                        \/ self._bounding_box.region_measure\n                    )\n                if self._bounding_box.subregion_measure:\n                    self.properties[\n                        \"subregion_measure_bb\"\n                    ] = self._bounding_box.subregion_measure\n            except ValueError:\n                warnings.warn(\n                    \"Properties related to bounding box could not be computed.\",\n                    UserWarning,\n                )\n        return self._bounding_box\n\n    @property\n    def convex_hull(self):\n        \"\"\"Hull object: Return an object representing the convex hull of all localizations.\"\"\"\n        if self._convex_hull is None:\n            try:\n                self._convex_hull = locan.data.hulls.ConvexHull(self.coordinates)\n                self.properties[\"region_measure_ch\"] = self._convex_hull.region_measure\n                if self._convex_hull.region_measure:\n                    self.properties[\"localization_density_ch\"] = (\n                        self.properties[\"localization_count\"]\n                        \/ self._convex_hull.region_measure\n                    )\n            except (TypeError, QhullError):\n                warnings.warn(\n                    \"Properties related to convex hull could not be computed.\",\n                    UserWarning,\n                )\n        return self._convex_hull\n\n    @property\n    def oriented_bounding_box(self):\n        \"\"\"Hull object: Return an object representing the oriented minimal bounding box.\"\"\"\n        if self._oriented_bounding_box is None:\n            try:\n                self._oriented_bounding_box = locan.data.hulls.OrientedBoundingBox(\n                    self.coordinates\n                )\n                self.properties[\n                    \"region_measure_obb\"\n                ] = self._oriented_bounding_box.region_measure\n                if self._oriented_bounding_box.region_measure:\n                    self.properties[\"localization_density_obb\"] = (\n                        self.properties[\"localization_count\"]\n                        \/ self._oriented_bounding_box.region_measure\n                    )\n                self.properties[\"orientation_obb\"] = self._oriented_bounding_box.angle\n                self.properties[\n                    \"circularity_obb\"\n                ] = self._oriented_bounding_box.elongation\n            except TypeError:\n                warnings.warn(\n                    \"Properties related to oriented bounding box could not be computed.\",\n                    UserWarning,\n                )\n        return self._oriented_bounding_box\n\n    @property\n    def alpha_shape(self):\n        \"\"\"Hull object: Return an object representing the alpha-shape of all localizations.\"\"\"\n        return self._alpha_shape\n\n    def update_alpha_shape(self, alpha):\n        \"\"\"Compute the alpha shape for specific `alpha` and update `self.alpha_shape`.\n\n        Parameters\n        ----------\n        alpha : float\n            Alpha parameter specifying a unique alpha complex.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        try:\n            if self._alpha_shape is None:\n                self._alpha_shape = locan.data.hulls.AlphaShape(\n                    points=self.coordinates, alpha=alpha\n                )\n            else:\n                self._alpha_shape.alpha = alpha\n\n            self.properties[\"region_measure_as\"] = self._alpha_shape.region_measure\n            try:\n                self.properties[\"localization_density_as\"] = (\n                    self._alpha_shape.n_points_alpha_shape\n                    \/ self._alpha_shape.region_measure\n                )\n            except ZeroDivisionError:\n                self.properties[\"localization_density_as\"] = float(\"nan\")\n\n        except TypeError:\n            warnings.warn(\n                \"Properties related to alpha shape could not be computed.\", UserWarning\n            )\n        return self\n\n    def update_alpha_shape_in_references(self, alpha):\n        \"\"\"\n        Compute the alpha shape for each element in `locdata.references` and update `locdata.dataframe`.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if isinstance(self.references, list):\n            for reference in self.references:\n                reference.update_alpha_shape(alpha=alpha)\n            new_df = pd.DataFrame(\n                [reference.properties for reference in self.references]\n            )\n            new_df.index = self.data.index\n            self.dataframe.update(new_df)\n            new_columns = [\n                column for column in new_df.columns if column in self.dataframe.columns\n            ]\n            new_df.drop(columns=new_columns, inplace=True, errors=\"ignore\")\n            self.dataframe = pd.concat([self.dataframe, new_df], axis=1)\n        return self\n\n    @property\n    def inertia_moments(self):\n        \"\"\"Inertia moments are returned as computed by :func:`locan.data.properties.inertia_moments`.\"\"\"\n        if self._inertia_moments is None:\n            try:\n                self._inertia_moments = locan.data.properties.inertia_moments(\n                    self.coordinates\n                )\n                self.properties[\"orientation_im\"] = self._inertia_moments.orientation\n                self.properties[\"circularity_im\"] = self._inertia_moments.eccentricity\n            except TypeError:\n                warnings.warn(\n                    \"Properties related to inertia_moments could not be computed.\",\n                    UserWarning,\n                )\n        return self._inertia_moments\n\n    def update_inertia_moments_in_references(self):\n        \"\"\"\n        Compute inertia_moments for each element in locdata.references and update locdata.dataframe.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if isinstance(self.references, list):\n            for reference in self.references:\n                reference.inertia_moments  # request property to update\n            new_df = pd.DataFrame(\n                [reference.properties for reference in self.references]\n            )\n            new_df.index = self.data.index\n            self.dataframe.update(new_df)\n            new_columns = [\n                column for column in new_df.columns if column in self.dataframe.columns\n            ]\n            new_df.drop(columns=new_columns, inplace=True, errors=\"ignore\")\n            self.dataframe = pd.concat([self.dataframe, new_df], axis=1)\n        return self\n\n    @property\n    def region(self):\n        \"\"\"RoiRegion object: Return the region that supports all localizations.\"\"\"\n        return self._region\n\n    @region.setter\n    def region(self, region):\n        if region is not None:\n            if region.dimension != self.dimension:\n                raise TypeError(\n                    \"Region dimension and coordinates dimension must be identical.\"\n                )\n            elif len(self) != len(region.contains(self.coordinates)):\n                logger.warning(\"Not all coordinates are within region.\")\n\n        if isinstance(region, (Region, RoiRegion)) or region is None:\n            self._region = region\n\n        elif isinstance(\n            region, dict\n        ):  # legacy code to deal with deprecated RoiLegacy_0\n            region_ = RoiRegion(**region)\n            if region_ is not None:\n                if region_.dimension != self.dimension:\n                    raise TypeError(\n                        \"Region dimension and coordinates dimension must be identical.\"\n                    )\n                elif len(self) != len(region_.contains(self.coordinates)):\n                    logger.warning(\"Not all coordinates are within region.\")\n            self._region = region_\n\n        else:\n            raise TypeError\n\n        # property for region measures\n        if self._region is not None:\n            if self._region.region_measure:\n                self.properties[\"region_measure\"] = self._region.region_measure\n                self.properties[\"localization_density\"] = (\n                    self.meta.element_count \/ self._region.region_measure\n                )\n            if self._region.subregion_measure:\n                self.properties[\"subregion_measure\"] = self._region.subregion_measure\n\n    @property\n    def data(self):\n        \"\"\"pandas.DataFrame: Return all elements either copied from the reference or referencing the current\n        dataframe. \"\"\"\n        if isinstance(self.references, LocData):\n            # we refer to the localization data by its index label, not position\n            # in other words we decided not to use iloc but loc\n            # df = self.references.data.loc[self.indices]  ... but this does not work in pandas.\n            # also see:\n            # https:\/\/pandas.pydata.org\/pandas-docs\/stable\/user_guide\/indexing.html#deprecate-loc-reindex-listlike\n            try:\n                df = self.references.data.loc[self.indices]\n            except KeyError:\n                df = self.references.data.loc[\n                    self.references.data.index.intersection(self.indices)\n                ]\n            df = pd.merge(\n                df, self.dataframe, left_index=True, right_index=True, how=\"outer\"\n            )\n            return df\n        else:\n            return self.dataframe\n\n    @property\n    def coordinates(self):\n        \"\"\"ndarray: Return all coordinate values. \"\"\"\n        return self.data[self.coordinate_labels].values\n\n    @property\n    def centroid(self):\n        \"\"\"ndarray: Return coordinate values of the centroid\n        (being the property values for all coordinate labels).\"\"\"\n        return np.array(\n            [\n                self.properties[coordinate_label]\n                for coordinate_label in self.coordinate_labels\n            ]\n        )\n\n    @classmethod\n    def from_dataframe(cls, dataframe=pd.DataFrame(), meta=None):\n        \"\"\"\n        Create new LocData object from pandas.DataFrame with localization data.\n\n        Parameters\n        ----------\n        dataframe : pandas.DataFrame\n            Localization data.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with dataframe representing the concatenated data.\n        \"\"\"\n        dataframe = dataframe\n        meta_ = metadata_pb2.Metadata()\n\n        meta_.source = metadata_pb2.DESIGN\n        meta_.state = metadata_pb2.RAW\n        meta_.history.add(name=\"LocData.from_dataframe\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        return cls(dataframe=dataframe, meta=meta_)\n\n    @classmethod\n    def from_coordinates(cls, coordinates=(), coordinate_labels=None, meta=None):\n        \"\"\"\n        Create new LocData object from a sequence of localization coordinates.\n\n        Parameters\n        ----------\n        coordinates : sequence of tuples with shape (n_loclizations, dimension)\n            Sequence of tuples with localization coordinates\n        coordinate_labels : sequence of str\n            The available coordinate properties.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with dataframe representing the concatenated data.\n        \"\"\"\n        if np.size(coordinates):\n            dimension = len(coordinates[0])\n\n            if coordinate_labels is None:\n                coordinate_labels = [\"position_x\", \"position_y\", \"position_z\"][\n                    0:dimension\n                ]\n            else:\n                if all(cl in PROPERTY_KEYS for cl in coordinate_labels):\n                    coordinate_labels = coordinate_labels\n                else:\n                    raise ValueError(\n                        \"The given coordinate_labels are not standard property keys.\"\n                    )\n\n            dataframe = pd.DataFrame.from_records(\n                data=coordinates, columns=coordinate_labels\n            )\n\n        else:\n            dataframe = pd.DataFrame()\n\n        meta_ = metadata_pb2.Metadata()\n        meta_.source = metadata_pb2.DESIGN\n        meta_.state = metadata_pb2.RAW\n        meta_.history.add(name=\"LocData.from_coordinates\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        return cls(dataframe=dataframe, meta=meta_)\n\n    @classmethod\n    def from_selection(cls, locdata, indices=slice(0, None), meta=None):\n        \"\"\"\n        Create new LocData object from selected elements in another `LocData`.\n\n        Parameters\n        ----------\n        locdata : LocData\n            Locdata object from which to select elements.\n        indices : slice object, list(int), None\n            Index labels for elements in locdata that make up the new data.\n            Note that contrary to usual python slices, both the start and the stop are included\n            (see pandas documentation). `Indices` refer to index value not position in list.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with dataframe representing the selected data.\n\n        Note\n        ----\n        No error is raised if indices do not exist in locdata.\n        \"\"\"\n        references = locdata\n        indices = indices\n        meta_ = metadata_pb2.Metadata()\n        meta_.CopyFrom(locdata.meta)\n        try:\n            meta_.ClearField(\"identifier\")\n        except ValueError:\n            pass\n\n        try:\n            meta_.ClearField(\"element_count\")\n        except ValueError:\n            pass\n\n        try:\n            meta_.ClearField(\"frame_count\")\n        except ValueError:\n            pass\n\n        meta_.modification_time.GetCurrentTime()\n        meta_.state = metadata_pb2.MODIFIED\n        meta_.ancestor_identifiers.append(locdata.meta.identifier)\n        meta_.history.add(name=\"LocData.from_selection\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        new_locdata = cls(references=references, indices=indices, meta=meta_)\n        new_locdata.region = references.region\n        return new_locdata\n\n    @classmethod\n    def from_collection(cls, locdatas, meta=None):\n        \"\"\"\n        Create new LocData object by collecting LocData objects.\n\n        Parameters\n        ----------\n        locdatas : list of LocData\n            Locdata objects to collect.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with dataframe representing the concatenated data.\n        \"\"\"\n        references = locdatas\n        dataframe = pd.DataFrame([ref.properties for ref in references])\n\n        meta_ = metadata_pb2.Metadata()\n\n        meta_.source = metadata_pb2.DESIGN\n        meta_.state = metadata_pb2.RAW\n        meta_.ancestor_identifiers[:] = [ref.meta.identifier for ref in references]\n        meta_.history.add(name=\"LocData.from_collection\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        return cls(references=references, dataframe=dataframe, meta=meta_)\n\n    @classmethod\n    def concat(cls, locdatas, meta=None):\n        \"\"\"\n        Concatenate LocData objects.\n\n        Parameters\n        ----------\n        locdatas : list of LocData\n            Locdata objects to concatenate.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with dataframe representing the concatenated data.\n        \"\"\"\n\n        dataframe = pd.concat([i.data for i in locdatas], ignore_index=True, sort=False)\n\n        # concatenate references also if None\n        references = []\n        for locdata in locdatas:\n            try:\n                references.extend(locdata.references)\n            except TypeError:\n                references.append(locdata.references)\n\n        # check if all elements are None\n        if not any(references):\n            references = None\n\n        meta_ = metadata_pb2.Metadata()\n\n        meta_.creation_time.GetCurrentTime()\n        meta_.source = metadata_pb2.DESIGN\n        meta_.state = metadata_pb2.MODIFIED\n        meta_.ancestor_identifiers[:] = [dat.meta.identifier for dat in locdatas]\n        meta_.history.add(name=\"concat\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        return cls(references=references, dataframe=dataframe, meta=meta_)\n\n    @classmethod\n    def from_chunks(\n        cls,\n        locdata,\n        chunks=None,\n        chunk_size=None,\n        n_chunks=None,\n        order=\"successive\",\n        drop=False,\n        meta=None,\n    ):\n        \"\"\"\n        Divide locdata in chunks of localization elements.\n\n        Parameters\n        ----------\n        locdatas : list of LocData\n            Locdata objects to concatenate.\n        chunks : list[tuples]\n            Localization chunks as defined by a list of index-tuples\n        chunk_size : int, None\n            Number of localizations per chunk. One of `chunk_size` or `n_chunks` must be different from None.\n        n_chunks : int, None\n            Number of chunks. One of `chunk_size` or `n_chunks` must be different from None.\n        order : str\n            The order in which to select localizations. One of 'successive' or 'alternating'.\n        drop : bool\n            If True the last chunk will be eliminated if it has fewer localizations than the other chunks.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            A new LocData instance with references and dataframe elements representing the individual chunks.\n        \"\"\"\n        n_nones = sum(element is None for element in [chunks, chunk_size, n_chunks])\n\n        if n_nones != 2:\n            raise ValueError(\n                \"One and only one of `chunks`, `chunk_size` or `n_chunks` must be different from None.\"\n            )\n        elif chunks is not None:\n            index_lists = list(chunks)\n        else:\n            if chunk_size is not None:\n                if (len(locdata) % chunk_size) == 0:\n                    n_chunks = len(locdata) \/\/ chunk_size\n                else:\n                    n_chunks = len(locdata) \/\/ chunk_size + 1\n            else:  # if n_chunks is not None\n                if (len(locdata) % n_chunks) == 0:\n                    chunk_size = len(locdata) \/\/ n_chunks\n                else:\n                    chunk_size = len(locdata) \/\/ (n_chunks - 1)\n\n            if order == \"successive\":\n                if (len(locdata) % chunk_size) == 0:\n                    chunk_sizes = [chunk_size] * n_chunks\n                else:\n                    chunk_sizes = [chunk_size] * (n_chunks - 1) + [\n                        (len(locdata) % chunk_size)\n                    ]\n                cum_chunk_sizes = list(accumulate(chunk_sizes))\n                cum_chunk_sizes.insert(0, 0)\n                index_lists = [\n                    locdata.data.index[slice(lower, upper)]\n                    for lower, upper in zip(cum_chunk_sizes[:-1], cum_chunk_sizes[1:])\n                ]\n\n            elif order == \"alternating\":\n                index_lists = [\n                    locdata.data.index[slice(i_chunk, None, n_chunks)]\n                    for i_chunk in range(n_chunks)\n                ]\n\n            else:\n                raise ValueError(f\"The order {order} is not implemented.\")\n\n        if drop and len(index_lists) > 1 and len(index_lists[-1]) < len(index_lists[0]):\n            index_lists = index_lists[:-1]\n\n        references = [\n            LocData.from_selection(locdata=locdata, indices=index_list)\n            for index_list in index_lists\n        ]\n        dataframe = pd.DataFrame([ref.properties for ref in references])\n\n        meta_ = metadata_pb2.Metadata()\n\n        meta_.creation_time.GetCurrentTime()\n        meta_.source = metadata_pb2.DESIGN\n        meta_.state = metadata_pb2.RAW\n        meta_.ancestor_identifiers[:] = [ref.meta.identifier for ref in references]\n        meta_.history.add(name=\"LocData.chunks\")\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(meta_, key, value)\n        else:\n            meta_.MergeFrom(meta)\n\n        return cls(references=references, dataframe=dataframe, meta=meta_)\n\n    def reset(self, reset_index=False):\n        \"\"\"\n        Reset hulls and properties. This is needed after the dataframe attribute has been modified in place.\n\n        Note\n        ----\n        Should be used with care because metadata is not updated accordingly.\n        The region property is not changed.\n        Better to just re-instantiate with `LocData.from_dataframe()` or use `locdata.update()`.\n\n        Parameters\n        ----------\n        reset_index : Bool\n            Flag indicating if the index is reset to integer values. If True the previous index values are discarded.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if reset_index is True:\n            self.dataframe.reset_index(drop=True, inplace=True)\n\n        self.properties = {}\n        self._bounding_box = None\n        self._oriented_bounding_box = None\n        self._convex_hull = None\n        self._alpha_shape = None\n\n        self._update_properties()\n\n        return self\n\n    def update(self, dataframe, reset_index=False, meta=None):\n        \"\"\"\n        Update the dataframe attribute in place.\n\n        Use this function rather than setting locdata.dataframe directly in order to automatically update\n        the attributes for dimension, coordinate_labels, hulls, properties, and metadata.\n\n        Parameters\n        ----------\n        dataframe : pandas.DataFrame, None\n            Dataframe with localization data.\n        reset_index : Bool\n            Flag indicating if the index is reset to integer values. If True the previous index values are discarded.\n        meta : locan.data.metadata_pb2.Metadata\n            Metadata about the current dataset and its history.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        local_parameter = locals()\n        del local_parameter[\n            \"dataframe\"\n        ]  # dataframe is obvious and possibly large and should not be repeated in meta.\n\n        if self.references is not None:\n            self.reduce(reset_index=reset_index)\n            logger.warning(\n                \"LocData.reduce() was applied since self.references was not None.\"\n            )\n\n        self.dataframe = dataframe\n        self.coordinate_labels = sorted(\n            list(\n                set(self.data.columns).intersection(\n                    {\"position_x\", \"position_y\", \"position_z\"}\n                )\n            )\n        )\n        self.dimension = len(self.coordinate_labels)\n        self.reset(reset_index=reset_index)  # update hulls and properties\n\n        # update meta\n        self.meta.modification_time.GetCurrentTime()\n        self.meta.state = metadata_pb2.MODIFIED\n        self.meta.history.add(name=\"LocData.update\", parameter=str(local_parameter))\n\n        self.meta.element_count = len(self.data.index)\n        if \"frame\" in self.data.columns:\n            self.meta.frame_count = len(self.data[\"frame\"].unique())\n\n        if meta is None:\n            pass\n        elif isinstance(meta, dict):\n            for key, value in meta.items():\n                setattr(self.meta, key, value)\n        else:\n            self.meta.MergeFrom(meta)\n\n        return self\n\n    def reduce(self, reset_index=False):\n        \"\"\"\n        Clean up references.\n\n        This includes to update `Locdata.dataframe` and set `LocData.references` and `LocData.indices` to None.\n\n        Parameters\n        ----------\n        reset_index : Bool\n            Flag indicating if the index is reset to integer values. If True the previous index values are discarded.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if self.references is None:\n            pass\n        elif isinstance(self.references, (LocData, list)):\n            self.dataframe = self.data\n            self.indices = None\n            self.references = None\n        else:\n            raise ValueError(\"references has undefined value.\")\n\n        if reset_index is True:\n            self.dataframe.reset_index(drop=True, inplace=True)\n\n        return self\n\n    def update_convex_hulls_in_references(self):\n        \"\"\"\n        Compute the convex hull for each element in locdata.references and update locdata.dataframe.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if isinstance(self.references, list):\n            for reference in self.references:\n                reference.convex_hull  # request property to update reference._convex_hull\n\n            new_df = pd.DataFrame(\n                [reference.properties for reference in self.references]\n            )\n            new_df.index = self.data.index\n            self.dataframe.update(new_df)\n            new_columns = [\n                column for column in new_df.columns if column in self.dataframe.columns\n            ]\n            new_df.drop(columns=new_columns, inplace=True, errors=\"ignore\")\n            self.dataframe = pd.concat([self.dataframe, new_df], axis=1)\n        return self\n\n    def update_oriented_bounding_box_in_references(self):\n        \"\"\"\n        Compute the oriented bounding box for each element in locdata.references and update locdata.dataframe.\n\n        Returns\n        -------\n        LocData\n            The modified object\n        \"\"\"\n        if isinstance(self.references, list):\n            for reference in self.references:\n                reference.oriented_bounding_box  # request property to update reference._convex_hull\n            new_df = pd.DataFrame(\n                [reference.properties for reference in self.references]\n            )\n            new_df.index = self.data.index\n            self.dataframe.update(new_df)\n            new_columns = [\n                column for column in new_df.columns if column in self.dataframe.columns\n            ]\n            new_df.drop(columns=new_columns, inplace=True, errors=\"ignore\")\n            self.dataframe = pd.concat([self.dataframe, new_df], axis=1)\n        return self\n\n    def projection(self, coordinate_labels):\n        \"\"\"\n        Reduce dimensions by projecting all localization coordinates onto selected coordinates.\n\n        Parameters\n        ----------\n        coordinate_labels : str, list\n            The coordinate labels to project onto.\n\n        Returns\n        -------\n            LocData\n        \"\"\"\n        local_parameter = locals()\n\n        if isinstance(coordinate_labels, str):\n            coordinate_labels = [coordinate_labels]\n\n        new_locdata = copy.deepcopy(self)\n\n        # reduce coordinate dimensions\n        coordinate_labels_to_drop = [\n            label for label in self.coordinate_labels if label not in coordinate_labels\n        ]\n        columns = self.data.columns\n        new_columns = [\n            column for column in columns if column not in coordinate_labels_to_drop\n        ]\n        dataframe = new_locdata.data[new_columns]\n\n        # update\n        _meta = metadata_pb2.Metadata()\n        _meta.history.add(name=\"LocData.projection\", parameter=str(local_parameter))\n        # other updates are done in the coming update call.\n\n        new_locdata = new_locdata.update(dataframe=dataframe, meta=_meta)\n\n        return new_locdata\n\n    def print_meta(self):\n        \"\"\"\n        Print Locdata.metadata.\n\n        See Also\n        --------\n        :func:`locan.data.metadata_utils.metadata_to_formatted_string`\n        \"\"\"\n        print(metadata_to_formatted_string(self.meta))\n\n    def print_summary(self):\n        \"\"\"\n        Print a summary containing the most common metadata keys.\n        \"\"\"\n        meta_ = metadata_pb2.Metadata()\n        if self.meta.HasField(\"file\"):\n            meta_.file.CopyFrom(self.meta.file)\n        meta_.identifier = self.meta.identifier\n        meta_.comment = self.meta.comment\n        meta_.creation_time.CopyFrom(self.meta.creation_time)\n        if self.meta.HasField(\"modification_time\"):\n            meta_.modification_time.CopyFrom(self.meta.modification_time)\n        meta_.source = self.meta.source\n        meta_.state = self.meta.state\n        meta_.element_count = self.meta.element_count\n        meta_.frame_count = self.meta.frame_count\n\n        print(metadata_to_formatted_string(meta_))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_221","text":"<gh_stars>1-10\n#!\/usr\/bin\/python\n\nimport sys\nimport time\nimport threading\nimport numpy\nimport string\nfrom math import sqrt,exp,log,pi,atan,sin\nfrom scipy.integrate import quad\n\n\ndef Calc_Lifetime(Pmed,param,I0,twiss,ex,ey,sigP,sigS):\n# float Pmed = residual gas pressure (nTorr)\n# Dicionary param = basic machine parameters\n# array I0,twiss,acc = current distribution(A), twiss parameters and momentum acceptance along the ring (%)\n# array ex,ey,sigP,sigS = Calculated values for emittances, energy spread and bunch length for each bunch\n\n\t#Twiss parameters\n\ts=numpy.zeros(len(twiss))\n\tbetax=numpy.zeros(len(twiss))\n\talphax=numpy.zeros(len(twiss))\n\tbetay=numpy.zeros(len(twiss))\n\talphay=numpy.zeros(len(twiss))\n\tDx=numpy.zeros(len(twiss))\n\tDpx=numpy.zeros(len(twiss))\n\tDy=numpy.zeros(len(twiss))\n\tDpy=numpy.zeros(len(twiss))\n\taccp=numpy.zeros(len(twiss))\n\taccn=numpy.zeros(len(twiss))\n\n\ts=twiss[:,0]\n\tbetax=twiss[:,2]\n\talphax=twiss[:,3]\n\tbetay=twiss[:,6]\n\talphay=twiss[:,7]\n\tDx=twiss[:,4]\n\tDpx=twiss[:,5]\n\tDy=twiss[:,8]\n\tDpy=twiss[:,9]\n\taccp=twiss[:,10]\n\taccn=twiss[:,11]\n\tDs=numpy.zeros(len(twiss))\n\tacc=numpy.zeros(len(twiss))\n\t\n\tDs=s-numpy.roll(s,1)\n\tDs[0]=0\n\tacc=numpy.minimum(accp,accn)\n\n\t#Calculate average beta functions\n\tbetax_avg=numpy.average(betax,weights=Ds)\n\tbetay_avg=numpy.average(betay,weights=Ds)\n\t#print \"<betax> = \",betax_avg\n\t#print \"<betay> = \",betay_avg\n\t#print \"<acc> = \",numpy.average(acc,weights=Ds)#, \"<accp> = \",numpy.average(accp,weights=Ds), \"<accn> = \",numpy.average(accn,weights=Ds) \n\n\t#Machine parameters\n\tC = param['C'] #Circunference (m)\n\tfrev=param['C']\/param['cluz'] #Rev. freq (Hz)\t\t\n\ttheta_x = sqrt(param['Ax']\/betax_avg)\n\ttheta_y = sqrt(param['Ay']\/betay_avg)\n\tR=theta_y\/theta_x\n\tFR=pi+(R**2+1.0)*sin(2*atan(R))+2.0*(R**2.0-1.0)*atan(R)\n\t\n\t#Elastic Scattering Lifetime\n\tTelas=10.25*2.0*pi\/FR*(param['En']\/1.0e+09)**2*param['Ay']\/(betay_avg*Pmed)\n\t\n\t#Inelastic Scattering Lifetime\n\tTine=1\/(0.0065*Pmed*log(1.\/(numpy.average(acc,weights=Ds))))\n\t\n\t#Touschek Lifetime Calculation\n\tsigx=numpy.zeros(len(twiss))\n\tsigy=numpy.zeros(len(twiss))\n\tepsilon=numpy.zeros(len(twiss))\n\tTv=numpy.zeros(len(twiss))\n\tdsdT=numpy.zeros(len(twiss)-1)\n\t\t\n\tsigx=numpy.sqrt(betax*ex+(Dx*sigP)**2)\n\tsigy=numpy.sqrt(betay*ey+(Dy*sigP)**2)\n\tepsilonp=(accp)**2*(betax\/ex)\/(1957.0*param['En']\/1.0e+09)**2\n\tepsilonn=(accn)**2*(betax\/ex)\/(1957.0*param['En']\/1.0e+09)**2\n\tTvp=(5.39e17*(param['En']\/1.0e+09)**2*(accp)**3*sigx*sigy*sigS\/(De(epsilonp)*C))**(-1.0)\n\tTvn=(5.39e17*(param['En']\/1.0e+09)**2*(accn)**3*sigx*sigy*sigS\/(De(epsilonn)*C))**(-1.0)\n \taux=0.5*(numpy.average(Tvp,weights=Ds)+numpy.average(Tvn,weights=Ds))\n \tTtous=1.0\/(aux*I0)\n\t \n\treturn (Ttous,Tine,Telas)\n\t\ndef Calc_Lifetime_Matlab(Pmed,param,twiss,ex,ey,sigP,sigS):\n# float Pmed = residual gas pressure (nTorr)\n# Dicionary param = basic machine parameters\n# array I0,twiss,acc = current distribution(A), twiss parameters and momentum acceptance along the ring (%)\n# array ex,ey,sigP,sigS = Calculated values for emittances, energy spread and bunch length for each bunch\n\n\t#Twiss parameters\n\ts=numpy.zeros(len(twiss))\n\tbetax=numpy.zeros(len(twiss))\n\talphax=numpy.zeros(len(twiss))\n\tbetay=numpy.zeros(len(twiss))\n\talphay=numpy.zeros(len(twiss))\n\tDx=numpy.zeros(len(twiss))\n\tDpx=numpy.zeros(len(twiss))\n\tDy=numpy.zeros(len(twiss))\n\tDpy=numpy.zeros(len(twiss))\n\taccp=numpy.zeros(len(twiss))\n\taccn=numpy.zeros(len(twiss))\n\n\ts=twiss[:,0]\n\tbetax=twiss[:,2]\n\talphax=twiss[:,3]\n\tbetay=twiss[:,6]\n\talphay=twiss[:,7]\n\tDx=twiss[:,4]\n\tDpx=twiss[:,5]\n\tDy=twiss[:,8]\n\tDpy=twiss[:,9]\n\taccp=twiss[:,10]\n\taccn=twiss[:,11]\n\tDs=numpy.zeros(len(twiss))\n\tacc=numpy.zeros(len(twiss))\n\t\n\tDs=s-numpy.roll(s,1)\n\tDs[0]=0\n\tacc=numpy.minimum(accp,accn)\n\n\t#Calculate average beta functions\n\tbetax_avg=numpy.average(betax,weights=Ds)\n\tbetay_avg=numpy.average(betay,weights=Ds)\n\t#print \"<betax> = \",betax_avg\n\t#print \"<betay> = \",betay_avg\n\t#print \"<acc> = \",numpy.average(acc,weights=Ds)#, \"<accp> = \",numpy.average(accp,weights=Ds), \"<accn> = \",numpy.average(accn,weights=Ds) \n\n\t#Machine parameters\n\tC = param['C'] #Circunference (m)\n\tfrev=param['C']\/param['cluz'] #Rev. freq (Hz)\t\n\tgamma=param['gamma']\n\tNp=param['Np']\t\n\ttheta_x = sqrt(param['Ax']\/betax_avg)\n\ttheta_y = sqrt(param['Ay']\/betay_avg)\n\tR=theta_y\/theta_x\n\tFR=pi+(R**2+1.0)*sin(2*atan(R))+2.0*(R**2.0-1.0)*atan(R)\n\t\n\t#Elastic Scattering Lifetime\n\tTelas=10.25*2.0*pi\/FR*(param['En']\/1.0e+09)**2*param['Ay']\/(betay_avg*Pmed)\n\t\n\t#Inelastic Scattering Lifetime\n\tTine=1\/(0.0065*Pmed*log(1.\/(numpy.average(acc,weights=Ds))))\n\t\n\t#Touschek Lifetime Calculation\n\tsigx=numpy.zeros(len(twiss))\n\tsigy=numpy.zeros(len(twiss))\n\tepsilon=numpy.zeros(len(twiss))\n\tTv=numpy.zeros(len(twiss))\n\tdsdT=numpy.zeros(len(twiss)-1)\n\t\n\t#bunch size and volume\n\tsigx=numpy.sqrt(betax*ex+(Dx*sigP)**2)\n\tsigy=numpy.sqrt(betay*ey+(Dy*sigP)**2)\n\tV=sigS*sigx*sigy\n\t\n\t# parameters\n\tSx2=ex*betax\n\tfactor=betax*Dpx+alphax*Dx\n\tA1=1.0\/(4.0*sigP**2)+(Dx**2+factor**2)\/(4.0*Sx2)\n\tB1=betax*factor\/(2.0*Sx2)\n\tC1=betax**2\/(4.0*Sx2)-B1**2\/(4.0*A1)\n\t\n\t#Epsilon factors\t\n\t#epsilonp=(2.0*numpy.sqrt(C1)\/gamma*accp)**2\n\t#epsilonn=(2.0*numpy.sqrt(C1)\/gamma*accn)**2\n\tepsilonp=(2.0*numpy.sqrt(C1)*accp)**2\/(1957.0*param['En']\/1.0e+09)**2\n\tepsilonn=(2.0*numpy.sqrt(C1)*accn)**2\/(1957.0*param['En']\/1.0e+09)**2\n\t\n\t\n\t#Lifetime\n\tTvp=9.4718e-23*Np\/(gamma**2)*1\/(accp**3)*De(epsilonp)\/V\n\tTvn=9.4718e-23*Np\/(gamma**2)*1\/(accn**3)*De(epsilonn)\/V\n \taux=0.5*(numpy.average(Tvp,weights=Ds)+numpy.average(Tvn,weights=Ds))*3600\n \tTtous=1.0\/aux\n\t \n\treturn (Ttous,Tine,Telas)\t\n\t\ndef De(e):\n\t\n\tout=numpy.zeros(len(e))\n\tfor j in range(len(e)):\n\t\t(int1,err1)=quad(integrand1,e[j],numpy.inf)\n\t\t(int2,err2)=quad(integrand2,e[j],numpy.inf)\n\t\tout[j]=0.5*sqrt(e[j])*(-3.0*exp(-e[j])+e[j]*int1+int2*(3.0*e[j]-e[j]*log(e[j])+2.0))\t\t\t\t\t\t\t\n\treturn out\n\t\ndef integrand1(x):\t\t\n\treturn log(x)\/x*exp(-x)\n\ndef integrand2(x):\n\treturn exp(-x)\/x\t"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_222","text":"import numpy as np\nimport libs.configs.config_v1 as cfg\nfrom PIL import Image, ImageFont, ImageDraw, ImageEnhance\nfrom scipy.misc import imresize\n\nFLAGS = cfg.FLAGS\n_DEBUG = False\n\ndef draw_img(step, image, name='', image_height=1, image_width=1, rois=None):\n    img = np.uint8(image\/0.1*127.0 + 127.0)\n    img = Image.fromarray(img)\n    return img.save(FLAGS.train_dir + 'test_' + name + '_' +  str(step) +'.jpg', 'JPEG')\n\ndef draw_bbox(step, image, name='', image_height=1, image_width=1, bbox=None, label=None, gt_label=None, mask=None, prob=None, iou=None, vis_th=0.5, vis_all=False, ignore_bg=True):\n    source_img = Image.fromarray(image)\n    b, g, r = source_img.split()\n    source_img = Image.merge(\"RGB\", (r, g, b))\n    draw = ImageDraw.Draw(source_img)\n    color = '#0000ff'\n    if mask is not None:\n        m = np.array(mask*255.0)\n        m = np.transpose(m,(0,3,1,2))\n    if bbox is not None:\n        for i, box in enumerate(bbox):\n            if label is not None and not np.all(box==0):\n                if prob is not None:\n                    if ((prob[i,label[i]] > vis_th) or (vis_all is True)) and ((ignore_bg is True) and (label[i] > 0)) :\n                        if gt_label is not None:\n                            if gt_label is not None and len(iou) > 1:\n                                text  = cat_id_to_cls_name(label[i]) + ' : ' + cat_id_to_cls_name(gt_label[i]) + ' : ' + str(iou[i])[:3]\n                            else:\n                                text  = cat_id_to_cls_name(label[i]) + ' : ' + cat_id_to_cls_name(gt_label[i]) + ' : ' + str(prob[i][label[i]])[:4]\n                            \n                            if label[i] != gt_label[i]:\n                                color = '#ff0000'#draw.text((2+bbox[i,0], 2+bbox[i,1]), cat_id_to_cls_name(label[i]) + ' : ' + cat_id_to_cls_name(gt_label[i]), fill='#ff0000')\n                            else:\n                                color = '#0000ff'  \n                        else: \n                            text = cat_id_to_cls_name(label[i]) + ' : ' +  \"{:.3f}\".format(prob[i][label[i]])  #str(i)#+\n                        draw.text((2+bbox[i,0], 2+bbox[i,1]), text, fill=color)\n\n                        if _DEBUG is True:\n                            print(\"plot\",label[i], prob[i,label[i]])\n                        draw.rectangle(box,fill=None,outline=color)\n\n                        if mask is not None:\n                            # print(\"mask number: \",i)\n                            box = np.floor(box).astype('uint16')\n                            bbox_w = box[2]-box[0]\n                            bbox_h = box[3]-box[1]\n                            mask_color_id = np.random.randint(35)\n                            color_img = color_id_to_color_code(mask_color_id)* np.ones((bbox_h,bbox_w,1)) * 255\n                            color_img = Image.fromarray(color_img.astype('uint8')).convert('RGBA')\n                            #color_img = Image.new(\"RGBA\", (bbox_w,bbox_h), np.random.rand(1,3) * 255 )\n                            resized_m = imresize(m[i][label[i]], [bbox_h, bbox_w], interp='bilinear') #label[i]\n                            resized_m[resized_m >= 128] = 128\n                            resized_m[resized_m < 128] = 0\n                            resized_m = Image.fromarray(resized_m.astype('uint8'), 'L')\n                            #print(box)\n                            #print(resized_m)\n                            \n                            source_img.paste(color_img , (box[0], box[1]), mask=resized_m)\n\n                        #return source_img.save(FLAGS.train_dir + 'est_imgs\/' + name + '_' +  str(step) +'.jpg', 'JPEG')\n                    \n                    else: \n                        if _DEBUG is True:\n                            print(\"skip\",label[i], prob[i,label[i]])\n                else:\n                    text = cat_id_to_cls_name(label[i])\n                    draw.text((2+bbox[i,0], 2+bbox[i,1]), text, fill=color)\n                    draw.rectangle(box,fill=None,outline=color)\n\n    return source_img.save(FLAGS.train_dir + 'est_imgs\/' + name + '_' +  str(step) +'.jpg', 'JPEG')\n\ndef cat_id_to_cls_name(catId):\n    cls_name = np.array([  'background', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n                       'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\n                       'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',\n                       'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',\n                       'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',\n                       'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',\n                       'baseball glove', 'skateboard', 'surfboard', 'tennis racket',\n                       'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',\n                       'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',\n                       'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',\n                       'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',\n                       'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',\n                       'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',\n                       'scissors', 'teddy bear', 'hair drier', 'toothbrush'])\n    return cls_name[catId]\n\ndef color_id_to_color_code(colorId):\n    color_code = np.array([[178, 31, 53],\n                           [216, 39, 53],\n                           [255, 116, 53],\n                           [255, 161, 53],\n                           [255, 203, 53],\n                           [255, 255, 53],\n                           [0, 117, 58],\n                           [0, 158, 71],\n                           [22, 221, 53],\n                           [0, 82, 165],\n                           [0, 121, 231],\n                           [0, 169, 252],\n                           [104, 30, 126],\n                           [125, 60, 181],\n                           [189, 122, 246],\n                           [234, 62, 112],\n                           [198, 44, 58],\n                           [243, 114, 82],\n                           [255, 130, 1],\n                           [255, 211, 92],\n                           [138, 151, 71],\n                           [2, 181, 160],\n                           [75, 196, 213],\n                           [149, 69, 103],\n                           [125, 9, 150],\n                           [169, 27, 176],\n                           [198, 30, 153],\n                           [207, 0, 99],\n                           [230, 21, 119],\n                           [243, 77, 154],\n                           [144, 33, 71],\n                           [223, 40, 35],\n                           [247, 106, 4],\n                           [206, 156, 72],\n                           [250, 194, 0],\n                           [254, 221, 39],\n                           ])\n    return color_code[colorId]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_223","text":"from __future__ import unicode_literals, division, print_function, absolute_import\nfrom builtins import object\nfrom collections import defaultdict\nfrom copy import deepcopy\nimport numpy as np\nfrom scipy.sparse import csr_matrix, lil_matrix\n\n\nclass ContextModel(object):\n\n    def __init__(self, sentences, min_count=5, window=5, wordlist=[], progress=1000, forward=True, backward=True):\n        \"\"\"\n        sentences: list\/generator of lists of words\n        in case this is based on a pretrained word2vec model, give the index2word attribute as wordlist\n\n        Attributes:\n            - min_count: how often a word has to occur at least\n            - window: how many words in a word's context should be considered\n            - word2index: {word:idx}\n            - index2word: [word1, word2, ...]\n            - wcounts: {word: frequency}\n            - featmat: n_voc x n_voc sparse array with weighted context word counts for every word\n            - progress: after how many sentences a progress printout should occur (default 1000)\n        \"\"\"\n        self.progress = progress\n        self.min_count = min_count\n        self.window = window\n        self.forward = forward\n        self.backward = backward\n        self.build_windex(sentences, wordlist)\n        self._get_raw_context_matrix(sentences)\n\n    def build_windex(self, sentences, wordlist=[]):\n        \"\"\"\n        go through all the sentences and get an overview of all used words and their frequencies\n        \"\"\"\n        # get an overview of the vocabulary\n        vocab = defaultdict(int)\n        for sentence_no, sentence in enumerate(sentences):\n            if not sentence_no % self.progress:\n                print(\"PROGRESS: at sentence #%i, processed %i words and %i unique words\" % (sentence_no, sum(vocab.values()), len(vocab)))\n            for word in sentence:\n                vocab[word] += 1\n        print(\"collected %i unique words from a corpus of %i words and %i sentences\" % (len(vocab), sum(vocab.values()), sentence_no + 1))\n        # assign a unique index to each word and remove all words with freq < min_count\n        self.wcounts, self.word2index, self.index2word = {}, {}, []\n        if not wordlist:\n            wordlist = [word for word, c in vocab.items() if c >= self.min_count]\n        for word in wordlist:\n            self.word2index[word] = len(self.word2index)\n            self.index2word.append(word)\n            self.wcounts[word] = vocab[word]\n\n    def _get_raw_context_matrix(self, sentences):\n        \"\"\"\n        compute the raw context matrix with weighted counts\n        it has an entry for every word in the vocabulary\n        \"\"\"\n        # make the feature matrix\n        featmat = lil_matrix((len(self.index2word), len(self.index2word)), dtype=float)\n        for sentence_no, sentence in enumerate(sentences):\n            if not sentence_no % self.progress:\n                print(\"PROGRESS: at sentence #%i\" % sentence_no)\n            sentence = [word if word in self.word2index else None for word in sentence]\n            # forward pass\n            if self.forward:\n                for i, word in enumerate(sentence[:-1]):\n                    if word:\n                        # get all words in the forward window\n                        wwords = sentence[i + 1:min(i + 1 + self.window, len(sentence))]\n                        for j, w in enumerate(wwords, 1):\n                            if w:\n                                featmat[self.word2index[word], self.word2index[w]] += 1.  # \/j\n            # backwards pass\n            if self.backward:\n                sentence_back = sentence[::-1]\n                for i, word in enumerate(sentence_back[:-1]):\n                    if word:\n                        # get all words in the forward window of the backwards sentence\n                        wwords = sentence_back[i + 1:min(i + 1 + self.window, len(sentence_back))]\n                        for j, w in enumerate(wwords, 1):\n                            if w:\n                                featmat[self.word2index[word], self.word2index[w]] += 1.  # \/j\n        print(\"PROGRESS: through with all the sentences\")\n        self.featmat = csr_matrix(featmat)\n\n    def get_context_matrix(self, fill_diag=True, norm='count'):\n        \"\"\"\n        for every word in the sentences, create a vector that contains the counts of its context words\n        (weighted by the distance to it with a max distance of window)\n        Inputs:\n            - norm: if the feature matrix should be normalized to contain ones on the diagonal\n                    (--> average context vectors)\n            - fill_diag: if diagonal of featmat should be filled with word counts\n        Returns:\n            - featmat: n_voc x n_voc sparse array with weighted context word counts for every word\n        \"\"\"\n        featmat = deepcopy(self.featmat)\n        # fill up the diagonals with the total counts of each word --> similarity matrix\n        if fill_diag:\n            featmat = lil_matrix(featmat)\n            for i, word in enumerate(self.index2word):\n                featmat[i, i] = self.wcounts[word]\n            featmat = csr_matrix(featmat)\n        assert ((featmat - featmat.transpose()).data**2).sum() < 2.220446049250313e-16, \"featmat not symmetric\"\n        # possibly normalize by the max counts\n        if norm in (\"count\", \"max\"):\n            normmat = lil_matrix(featmat.shape, dtype=float)\n            if norm == \"count\":\n                print(\"normalizing feature matrix by word count\")\n                normmat.setdiag([1. \/ self.wcounts[word] for word in self.index2word])\n            elif norm == \"max\":\n                print(\"normalizing feature matrix by max counts\")\n                normmat.setdiag([1. \/ v[0] if v[0] else 1. for v in featmat.max(axis=1).toarray()])\n            featmat = csr_matrix(normmat) * featmat  # row in featmat multiplied by entry on diagonal\n        return featmat\n\n    def get_local_context_matrix(self, tokens):\n        \"\"\"\n        compute a local context matrix. it has an entry for every token, even if it is not present in the vocabulary\n        Inputs:\n            - tokens: list of words\n        Returns:\n            - local_featmat: size len(set(tokens)) x n_vocab\n            - tok_idx: {word: index} to map the words from the tokens list to an index of the featmat\n        \"\"\"\n        # for every token we still only need one representation per document\n        tok_idx = {word: i for i, word in enumerate(set(tokens))}\n        featmat = lil_matrix((len(tok_idx), len(self.index2word)), dtype=float)\n        # clean out context words we don't know\n        known_tokens = [word if word in self.word2index else None for word in tokens]\n        # forward pass\n        if self.forward:\n            for i, word in enumerate(tokens[:-1]):\n                # get all words in the forward window\n                wwords = known_tokens[i + 1:min(i + 1 + self.window, len(known_tokens))]\n                for j, w in enumerate(wwords, 1):\n                    if w:\n                        featmat[tok_idx[word], self.word2index[w]] += 1. \/ j\n        # backwards pass\n        if self.backward:\n            tokens_back = tokens[::-1]\n            known_tokens_back = known_tokens[::-1]\n            for i, word in enumerate(tokens_back[:-1]):\n                # get all words in the forward window of the backwards sentence, incl. word itself\n                wwords = known_tokens_back[i + 1:min(i + 1 + self.window, len(known_tokens_back))]\n                for j, w in enumerate(wwords, 1):\n                    if w:\n                        featmat[tok_idx[word], self.word2index[w]] += 1. \/ j\n        featmat = csr_matrix(featmat)\n        # normalize matrix\n        normmat = lil_matrix((featmat.shape[0], featmat.shape[0]), dtype=float)\n        normmat.setdiag([1. \/ v[0] if v[0] else 1. for v in featmat.max(axis=1).toarray()])\n        featmat = csr_matrix(normmat) * featmat\n        return featmat, tok_idx\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_213","text":"from bs4 import BeautifulSoup as bs\nfrom label_navi import calLinkChaotic as clc\nfrom label_navi import calLinkRatio as clr\nimport scipy as sp\nimport numpy as np\nimport sys\nimport matplotlib.pyplot as plt\n\n\nfileName = sys.argv[1]\ndom = bs(open('..\/data\/en-original\/' + fileName))\n\nnodeList = []\nfor des in dom.descendants:\n    try:\n        if des.name != None and des.find_all('a'):\n            if ~np.isnan(clc(des)) and clc(des) >= 0:\n                nodeList.append([clc(des), clr(des), len(des.find_all('a')), des.name])\n    except:\n        print(des.name)\n        break\ndataList = []\nfor node in nodeList:\n    if node[2] > 1:\n        dataList.append( [node[0], node[1] ])\ndataList = np.array(dataList)\n\nprint(len(dataList))\n\nk = len(dataList)\nx = dataList[:,0]\ny = dataList[:,1]\n#n, bins, patches = P.hist(x, 10, histtype='step', stacked=True, fill=True)\n\nplt.scatter( range( 1, (k+1)), x )\n\nplt.grid()\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_215","text":"<reponame>davisidarta\/dynamo-release<filename>dynamo\/preprocessing\/utils.py\nimport numpy as np\nimport pandas as pd\nimport statsmodels.api as sm\nfrom scipy.sparse import issparse, csr_matrix\nimport warnings\n# from functools import reduce\nfrom sklearn.decomposition import PCA, TruncatedSVD\n\n\n# ---------------------------------------------------------------------------------------------------\n# symbol conversion related\ndef convert2gene_symbol(input_names, scopes='ensembl.gene'):\n    \"\"\"Convert ensemble gene id to official gene names using mygene package.\n\n    Parameters\n    ----------\n        input_names: list-like\n            The ensemble gene id names that you want to convert to official gene names. All names should come from the same\n            species.\n        scopes: `list-like` or `None` (default: `None`)\n            Scopes are needed when you use non-official gene name as your gene indices (or adata.var_name). This\n            arugument corresponds to type of types of identifiers, either a list or a comma-separated fields to specify\n            type of input qterms, e.g. “entrezgene”, “entrezgene,symbol”, [“ensemblgene”, “symbol”]. Refer to official\n            MyGene.info docs (https:\/\/docs.mygene.info\/en\/latest\/doc\/query_service.html#available_fields) for full list\n            of fields.\n\n    Returns\n    -------\n        var_pd: `pd.Dataframe`\n            A pandas dataframe that includes the following columns:\n            query: the input ensmble ids\n            _id: identified id from mygene\n            _score: confidence of the retrieved official gene name.\n            symbol: retrieved official gene name\n    \"\"\"\n\n    try:\n        import mygene\n    except ImportError:\n        raise ImportError(\"You need to install the package `mygene` (pip install mygene --user) \"\n                          \"See https:\/\/pypi.org\/project\/mygene\/ for more details.\")\n\n    import mygene\n    mg = mygene.MyGeneInfo()\n\n    ensemble_names = [i.split('.')[0] for i in input_names]\n    var_pd = mg.querymany(ensemble_names, scopes=scopes, fields='symbol', as_dataframe=True, df_index=True)\n    #var_pd.drop_duplicates(subset='query', inplace=True) # use when df_index is not True\n    var_pd = var_pd.loc[~var_pd.index.duplicated(keep='first')]\n\n    return var_pd\n\ndef convert2symbol(adata, scopes=None, subset=True):\n    if np.all(adata.var_names.str.startswith('ENS')) or scopes is not None:\n        prefix = adata.var_names[0]\n        if scopes is None:\n            if prefix[:4] == 'ENSG' or prefix[:7] == 'ENSMUSG':\n                scopes = 'ensembl.gene'\n            elif prefix[:4] == 'ENST' or prefix[:7] == 'ENSMUST':\n                scopes = 'ensembl.transcript'\n            else:\n                raise Exception('Your adata object uses non-official gene names as gene index. \\n'\n                                'Dynamo finds those IDs are neither from ensembl.gene or ensembl.transcript and thus cannot '\n                                'convert them automatically. \\n'\n                                'Please pass the correct scopes or first convert the ensemble ID to gene short name '\n                                '(for example, using mygene package). \\n'\n                                'See also dyn.pp.convert2gene_symbol')\n\n        adata.var['query'] = [i.split('.')[0] for i in adata.var.index]\n        if scopes is str:\n            adata.var[scopes] = adata.var.index\n        else:\n            adata.var['scopes'] = adata.var.index\n\n        warnings.warn('Your adata object uses non-official gene names as gene index. \\n'\n                      'Dynamo is converting those names to official gene names.')\n        official_gene_df = convert2gene_symbol(adata.var_names, scopes)\n        merge_df = adata.var.merge(official_gene_df, left_on='query', right_on='query', how='left').set_index(\n            adata.var.index)\n        adata.var = merge_df\n        valid_ind = np.where(merge_df['notfound'] != True)[0]\n\n        if subset:\n            adata._inplace_subset_var(valid_ind)\n            adata.var.index = adata.var['symbol'].values.copy()\n        else:\n            indices = np.array(adata.var.index)\n            indices[valid_ind] = adata.var.loc[valid_ind, 'symbol'].values.copy()\n            adata.var.index = indices\n\n    return adata\n\n# ---------------------------------------------------------------------------------------------------\n# implmentation of Cooks' distance (but this is for Poisson distribution fitting)\n\n# https:\/\/stackoverflow.com\/questions\/47686227\/poisson-regression-in-statsmodels-and-r\n\n# from __future__ import division, print_function\n\n# https:\/\/stats.stackexchange.com\/questions\/356053\/the-identity-link-function-does-not-respect-the-domain-of-the-gamma-family\ndef _weight_matrix(fitted_model):\n    \"\"\"Calculates weight matrix in Poisson regression\n\n    Parameters\n    ----------\n    fitted_model : statsmodel object\n        Fitted Poisson model\n\n    Returns\n    -------\n    W : 2d array-like\n        Diagonal weight matrix in Poisson regression\n    \"\"\"\n    return np.diag(fitted_model.fittedvalues)\n\n\ndef _hessian(X, W):\n    \"\"\"Hessian matrix calculated as -X'*W*X\n\n    Parameters\n    ----------\n    X : 2d array-like\n        Matrix of covariates\n\n    W : 2d array-like\n        Weight matrix\n\n    Returns\n    -------\n    hessian : 2d array-like\n        Hessian matrix\n    \"\"\"\n    return -np.dot(X.T, np.dot(W, X))\n\n\ndef _hat_matrix(X, W):\n    \"\"\"Calculate hat matrix = W^(1\/2) * X * (X'*W*X)^(-1) * X'*W^(1\/2)\n\n    Parameters\n    ----------\n    X : 2d array-like\n        Matrix of covariates\n\n    W : 2d array-like\n        Diagonal weight matrix\n\n    Returns\n    -------\n    hat : 2d array-like\n        Hat matrix\n    \"\"\"\n    # W^(1\/2)\n    Wsqrt = W ** (0.5)\n\n    # (X'*W*X)^(-1)\n    XtWX = -_hessian(X=X, W=W)\n    XtWX_inv = np.linalg.inv(XtWX)\n\n    # W^(1\/2)*X\n    WsqrtX = np.dot(Wsqrt, X)\n\n    # X'*W^(1\/2)\n    XtWsqrt = np.dot(X.T, Wsqrt)\n\n    return np.dot(WsqrtX, np.dot(XtWX_inv, XtWsqrt))\n\n\ndef cook_dist(model, X, good):\n    # Weight matrix\n    W = _weight_matrix(model)\n\n    # Hat matrix\n    H = _hat_matrix(X, W)\n    hii = np.diag(\n        H\n    )  # Diagonal values of hat matrix # fit.get_influence().hat_matrix_diag\n\n    # Pearson residuals\n    r = model.resid_pearson\n\n    # Cook's distance (formula used by R = (res\/(1 - hat))^2 * hat\/(dispersion * p))\n    # Note: dispersion is 1 since we aren't modeling overdispersion\n\n    resid = good.disp - model.predict(good)\n    rss = np.sum(resid ** 2)\n    MSE = rss \/ (good.shape[0] - 2)\n    # use the formula from: https:\/\/www.mathworks.com\/help\/stats\/cooks-distance.html\n    cooks_d = (\n        r ** 2 \/ (2 * MSE) * hii \/ (1 - hii) ** 2\n    )  # (r \/ (1 - hii)) ** 2 *  \/ (1 * 2)\n\n    return cooks_d\n\n\n# ---------------------------------------------------------------------------------------------------\n# preprocess utilities\ndef basic_stats(adata):\n    adata.obs['nGenes'], adata.obs['nCounts'] = (adata.X > 0).sum(1), (adata.X).sum(1)\n    mito_genes = adata.var_names.str.upper().str.startswith('MT-')\n    try:\n        adata.obs['pMito'] = (adata[:, mito_genes].X).sum(1).A1 \/ adata.obs['nCounts'] if issparse(adata.X) else  \\\n            (adata[:, mito_genes].X).sum(1) \/ adata.obs['nCounts']\n    except:\n        raise Exception(f\"looks like your var_names may be corrupted (i.e. include nan values)\")\n\n\ndef unique_var_obs_adata(adata):\n    \"\"\"Function to make the obs and var attribute's index unique\"\"\"\n    adata.obs_names_make_unique()\n    adata.var_names_make_unique()\n\n    return adata\n\n\ndef layers2csr(adata):\n    \"\"\"Function to make the obs and var attribute's index unique\"\"\"\n    for i in adata.layers.keys():\n        adata.layers[i] = csr_matrix(adata.layers[i]) if not issparse(adata.layers[i]) else adata.layers[i]\n\n    return adata\n\n\ndef merge_adata_attrs(adata_ori, adata, attr):\n    if attr == 'var':\n        _columns = set(adata.var.columns).difference(adata_ori.var.columns)\n        var_df = adata_ori.var.merge(adata.var[_columns], how='left',\n                                            left_index=True, right_index=True)\n        adata_ori.var = var_df.loc[adata_ori.var.index, :]\n    elif attr == 'obs':\n        _columns = set(adata.obs.columns).difference(adata_ori.obs.columns)\n        obs_df = adata_ori.obs.merge(adata.obs[_columns], how='left',\n                                            left_index=True, right_index=True)\n        adata_ori.obs = obs_df.loc[adata_ori.obs.index, :]\n\n    return adata_ori\n\n\ndef allowed_layer_raw_names():\n    only_splicing = ['spliced', 'unspliced']\n    only_labeling = ['new', 'total']\n    splicing_and_labeling = ['uu', 'ul', 'su', 'sl']\n\n    return only_splicing, only_labeling, splicing_and_labeling\n\n\ndef allowed_X_layer_names():\n    only_splicing = ['X_spliced', 'X_unspliced']\n    only_labeling = ['X_new', 'X_total']\n    splicing_and_labeling = ['X_uu', 'X_ul', 'X_su', 'X_sl']\n\n    return only_splicing, only_labeling, splicing_and_labeling\n\n\ndef get_layer_keys(adata, layers=\"all\", remove_normalized=True, include_protein=True):\n    \"\"\"Get the list of available layers' keys.\n    \"\"\"\n    layer_keys = list(adata.layers.keys())\n    if remove_normalized:\n        layer_keys = [i for i in layer_keys if not i.startswith(\"X_\")]\n\n    if \"protein\" in adata.obsm.keys() and include_protein:\n        layer_keys.extend([\"X\", \"protein\"])\n    else:\n        layer_keys.extend([\"X\"])\n    layers = (\n        layer_keys\n        if layers == \"all\"\n        else list(set(layer_keys).intersection(list(layers)))\n    )\n\n    layers = list(set(layers).difference([\"matrix\", \"ambiguous\", \"spanning\"]))\n    return layers\n\n\ndef get_shared_counts(adata, layers, min_shared_count, type=\"gene\"):\n    layers = list(set(layers).difference([\"X\", \"matrix\", \"ambiguous\", \"spanning\"]))\n    layers = np.array(layers)[~pd.DataFrame(layers)[0].str.startswith(\"X_\").values]\n\n    _nonzeros, _sum = None, None\n    for layer in layers:\n        if issparse(adata.layers[layers[0]]):\n            _nonzeros = (\n                adata.layers[layer] > 0\n                if _nonzeros is None\n                else _nonzeros.multiply(adata.layers[layer] > 0)\n            )\n        else:\n            _nonzeros = (\n                adata.layers[layer] > 0\n                if _nonzeros is None\n                else _nonzeros * (adata.layers[layer] > 0)\n            )\n\n    for layer in layers:\n        if issparse(adata.layers[layers[0]]):\n            _sum = (\n                _nonzeros.multiply(adata.layers[layer])\n                if _sum is None\n                else _sum + _nonzeros.multiply(adata.layers[layer])\n            )\n        else:\n            _sum = (\n                np.multiply(_nonzeros, adata.layers[layer])\n                if _sum is None\n                else _sum + np.multiply(_nonzeros, adata.layers[layer])\n            )\n\n    if type == \"gene\":\n        return (\n            np.array(_sum.sum(0).A1 >= min_shared_count)\n            if issparse(adata.layers[layers[0]])\n            else np.array(_sum.sum(0) >= min_shared_count)\n        )\n    if type == \"cells\":\n        return (\n            np.array(_sum.sum(1).A1 >= min_shared_count)\n            if issparse(adata.layers[layers[0]])\n            else np.array(_sum.sum(1) >= min_shared_count)\n        )\n\n\ndef clusters_stats(U, S, clusters_uid, cluster_ix, size_limit=40):\n    \"\"\"Calculate the averages per cluster\n\n    If the cluster is too small (size<size_limit) the average of the total is reported instead\n    This function is modified from velocyto in order to reproduce velocyto's DentateGyrus notebook.\n    \"\"\"\n    U_avgs = np.zeros((S.shape[1], len(clusters_uid)))\n    S_avgs = np.zeros((S.shape[1], len(clusters_uid)))\n    avgU_div_avgS = np.zeros((S.shape[1], len(clusters_uid)))\n    slopes_by_clust = np.zeros((S.shape[1], len(clusters_uid)))\n\n    for i, uid in enumerate(clusters_uid):\n        cluster_filter = cluster_ix == i\n        n_cells = np.sum(cluster_filter)\n        if n_cells > size_limit:\n            U_avgs[:, i], S_avgs[:, i] = (\n                U[cluster_filter, :].mean(0),\n                S[cluster_filter, :].mean(0),\n            )\n        else:\n            U_avgs[:, i], S_avgs[:, i] = U.mean(0), S.mean(0)\n\n    return U_avgs, S_avgs\n\n\ndef get_svr_filter(adata, layer=\"spliced\", n_top_genes=3000, return_adata=False):\n    score_name = \"score\" if layer in [\"X\", \"all\"] else layer + \"_score\"\n    valid_idx = np.where(np.isfinite(adata.var.loc[:, score_name]))[0]\n\n    valid_table = adata.var.iloc[valid_idx, :]\n    nth_score = np.sort(valid_table.loc[:, score_name])[::-1][\n        np.min((n_top_genes - 1, valid_table.shape[0] - 1))\n    ]\n\n    feature_gene_idx = np.where(valid_table.loc[:, score_name] >= nth_score)[0][\n        :n_top_genes\n    ]\n    feature_gene_idx = valid_idx[feature_gene_idx]\n\n    if return_adata:\n        adata.var.loc[:, \"use_for_pca\"] = False\n        adata.var.loc[adata.var.index[feature_gene_idx], \"use_for_pca\"] = True\n        res = adata\n    else:\n        filter_bool = np.zeros(adata.n_vars, dtype=bool)\n        filter_bool[feature_gene_idx] = True\n        res = filter_bool\n\n    return res\n\ndef sz_util(adata, layer, round_exprs, method, locfunc, total_layers=None, CM=None, scale_to=None):\n    adata = adata.copy()\n\n    if layer == '_total_' and '_total_' not in adata.layers.keys():\n        if total_layers is not None:\n            if not isinstance(total_layers, list): total_layers = [total_layers]\n            if len(set(total_layers).difference(adata.layers.keys())) == 0:\n                total = None\n                for t_key in total_layers:\n                    total = (\n                        adata.layers[t_key] if total is None else total + adata.layers[t_key]\n                    )\n                adata.layers[\"_total_\"] = total\n\n    if layer == \"raw\":\n        CM = adata.raw.X if CM is None else CM\n    elif layer == \"X\":\n        CM = adata.X if CM is None else CM\n    elif layer == \"protein\":\n        if \"protein\" in adata.obsm_keys():\n            CM = adata.obsm[\"protein\"] if CM is None else CM\n        else:\n            return None, None\n    else:\n        CM = adata.layers[layer] if CM is None else CM\n\n    if round_exprs:\n        if issparse(CM):\n            CM.data = np.round(CM.data, 0)\n        else:\n            CM = CM.round().astype(\"int\")\n\n    cell_total = CM.sum(axis=1).A1 if issparse(CM) else CM.sum(axis=1)\n    cell_total += cell_total == 0  # avoid infinity value after log (0)\n\n    if method in [\"mean-geometric-mean-total\", 'geometric']:\n        sfs = cell_total \/ (np.exp(locfunc(np.log(cell_total))) if scale_to is None else scale_to)\n    elif method == \"median\":\n        sfs = cell_total \/ (np.nanmedian(cell_total) if scale_to is None else scale_to)\n    elif method == \"mean\":\n        sfs = cell_total \/ (np.nanmean(cell_total) if scale_to is None else scale_to)\n    else:\n        raise NotImplementedError(f\"This method {method} is not supported!\")\n\n    return sfs, cell_total\n\ndef get_sz_exprs(adata, layer, total_szfactor=None):\n    if layer == \"raw\":\n        CM = adata.raw.X\n        szfactors = adata.obs[layer + \"Size_Factor\"].values[:, None]\n    elif layer == \"X\":\n        CM = adata.X\n        szfactors = adata.obs[\"Size_Factor\"].values[:, None]\n    elif layer == \"protein\":\n        if \"protein\" in adata.obsm_keys():\n            CM = adata.obsm[layer]\n            szfactors = adata.obs[\"protein_Size_Factor\"].values[:, None]\n        else:\n            CM, szfactors = None, None\n    else:\n        CM = adata.layers[layer]\n        szfactors = adata.obs[layer + \"_Size_Factor\"].values[:, None]\n\n    if total_szfactor is not None and total_szfactor in adata.obs.keys():\n        szfactors = adata.obs[total_szfactor][:, None]\n    else:\n        warnings.warn(\"{total_szfactor} is not None but it is not in adata object.\")\n\n    return szfactors, CM\n\ndef normalize_util(CM, szfactors, relative_expr, pseudo_expr, norm_method=np.log1p):\n    if norm_method == np.log1p: pseudo_expr = 0\n    if relative_expr:\n        CM = (\n            CM.multiply(csr_matrix(1 \/ szfactors))\n            if issparse(CM)\n            else CM \/ szfactors\n        )\n\n    if pseudo_expr is None:\n        pseudo_expr = 1\n    if issparse(CM):\n        CM.data = (\n            norm_method(CM.data + pseudo_expr)\n            if norm_method is not None\n            else CM.data\n        )\n        if norm_method is not None and norm_method.__name__ == 'Freeman_Tukey': CM.data -= 1\n    else:\n        CM = (\n            norm_method(CM + pseudo_expr)\n            if norm_method is not None\n            else CM\n        )\n\n    return CM\n\n\ndef Freeman_Tukey(X, inverse=False):\n    if inverse:\n        res = np.sqrt(X) + np.sqrt((X + 1))\n    else:\n        res = (X**2 - 1)**2 \/ (4 * X**2)\n\n    return res\n\n# ---------------------------------------------------------------------------------------------------\n# pca\n\n\ndef pca(adata, CM, n_pca_components=30, pca_key='X', pcs_key='PCs'):\n\n    if adata.n_obs < 100000:\n        pca = PCA(n_components=min(n_pca_components, CM.shape[1] - 1), svd_solver=\"arpack\", random_state=0)\n        fit = pca.fit(CM.toarray()) if issparse(CM) else pca.fit(CM)\n        X_pca = fit.transform(CM.toarray()) if issparse(CM) else fit.transform(CM)\n        adata.obsm[pca_key] = X_pca\n        adata.uns[pcs_key] = fit.components_.T\n\n        adata.uns[\"explained_variance_ratio_\"] = fit.explained_variance_ratio_\n    else:\n        # unscaled PCA\n        fit = TruncatedSVD(\n            n_components=min(n_pca_components + 1, CM.shape[1] - 1), random_state=0\n        )\n        # first columns is related to the total UMI (or library size)\n        X_pca = fit.fit_transform(CM)[:, 1:]\n        adata.obsm[pca_key] = X_pca\n        adata.uns[pcs_key] = fit.components_.T\n\n        adata.uns[\"explained_variance_ratio_\"] = fit.explained_variance_ratio_[1:]\n\n    return adata, fit, X_pca\n\n\ndef pca_genes(PCs, n_top_genes=100):\n    ret = np.zeros(PCs.shape[0], dtype=bool)\n    for q in PCs.T:\n        qq = np.sort(np.abs(q))[::-1]\n        idx = np.abs(q) > qq[n_top_genes]\n        ret = np.logical_or(idx, ret)\n    return ret\n\n\ndef add_noise_to_duplicates(adata, basis='pca'):\n    X_data = adata.obsm['X_' + basis]\n    min_val = abs(X_data).min()\n\n    n_obs, n_var = X_data.shape\n    while(True):\n        _, index = np.unique(X_data, axis=0, return_index=True)\n        duplicated_idx = np.setdiff1d(np.arange(n_obs), index)\n\n        if len(duplicated_idx) == 0:\n            adata.obsm['X_' + basis] = X_data\n            break\n        else:\n            X_data[duplicated_idx, :] += np.random.normal(0, min_val \/ 1000, (len(duplicated_idx), n_var))\n\n\n# ---------------------------------------------------------------------------------------------------\n# labeling related\n\n\ndef collapse_adata(adata):\n    \"\"\"Function to collapse the four species data, will be generalized to handle dual-datasets\"\"\"\n    only_splicing, only_labeling, splicing_and_labeling = allowed_layer_raw_names()\n\n    if np.all([i in adata.layers.keys() for i in splicing_and_labeling]):\n        if only_splicing[0] not in adata.layers.keys(): adata.layers[only_splicing[0]] = adata.layers['su'] + adata.layers['sl']\n        if only_splicing[1] not in adata.layers.keys(): adata.layers[only_splicing[1]] = adata.layers['uu'] + adata.layers['ul']\n        if only_labeling[0] not in adata.layers.keys(): adata.layers[only_labeling[0]] = adata.layers['ul'] + adata.layers['sl']\n        if only_labeling[1] not in adata.layers.keys(): adata.layers[only_labeling[1]] = adata.layers[only_labeling[0]] + adata.layers['uu'] + adata.layers['su']\n\n    return adata\n\ndef detect_datatype(adata):\n    has_splicing, has_labeling, has_protein = False, False, False\n\n    layers = adata.layers.keys()\n    if len({'ul', 'sl', 'uu', 'su'}.difference(layers)) == 0:\n        has_splicing, has_labeling = True, True\n    elif len({'unspliced', 'spliced'}.difference(layers)) == 0:\n        has_splicing = True\n    elif len({'new', 'total'}.difference(layers)) == 0:\n        has_labeling = True\n\n    if \"protein\" in adata.obsm.keys():\n        has_protein = True\n\n    return has_splicing, has_labeling, has_protein\n\n\ndef default_layer(adata):\n    has_splicing, has_labeling, _ = detect_datatype(adata)\n\n    if has_splicing:\n        if has_labeling:\n            if len(set(adata.layers.keys()).intersection(['new', 'total', 'spliced', 'unspliced'])) == 4:\n                adata = collapse_adata(adata)\n            default_layer = \"M_t\" if \"M_t\" in adata.layers.keys() else \"X_total\" if \\\n                \"X_total\" in adata.layers.keys() else \"total\"\n        else:\n            default_layer = \"M_s\" if \"M_s\" in adata.layers.keys() else \"X_spliced\" if \\\n                \"X_spliced\" in adata.layers.keys() else \"spliced\"\n    else:\n        default_layer = \"M_t\" if \"M_t\" in adata.layers.keys() else \"X_total\" if \\\n            \"X_total\" in adata.layers.keys() else \"total\"\n\n    return default_layer\n\ndef NTR(adata):\n    \"\"\"calculate the new to total ratio across cells. Note that\n    NTR for the first time point in degradation approximates gamma\/beta.\"\"\"\n\n    if len({'new', 'total'}.intersection(adata.layers.keys())) == 2:\n        ntr = adata.layers['new'].sum(1) \/ adata.layers['total'].sum(1)\n        ntr = ntr.A1 if issparse(adata.layers['new']) else ntr\n\n        var_ntr = adata.layers['new'].sum(0) \/ adata.layers['total'].sum(0)\n        var_ntr = var_ntr.A1 if issparse(adata.layers['new']) else var_ntr\n    elif len({'uu', 'ul', 'su', 'sl'}.intersection(adata.layers.keys())) == 4:\n        new = adata.layers['ul'].sum(1) + \\\n              adata.layers['sl'].sum(1)\n        total = new + adata.layers['uu'].sum(1) + \\\n                adata.layers['su'].sum(1)\n        ntr = new \/ total\n\n        ntr = ntr.A1 if issparse(adata.layers['uu']) else ntr\n\n        new = adata.layers['ul'].sum(0) + \\\n              adata.layers['sl'].sum(0)\n        total = new + adata.layers['uu'].sum(0) + \\\n                adata.layers['su'].sum(0)\n        var_ntr = new \/ total\n\n        var_ntr = var_ntr.A1 if issparse(adata.layers['uu']) else var_ntr\n    elif len({'unspliced', 'spliced'}.intersection(adata.layers.keys())) == 2:\n        with warnings.catch_warnings():\n            warnings.simplefilter(\"ignore\")\n            \n            ntr = adata.layers['unspliced'].sum(1) \/ (adata.layers['unspliced'] + adata.layers['spliced']).sum(1)\n            var_ntr = adata.layers['unspliced'].sum(0) \/ (adata.layers['unspliced'] + adata.layers['spliced']).sum(0)\n\n        ntr = ntr.A1 if issparse(adata.layers['unspliced']) else ntr\n        var_ntr = var_ntr.A1 if issparse(adata.layers['unspliced']) else var_ntr\n    else:\n        ntr, var_ntr = None, None\n\n    return ntr, var_ntr\n\n\ndef scale(adata, layers=None, scale_to_layer=None, scale_to=1e6):\n    \"\"\"scale layers to a particular total expression value, similar to `normalize_expr_data` function.\"\"\"\n    layers = get_layer_keys(adata, layers)\n    has_splicing, has_labeling, _ = detect_datatype(adata)\n\n    if scale_to_layer is None:\n        scale_to_layer = 'total' if has_labeling else None\n        scale = scale_to \/ adata.layers[scale_to_layer].sum(1)\n    else:\n        scale = None\n\n    for layer in layers:\n        if scale is None:\n            scale = scale_to \/ adata.layers[layer].sum(1)\n\n        adata.layers[layer] = csr_matrix(adata.layers[layer].multiply(scale))\n\n    return adata\n\n# ---------------------------------------------------------------------------------------------------\n# ERCC related\n\ndef relative2abs(adata,\n                 dilution,\n                 volume,\n                 from_layer=None,\n                 to_layers=None,\n                 mixture_type=1,\n                 ERCC_controls=None,\n                 ERCC_annotation=None):\n    \"\"\"Converts FPKM\/TPM data to transcript counts using ERCC spike-in. This is based on the relative2abs function from\n    monocle 2 (Qiu, et. al, Nature Methods, 2017).\n\n    Parameters\n    ----------\n        adata: :class:`~anndata.AnnData`\n            an Annodata object\n        dilution: `float`\n            the dilution of the spikein transcript in the lysis reaction mix. Default is 40, 000. The number of spike-in\n            transcripts per single-cell lysis reaction was calculated from.\n        volume: `float`\n            the approximate volume of the lysis chamber (nanoliters). Default is 10\n        from_layer: `str` or `None`\n            The layer in which the ERCC TPM values will be used as the covariate for the ERCC based linear regression.\n        to_layers: `str`, `None` or `list-like`\n            The layers that our ERCC based transformation will be applied to.\n        mixture_type:\n            the type of spikein transcripts from the spikein mixture added in the experiments. By default, it is mixture 1.\n            Note that m\/c we inferred are also based on mixture 1.\n        ERCC_controls:\n            the FPKM\/TPM matrix for each ERCC spike-in transcript in the cells if user wants to perform the transformation based\n            on their spike-in data. Note that the row and column names should match up with the ERCC_annotation and relative_\n            exprs_matrix respectively.\n        ERCC_annotation:\n            the ERCC_annotation matrix from illumina USE GUIDE which will be ued for calculating the ERCC transcript copy\n            number for performing the transformation.\n\n    Returns\n    -------\n        An adata object with the data specified in the to_layers transformed into absolute counts.\n    \"\"\"\n\n    if ERCC_annotation is None:\n        ERCC_annotation = pd.read_csv('https:\/\/www.dropbox.com\/s\/cmiuthdw5tt76o5\/ERCC_specification.txt?dl=1', sep='\\t')\n\n    ERCC_id = ERCC_annotation['ERCC ID']\n\n    ERCC_id = adata.var_names.intersection(ERCC_id)\n    if len(ERCC_id) < 10 and ERCC_controls is None:\n        raise Exception(f'The adata object you provided has less than 10 ERCC genes.')\n\n    if to_layers is not None:\n        to_layers = [to_layers] if to_layers is str else to_layers\n        to_layers = list(set(adata.layers.keys()).intersection(to_layers))\n        if len(to_layers) == 0:\n            raise Exception(f\"The layers {to_layers} that will be converted to absolute counts doesn't match any layers\"\n                            f\"from the adata object.\")\n\n    mixture_name = \"concentration in Mix 1 (attomoles\/ul)\" if mixture_type == 1 else \"concentration in Mix 2 (attomoles\/ul)\"\n    ERCC_annotation['numMolecules'] = ERCC_annotation.loc[:, mixture_name] * (\n                volume * 10 ** (-3) * 1 \/ dilution * 10 ** (-18) * 6.02214129 * 10 ** (23))\n\n    ERCC_annotation['rounded_numMolecules'] = ERCC_annotation['numMolecules'].astype(int)\n\n    if from_layer in [None, 'X']:\n        X, X_ercc = (adata.X, adata[:, ERCC_id].X if ERCC_controls is None else ERCC_controls)\n    else:\n        X, X_ercc = (adata.layers[from_layer], adata[:, ERCC_id] \\\n            if ERCC_controls is None else ERCC_controls)\n\n    logged = False if X.max() > 100 else True\n\n    if not logged:\n        X, X_ercc = (np.log1p(X.A) if issparse(X_ercc) else np.log1p(X), \\\n                     np.log1p(X_ercc.A) if issparse(X_ercc) else np.log1p(X_ercc))\n    else:\n        X, X_ercc = (X.A if issparse(X_ercc) else X, X_ercc.A if issparse(X_ercc) else X_ercc)\n\n    y = np.log1p(ERCC_annotation['numMolecules'])\n\n    for i in range(adata.n_obs):\n        X_i, X_ercc_i = X[i, :], X_ercc[i, :]\n\n        X_i, X_ercc_i = sm.add_constant(X_i),  sm.add_constant(X_ercc_i)\n        res = sm.RLM(y, X_ercc_i).fit()\n        k, b = res.params[::-1]\n\n        if to_layers is None:\n            X = adata.X\n            logged = False if X.max() > 100 else True\n\n            if not logged:\n                X_i = np.log1p(X[i, :].A) if issparse(X) else np.log1p(X[i, :])\n            else:\n                X_i = X[i, :].A if issparse(X) else X[i, :]\n\n            res = k * X_i + b\n            res = res if logged else np.expm1(res)\n            adata.X[i, :] = csr_matrix(res) if issparse(X) else res\n        else:\n            for cur_layer in to_layers:\n                X = adata.layers[cur_layer]\n\n                logged = False if X.max() > 100 else True\n                if not logged:\n                    X_i = np.log1p(X[i, :].A) if issparse(X) else np.log1p(X[i, :])\n                else:\n                    X_i = X[i, :].A if issparse(X) else X[i, :]\n\n                res = k * X_i + b if logged else np.expm1(k * X_i + b)\n                adata.layers[cur_layer][i, :] = csr_matrix(res) if issparse(X) else res\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_217","text":"#! \/usr\/bin\/env python3\n\nimport numpy as np\nfrom scipy.stats import loguniform, truncnorm\nimport argparse\n\nparser = argparse.ArgumentParser(description=\"Generate initial (random) sample grid\")\nparser.add_argument(\"--fixed-parameter\", nargs=2, action=\"append\", help=\"Fix a parameter's value, e.g. `--fixed-parameter dist 40.0`\")\nparser.add_argument(\"--set-limit\", nargs=3, action=\"append\", help=\"Set a parameter's limits to something other than the default, e.g. `--set-limit mej_dyn 0.01, 0.05`\")\nparser.add_argument(\"--npts\", type=int, default=25000, help=\"Number of points to use in the grid\")\nparser.add_argument(\"--output-file\", help=\"Filename to save grid to\")\nparser.add_argument(\"--gaussian-prior\", action=\"append\", nargs=3, help=\"Give a parameter a Gaussian prior, specifying the mean and standard deviation; for example, `--gaussian-prior theta 20.0 5.0`\")\nargs = parser.parse_args()\n\n#\n# Prior functions\n#\n\ndef uniform(llim, rlim, x):\n    return 1. \/ (rlim - llim)\n\ndef log_uniform(llim, rlim, x):\n    return loguniform.pdf(x, llim, rlim)\n\ndef gaussian(llim, rlim, mu, sigma, x):\n    return truncnorm.pdf(x, llim, rlim, loc=mu, scale=sigma)\n   \n#\n# Functions to draw samples from the priors\n#\ndef sample_uniform(llim, rlim, n):\n    return np.random.uniform(llim, rlim, size=n)\n\ndef sample_log_uniform(llim, rlim, n):\n    return loguniform.rvs(llim, rlim, size=n)\n\ndef sample_gaussian(llim, rlim, mu, sigma, n):\n    return truncnorm.rvs(llim, rlim, loc=mu, scale=sigma, size=n)\n\n# the parameters FIXME: should this be more flexible?\nordered_parameters = [\"mej_dyn\", \"vej_dyn\", \"mej_wind\", \"vej_wind\", \"theta\"]\n\n# Parameter limits\nlimits = {\n        \"mej_dyn\":[0.001, 0.1],\n        \"vej_dyn\":[0.05, 0.3],\n        \"mej_wind\":[0.001, 0.1],\n        \"vej_wind\":[0.05, 0.3],\n        \"theta\":[0., 90.]\n}\n\n# If the user specified different limits, change them accordingly\nif args.set_limit is not None:\n    for [_parameter, _llim, _rlim] in args.set_limit:\n        limits[_parameter] = [float(_llim), float(_rlim)]\n\n\n# Specify each parameter's prior\nprior_functions = {\n        \"mej_dyn\":lambda x: log_uniform(*limits[\"mej_dyn\"], x),\n        \"vej_dyn\":lambda x: uniform(*limits[\"vej_dyn\"], x),\n        \"mej_wind\":lambda x: log_uniform(*limits[\"mej_wind\"], x),\n        \"vej_wind\":lambda x: uniform(*limits[\"vej_wind\"], x),\n        \"theta\":lambda x: uniform(*limits[\"theta\"], x)\n}\n\n# Specify each parameter's prior sampling function\nprior_sampling_functions = {\n        \"mej_dyn\":lambda n: sample_log_uniform(*limits[\"mej_dyn\"], n),\n        \"vej_dyn\":lambda n: sample_uniform(*limits[\"vej_dyn\"], n),\n        \"mej_wind\":lambda n: sample_log_uniform(*limits[\"mej_wind\"], n),\n        \"vej_wind\":lambda n: sample_uniform(*limits[\"vej_wind\"], n),\n        \"theta\":lambda n: sample_uniform(*limits[\"theta\"], n)\n}\n\n# Deal with possible fixed parameters\nfixed_parameters = {}\nif args.fixed_parameter is not None:\n    for [_parameter, _val] in args.fixed_parameter:\n        fixed_parameters[_parameter] = float(_val)\n\n# Gaussian priors\nif args.gaussian_prior is not None:\n    for [_parameter, _mu, _sigma] in args.gaussian_prior:\n        _mu, _sigma = float(_mu), float(_sigma)\n        a, b = (limits[_parameter][0] - _mu) \/ _sigma, (limits[_parameter][1] - _mu) \/ _sigma\n        prior_functions[_parameter] = lambda x: gaussian(a, b, _mu, _sigma, x)\n        prior_sampling_functions[_parameter] = lambda n: sample_gaussian(a, b, _mu, _sigma, n)\n\n#\n# Generate the grid\n#\n\ngrid = np.empty((args.npts, len(ordered_parameters) + 3))\n\n# The first column, for lnL, gets filled in later (by generate_posterior_samples.py), so for now make it 0\ngrid[:,0] = 0.\n\n# The second and third columns are the prior and sampling prior, respectively, which are the same for the initial grid.\n# The joint prior is the product of all the separate priors, so we'll set them to 1 now and multiply them by each parameter's prior in the loop.\ngrid[:,1] = 0.\n\n# Do the sampling and compute priors\nfor i, _parameter in enumerate(ordered_parameters):\n    grid[:,i + 3] = prior_sampling_functions[_parameter](args.npts) if _parameter not in fixed_parameters.keys() else fixed_parameters[_parameter]\n    grid[:,1] += np.log(prior_functions[_parameter](grid[:,i + 3]))\ngrid[:,2] = grid[:,1]\n\n# Save the grid\nnp.savetxt(args.output_file, grid, header=(\"ln(L) ln(p) ln(ps) \" + \" \".join(ordered_parameters)))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_64","text":"<filename>env.py\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nfrom scipy.io import loadmat, savemat\nimport networkx as nx\nimport numpy as np\n# import matplotlib.pyplot as plt\n\n\nclass Topology(object):\n    def __init__(self, config, data_dir='.\/data\/'):\n        self.topology_file = data_dir + 'topo\/' + config.topology_file\n        self.shortest_paths_file = self.topology_file + '_shortest_paths'\n        self.DG = nx.DiGraph()\n\n        self.load_topology()\n        self.calculate_paths()\n\n    def load_topology(self):\n        print('[*] Loading topology...', self.topology_file)\n        f = open(self.topology_file, 'r')\n        header = f.readline()\n        header = header.split('\\t')\n        self.num_nodes = int(header[1])\n        self.num_links = int(header[3])\n        f.readline()\n        self.link_idx_to_sd = {}\n        self.link_sd_to_idx = {}\n        self.link_capacities = np.empty((self.num_links))\n        self.link_weights = np.empty((self.num_links))\n        for line in f:\n            link = line.split('\\t')\n            i, s, d, w, c = link\n            self.link_idx_to_sd[int(i)] = (int(s), int(d))\n            self.link_sd_to_idx[(int(s), int(d))] = int(i)\n            self.link_capacities[int(i)] = float(c)\n            self.link_weights[int(i)] = int(w)\n            self.DG.add_weighted_edges_from([(int(s), int(d), int(w))])\n\n        assert len(self.DG.nodes()) == self.num_nodes and len(self.DG.edges()) == self.num_links\n\n        f.close()\n        # print('nodes: %d, links: %d\\n'%(self.num_nodes, self.num_links))\n\n        # nx.draw_networkx(self.DG)\n        # plt.show()\n\n    def calculate_paths(self):\n        self.pair_idx_to_sd = []\n        self.pair_sd_to_idx = {}\n        # Shortest paths\n        self.shortest_paths = []\n        if os.path.exists(self.shortest_paths_file):\n            print('[*] Loading shortest paths...', self.shortest_paths_file)\n            f = open(self.shortest_paths_file, 'r')\n            self.num_pairs = 0\n            for line in f:\n                sd = line[:line.find(':')]\n                s = int(sd[:sd.find('-')])\n                d = int(sd[sd.find('>') + 1:])\n                self.pair_idx_to_sd.append((s, d))\n                self.pair_sd_to_idx[(s, d)] = self.num_pairs\n                self.num_pairs += 1\n                self.shortest_paths.append([])\n                paths = line[line.find(':') + 1:].strip()[1:-1]\n                while paths != '':\n                    idx = paths.find(']')\n                    path = paths[1:idx]\n                    node_path = np.array(path.split(',')).astype(np.int16)\n                    assert node_path.size == np.unique(node_path).size\n                    self.shortest_paths[-1].append(node_path)\n                    paths = paths[idx + 3:]\n        else:\n            print('[!] Calculating shortest paths...')\n            f = open(self.shortest_paths_file, 'w+')\n            self.num_pairs = 0\n            for s in range(self.num_nodes):\n                for d in range(self.num_nodes):\n                    if s != d:\n                        self.pair_idx_to_sd.append((s, d))\n                        self.pair_sd_to_idx[(s, d)] = self.num_pairs\n                        self.num_pairs += 1\n                        self.shortest_paths.append(list(nx.all_shortest_paths(self.DG, s, d, weight='weight')))\n                        line = str(s) + '->' + str(d) + ': ' + str(self.shortest_paths[-1])\n                        f.writelines(line + '\\n')\n\n        assert self.num_pairs == self.num_nodes * (self.num_nodes - 1)\n        f.close()\n\n        print('pairs: %d, nodes: %d, links: %d\\n' \\\n              % (self.num_pairs, self.num_nodes, self.num_links))\n\n\nclass Traffic(object):\n    def __init__(self, config, num_nodes, data_dir='..\/data\/', is_training=False):\n        self.num_nodes = num_nodes\n\n        splitted_data_fname = os.path.join(data_dir, 'splitted_data\/{}.mat'.format(config.dataset))\n        if not os.path.isfile(splitted_data_fname):\n            self.split_data_from_mat(data_dir=data_dir, dataset=config.dataset)\n\n        print('Load data from ', splitted_data_fname)\n        data = loadmat(splitted_data_fname)\n        if is_training:\n            traffic_matrices = data['train']\n        else:\n            traffic_matrices = data['test']\n\n        tms_shape = traffic_matrices.shape\n        self.tm_cnt = tms_shape[0]\n        self.traffic_matrices = np.reshape(traffic_matrices, newshape=(self.tm_cnt, num_nodes, num_nodes))\n        self.traffic_file = splitted_data_fname\n        print('Traffic matrices dims: [%d, %d, %d]\\n' % (self.traffic_matrices.shape[0],\n                                                         self.traffic_matrices.shape[1],\n                                                         self.traffic_matrices.shape[2]))\n\n    @staticmethod\n    def remove_outliers(data):\n        q25, q75 = np.percentile(data, 25, axis=0), np.percentile(data, 75, axis=0)\n        iqr = q75 - q25\n        cut_off = iqr * 3\n        lower, upper = q25 - cut_off, q75 + cut_off\n        for i in range(data.shape[1]):\n            flow = data[:, i]\n            flow[flow > upper[i]] = upper[i]\n            # flow[flow < lower[i]] = lower[i]\n            data[:, i] = flow\n\n        return data\n\n    def train_test_split(self, X, dataset):\n        if 'abilene' in dataset:\n            train_size = 4 * 7 * 288  # 4 weeks\n            val_size = 288 * 7  # 1 week\n            test_size = 288 * 7 * 2  # 2 weeks\n        elif 'geant' in dataset:\n            train_size = 96 * 7 * 4 * 2  # 2 months\n            val_size = 96 * 7 * 2  # 2 weeks\n            test_size = 96 * 7 * 4  # 1 month\n        elif 'brain' in dataset:\n            train_size = 1440 * 3  # 3 days\n            val_size = 1440  # 1 day\n            test_size = 1440 * 2  # 2 days\n        elif 'uninett' in dataset:  # granularity: 5 min\n            train_size = 4 * 7 * 288  # 4 weeks\n            val_size = 288 * 7  # 1 week\n            test_size = 288 * 7 * 2  # 2 weeks\n        elif 'renater_tm' in dataset:  # granularity: 5 min\n            train_size = 4 * 7 * 288  # 4 weeks\n            val_size = 288 * 7  # 1 week\n            test_size = 288 * 7 * 2  # 2 weeks\n        else:\n            raise NotImplementedError\n\n        X_train = X[:train_size]\n\n        X_val = X[train_size:val_size + train_size]\n\n        X_test = X[val_size + train_size: val_size + train_size + test_size]\n\n        if 'abilene' in dataset or 'geant' in dataset or 'brain' in dataset:\n            X_train = self.remove_outliers(X_train)\n            X_val = self.remove_outliers(X_val)\n\n        print('Raw data:')\n        print('X_train: ', X_train.shape)\n        print('X_val: ', X_val.shape)\n        print('X_test: ', X_test.shape)\n\n        return X_train, X_val, X_test\n\n    def split_data_from_mat(self, data_dir, dataset):\n        X = self.load_raw(data_dir=data_dir, dataset=dataset)\n        train, val, test = self.train_test_split(X, dataset)\n        savepath = os.path.join(data_dir, 'splitted_data\/')\n        if not os.path.exists(savepath):\n            os.makedirs(savepath)\n\n        savepathfile = os.path.join(savepath, '{}.mat'.format(dataset))\n        savemat(savepathfile, {'train': train,\n                               'val': val,\n                               'test': test})\n\n    @staticmethod\n    def load_raw(data_dir, dataset):\n        # load raw data\n        data_path = os.path.join(data_dir, 'data\/{}.mat'.format(dataset))\n        X = loadmat(data_path)['X']\n        X = np.reshape(X, newshape=(X.shape[0], -1))\n        return X\n\n    def load_traffic_from_mat(self, config):\n        pass\n\n    def load_traffic(self, config):\n        assert os.path.exists(self.traffic_file)\n        print('[*] Loading traffic matrices...', self.traffic_file)\n        f = open(self.traffic_file, 'r')\n        traffic_matrices = []\n        for line in f:\n            volumes = line.strip().split(' ')\n            total_volume_cnt = len(volumes)\n            assert total_volume_cnt == self.num_nodes * self.num_nodes\n            matrix = np.zeros((self.num_nodes, self.num_nodes))\n            for v in range(total_volume_cnt):\n                i = int(v \/ self.num_nodes)\n                j = v % self.num_nodes\n                if i != j:\n                    matrix[i][j] = float(volumes[v])\n            # print(matrix + '\\n')\n            traffic_matrices.append(matrix)\n\n        f.close()\n        self.traffic_matrices = np.array(traffic_matrices)\n\n        tms_shape = self.traffic_matrices.shape\n        self.tm_cnt = tms_shape[0]\n        print('Traffic matrices dims: [%d, %d, %d]\\n' % (tms_shape[0], tms_shape[1], tms_shape[2]))\n\n\nclass Environment(object):\n    def __init__(self, config, is_training=False):\n        self.data_dir = config.data_dir\n        self.topology = Topology(config, self.data_dir)\n        self.traffic = Traffic(config, self.topology.num_nodes, self.data_dir, is_training=is_training)\n        self.traffic_matrices = self.traffic.traffic_matrices  # kbps\n        # self.traffic_matrices = self.traffic.traffic_matrices * 100 * 8 \/ 300 \/ 1000  # kbps\n        self.tm_cnt = self.traffic.tm_cnt\n        self.traffic_file = self.traffic.traffic_file\n        self.num_pairs = self.topology.num_pairs\n        self.pair_idx_to_sd = self.topology.pair_idx_to_sd\n        self.pair_sd_to_idx = self.topology.pair_sd_to_idx\n        self.num_nodes = self.topology.num_nodes\n        self.num_links = self.topology.num_links\n        self.link_idx_to_sd = self.topology.link_idx_to_sd\n        self.link_sd_to_idx = self.topology.link_sd_to_idx\n        self.link_capacities = self.topology.link_capacities\n        self.link_weights = self.topology.link_weights\n        self.shortest_paths_node = self.topology.shortest_paths  # paths consist of nodes\n        self.shortest_paths_link = self.convert_to_edge_path(self.shortest_paths_node)  # paths consist of links\n\n    def convert_to_edge_path(self, node_paths):\n        edge_paths = []\n        num_pairs = len(node_paths)\n        for i in range(num_pairs):\n            edge_paths.append([])\n            num_paths = len(node_paths[i])\n            for j in range(num_paths):\n                edge_paths[i].append([])\n                path_len = len(node_paths[i][j])\n                for n in range(path_len - 1):\n                    e = self.link_sd_to_idx[(node_paths[i][j][n], node_paths[i][j][n + 1])]\n                    assert e >= 0 and e < self.num_links\n                    edge_paths[i][j].append(e)\n                # print(i, j, edge_paths[i][j])\n\n        return edge_paths\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_65","text":"<gh_stars>0\nfrom datetime import datetime\nimport time\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.interpolate import interp1d\nfrom scipy.signal import butter, lfilter\n\n__author__ = \"<NAME>\"\n__version__ = \"Version 0.9\"\n\nmeasures = {}\nworking_data = {}\n\n#Data handling\ndef get_data(filename, delim = ',', column_name = 'None'):\n\tfile_ext = filename.split('.')[-1]\n\tif file_ext == 'csv' or file_ext == 'txt':\n\t\tif (column_name != 'None'):\n\t\t\thrdata = np.genfromtxt(filename, delimiter=delim, names=True, dtype=None)\n\t\t\ttry:\n\t\t\t\thrdata = hrdata[column_name]\n\t\t\texcept:\n\t\t\t\tprint('\\nError loading column \"%s\" from file \"%s\". Is column name specified correctly?' %(column_name, filename))\n\t\telif (column_name == 'None'):\n\t\t\thrdata = np.genfromtxt(filename, delimiter=delim, dtype = np.float64)\n\t\telse:\n\t\t\tprint('\\nError: column name \"%s\" not found in header of \"%s\".\\n' %(column_name, filename))\n\telif file_ext == 'mat':\n\t\tprint('getting matlab file')\n\t\timport scipy.io\n\t\tdata = scipy.io.loadmat(filename)\n\t\tif (column_name != \"None\"):\n\t\t\thrdata = np.array(data[column_name][:,0], dtype=np.float64)\n\t\telse:\n\t\t\tprint(\"\\nError: column name required for Matlab .mat files\\n\\n\")\n\telse:\n\t\tprint('unknown file format')\n\t\thrdata = np.nan\n\treturn hrdata\n\n#Preprocessing\ndef get_samplerate_mstimer(timerdata):\n\tfs = ((len(timerdata) \/ (timerdata[-1]-timerdata[0]))*1000)\n\tworking_data['fs'] = fs\n\treturn fs\n\ndef get_samplerate_datetime(datetimedata, timeformat='%H:%M:%S.%f'):\n\telapsed = ((datetime.strptime(datetimedata[-1], timeformat) - datetime.strptime(datetimedata[0], timeformat)).total_seconds())\n\tfs = (len(datetimedata) \/ elapsed)\n\tworking_data['fs'] = fs\n\treturn fs\n\ndef rollwindow(x, window):\n\tshape = x.shape[:-1] + (x.shape[-1] - window + 1, window)\n\tstrides = x.strides + (x.strides[-1],)\n\treturn np.lib.stride_tricks.as_strided(x, shape=shape, strides=strides)\n\ndef rolmean(hrdata, hrw, fs):\n\tavg_hr = (np.mean(hrdata)) \n\thrarr = np.array(hrdata)\n\trol_mean = np.mean(rollwindow(hrarr, int(hrw*fs)), axis=1)\n\tln = np.array([avg_hr for i in range(0,abs(len(hrarr)-len(rol_mean))\/2)])\n\trol_mean = np.insert(rol_mean, 0, ln)\n\trol_mean = np.append(rol_mean, ln)\n\trol_mean = rol_mean * 1.1\n\treturn rol_mean\n\ndef butter_lowpass(cutoff, fs, order=5):\n\tnyq = 0.5 * fs\n\tnormal_cutoff = cutoff \/ nyq\n\tb, a = butter(order, normal_cutoff, btype='low', analog=False)\n\treturn b, a\n\ndef butter_lowpass_filter(hrdata, cutoff, fs, order):\n\tb, a = butter_lowpass(cutoff, fs, order=order)\n\ty = lfilter(b, a, hrdata)\n\treturn y    \n\ndef filtersignal(hrdata, cutoff, fs, order):\n\thr = np.power(np.array(hrdata), 3)\n\thrfiltered = butter_lowpass_filter(hr, cutoff, fs, order)\n\treturn hrfiltered\n\n#Peak detection\ndef detect_peaks(hrdata, rol_mean, ma_perc, fs):\n\trm = np.array(rol_mean)\n\trolmean = rm+((rm\/100)*ma_perc)\n\tpeaksx = np.where((hrdata > rolmean))[0]\n\tpeaksy = hrdata[np.where((hrdata > rolmean))[0]]\n\tpeakedges = np.concatenate((np.array([0]), (np.where(np.diff(peaksx) > 1)[0]), np.array([len(peaksx)])))\n\tpeaklist = []\n\tybeat = []\n\n\tfor i in range(0, len(peakedges)-1):\n\t\ttry:\n\t\t\ty = peaksy[peakedges[i]:peakedges[i+1]].tolist()\n\t\t\tpeaklist.append(peaksx[peakedges[i] + y.index(max(y))])\n\t\texcept:\n\t\t\tpass\n\t\n\tworking_data['peaklist'] = peaklist\n\tworking_data['ybeat'] = [hrdata[x] for x in peaklist]\n\tworking_data['rolmean'] = rolmean\n\tcalc_RR(fs)\n\tif len(working_data['RR_list']):\n\t\tworking_data['rrsd'] = np.std(working_data['RR_list'])\n\telse:\n\t\tworking_data['rrsd'] = np.inf\n\ndef fit_peaks(hrdata, rol_mean, fs):\n\tma_perc_list = [5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 150, 200, 300]\n\trrsd = []\n\tvalid_ma = []\n\tfor x in ma_perc_list:\n\t\tdetect_peaks(hrdata, rol_mean, x, fs)\n\t\tbpm = ((len(working_data['peaklist'])\/(len(working_data['hr'])\/fs))*60)\n\t\trrsd.append([working_data['rrsd'], bpm, x])\n\n\tfor x,y,z in rrsd:\n\t\tif ((x > 1) and ((y > 40) and (y < 150))):\n\t\t\tvalid_ma.append([x, z])\n\t\n\tworking_data['best'] = min(valid_ma, key = lambda t: t[0])[1]\n\tdetect_peaks(hrdata, rol_mean, min(valid_ma, key = lambda t: t[0])[1], fs)\n\ndef check_peaks():\n\tRR_arr = np.array(working_data['RR_list'])\n\tpeaklist = np.array(working_data['peaklist'])\n\tpeaklist2 = working_data['peaklist']\n\tybeat = np.array(working_data['ybeat'])\n\tupper_threshold = np.mean(RR_arr) + 300\n\tlower_threshold = np.mean(RR_arr) - 300\n\tworking_data['RR_list_cor'] = RR_arr[np.where((RR_arr > lower_threshold) & (RR_arr < upper_threshold))]\n\tpeaklist_cor = peaklist[np.where((RR_arr > lower_threshold) & (RR_arr < upper_threshold))[0]+1]\n\tworking_data['peaklist_cor'] = np.insert(peaklist_cor, 0, peaklist[0])\n\tworking_data['removed_beats'] = peaklist[np.where((RR_arr <= lower_threshold) | (RR_arr >= upper_threshold))[0]+1]\n\tworking_data['removed_beats_y'] = removed_beats_y = ybeat[np.where((RR_arr <= lower_threshold) | (RR_arr >= upper_threshold))[0]+1]\n\n#Calculating all measures\ndef calc_RR(fs):\n\tpeaklist = np.array(working_data['peaklist'])\n\tRR_list = (np.diff(peaklist) \/ fs) * 1000.0\n\tRR_diff = np.abs(np.diff(RR_list))\n\tRR_sqdiff = np.power(RR_diff, 2)\n\tworking_data['RR_list'] = RR_list\n\tworking_data['RR_diff'] = RR_diff\n\tworking_data['RR_sqdiff'] = RR_sqdiff\n\t\ndef calc_ts_measures():\n\tRR_list = working_data['RR_list_cor']\n\tRR_diff = working_data['RR_diff']\n\tRR_sqdiff = working_data['RR_sqdiff']\n\tmeasures['bpm'] = 60000 \/ np.mean(RR_list)\n\tmeasures['ibi'] = np.mean(RR_list)\n\tmeasures['sdnn'] = np.std(RR_list)\n\tmeasures['sdsd'] = np.std(RR_diff)\n\tmeasures['rmssd'] = np.sqrt(np.mean(RR_sqdiff))\n\tNN20 = [x for x in RR_diff if (x>20)]\n\tNN50 = [x for x in RR_diff if (x>50)]\n\tmeasures['nn20'] = NN20\n\tmeasures['nn50'] = NN50\n\tmeasures['pnn20'] = float(len(NN20)) \/ float(len(RR_diff))\n\tmeasures['pnn50'] = float(len(NN50)) \/ float(len(RR_diff))\n\tmeasures['hr_mad'] = np.median(np.abs(RR_list-np.median(RR_list)))\n\ndef calc_fd_measures(hrdata, fs):\n\tpeaklist = working_data['peaklist_cor']\n\tRR_list = working_data['RR_list_cor']\n\tRR_x = peaklist[1:]\n\tRR_y = RR_list\n\tRR_x_new = np.linspace(RR_x[0],RR_x[-1],RR_x[-1])\n\tf = interp1d(RR_x, RR_y, kind='cubic')\n\tn = len(hrdata)\n\tfrq = np.fft.fftfreq(len(hrdata), d=((1\/fs)))\n\tfrq = frq[range(n\/2)]\n\tY = np.fft.fft(f(RR_x_new))\/n\n\tY = Y[range(n\/2)]\n\tmeasures['lf'] = np.trapz(abs(Y[(frq>=0.04) & (frq<=0.15)]))\n\tmeasures['hf'] = np.trapz(abs(Y[(frq>=0.16) & (frq<=0.5)]))\n\tmeasures['lf\/hf'] = measures['lf'] \/ measures['hf']\n\n#Plotting it\ndef plotter(show=True, title='Heart Rate Signal Peak Detection'):\n\tpeaklist = working_data['peaklist']\n\tybeat = working_data['ybeat']\n\trejectedpeaks = working_data['removed_beats']\n\trejectedpeaks_y = working_data['removed_beats_y']\n\tplt.title(title)\n\tplt.plot(working_data['hr'], alpha=0.5, color='blue', label='heart rate signal')\n\tplt.scatter(peaklist, ybeat, color='green', label='BPM:%.2f' %(measures['bpm']))\n\tplt.scatter(rejectedpeaks, rejectedpeaks_y, color='red', label='rejected peaks')\n\tplt.legend(loc=4, framealpha=0.6) \n\tif show == True:\n\t\tplt.show() \n\telse:\n\t\treturn plt\n\n#Wrapper function\ndef process(hrdata, fs, hrw = 0.75):\n\tt1 = time.clock()\n\thrdata = filtersignal(hrdata, 4, fs, 5)\n\tworking_data['hr'] = hrdata\n\tprint(hrdata)\n\trol_mean = rolmean(hrdata, hrw, fs)\n\tfit_peaks(hrdata, rol_mean, fs)\n\tcalc_RR(fs)\n\tcheck_peaks()\n\tcalc_ts_measures()\n\tcalc_fd_measures(hrdata, fs)\n\tprint('\\nFinished in %.4fsec' %(time.clock()-t1))\n\treturn measures\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_67","text":"<filename>distance\/experimental\/np_brats.py\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom scipy import ndimage\nfrom scipy.ndimage import morphology, distance_transform_edt\nfrom scipy.ndimage import _ni_support\nfrom scipy.ndimage.morphology import distance_transform_edt, binary_erosion,\\\n    generate_binary_structure\nfrom scipy.ndimage.measurements import label, find_objects\nfrom scipy.stats import pearsonr\n\ndef surface_distances(result, reference, voxelspacing=None, connectivity=1):\n    \"\"\"\n    The distances between the surface voxel of binary objects in result and their\n    nearest partner surface voxel of a binary object in reference.\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    result = np.atleast_1d(result.astype(np.bool))\n    reference = np.atleast_1d(reference.astype(np.bool))\n    if voxelspacing is not None:\n        voxelspacing = _ni_support._normalize_sequence(voxelspacing, result.ndim)\n        voxelspacing = np.asarray(voxelspacing, dtype=np.float64)\n        if not voxelspacing.flags.contiguous:\n            voxelspacing = voxelspacing.copy()\n\n    # binary structure\n    footprint = generate_binary_structure(result.ndim, connectivity)\n\n    # test for emptiness\n    if 0 == np.count_nonzero(result):\n        raise RuntimeError('The first supplied array does not contain any binary object.')\n    if 0 == np.count_nonzero(reference):\n        raise RuntimeError('The second supplied array does not contain any binary object.')\n\n        # extract only 1-pixel border line of objects\n    result_border = result ^ binary_erosion(result, structure=footprint, iterations=1)\n    reference_border = reference ^ binary_erosion(reference, structure=footprint, iterations=1)\n\n    # compute average surface distance\n    # Note: scipys distance transform is calculated only inside the borders of the\n    #       foreground objects, therefore the input has to be reversed\n    dt = distance_transform_edt(~reference_border, sampling=voxelspacing)\n    sds = dt[result_border]\n\n    return sds\n\nclass HausdorffBinaryLoss(nn.Module):\n    \"\"\"\n    Hausdorff Distance.\n\n    Computes the (symmetric) Hausdorff Distance (HD) between the binary objects in two\n    images. It is defined as the maximum surface distance between the objects.\n\n    Parameters\n    ----------\n    result : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    reference : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    voxelspacing : float or sequence of floats, optional\n        The voxelspacing in a distance unit i.e. spacing of elements\n        along each dimension. If a sequence, must be of length equal to\n        the input rank; if a single number, this is used for all axes. If\n        not specified, a grid spacing of unity is implied.\n    connectivity : int\n        The neighbourhood\/connectivity considered when determining the surface\n        of the binary objects. This value is passed to\n        `scipy.ndimage.morphology.generate_binary_structure` and should usually be :math:`> 1`.\n        Note that the connectivity influences the result in the case of the Hausdorff distance.\n\n    Returns\n    -------\n    hd : float\n        The symmetric Hausdorff Distance between the object(s) in ```result``` and the\n        object(s) in ```reference```. The distance unit is the same as for the spacing of\n        elements along each dimension, which is usually given in mm.\n\n    See also\n    --------\n    :func:`assd`\n    :func:`asd`\n\n    Notes\n    -----\n    This is a real metric. The binary images can therefore be supplied in any order.\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    def __init__(self, voxelspacing=None, connectivity=1):\n        self.voxelspacing=voxelspacing\n        self.connectivity=connectivity\n\n    def forward(self, result, reference):\n        hd1 = surface_distances(result, reference, self.voxelspacing, self.connectivity).max()\n        hd2 = surface_distances(reference, result, self.voxelspacing, self.connectivity).max()\n        hd = max(hd1, hd2)\n        return hd\n\nclass Hausdorff95BinaryLoss(nn.Module):\n    \"\"\"\n    95th percentile of the Hausdorff Distance.\n    Computes the 95th percentile of the (symmetric) Hausdorff Distance (HD) between the binary objects in two\n    images. Compared to the Hausdorff Distance, this metric is slightly more stable to small outliers and is\n    commonly used in Biomedical Segmentation challenges.\n    Parameters as per HausdorffBratsBinaryLoss\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n\n    def __init__(self, voxelspacing=None, connectivity=1):\n        self.voxelspacing=voxelspacing\n        self.connectivity=connectivity\n\n    def forward(self, result, reference):\n        hd1 = surface_distances(result, reference, self.voxelspacing, self.connectivity)\n        hd2 = surface_distances(reference, result, self.voxelspacing, self.connectivity)\n        hd95 = np.percentile(np.hstack((hd1, hd2)), 95)\n        return hd95\n\ndef asd(result, reference, voxelspacing=None, connectivity=1):\n    \"\"\"\n    Average surface distance metric.\n\n    Computes the average surface distance (ASD) between the binary objects in two images.\n\n    Parameters\n    ----------\n    result : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    reference : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    voxelspacing : float or sequence of floats, optional\n        The voxelspacing in a distance unit i.e. spacing of elements\n        along each dimension. If a sequence, must be of length equal to\n        the input rank; if a single number, this is used for all axes. If\n        not specified, a grid spacing of unity is implied.\n    connectivity : int\n        The neighbourhood\/connectivity considered when determining the surface\n        of the binary objects. This value is passed to\n        `scipy.ndimage.morphology.generate_binary_structure` and should usually be :math:`> 1`.\n        The decision on the connectivity is important, as it can influence the results\n        strongly. If in doubt, leave it as it is.\n\n    Returns\n    -------\n    asd : float\n        The average surface distance between the object(s) in ``result`` and the\n        object(s) in ``reference``. The distance unit is the same as for the spacing\n        of elements along each dimension, which is usually given in mm.\n\n    See also\n    --------\n    :func:`assd`\n    :func:`hd`\n\n\n    Notes\n    -----\n    This is not a real metric, as it is directed. See `assd` for a real metric of this.\n\n    The method is implemented making use of distance images and simple binary morphology\n    to achieve high computational speed.\n\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    sds = surface_distances(result, reference, voxelspacing, connectivity)\n    asd = sds.mean()\n    return asd\n\ndef assd(result, reference, voxelspacing=None, connectivity=1):\n    \"\"\"\n    Average symmetric surface distance.\n\n    Computes the average symmetric surface distance (ASD) between the binary objects in\n    two images.\n\n    Parameters\n    ----------\n    result : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    reference : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    voxelspacing : float or sequence of floats, optional\n        The voxelspacing in a distance unit i.e. spacing of elements\n        along each dimension. If a sequence, must be of length equal to\n        the input rank; if a single number, this is used for all axes. If\n        not specified, a grid spacing of unity is implied.\n    connectivity : int\n        The neighbourhood\/connectivity considered when determining the surface\n        of the binary objects. This value is passed to\n        `scipy.ndimage.morphology.generate_binary_structure` and should usually be :math:`> 1`.\n        The decision on the connectivity is important, as it can influence the results\n        strongly. If in doubt, leave it as it is.\n\n    Returns\n    -------\n    assd : float\n        The average symmetric surface distance between the object(s) in ``result`` and the\n        object(s) in ``reference``. The distance unit is the same as for the spacing of\n        elements along each dimension, which is usually given in mm.\n\n    See also\n    --------\n    :func:`asd`\n    :func:`hd`\n\n    Notes\n    -----\n    This is a real metric, obtained by calling and averaging\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    assd = np.mean(\n        (asd(result, reference, voxelspacing, connectivity), asd(reference, result, voxelspacing, connectivity)))\n    return assd\n\nclass AverageSymmetricSurfaceDistance():\n\n    def __init__(self, voxelspacing=None, connectivity=1):\n        super(AverageSymmetricSurfaceDistance, self).__init__()\n        self.voxelspacing=voxelspacing\n        self.connectivity=connectivity\n\n    def forward(self, net_output, target):\n        a = assd(net_output.detach().cpu().numpy(), target.detach().cpu().numpy())\n        return a.to(net_output.device)\n\ndef obj_asd(result, reference, voxelspacing=None, connectivity=1):\n    \"\"\"\n    Average surface distance between objects.\n\n    First correspondences between distinct binary objects in reference and result are\n    established. Then the average surface distance is only computed between corresponding\n    objects. Correspondence is defined as unique and at least one voxel overlap.\n\n    Parameters\n    ----------\n    result : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    reference : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    voxelspacing : float or sequence of floats, optional\n        The voxelspacing in a distance unit i.e. spacing of elements\n        along each dimension. If a sequence, must be of length equal to\n        the input rank; if a single number, this is used for all axes. If\n        not specified, a grid spacing of unity is implied.\n    connectivity : int\n        The neighbourhood\/connectivity considered when determining what accounts\n        for a distinct binary object as well as when determining the surface\n        of the binary objects. This value is passed to\n        `scipy.ndimage.morphology.generate_binary_structure` and should usually be :math:`> 1`.\n        The decision on the connectivity is important, as it can influence the results\n        strongly. If in doubt, leave it as it is.\n\n    Returns\n    -------\n    asd : float\n        The average surface distance between all mutually existing distinct binary\n        object(s) in ``result`` and ``reference``. The distance unit is the same as for the\n        spacing of elements along each dimension, which is usually given in mm.\n\n    See also\n    --------\n    :func:`obj_assd`\n    :func:`obj_tpr`\n    :func:`obj_fpr`\n\n    Notes\n    -----\n    This is not a real metric, as it is directed. See `obj_assd` for a real metric of this.\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    sds = list()\n    labelmap1, labelmap2, _a, _b, mapping = __distinct_binary_object_correspondences(result, reference, connectivity)\n    slicers1 = find_objects(labelmap1)\n    slicers2 = find_objects(labelmap2)\n    for lid2, lid1 in list(mapping.items()):\n        window = __combine_windows(slicers1[lid1 - 1], slicers2[lid2 - 1])\n        object1 = labelmap1[window] == lid1\n        object2 = labelmap2[window] == lid2\n        sds.extend(surface_distances(object1, object2, voxelspacing, connectivity))\n    asd = np.mean(sds)\n\n    return asd\n\ndef obj_assd(result, reference, voxelspacing=None, connectivity=1):\n    \"\"\"\n    Average symmetric surface distance.\n\n    Computes the average symmetric surface distance (ASSD) between the binary objects in\n    two images.\n\n    Parameters\n    ----------\n    result : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    reference : array_like\n        Input data containing objects. Can be any type but will be converted\n        into binary: background where 0, object everywhere else.\n    voxelspacing : float or sequence of floats, optional\n        The voxelspacing in a distance unit i.e. spacing of elements\n        along each dimension. If a sequence, must be of length equal to\n        the input rank; if a single number, this is used for all axes. If\n        not specified, a grid spacing of unity is implied.\n    connectivity : int\n        The neighbourhood\/connectivity considered when determining what accounts\n        for a distinct binary object as well as when determining the surface\n        of the binary objects. This value is passed to\n        `scipy.ndimage.morphology.generate_binary_structure` and should usually be :math:`> 1`.\n        The decision on the connectivity is important, as it can influence the results\n        strongly. If in doubt, leave it as it is.\n\n    Returns\n    -------\n    assd : float\n        The average symmetric surface distance between all mutually existing distinct\n        binary object(s) in ``result`` and ``reference``. The distance unit is the same as for\n        the spacing of elements along each dimension, which is usually given in mm.\n\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    assd = np.mean((obj_asd(result, reference, voxelspacing, connectivity),\n                       obj_asd(reference, result, voxelspacing, connectivity)))\n    return assd\n\nclass AverageObjectSymmetricSurfaceDistance():\n    def __init__(self, voxelspacing=None, connectivity=1):\n        super(AverageObjectSymmetricSurfaceDistance, self).__init__()\n        self.voxelspacing=voxelspacing\n        self.connectivity=connectivity\n\n    def forward(self, net_output, target):\n        assd=obj_assd(net_output.detach().cpu().numpy(), target.detach().cpu().numpy())\n        return assd.to(net_output.device)\n\n\ndef compute_edts_forPenalizedLoss(GT):\n    \"\"\"\n    GT.shape = (batch_size, x,y,z)\n    only for binary segmentation\n    \"\"\"\n    res = np.zeros(GT.shape)\n    for i in range(GT.shape[0]):\n        posmask = GT[i]\n        negmask = ~posmask\n        pos_edt = distance_transform_edt(posmask)\n        pos_edt = (np.max(pos_edt) - pos_edt) * posmask\n        neg_edt = distance_transform_edt(negmask)\n        neg_edt = (np.max(neg_edt) - neg_edt) * negmask\n\n        res[i] = pos_edt \/ np.max(pos_edt) + neg_edt \/ np.max(neg_edt)\n    return res\n\ndef __combine_windows(w1, w2):\n    \"\"\"\n    Joins two windows (defined by tuple of slices) such that their maximum\n    combined extend is covered by the new returned window.\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    res = []\n    for s1, s2 in zip(w1, w2):\n        res.append(slice(min(s1.start, s2.start), max(s1.stop, s2.stop)))\n\n    return tuple(res)\n\ndef __distinct_binary_object_correspondences(reference, result, connectivity=1):\n    \"\"\"\n    Determines all distinct (where connectivity is defined by the connectivity parameter\n    passed to scipy's `generate_binary_structure`) binary objects in both of the input\n    parameters and returns a 1to1 mapping from the labelled objects in reference to the\n    corresponding (whereas a one-voxel overlap suffices for correspondence) objects in\n    result.\n\n    All stems from the problem, that the relationship is non-surjective many-to-many.\n\n    @return (labelmap1, labelmap2, n_lables1, n_labels2, labelmapping2to1)\n    after: https:\/\/github.com\/doublechenching\/brats_segmentation-pytorch\/blob\/master\/utils\/metric\/binary.py\n    \"\"\"\n    result = np.atleast_1d(result.astype(np.bool))\n    reference = np.atleast_1d(reference.astype(np.bool))\n\n    # binary structure\n    footprint = generate_binary_structure(result.ndim, connectivity)\n\n    # label distinct binary objects\n    labelmap1, n_obj_result = label(result, footprint)\n    labelmap2, n_obj_reference = label(reference, footprint)\n\n    # find all overlaps from labelmap2 to labelmap1; collect one-to-one relationships and store all one-two-many for later processing\n    slicers = find_objects(labelmap2)  # get windows of labelled objects\n    mapping = dict()  # mappings from labels in labelmap2 to corresponding object labels in labelmap1\n    used_labels = set()  # set to collect all already used labels from labelmap2\n    one_to_many = list()  # list to collect all one-to-many mappings\n    for l1id, slicer in enumerate(slicers):  # iterate over object in labelmap2 and their windows\n        l1id += 1  # labelled objects have ids sarting from 1\n        bobj = (l1id) == labelmap2[slicer]  # find binary object corresponding to the label1 id in the segmentation\n        l2ids = np.unique(labelmap1[slicer][\n                                 bobj])  # extract all unique object identifiers at the corresponding positions in the reference (i.e. the mapping)\n        l2ids = l2ids[0 != l2ids]  # remove background identifiers (=0)\n        if 1 == len(\n                l2ids):  # one-to-one mapping: if target label not already used, add to final list of object-to-object mappings and mark target label as used\n            l2id = l2ids[0]\n            if not l2id in used_labels:\n                mapping[l1id] = l2id\n                used_labels.add(l2id)\n        elif 1 < len(l2ids):  # one-to-many mapping: store relationship for later processing\n            one_to_many.append((l1id, set(l2ids)))\n\n    # process one-to-many mappings, always choosing the one with the least labelmap2 correspondences first\n    while True:\n        one_to_many = [(l1id, l2ids - used_labels) for l1id, l2ids in\n                       one_to_many]  # remove already used ids from all sets\n        one_to_many = [x for x in one_to_many if x[1]]  # remove empty sets\n        one_to_many = sorted(one_to_many, key=lambda x: len(x[1]))  # sort by set length\n        if 0 == len(one_to_many):\n            break\n        l2id = one_to_many[0][1].pop()  # select an arbitrary target label id from the shortest set\n        mapping[one_to_many[0][0]] = l2id  # add to one-to-one mappings\n        used_labels.add(l2id)  # mark target label as used\n        one_to_many = one_to_many[1:]  # delete the processed set from all sets\n\n    return labelmap1, labelmap2, n_obj_result, n_obj_reference, mapping\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_68","text":"#!\/usr\/local\/anaconda3\/envs\/py36 python\n# -*- coding: utf-8 -*-\n\n# Plotting\nimport matplotlib; matplotlib.use('TkAgg')\nimport matplotlib.pyplot as pl\nimport seaborn as sns; sns.set_style('ticks')\n\nimport matplotlib as mpl\n# from matplotlib.ticker import FormatStrFormatter\nparams = {\n    'axes.labelsize': 12,\n    'font.size': 12,\n    'legend.fontsize': 12,\n    'xtick.labelsize': 12,\n    'ytick.labelsize': 12,\n    'text.usetex': True\n}\nmpl.rcParams.update(params)\n\n\n# Imports\nfrom astropy.io import fits\nfrom scipy import interpolate\nimport numpy as np\nimport pandas as pd\nfrom util import *\nimport pyphot\nlib = pyphot.get_library()\nimport astropy.units as u\nfrom scipy.signal import medfilt\n\n\ndef synpassflux(wl, flux, band):\n    # Calculate synthetic magnitudes\n    n_bands = len(band)\n\n    filt = np.genfromtxt(\"\/Users\/jonatanselsing\/github\/iPTF16geu\/data\/passbands\/%s\"%band)\n    lamb_T, T = filt[:,0], filt[:,1]\n    f = pyphot.Filter(lamb_T, T, name=band, dtype='photon', unit='Angstrom')\n    fluxes = f.get_flux(wl, flux, axis=0)\n    synmags = -2.5 * np.log10(fluxes) - f.AB_zero_mag\n    cwav = np.mean(lamb_T)\n    cwave = (float(max(lamb_T[T > np.percentile(T, 10)] - cwav)), float(cwav - min(lamb_T[T > np.percentile(T, 10)])))\n    synmag_flux = ((synmags*u.ABmag).to((u.erg\/(u.s * u.cm**2 * u.AA)), u.spectral_density(cwav * u.AA))).value\n    return synmag_flux, cwav, cwave, synmags\n\n\ndef main():\n\n\n\n\n\n    root_dir = \"..\/data\/\"\n    OBs = [\"OB1\", \"OB3\", \"OB4\", \"OB5\", \"OB6\", \"OB7\", \"OB8\"]\n\n    wl_out, flux_out, error_out = [0]*len(OBs), [0]*len(OBs), [0]*len(OBs)\n    offsets = [0.95, 0.95, 0.85, 0.95, 0.95, 0.95, 0.95]\n    bin_f = 1\n    for ii, kk in enumerate(OBs):\n\n        off = 0\n        mult = 1.0\n\n        ############################## OB ##############################\n        f = fits.open(root_dir + \"UVB%s.fits\"%kk)\n        wl = 10. * f[1].data.field(\"WAVE\").flatten()\n\n        q = f[1].data.field(\"QUAL\").flatten()\n        try:\n            t = f[1].data.field(\"TRANS\").flatten()\n        except:\n            t = np.ones_like(q)\n        mask_wl = (wl > 3200) & (wl < 5550)\n        mask_qual = ~q.astype(\"bool\")\n        flux = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"FLUX\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n\n        error = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"ERR\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n        wl_plot = wl[mask_wl]\n        dust_ext = correct_for_dust(wl_plot, 0.52)\n        flux = dust_ext*flux(wl_plot)\n        error = dust_ext*error(wl_plot)\n        b_wl, b_f, b_e, b_q = bin_spectrum(wl_plot, flux, error, np.zeros_like(flux).astype(\"bool\"), bin_f)\n\n        wl_stitch, flux_stitch, error_stitch = b_wl, b_f, b_e\n\n\n\n        f = fits.open(root_dir + \"VIS%s.fits\"%kk)\n\n        wl = 10. * f[1].data.field(\"WAVE\").flatten()\n        q = f[1].data.field(\"QUAL\").flatten()\n\n        try:\n            t = f[1].data.field(\"TRANS\").flatten()\n        except:\n            t = np.ones_like(wl)\n\n\n        mask_wl = (wl > 5650) & (wl < 10000)\n        mask_qual = ~q.astype(\"bool\")\n\n        flux = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"FLUX\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n        error = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"ERR\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n        wl_plot = wl[mask_wl]\n        dust_ext = correct_for_dust(wl_plot, 0.52)\n        flux = offsets[ii]*dust_ext*flux(wl_plot) \/ t[mask_wl]\n        error = offsets[ii]*dust_ext*error(wl_plot) \/ t[mask_wl]\n        b_wl, b_f, b_e, b_q = bin_spectrum(wl_plot, flux, error, np.zeros_like(flux).astype(\"bool\"), bin_f)\n\n        wl_stitch, flux_stitch, error_stitch = np.concatenate([wl_stitch,b_wl]), np.concatenate([flux_stitch,b_f]), np.concatenate([error_stitch, b_e])\n        # wl_stitch, flux_stitch, error_stitch = np.concatenate([wl_stitch,wl_plot]), np.concatenate([flux_stitch,flux]), np.concatenate([error_stitch, error])\n\n\n\n\n\n        f = fits.open(root_dir + \"NIR%s.fits\"%kk)\n        wl = 10. * f[1].data.field(\"WAVE\").flatten()\n        q = f[1].data.field(\"QUAL\").flatten()\n\n        try:\n            t = f[1].data.field(\"TRANS\").flatten()\n        except:\n            t = np.ones_like(wl)\n\n\n        mask_wl = (wl > 10000) & (wl < 25000)\n        mask_qual = ~q.astype(\"bool\")\n        flux = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"FLUX\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n        error = interpolate.interp1d(wl[mask_qual], f[1].data.field(\"ERR\").flatten()[mask_qual], bounds_error=False, fill_value=np.nan)\n        wl_plot = wl[mask_wl]\n        dust_ext = correct_for_dust(wl_plot, 0.52)\n        flux = offsets[ii]*dust_ext*flux(wl_plot) \/ t[mask_wl]\n        error = offsets[ii]*dust_ext*error(wl_plot) \/ t[mask_wl]\n\n\n        b_wl, b_f, b_e, b_q = bin_spectrum(wl_plot, flux, error, np.zeros_like(flux).astype(\"bool\"), bin_f*3)\n        wl_stitch, flux_stitch, error_stitch = np.concatenate([wl_stitch,b_wl]), np.concatenate([flux_stitch,b_f]), np.concatenate([error_stitch, b_e])\n\n\n\n        # pl.scatter(wl_stitch, flux_stitch)\n        # pl.show()\n        wl = np.arange(min(wl_stitch), max(wl_stitch), np.median(np.diff(wl_stitch)))\n        f = interpolate.interp1d(wl_stitch, flux_stitch, fill_value=np.nan)\n        g = interpolate.interp1d(wl_stitch, error_stitch, fill_value=np.nan)\n        # h = interpolate.interp1d(wl_stitch, bp_stitch, fill_value=np.nan)\n\n        wl_out[ii] = wl\n        flux_out[ii] = f(wl)\n        # flux_out[ii][h(wl) != 0] = np.nan\n        error_out[ii] = g(wl)\n        # error_out[ii][h(wl) != 0] = np.nan\n#\n        # np.savetxt(root_dir+\"%s_stitched.dat\"%kk, list(zip(wl, flux_out[ii], error_out[ii])), fmt='%1.2f %1.4e %1.4e')\n\n\n    min_wl = 100000\n    max_wl = 0\n    flux_scaling = [0]*len(OBs)\n    for ii, kk in enumerate(OBs):\n        min_wl_temp = min(wl_out[ii])\n        min_wl = min(min_wl_temp, min_wl)\n        max_wl_temp = max(wl_out[ii])\n        max_wl = max(max_wl_temp, max_wl)\n        dwl = np.median(np.diff(wl_out[ii]))\n        flux_scaling[ii] =  np.median(flux_out[ii][(wl_out[ii] > 7000) & (wl_out[ii] < 7100)])\n        np.savetxt(root_dir+\"%s_stitched.dat\"%kk, list(zip(wl, flux_out[ii]*(flux_scaling[0]\/flux_scaling[ii]), error_out[ii]*(flux_scaling[0]\/flux_scaling[ii]))), fmt='%1.2f %1.4e %1.4e')\n\n\n    # print(flux_scaling)\n\n    # print(min_wl, max_wl, dwl)\n    wl_final = np.arange(min_wl, max_wl, dwl)\n    crab_spectra_flux = np.zeros((len(OBs), len(wl_final)))\n    crab_spectra_error = np.zeros((len(OBs), len(wl_final)))\n\n    for ii, kk in enumerate(OBs):\n        mask = np.isnan(flux_out[ii]).astype(\"int\")\n        f = interpolate.interp1d(wl_out[ii], flux_out[ii], bounds_error=False, fill_value=np.nan)\n        g = interpolate.interp1d(wl_out[ii], error_out[ii], bounds_error=False, fill_value=np.nan)\n        crab_spectra_flux[ii, :] = f(wl_final)*(flux_scaling[0]\/flux_scaling[ii])\n        crab_spectra_error[ii, :] = g(wl_final)*(flux_scaling[0]\/flux_scaling[ii])\n\n        pl.plot(wl_final, crab_spectra_flux[ii, :], color=\"black\", alpha = 0.2, linestyle=\"steps-mid\", rasterized=True)\n\n\n    print(np.mean(flux_scaling), np.std(flux_scaling))\n    print(np.mean(flux_scaling[0]\/flux_scaling), np.std(flux_scaling[0]\/flux_scaling))\n\n\n    # l, m, h =(np.percentile(flux_scaling[0]\/flux_scaling, [15.9, 50, 84.2]))\n    # print(m, m - l, h - m)\n    # exit()\n\n    # Median spectrum\n    med_spec = np.nanmedian(crab_spectra_flux[:, :], axis=0)\n    np.savetxt(root_dir+\"median_spectrum.dat\", list(zip(wl_final, med_spec)), fmt='%1.2f %1.4e')\n\n    # Weighted mean\n    weight = 1.0 \/ (crab_spectra_error ** 2.0)\n    average = np.ma.sum(crab_spectra_flux * weight, axis=0) \/ np.ma.sum(weight, axis=0)\n    std = np.sqrt(np.ma.sum(crab_spectra_error**2 * weight**2, axis=0) \/ np.ma.sum(weight, axis=0)**2)\n\n    # average =  np.nanmean(crab_spectra_flux, axis=0)\n    # std = np.sqrt(np.nansum(crab_spectra_error**2, axis=0))\n    # print(average)\n    # print(std)\n\n    np.savetxt(root_dir+\"weighted_spectrum.dat\", list(zip(wl_final, average, std)), fmt='%1.2f %1.4e %1.4e')\n    # exit()\n    # pl.plot(wl_final, med_spec)\n    pl.plot(wl_final, medfilt(average, 1), linestyle=\"steps-mid\", rasterized=True)\n\n\n\n\n\n    # NUV = np.genfromtxt(\"..\/data\/crabNUV.txt\")\n    # dust_ext = correct_for_dust(NUV[:, 0], 0.52)\n    # pl.plot(NUV[:, 0], dust_ext*medfilt(NUV[:, 1], 11), linestyle=\"steps-mid\")\n    # pl.show()\n\n\n    # for ii, OB in enumerate(OBs):\n\n\n    # passbands = [\n        # \"FORS2_U.dat\", \"FORS2_B.dat\", \"FORS2_V.dat\", \"FORS2_R.dat\", \"FORS2_I.dat\", \"2MASS_J.dat\", \"2MASS_H.dat\", \"2MASS_Ks.dat\"\n        # ]\n    passbands = [\"FORS1_U.dat\", \"FORS1_B.dat\", \"FORS1_V.dat\", \"FORS1_R.dat\", \"FORS1_I.dat\", \"FORS2_z.dat\", \"NACO_J.dat\", \"NACO_H.dat\", \"NACO_Ks.dat\"]\n    photometry = pd.read_csv(\"..\/data\/Crab_phot.csv\")\n\n    vega_conv = pd.read_csv(\"~\/github\/iPTF16geu\/data\/passbands\/VEGA_AB.csv\")\n    # cmap1 = sns.color_palette(\"viridis\", len(passbands))\n    cmap1 = sns.color_palette(\"plasma\", 5+len(passbands))\n\n    for pp, ss in enumerate(passbands):\n        pass_name = ss.split(\"_\")[-1].split(\".\")[0]\n        meas_mag = photometry.loc[photometry['Bandpass'] == pass_name]\n        print(pass_name)\n        vega = vega_conv.loc[vega_conv[\"Band\"] == pass_name]\n        print(meas_mag[\"CrabPulsar+Knot\"], vega[\"dmag\"].values)\n        meas_mag[\"CrabPulsar+Knot\"] = meas_mag[\"CrabPulsar+Knot\"] + vega[\"dmag\"].values\n        dust_ext = correct_for_dust(vega[\"leff\"].values, 0.52)\n        # print(dust_ext, ebv)\n\n\n\n        nanmask = (np.isnan(average) | np.isnan(std)) | (np.isinf(average) | np.isinf(std))\n        synmag_flux, cwav, cwave, synmag = synpassflux(wl_final[~nanmask], average[~nanmask], ss)\n        synmag_error, cwav, cwave, synmag_err = synpassflux(wl_final[~nanmask], std[~nanmask], ss)\n        _, _, _, synmag_err_up = synpassflux(wl_final[~nanmask], average[~nanmask] + std[~nanmask], ss)\n        _, _, _, synmag_err_low = synpassflux(wl_final[~nanmask], average[~nanmask] - std[~nanmask], ss)\n        e_u = (synmag - synmag_err_up)\n        e_l = (synmag_err_low - synmag)\n        # pl.errorbar(cwav, synmag_flux, xerr = [[cwave]], yerr = synmag_error,  fmt = 'o', color=cmap1[pp], zorder = 10, ms = 5, elinewidth=1.7, label = \"%s = %s$^{+%s}_{-%s}$\"%(pass_name, np.around(synmag, 2), np.around(e_u, 2), np.around(e_l, 2)))\n        # pl.errorbar(cwav, synmag_flux, xerr = [[cwave]], yerr = synmag_error,  fmt = 'o', color=cmap1[pp], zorder = 10, ms = 5, elinewidth=1.7, label = \"%s\"%(pass_name))\n\n        if meas_mag.shape[0] > 0:\n            meas_flux = ((meas_mag[\"CrabPulsar+Knot\"].values*u.ABmag).to((u.erg\/(u.s * u.cm**2 * u.AA)), u.spectral_density(cwav * u.AA))).value\n            meas_flux_up =  (((meas_mag[\"CrabPulsar+Knot\"].values + meas_mag[\"CrabPulsar+Knot_e\"].values)*u.ABmag).to((u.erg\/(u.s * u.cm**2 * u.AA)), u.spectral_density(cwav * u.AA))).value\n            meas_flux_do =  (((meas_mag[\"CrabPulsar+Knot\"].values - meas_mag[\"CrabPulsar+Knot_e\"].values)*u.ABmag).to((u.erg\/(u.s * u.cm**2 * u.AA)), u.spectral_density(cwav * u.AA))).value\n\n            pl.errorbar(cwav, dust_ext*meas_flux, xerr = [[cwave]], yerr = [[(meas_flux_do, meas_flux_up)]],  fmt = 'o', color=cmap1[pp], ms = 7, zorder=9, label = \"%s\"%(pass_name))\n    pl.xlim(2900, 25000)\n    pl.ylim(1e-16, 2e-14)\n\n\n\n\n\n\n    pl.ylabel(r'$\\log (F_\\lambda \/ \\mathrm{erg}~\\mathrm{s}^{-1}~\\mathrm{cm}^{-2}~\\mathrm{\\AA}^{-1}$)')\n    pl.semilogy()\n    pl.legend()\n\n    # Add frequency axis\n    ax = pl.gca()\n    ax2 = pl.twiny()\n\n    # get axis limits\n    xmin, xmax = ax.get_xlim()\n   ax2.set_xlim((xmin, xmax))\n\n    def co(angs):\n        return(3e18\/(10**angs))\n    nu_arr = np.array([15, 14.6, 14.4, 14.3, 14.2, 14.1])\n    ax2.set_xticks(co(nu_arr))\n    ax2.set_xticklabels(nu_arr)\n\n\n\n    ax.set_xlabel(r\"$ \\lambda_{\\mathrm{obs}}\/\\mathrm{\\AA}$\")\n    ax2.set_xlabel(r\"$\\log (\\nu\/\\mathrm{Hz})$\")\n\n    pl.tight_layout()\n    pl.savefig(\"..\/figures\/combined_spectrum.pdf\")\n    pl.show()\n\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_69","text":"r\"\"\"Classes and functions to define and manipulate symbolic Operator\nexpressions. For more details see :ref:`operator_algebra`.\n\nFor a list of all properties and methods of an operator object, see the\ndocumentation for the basic :class:`Operator` class.\n\"\"\"\nimport re\nfrom abc import ABCMeta, abstractmethod\nfrom collections import OrderedDict, defaultdict\nfrom itertools import product as cartesian_product\n\nfrom sympy import sympify\n\nfrom ..pattern_matching import pattern, pattern_head, wc\nfrom ..utils.indices import FockIndex, IdxSym, SymbolicLabelBase\nfrom ..utils.ordering import FullCommutativeHSOrder\nfrom ..utils.properties_for_args import properties_for_args\nfrom ..utils.singleton import Singleton, singleton_object\nfrom .abstract_quantum_algebra import (\n    QuantumAdjoint,\n    QuantumDerivative,\n    QuantumExpression,\n    QuantumIndexedSum,\n    QuantumOperation,\n    QuantumPlus,\n    QuantumSymbol,\n    QuantumTimes,\n    ScalarTimesQuantumExpression,\n    SingleQuantumOperation,\n    ensure_local_space,\n)\nfrom .algebraic_properties import (\n    assoc,\n    assoc_indexed,\n    collect_summands,\n    commutator_order,\n    delegate_to_method,\n    disjunct_hs_zero,\n    filter_neutral,\n    implied_local_space,\n    indexed_sum_over_const,\n    indexed_sum_over_kronecker,\n    match_replace,\n    match_replace_binary,\n    orderby,\n    scalars_to_op,\n)\nfrom .exceptions import CannotSimplify\nfrom .hilbert_space_algebra import (\n    HilbertSpace,\n    LocalSpace,\n    ProductSpace,\n    TrivialSpace,\n)\nfrom .scalar_algebra import Scalar, ScalarValue, is_scalar\n\n\nsympyOne = sympify(1)\n\n# for hilbert space dimensions less than or equal to this,\n# compute numerically PseudoInverse and NullSpaceProjector representations\nDENSE_DIMENSION_LIMIT = 1000\n\n__all__ = [\n    'Adjoint',\n    'LocalOperator',\n    'LocalSigma',\n    'NullSpaceProjector',\n    'Operator',\n    'OperatorPlus',\n    'OperatorPlusMinusCC',\n    'OperatorSymbol',\n    'OperatorTimes',\n    'OperatorTrace',\n    'PseudoInverse',\n    'ScalarTimesOperator',\n    'LocalProjector',\n    'adjoint',\n    'rewrite_with_operator_pm_cc',\n    'decompose_space',\n    'factor_coeff',\n    'factor_for_trace',\n    'get_coeffs',\n    'II',\n    'IdentityOperator',\n    'ZeroOperator',\n    'OperatorDerivative',\n    'Commutator',\n    'OperatorIndexedSum',\n    'tr',\n]\n\n__private__ = []\n# anything not in __all__ must be in __private__\n\n\n###############################################################################\n# Abstract base classes\n###############################################################################\n\n\nclass Operator(QuantumExpression, metaclass=ABCMeta):\n    \"\"\"Base class for all quantum operators.\"\"\"\n\n    def pseudo_inverse(self):\n        \"\"\"Pseudo-inverse $\\Op{X}^+$ of the operator $\\Op{X}$\n\n        It is defined via the relationship\n\n        .. math::\n\n            \\Op{X} \\Op{X}^+ \\Op{X} =  \\Op{X}  \\\\\n            \\Op{X}^+ \\Op{X} \\Op{X}^+ =  \\Op{X}^+  \\\\\n            (\\Op{X}^+ \\Op{X})^\\dagger = \\Op{X}^+ \\Op{X}  \\\\\n            (\\Op{X} \\Op{X}^+)^\\dagger = \\Op{X} \\Op{X}^+\n        \"\"\"\n        return self._pseudo_inverse()\n\n    @abstractmethod\n    def _pseudo_inverse(self):\n        raise NotImplementedError(self.__class__.__name__)\n\n    def expand_in_basis(self, basis_states=None, hermitian=False):\n        \"\"\"Write the operator as an expansion into all\n        :class:`KetBras <.KetBra>`\n        spanned by `basis_states`.\n\n        Args:\n            basis_states (list or None): List of basis states (:class:`.State`\n                instances) into which to expand the operator. If None, use the\n                operator's `space.basis_states`\n            hermitian (bool): If True, assume that the operator is Hermitian\n                and represent all elements in the lower triangle of the\n                expansion via :class:`OperatorPlusMinusCC`. This is meant to\n                enhance readability\n\n        Raises:\n            .BasisNotSetError: If `basis_states` is None and the operator's\n                Hilbert space has no well-defined basis\n\n        Example:\n\n            >>> hs = LocalSpace(1, basis=('g', 'e'))\n            >>> op = LocalSigma('g', 'e', hs=hs) + LocalSigma('e', 'g', hs=hs)\n            >>> print(ascii(op, sig_as_ketbra=False))\n            sigma_e,g^(1) + sigma_g,e^(1)\n            >>> print(ascii(op.expand_in_basis()))\n            |e><g|^(1) + |g><e|^(1)\n            >>> print(ascii(op.expand_in_basis(hermitian=True)))\n            |g><e|^(1) + c.c.\n        \"\"\"\n        # fmt: off\n        from qalgebra.core.state_algebra import KetBra  # isort:skip\n        # KetBra is imported locally to avoid circular imports\n        # fmt: on\n        if basis_states is None:\n            basis_states = list(self.space.basis_states)\n        else:\n            basis_states = list(basis_states)\n        diag_terms = []\n        terms = []\n        for i, ket_i in enumerate(basis_states):\n            for j, ket_j in enumerate(basis_states):\n                if i > j and hermitian:\n                    continue\n                op_ij = (ket_i.dag() * self * ket_j).expand()\n                ketbra = KetBra(ket_i, ket_j)\n                term = op_ij * ketbra\n                if term is not ZeroOperator:\n                    if i == j:\n                        diag_terms.append(op_ij * ketbra)\n                    else:\n                        terms.append(op_ij * ketbra)\n        if hermitian:\n            res = OperatorPlus.create(*diag_terms)\n            if len(terms) > 0:\n                res = res + OperatorPlusMinusCC(OperatorPlus.create(*terms))\n            return res\n        else:\n            return OperatorPlus.create(*diag_terms) + OperatorPlus.create(\n                *terms\n            )\n\n\nclass LocalOperator(Operator, metaclass=ABCMeta):\n    \"\"\"Base class for \"known\" operators on a :class:`.LocalSpace`.\n\n    All :class:`LocalOperator` instances have known algebraic properties and a\n    fixed associated identifier (symbol) that is used when printing that\n    operator. A custom identifier can be used through the associated\n    :class:`.LocalSpace`'s `local_identifiers` parameter. For example::\n\n        >>> hs1_custom = LocalSpace(1, local_identifiers={'Destroy': 'b'})\n        >>> b = Destroy(hs=hs1_custom)\n        >>> ascii(b)\n        'b^(1)'\n\n    Note:\n        It is recommended that subclasses use the :func:`.properties_for_args`\n        class decorator if they define any position arguments (via the\n        ``_arg_names`` class attribute)\n    \"\"\"\n\n    simplifications = [\n        implied_local_space(keys=['hs']),\n    ]\n\n    _identifier = None  # must be overridden by subclasses!\n    _dagger = False  #: do representations include a dagger?\n    _arg_names = ()  #: names of args that can be passed to __init__\n    _scalar_args = True  #: convert args to Scalar?\n    _hs_cls = LocalSpace  #: allowed type of `hs`\n    _rx_identifier = re.compile('^[A-Za-z][A-Za-z0-9]*(_[A-Za-z0-9().+-]+)?$')\n\n    def __init__(self, *args, hs):\n        if len(args) != len(self._arg_names):\n            raise ValueError(\n                \"expected %d arguments, gotten %d\"\n                % (len(self._arg_names), len(args))\n            )\n        if self._scalar_args:\n            args = [ScalarValue.create(arg) for arg in args]\n        for i, arg_name in enumerate(self._arg_names):\n            self.__dict__['_%s' % arg_name] = args[i]\n        hs = ensure_local_space(hs, cls=self._hs_cls)\n        self._hs = hs\n        if self._identifier is None:\n            raise TypeError(\n                r\"Can't instantiate abstract class %s with undefined \"\n                r\"_identifier\" % self.__class__.__name__\n            )\n        self._args = args\n        super().__init__(*args, hs=hs)\n\n    @property\n    def space(self):\n        \"\"\"Hilbert space of the operator (:class:`.LocalSpace` instance).\"\"\"\n        return self._hs\n\n    @property\n    def args(self):\n        \"\"\"The positional arguments used for instantiating the operator\"\"\"\n        return tuple(self._args)\n\n    @property\n    def kwargs(self):\n        \"\"\"The keyword arguments used for instantiating the operator\"\"\"\n        return OrderedDict([('hs', self._hs)])\n\n    @property\n    def identifier(self):\n        \"\"\"The identifier (symbol) that is used when printing the operator.\n\n        A custom identifier can be used through the associated\n        :class:`.LocalSpace`'s `local_identifiers` parameter. For example::\n\n            >>> a = Destroy(hs=1)\n            >>> a.identifier\n            'a'\n            >>> hs1_custom = LocalSpace(1, local_identifiers={'Destroy': 'b'})\n            >>> b = Destroy(hs=hs1_custom)\n            >>> b.identifier\n            'b'\n            >>> ascii(b)\n            'b^(1)'\n        \"\"\"\n\n        identifier = self._hs._local_identifiers.get(\n            self.__class__.__name__, self._identifier\n        )\n        if not self._rx_identifier.match(identifier):\n            raise ValueError(\n                \"identifier '%s' does not match pattern '%s'\"\n                % (identifier, self._rx_identifier.pattern)\n            )\n        return identifier\n\n    def _diff(self, sym):\n        return OperatorDerivative(self, derivs={sym: 1})\n\n    def _simplify_scalar(self, func):\n        if self._scalar_args:\n            args = [arg.simplify_scalar(func=func) for arg in self.args]\n            return self.create(*args, hs=self.space)\n        else:\n            return super()._simplify_scalar(func=func)\n\n\n###############################################################################\n# Operator algebra elements\n###############################################################################\n\n\nclass OperatorSymbol(QuantumSymbol, Operator):\n    \"\"\"Symbolic operator\n\n    See :class:`.QuantumSymbol`.\n    \"\"\"\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\n@singleton_object\nclass IdentityOperator(Operator, metaclass=Singleton):\n    \"\"\"``IdentityOperator`` constant (singleton) object.\"\"\"\n\n    _order_index = 2\n\n    @property\n    def space(self):\n        \"\"\":class:`.TrivialSpace`\"\"\"\n        return TrivialSpace\n\n    @property\n    def args(self):\n        return tuple()\n\n    def _diff(self, sym):\n        return ZeroOperator\n\n    def _adjoint(self):\n        return self\n\n    def _pseudo_inverse(self):\n        return self\n\n\nII = IdentityOperator\n\n\n@singleton_object\nclass ZeroOperator(Operator, metaclass=Singleton):\n    \"\"\"``ZeroOperator`` constant (singleton) object.\"\"\"\n\n    _order_index = 2\n\n    @property\n    def space(self):\n        \"\"\":class:`.TrivialSpace`\"\"\"\n        return TrivialSpace\n\n    @property\n    def args(self):\n        return tuple()\n\n    def _diff(self, sym):\n        return self\n\n    def _adjoint(self):\n        return self\n\n    def _pseudo_inverse(self):\n        return self\n\n\n@properties_for_args\nclass LocalSigma(LocalOperator):\n    r\"\"\"Level flip operator between two levels of a :class:`.LocalSpace`.\n\n    .. math::\n\n        \\Op{\\sigma}_{jk}^{\\rm hs} =\n        \\left| j\\right\\rangle_{\\rm hs} \\left \\langle k \\right |_{\\rm hs}\n\n    For $j=k$ this becomes a projector $\\Op{P}_k$ onto the eigenstate\n    $\\ket{k}$.\n\n    Args:\n        j (int or str): The label or index identifying $\\ket{j}$\n        k (int or str):  The label or index identifying $\\ket{k}$\n        hs (LocalSpace or int or str): The Hilbert space on which the\n            operator acts. If an :class:`int` or a :class:`str`, an implicit\n            Hilbert space will be constructed as a subclass of\n            :class:`.LocalSpace`, as configured by :func:`.init_algebra`.\n\n    Note:\n        The parameters `j` or `k` may be an integer or a string. A string\n        refers to the label of an eigenstate in the basis of `hs`, which needs\n        to be set. An integer refers to the (zero-based) index of eigenstate of\n        the Hilbert space. This works if `hs` has an unknown dimension.\n        Assuming the Hilbert space has a defined basis, using integer or string\n        labels is equivalent::\n\n            >>> hs = LocalSpace('tls', basis=('g', 'e'))\n            >>> LocalSigma(0, 1, hs=hs) == LocalSigma('g', 'e', hs=hs)\n            True\n\n    Raises:\n        ValueError: If `j` or `k` are invalid value for the given `hs`\n\n    Printers should represent this operator either in braket notation, or using\n    the operator identifier\n\n        >>> LocalSigma(0, 1, hs=0).identifier\n        'sigma'\n\n    For ``j == k``, an alternative (fixed) identifier may be used\n\n        >>> LocalSigma(0, 0, hs=0)._identifier_projector\n        'Pi'\n    \"\"\"\n\n    _identifier = \"sigma\"\n    _identifier_projector = \"Pi\"\n    _rx_identifier = re.compile('^[A-Za-z][A-Za-z0-9]*$')\n    _arg_names = ('j', 'k')\n    _scalar_args = False  # args are labels, not scalar coefficients\n    _rules = OrderedDict()\n    simplifications = [\n        implied_local_space(keys=['hs']),\n        match_replace,\n    ]\n\n    def __init__(self, j, k, *, hs):\n        if isinstance(hs, (str, int)):\n            hs = self._default_hs_cls(hs)\n        hs._unpack_basis_label_or_index(j)  # for applying checks only ...\n        hs._unpack_basis_label_or_index(k)  # ... (disregard returned tuple)\n        if hs.has_basis:\n            # normalize integer i\/j to str label, if possible\n            if isinstance(j, int):\n                j = hs.basis_labels[j]\n            if isinstance(k, int):\n                k = hs.basis_labels[k]\n        super().__init__(j, k, hs=hs)\n\n    @property\n    def args(self):\n        \"\"\"The two eigenstate labels `j` and `k` that the operator connects\"\"\"\n        return self.j, self.k\n\n    @property\n    def index_j(self):\n        \"\"\"Index `j` or (zero-based) index of the label `j` in the basis\"\"\"\n        if isinstance(self.j, (int, SymbolicLabelBase)):\n            return self.j\n        else:\n            try:\n                return self.space.basis_labels.index(self.j)\n            except ValueError:\n                raise ValueError(\n                    \"%r is not one of the basis labels %r\"\n                    % (self.j, self.space.basis_labels)\n                )\n\n    @property\n    def index_k(self):\n        \"\"\"Index `k` or (zero-based) index of the label `k` in the basis\"\"\"\n        if isinstance(self.k, (int, SymbolicLabelBase)):\n            return self.k\n        else:\n            try:\n                return self.space.basis_labels.index(self.k)\n            except ValueError:\n                raise ValueError(\n                    \"%r is not one of the basis labels %r\"\n                    % (self.k, self.space.basis_labels)\n                )\n\n    def raise_jk(self, j_incr=0, k_incr=0):\n        r\"\"\"Return a new :class:`LocalSigma` instance with incremented `j`,\n        `k`, on the same Hilbert space:\n\n        .. math::\n\n            \\Op{\\sigma}_{jk}^{\\rm hs} \\rightarrow \\Op{\\sigma}_{j'k'}^{\\rm hs}\n\n        This is the result of multiplying $\\Op{\\sigma}_{jk}^{\\rm hs}$\n        with any raising or lowering operators.\n\n        If $j'$ or $k'$ are outside the Hilbert space ${\\rm hs}$, the result is\n        the :obj:`ZeroOperator` .\n\n        Args:\n            j_incr (int): The increment between labels $j$ and $j'$\n            k_incr (int): The increment between labels $k$ and $k'$. Both\n                increments may be negative.\n        \"\"\"\n        try:\n            if isinstance(self.j, int):\n                new_j = self.j + j_incr\n            else:  # str\n                new_j = self.space.next_basis_label_or_index(self.j, j_incr)\n            if isinstance(self.k, int):\n                new_k = self.k + k_incr\n            else:  # str or SymbolicLabelBase\n                new_k = self.space.next_basis_label_or_index(self.k, k_incr)\n            return LocalSigma.create(new_j, new_k, hs=self.space)\n        except (IndexError, ValueError):\n            return ZeroOperator\n\n    def _adjoint(self):\n        return LocalSigma(j=self.k, k=self.j, hs=self.space)\n\n    def _pseudo_inverse(self):\n        return self._adjoint()\n\n\ndef LocalProjector(j, *, hs):\n    \"\"\"A projector onto a specific level of a :class:`.LocalSpace`\n\n    Args:\n        j (int or str): The label or index identifying the state onto which\n            is projected\n        hs (HilbertSpace): The Hilbert space on which the operator acts\n    \"\"\"\n    return LocalSigma(j, j, hs=hs)\n\n\n###############################################################################\n# Algebra Operations\n###############################################################################\n\n\nclass OperatorPlus(QuantumPlus, Operator):\n    \"\"\"Sum of Operators\"\"\"\n\n    _neutral_element = ZeroOperator\n    _binary_rules = OrderedDict()\n    simplifications = [\n        assoc,\n        scalars_to_op,\n        orderby,\n        collect_summands,\n        match_replace_binary,\n    ]\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\nclass OperatorTimes(QuantumTimes, Operator):\n    \"\"\"Product of operators\n\n    This serves both as a product within a Hilbert space as well as a tensor\n    product.\"\"\"\n\n    _neutral_element = IdentityOperator\n    _binary_rules = OrderedDict()\n    simplifications = [assoc, orderby, filter_neutral, match_replace_binary]\n\n    def _pseudo_inverse(self):\n        return self.__class__.create(\n            *[o._pseudo_inverse() for o in reversed(self.operands)]\n        )\n\n\nclass ScalarTimesOperator(Operator, ScalarTimesQuantumExpression):\n    \"\"\"Product of a :class:`.Scalar` coefficient and an :class:`.Operator`.\"\"\"\n\n    _rules = OrderedDict()\n    simplifications = [\n        match_replace,\n    ]\n\n    @staticmethod\n    def has_minus_prefactor(c):\n        \"\"\"\n        For a scalar object c, determine whether it is prepended by a \"-\" sign.\n        \"\"\"\n        # TODO: check if this is necessary; if yes, move\n        cs = str(c).strip()\n        return cs[0] == \"-\"\n\n    def _pseudo_inverse(self):\n        c, t = self.operands\n        return t.pseudo_inverse() \/ c\n\n    def __eq__(self, other):\n        # TODO: review, and add this to ScalarTimesQuantumExpression\n        if self.term is IdentityOperator and is_scalar(other):\n            return self.coeff == other\n        return super().__eq__(other)\n\n    def __hash__(self):\n        # TODO: review, and add this to ScalarTimesQuantumExpression\n        return super().__hash__()\n\n    def _adjoint(self):\n        return ScalarTimesOperator(self.coeff.conjugate(), self.term.adjoint())\n\n\nclass OperatorDerivative(QuantumDerivative, Operator):\n    \"\"\"Symbolic partial derivative of an operator\n\n    See :class:`.QuantumDerivative`.\n    \"\"\"\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\nclass Commutator(QuantumOperation, Operator):\n    r\"\"\"Commutator of two operators\n\n    .. math::\n\n        [\\Op{A}, \\Op{B}] = \\Op{A}\\Op{B} - \\Op{A}\\Op{B}\n\n    \"\"\"\n\n    _rules = OrderedDict()\n    simplifications = [\n        scalars_to_op,\n        disjunct_hs_zero,\n        commutator_order,\n        match_replace,\n    ]\n    # TODO: doit method\n\n    order_key = FullCommutativeHSOrder\n\n    # commutator_order makes FullCommutativeHSOrder anti-commutative\n\n    def __init__(self, A, B):\n        self._hs = A.space * B.space\n        super().__init__(A, B)\n\n    @property\n    def A(self):\n        \"\"\"Left side of the commutator\"\"\"\n        return self.operands[0]\n\n    @property\n    def B(self):\n        \"\"\"Left side of the commutator\"\"\"\n        return self.operands[1]\n\n    def doit(self, classes=None, recursive=True, **kwargs):\n        \"\"\"Write out commutator\n\n        Write out the commutator according to its definition\n        $[\\Op{A}, \\Op{B}] = \\Op{A}\\Op{B} - \\Op{A}\\Op{B}$.\n\n        See :meth:`.Expression.doit`.\n        \"\"\"\n        return super().doit(classes, recursive, **kwargs)\n\n    def _doit(self, **kwargs):\n        return self.A * self.B - self.B * self.A\n\n    def _expand(self):\n        A = self.A.expand()\n        B = self.B.expand()\n        if isinstance(A, OperatorPlus):\n            A_summands = A.operands\n        else:\n            A_summands = (A,)\n        if isinstance(B, OperatorPlus):\n            B_summands = B.operands\n        else:\n            B_summands = (B,)\n        summands = []\n        for combo in cartesian_product(A_summands, B_summands):\n            summands.append(Commutator.create(*combo))\n        return OperatorPlus.create(*summands)\n\n    def _series_expand(self, param, about, order):\n        A_series = self.A.series_expand(param, about, order)\n        B_series = self.B.series_expand(param, about, order)\n        res = []\n        for n in range(order + 1):\n            summands = [\n                self.create(A_series[k], B_series[n - k]) for k in range(n + 1)\n            ]\n            res.append(OperatorPlus.create(*summands))\n        return tuple(res)\n\n    def _diff(self, sym):\n        return self.__class__(self.A.diff(sym), self.B) + self.__class__(\n            self.A, self.B.diff(sym)\n        )\n\n    def _adjoint(self):\n        return Commutator(self.B.adjoint(), self.A.adjoint())\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\nclass OperatorTrace(SingleQuantumOperation, Operator):\n    r\"\"\"(Partial) trace of an operator\n\n    Trace of an operator `op` ($\\Op{O}) over the degrees\n    of freedom of a Hilbert space `over_space` ($\\mathcal{H}$):\n\n    .. math::\n\n        {\\rm Tr}_{\\mathcal{H}} \\Op{O}\n\n    Args:\n        over_space (.HilbertSpace): The degrees of freedom to trace over\n        op (Operator): The operator to take the trace of.\n    \"\"\"\n    _rules = OrderedDict()\n    simplifications = [\n        scalars_to_op,\n        implied_local_space(keys=['over_space']),\n        match_replace,\n    ]\n\n    def __init__(self, op, *, over_space):\n        if isinstance(over_space, (int, str)):\n            over_space = self._default_hs_cls(over_space)\n        assert isinstance(over_space, HilbertSpace)\n        self._over_space = over_space\n        super().__init__(op, over_space=over_space)\n        self._space = None\n\n    @property\n    def kwargs(self):\n        return {'over_space': self._over_space}\n\n    @property\n    def operand(self):\n        return self.operands[0]\n\n    @property\n    def space(self):\n        if self._space is None:\n            return self.operands[0].space \/ self._over_space\n        return self._space\n\n    def _expand(self):\n        s = self._over_space\n        o = self.operand\n        return OperatorTrace.create(o.expand(), over_space=s)\n\n    def _series_expand(self, param, about, order):\n        ope = self.operand.series_expand(param, about, order)\n        return tuple(\n            OperatorTrace.create(opet, over_space=self._over_space)\n            for opet in ope\n        )\n\n    def _diff(self, sym):\n        s = self._over_space\n        o = self.operand\n        return OperatorTrace.create(o._diff(sym), over_space=s)\n\n    def _adjoint(self):\n        # there is a rule Tr[A^\\dagger] -> Tr[A]^\\dagger, which we don't want\n        # to counteract here with an inverse rule\n        return Adjoint(self)\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\nclass Adjoint(QuantumAdjoint, Operator):\n    \"\"\"Symbolic Adjoint of an operator\"\"\"\n\n    simplifications = [scalars_to_op, delegate_to_method('_adjoint')]\n    # The reason that Adjoint does not have have `match_replace` in\n    # `simplifications`, respectively a `_rules` class attribute is that the\n    # `_adjoint` property that we delegate to is mandatory. Thus, if we had\n    # rules on top of that, it would create the confusing situation of the rule\n    # contradicting the `_adjoint` property.\n\n    def _pseudo_inverse(self):\n        return self.operand.pseudo_inverse().adjoint()\n\n\nclass OperatorPlusMinusCC(SingleQuantumOperation, Operator):\n    \"\"\"An operator plus or minus its complex conjugate.\"\"\"\n\n    def __init__(self, op, *, sign=+1):\n        self._sign = sign\n        super().__init__(op, sign=sign)\n\n    @property\n    def kwargs(self):\n        if self._sign > 0:\n            return {\n                'sign': +1,\n            }\n        else:\n            return {\n                'sign': -1,\n            }\n\n    @property\n    def minimal_kwargs(self):\n        if self._sign == +1:\n            return {}\n        else:\n            return self.kwargs\n\n    def _expand(self):\n        return self\n\n    def _diff(self, sym):\n        return OperatorPlusMinusCC(self.operands._diff(sym), sign=self._sign)\n\n    def _adjoint(self):\n        return OperatorPlusMinusCC(self.operand.adjoint(), sign=self._sign)\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self.doit())\n\n    def doit(self, classes=None, recursive=True, **kwargs):\n        \"\"\"Write out the complex conjugate summand\n\n        See :meth:`.Expression.doit`.\n        \"\"\"\n        return super().doit(classes, recursive, **kwargs)\n\n    def _doit(self, **kwargs):\n        if self._sign > 0:\n            return self.operand + self.operand.adjoint()\n        else:\n            return self.operand - self.operand.adjoint()\n\n\nclass PseudoInverse(SingleQuantumOperation, Operator):\n    r\"\"\"Unevaluated pseudo-inverse $\\Op{X}^+$ of an operator $\\Op{X}$.\n\n    It is defined via the relationship\n\n    .. math::\n\n        \\Op{X} \\Op{X}^+ \\Op{X} =  \\Op{X}  \\\\\n        \\Op{X}^+ \\Op{X} \\Op{X}^+ =  \\Op{X}^+  \\\\\n        (\\Op{X}^+ \\Op{X})^\\dagger = \\Op{X}^+ \\Op{X}  \\\\\n        (\\Op{X} \\Op{X}^+)^\\dagger = \\Op{X} \\Op{X}^+\n    \"\"\"\n    simplifications = [scalars_to_op, delegate_to_method('_pseudo_inverse')]\n    # `PseudoInverse` does not use rules because it delegates to\n    # `_pseudo_inverse`, cf. `Adjoint`\n\n    def _expand(self):\n        return self\n\n    def _pseudo_inverse(self):\n        return self.operand\n\n    def _adjoint(self):\n        return Adjoint(self)\n\n\nclass NullSpaceProjector(SingleQuantumOperation, Operator):\n    r\"\"\"Projection operator onto the nullspace of its operand.\n\n    Returns the operator :math:`\\mathcal{P}_{{\\rm Ker} X}` with\n\n    .. math::\n\n        X \\mathcal{P}_{{\\rm Ker} X}\n          = 0\n        \\Leftrightarrow\n        X (1 - \\mathcal{P}_{{\\rm Ker} X})\n          = X \\\\\n        \\mathcal{P}_{{\\rm Ker} X}^\\dagger\n          = \\mathcal{P}_{{\\rm Ker} X}\n          = \\mathcal{P}_{{\\rm Ker} X}^2\n    \"\"\"\n\n    _rules = OrderedDict()\n    simplifications = [\n        scalars_to_op,\n        match_replace,\n    ]\n\n    def _expand(self):\n        return self\n\n    def _adjoint(self):\n        return Adjoint(self)\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\nclass OperatorIndexedSum(QuantumIndexedSum, Operator):\n    \"\"\"Indexed sum over operators\"\"\"\n\n    _rules = OrderedDict()\n    simplifications = [\n        assoc_indexed,\n        scalars_to_op,\n        indexed_sum_over_kronecker,\n        indexed_sum_over_const,\n        match_replace,\n    ]\n\n    def _pseudo_inverse(self):\n        return PseudoInverse(self)\n\n\n###############################################################################\n# Constructor Routines\n###############################################################################\n\n\ntr = OperatorTrace.create\n\n\n###############################################################################\n# Auxilliary routines\n###############################################################################\n\n\ndef factor_for_trace(ls: HilbertSpace, op: Operator) -> Operator:\n    r\"\"\"Factor `ls` out of `op` for easy tracing.\n\n    Given a :class:`.LocalSpace` `ls` to take the partial trace over and an\n    operator `op`, factor the trace such that operators acting on disjoint\n    degrees of freedom are pulled out of the trace. If the operator acts\n    trivially on ls the trace yields only a pre-factor equal to the dimension\n    of ls. If there are :class:`.LocalSigma` operators among a product, the\n    trace's cyclical property is used to move to sandwich the full product by\n    :class:`LocalSigma` operators:\n\n    .. math::\n\n        {\\rm Tr} A \\sigma_{jk} B = {\\rm Tr} \\sigma_{jk} B A \\sigma_{jj}\n\n    Args:\n        ls: Degree of freedom to trace over\n        op: Operator to take the trace of\n\n    Returns:\n        The (partial) trace over the operator's spc-degrees of freedom\n    \"\"\"\n    if op.space == ls:\n        if isinstance(op, OperatorTimes):\n            pull_out = [o for o in op.operands if o.space is TrivialSpace]\n            rest = [o for o in op.operands if o.space is not TrivialSpace]\n            if pull_out:\n                return OperatorTimes.create(*pull_out) * OperatorTrace.create(\n                    OperatorTimes.create(*rest), over_space=ls\n                )\n        raise CannotSimplify()\n    if ls & op.space == TrivialSpace:\n        return ls.dimension * op\n    if ls < op.space and isinstance(op, OperatorTimes):\n        pull_out = [o for o in op.operands if (o.space & ls) == TrivialSpace]\n\n        rest = [o for o in op.operands if (o.space & ls) != TrivialSpace]\n        if not isinstance(rest[0], LocalSigma) or not isinstance(\n            rest[-1], LocalSigma\n        ):\n            for j, r in enumerate(rest):\n                if isinstance(r, LocalSigma):\n                    m = r.j\n                    rest = (\n                        rest[j:] + rest[:j] + [LocalSigma.create(m, m, hs=ls)]\n                    )\n                    break\n        if not rest:\n            rest = [IdentityOperator]\n        if len(pull_out):\n            return OperatorTimes.create(*pull_out) * OperatorTrace.create(\n                OperatorTimes.create(*rest), over_space=ls\n            )\n    raise CannotSimplify()\n\n\ndef decompose_space(H, A):\n    \"\"\"Simplifies OperatorTrace expressions over tensor-product spaces by\n    turning it into iterated partial traces.\n\n    Args:\n        H (ProductSpace): The full space.\n        A (Operator):\n\n    Returns:\n        Operator: Iterative partial trace expression\n    \"\"\"\n    return OperatorTrace.create(\n        OperatorTrace.create(A, over_space=H.operands[-1]),\n        over_space=ProductSpace.create(*H.operands[:-1]),\n    )\n\n\ndef get_coeffs(expr, expand=False, epsilon=0.0):\n    \"\"\"Create a dictionary with all Operator terms of the expression\n    (understood as a sum) as keys and their coefficients as values.\n\n    The returned object is a defaultdict that return 0. if a term\/key\n    doesn't exist.\n\n    Args:\n        expr: The operator expression to get all coefficients from.\n        expand: Whether to expand the expression distributively.\n        epsilon: If non-zero, drop all Operators with coefficients that have\n            absolute value less than epsilon.\n\n    Returns:\n        dict: A dictionary ``{op1: coeff1, op2: coeff2, ...}``\n    \"\"\"\n    if expand:\n        expr = expr.expand()\n    ret = defaultdict(int)\n    operands = expr.operands if isinstance(expr, OperatorPlus) else [expr]\n    for e in operands:\n        c, t = _coeff_term(e)\n        try:\n            if abs(complex(c)) < epsilon:\n                continue\n        except TypeError:\n            pass\n        ret[t] += c\n    return ret\n\n\ndef _coeff_term(op):\n    # TODO: remove\n    if isinstance(op, ScalarTimesOperator):\n        return op.coeff, op.term\n    elif is_scalar(op):\n        if op == 0:\n            return 0, ZeroOperator\n        else:\n            return op, IdentityOperator\n    else:\n        return 1, op\n\n\ndef factor_coeff(cls, ops, kwargs):\n    \"\"\"Factor out coefficients of all factors.\"\"\"\n    coeffs, nops = zip(*map(_coeff_term, ops))\n    coeff = 1\n    for c in coeffs:\n        coeff *= c\n    if coeff == 1:\n        return nops, coeffs\n    else:\n        return coeff * cls.create(*nops, **kwargs)\n\n\ndef adjoint(obj):\n    \"\"\"Return the adjoint of an obj.\"\"\"\n    try:\n        return obj.adjoint()\n    except AttributeError:\n        return obj.conjugate()\n\n\n###############################################################################\n# Extra (\"manual\") simplifications\n###############################################################################\n\n\ndef rewrite_with_operator_pm_cc(expr):\n    \"\"\"Try to rewrite expr using :class:`.OperatorPlusMinusCC`.\n\n    Example::\n\n        >>> A = OperatorSymbol('A', hs=1)\n        >>> sum = A + A.dag()\n        >>> sum2 = rewrite_with_operator_pm_cc(sum)\n        >>> print(ascii(sum2))\n        A^(1) + c.c.\n    \"\"\"\n    # TODO: move this to the toolbox\n    from qalgebra.toolbox.core import temporary_rules\n\n    def _combine_operator_p_cc(A, B):\n        if B.adjoint() == A:\n            return OperatorPlusMinusCC(A, sign=+1)\n        else:\n            raise CannotSimplify\n\n    def _combine_operator_m_cc(A, B):\n        if B.adjoint() == A:\n            return OperatorPlusMinusCC(A, sign=-1)\n        else:\n            raise CannotSimplify\n\n    def _scal_combine_operator_pm_cc(c, A, d, B):\n        if B.adjoint() == A:\n            if c == d:\n                return c * OperatorPlusMinusCC(A, sign=+1)\n            elif c == -d:\n                return c * OperatorPlusMinusCC(A, sign=-1)\n        raise CannotSimplify\n\n    A = wc(\"A\", head=Operator)\n    B = wc(\"B\", head=Operator)\n    c = wc(\"c\", head=Scalar)\n    d = wc(\"d\", head=Scalar)\n\n    with temporary_rules(OperatorPlus, clear=True):\n        OperatorPlus.add_rule(\n            'PM1', pattern_head(A, B), _combine_operator_p_cc\n        )\n        OperatorPlus.add_rule(\n            'PM2',\n            pattern_head(pattern(ScalarTimesOperator, -1, B), A),\n            _combine_operator_m_cc,\n        )\n        OperatorPlus.add_rule(\n            'PM3',\n            pattern_head(\n                pattern(ScalarTimesOperator, c, A),\n                pattern(ScalarTimesOperator, d, B),\n            ),\n            _scal_combine_operator_pm_cc,\n        )\n        return expr.rebuild()\n\n\nOperator._zero = ZeroOperator\nOperator._one = IdentityOperator\nOperator._base_cls = Operator\nOperator._scalar_times_expr_cls = ScalarTimesOperator\nOperator._plus_cls = OperatorPlus\nOperator._times_cls = OperatorTimes\nOperator._adjoint_cls = Adjoint\nOperator._indexed_sum_cls = OperatorIndexedSum\nOperator._derivative_cls = OperatorDerivative\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_71","text":"<reponame>bilgelm\/NiMARE<gh_stars>0\n\"\"\"\nTopic modeling with generalized correspondence latent Dirichlet allocation.\n\"\"\"\nimport logging\nimport os.path as op\n\nimport numpy as np\nimport pandas as pd\nimport nibabel as nib\nfrom scipy.stats import multivariate_normal\n\nfrom ...base import AnnotationModel\nfrom ...due import due, Doi\nfrom ...utils import get_template\n\nLGR = logging.getLogger(__name__)\n\n\n@due.dcite(Doi('10.1371\/journal.pcbi.1005649'),\n           description='Introduces GC-LDA decoding.')\nclass GCLDAModel(AnnotationModel):\n    \"\"\"\n    Generate a GCLDA topic model.\n\n    Parameters\n    ----------\n    count_df : :obj:`pandas.DataFrame`\n        A DataFrame with feature counts for the model. The index is 'id',\n        used for identifying studies. Other columns are features (e.g.,\n        unigrams and bigrams from Neurosynth), where each value is the number\n        of times the feature is found in a given article.\n    coordinates_df : :obj:`pandas.DataFrame`\n        A DataFrame with a list of foci in the dataset. The index is 'id',\n        used for identifying studies. Additional columns include 'i', 'j' and\n        'k' (the matrix indices of the foci in standard space).\n    n_topics : :obj:`int`, optional\n        Number of topics to generate in model. The default is 100.\n    n_regions : :obj:`int`, optional\n        Number of subregions per topic (>=1). The default is 2.\n    alpha : :obj:`float`, optional\n        Prior count on topics for each document. The default is 0.1.\n    beta : :obj:`float`, optional\n        Prior count on word-types for each topic. The default is 0.01.\n    gamma : :obj:`float`, optional\n        Prior count added to y-counts when sampling z assignments. The\n        default is 0.01.\n    delta : :obj:`float`, optional\n        Prior count on subregions for each topic. The default is 1.0.\n    dobs : :obj:`int`, optional\n        Spatial region 'default observations' (# observations weighting\n        Sigma estimates in direction of default 'roi_size' value). The\n        default is 25.\n    roi_size : :obj:`float`, optional\n        Default spatial 'region of interest' size (default value of\n        diagonals in covariance matrix for spatial distribution, which the\n        distributions are biased towards). The default is 50.0.\n    symmetric : :obj:`bool`, optional\n        Whether or not to use symmetry constraint on subregions. Symmetry\n        requires n_regions = 2. The default is False.\n    seed_init : :obj:`int`, optional\n        Initial value of random seed. The default is 1.\n    name : :obj:`str`, optional\n        Name of model.\n    \"\"\"\n    def __init__(self, count_df, coordinates_df, mask='Mni152_2mm',\n                 n_topics=100, n_regions=2, symmetric=True, alpha=.1,\n                 beta=.01, gamma=.01, delta=1.0, dobs=25, roi_size=50.0,\n                 seed_init=1, name='gclda'):\n        LGR.info('Constructing\/Initializing GCLDA Model')\n\n        # --- Checking to make sure parameters are valid\n        if (symmetric is True) and (n_regions != 2):\n            # symmetric model only valid if R = 2\n            raise ValueError('Cannot run a symmetric model unless #Subregions '\n                             '(n_regions) == 2 !')\n\n        # Initialize sampling parameters\n        self.iter = 0  # Tracks the global sampling iteration of the model\n        self.seed = 0  # Tracks current random seed to use (gets incremented\n                       # after initialization and each sampling update)\n\n        # Set up model hyperparameters\n        # Pseudo-count hyperparams need to be floats so that when sampling\n        # distributions are computed the count matrices\/vectors are converted\n        # to floats\n        self.params = {\n            'n_topics': n_topics,  # Number of topics (T)\n            'n_regions': n_regions,  # Number of subregions (R)\n            'alpha': alpha,  # Prior count on topics for each doc\n            'beta': beta,  # Prior count on word-types for each topic\n            'gamma': gamma,  # Prior count added to y-counts when sampling z assignments\n            'delta': delta,  # Prior count on subregions for each topic\n            'roi_size': roi_size,  # Default ROI (default covariance spatial\n                                   # region we regularize towards) (not in paper)\n            'dobs': dobs,  # Sample constant (# observations weighting\n                           # sigma in direction of default covariance)\n                           # (not in paper)\n            'symmetric': symmetric,  # Use constrained symmetry on subregions?\n                                     # (only for n_regions = 2)\n            'seed_init': seed_init,  # Random seed for initializing model\n            }\n        self.model_name = ('{0}_{1}T_{2}R_alpha{3:.3f}_beta{4:.3f}_'\n                           'gamma{5:.3f}_delta{6:.3f}_{7}dobs_{8:.1f}roi_{9}'\n                           'symmetric_{10}').format(\n            name, self.params['n_topics'], self.params['n_regions'],\n            self.params['alpha'], self.params['beta'],\n            self.params['gamma'], self.params['delta'],\n            self.params['dobs'], self.params['roi_size'],\n            self.params['symmetric'], self.params['seed_init'])\n\n        # Prepare data\n        if isinstance(mask, str) and not op.isfile(mask):\n            self.mask = get_template(mask, mask='brain')\n        elif isinstance(mask, str) and op.isfile(mask):\n            self.mask = nib.load(mask)\n        elif isinstance(mask, nib.Nifti1Image):\n            self.mask = mask\n        else:\n            raise Exception('Input \"mask\" could not be figured out.')\n\n        # Import all word-labels into a list\n        # List of word-strings (wtoken_word_idx values are indices into this list)\n        self.vocabulary = count_df.columns.tolist()\n\n        # Extract document and word indices from count_df\n        count_df.index = count_df.index.astype(str)\n        ids = count_df.index.tolist()\n        docidx_mapper = {id_: i for (i, id_) in enumerate(ids)}\n        self.ids = ids\n\n        # Create docidx column\n        count_df['id'] = count_df.index\n        count_df['docidx'] = count_df['id'].map(docidx_mapper)\n        count_df = count_df.dropna(subset=['docidx'])\n        count_df = count_df.drop('id', 1)\n\n        # Remove words not found anywhere in the corpus\n        count_df = count_df.loc[:, (count_df != 0).any(axis=0)]\n\n        # Get updated vocabulary\n        word_labels = count_df.columns.tolist()\n        word_labels.remove('docidx')\n        self.word_labels = word_labels\n        widx_mapper = {word: i for (i, word) in enumerate(self.word_labels)}\n\n        # Melt dataframe and create widx column\n        widx_df = pd.melt(count_df, id_vars=['docidx'], var_name='word',\n                          value_name='count')\n        widx_df['widx'] = widx_df['word'].map(widx_mapper)\n\n        # Replicate rows based on count\n        widx_df = widx_df.loc[np.repeat(widx_df.index.values, widx_df['count'])]\n        widx_df = widx_df[['docidx', 'widx']].astype(int)\n        widx_df.sort_values(by=['docidx', 'widx'], inplace=True)\n        # List of document-indices for word-tokens\n        self.wtoken_doc_idx = widx_df['docidx'].tolist()\n        # List of word-indices for word-tokens\n        self.wtoken_word_idx = widx_df['widx'].tolist()\n\n        # Import all peak-indices into lists\n        if 'id' not in coordinates_df.columns:\n            coordinates_df['id'] = coordinates_df.index\n        coordinates_df['docidx'] = coordinates_df['id'].astype(str).map(docidx_mapper)\n        coordinates_df = coordinates_df.dropna(subset=['docidx'])\n        coordinates_df = coordinates_df[['docidx', 'x', 'y', 'z']]\n        coordinates_df['docidx'] = coordinates_df['docidx'].astype(int)\n        # List of document-indices for peak-tokens x\n        self.ptoken_doc_idx = coordinates_df['docidx'].tolist()\n        self.peak_vals = coordinates_df[['x', 'y', 'z']].values\n\n        # Seed random number generator\n        np.random.seed(self.params['seed_init'])  # pylint: disable=no-member\n\n        # Preallocate vectors of assignment indices\n        self.wtoken_topic_idx = np.zeros(\n            len(self.wtoken_word_idx), dtype=int)  # word->topic assignments\n\n        # Randomly initialize peak->topic assignments (y) ~ unif(1...n_topics)\n        self.peak_topic_idx = np.random.randint(\n            self.params['n_topics'],  # pylint: disable=no-member\n            size=(len(self.ptoken_doc_idx)))\n\n        self.peak_region_idx = np.zeros(\n            len(self.ptoken_doc_idx), dtype=int)  # peak->region assignments\n\n        # Preallocate count matrices\n        # Peaks: D x T: Number of peak-tokens assigned to each topic per document\n        self.n_peak_tokens_doc_by_topic = np.zeros(\n            (len(self.ids), self.params['n_topics']), dtype=int)\n\n        # Peaks: R x T: Number of peak-tokens assigned to each subregion per topic\n        self.n_peak_tokens_region_by_topic = np.zeros(\n            (self.params['n_regions'], self.params['n_topics']), dtype=int)\n\n        # Words: W x T: Number of word-tokens assigned to each topic per word-type\n        self.n_word_tokens_word_by_topic = np.zeros(\n            (len(self.word_labels), self.params['n_topics']), dtype=int)\n\n        # Words: D x T: Number of word-tokens assigned to each topic per document\n        self.n_word_tokens_doc_by_topic = np.zeros(\n            (len(self.ids), self.params['n_topics']), dtype=int)\n\n        # Words: 1 x T: Total number of word-tokens assigned to each topic (across all docs)\n        self.total_n_word_tokens_by_topic = np.zeros(\n            (1, self.params['n_topics']), dtype=int)\n\n        # Preallocate Gaussians for all subregions\n        # Regions_Mu & Regions_Sigma: Gaussian mean and covariance for all\n        # subregions of all topics\n        # Formed using lists (over topics) of lists (over subregions) of numpy\n        # arrays\n        #   regions_mu = (n_topics, n_regions, 1, n_peak_dims)\n        #   regions_sigma = (n_topics, n_regions, n_peak_dims, n_peak_dims)\n        self.regions_mu = []\n        self.regions_sigma = []\n        for i_topic in range(self.params['n_topics']):\n            topic_mu = []\n            topic_sigma = []\n            for j_region in range(self.params['n_regions']):\n                topic_mu.append(np.zeros((1, self.peak_vals.shape[1])))\n                topic_sigma.append(np.zeros(\n                    (self.peak_vals.shape[1], self.peak_vals.shape[1])))\n            self.regions_mu.append(topic_mu)  # (\\mu^{(t)}_r)\n            self.regions_sigma.append(topic_sigma)  # (\\sigma^{(t)}_r)\n\n        # Initialize lists for tracking log-likelihood of data over sampling iterations\n        self.loglikely_iter = []  # Tracks iteration we compute each loglikelihood at\n        self.loglikely_x = []  # Tracks log-likelihood of peak tokens\n        self.loglikely_w = []  # Tracks log-likelihood of word tokens\n        self.loglikely_tot = []  # Tracks log-likelihood of peak + word tokens\n\n        # Initialize peak->subregion assignments (r)\n        if not self.params['symmetric']:\n            # if symmetric model use deterministic assignment :\n            #     if peak_val[0] > 0, r = 1, else r = 0\n            self.peak_region_idx[:] = np.random.randint(\n                self.params['n_regions'],  # pylint: disable=no-member\n                size=(len(self.ptoken_doc_idx)))\n        else:\n            # if asymmetric model, randomly sample r ~ unif(1...n_regions)\n            self.peak_region_idx[:] = (self.peak_vals[:, 0] > 0).astype(int)\n\n        # Update model vectors and count matrices to reflect y and r assignments\n        for i_ptoken in range(len(self.ptoken_doc_idx)):\n            # document -idx (d)\n            doc = self.ptoken_doc_idx[i_ptoken]\n            topic = self.peak_topic_idx[i_ptoken]  # peak-token -> topic assignment (y_i)\n            region = self.peak_region_idx[i_ptoken]  # peak-token -> subregion assignment (c_i)\n            self.n_peak_tokens_doc_by_topic[doc, topic] += 1  # Increment document-by-topic counts\n            self.n_peak_tokens_region_by_topic[region, topic] += 1  # Increment region-by-topic\n\n        # Randomly Initialize Word->Topic Assignments (z) for each word\n        # token w_i: sample z_i proportional to p(topic|doc_i)\n        for i_wtoken in range(len(self.wtoken_word_idx)):\n            # w_i word-type\n            word = self.wtoken_word_idx[i_wtoken]\n\n            # w_i doc-index\n            doc = self.wtoken_doc_idx[i_wtoken]\n\n            # Estimate p(t|d) for current doc\n            p_topic_g_doc = self.n_peak_tokens_doc_by_topic[doc] + self.params['gamma']\n\n            # Sample a topic from p(t|d) for the z-assignment\n            probs = np.cumsum(p_topic_g_doc)  # Compute a cdf of the sampling\n                                              # distribution for z\n            # Which elements of cdf are less than random sample?\n            sample_locs = probs < np.random.rand() * probs[-1]  # pylint: disable=no-member\n            sample_locs = np.where(sample_locs)  # How many elements of cdf are\n                                                 # less than sample\n            topic = len(sample_locs[0])  # z = # elements of cdf less than\n                                         # rand-sample\n\n            # Update model assignment vectors and count-matrices to reflect z\n            self.wtoken_topic_idx[i_wtoken] = topic  # Word-token -> topic assignment (z_i)\n            self.n_word_tokens_word_by_topic[word, topic] += 1\n            self.total_n_word_tokens_by_topic[0, topic] += 1\n            self.n_word_tokens_doc_by_topic[doc, topic] += 1\n\n        # Get Initial Spatial Parameter Estimates\n        self._update_regions()\n\n        # Get Log-Likelihood of data for Initialized model and save to\n        # variables tracking loglikely\n        self.compute_log_likelihood()\n\n    def update(self, loglikely_freq=1, verbose=2):\n        \"\"\"\n        Run a complete update cycle (sample z, sample y&r, update regions).\n\n        Parameters\n        ----------\n        loglikely_freq : :obj:`int`, optional\n            The frequency with which log-likelihood is updated. Default value\n            is 1 (log-likelihood is updated every iteration).\n        verbose : {0, 1, 2}, optional\n            Determines how much info is printed to console. 0 = none,\n            1 = a little, 2 = a lot. Default value is 2.\n        \"\"\"\n        self.iter += 1  # Update total iteration count\n\n        if verbose == 2:\n            LGR.info('Iter {0:04d}: Sampling z'.format(self.iter))\n        self.seed += 1\n        self._update_word_topic_assignments(self.seed)  # Update z-assignments\n\n        if verbose == 2:\n            LGR.info('Iter {0:04d}: Sampling y|r'.format(self.iter))\n        self.seed += 1\n        self._update_peak_assignments(self.seed)  # Update y-assignments\n\n        if verbose == 2:\n            LGR.info('Iter {0:04d}: Updating spatial params'.format(self.iter))\n        self._update_regions()  # Update gaussian estimates for all subregions\n\n        # Only update loglikelihood every 'loglikely_freq' iterations\n        # (Computing log-likelihood isn't necessary and slows things down a bit)\n        if self.iter % loglikely_freq == 0:\n            if verbose == 2:\n                LGR.info('Iter {0:04d}: Computing log-likelihood'.format(self.iter))\n            self.compute_log_likelihood()  # Compute log-likelihood of\n                                           # model in current state\n            if verbose > 0:\n                LGR.info('Iter {0:04d} Log-likely: x = {1:10.1f}, w = {2:10.1f}, '\n                         'tot = {3:10.1f}'.format(self.iter, self.loglikely_x[-1],\n                                                  self.loglikely_w[-1],\n                                                  self.loglikely_tot[-1]))\n\n    def run(n_iters=10, loglikely_freq=10, verbose=1):\n        \"\"\"\n        Run multiple iterations.\n        \"\"\"\n        for i in range(model.iter, n_iters):\n            model.update(loglikely_freq=loglikely_freq, verbose=verbose)\n\n    def _update_word_topic_assignments(self, randseed):\n        \"\"\"\n        Update wtoken_topic_idx (z) indicator variables assigning words->topics.\n\n        Parameters\n        ----------\n        randseed : :obj:`int`\n            Random seed for this iteration.\n        \"\"\"\n        # --- Seed random number generator\n        np.random.seed(randseed)  # pylint: disable=no-member\n\n        # Loop over all word tokens\n        for i_wtoken in range(len(self.wtoken_word_idx)):\n            # Get indices for current token\n            word = self.wtoken_word_idx[i_wtoken]  # w_i word-type\n            doc = self.wtoken_doc_idx[i_wtoken]  # w_i doc-index\n            topic = self.wtoken_topic_idx[i_wtoken]  # current topic assignment for\n                                                     # word token w_i\n\n            # Decrement count-matrices to remove current wtoken_topic_idx\n            self.n_word_tokens_word_by_topic[word, topic] -= 1\n            self.total_n_word_tokens_by_topic[0, topic] -= 1\n            self.n_word_tokens_doc_by_topic[doc, topic] -= 1\n\n            # Get sampling distribution:\n            #    p(z_i|z,d,w) ~ p(w|t) * p(t|d)\n            #                 ~ p_w_t * p_topic_g_doc\n            p_word_g_topic = (self.n_word_tokens_word_by_topic[word, :] + self.params['beta']) \/\\\n                             (self.total_n_word_tokens_by_topic +\n                              self.params['beta'] * len(self.word_labels))\n            p_topic_g_doc = self.n_peak_tokens_doc_by_topic[doc, :] + self.params['gamma']\n            probs = p_word_g_topic * p_topic_g_doc  # The unnormalized sampling distribution\n\n            # Sample a z_i assignment for the current word-token from the sampling distribution\n            probs = np.squeeze(probs) \/ np.sum(probs)  # Normalize the sampling\n                                                       # distribution\n            # Numpy returns a [1 x T] vector with a '1' in the index of sampled topic\n            vec = np.random.multinomial(1, probs)  # pylint: disable=no-member\n            topic = np.where(vec)[0][0]  # Extract selected topic from vector\n\n            # Update the indices and the count matrices using the sampled z assignment\n            self.wtoken_topic_idx[i_wtoken] = topic  # Update w_i topic-assignment\n            self.n_word_tokens_word_by_topic[word, topic] += 1\n            self.total_n_word_tokens_by_topic[0, topic] += 1\n            self.n_word_tokens_doc_by_topic[doc, topic] += 1\n\n    def _update_peak_assignments(self, randseed):\n        \"\"\"\n        Update y \/ r indicator variables assigning peaks->topics\/subregions.\n\n        Parameters\n        ----------\n        randseed : :obj:`int`\n            Random seed for this iteration.\n        \"\"\"\n        # Seed random number generator\n        np.random.seed(randseed)  # pylint: disable=no-member\n\n        # Retrieve p(x|r,y) for all subregions\n        peak_probs = self._get_peak_probs(self)\n\n        # Iterate over all peaks x, and sample a new y and r assignment for each\n        for i_ptoken in range(len(self.ptoken_doc_idx)):\n            doc = self.ptoken_doc_idx[i_ptoken]\n            topic = self.peak_topic_idx[i_ptoken]\n            region = self.peak_region_idx[i_ptoken]\n\n            # Decrement count in Subregion x Topic count matrix\n            self.n_peak_tokens_region_by_topic[region, topic] -= 1\n\n            # Decrement count in Document x Topic count matrix\n            self.n_peak_tokens_doc_by_topic[doc, topic] -= 1\n\n            # Retrieve the probability of generating current x from all\n            # subregions: [R x T] array of probs\n            p_x_subregions = (peak_probs[i_ptoken, :, :]).transpose()\n\n            # Compute the probabilities of all subregions given doc\n            #     p(r|d) ~ p(r|t) * p(t|d)\n            # Counts of subregions per topic + prior: p(r|t)\n            p_region_g_topic = self.n_peak_tokens_region_by_topic + self.params['delta']\n\n            # Normalize the columns such that each topic's distribution over\n            # subregions sums to 1\n            p_region_g_topic = p_region_g_topic \/ np.sum(p_region_g_topic, axis=0)\n\n            # Counts of topics per document + prior: p(t|d)\n            p_topic_g_doc = self.n_peak_tokens_doc_by_topic[doc, :] + self.params['alpha']\n\n            # Reshape from (ntopics,) to (nregions, ntopics) with duplicated rows\n            p_topic_g_doc = np.array([p_topic_g_doc] * self.params['n_regions'])\n\n            # Compute p(subregion | document): p(r|d) ~ p(r|t) * p(t|d)\n            # [R x T] array of probs\n            p_region_g_doc = p_topic_g_doc * p_region_g_topic\n\n            # Compute the multinomial probability: p(z|y)\n            # Need the current vector of all z and y assignments for current doc\n            # The multinomial from which z is sampled is proportional to number\n            # of y assigned to each topic, plus constant \\gamma\n            doc_y_counts = self.n_peak_tokens_doc_by_topic[doc, :] + self.params['gamma']\n            doc_z_counts = self.n_word_tokens_doc_by_topic[doc, :]\n            p_peak_g_topic = self._compute_prop_multinomial_from_zy_vectors(\n                doc_z_counts, doc_y_counts)\n\n            # Reshape from (ntopics,) to (nregions, ntopics) with duplicated rows\n            p_peak_g_topic = np.array([p_peak_g_topic] * self.params['n_regions'])\n\n            # Get the full sampling distribution:\n            # [R x T] array containing the proportional probability of all y\/r combinations\n            probs_pdf = p_x_subregions * p_region_g_doc * p_peak_g_topic\n\n            # Convert from a [R x T] matrix into a [R*T x 1] array we can sample from\n            probs_pdf = probs_pdf.transpose().ravel()\n\n            # Normalize the sampling distribution\n            probs_pdf = probs_pdf \/ np.sum(probs_pdf)\n\n            # Sample a single element (corresponding to a y_i and c_i assignment\n            # for the peak token) from the sampling distribution\n            # Returns a [1 x R*T] vector with a '1' in location that was sampled\n            vec = np.random.multinomial(1, probs_pdf)  # pylint: disable=no-member\n            sample_idx = np.where(vec)[0][0]  # Extract linear index value from vector\n\n            # Transform the linear index of the sampled element into the\n            # subregion\/topic (r\/y) assignment indices\n            # Subregion sampled (r)\n            region = np.remainder(sample_idx, self.params['n_regions'])  # pylint: disable=no-member\n            topic = int(np.floor(sample_idx \/ self.params['n_regions']))  # Topic sampled (y)\n\n            # Update the indices and the count matrices using the sampled y\/r assignments\n            self.n_peak_tokens_region_by_topic[region, topic] += 1  # Increment count in\n                                                                    # Subregion x Topic count\n                                                                    # matrix\n            self.n_peak_tokens_doc_by_topic[doc, topic] += 1  # Increment count in\n                                                              # Document x Topic count matrix\n            self.peak_topic_idx[i_ptoken] = topic  # Update y->topic assignment\n            self.peak_region_idx[i_ptoken] = region  # Update y->subregion assignment\n\n    def _update_regions(self):\n        \"\"\"\n        Update spatial distribution parameters (Gaussians params for all\n        subregions).\n        Updates regions_mu and regions_sigma, indicating location and\n        distribution of each subregion.\n        \"\"\"\n        # Generate default ROI based on default_width\n        default_roi = self.params['roi_size'] * np.eye(self.peak_vals.shape[1])\n\n        if not self.params['symmetric']:\n            # For each region, compute a mean and a regularized covariance matrix\n            for i_topic in range(self.params['n_topics']):\n                for j_region in range(self.params['n_regions']):\n                    # Get all peaks assigned to current topic & subregion\n                    idx = (self.peak_topic_idx == i_topic) & (self.peak_region_idx == j_region)\n                    vals = self.peak_vals[idx]\n                    n_obs = self.n_peak_tokens_region_by_topic[j_region, i_topic]\n\n                    # Estimate mean\n                    # If there are no observations, we set mean equal to zeros,\n                    # otherwise take MLE\n                    if n_obs == 0:\n                        mu = np.zeros([self.peak_vals.shape[1]])\n                    else:\n                        mu = np.mean(vals, axis=0)\n\n                    # Estimate covariance\n                    # if there are 1 or fewer observations, we set sigma_hat\n                    # equal to default ROI, otherwise take MLE\n                    if n_obs <= 1:\n                        c_hat = default_roi\n                    else:\n                        c_hat = np.cov(np.transpose(vals))\n\n                    # Regularize the covariance, using the ratio of observations\n                    # to dobs (default constant # observations)\n                    d_c = n_obs \/ (n_obs + self.params['dobs'])\n                    sigma = d_c * c_hat + (1-d_c) * default_roi\n\n                    # Store estimates in model object\n                    self.regions_mu[i_topic][j_region][:] = mu\n                    self.regions_sigma[i_topic][j_region][:] = sigma\n        else:\n            # With symmetric subregions, we jointly compute all estimates for\n            # subregions 1 & 2, constraining the means to be symmetric w.r.t.\n            # the origin along x-dimension\n            for i_topic in range(self.params['n_topics']):\n                # Get all peaks assigned to current topic & subregion 1\n                idx1 = (self.peak_topic_idx == i_topic) & (self.peak_region_idx == 0)\n                vals1 = self.peak_vals[idx1]\n                n_obs1 = self.n_peak_tokens_region_by_topic[0, i_topic]\n\n                # Get all peaks assigned to current topic & subregion 2\n                idx2 = (self.peak_topic_idx == i_topic) & (self.peak_region_idx == 1)\n                vals2 = self.peak_vals[idx2]\n                n_obs2 = self.n_peak_tokens_region_by_topic[1, i_topic]\n\n                # Get all peaks assigned to current topic & either subregion\n                allvals = self.peak_vals[idx1 | idx2]\n\n                # Estimate means\n                # If there are no observations, we set mean equal to zeros,\n                # otherwise take MLE\n\n                # Estimate independent mean for subregion 1\n                if n_obs1 == 0:\n                    m = np.zeros([self.peak_vals.shape[1]])\n                else:\n                    m = np.mean(vals1, axis=0)\n\n                # Estimate independent mean for subregion 2\n                if n_obs2 == 0:\n                    n = np.zeros([self.peak_vals.shape[1]])\n                else:\n                    n = np.mean(vals2, axis=0)\n\n                # Estimate the weighted means of all dims, where for dim1 we\n                # compute the mean w.r.t. absolute distance from the origin\n                weighted_mean_dim1 = (-m[0]*n_obs1 + n[0]*n_obs2) \/ (n_obs1 + n_obs2)\n                weighted_mean_otherdims = np.mean(allvals[:, 1:], axis=0)\n\n                # Store weighted mean estimates\n                mu1 = np.zeros([1, self.peak_vals.shape[1]])\n                mu2 = np.zeros([1, self.peak_vals.shape[1]])\n                mu1[0, 0] = -weighted_mean_dim1\n                mu1[0, 1:] = weighted_mean_otherdims\n                mu2[0, 0] = weighted_mean_dim1\n                mu2[0, 1:] = weighted_mean_otherdims\n\n                # Store estimates in model object\n                self.regions_mu[i_topic][0][:] = mu1\n                self.regions_mu[i_topic][1][:] = mu2\n\n                # Estimate Covariances\n                # Covariances are estimated independently\n                # Cov for subregion 1\n                if n_obs1 <= 1:\n                    c_hat1 = default_roi\n                else:\n                    c_hat1 = np.cov(np.transpose(vals1))\n\n                # Cov for subregion 2\n                if n_obs2 <= 1:\n                    c_hat2 = default_roi\n                else:\n                    c_hat2 = np.cov(np.transpose(vals2))\n\n                # Regularize the covariances, using the ratio of observations\n                # to sample_constant\n                d_c_1 = (n_obs1) \/ (n_obs1 + self.params['dobs'])\n                d_c_2 = (n_obs2) \/ (n_obs2 + self.params['dobs'])\n                sigma1 = d_c_1 * c_hat1 + (1 - d_c_1) * default_roi\n                sigma2 = d_c_2 * c_hat2 + (1 - d_c_2) * default_roi\n\n                # Store estimates in model object\n                self.regions_sigma[i_topic][0][:] = sigma1\n                self.regions_sigma[i_topic][1][:] = sigma2\n\n    @due.dcite(Doi('10.1145\/1577069.1755845'),\n               description='Describes method for computing log-likelihood '\n                           'used in model.')\n    def compute_log_likelihood(self, model=None, update_vectors=True):\n        \"\"\"\n        Compute Log-likelihood of a model object given current model.\n        Computes the log-likelihood of data in any model object (either train\n        or test) given the posterior predictive distributions over peaks and\n        word-types for the model. Note that this is not computing the joint\n        log-likelihood of model parameters and data.\n\n        Parameters\n        ----------\n        model : :obj:`gclda.Model`, optional\n            The model for which log-likelihoods will be calculated.\n            If not provided, log-likelihood will be calculated for the current\n            model (self).\n        update_vectors : :obj:`bool`, optional\n            Whether to update model's log-likelihood vectors or not.\n\n        Returns\n        -------\n        x_loglikely : :obj:`float`\n            Total log-likelihood of all peak tokens.\n        w_loglikely : :obj:`float`\n            Total log-likelihood of all word tokens.\n        tot_loglikely : :obj:`float`\n            Total log-likelihood of peak + word tokens.\n\n        References\n        ----------\n        [1] <NAME>., <NAME>., <NAME>., & <NAME>. (2009).\n        Distributed algorithms for topic models. Journal of Machine Learning\n        Research, 10(Aug), 1801-1828.\n        \"\"\"\n        if model is None:\n            model = self\n        elif update_vectors:\n            LGR.info('External model detected: Disabling update_vectors')\n            update_vectors = False\n\n        # Pre-compute all probabilities from count matrices that are needed\n        # for loglikelihood computations\n        # Compute docprobs for y = ND x NT: p( y_i=t | d )\n        doccounts = self.n_peak_tokens_doc_by_topic + self.params['alpha']\n        doccounts_sum = np.sum(doccounts, axis=1)\n        docprobs_y = np.transpose(np.transpose(doccounts) \/ doccounts_sum)\n\n        # Compute docprobs for z = ND x NT: p( z_i=t | y^(d) )\n        doccounts = self.n_peak_tokens_doc_by_topic + self.params['gamma']\n        doccounts_sum = np.sum(doccounts, axis=1)\n        docprobs_z = np.transpose(np.transpose(doccounts) \/ doccounts_sum)\n\n        # Compute regionprobs = NR x NT: p( r | t )\n        regioncounts = (self.n_peak_tokens_region_by_topic) + self.params['delta']\n        regioncounts_sum = np.sum(regioncounts, axis=0)\n        regionprobs = regioncounts \/ regioncounts_sum\n\n        # Compute wordprobs = NW x NT: p( w | t )\n        wordcounts = self.n_word_tokens_word_by_topic + self.params['beta']\n        wordcounts_sum = np.sum(wordcounts, axis=0)\n        wordprobs = wordcounts \/ wordcounts_sum\n\n        # Get the matrix giving p(x_i|r,t) for all x:\n        #    NY x NT x NR matrix of probabilities of all peaks given all\n        #    topic\/subregion spatial distributions\n        peak_probs = self._get_peak_probs(model)\n\n        # Compute observed peaks (x) Loglikelihood:\n        # p(x|model, doc) = p(topic|doc) * p(subregion|topic) * p(x|subregion)\n        #                 = p_topic_g_doc * p_region_g_topic * p_x_r\n        # Initialize variable tracking total loglikelihood of all x tokens\n        x_loglikely = 0\n\n        # Go over all observed peaks and add p(x|model) to running total\n        for i_ptoken in range(len(self.ptoken_doc_idx)):\n            doc = self.ptoken_doc_idx[i_ptoken] - 1  # convert didx from 1-idx to 0-idx\n            p_x = 0  # Running total for p(x|d) across subregions:\n                     # Compute p(x_i|d) for each subregion separately and then\n                     # sum across the subregions\n            for j_region in range(self.params['n_regions']):\n                # p(t|d) - p(topic|doc)\n                p_topic_g_doc = docprobs_y[doc]\n\n                # p(r|t) - p(subregion|topic)\n                p_region_g_topic = regionprobs[j_region]\n\n                # p(r|d) - p(subregion|document) = p(topic|doc)*p(subregion|topic)\n                p_region_g_doc = p_topic_g_doc * p_region_g_topic\n\n                # p(x|r) - p(x|subregion)\n                p_x_r = peak_probs[i_ptoken, :, j_region]\n\n                # p(x|subregion,doc) = sum_topics ( p(subregion|doc) * p(x|subregion) )\n                p_x_rd = np.dot(p_region_g_doc, p_x_r)\n                p_x += p_x_rd  # Add probability for current subregion to total\n                               # probability for token across subregions\n            # Add probability for current token to running total for all x tokens\n            x_loglikely += np.log(p_x)  # pylint: disable=no-member\n\n        # Compute observed words (w) Loglikelihoods:\n        # p(w|model, doc) = p(topic|doc) * p(word|topic)\n        #                 = p_topic_g_doc * p_w_t\n        w_loglikely = 0  # Initialize variable tracking total loglikelihood of all w tokens\n\n        # Compute a matrix of posterior predictives over words:\n        # = ND x NW p(w|d) = sum_t ( p(t|d) * p(w|t) )\n        p_wtoken_g_doc = np.dot(docprobs_z, np.transpose(wordprobs))\n\n        # Go over all observed word tokens and add p(w|model) to running total\n        for i_wtoken in range(len(self.wtoken_word_idx)):\n            # convert wtoken_word_idx from 1-idx to 0-idx\n            word_token = self.wtoken_word_idx[i_wtoken] - 1\n            # convert wtoken_doc_idx from 1-idx to 0-idx\n            doc = self.wtoken_doc_idx[i_wtoken] - 1\n            # Probability of sampling current w token from d\n            p_wtoken = p_wtoken_g_doc[doc, word_token]\n            # Add log-probability of current token to running total for all w tokens\n            w_loglikely += np.log(p_wtoken)  # pylint: disable=no-member\n        tot_loglikely = x_loglikely + w_loglikely\n\n        # Update model log-likelihood history vector (if update_vectors == True)\n        if update_vectors:\n            self.loglikely_iter.append(self.iter)\n            self.loglikely_x.append(x_loglikely)\n            self.loglikely_w.append(w_loglikely)\n            self.loglikely_tot.append(tot_loglikely)\n\n        # Return loglikely values (used when computing log-likelihood for a\n        # model-object containing hold-out data)\n        return (x_loglikely, w_loglikely, tot_loglikely)\n\n    def _get_peak_probs(self, model):\n        \"\"\"\n        Compute a matrix giving p(x|r,t), using all x values in a model\n        object, and each topic's spatial parameters.\n\n        Returns\n        -------\n        peak_probs : :obj:`numpy.ndarray` of :obj:`numpy.64`\n            nPeaks x nTopics x nRegions matrix of probabilities, giving\n            probability of sampling each peak (x) from all subregions.\n        \"\"\"\n        peak_probs = np.zeros(\n            (len(model.ptoken_doc_idx), self.params['n_topics'],\n             self.params['n_regions']), dtype=float)\n        for i_topic in range(self.params['n_topics']):\n            for j_region in range(self.params['n_regions']):\n                pdf = multivariate_normal.pdf(\n                    model.peak_vals,\n                    mean=self.regions_mu[i_topic][j_region][0],\n                    cov=self.regions_sigma[i_topic][j_region])\n                peak_probs[:, i_topic, j_region] = pdf\n        return peak_probs\n\n    def _compute_prop_multinomial_from_zy_vectors(self, z, y):\n        \"\"\"\n        Compute proportional multinomial probabilities of current x vector\n        given current y vector, for all proposed y_i values.\n        Note that this only returns values proportional to the relative\n        probabilities of all proposals for y_i.\n\n        Parameters\n        ----------\n        z : :obj:`numpy.ndarray` of :obj:`numpy.int64`\n            A 1-by-T vector of current z counts for document d.\n        y : :obj:`numpy.ndarray` of :obj:`numpy.float64`\n            A 1-by-T vector of current y counts (plus gamma) for document d.\n\n        Returns\n        -------\n        p : :obj:`numpy.ndarray` of :obj:`numpy.float64`\n            A 1-by-T vector giving the proportional probability of z, given\n            that topic t was incremented.\n        \"\"\"\n        # Compute the proportional probabilities in log-space\n        logp = z * np.log((y+1) \/ y)  # pylint: disable=no-member\n        p = np.exp(logp - np.max(logp))  # Add a constant before exponentiating\n                                         # to avoid any underflow issues\n        return p\n\n    def get_spatial_probs(self):\n        \"\"\"\n        Get conditional probability of selecting each voxel in the brain mask\n        given each topic.\n\n        Returns\n        -------\n        p_voxel_g_topic : :obj:`numpy.ndarray` of :obj:`numpy.float64`\n            A voxel-by-topic array of conditional probabilities: p(voxel|topic).\n            For cell ij, the value is the probability of voxel i being selected\n            given topic j has already been selected.\n        p_topic_g_voxel : :obj:`numpy.ndarray` of :obj:`numpy.float64`\n            A voxel-by-topic array of conditional probabilities: p(topic|voxel).\n            For cell ij, the value is the probability of topic j being selected\n            given voxel i is active.\n        \"\"\"\n        affine = self.mask_img.affine\n        mask_ijk = np.vstack(np.where(self.mask_img.get_data())).T\n        mask_xyz = nib.affines.apply_affine(affine, mask_ijk)\n\n        spatial_dists = np.zeros((mask_xyz.shape[0], self.params['n_topics']), float)\n        for i_topic in range(self.params['n_topics']):\n            for j_region in range(self.params['n_regions']):\n                pdf = multivariate_normal.pdf(\n                    mask_xyz,\n                    mean=self.regions_mu[i_topic][j_region][0],\n                    cov=self.regions_sigma[i_topic][j_region])\n                spatial_dists[:, i_topic] += pdf\n        p_topic_g_voxel = spatial_dists \/ np.sum(spatial_dists, axis=1)[:, None]\n        p_topic_g_voxel = np.nan_to_num(p_topic_g_voxel, 0)  # might be unnecessary\n\n        p_voxel_g_topic = spatial_dists \/ np.sum(spatial_dists, axis=0)[None, :]\n        p_voxel_g_topic = np.nan_to_num(p_voxel_g_topic, 0)  # might be unnecessary\n\n        return p_topic_g_voxel, p_voxel_g_topic\n\n    def save_model_params(self, out_dir, n_top_words=15):\n        \"\"\"\n        Run all export-methods: calls all save-methods to export parameters to\n        files.\n\n        Parameters\n        ----------\n        out_dir : :obj:`str`\n            The name of the output directory.\n        n_top_words : :obj:`int`, optional\n            The number of words associated with each topic to report in topic\n            word probabilities file.\n        \"\"\"\n        # If output directory doesn't exist, make it\n        if not isdir(out_dir):\n            mkdir(out_dir)\n\n        # print topic-word distributions for top-K words in easy-to-read format\n        out_file = join(out_dir, 'Topic_X_Word_Probs.csv')\n        self._save_topic_word_probs(out_file, n_top_words=n_top_words)\n\n        # print topic x word count matrix: m.n_word_tokens_word_by_topic\n        out_file = join(out_dir, 'Topic_X_Word_CountMatrix.csv')\n        self._save_topic_word_counts(out_file)\n\n        # print activation-assignments to topics and subregions:\n        # Peak_x, Peak_y, Peak_z, peak_topic_idx, peak_region_idx\n        out_file = join(out_dir, 'ActivationAssignments.csv')\n        self._save_activation_assignments(out_file)\n\n    def _save_activation_assignments(self, out_file):\n        \"\"\"\n        Save Peak->Topic and Peak->Subregion assignments for all x-tokens in\n        model to file.\n\n        Parameters\n        ----------\n        out_file : :obj:`str`\n            The name of the output file.\n        \"\"\"\n        ptopic_idx = self.peak_topic_idx[i_ptoken]+1\n        pregion_idx = self.peak_region_idx[i_ptoken]+1\n        data = np.hstack((self.peak_vals[i_ptoken, :3],\n                          ptopic_idx[:, None],\n                          pregion_idx[:, None]))\n\n        df = pd.DataFrame(data=data,\n                          columns=['Peak_X', 'Peak_Y', 'Peak_Z',\n                                   'Topic_Assignment', 'Subregion_Assignment'])\n        df.to_csv(out_file, index=False)\n\n    def _save_topic_word_counts(self, out_file):\n        \"\"\"\n        Save Topic->Word counts for all topics and words to file.\n\n        Parameters\n        ----------\n        out_file : :obj:`str`\n            The name of the output file.\n        \"\"\"\n        with open(out_file, 'w+') as fid:\n            # Print the topic-headers\n            fid.write('WordLabel,')\n            for i_topic in range(self.params['n_topics']):\n                fid.write('Topic_{0:02d},'.format(i_topic+1))\n            fid.write('\\n')\n\n            # For each row \/ wlabel: wlabel-string and its count under each\n            # topic (the \\phi matrix before adding \\beta and normalizing)\n            for i_word in range(len(self.word_labels)):\n                fid.write('{0},'.format(self.word_labels[i_word]))\n\n                # Print counts under all topics\n                for j_topic in range(self.params['n_topics']):\n                    fid.write('{0},'.format(self.n_word_tokens_word_by_topic[i_word,\n                                                                             j_topic]))\n                # Newline for next wlabel row\n                fid.write('\\n')\n\n    def _save_topic_word_probs(self, out_file, n_top_words=15):\n        \"\"\"\n        Save Topic->Word probability distributions for top K words to file.\n\n        Parameters\n        ----------\n        out_file : :obj:`str`\n            The name of the output file.\n        n_top_words : :obj:`int`, optional\n            The number of top words to be written out for each topic.\n        \"\"\"\n        with open(out_file, 'w+') as fid:\n            # Compute topic->word probs and marginal topic-probs\n            wprobs = self.n_word_tokens_word_by_topic + self.params['beta']\n\n            # Marginal topicprobs\n            topic_probs = np.sum(wprobs, axis=0) \/ np.sum(wprobs)\n            wprobs = wprobs \/ np.sum(wprobs, axis=0)  # Normalized word-probs\n\n            # Get the sorted probabilities and indices of words under each topic\n            rnk_vals = np.sort(wprobs, axis=0)\n            rnk_vals = rnk_vals[::-1]\n            rnk_idx = np.argsort(wprobs, axis=0)\n            rnk_idx = rnk_idx[::-1]\n\n            # Print the topic-headers\n            for i_topic in range(self.params['n_topics']):\n                # Print each topic and its marginal probability to columns\n                fid.write('Topic_{0:02d},{1:.4f},'.format(i_topic+1,\n                                                          topic_probs[i_topic]))\n            fid.write('\\n')\n\n            # Print the top K word-strings and word-probs for each topic\n            for i in range(n_top_words):\n                for j_topic in range(self.params['n_topics']):\n                    # Print the kth word in topic t and its probability\n                    fid.write('{0},{1:.4f},'.format(self.word_labels[rnk_idx[i, j_topic]],\n                                                    rnk_vals[i, j_topic]))\n                fid.write('\\n')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_72","text":"<reponame>zmlabe\/ExtremeEvents<gh_stars>1-10\n\"\"\"\nScript plots LRP maps for correct and incorrect cases\n\nAuthor    : <NAME>\nDate      : 19 January 2021\n\"\"\"\n\n### Import modules\nimport numpy as np\nimport scipy.stats as sts\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.basemap import Basemap, addcyclic, shiftgrid\nimport calc_Utilities as UT\nimport calc_dataFunctions as df\nimport palettable.cubehelix as cm\nimport palettable.scientific.sequential as ssss\nimport palettable.scientific.diverging as dddd\nimport calc_Stats as dSS\nimport cmocean\nfrom sklearn.metrics import accuracy_score\nfrom netCDF4 import Dataset\n\n### Set preliminaries\ndirectoryfigure = '\/Users\/zlabe\/Desktop\/ExtremeEvents_NewANN_v1\/LENS\/'\ndirectorydata = '\/Users\/zlabe\/Documents\/Research\/ExtremeEvents\/Data\/'\nreg_name = 'Globe'\ndataset = 'LENS'\ndataset_obs = '20CRv3'\nrm_ensemble_mean = True\nvariq = ['T2M']\nseasons = ['annual']\nland_only = False\nocean_only = False\nrm_merid_mean = False\nrm_annual_mean = False\nrm_ensemble_mean = True\nensnum = 40\nnum_of_class = 2\niterations = 100\nletters = [\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\"]\nlabely = [r'1920-2009',r'1920-2009',r'1920-2009',\n          r'2009-2099',r'2009-2099',r'2009-2099']\nheaders = [r'\\textbf{GOOD}',r'\\textbf{BAD}',r'\\textbf{DIFF}']\n\n### Create sample class labels for 1920-2099\nif num_of_class == 3:\n    yearlabels = np.arange(1920,2099+1,1)\n    lengthlabels = yearlabels.shape[0]\/\/num_of_class\n    array1 = np.asarray([0]*lengthlabels)\n    array2 = np.asarray([1]*lengthlabels)\n    array3 = np.asarray([2]*lengthlabels)\n    classesl = np.concatenate([array1,array2,array3],axis=None)\nelif num_of_class == 2:\n    yearlabels = np.arange(1920,2099+1,1)\n    lengthlabels = yearlabels.shape[0]\/\/num_of_class\n    array1 = np.asarray([0]*lengthlabels)\n    array2 = np.asarray([1]*lengthlabels)\n    classesl = np.concatenate([array1,array2],axis=None)\n    \n### Read in prediction data\ntrainq = np.genfromtxt(directorydata + 'training_Century_%s_%s_%s_%s_iterations%s_v3.txt' % (variq[0],seasons[0],reg_name,dataset,iterations))\ntestq = np.genfromtxt(directorydata + 'testing_Century_%s_%s_%s_%s_iterations%s_v3.txt' % (variq[0],seasons[0],reg_name,dataset,iterations))\nobsq = np.genfromtxt(directorydata + 'obsout_Century_%s_%s_%s_%s-%s_iterations%s_v3.txt' % (variq[0],seasons[0],reg_name,dataset_obs,dataset,iterations))\n    \n### Reshape\ntrain = np.reshape(trainq,(trainq.shape[0]\/\/yearlabels.shape[0],yearlabels.shape[0],trainq.shape[1]))\ntest = np.reshape(testq,(testq.shape[0]\/\/yearlabels.shape[0],yearlabels.shape[0],testq.shape[1]))\nobs = obsq\n\n### Read in LRP training data\ndata1 = Dataset(directorydata + 'LRP_Maps_train_AnnualT2M_LENS.nc')\nlat1 = data1.variables['lat'][:]\nlon1 = data1.variables['lon'][:]\nlrptrain = data1.variables['LRP'][:].reshape(train.shape[0],yearlabels.shape[0],lat1.shape[0]*lon1.shape[0])\ndata1.close()\n\n### Read in LRP testing data\ndata2 = Dataset(directorydata + 'LRP_Maps_test_AnnualT2M_LENS.nc')\nlrptest = data2.variables['LRP'][:].reshape(test.shape[0],yearlabels.shape[0],lat1.shape[0]*lon1.shape[0])\ndata2.close()\n\n### Meshgrid\nlon2,lat2 = np.meshgrid(lon1,lat1)\n\n###############################################################################\n###############################################################################\n###############################################################################\n### Calculate accuracy\ndef truelabel(data):\n    \"\"\"\n    Calculate argmax\n    \"\"\"\n    maxindexdata = np.empty((data.shape[0],data.shape[1]))\n    for i in range(data.shape[0]):\n        maxindexdata[i,:] = np.argmax(data[i,:,:],axis=1)    \n    meanmaxindexdata= np.nanmean(maxindexdata,axis=0)\n    \n    return maxindexdata,meanmaxindexdata\n\ndef accuracyTotalTime(data_pred,data_true):\n    \"\"\"\n    Compute accuracy for the entire time series\n    \"\"\"\n    accdata_pred = np.empty((data_pred.shape[0]))\n    for i in range(data_pred.shape[0]):\n        accdata_pred[i] = accuracy_score(data_true,data_pred[i,:])\n        \n    return accdata_pred\n\ndef accuracyTPeriodTime(data_pred,data_true):\n    \"\"\"\n    Compute accuracy for the three periods\n    \"\"\"\n    time = data_true.shape[0]\n    period = int(time\/\/2)\n    \n    accdata_pred = np.empty((data_pred.shape[0],2))\n    for i in range(data_pred.shape[0]):\n        for save,j in enumerate(range(0,time,period)):\n            accdata_pred[i,save] = accuracy_score(data_true[j:j+period],\n                                                data_pred[i,j:j+period])\n        \n    return accdata_pred\n\n### Calculate statistics\nindextrain,meanindextrain = truelabel(train)\nindextest,meanindextest = truelabel(test)\n\nacctrain = accuracyTotalTime(indextrain,classesl)\nacctest = accuracyTotalTime(indextest,classesl)\n\nperiodtrain = accuracyTPeriodTime(indextrain,classesl)\nperiodtest = accuracyTPeriodTime(indextest,classesl)\n\n### Save good lrp maps\ndef lrpType1(indexdata,lrpdata,classesl,lat1,lon1):\n    lrpdata_good = []\n    lrpdata_bad = []\n    for i in range(indexdata.shape[0]):\n        for j in range(int(indexdata.shape[1]-indexdata.shape[1]\/2)):\n            if indexdata[i,j] == classesl[j]:\n                lrpdata_good.append(lrpdata[i,j,:])\n            else:\n                lrpdata_bad.append(lrpdata[i,j,:])\n    lrpdata_goodmap = np.asarray(lrpdata_good).reshape(len(lrpdata_good),lat1.shape[0],lon1.shape[0])\n    lrpdata_badmap = np.asarray(lrpdata_bad).reshape(len(lrpdata_bad),lat1.shape[0],lon1.shape[0])\n    meangood_data = np.nanmean(lrpdata_goodmap,axis=0)\n    meanbad_data = np.nanmean(lrpdata_badmap,axis=0)\n    \n    sizegood = len(lrpdata_goodmap)\n    sizebad = len(lrpdata_badmap)\n    \n    return meangood_data,meanbad_data,sizegood,sizebad\n\ndef lrpType2(indexdata,lrpdata,classesl,lat1,lon1):\n    lrpdata_good = []\n    lrpdata_bad = []\n    for i in range(indexdata.shape[0]):\n        for j in range(int(indexdata.shape[1]-indexdata.shape[1]\/2)):\n            if indexdata[i,j] == classesl[int(indexdata.shape[1]\/2)+j]:\n                lrpdata_good.append(lrpdata[i,int(indexdata.shape[1]\/2)+j,:])\n            else:\n                lrpdata_bad.append(lrpdata[i,j,:])\n    lrpdata_goodmap = np.asarray(lrpdata_good).reshape(len(lrpdata_good),lat1.shape[0],lon1.shape[0])\n    lrpdata_badmap = np.asarray(lrpdata_bad).reshape(len(lrpdata_bad),lat1.shape[0],lon1.shape[0])\n    meangood_data = np.nanmean(lrpdata_goodmap,axis=0)\n    meanbad_data = np.nanmean(lrpdata_badmap,axis=0)\n    \n    sizegood = len(lrpdata_goodmap)\n    sizebad = len(lrpdata_badmap)\n    \n    return meangood_data,meanbad_data,sizegood,sizebad\n\ngoodtrain1,badtrain1,sizetraingood1,sizetrainbad1 = lrpType1(indextrain,lrptrain,classesl,lat1,lon1)\ngoodtest1,badtest1,sizetestgood1,sizetestbad1  = lrpType1(indextest,lrptest,classesl,lat1,lon1)\ndifftrain_1 = goodtrain1 - badtrain1\ndifftest_1 = goodtest1 - badtest1\n\ngoodtrain2,badtrain2,sizetraingood2,sizetrainbad2 = lrpType2(indextrain,lrptrain,classesl,lat1,lon1)\ngoodtest2,badtest2,sizetestgood2,sizetestbad2  = lrpType2(indextest,lrptest,classesl,lat1,lon1)\ndifftrain_2 = goodtrain2 - badtrain2\ndifftest_2 = goodtest2 - badtest2\n\ntrainplot = [goodtrain1,badtrain1,difftrain_1,\n              goodtrain2,badtrain2,difftrain_2]\ntestplot = [goodtest1,badtest1,difftest_1,\n              goodtest2,badtest2,difftest_2]\n\n#######################################################################\n#######################################################################\n#######################################################################\n### Plot subplot of LRP means\nplt.rc('text',usetex=True)\nplt.rc('font',**{'family':'sans-serif','sans-serif':['<NAME>']}) \n\nlimit = np.arange(0,0.5001,0.005)\nbarlim = np.round(np.arange(0,0.6,0.1),2)\nlimitdiff = np.arange(-0.3,0.301,0.0025)\nbarlimdiff = np.round(np.arange(-0.3,0.31,0.15),2)\ncmap = [cm.cubehelix2_16.mpl_colormap,cm.cubehelix2_16.mpl_colormap,dddd.Berlin_12.mpl_colormap,\n         cm.cubehelix2_16.mpl_colormap,cm.cubehelix2_16.mpl_colormap,dddd.Berlin_12.mpl_colormap]\nlimits = [limit,limit,limitdiff,limit,limit,limitdiff]\nbarlimits = [barlim,barlimdiff]\nlabel = r'\\textbf{RELEVANCE}'\nlabeldiff = r'\\textbf{LRP DIFFERENCE}'\n\nfig = plt.figure(figsize=(9,4))\nfor r in range(len(trainplot)):\n    var = trainplot[r]\n    \n    ax1 = plt.subplot(2,3,r+1)\n    m = Basemap(projection='moll',lon_0=0,resolution='l',area_thresh=10000)\n    circle = m.drawmapboundary(fill_color='dimgrey')\n    circle.set_clip_on(False) \n    if any([r==0,r==1,r==3,r==4]):\n        m.drawcoastlines(color='darkgrey',linewidth=0.3)\n    elif any([r==2,r==5]):\n        m.drawcoastlines(color='darkgrey',linewidth=0.3)\n        \n    var, lons_cyclic = addcyclic(var, lon1)\n    var, lons_cyclic = shiftgrid(180., var, lons_cyclic, start=False)\n    lon2d, lat2d = np.meshgrid(lons_cyclic, lat1)\n    x, y = m(lon2d, lat2d)\n       \n    circle = m.drawmapboundary(fill_color='dimgrey',color='dimgray',\n                      linewidth=0.7)\n    circle.set_clip_on(False)\n    \n    if any([r==0,r==1,r==3,r==4]):\n        cs1 = m.contourf(x,y,var,limits[r],extend='max')\n        cs1.set_cmap(cmap[r]) \n    elif any([r==2,r==5]):\n        cs2 = m.contourf(x,y,var,limits[r],extend='both')\n        cs2.set_cmap(cmap[r]) \n            \n    if any([r==0,r==3]):\n        ax1.annotate(r'\\textbf{%s}' % labely[r],xy=(0,0),xytext=(-0.07,0.5),\n                      textcoords='axes fraction',color='k',fontsize=10,\n                      rotation=90,ha='center',va='center')\n    if any([r==0,r==1,r==2]):\n        ax1.annotate(r'\\textbf{%s}' % headers[r],xy=(0,0),xytext=(0.5,1.10),\n                      textcoords='axes fraction',color='dimgrey',fontsize=20,\n                      rotation=0,ha='center',va='center')\n    ax1.annotate(r'\\textbf{[%s]}' % letters[r],xy=(0,0),xytext=(0.86,0.97),\n                  textcoords='axes fraction',color='k',fontsize=6,\n                  rotation=330,ha='center',va='center')\n    \n###############################################################################\ncbar_ax1 = fig.add_axes([0.2,0.09,0.3,0.03])                \ncbar1 = fig.colorbar(cs1,cax=cbar_ax1,orientation='horizontal',\n                    extend='max',extendfrac=0.07,drawedges=False)\ncbar1.set_label(label,fontsize=9,color='dimgrey',labelpad=1.4)  \ncbar1.set_ticks(barlimits[0])\ncbar1.set_ticklabels(list(map(str,barlimits[0])))\ncbar1.ax.tick_params(axis='x', size=.01,labelsize=5)\ncbar1.outline.set_edgecolor('dimgrey')\n\n###############################################################################\ncbar_ax2 = fig.add_axes([0.675,0.09,0.3,0.03])                \ncbar2 = fig.colorbar(cs2,cax=cbar_ax2,orientation='horizontal',\n                    extend='both',extendfrac=0.07,drawedges=False)\ncbar2.set_label(labeldiff,fontsize=9,color='dimgrey',labelpad=1.4)  \ncbar2.set_ticks(barlimits[1])\ncbar2.set_ticklabels(list(map(str,barlimits[1])))\ncbar2.ax.tick_params(axis='x', size=.01,labelsize=5)\ncbar2.outline.set_edgecolor('dimgrey')\n\nplt.tight_layout()\nplt.subplots_adjust(top=0.85,wspace=0.02,hspace=0.02,bottom=0.14)\n\nplt.savefig(directoryfigure + 'training_differenceLRP_composites_LENS.png',dpi=300)\n\n#######################################################################\n#######################################################################\n#######################################################################\n### Plot subplot of LRP means testing\nplt.rc('text',usetex=True)\nplt.rc('font',**{'family':'sans-serif','sans-serif':['Avant Garde']}) \n\nlimit = np.arange(0,0.5001,0.005)\nbarlim = np.round(np.arange(0,0.6,0.1),2)\nlimitdiff = np.arange(-0.3,0.301,0.0025)\nbarlimdiff = np.round(np.arange(-0.3,0.31,0.15),2)\ncmap = [cm.cubehelix2_16.mpl_colormap,cm.cubehelix2_16.mpl_colormap,dddd.Berlin_12.mpl_colormap,\n          cm.cubehelix2_16.mpl_colormap,cm.cubehelix2_16.mpl_colormap,dddd.Berlin_12.mpl_colormap]\nlimits = [limit,limit,limitdiff,limit,limit,limitdiff]\nbarlimits = [barlim,barlimdiff]\nlabel = r'\\textbf{RELEVANCE}'\nlabeldiff = r'\\textbf{LRP DIFFERENCE}'\n\nfig = plt.figure(figsize=(9,4))\nfor r in range(len(testplot)):\n    var = testplot[r]\n    \n    ax1 = plt.subplot(2,3,r+1)\n    m = Basemap(projection='moll',lon_0=0,resolution='l',area_thresh=10000)\n    circle = m.drawmapboundary(fill_color='dimgrey')\n    circle.set_clip_on(False) \n    if any([r==0,r==1,r==3,r==4]):\n        m.drawcoastlines(color='darkgrey',linewidth=0.27)\n    elif any([r==2,r==5]):\n        m.drawcoastlines(color='darkgrey',linewidth=0.27)\n        \n    var, lons_cyclic = addcyclic(var, lon1)\n    var, lons_cyclic = shiftgrid(180., var, lons_cyclic, start=False)\n    lon2d, lat2d = np.meshgrid(lons_cyclic, lat1)\n    x, y = m(lon2d, lat2d)\n       \n    circle = m.drawmapboundary(fill_color='dimgrey',color='dimgray',\n                      linewidth=0.7)\n    circle.set_clip_on(False)\n    \n    if any([r==0,r==1,r==3,r==4]):\n        cs1 = m.contourf(x,y,var,limits[r],extend='max')\n        cs1.set_cmap(cmap[r]) \n    elif any([r==2,r==5]):\n        cs2 = m.contourf(x,y,var,limits[r],extend='both')\n        cs2.set_cmap(cmap[r]) \n            \n    if any([r==0,r==3]):\n        ax1.annotate(r'\\textbf{%s}' % labely[r],xy=(0,0),xytext=(-0.07,0.5),\n                      textcoords='axes fraction',color='k',fontsize=10,\n                      rotation=90,ha='center',va='center')\n    if any([r==0,r==1,r==2]):\n        ax1.annotate(r'\\textbf{%s}' % headers[r],xy=(0,0),xytext=(0.5,1.10),\n                      textcoords='axes fraction',color='dimgrey',fontsize=20,\n                      rotation=0,ha='center',va='center')\n    ax1.annotate(r'\\textbf{[%s]}' % letters[r],xy=(0,0),xytext=(0.86,0.97),\n                  textcoords='axes fraction',color='k',fontsize=6,\n                  rotation=330,ha='center',va='center')\n    \n###############################################################################\ncbar_ax1 = fig.add_axes([0.2,0.09,0.3,0.03])                \ncbar1 = fig.colorbar(cs1,cax=cbar_ax1,orientation='horizontal',\n                    extend='max',extendfrac=0.07,drawedges=False)\ncbar1.set_label(label,fontsize=9,color='dimgrey',labelpad=1.4)  \ncbar1.set_ticks(barlimits[0])\ncbar1.set_ticklabels(list(map(str,barlimits[0])))\ncbar1.ax.tick_params(axis='x', size=.01,labelsize=5)\ncbar1.outline.set_edgecolor('dimgrey')\n\n###############################################################################\ncbar_ax2 = fig.add_axes([0.675,0.09,0.3,0.03])                \ncbar2 = fig.colorbar(cs2,cax=cbar_ax2,orientation='horizontal',\n                    extend='both',extendfrac=0.07,drawedges=False)\ncbar2.set_label(labeldiff,fontsize=9,color='dimgrey',labelpad=1.4)  \ncbar2.set_ticks(barlimits[1])\ncbar2.set_ticklabels(list(map(str,barlimits[1])))\ncbar2.ax.tick_params(axis='x', size=.01,labelsize=5)\ncbar2.outline.set_edgecolor('dimgrey')\n\nplt.tight_layout()\nplt.subplots_adjust(top=0.85,wspace=0.02,hspace=0.02,bottom=0.14)\n\nplt.savefig(directoryfigure + 'testing_differenceLRP_composites_LENS.png',dpi=300)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_73","text":"<reponame>ptro-development\/trader\nimport pydot\nimport numpy\n\nfrom scipy.stats.stats import pearsonr\n\nfrom trader.libs.samples import get_leaf_atrribute_number, \\\n    get_key_sample_data\n\n\nclass Leaf(object):\n\n    def __init__(self, key, data, previous_leaf):\n        self.key = key\n        self.data = data\n        self.previous_leaf = previous_leaf\n        self.next_leafs = []\n\n    def __str__(self):\n        return \"<id:\" + str(id(self)) + \" key:\" + str(self.key) + \" data:\" + str(self.data) + \\\n            \" next_leafs count:\" + str(len(self.next_leafs)) + \">\"\n\n    def is_last_leaf(self):\n        return len(self.get_next_leafs()) == 0\n\n    def get_key(self):\n        return self.key\n\n    def get_data(self):\n        return self.data\n\n    def set_data(self, data):\n        self.data = data\n\n    def get_next_leafs(self):\n        return self.next_leafs\n\n    def get_previous_leaf(self):\n        return self.previous_leaf\n\n    def add_leaf(self, key, data):\n        new_leaf = Leaf(key, data, self)\n        self.next_leafs.append(new_leaf)\n        return new_leaf\n\n    def get_leafs(self, keys):\n        return filter(\n            lambda x: x.get_key() in keys,\n            self.next_leafs\n        )\n\n\nclass TradeSequenceTree(object):\n\n    def __init__(\n            self, found_sample_keys,\n            not_found_sample_keys,\n            common_leafs_atributes,\n            common_leafs_atributes_key_index_map):\n        self.found_sample_keys = found_sample_keys\n        self.not_found_sample_keys = not_found_sample_keys\n        self.common_leafs_atributes = common_leafs_atributes\n        self.common_leafs_atributes_key_index_map = common_leafs_atributes_key_index_map  # noqa\n        self.first_leaf = Leaf(None, None, None)\n\n    def get_root(self):\n        return self.first_leaf\n\n    def get_found_sample_keys(self):\n        return self.found_sample_keys\n\n    def get_not_found_sample_keys(self):\n        return self.not_found_sample_keys\n\n    def get_all_sample_keys(self):\n        return self.found_sample_keys + self.not_found_sample_key\n\n    def get_common_leafs_atributes(self):\n        return self.common_leafs_atributes\n\n    def get_common_leafs_atributes_key_index_map(self):\n        return self.common_leafs_atributes_key_index_map\n\n\ndef get_next_not_found_leafs_extended(last_leaf, not_found_keys):\n    assert isinstance(last_leaf, Leaf) and last_leaf is not None\n    assert isinstance(not_found_keys, list) and len(not_found_keys) != 0\n    # [[leaf, length, probability], ...]\n    data = []\n    overall_count = 0\n    for n_leaf in last_leaf.get_leafs(not_found_keys):\n        count = n_leaf.get_data()[\"count\"]\n        if count > 0:\n            overall_count += count\n            #data.append([n_leaf, int(n_leaf.get_key()[1:]), count])\n            for volatility_set in n_leaf.get_data()[\"volatilities\"]:\n                data_to_add = [n_leaf, int(n_leaf.get_key()[1:]), count]\n                data_to_add.extend(volatility_set)\n                data.append(data_to_add)\n            # data.append([n_leaf, int(n_leaf.get_key()[1:])])\n    # compute probability\n    for index, bit in enumerate(data):\n        data[index][2] = float(bit[2]) \/ overall_count\n        # pass\n    # print \"not_found data\", data\n    return data\n\n\ndef get_next_found_leafs_extended(\n        key, last_leaf, found_keys, common_leaf_attributes, samples):\n    \"\"\"\n    To compute array of leafs characteristics against incoming key.\n\n    [[leaf, attribute_number, probability, correlation, volatilities_1, volatilities_2, ...], ...]\n\n    last_leaf - represents previous leaf\n    found_keys - are used to do selection on next leafs\n    common_leaf_attributes -\n    samples -\n    \"\"\"\n    assert isinstance(last_leaf, Leaf) and last_leaf is not None\n    assert isinstance(found_keys, list) and len(found_keys) != 0\n    assert isinstance(common_leaf_attributes, dict) and len(common_leaf_attributes) != 0  # noqa\n    assert isinstance(samples, list) and len(found_keys) != 0\n    data = []\n    overall_count = 0\n    key_sample_data = get_key_sample_data(key, samples)\n    #print last_leaf.get_leafs(found_keys)\n    #import sys; sys.exit();\n    for n_leaf in last_leaf.get_leafs(found_keys):\n        volatilities = []\n        count = n_leaf.get_data()[\"count\"]\n        # print \"n_leaf\", n_leaf, count\n        if count > 0:\n            overall_count += count\n            n_attribute = get_leaf_atrribute_number(\n                n_leaf.get_key(), common_leaf_attributes)\n            n_key_sample_data_b = get_key_sample_data(\n                n_leaf.get_key(), samples)\n            # print \"key_sample_data\", key_sample_data, \"n_key_sample_data_b\", n_key_sample_data_b  # noqa\n            correlation, other = pearsonr(key_sample_data, n_key_sample_data_b)\n            # TODO: compute volatilities\n            # only volatilities after re-sampling should be used, so from tree\n            # print \"correlation\", correlation\n            for volatility_set in n_leaf.get_data()[\"volatilities\"]:\n                data_to_add = [n_leaf, n_attribute, count, correlation]\n                data_to_add.extend(volatility_set)\n                data.append(data_to_add)\n            # data.append([n_leaf, n_attribute])\n    # compute probability\n    for index, bit in enumerate(data):\n        data[index][2] = float(bit[2]) \/ overall_count\n        # pass\n    return data\n\n\ndef get_leafs_chain(tree, leafs_key_sequence):\n    success = True\n    chain = []\n    chain.append(tree.get_root())\n    for index, key in enumerate(leafs_key_sequence):\n        tmp_leaf = chain[-1].get_leafs([key])\n        if tmp_leaf:\n            chain.append(tmp_leaf[0])\n        else:\n            success = False\n            break\n    return (success, chain)\n\n\ndef get_last_leaf_in_leafs_chain(tree, leafs_key_sequence):\n    success = True\n    last_leaf = tree.get_root()\n    for key in leafs_key_sequence:\n        tmp_leaf = last_leaf.get_leafs([key])\n        if tmp_leaf:\n            last_leaf = tmp_leaf\n        else:\n            success = False\n            break\n    if success:\n        return last_leaf\n    else:\n        return None\n\n\ndef get_leaf_samples_count(leaf, keys):\n    return sum(\n        leaf.get_data()[\"count\"] for leaf in leaf.get_leafs(keys))\n\n\ndef get_leafs_chain_probability_report(tree, leafs_key_sequence):\n    success, chain = get_leafs_chain(\n        tree, leafs_key_sequence)\n    if success:\n        print \"Whole sample probability chain:\"\n    else:\n        print \"Not whole sample probability chain was found.\"\n    data = []\n    for leaf in chain:\n        found_probability, not_found_probability = get_leaf_next_probabilities(\n            leaf, tree)\n        data.append(\n            leaf.get_key(),\n            found_probability, not_found_probability)\n    print data\n\n\ndef get_last_leafs(leaf, depth):\n    if depth != 0:\n        depth -= 1\n        for leaf in leaf.get_next_leafs():\n            if leaf.is_last_leaf():\n                yield leaf\n            else:\n                for n_leaf in get_last_leafs(leaf, depth):\n                    yield n_leaf\n    else:\n        yield leaf\n\n\ndef get_leafs_samples_chain(leaf, root_leaf):\n    yield leaf\n    if not leaf.get_previous_leaf() == root_leaf:\n        for n_leaf in get_leafs_samples_chain(\n                leaf.get_previous_leaf(), root_leaf):\n            yield n_leaf\n\n\ndef reset_tree_counters(root_leaf):\n    for leaf in root_leaf.get_next_leafs():\n        data = leaf.get_data()\n        data[\"count\"] = 0\n        leaf.set_data(data)\n        if not leaf.is_last_leaf():\n            reset_tree_counters(leaf)\n\n\ndef reset_tree_volatilities(root_leaf):\n    for leaf in root_leaf.get_next_leafs():\n        data = leaf.get_data()\n        data[\"volatilities\"] = []\n        leaf.set_data(data)\n        if not leaf.is_last_leaf():\n            reset_tree_counters(leaf)\n\n\ndef reset_tree_values(root_leaf):\n    reset_tree_counters(root_leaf)\n    reset_tree_volatilities(root_leaf)\n\n\ndef normalise_tree_volatilities(root_leaf, linear_normalisation):\n    for leaf in root_leaf.get_next_leafs():\n        data = leaf.get_data()\n        if \"volatilities\" in data:\n            normalised_volatilities = []\n            for volatilities in data[\"volatilities\"]:\n                normalised_volatilities.append(\n                    linear_normalisation.normalise_array(volatilities))\n            data[\"volatilities\"] = normalised_volatilities\n            leaf.set_data(data)\n            if not leaf.is_last_leaf():\n                normalise_tree_volatilities(leaf, linear_normalisation)\n\n\ndef get_leafs_layers(leafs, depth=0):\n    next_leafs = []\n    for leaf in leafs:\n        next_leafs.extend(\n            leaf.get_next_leafs())\n    if next_leafs:\n        yield next_leafs\n        if depth > 0:\n            for layer in get_leafs_layers(next_leafs, depth-1):\n                yield layer\n\n\ndef get_next_leafs_extended(leaf):\n    known = []\n    unknown = []\n    for n_leaf in leaf.get_next_leafs():\n        if isinstance(n_leaf.get_key(), basestring):\n            unknown.append(n_leaf)\n        else:\n            known.append(n_leaf)\n    return known, unknown\n\n\ndef get_leafs_layers_extended(leafs, depth=0):\n    known_next = []\n    unknown_next = []\n    for leaf in leafs:\n        known, unknown = get_next_leafs_extended(leaf)\n        known_next.extend(known)\n        unknown_next.extend(unknown)\n    if known_next or unknown_next:\n        yield known_next, unknown_next\n        if depth > 0:\n            for known, unknown in get_leafs_layers_extended(\n                    known_next + unknown_next, depth-1):\n                yield known, unknown\n\n\ndef get_leafs_probabilities(leafs, tree):\n    counts = numpy.array((9 * [0.0]))\n    key_count_map = tree.get_common_leafs_atributes_key_index_map()\n    atributes = tree.get_common_leafs_atributes()\n    all_count = 0.0\n    for leaf in leafs:\n        count = leaf.get_data()[\"count\"]\n        counts[\n            key_count_map[\n                atributes[leaf.get_key()]]] += count\n        all_count += count\n    if all_count > 0:\n        counts \/= all_count\n    return counts\n\n\ndef get_in_layer_match_probability(\n        tree, layer_position, starting_layers_counts):\n    current_layers_counts = get_tree_layers_counts(tree, layer_position)\n    probability = 0.0\n    if layer_position > -1 and layer_position < len(current_layers_counts):\n        current_count = float(current_layers_counts[layer_position])\n        if current_count > 0:\n            probability += current_count \/ starting_layers_counts[\n                layer_position]\n    return probability\n\n\ndef get_in_layer_match_probability_extended(\n        tree, layer_position,\n        starting_layers_counts_known, starting_layers_counts_unknown):\n    assert isinstance(starting_layers_counts_known, list) and \\\n        len(starting_layers_counts_known) != 0\n    assert isinstance(starting_layers_counts_unknown, list) and \\\n        len(starting_layers_counts_unknown) != 0\n    assert isinstance(layer_position, int)\n    assert isinstance(tree, TradeSequenceTree)\n    current_layers_counts_known, current_layers_counts_unknown = get_tree_layers_counts_extended(  # noqa\n        tree, layer_position)\n    # [know, unknown]\n    probability = [0.0, 0.0]\n    starting_layers = (\n        starting_layers_counts_known, starting_layers_counts_unknown)\n    for index, current_layers in enumerate((\n            current_layers_counts_known, current_layers_counts_unknown)):\n        if layer_position > -1 and layer_position < len(current_layers):\n            current_count = float(current_layers[layer_position])\n            if current_count > 0:\n                probability[index] += current_count \/ starting_layers[index][\n                    layer_position]\n    return probability\n\n\ndef get_leafs_count(leafs):\n    count = 0.0\n    for leaf in leafs:\n        count += leaf.get_data()[\"count\"]\n    return count\n\n\ndef get_leaf_next_probabilities(leaf, tree):\n    # counts array\n    # [found_count, not_found_count]\n    counts = [0, 0]\n    counts[0] = get_leaf_samples_count(\n        leaf, tree.get_found_sample_keys())\n    counts[1] = get_leaf_samples_count(\n        leaf, tree.get_not_found_sample_keys())\n    all_count = sum(counts)\n    probabilities = 2 * [-1.0]\n    for index, count in enumerate(counts):\n        if count > 0:\n            probabilities[index] = count \/ float(all_count)\n    return probabilities\n\n\ndef get_extended_leaf_next_probabilities(leaf, tree, depth=0):\n    counts = numpy.array((9 * [0.0]))\n    key_count_map = tree.get_common_leafs_atributes_key_index_map()\n    atributes = tree.get_common_leafs_atributes()\n    all_count = 0.0\n    for next_leaf in leaf.get_next_leafs():\n        count = next_leaf.get_data()[\"count\"]\n        counts[\n            key_count_map[\n                atributes[next_leaf.get_key()]]] += count\n        all_count += count\n    if all_count > 0:\n        counts \/= all_count\n    print \"depth A\", depth\n    yield counts\n    if depth > 0:\n        print \"depth B\", depth\n        counts_next = numpy.array((9 * [0.0]))\n        for next_leaf in leaf.get_next_leafs():\n            if not next_leaf.is_last_leaf():\n                for prob in get_extended_leaf_next_probabilities(\n                        next_leaf, tree, depth-1):\n                    counts_next += prob\n                all_counts = sum(counts_next)\n                if all_counts > 0:\n                    counts_next \/= float(all_counts)\n        yield counts_next\n\n\ndef report_extended_leaf_next_probabilities_old(leaf, tree, depth=0):\n    key_count_map = tree.get_common_leafs_atributes_key_index_map()\n    prob = [p for p in get_extended_leaf_next_probabilities(\n        leaf, tree, depth)]\n    new_chain = reversed(\n        list(get_leafs_samples_chain(leaf, tree.get_root())))\n    common_leaf_atributes = tree.get_common_leafs_atributes()\n    print \"Chain: \" + \"->\".join(\n        [str(l.get_key()) + \"(%s)\" % common_leaf_atributes[l.get_key()] for l in new_chain])  # noqa\n    for index, p in enumerate(prob):\n        data = zip(\n            sorted(key_count_map.items(), key=lambda x: x[1]), p)\n        report = [str(d[0][0]) + \":\" + \"%.3f\" % d[1] for d in data]\n        print \"Level \" + str(index) + \" \" + \" \".join(report)\n\n\ndef report_extended_leaf_next_probabilities(leaf, tree, depth=0):\n    key_count_map = tree.get_common_leafs_atributes_key_index_map()\n    new_chain = reversed(\n        list(get_leafs_samples_chain(leaf, tree.get_root())))\n    common_leaf_atributes = tree.get_common_leafs_atributes()\n    print \"Chain: \" + \"->\".join(\n        [str(l.get_key()) + \"(%s)\" % common_leaf_atributes[l.get_key()] for l in new_chain])  # noqa\n    for index, layer in enumerate(get_leafs_layers([leaf], depth)):\n        prob = get_leafs_probabilities(layer, tree)\n        data = zip(\n            sorted(key_count_map.items(), key=lambda x: x[1]), prob)\n        report = [str(d[0][0]) + \":\" + \"%.3f\" % d[1] for d in data]\n        print \"Level \" + str(index) + \" \" + \" \".join(report)\n\n\ndef get_next_leafs_chains_report(tree, leafs_key_sequence, depth):\n    success, chain = get_leafs_chain(\n        tree, leafs_key_sequence)\n    if success:\n        found_chains = []\n        not_found_chains = []\n        for leaf in get_last_leafs(chain[-1], depth):\n            new_chain = reversed(\n                list(get_leafs_samples_chain(leaf, tree.get_root())))\n            if leaf.get_key() in tree.get_found_sample_keys():\n                found_chains.append(new_chain)\n            else:\n                not_found_chains.append(new_chain)\n        probabilities = get_leaf_next_probabilities(\n            chain[-1], tree)\n        print \"For sequence:%s depth:%s is found_chains:%s not_found_chains:%s found_probability:%.3f not_found_probability:%.3f\" % (  # noqa\n            leafs_key_sequence, depth,\n            len(found_chains), len(not_found_chains),\n            probabilities[0], probabilities[1])\n\n\ndef update_top_leaf_counts(\n        tree, future_trails, top_leaf_key,\n        next_leaf_key, positive_or_negative,\n        report_probabilities=False, depth=0):\n    tmp = []\n    while(future_trails[top_leaf_key]):\n        leaf = future_trails[top_leaf_key].pop()\n        found_leaf = leaf.get_leafs([next_leaf_key])\n        if found_leaf:\n            leaf = found_leaf[0]\n            data = leaf.get_data()\n            if positive_or_negative:\n                data[\"count\"] += 1\n            else:\n                data[\"count\"] -= 1\n            leaf.set_data(data)\n            if report_probabilities:\n                report_extended_leaf_next_probabilities(\n                    leaf, tree, depth)\n            if not leaf.is_last_leaf():\n                tmp.append(leaf)\n            else:\n                pass\n                # add finished trail into results\n                # for accounting\n        else:\n            pass\n            \"\"\" This scenario should not be covered\n            as there is supposed to be always the first\n            match and next is not guarantied.\n            \"\"\"\n    if tmp:\n        future_trails[top_leaf_key] = tmp\n\n\ndef update_top_leafs_counts(\n        future_trails, incoming_sequence_key,\n        tree, top_leafs_keys, positive_or_negative=True,\n        report_probabilities=False, depth=0):\n    if incoming_sequence_key in top_leafs_keys:\n        root_leaf = tree.get_root()\n        future_trails[incoming_sequence_key].append(root_leaf)\n    # do processing of new key for existing future trail\n    for top_leaf_key in top_leafs_keys:\n        update_top_leaf_counts(\n            tree, future_trails, top_leaf_key,\n            incoming_sequence_key, positive_or_negative,\n            report_probabilities, depth)\n\n\ndef update_top_leafs_counts_2(\n        tree_trails, start_end_positions,\n        incoming_sequence_key, positive_or_negative,\n        depth=10):\n    tree_trails.append(incoming_sequence_key)\n    tree_trails.update(\n        incoming_sequence_key, start_end_positions,\n        positive_or_negative, depth)\n\n\ndef generate_tree_edge(leaf, graph, depth=0, color=\"black\", common_leafs=True):\n    if leaf.get_previous_leaf():\n        key = str(leaf.get_key()) + \"_\" + str(depth)\n        if not common_leafs:\n            key += \"_\" + str(leaf.get_previous_leaf().get_key())\n    else:\n        key = str(leaf.get_key()) + \"_\" + str(depth)\n    depth += 1\n    for n_leaf in leaf.get_next_leafs():\n        key_next = str(n_leaf.get_key()) + \"_\" + str(depth)\n        if not common_leafs:\n            key_next += \"_\" + str(leaf.get_key())\n        edge = pydot.Edge(\n            key, key_next,\n            label=str(n_leaf.get_data()[\"count\"]),\n            labelfontcolor=\"#009933\",\n            fontsize=\"10.0\",\n            color=color)\n        graph.add_edge(edge)\n        generate_tree_edge(n_leaf, graph, depth, color)\n\n\ndef generate_tree_chart(file_path, tree, size=None):\n    if size:\n        graph = pydot.Dot(graph_type=\"graph\", size=size)\n    else:\n        graph = pydot.Dot(graph_type=\"graph\", overlap=\"False\")\n    generate_tree_edge(tree.get_root(), graph)\n    graph.write_png(file_path, prog=\"dot\")\n\n\ndef get_tree_layers_counts(tree, max_depth=50):\n    layer_counts = []\n    for layer in get_leafs_layers([tree.get_root()], max_depth):\n        layer_counts.append(get_leafs_count(layer))\n    return layer_counts\n\n\ndef get_tree_layers_counts_extended(tree, max_depth=50):\n    known_layer_counts = []\n    unknown_layer_counts = []\n    for known, unknown in get_leafs_layers_extended(\n            [tree.get_root()], max_depth):\n        known_layer_counts.append(get_leafs_count(known))\n        unknown_layer_counts.append(get_leafs_count(unknown))\n    return known_layer_counts, unknown_layer_counts\n\n\ndef increment_leaf_key_count(leaf, data_key=\"count\"):\n    data = leaf.get_data()\n    if data_key in leaf.data:\n        data[data_key] += 1\n        leaf.set_data(data)\n    else:\n        data[data_key] = 1\n        leaf.set_data(data)\n\n\ndef decrement_leaf_key_count(leaf, data_key=\"count\"):\n    if data_key in leaf.data:\n        data = leaf.get_data()\n        data[data_key] -= 1\n        leaf.set_data(data)\n\n\ndef delete_leaf_volatilities(leaf, delete_index, data_key=\"volatilities\"):\n    if data_key in leaf.data:\n        data = leaf.get_data()\n        del data[data_key][delete_index]\n        leaf.set_data(data)\n\n\ndef append_leaf_key_volatilities(leaf, volatilities, data_key=\"volatilities\"):\n    data = leaf.get_data()\n    # print leaf.key, \"volatilities\", volatilities\n    if data_key in leaf.data:\n        data[data_key].append(volatilities)\n        leaf.set_data(data)\n    else:\n        data[data_key] = [volatilities]\n        leaf.set_data(data)\n    # print \"data\", data\n\n\ndef get_leaf_key_volatilities(leaf, data_key=\"volatilities\"):\n    return leaf.get_data()[\"volatilities\"]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_74","text":"from logging import Logger\n\nimport torch\nfrom scipy.stats import spearmanr\nfrom torch import nn\nfrom torch.optim.adamw import AdamW\nfrom torch.utils.data.dataloader import DataLoader\nfrom torch.utils.tensorboard import SummaryWriter\nfrom tqdm import tqdm\nfrom transformers import get_linear_schedule_with_warmup\n\nfrom tasks.korsts.config import TrainConfig\nfrom tasks.korsts.model import KorSTSModel\n\n\nclass Trainer:\n    def __init__(\n        self,\n        config: TrainConfig,\n        model: KorSTSModel,\n        train_data_loader: DataLoader,\n        dev_data_loader: DataLoader,\n        test_data_loader: DataLoader,\n        logger: Logger,\n        summary_writer: SummaryWriter,\n    ):\n        self.config = config\n        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n        self.model = model\n        self.model.to(self.device)\n\n        self.train_data_loader = train_data_loader\n        self.dev_data_loader = dev_data_loader\n        self.test_data_loader = test_data_loader\n        self.logger = logger\n        self.summary_writer = summary_writer\n\n        self.criterion = nn.MSELoss()\n        self.optimizer = AdamW(model.parameters(), lr=config.learning_rate)\n\n        # total step 계산\n        self.steps_per_epoch = len(train_data_loader)\n        self.total_steps = self.steps_per_epoch * config.num_epochs\n        self.warmup_steps = config.warmup_step_ratio * self.total_steps\n\n        self.scheduler = get_linear_schedule_with_warmup(\n            self.optimizer, num_warmup_steps=self.warmup_steps, num_training_steps=self.total_steps\n        )\n        self.global_step = 0\n\n    def train(self):\n        # train\n        self.logger.info(\"========== train ==========\")\n        self.logger.info(f\"device                : {self.device}\")\n        self.logger.info(f\"dataset length\/ train : {len(self.train_data_loader.dataset)}\")\n        self.logger.info(f\"dataset length\/ dev   : {len(self.dev_data_loader.dataset)}\")\n        self.logger.info(f\"dataset length\/ test  : {len(self.test_data_loader.dataset)}\")\n        self.logger.info(f\"batch size            : {self.config.batch_size}\")\n        self.logger.info(f\"learning rate         : {self.config.learning_rate}\")\n        self.logger.info(f\"dropout prob          : {self.config.dropout_prob}\")\n        self.logger.info(f\"total epoch           : {self.config.num_epochs}\")\n        self.logger.info(f\"steps per epoch       : {self.steps_per_epoch}\")\n        self.logger.info(f\"total steps           : {self.total_steps}\")\n        self.logger.info(f\"warmup steps          : {self.warmup_steps}\\n\")\n\n        for epoch in range(self.config.num_epochs):\n            running_loss = 0.0\n            train_targets = []\n            train_predictions = []\n\n            for step, data in enumerate(tqdm(self.train_data_loader)):\n                self.model.train()\n\n                self.global_step += 1\n\n                input_token_ids = data[0].to(self.device)\n                attention_mask = data[1].to(self.device)\n                token_type_ids = data[2].to(self.device)\n                labels = data[3].to(self.device)\n\n                loss, outputs = self._train_step(input_token_ids, attention_mask, token_type_ids, labels)\n\n                running_loss += loss\n                train_targets.extend(labels.tolist())\n                train_predictions.extend(outputs.tolist())\n\n                if (step + 1) % self.config.logging_interval == 0:\n                    train_loss = running_loss \/ self.config.logging_interval\n                    train_corr = spearmanr(train_targets, train_predictions)[0]\n                    self.logger.info(\n                        f\"Epoch {epoch}, Step {step + 1}\\t| Loss {train_loss:.4f}  \"\n                        f\"Spearman Correlation {train_corr:.4f}\"\n                    )\n\n                    self.summary_writer.add_scalar(\"korsts\/train\/loss\", train_loss, self.global_step)\n                    self.summary_writer.add_scalar(\"korsts\/train\/spearman\", train_corr, self.global_step)\n\n                    running_loss = 0.0\n                    train_targets = []\n                    train_predictions = []\n\n            # dev every epoch\n            dev_loss, dev_targets, dev_predictions = self._validation(self.dev_data_loader)\n            dev_corr = spearmanr(dev_targets, dev_predictions)[0]\n            self.logger.info(f\"######### DEV REPORT #EP{epoch} #########\")\n            self.logger.info(f\"Loss {dev_loss:.4f}\")\n            self.logger.info(f\"Spearman Correlation {dev_corr:.4f}\\n\")\n\n            self.summary_writer.add_scalar(\"korsts\/dev\/loss\", dev_loss, self.global_step)\n            self.summary_writer.add_scalar(\"korsts\/dev\/spearman\", dev_corr, self.global_step)\n\n            # test every epoch\n            test_loss, test_targets, test_predictions = self._validation(self.test_data_loader)\n            test_corr = spearmanr(test_targets, test_predictions)[0]\n            self.logger.info(f\"######### TEST REPORT #EP{epoch} #########\")\n            self.logger.info(f\"Loss {test_loss:.4f}\")\n            self.logger.info(f\"Spearman Correlation {test_corr:.4f}\\n\")\n\n            self.summary_writer.add_scalar(\"korsts\/test\/loss\", test_loss, self.global_step)\n            self.summary_writer.add_scalar(\"korsts\/test\/spearman\", test_corr, self.global_step)\n\n            # output_path = os.path.join(self.config.checkpoint_dir, f\"model-epoch-{epoch}.pth\")\n            # torch.save(self.model.state_dict(), output_path)\n            # self.logger.info(f\"MODEL IS SAVED AT {output_path}\\n\")\n\n    def _train_step(self, input_token_ids, attention_mask, token_type_ids, labels):\n        self.optimizer.zero_grad()\n\n        outputs = self.model(input_token_ids, attention_mask, token_type_ids)\n        outputs = outputs.view(-1)\n\n        loss = self.criterion(outputs, labels)\n        loss.backward()\n        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)\n\n        self.optimizer.step()\n        self.scheduler.step()\n\n        return loss.item(), outputs\n\n    def _validation(self, data_loader):\n        self.model.eval()\n\n        running_loss = 0.0\n        targets = []\n        predictions = []\n\n        with torch.no_grad():\n            for data in data_loader:\n                input_token_ids = data[0].to(self.device)\n                attention_mask = data[1].to(self.device)\n                token_type_ids = data[2].to(self.device)\n                labels = data[3].to(self.device)\n\n                outputs = self.model(input_token_ids, attention_mask, token_type_ids)\n                outputs = outputs.view(-1)\n\n                loss = self.criterion(outputs, labels)\n\n                running_loss += loss.item()\n                targets.extend(labels.tolist())\n                predictions.extend(outputs.tolist())\n\n        assert len(targets) == len(predictions)\n\n        mean_loss = running_loss \/ len(data_loader)\n\n        return mean_loss, targets, predictions\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_76","text":"from __future__ import division\n\nimport logging\n\nimport jax.numpy as np\nimport jax\nimport numpy as raw_np\nfrom sklearn.base import BaseEstimator, RegressorMixin\nfrom sklearn.preprocessing import label_binarize\n\nimport scipy\nimport scipy.optimize\nimport scipy.linalg\n\nfrom ..utils import clip_jax\n\nfrom jax.config import config\nconfig.update(\"jax_enable_x64\", True)\n\n\nclass MultinomialRegression(BaseEstimator, RegressorMixin):\n    def __init__(self, weights_0=None, method=None, initializer='identity',\n                 reg_format=None,\n                 reg_lambda=0.0, reg_mu=None, reg_norm=False, ref_row=True):\n        if method not in [None, 'Full', 'Diag', 'FixDiag']:\n            raise(ValueError('method {} not avaliable'.format(method)))\n\n        self.weights_ = weights_0\n        self.weights_0_ = weights_0\n        self.method_ = method\n        self.initializer = initializer\n        self.reg_format = reg_format\n        self.reg_lambda = reg_lambda\n        self.reg_mu = reg_mu  # If number, then ODIR is applied\n        self.reg_norm = reg_norm\n        self.ref_row = ref_row\n        self.classes = None\n\n    @property\n    def coef_(self):\n        return self.weights_[:, :-1]\n\n    @property\n    def intercept_(self):\n        return self.weights_[:, -1]\n\n    def predict_proba(self, S):\n\n        S_ = np.hstack((S, np.ones((len(S), 1))))\n\n        return np.asarray(_calculate_outputs(self.weights_, S_))\n\n    # FIXME Should we change predict for the argmax?\n    def predict(self, S):\n\n        return np.asarray(self.predict_proba(S))\n\n\n    def fit(self, X, y, *args, **kwargs):\n\n        X_ = np.hstack((X, np.ones((len(X), 1))))\n\n        self.classes = raw_np.unique(y)\n\n        k = len(self.classes)\n\n        if self.reg_norm:\n            if self.reg_mu is None:\n                self.reg_lambda = self.reg_lambda \/ (k * (k + 1))\n            else:\n                self.reg_lambda = self.reg_lambda \/ (k * (k - 1))\n                self.reg_mu = self.reg_mu \/ k\n\n        target = label_binarize(y, self.classes)\n\n        if k == 2:\n            target = np.hstack([1-target, target])\n\n        n, m = X_.shape\n\n        XXT = (X_.repeat(m, axis=1) * np.hstack([X_]*m)).reshape((n, m, m))\n\n        logging.debug(self.method_)\n\n        self.weights_0_ = self._get_initial_weights(self.initializer)\n\n        if k <= 36:\n            weights = _newton_update(self.weights_0_, X_, XXT, target, k,\n                                     self.method_, reg_lambda=self.reg_lambda,\n                                     reg_mu=self.reg_mu, ref_row=self.ref_row,\n                                     initializer=self.initializer,\n                                     reg_format=self.reg_format)\n        else:\n            res = scipy.optimize.fmin_l_bfgs_b(func=_objective, fprime=_gradient,\n                                               x0=self.weights_0_,\n                                               args=(X_, XXT, target, k,\n                                                     self.method_,\n                                                     self.reg_lambda,\n                                                     self.reg_mu, self.ref_row,\n                                                     self.initializer,\n                                                     self.reg_format),\n                                               maxls=128,\n                                               factr=1.0)\n            weights = res[0]\n\n        self.weights_ = _get_weights(weights, k, self.ref_row, self.method_)\n\n        return self\n\n    def _get_initial_weights(self, ref_row, initializer='identity'):\n        ''' Returns an array containing only the weights of the full weight\n        matrix.\n\n        '''\n\n        if initializer not in ['identity', None]:\n            raise ValueError\n\n        k = len(self.classes)\n\n        if self.weights_0_ is None:\n\n            if self.method_ == 'Full':\n                if initializer == 'identity':\n                    weights_0 = _get_identity_weights(k, ref_row, self.method_)\n                else:\n                    weights_0 = np.zeros(k * (k + 1))\n\n            if self.method_ == 'Diag':\n                if initializer == 'identity':\n                    weights_0 = _get_identity_weights(k, ref_row, self.method_)\n                else:\n                    weights_0 = np.zeros(2*k)\n\n            elif self.method_ == 'FixDiag':\n                if initializer == 'identity':\n                    weights_0 = _get_identity_weights(k, ref_row, self.method_)\n                else:\n                    weights_0 = np.zeros(1)\n\n            if self.method_ is None:\n                if initializer == 'identity':\n                    weights_0 = _get_identity_weights(k, ref_row, self.method_)\n                else:\n                    weights_0 = np.zeros(k * (k + 1))\n        else:\n            weights_0 = self.weights_0_\n\n        return weights_0\n\n\ndef _objective(params, *args):\n    (X, _, y, k, method, reg_lambda, reg_mu, ref_row, _, reg_format) = args\n    weights = _get_weights(params, k, ref_row, method)\n    outputs = clip_jax(_calculate_outputs(weights, X))\n    loss = np.mean(-np.log(np.sum(y * outputs, axis=1)))\n\n    if reg_mu is None:\n        if reg_format == 'identity':\n            reg = np.hstack([np.eye(k), np.zeros((k, 1))])\n        else:\n            reg = np.zeros((k, k+1))\n        loss = loss + reg_lambda * np.sum((weights - reg)**2)\n    else:\n        weights_hat = weights - np.hstack([weights[:, :-1] * np.eye(k),\n                                           np.zeros((k, 1))])\n        loss = loss + reg_lambda * np.sum(weights_hat[:, :-1] ** 2) + \\\n            reg_mu * np.sum(weights_hat[:, -1] ** 2)\n\n    return loss\n\n\n_gradient = jax.grad(_objective, argnums=0)\n\n\n_hessian = jax.hessian(_objective, argnums=0)\n\n\ndef _get_weights(params, k, ref_row, method):\n        ''' Reshapes the given params (weights) into the full matrix including 0\n        '''\n\n        if method in ['Full', None]:\n            raw_weights = params.reshape(-1, k+1)\n            # weights = np.zeros([k, k+1])\n            # weights[:-1, :] = params.reshape(-1, k + 1)\n\n        elif method == 'Diag':\n            raw_weights = np.hstack([np.diag(params[:k]),\n                                     params[k:].reshape(-1, 1)])\n            # weights[:, :-1][np.diag_indices(k)] = params[:]\n\n        elif method == 'FixDiag':\n            raw_weights = np.hstack([np.eye(k) * params[0], np.zeros((k, 1))])\n            # weights[np.dgag_indices(k - 1)] = params[0]\n            # weights[np.diag_indices(k)] = params[0]\n        else:\n            raise(ValueError(\"Unknown calibration method {}\".format(method)))\n\n        if ref_row:\n            weights = raw_weights - np.repeat(\n                raw_weights[-1, :].reshape(1, -1), k, axis=0)\n        else:\n            weights = raw_weights\n\n        return weights\n\n\ndef _get_identity_weights(n_classes, ref_row, method):\n\n    raw_weights = None\n\n    if (method is None) or (method == 'Full'):\n        raw_weights = np.zeros((n_classes, n_classes + 1)) + \\\n                      np.hstack([np.eye(n_classes), np.zeros((n_classes, 1))])\n        raw_weights = raw_weights.ravel()\n\n    elif method == 'Diag':\n        raw_weights = np.hstack([np.ones(n_classes), np.zeros(n_classes)])\n\n    elif method == 'FixDiag':\n        raw_weights = np.ones(1)\n\n    return raw_weights.ravel()\n\n\ndef _calculate_outputs(weights, X):\n    mul = np.dot(X, weights.transpose())\n    return _softmax(mul)\n\n\ndef _softmax(X):\n    \"\"\"Compute the softmax of matrix X in a numerically stable way.\"\"\"\n    shiftx = X - np.max(X, axis=1).reshape(-1, 1)\n    exps = np.exp(shiftx)\n    return exps \/ np.sum(exps, axis=1).reshape(-1, 1)\n\n\ndef _newton_update(weights_0, X, XX_T, target, k, method_, maxiter=int(1024),\n                   ftol=1e-12, gtol=1e-8, reg_lambda=0.0, reg_mu=None,\n                   ref_row=True, initializer=None, reg_format=None):\n\n    L_list = [raw_np.float(_objective(weights_0, X, XX_T, target, k, method_,\n                                      reg_lambda, reg_mu, ref_row, initializer,\n                                      reg_format))]\n\n    weights = weights_0.copy()\n\n    # TODO move this to the initialization\n    if method_ is None:\n        weights = np.zeros_like(weights)\n\n    for i in range(0, maxiter):\n\n        gradient = _gradient(weights, X, XX_T, target, k, method_, reg_lambda,\n                             reg_mu, ref_row, initializer, reg_format)\n\n        if np.abs(gradient).sum() < gtol:\n            break\n\n        # FIXME hessian is ocasionally NaN\n        hessian = _hessian(weights, X, XX_T, target, k, method_, reg_lambda,\n                           reg_mu, ref_row, initializer, reg_format)\n\n        if method_ == 'FixDiag':\n            updates = gradient \/ hessian\n        else:\n            try:\n                inverse = scipy.linalg.pinv2(hessian)\n                updates = np.matmul(inverse, gradient)\n            except (raw_np.linalg.LinAlgError, ValueError) as err:\n                logging.error(err)\n                updates = gradient\n\n        for step_size in np.hstack((np.linspace(1, 0.1, 10),\n                                    np.logspace(-2, -32, 31))):\n\n            tmp_w = weights - (updates * step_size).ravel()\n\n            if np.any(np.isnan(tmp_w)):\n                logging.debug(\"{}: There are NaNs in tmp_w\".format(method_))\n\n            L = _objective(tmp_w, X, XX_T, target, k, method_, reg_lambda,\n                           reg_mu, ref_row, initializer, reg_format)\n\n            if (L - L_list[-1]) < 0:\n                break\n\n        L_list.append(raw_np.float(L))\n\n        logging.debug(\"{}: after {} iterations log-loss = {:.7e}, sum_grad = {:.7e}\".format(\n            method_, i, L, np.abs(gradient).sum()))\n\n        if np.isnan(L):\n            logging.error(\"{}: log-loss is NaN\".format(method_))\n            break\n\n        if i >= 5:\n            if (raw_np.float(raw_np.min(raw_np.diff(L_list[-5:]))) > -ftol) & \\\n               (raw_np.float(raw_np.sum(raw_np.diff(L_list[-5:])) > 0) == 0):\n                weights = tmp_w.copy()\n                logging.debug('{}: Terminate as there is not enough changes on loss.'.format(\n                    method_))\n                break\n\n        if (L_list[-1] - L_list[-2]) > 0:\n            logging.debug('{}: Terminate as the loss increased {}.'.format(\n                method_, np.diff(L_list[-2:])))\n            break\n        else:\n            weights = tmp_w.copy()\n\n    L = _objective(weights, X, XX_T, target, k, method_,\n                   reg_lambda, reg_mu, ref_row, initializer, reg_format)\n\n    logging.debug(\"{}: after {} iterations final log-loss = {:.7e}, sum_grad = {:.7e}\".format(\n        method_, i, L, np.abs(gradient).sum()))\n\n    return weights\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_77","text":"<reponame>feynmanliang\/travelling-cluster-chain<gh_stars>0\n#!\/usr\/bin\/env python3\n#vim:set et sw=4 ts=8:\n\nimport scipy.io\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nif __name__ == '__main__':\n    N_docs = 1740\n    N_mb = 5\n    plt.grid()\n    num_workers = len(set(\n        x[:16] for x in glob('output\/samples-*-*.mm')))\n    legend = []\n    # plt.semilogy()\n    for i in range(1, num_workers+1):\n        # Perplexities here are recorded once per minibatch\n        perplexities = scipy.io.mmread('.\/perplexities-{}.mm'.format(i))\n        # plt.plot(perplexities)\n\n        # average over entire batch\n        pp = []\n        for batch in range(int(perplexities.shape[0] \/ (N_docs \/ N_mb))):\n            pp.append(perplexities[int(N_docs\/N_mb*batch):int(N_docs\/N_mb*(batch+1))].mean())\n        plt.plot(pp)\n        legend.append(\"Worker {}\".format(i))\n\n    plt.legend(legend)\n    # plt.xlabel('Trajectory number')\n    plt.xlabel('Iteration over dataset')\n    plt.ylabel('Perplexity (nats)')\n    plt.savefig('fig-perplexities.png'.format(i))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_78","text":"<reponame>christiankuhl\/VortexDynamics\n\"\"\"\nThis module implements the N-vortex dynamics for an ellipse.\nInsert code here as if it were inside a class definition statement.\n\"\"\"\n\nimport numpy as np\nfrom scipy.special import ellipk\nfrom scipy.optimize import newton\nfrom mpmath import ellipfun\nfrom cmath import asin\nfrom utils import vectorized\n\ndef __init__(self, a):\n    \"\"\"\n    Instantiates an ellipse with half axes a and 1.\n    \"\"\"\n    self.a = a\n    self.xlim = (-a, a)\n    self.ylim = (-1, 1)\n    self._k = self.solve_for_k()\n    self._K = ellipk(self._k)\n    print(self._k)\n\ndef JGradG(self, z1, z2):\n    z1, z2 = complex(*z1), complex(*z2)\n    fz, fw, fprimez = self.F(z1), self.F(z2), self.Fprime(z1)\n    igradG = -1.j \/ (2 * np.pi) * (fprimez * np.conj(fw) * (1 - fz * np.conj(fw))\n                                    \/ np.abs((1 - fz * np.conj(fw)))**2\n                                    - (fprimez * (fz - fw)) \/ np.abs((fz - fw))**2)\n    return np.array([np.real(igradG), np.imag(igradG)])\n\n@vectorized\ndef JGradh(self, z):\n    # z = complex(*z)\n    f, fprime, f2prime = self.F(z), self.Fprime(z), self.F2prime(z)\n    # f, fprime, f2prime = z, 1, 0\n    jhprime = 1.j \/ (2 * np.pi) * (2 * f * fprime \/ (1 - np.abs(f)**2)\n                                     + fprime * f2prime \/ (np.abs(fprime)**2))\n    return np.array([np.real(jhprime), np.imag(jhprime)])\n\ndef plot_me(self, t):\n    return np.array([self.a*np.cos(2*np.pi*t), np.sin(2*np.pi*t)])\n\n# Main interface implemented above, lots of helper functions below this point\n\ndef solve_for_k(self):\n    def rhs(k):\n        c = 2\/np.pi * np.arcsinh(2 * self.a \/ (self.a**2 - 1))\n        return ellipk(np.sqrt(1 - k**2)) \/ ellipk(k) - c\n    return newton(rhs, .5)\n\n@vectorized\ndef W(self, z):\n    return 2 * self._K \/ np.pi * asin(z \/ np.sqrt(self.a**2 - 1))\n\ndef h(self, z):\n    return 1\/(2*np.pi)*np.log((1-np.abs(self.F(z))**2)\/np.abs(self.Fprime(z)))\n\ndef F(self, z):\n    return np.sqrt(self._k) * self.snW(z)\n\ndef Fprime(self, z):\n    cn, dn = self.cnW(z), self.dnW(z)\n    return (2 * np.sqrt(self._k) * self._K \/ (np.pi * np.sqrt(self.a**2 - 1 - z**2))\n            * cn * dn)\n\ndef F2prime(self, z):\n    sn, cn, dn = self.snW(z), self.cnW(z), self.dnW(z)\n    return 2*np.sqrt(self._k)*self._K\/(np.pi*(self.a**2-1-z**2)**(3\/2))*cn*dn*z-4*np.sqrt(self._k)*self._K**2\/(np.pi**2*(self.a**2-1-z**2))*sn*(dn**2+self._k**2*cn**2)\n\n@vectorized\ndef sn(self, z):\n    return ellipfun('sn', z, self._k**2).__complex__()\n\n@vectorized\ndef cn(self, z):\n    return ellipfun('cn', z, self._k**2).__complex__()\n\n@vectorized\ndef dn(self, z):\n    return ellipfun('dn', z, self._k**2).__complex__()\n\n@vectorized\ndef snW(self, z):\n    return self.sn(self.W(z))\n\n@vectorized\ndef cnW(self, z):\n    return self.cn(self.W(z))\n\n@vectorized\ndef dnW(self, z):\n    return self.dn(self.W(z))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_79","text":"import numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.lines as lines\nimport matplotlib.gridspec as gridspec\nimport scipy.misc\nfrom scipy import special\nimport paratf\n\nplt.rcParams[\"font.family\"] = \"serif\"\nplt.rcParams[\"font.serif\"] = \"Times\"\n\ninches = 2\nrows = 1\ncols = 3\nwidths = [1,1,1]\nheights = [1]\nhspace = 0.05\nwspace = 0.15\n\nf = plt.figure(figsize=(inches*(np.sum(widths) + widths[0]*(wspace)*(cols - 1)),\n                        inches*(np.sum(heights))))\n\nouter_grid = gridspec.GridSpec(ncols=cols, nrows=rows,\n                               width_ratios=widths, height_ratios=heights,\n                               hspace=hspace, wspace=wspace)\n\ndef an(krda, n):\n    return (n\/np.pi)*((special.jn(n, krda)\/(krda))**2)\n\ndef hdet(krd, theta, alpha):\n    return an(krd*alpha, 1)*np.sin(theta)**2 + 0.5*an(krd*alpha, 2)*(alpha**2)*(np.cos(theta)**2)\n\nalphas = [0.25, 0.5, 0.75]\nalpha_strs = ['0.25', '0.5', '0.75']\nfor col in range(cols):\n    alpha = alphas[col]\n    ax = f.add_subplot(outer_grid[0, col])\n    ax.set_xlim([0,2])\n    ax.set_ylim([0,1])\n\n    thetas = [0, np.pi\/8, np.pi\/4, 3*np.pi\/8, np.pi\/2]\n    theta_strs = ['0', '$\\pi\/8$', '$\\pi\/4$', '$3\\pi\/8$', '$\\pi\/2$']\n    for theta in thetas:\n        nucr = np.linspace(1e-3, 2, 100)\n        ax.plot(nucr, paratf.dpsf(nucr, theta, NA=alpha)\/paratf.dpsf(1e-3, np.pi\/2, NA=alpha), '-', c=[1 - theta\/(np.pi\/2), 0, 0], lw=0.5)\n\n    # Monopole\n    ax.plot(nucr, (paratf.jinc(0, nucr)\/paratf.jinc(0, 0))**2, '-', c=[0, 1, 0], lw=1.5, zorder=0, alpha=1)        \n\n    ax.tick_params(direction='out', left=True, right=False, width=0.75)\n    ax.yaxis.set_ticks([0, 0.25, 0.5, 0.75, 1.0])\n    if col == 0:\n        ax.set_yticklabels(['0','0.25','0.5','0.75','1'])\n    else:\n        ax.set_yticklabels([])\n    ax.xaxis.set_ticks([0, 0.5, 1, 1.5, 2])\n    ax.set_xticklabels(['0','0.5','1','1.5','2'])\n    \n    ax.text(0.5, 1.08, 'NA$\/n_o ='+alpha_strs[col]+'$', ha='center', va='center', rotation=0, transform=ax.transAxes)\n    if col == 0:\n        ax.text(-0.4, 0.5, 'Renormalized\\n dipole point spread function \\n $h(r, \\\\vartheta)\/h(0, \\\\pi\/2)$', ha='center', va='center', rotation=90, transform=ax.transAxes)\n        ax.text(0.5, -0.25, 'Scaled distance $\\\\nu_c r$', ha='center', va='center', transform=ax.transAxes)\n        for i, theta_str in enumerate(theta_strs):\n            if i == 4:\n                theta_str = '$\\\\vartheta =' + theta_str[1:-1] + '$'\n            ax.text(0.75, 0.4 + 0.1*i, theta_str, ha='right', va='center', transform=ax.transAxes)\n            l1 = lines.Line2D([0.8,0.9], 2*[0.4 + 0.1*i], c=[1 - thetas[i]\/(np.pi\/2), 0, 0], lw=0.5, transform=ax.transAxes)\n            f.lines.extend([l1])\n        ax.text(0.75, 0.8 + 0.1*1, 'Monopole', ha='right', va='center', transform=ax.transAxes)\n        l1 = lines.Line2D([0.8,0.9], 2*[0.8 + 0.1*1], c=[0, 1, 0], lw=1.5, transform=ax.transAxes)\n        f.lines.extend([l1])\n\n\n    if col != 0:\n        ax.text(0.5, -0.25, '$\\\\nu_c r$', ha='center', va='center', transform=ax.transAxes)\nf.savefig('dpsf.pdf', dpi=500, bbox_inches='tight')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_66","text":"\"\"\"\nProject: RadarBook\nFile: rectangular_plate.py\nCreated by: <NAME>\nOn: 10\/30\/2018\nCreated with: PyCharm\n\nCopyright (C) 2019 Artech House (<EMAIL>)\nThis file is part of Introduction to Radar Using Python and MATLAB\nand can not be copied and\/or distributed without the express permission of Artech House.\n\"\"\"\nfrom numpy import radians, sin, cos, sinc\nfrom scipy.constants import c, pi\n\n\ndef radar_cross_section(frequency, width, length, incident_theta, observation_theta, observation_phi):\n    \"\"\"\n    Calculate the bistatic radar cross section for a rectangular plate.\n    :param frequency: The frequency of the incident energy (Hz).\n    :param width: The width of the plate (m).\n    :param length: The length of the plate (m).\n    :param incident_theta: The incident angle theta (deg).\n    :param observation_theta: The observation angle theta (deg).\n    :param observation_phi: The observation angle phi (deg).\n    :return: The bistatic radar cross section (m^2).\n    \"\"\"\n    # Wavelength\n    wavelength = c \/ frequency\n\n    theta_i = radians(incident_theta)\n    theta_o = radians(observation_theta)\n\n    phi_o = radians(observation_phi)\n\n    x = width \/ wavelength * sin(theta_o) * cos(phi_o)\n    y = length \/ wavelength * (sin(theta_o) * sin(phi_o) - sin(theta_i))\n\n    rcs_tm = 4.0 * pi * (length * width \/ wavelength) ** 2 * (cos(theta_i) ** 2 * (cos(theta_o) ** 2 * cos(phi_o) ** 2\n                                                              + sin(phi_o) ** 2)) * sinc(x) ** 2 * sinc(y) ** 2\n\n    rcs_te = 4.0 * pi * (length * width \/ wavelength) ** 2 * (cos(theta_o) ** 2 * sin(phi_o) ** 2\n                                                              + cos(phi_o) ** 2) * sinc(x) ** 2 * sinc(y) ** 2\n\n    return rcs_tm, rcs_te\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_70","text":"import re\nimport os\nimport sys\nimport pandas as pd\nfrom lxml import etree\nfrom scipy import stats\nimport gzip\nfrom sqlalchemy import create_engine\n\nclass Polite():\n    \"\"\"\n    MALLET parameters used: 'output-topic-keys', 'output-doc-topics',\n    'word-topic-counts-file', 'topic-word-weights-file',\n    'xml-topic-report', 'xml-topic-phrase-report',\n    'diagnostics-file', 'output-state'\n    \"\"\"\n\n    class TableDef():\n        def __init__(self, index=[], cols=[]):\n            self.cols = cols\n            self.index = index\n\n    schema = dict(\n        DOC = TableDef(['doc_id']),\n        DOCTOPIC_NARROW = TableDef(['doc_id', 'topic_id']),\n        DOCTOPIC = TableDef(['doc_id']),\n        DOCWORD = TableDef(['doc_id', 'word_id']),\n        PHRASE = TableDef(['phrase_str']),\n        TOPIC = TableDef(['topic_id']),\n        TOPICPHRASE = TableDef(['topic_id', 'topic_phrase']),\n        TOPICWORD_DIAGS = TableDef(['topic_id', 'word_id']),\n        TOPICWORD_NARROW = TableDef(['word_id', 'topic_id']),\n        TOPICWORD_WEIGHTS = TableDef(['topic_id', 'word_str']),\n        TOPICWORD = TableDef(['word_id']),\n        VOCAB = TableDef(['word_id'])\n    ) \n\n    def __init__(self, config_file, tables_dir='.\/', save_mode='csv'):\n        \"\"\"Initialize MALLET with trial name\"\"\"\n        self.config_file = config_file\n        self.tables_dir = tables_dir\n        self._convert_config_file()\n        self.save_mode = save_mode\n\n        if self.save_mode == 'sql':\n            engine = create_engine(f'sqlite:\/\/\/{self.tables_dir}model.db', echo=True)\n            self.db = engine.connect()\n\n    def __del__(self):\n        if self.save_mode == 'sql':\n            self.db.close()\n\n    def save_table(self, df, table_name):\n        self.schema[table_name].cols = df.columns\n        if self.save_mode == 'sql':\n            df.to_sql(table_name, self.db, if_exists='replace', index=True)    \n        elif self.save_mode == 'csv':\n            df.to_csv(self.tables_dir + f'{table_name}.csv')\n\n    def get_table(self, table_name):\n        index_cols = self.schema[table_name].index\n        if self.save_mode == 'sql':\n            df = pd.read_sql_table(table_name, self.db, \n            index_col = index_cols)\n        elif self.save_mode == 'csv':\n            df = pd.read_csv(self.tables_dir + f'{table_name}.csv', \n                index_col=index_cols)\n        else:\n            raise ValueError(\"No save method!\")\n        return df\n\n    def _convert_config_file(self):\n        \"\"\"Converts the MALLLET config file into a Python dictionary.\"\"\"\n        self.config = {}\n        with open(self.config_file, 'r') as cfg:\n            for line in cfg.readlines():\n                if not re.match(r'^#', line):\n                    a, b = line.split()\n                    b = b.strip()\n                    if re.match(r'^\\d+$', b):\n                        b = int(b)\n                    elif re.match(r'^\\d+\\.\\d*$', b):\n                        b = float(b)\n                    elif re.match(r'^TRUE$', b, flags=re.IGNORECASE):\n                        b = True\n                    elif re.match(r'^FALSE$', b, flags=re.IGNORECASE):\n                        b = False\n                    self.config[a] = b\n        \n        # config = pd.DataFrame(self.config)\n\n    def get_source_file(self, src_file_key):\n        src_file = self.config[src_file_key]\n        if not os.path.isfile(src_file):\n            print(f\"File {src_file} for {src_file_key} does not exist. Try running MALLET first.\")\n            sys.exit(1)\n        else:\n            return src_file\n\n    def import_table_state(self):\n        \"\"\"Import the state file into docword table\"\"\"\n        src_file = self.get_source_file('output-state')\n        with gzip.open(src_file, 'rb') as f:\n            docword = pd.DataFrame(\n                [line.split() for line in f.readlines()[3:]],\n                columns=['doc_id', 'src', 'word_pos', 'word_id', 'word_str', 'topic_id'])\n        docword = docword[['doc_id', 'word_id', 'word_pos', 'topic_id']]\n        docword = docword.astype('int')\n        docword = docword.set_index(['doc_id', 'word_id'])\n\n        # SAVE\n        self.save_table(docword, 'DOCWORD')\n\n\n    def import_table_topic(self):\n        \"\"\"Import data into topic table\"\"\"\n        src_file = self.get_source_file('output-topic-keys')\n        topic = pd.read_csv(src_file, sep='\\t', header=None, index_col='topic_id',\n            names=['topic_id', 'topic_alpha', 'topic_words'])\n        topic['topic_alpha_zscore'] = stats.zscore(topic.topic_alpha)\n\n        # SAVE\n        self.save_table(topic, 'TOPIC')\n\n        \n    def import_tables_topicword_and_word(self):\n        \"\"\"Import data into topicword and word tables\"\"\"\n        src_file = self.get_source_file('word-topic-counts-file')\n        WORD = []\n        TOPICWORD = []\n        with open(src_file, 'r') as src:\n            for line in src.readlines():\n                row = line.strip().split()\n                word_id, word_str = row[0:2]\n                WORD.append((int(word_id), word_str))\n                for item in row[2:]:\n                    topic_id, word_count = item.split(':')\n                    TOPICWORD.append((int(word_id), int(topic_id), int(word_count)))\n\n        # May use schema for indexes\n        word = pd.DataFrame(WORD, columns=['word_id', 'word_str']).set_index('word_id')\n        topicword = pd.DataFrame(TOPICWORD, columns=['word_id', 'topic_id', 'word_count'])\\\n            .set_index(['word_id', 'topic_id'])\n        topicword_wide = topicword.unstack(fill_value=0)\n        topicword_wide.columns = topicword_wide.columns.droplevel(0)\n        topicword_wide = topicword_wide \/ topicword_wide.sum()\n\n        src_file2 = self.get_source_file('topic-word-weights-file')\n        topicword_w = pd.read_csv(src_file2,  sep='\\t', names=['topic_id','word_str','word_wgt'])\\\n            .set_index(['topic_id','word_str'])\n\n        # COMBINE TOPICWORD_NARROW AND TOPICWORD_WEIGHTS\n        # Note that word weights are just smoothed values\n        # So we really should only save the smoothing beta parameter, e.g. .01\n        # Get beta from self.config['beta']\n        # Should have model table for this stuff ... import the config file\n        # topicword_w = topicword_w.reset_index()\n        # topicword_w['word_id'] = topicword_w.word_str.map(word.reset_index().set_index('word_str').word_id)\n        # topicword_w = topicword_w.set_index(['topic_id','word_id'])\n        # topicword['word_wgt'] = topicword_w.word_wgt\n        \n        # SAVE\n        self.save_table(word, 'VOCAB')\n        self.save_table(topicword, 'TOPICWORD_NARROW')\n        self.save_table(topicword_wide, 'TOPICWORD')\n        # self.save_table(topicword_w, 'TOPICWORD_WEIGHTS')\n\n\n    def import_table_doctopic(self):\n        \"\"\"Import data into doctopic table\"\"\"\n        src_file = self.get_source_file('output-doc-topics')\n        doctopic = pd.read_csv(src_file, sep='\\t', header=None)\n        cols = ['doc_id', 'doc_tmp'] + [t for t in range(doctopic.shape[1]-2)]\n        doctopic.columns = cols\n        doctopic = doctopic.set_index('doc_id')\n        doc = doctopic.doc_tmp.str.split(',', expand=True).iloc[:, :2]\n        doc.columns = ['src_doc_id', 'doc_label']\n        doc.index.name = 'doc_id'\n        doctopic = doctopic.drop('doc_tmp', axis=1)\n        doctopic_narrow = doctopic.unstack().to_frame('topic_weight')\n        doctopic_narrow.index.names = ['doc_id', 'topic_id']\n        doctopic_narrow['topic_weight_zscore'] = stats.zscore(doctopic_narrow.topic_weight)\n        \n        # SAVE\n        self.save_table(doctopic, 'DOCTOPIC')\n        self.save_table(doc, 'DOC')\n        self.save_table(doctopic_narrow, 'DOCTOPIC_NARROW')\n\n\n    def import_table_topicphrase(self):\n        \"\"\"Import data into topicphrase table\"\"\"\n        src_file = self.get_source_file('xml-topic-phrase-report')\n        TOPICPHRASE = []\n        tree = etree.parse(src_file)\n        for topic in tree.xpath('\/topics\/topic'):\n            topic_id = int(topic.xpath('@id')[0])\n            for phrase in topic.xpath('phrase'):\n                phrase_weight = float(phrase.xpath('@weight')[0])\n                phrase_count = int(phrase.xpath('@count')[0])\n                topic_phrase = phrase.xpath('text()')[0]\n                TOPICPHRASE.append((topic_id, topic_phrase, phrase_weight, phrase_count))\n        topicphrase = pd.DataFrame(TOPICPHRASE, \n            columns=['topic_id', 'topic_phrase', 'phrase_weight', 'phrase_count'])\n\n        # Add phrase list to TOPIC\n        # MOVE TO add_topic_glosses()\n        topic = self.get_table('TOPIC')\n        topic['phrases'] = topicphrase.groupby('topic_id').apply(lambda x: ', '.join(x.topic_phrase))\n\n        topicphrase.set_index(['topic_id', 'topic_phrase'], inplace=True)\n\n        phrase = topicphrase.value_counts('topic_phrase').to_frame('n_topics').sort_index()\n        phrase['n_words'] = topicphrase.groupby('topic_phrase').phrase_count.sum().sort_index()\n        M = topicphrase.sort_index().reset_index()\n        M['topic_name'] = M.topic_id.astype('str').str.zfill(2)\n        phrase['topic_list'] = M.groupby('topic_phrase').topic_name.apply(lambda x: ' '.join(x))\\\n            .to_frame('topic_list').sort_index()\n        del(M)\n        phrase['topic_weight_mean'] = topicphrase.groupby(['topic_phrase']).mean().phrase_weight.sort_index()\n\n        topic['topic_label'] = topic.index.astype('str').str.zfill(2) + ': ' + topic.topic_words\n\n        # SAVE\n        self.save_table(phrase, 'PHRASE')\n        self.save_table(topicphrase, 'TOPICPHRASE')\n        self.save_table(topic, 'TOPIC')\n\n\n    def add_topic_glosses(self):\n        \"\"\"Add glosses to topic table\"\"\"\n        topicphrase = self.get_table('TOPICPHRASE')\n        topic = self.get_table('TOPIC')\n        topic['topic_gloss'] = topicphrase['phrase_weight'].unstack().idxmax(1)\n        \n        # SAVE\n        self.save_table(topic, 'TOPIC')\n\n    def add_diagnostics(self):\n        \"\"\"Add diagnostics data to topics and topicword_diags tables\"\"\"\n        src_file = self.get_source_file('diagnostics-file')\n        \n        TOPIC = []\n        TOPICWORD = []\n\n        # Schema\n        tkeys = ['id', 'tokens', 'document_entropy', 'word-length', 'coherence',\n                 'uniform_dist', 'corpus_dist',\n                 'eff_num_words', 'token-doc-diff', 'rank_1_docs',\n                 'allocation_ratio', 'allocation_count',\n                 'exclusivity']\n        tints = ['id', 'tokens']\n        wkeys = ['rank', 'count', 'prob', 'cumulative', 'docs', 'word-length', 'coherence',\n                 'uniform_dist', 'corpus_dist', 'token-doc-diff', 'exclusivity']\n        wints = ['rank', 'count', 'docs', 'word-length']\n\n        tree = etree.parse(src_file)\n        for topic in tree.xpath('\/model\/topic'):\n            tvals = []\n            for key in tkeys:\n                xpath = f'@{key}'\n                if key in tints:\n                    tvals.append(int(float(topic.xpath(xpath)[0])))\n                else:\n                    tvals.append(float(topic.xpath(xpath)[0]))\n            TOPIC.append(tvals)\n            for word in topic.xpath('word'):\n                wvals = []\n                topic_id = tvals[0]  # Hopefully\n                wvals.append(topic_id)\n                word_str = word.xpath('text()')[0]\n                wvals.append(word_str)\n                for key in wkeys:\n                    xpath = f'@{key}'\n                    if key in wints:\n                        wvals.append(int(float(word.xpath(xpath)[0])))\n                    else:\n                        wvals.append(float(word.xpath(xpath)[0]))\n                TOPICWORD.append(wvals)\n\n        tkeys = ['topic_{}'.format(re.sub('-', '_', k)) for k in tkeys]\n        wkeys = ['topic_id', 'word_str'] + wkeys\n        wkeys = [re.sub('-', '_', k) for k in wkeys]\n\n        topic_diags = pd.DataFrame(TOPIC, columns=tkeys).set_index('topic_id')\n        \n        topics = self.get_table('TOPIC')\n        topics = pd.concat([topics, topic_diags], axis=1)\n        topicword_diags = pd.DataFrame(TOPICWORD, columns=wkeys).set_index(['topic_id', 'word_str'])\n\n        word = self.get_table('VOCAB').reset_index().set_index('word_str')\n        topicword_diags['word_id'] = topicword_diags.apply(lambda x: word.loc[x.name[1]].word_id, axis=1)\n        topicword_diags = topicword_diags.reset_index().set_index(['topic_id', 'word_id'])\n\n        # SAVE\n        self.save_table(topics, 'TOPIC')\n        self.save_table(topicword_diags, 'TOPICWORD_DIAGS')\n\n    def do_all(self):\n        \"\"\"Run all importers and adders\"\"\"\n        self.import_table_state()\n        self.import_table_topic()\n        self.import_tables_topicword_and_word()\n        self.import_table_doctopic()\n        self.import_table_topicphrase()\n        self.add_diagnostics()\n        self.add_topic_glosses()\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_75","text":"import numpy as np\r\nimport random\r\nimport math\r\nimport zmq\r\nimport time\r\nfrom scipy.spatial import distance\r\nfrom tdw.output_data import IsOnNavMesh, Images, Bounds\r\nfrom PIL import Image\r\nimport io\r\nimport os\r\nfrom threading import Thread\r\nfrom tdw.controller import Controller\r\nfrom typing import List, Tuple, Dict, Optional, Union\r\nimport socket\r\nfrom contextlib import closing\r\nfrom tdw.librarian import ModelRecord\r\nfrom pathlib import Path\r\nimport boto3\r\nfrom botocore.exceptions import ProfileNotFound, ClientError\r\nfrom subprocess import check_output, Popen, call\r\nimport re\r\nfrom psutil import pid_exists\r\nimport base64\r\n\r\n\r\nclass TDWUtils:\r\n    \"\"\"\r\n    Utility functions for controllers.\r\n\r\n    Usage:\r\n\r\n    ```python\r\n    from tdw.tdw_utils import TDWUtils\r\n    ```\r\n    \"\"\"\r\n\r\n    VECTOR3_ZERO = {\"x\": 0, \"y\": 0, \"z\": 0}\r\n\r\n    # Cached values used during point cloud generation.\r\n    __WIDTH: int = -1\r\n    __HEIGHT: int = -1\r\n    __CAM_TO_IMG_MAT: Optional[np.array] = None\r\n\r\n    @staticmethod\r\n    def vector3_to_array(vector3: Dict[str, float]) -> np.array:\r\n        \"\"\"\r\n        Convert a Vector3 object to a numpy array.\r\n\r\n        :param vector3: The Vector3 object, e.g. `{\"x\": 0, \"y\": 0, \"z\": 0}`\r\n\r\n        :return A numpy array.\r\n        \"\"\"\r\n\r\n        return np.array([vector3[\"x\"], vector3[\"y\"], vector3[\"z\"]])\r\n\r\n    @staticmethod\r\n    def array_to_vector3(arr: np.array) -> Dict[str, float]:\r\n        \"\"\"\r\n        Convert a numpy array to a Vector3.\r\n\r\n        :param arr: The numpy array.\r\n\r\n        :return A Vector3, e.g. `{\"x\": 0, \"y\": 0, \"z\": 0}`\r\n        \"\"\"\r\n\r\n        return {\"x\": float(arr[0]), \"y\": float(arr[1]), \"z\": float(arr[2])}\r\n\r\n    @staticmethod\r\n    def vector4_to_array(vector4: Dict[str, float]) -> np.array:\r\n        \"\"\"\r\n        Convert a Vector4 to a numpy array.\r\n\r\n        :param vector4: The Vector4 object, e.g. `{\"x\": 0, \"y\": 0, \"z\": 0, \"w\": 0}`\r\n\r\n        :return A numpy array.\r\n        \"\"\"\r\n\r\n        return np.array([vector4[\"x\"], vector4[\"y\"], vector4[\"z\"], vector4[\"w\"]])\r\n\r\n    @staticmethod\r\n    def array_to_vector4(arr: np.array) -> Dict[str, float]:\r\n        \"\"\"\r\n        Convert a numpy array to a Vector4.\r\n\r\n        :param arr: The numpy array.\r\n\r\n        :return A Vector4, e.g. `{\"x\": 0, \"y\": 0, \"z\": 0, \"w\": 0}`\r\n        \"\"\"\r\n\r\n        return {\"x\": arr[0], \"y\": arr[1], \"z\": arr[2], \"w\": arr[3]}\r\n\r\n    @staticmethod\r\n    def color_to_array(color: Dict[str, float]) -> np.array:\r\n        \"\"\"\r\n        Convert a RGB Color to a numpy array.\r\n\r\n        :param color: The Color object, e.g. `{\"r\": 0, \"g\": 0, \"b\": 0, \"a\": 1}`\r\n\r\n        :return A numpy array.\r\n        \"\"\"\r\n\r\n        return np.array([round(color[\"r\"] * 255), round(color[\"g\"] * 255), round(color[\"b\"] * 255)])\r\n\r\n    @staticmethod\r\n    def array_to_color(arr: np.array) -> Dict[str, float]:\r\n        \"\"\"\r\n        Convert a numpy array to a RGBA Color. If no A value is supplied it will default to 1.\r\n\r\n        :param arr: The array.\r\n\r\n        :return A Color, e.g. `{\"r\": 0, \"g\": 0, \"b\": 0, \"a\": 1}`\r\n        \"\"\"\r\n\r\n        return {\"r\": arr[0], \"g\": arr[1], \"b\": arr[2], \"a\": 1 if len(arr) == 3 else arr[3]}\r\n\r\n    @staticmethod\r\n    def get_random_point_in_circle(center: np.array, radius: float) -> np.array:\r\n        \"\"\"\r\n        Get a random point in a circle, defined by a center and radius.\r\n\r\n        :param center: The center of the circle.\r\n        :param radius: The radius of the circle.\r\n\r\n        :return A numpy array. The y value (`arr[1]`) is always 0.\r\n        \"\"\"\r\n\r\n        alpha = 2 * math.pi * random.random()\r\n        r = radius * math.sqrt(random.random())\r\n        x = r * math.cos(alpha) + center[0]\r\n        z = r * math.sin(alpha) + center[2]\r\n\r\n        return np.array([x, 0, z])\r\n\r\n    @staticmethod\r\n    def get_magnitude(vector3: Dict[str, float]) -> float:\r\n        \"\"\"\r\n        Get the magnitude of a Vector3.\r\n\r\n        :param vector3: The Vector3 object, e.g. `{\"x\": 0, \"y\": 0, \"z\": 0}`\r\n\r\n        :return The vector magnitude.\r\n        \"\"\"\r\n\r\n        return np.linalg.norm(TDWUtils.vector3_to_array(vector3))\r\n\r\n    @staticmethod\r\n    def extend_line(p0: np.array, p1: np.array, d: float, clamp_y=True) -> np.array:\r\n        \"\"\"\r\n        Extend the line defined by p0 to p1 by distance d. Clamps the y value to 0.\r\n\r\n        :param p0: The origin.\r\n        :param p1: The second point.\r\n        :param d: The distance of which the line is to be extended.\r\n        :param clamp_y: Clamp the y value to 0.\r\n\r\n        :return: The position at distance d.\r\n        \"\"\"\r\n\r\n        if clamp_y:\r\n            p0[1] = 0\r\n            p1[1] = 0\r\n\r\n        # Get the distance between the two points.\r\n        d0 = distance.euclidean(p0, p1)\r\n        # Get the total distance.\r\n        d_total = d0 + d\r\n\r\n        return p1 + ((p1 - p0) * d_total)\r\n\r\n    @staticmethod\r\n    def get_distance(vector3_0: Dict[str, float], vector3_1: Dict[str, float]) -> float:\r\n        \"\"\"\r\n        Calculate the distance between two Vector3 (e.g. `{\"x\": 0, \"y\": 0, \"z\": 0}`) objects.\r\n\r\n        :param vector3_0: The first Vector3.\r\n        :param vector3_1: The second Vector3.\r\n\r\n        :return The distance.\r\n        \"\"\"\r\n\r\n        return distance.euclidean(TDWUtils.vector3_to_array(vector3_0), TDWUtils.vector3_to_array(vector3_1))\r\n\r\n    @staticmethod\r\n    def get_box(width: int, length: int) -> List[Dict[str, int]]:\r\n        \"\"\"\r\n        Returns a list of x,y positions that can be used to create a box with the `create_exterior_walls` command.\r\n        :param width: The width of the box.\r\n        :param length: The length of the box.\r\n\r\n        :return The box as represented by a list of `{\"x\": x, \"y\": y}` dictionaries.\r\n        \"\"\"\r\n\r\n        box = []\r\n        for x in range(width):\r\n            for y in range(length):\r\n                if x == 0 or x == width - 1 or y == 0 or y == length - 1:\r\n                    box.append({\"x\": x, \"y\": y})\r\n        return box\r\n\r\n    @staticmethod\r\n    def get_vector3(x, y, z) -> Dict[str, float]:\r\n        \"\"\"\r\n        :param x: The x value.\r\n        :param y: The y value.\r\n        :param z: The z value.\r\n\r\n        :return: A Vector3: {\"x\": x, \"y\", y, \"z\": z}\r\n        \"\"\"\r\n\r\n        return {\"x\": x, \"y\": y, \"z\": z}\r\n\r\n    @staticmethod\r\n    def create_empty_room(width: int, length: int) -> dict:\r\n        \"\"\"\r\n        :param width: The width of the room.\r\n        :param length: The length of the room.\r\n\r\n        :return: A `create_exterior_walls` command that creates a box with dimensions (width, length).\r\n        \"\"\"\r\n\r\n        return {\"$type\": \"create_exterior_walls\", \"walls\": TDWUtils.get_box(width, length)}\r\n\r\n    @staticmethod\r\n    def create_room_from_image(filepath: str, exterior_color=(255, 0, 0), interior_color=(0, 0, 0)) -> List[dict]:\r\n        \"\"\"\r\n        Load a .png file from the disk and use it to create a room. Each pixel on the image is a grid point.\r\n\r\n        :param filepath: The absolute filepath to the image.\r\n        :param exterior_color: The color on the image marking exterior walls (default=red).\r\n        :param interior_color: The color on the image marking interior walls (default=black).\r\n\r\n        :return: A list of commands: The first creates the exterior walls, and the second creates the interior walls.\r\n        \"\"\"\r\n\r\n        exterior_walls = []\r\n        interior_walls = []\r\n\r\n        # Read the image.\r\n        img = Image.open(filepath)\r\n        pixels = img.load()\r\n        col, row = img.size\r\n\r\n        # Read each pixel as a grid point.\r\n        for i in range(row):\r\n            for j in range(col):\r\n                pixel = pixels[i, j]\r\n                if len(pixel) == 4:\r\n                    pixel = (pixel[0], pixel[1], pixel[2])\r\n                if pixel == exterior_color:\r\n                    exterior_walls.append({\"x\": i, \"y\": col - j})\r\n                elif pixel == interior_color:\r\n                    interior_walls.append({\"x\": i, \"y\": col - j})\r\n\r\n        return [{\"$type\": \"create_exterior_walls\",\r\n                 \"walls\": exterior_walls},\r\n                {\"$type\": \"create_interior_walls\",\r\n                 \"walls\": interior_walls}]\r\n\r\n    @staticmethod\r\n    def save_images(images: Images, filename: str, output_directory=\"dist\", resize_to=None, append_pass: bool = True) -> None:\r\n        \"\"\"\r\n        Save each image in the Images object.\r\n        The name of the image will be: pass_filename.extension, e.g.: `\"0000\"` -> `depth_0000.png`\r\n        The images object includes the pass and extension information.\r\n\r\n        :param images: The Images object. Contains each capture pass plus metadata.\r\n        :param output_directory: The directory to write images to.\r\n        :param filename: The filename of each image, minus the extension. The image pass will be appended as a prefix.\r\n        :param resize_to: Specify a (width, height) tuple to resize the images to. This is slower than saving as-is.\r\n        :param append_pass: If false, the image pass will _not_ be appended to the filename as a prefix, e.g.: `\"0000\"`: -> \"`0000.jpg\"`\r\n        \"\"\"\r\n\r\n        if not os.path.isdir(output_directory):\r\n            os.makedirs(output_directory)\r\n\r\n        for i in range(images.get_num_passes()):\r\n            if append_pass:\r\n                fi = images.get_pass_mask(i)[1:] + \"_\" + filename + \".\" + images.get_extension(i)\r\n            else:\r\n                fi = filename + \".\" + images.get_extension(i)\r\n\r\n            if resize_to:\r\n                TDWUtils.get_pil_image(images, i).resize((resize_to[0], resize_to[1]), Image.LANCZOS)\\\r\n                    .save(os.path.join(output_directory, fi))\r\n            else:\r\n                pass_mask = images.get_pass_mask(i)\r\n                path = os.path.join(output_directory, fi)\r\n                # The depth passes aren't png files, so we need to convert them.\r\n                if pass_mask == \"_depth\" or pass_mask == \"_depth_simple\":\r\n                    # Save the image.\r\n                    Image.fromarray(TDWUtils.get_shaped_depth_pass(images=images, index=i)).save(path)\r\n                # Every other pass can be saved directly to disk.\r\n                else:\r\n                    with open(path, \"wb\") as f:\r\n                        f.write(images.get_image(i))\r\n\r\n    @staticmethod\r\n    def get_shaped_depth_pass(images: Images, index: int) -> np.array:\r\n        \"\"\"\r\n        The `_depth` and `_depth_simple` passes are a 1D array of RGB values, as oppposed to a png or jpg like every other pass.\r\n        This function reshapes the array into a 2D array of RGB values.\r\n\r\n        :param images: The `Images` output data.\r\n        :param index: The index in `Images` of the depth pass. See: `Images.get_pass_mask()`.\r\n\r\n        :return: A reshaped depth pass. Shape is: `(height, width, 3)`.\r\n        \"\"\"\r\n\r\n        return np.flip(np.reshape(images.get_image(index), (images.get_height(), images.get_width(), 3)), 0)\r\n\r\n    @staticmethod\r\n    def zero_padding(integer: int, width=4) -> str:\r\n        \"\"\"\r\n        :param integer: The integer being converted.\r\n        :param width: The total number of digits in the string. If integer == 3 and width == 4, output is: \"0003\".\r\n\r\n        :return A string representation of an integer padded with zeroes, e.g. converts `3` to `\"0003\"`.\r\n        \"\"\"\r\n\r\n        return str(integer).zfill(width)\r\n\r\n    @staticmethod\r\n    def get_pil_image(images: Images, index: int) -> Image:\r\n        \"\"\"\r\n        Converts Images output data to a PIL Image object.\r\n        Use this function to read and analyze an image in memory.\r\n        Do NOT use this function to save image data to disk; `save_image` is much faster.\r\n\r\n        :param images: Images data from the build.\r\n        :param index: The index of the image in Images.get_image\r\n\r\n        :return A PIL image.\r\n        \"\"\"\r\n\r\n        return Image.open(io.BytesIO(images.get_image(index)))\r\n\r\n    @staticmethod\r\n    def get_random_position_on_nav_mesh(c: Controller, width: float, length: float, x_e=0, z_e=0, bake=True, rng=random.uniform) -> Tuple[float, float, float]:\r\n        \"\"\"\r\n        Returns a random position on a NavMesh.\r\n\r\n        :param c: The controller.\r\n        :param width: The width of the environment.\r\n        :param length: The length of the environment.\r\n        :param bake: If true, send bake_nav_mesh.\r\n        :param rng: Random number generator.\r\n        :param x_e: The x position of the environment.\r\n        :param z_e: The z position of the environment.\r\n\r\n        :return The coordinates as a tuple `(x, y, z)`\r\n        \"\"\"\r\n\r\n        if bake:\r\n            c.communicate({'$type': 'bake_nav_mesh'})\r\n\r\n        # Try to find a valid position on the NavMesh.\r\n        is_on = False\r\n        x, y, z = (0, 0, 0)\r\n        while not is_on:\r\n            # Get a random position.\r\n            x = rng(-width \/ 2, width \/ 2) + x_e\r\n            z = rng(-length \/ 2, length \/ 2) + z_e\r\n            resp = c.communicate(\r\n                {'$type': 'send_is_on_nav_mesh',\r\n                 'position': {'x': x, 'y': 0, 'z': z},\r\n                 'max_distance': 4.0\r\n                 })\r\n            answer = IsOnNavMesh(resp[0])\r\n            is_on = answer.get_is_on()\r\n            x, y, z = answer.get_position()\r\n        return x, y, z\r\n\r\n    @staticmethod\r\n    def set_visual_material(c: Controller, substructure: List[dict], object_id: int, material: str, quality=\"med\") -> List[dict]:\r\n        \"\"\"\r\n        :param c: The controller.\r\n        :param substructure: The metadata substructure of the object.\r\n        :param object_id: The ID of the object in the scene.\r\n        :param material: The name of the new material.\r\n        :param quality: The quality of the material.\r\n\r\n        :return A list of commands to set ALL visual materials on an object to a single material.\r\n        \"\"\"\r\n\r\n        commands = []\r\n        for sub_object in substructure:\r\n            for i in range(len(sub_object[\"materials\"])):\r\n                commands.extend([c.get_add_material(material, library=\"materials_\" + quality + \".json\"),\r\n                                 {\"$type\": \"set_visual_material\",\r\n                                  \"id\": object_id,\r\n                                  \"material_name\": material,\r\n                                  \"object_name\": sub_object[\"name\"],\r\n                                  \"material_index\": i}])\r\n        return commands\r\n\r\n    @staticmethod\r\n    def get_depth_values(image: np.array, depth_pass: str = \"_depth\", width: int = 256, height: int = 256, near_plane: float = 0.1, far_plane: float = 100) -> np.array:\r\n        \"\"\"\r\n        Get the depth values of each pixel in a _depth image pass.\r\n        The far plane is hardcoded as 100. The near plane is hardcoded as 0.1.\r\n        (This is due to how the depth shader is implemented.)\r\n\r\n        :param image: The image pass as a numpy array.\r\n        :param depth_pass: The type of depth pass. This determines how the values are decoded. Options: `\"_depth\"`, `\"_depth_simple\"`.\r\n        :param width: The width of the screen in pixels. See output data `Images.get_width()`.\r\n        :param height: The height of the screen in pixels. See output data `Images.get_height()`.\r\n        :param near_plane: The near clipping plane. See command `set_camera_clipping_planes`. The default value in this function is the default value of the near clipping plane.\r\n        :param far_plane: The far clipping plane. See command `set_camera_clipping_planes`. The default value in this function is the default value of the far clipping plane.\r\n\r\n        :return An array of depth values.\r\n        \"\"\"\r\n\r\n        # Convert the image to a 2D image array.\r\n        image = np.flip(np.reshape(image, (height, width, 3)), 0)\r\n        if depth_pass == \"_depth\":\r\n            depth_values = np.array((image[:, :, 0] + image[:, :, 1] \/ 256.0 + image[:, :, 2] \/ (256.0 ** 2)))\r\n        elif depth_pass == \"_depth_simple\":\r\n            depth_values = image[:, :, 0] \/ 256.0\r\n        else:\r\n            raise Exception(f\"Invalid depth pass: {depth_pass}\")\r\n        # Un-normalize the depth values.\r\n        return (depth_values * ((far_plane - near_plane) \/ 256.0)).astype(np.float32)\r\n\r\n    @staticmethod\r\n    def get_point_cloud(depth, camera_matrix: Union[np.array, tuple], vfov: float = 54.43222, filename: str = None, near_plane: float = 0.1, far_plane: float = 100) -> np.array:\r\n        \"\"\"\r\n        Create a point cloud from an numpy array of depth values.\r\n\r\n        :param depth: Depth values converted from a depth pass. See: `TDWUtils.get_depth_values()`\r\n        :param camera_matrix: The camera matrix as a tuple or numpy array. See: [`send_camera_matrices`](https:\/\/github.com\/threedworld-mit\/tdw\/blob\/master\/Documentation\/api\/command_api.md#send_camera_matrices).\r\n        :param vfov: The field of view. See: [`set_field_of_view`](https:\/\/github.com\/threedworld-mit\/tdw\/blob\/master\/Documentation\/api\/command_api.md#set_field_of_view)\r\n        :param filename: If not None, the point cloud data will be written to this file.\r\n        :param near_plane: The near clipping plane. See command `set_camera_clipping_planes`. The default value in this function is the default value of the near clipping plane.\r\n        :param far_plane: The far clipping plane. See command `set_camera_clipping_planes`. The default value in this function is the default value of the far clipping plane.\r\n\r\n        :return: An point cloud as a numpy array of `[x, y, z]` coordinates.\r\n        \"\"\"\r\n\r\n        if isinstance(camera_matrix, tuple):\r\n            camera_matrix = np.array(camera_matrix)\r\n        camera_matrix = np.linalg.inv(camera_matrix.reshape((4, 4)))\r\n\r\n        # Different from real-world camera coordinate system.\r\n        # OpenGL uses negative z axis as the camera front direction.\r\n        # x axes are same, hence y axis is reversed as well.\r\n        # Source: https:\/\/learnopengl.com\/Getting-started\/Camera\r\n        rot = np.array([[1, 0, 0, 0],\r\n                        [0, -1, 0, 0],\r\n                        [0, 0, -1, 0],\r\n                        [0, 0, 0, 1]])\r\n        camera_matrix = np.dot(camera_matrix, rot)\r\n\r\n        # Cache some calculations we'll need to use every time.\r\n        if TDWUtils.__HEIGHT != depth.shape[0] or TDWUtils.__WIDTH != depth.shape[1]:\r\n            TDWUtils.__HEIGHT = depth.shape[0]\r\n            TDWUtils.__WIDTH = depth.shape[1]\r\n\r\n            img_pixs = np.mgrid[0: depth.shape[0], 0: depth.shape[1]].reshape(2, -1)\r\n            # Swap (v, u) into (u, v).\r\n            img_pixs[[0, 1], :] = img_pixs[[1, 0], :]\r\n            img_pix_ones = np.concatenate((img_pixs, np.ones((1, img_pixs.shape[1]))))\r\n\r\n            # Calculate the intrinsic matrix from vertical_fov.\r\n            # Motice that hfov and vfov are different if height != width\r\n            # We can also get the intrinsic matrix from opengl's perspective matrix.\r\n            # http:\/\/kgeorge.github.io\/2014\/03\/08\/calculating-opengl-perspective-matrix-from-opencv-intrinsic-matrix\r\n            vfov = vfov \/ 180.0 * np.pi\r\n            tan_half_vfov = np.tan(vfov \/ 2.0)\r\n            tan_half_hfov = tan_half_vfov * TDWUtils.__WIDTH \/ float(TDWUtils.__HEIGHT)\r\n            fx = TDWUtils.__WIDTH \/ 2.0 \/ tan_half_hfov  # focal length in pixel space\r\n            fy = TDWUtils.__HEIGHT \/ 2.0 \/ tan_half_vfov\r\n            intrinsics = np.array([[fx, 0, TDWUtils.__WIDTH \/ 2.0],\r\n                                   [0, fy, TDWUtils.__HEIGHT \/ 2.0],\r\n                                   [0, 0, 1]])\r\n            img_inv = np.linalg.inv(intrinsics[:3, :3])\r\n            TDWUtils.__CAM_TO_IMG_MAT = np.dot(img_inv, img_pix_ones)\r\n\r\n        points_in_cam = np.multiply(TDWUtils.__CAM_TO_IMG_MAT, depth.reshape(-1))\r\n        points_in_cam = np.concatenate((points_in_cam, np.ones((1, points_in_cam.shape[1]))), axis=0)\r\n        points_in_world = np.dot(camera_matrix, points_in_cam)\r\n        points_in_world = points_in_world[:3, :].reshape(3, TDWUtils.__WIDTH, TDWUtils.__HEIGHT)\r\n        points_in_cam = points_in_cam[:3, :].reshape(3, TDWUtils.__WIDTH, TDWUtils.__HEIGHT)\r\n        if filename is not None:\r\n            f = open(filename, 'w')\r\n            for i in range(points_in_world.shape[1]):\r\n                for j in range(points_in_world.shape[2]):\r\n                    if points_in_cam[2, i, j] < (far_plane - near_plane):\r\n                        f.write(f'{points_in_world[0, i, j]};{points_in_world[1, i, j]};{points_in_world[2, i, j]}\\n')\r\n        return points_in_world\r\n\r\n    @staticmethod\r\n    def create_avatar(avatar_type=\"A_Img_Caps_Kinematic\", avatar_id=\"a\", position=None, look_at=None) -> List[dict]:\r\n        \"\"\"\r\n        This is a wrapper for `create_avatar` and, optionally, `teleport_avatar_to` and `look_at_position`.\r\n\r\n        :param avatar_type: The type of avatar.\r\n        :param avatar_id: The avatar ID.\r\n        :param position: The position of the avatar. If this is None, the avatar won't teleport.\r\n        :param look_at: If this isn't None, the avatar will look at this position.\r\n\r\n        :return A list of commands to create theavatar.\r\n        \"\"\"\r\n\r\n        # Create the avatar.\r\n        commands = [{\"$type\": \"create_avatar\",\r\n                     \"type\": avatar_type,\r\n                     \"id\": avatar_id}]\r\n\r\n        # Teleport the avatar.\r\n        if position:\r\n            commands.append({\"$type\": \"teleport_avatar_to\",\r\n                             \"avatar_id\": avatar_id,\r\n                             \"position\": position})\r\n        if look_at:\r\n            commands.append({\"$type\": \"look_at_position\",\r\n                             \"avatar_id\": avatar_id,\r\n                             \"position\": look_at})\r\n        return commands\r\n\r\n    @staticmethod\r\n    def _send_start_build(socket, controller_address: str) -> dict:\r\n        \"\"\"\r\n        This sends a command to the launch_binaries daemon running on a remote node\r\n        to start a binary connected to the given controller address.\r\n\r\n        :param socket: The zmq socket.\r\n        :param controller_address: The host name or ip address of node running the controller.\r\n\r\n        :return Build info dictionary containing build port.\r\n        \"\"\"\r\n        request = {\"type\": \"start_build\",\r\n                   \"controller_address\": controller_address}\r\n        socket.send_json(request)\r\n        build_info = socket.recv_json()\r\n        return build_info\r\n\r\n    @staticmethod\r\n    def _send_keep_alive(socket, build_info: dict) -> dict:\r\n        \"\"\"\r\n        This sends a command to the launch_binaries daemon running on a remote node\r\n        to mark a given binary as still alive, preventing garbage collection.\r\n\r\n        :param socket: The zmq socket.\r\n        :param build_info: A diciontary containing the build_port.\r\n\r\n        :return a heartbeat indicating build is still alive.\r\n        \"\"\"\r\n\r\n        build_port = build_info[\"build_port\"]\r\n        request = {\"type\": \"keep_alive\", \"build_port\": build_port}\r\n        socket.send_json(request)\r\n        heartbeat = socket.recv_json()\r\n        return heartbeat\r\n\r\n    @staticmethod\r\n    def _send_kill_build(socket, build_info: dict) -> dict:\r\n        \"\"\"\r\n        This sends a command to the launch_binaries daemon running on a remote node to terminate a given binary.\r\n\r\n        :param socket: The zmq socket.\r\n        :param build_info: A diciontary containing the build_port.\r\n\r\n        :return A kill_status indicating build has been succesfully terminated.\r\n        \"\"\"\r\n\r\n        build_port = build_info[\"build_port\"]\r\n        request = {\"type\": \"kill_build\", \"build_port\": build_port}\r\n        socket.send_json(request)\r\n        kill_status = socket.recv_json()\r\n        return kill_status\r\n\r\n    @staticmethod\r\n    def _keep_alive_thread(socket, build_info: dict) -> None:\r\n        \"\"\"\r\n        This is a wrapper around the keep alive command to be executed in a separate thread.\r\n\r\n        :param socket: The zmq socket.\r\n        :param build_info: A diciontary containing the build_port.\r\n        \"\"\"\r\n        while True:\r\n            TDWUtils._send_keep_alive(socket, build_info)\r\n            time.sleep(60)\r\n\r\n    @staticmethod\r\n    def launch_build(listener_port: int, build_address: str, controller_address: str) -> dict:\r\n        \"\"\"\r\n        Connect to a remote binary_manager daemon and launch an instance of a TDW build.\r\n\r\n        Returns the necessary information for a local controller to connect.\r\n        Use this function to automatically launching binaries on remote (or local) nodes, and to\r\n        automatically shut down the build after controller is finished. Call in the constructor\r\n        of a controller and pass the build_port returned in build_info to the parent Controller class.\r\n\r\n        :param listener_port: The port launch_binaries is listening on.\r\n        :param build_address: Remote IP or hostname of node running launch_binaries.\r\n        :param controller_address: IP or hostname of node running controller.\r\n\r\n        :return The build_info dictionary containing build_port.\r\n        \"\"\"\r\n\r\n        context = zmq.Context()\r\n        socket = context.socket(zmq.REQ)\r\n        socket.connect(\"tcp:\/\/\" + build_address + \":%s\" % listener_port)\r\n        build_info = TDWUtils._send_start_build(socket, controller_address)\r\n        thread = Thread(target=TDWUtils._keep_alive_thread,\r\n                        args=(socket, build_info))\r\n        thread.setDaemon(True)\r\n        thread.start()\r\n        return build_info\r\n\r\n    @staticmethod\r\n    def get_unity_args(arg_dict: dict) -> List[str]:\r\n        \"\"\"\r\n        :param arg_dict: A dictionary of arguments. Key=The argument prefix (e.g. port) Value=Argument value.\r\n\r\n        :return The formatted command line string that is accepted by unity arg parser.\r\n        \"\"\"\r\n\r\n        formatted_args = []\r\n        for key, value in arg_dict.items():\r\n            prefix = \"-\" + key + \"=\"\r\n            if type(value) == list:\r\n                prefix += \",\".join([str(v) for v in value])\r\n            else:\r\n                prefix += str(value)\r\n            formatted_args += [prefix]\r\n        return formatted_args\r\n\r\n    @staticmethod\r\n    def find_free_port() -> int:\r\n        \"\"\"\r\n        :return a free port.\r\n        \"\"\"\r\n\r\n        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:\r\n            s.bind((\"\", 0))\r\n            return int(s.getsockname()[1])\r\n\r\n    @staticmethod\r\n    def get_unit_scale(record: ModelRecord) -> float:\r\n        \"\"\"\r\n        :param record: The model record.\r\n\r\n        :return The scale factor required to scale a model to 1 meter \"unit scale\".\r\n        \"\"\"\r\n\r\n        bounds = record.bounds\r\n\r\n        # Get the \"unit scale\" of the object.\r\n        s = 1 \/ max(\r\n            bounds['top']['y'] - bounds['bottom']['y'],\r\n            bounds['front']['z'] - bounds['back']['z'],\r\n            bounds['right']['x'] - bounds['left']['x'])\r\n        return s\r\n\r\n    @staticmethod\r\n    def validate_amazon_s3() -> bool:\r\n        \"\"\"\r\n        Validate that your local Amazon S3 credentials are set up correctly.\r\n\r\n        :return True if everything is OK.\r\n        \"\"\"\r\n\r\n        config_path = Path.home().joinpath(\".aws\/config\")\r\n        new_config_path = not config_path.exists()\r\n        # Generate a valid config file.\r\n        if new_config_path:\r\n            config_path.write_text(\"[default]\\nregion = us-east-1\\noutput = json\")\r\n            print(f\"Generated a new config file: {config_path.resolve()}\")\r\n        try:\r\n            session = boto3.Session(profile_name=\"tdw\")\r\n            s3 = session.resource(\"s3\")\r\n            s3.meta.client.head_object(Bucket='tdw-private', Key='models\/windows\/2018-2019.1\/iron_box')\r\n            return True\r\n        except ProfileNotFound:\r\n            print(f\"ERROR! Your AWS credentials file is not set up correctly.\")\r\n            print(\"Your AWS credentials must have a [tdw] profile with valid keys.\")\r\n            return False\r\n        except ClientError as e:\r\n            print(\"ERROR! Could not access bucket tdw-private. Make sure you have the right permissions.\")\r\n            error_code = e.response['Error']['Code']\r\n            print(e, error_code)\r\n            return False\r\n\r\n    @staticmethod\r\n    def get_base64_flex_particle_forces(forces: list) -> str:\r\n        \"\"\"\r\n        :param forces: The forces (see Flex documentation for how to arrange this array).\r\n\r\n        :return: An array of Flex particle forces encoded in base64.\r\n        \"\"\"\r\n\r\n        forces = np.array(forces, dtype=np.float32)\r\n        return base64.b64encode(forces).decode()\r\n\r\n    @staticmethod\r\n    def color_to_hashable(color: Union[np.array, Tuple[int, int, int]]) -> int:\r\n        \"\"\"\r\n        :param color: The color as an RGB array or tuple, where each value is between 0 and 255.\r\n\r\n        :return: A hashable integer representation of the color array.\r\n        \"\"\"\r\n\r\n        return (color[0] << 16) + (color[1] << 8) + color[2]\r\n\r\n    @staticmethod\r\n    def hashable_to_color(hashable: int) -> np.array:\r\n        \"\"\"\r\n        :param hashable: A hashable integer representing an RGB color.\r\n\r\n        :return: A color as a numpy array of integers between 0 and 255: `[r, g, b]`\r\n        \"\"\"\r\n\r\n        return np.array([(hashable >> 16) & 255, (hashable >> 8) & 255, hashable & 255], dtype=int)\r\n\r\n    @staticmethod\r\n    def get_bounds_dict(bounds: Bounds, index: int) -> Dict[str, np.array]:\r\n        \"\"\"\r\n        :param bounds: Bounds output data.\r\n        :param index: The index in `bounds` of the target object.\r\n\r\n        :return: A dictionary of the bounds. Key = the name of the position. Value = the position as a numpy array.\r\n        \"\"\"\r\n\r\n        return {\"top\": np.array(bounds.get_top(index)),\r\n                \"bottom\": np.array(bounds.get_bottom(index)),\r\n                \"left\": np.array(bounds.get_left(index)),\r\n                \"right\": np.array(bounds.get_right(index)),\r\n                \"front\": np.array(bounds.get_front(index)),\r\n                \"back\": np.array(bounds.get_back(index)),\r\n                \"center\": np.array(bounds.get_center(index))}\r\n\r\n    @staticmethod\r\n    def get_bounds_extents(bounds: Bounds, index: int) -> np.array:\r\n        \"\"\"\r\n        :param bounds: Bounds output data.\r\n        :param index: The index in `bounds` of the target object.\r\n\r\n        :return: The width (left to right), length (front to back), and height (top to bottom) of the bounds as a numpy array.\r\n        \"\"\"\r\n\r\n        return np.array([np.linalg.norm(np.array(bounds.get_left(index)) - np.array(bounds.get_right(index))),\r\n                         np.linalg.norm(np.array(bounds.get_front(index)) - np.array(bounds.get_back(index))),\r\n                         np.linalg.norm(np.array(bounds.get_top(index)) - np.array(bounds.get_bottom(index)))])\r\n\r\n    @staticmethod\r\n    def get_closest_position_in_bounds(origin: np.array, bounds: Bounds, index: int) -> np.array:\r\n        \"\"\"\r\n        :param origin: The origin from which the distance is calculated.\r\n        :param bounds: Bounds output data.\r\n        :param index: The index in `bounds` of the target object.\r\n\r\n        :return: The position on the object bounds that is closest to `origin`.\r\n        \"\"\"\r\n\r\n        object_bounds = TDWUtils.get_bounds_dict(bounds=bounds, index=index)\r\n\r\n        # Get the closest point on the bounds.\r\n        min_destination = \"\"\r\n        min_distance = 10000\r\n        for p in object_bounds:\r\n            d = np.linalg.norm(origin - object_bounds[p])\r\n            if d < min_distance:\r\n                min_distance = d\r\n                min_destination = p\r\n        return object_bounds[min_destination]\r\n\r\n    @staticmethod\r\n    def get_angle(forward: np.array, origin: np.array, position: np.array) -> float:\r\n        \"\"\"\r\n          :param position: The target position.\r\n          :param origin: The origin position of the directional vector.\r\n          :param forward: The forward directional vector.\r\n\r\n          :return: The angle in degrees between `forward` and the direction vector from `origin` to `position`.\r\n          \"\"\"\r\n\r\n        # Get the normalized directional vector to the target position.\r\n        p0 = np.array([origin[0], origin[2]])\r\n        p1 = np.array([position[0], position[2]])\r\n        d = p1 - p0\r\n        d = d \/ np.linalg.norm(d)\r\n        f = np.array([forward[0], forward[2]])\r\n\r\n        dot = f[0] * d[0] + f[1] * d[1]\r\n        det = f[0] * d[1] - f[1] * d[0]\r\n        angle = np.arctan2(det, dot)\r\n        angle = np.rad2deg(angle)\r\n        return angle\r\n\r\n    @staticmethod\r\n    def get_angle_between(v1: np.array, v2: np.array) -> float:\r\n        \"\"\"\r\n        :param v1: The first directional vector.\r\n        :param v2: The second directional vector.\r\n\r\n        :return: The angle in degrees between two directional vectors.\r\n        \"\"\"\r\n\r\n        ang1 = np.arctan2(v1[2], v1[0])\r\n        ang2 = np.arctan2(v2[2], v2[0])\r\n\r\n        return np.rad2deg((ang1 - ang2) % (2 * np.pi))\r\n\r\n    @staticmethod\r\n    def rotate_position_around(position: np.array, angle: float, origin: np.array = None) -> np.array:\r\n        \"\"\"\r\n        Rotate a position by a given angle around a given origin.\r\n\r\n        :param origin: The origin position.  If None, the origin is `[0, 0, 0]`\r\n        :param position: The point being rotated.\r\n        :param angle: The angle in degrees.\r\n\r\n        :return: The rotated position.\r\n        \"\"\"\r\n\r\n        if origin is None:\r\n            origin = np.array([0, 0, 0])\r\n\r\n        radians = np.deg2rad(angle)\r\n        x, y = position[0], position[2]\r\n        offset_x, offset_y = origin[0], origin[2]\r\n        adjusted_x = (x - offset_x)\r\n        adjusted_y = (y - offset_y)\r\n        cos_rad = np.cos(radians)\r\n        sin_rad = np.sin(radians)\r\n        qx = offset_x + cos_rad * adjusted_x + sin_rad * adjusted_y\r\n        qy = offset_y + -sin_rad * adjusted_x + cos_rad * adjusted_y\r\n\r\n        return np.array([qx, position[1], qy])\r\n\r\n    @staticmethod\r\n    def euler_angles_to_rpy(euler_angles: np.array) -> np.array:\r\n        \"\"\"\r\n        Convert Euler angles to ROS RPY angles.\r\n\r\n        :param euler_angles: A numpy array: `[x, y, z]` Euler angles in degrees.\r\n\r\n        :return: A numpy array: `[r, p, y]` angles in radians.\r\n        \"\"\"\r\n\r\n        # Source: https:\/\/github.com\/Unity-Technologies\/URDF-Importer\/blob\/c41208565419b04907496baa93ad1b675d41dc20\/com.unity.robotics.urdf-importer\/Runtime\/Extensions\/TransformExtensions.cs#L85-L92\r\n        return np.radians(np.array([-euler_angles[2], euler_angles[0], -euler_angles[1]]))\r\n\r\n\r\nclass AudioUtils:\r\n    \"\"\"\r\n    Utility class for recording audio in TDW using [fmedia](https:\/\/stsaz.github.io\/fmedia\/).\r\n\r\n    Usage:\r\n\r\n    ```python\r\n    from tdw.tdw_utils import AudioUtils\r\n    from tdw.controller import Controller\r\n\r\n    c = Controller()\r\n\r\n    initialize_trial()  # Your code here.\r\n\r\n    # Begin recording audio. Automatically stop recording at 10 seconds.\r\n    AudioUtils.start(output_path=\"path\/to\/file.wav\", until=(0, 10))\r\n\r\n    do_trial()  # Your code here.\r\n\r\n    # Stop recording.\r\n    AudioUtils.stop()\r\n    ```\r\n    \"\"\"\r\n\r\n    # The process ID of the audio recorder.\r\n    RECORDER_PID: Optional[int] = None\r\n    # The audio capture device.\r\n    DEVICE: Optional[str] = None\r\n\r\n    @staticmethod\r\n    def get_system_audio_device() -> str:\r\n        \"\"\"\r\n        :return: The audio device that can be used to capture system audio.\r\n        \"\"\"\r\n\r\n        devices = check_output([\"fmedia\", \"--list-dev\"]).decode(\"utf-8\").split(\"Capture:\")[1]\r\n        dev_search = re.search(\"device #(.*): Stereo Mix\", devices, flags=re.MULTILINE)\r\n        assert dev_search is not None, \"No suitable audio capture device found:\\n\" + devices\r\n        return dev_search.group(1)\r\n\r\n    @staticmethod\r\n    def start(output_path: Union[str, Path], until: Optional[Tuple[int, int]] = None) -> None:\r\n        \"\"\"\r\n        Start recording audio.\r\n\r\n        :param output_path: The path to the output file.\r\n        :param until: If not None, fmedia will record until `minutes:seconds`. The value must be a tuple of 2 integers. If None, fmedia will record until you send `AudioUtils.stop()`.\r\n        \"\"\"\r\n\r\n        if isinstance(output_path, str):\r\n            p = Path(output_path).resolve()\r\n        else:\r\n            p = output_path\r\n\r\n        # Create the directory.\r\n        if not p.parent.exists():\r\n            p.parent.mkdir(parents=True)\r\n\r\n        # Set the capture device.\r\n        if AudioUtils.DEVICE is None:\r\n            AudioUtils.DEVICE = AudioUtils.get_system_audio_device()\r\n        fmedia_call = [\"fmedia\",\r\n                       \"--record\",\r\n                       f\"--dev-capture={AudioUtils.DEVICE}\",\r\n                       f\"--out={str(p.resolve())}\",\r\n                       \"--globcmd=listen\"]\r\n        # Automatically stop recording.\r\n        if until is not None:\r\n            fmedia_call.append(f\"--until={TDWUtils.zero_padding(until[0], 2)}:{TDWUtils.zero_padding(until[1], 2)}\")\r\n        with open(os.devnull, \"w+\") as f:\r\n            AudioUtils.RECORDER_PID = Popen(fmedia_call,\r\n                                            stderr=f).pid\r\n\r\n    @staticmethod\r\n    def stop() -> None:\r\n        \"\"\"\r\n        Stop recording audio (if any fmedia process is running).\r\n        \"\"\"\r\n\r\n        if AudioUtils.RECORDER_PID is not None:\r\n            with open(os.devnull, \"w+\") as f:\r\n                call(['fmedia', '--globcmd=quit'], stderr=f, stdout=f)\r\n            AudioUtils.RECORDER_PID = None\r\n\r\n    @staticmethod\r\n    def is_recording() -> bool:\r\n        \"\"\"\r\n        :return: True if the fmedia recording process still exists.\r\n        \"\"\"\r\n\r\n        return AudioUtils.RECORDER_PID is not None and pid_exists(AudioUtils.RECORDER_PID)\r\n\r\n\r\nclass QuaternionUtils:\r\n    \"\"\"\r\n    Helper functions for using quaternions.\r\n\r\n    Quaternions are always numpy arrays in the following order: `[x, y, z, w]`.\r\n    This is the order returned in all Output Data objects.\r\n\r\n    Vectors are always numpy arrays in the following order: `[x, y, z]`.\r\n    \"\"\"\r\n\r\n    \"\"\":class_var\r\n    The global up directional vector.\r\n    \"\"\"\r\n    UP = np.array([0, 1, 0])\r\n    \"\"\":class_var\r\n    The global forward directional vector.\r\n    \"\"\"\r\n    FORWARD: np.array = np.array([0, 0, 1])\r\n    \"\"\":class_var\r\n    The quaternion identity rotation.\r\n    \"\"\"\r\n    IDENTITY = np.array([0, 0, 0, 1])\r\n\r\n    @staticmethod\r\n    def get_inverse(q: np.array) -> np.array:\r\n        \"\"\"\r\n        Source: https:\/\/referencesource.microsoft.com\/#System.Numerics\/System\/Numerics\/Quaternion.cs\r\n\r\n        :param q: The quaternion.\r\n\r\n        :return: The inverse of the quaternion.\r\n        \"\"\"\r\n\r\n        x = q[0]\r\n        y = q[1]\r\n        z = q[2]\r\n        w = q[3]\r\n\r\n        ls = x * x + y * y + z * z + w * w\r\n        inv = 1.0 \/ ls\r\n\r\n        return np.array([-x * inv, -y * inv, -z * inv, w * inv])\r\n\r\n    @staticmethod\r\n    def multiply(q1: np.array, q2: np.array) -> np.array:\r\n        \"\"\"\r\n        Multiply two quaternions.\r\n        Source: https:\/\/stackoverflow.com\/questions\/4870393\/rotating-coordinate-system-via-a-quaternion\r\n\r\n        :param q1: The first quaternion.\r\n        :param q2: The second quaternion.\r\n        :return: The multiplied quaternion: `q1 * q2`\r\n        \"\"\"\r\n\r\n        x1 = q1[0]\r\n        y1 = q1[1]\r\n        z1 = q1[2]\r\n        w1 = q1[3]\r\n\r\n        x2 = q2[0]\r\n        y2 = q2[1]\r\n        z2 = q2[2]\r\n        w2 = q2[3]\r\n\r\n        w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2\r\n        x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2\r\n        y = w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2\r\n        z = w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2\r\n        return np.array([x, y, z, w])\r\n\r\n    @staticmethod\r\n    def get_conjugate(q: np.array) -> np.array:\r\n        \"\"\"\r\n        Source: https:\/\/stackoverflow.com\/questions\/4870393\/rotating-coordinate-system-via-a-quaternion\r\n\r\n        :param q: The quaternion.\r\n\r\n        :return: The conjugate of the quaternion: `[-x, -y, -z, w]`\r\n        \"\"\"\r\n\r\n        x = q[0]\r\n        y = q[1]\r\n        z = q[2]\r\n        w = q[3]\r\n\r\n        return np.array([-x, -y, -z, w])\r\n\r\n    @staticmethod\r\n    def multiply_by_vector(q: np.array, v: np.array) -> np.array:\r\n        \"\"\"\r\n        Multiply a quaternion by a vector.\r\n        Source: https:\/\/stackoverflow.com\/questions\/4870393\/rotating-coordinate-system-via-a-quaternion\r\n\r\n        :param q: The quaternion.\r\n        :param v: The vector.\r\n\r\n        :return: A directional vector calculated from: `q * v`\r\n        \"\"\"\r\n\r\n        q2 = (v[0], v[1], v[2], 0.0)\r\n        return QuaternionUtils.multiply(QuaternionUtils.multiply(q, q2), QuaternionUtils.get_conjugate(q))[:-1]\r\n\r\n    @staticmethod\r\n    def world_to_local_vector(position: np.array, origin: np.array, rotation: np.array) -> np.array:\r\n        \"\"\"\r\n        Convert a vector position in absolute world coordinates to relative local coordinates.\r\n        Source: https:\/\/answers.unity.com\/questions\/601062\/what-inversetransformpoint-does-need-explanation-p.html\r\n\r\n        :param position: The position vector in world coordinates.\r\n        :param origin: The origin vector of the local space in world coordinates.\r\n        :param rotation: The rotation quaternion of the local coordinate space.\r\n\r\n        :return: `position` in local coordinates.\r\n        \"\"\"\r\n\r\n        return QuaternionUtils.multiply_by_vector(q=QuaternionUtils.get_inverse(q=rotation), v=position - origin)\r\n\r\n    @staticmethod\r\n    def get_up_direction(q: np.array) -> np.array:\r\n        \"\"\"\r\n        :param q: The rotation as a quaternion.\r\n\r\n        :return: A directional vector corresponding to the \"up\" direction from the quaternion.\r\n        \"\"\"\r\n\r\n        return QuaternionUtils.multiply_by_vector(q, QuaternionUtils.UP)\r\n\r\n    @staticmethod\r\n    def euler_angles_to_quaternion(euler: np.array) -> np.array:\r\n        \"\"\"\r\n        Convert Euler angles to a quaternion.\r\n\r\n        :param euler: The Euler angles vector.\r\n\r\n        :return: The quaternion representation of the Euler angles.\r\n        \"\"\"\r\n\r\n        roll = euler[0]\r\n        pitch = euler[1]\r\n        yaw = euler[2]\r\n        cy = np.cos(yaw * 0.5)\r\n        sy = np.sin(yaw * 0.5)\r\n        cp = np.cos(pitch * 0.5)\r\n        sp = np.sin(pitch * 0.5)\r\n        cr = np.cos(roll * 0.5)\r\n        sr = np.sin(roll * 0.5)\r\n\r\n        w = cy * cp * cr + sy * sp * sr\r\n        x = cy * cp * sr - sy * sp * cr\r\n        y = sy * cp * sr + cy * sp * cr\r\n        z = sy * cp * cr - cy * sp * sr\r\n        return np.array([x, y, z, w])\r\n\r\n    @staticmethod\r\n    def quaternion_to_euler_angles(quaternion: np.array) -> np.array:\r\n        \"\"\"\r\n        Convert a quaternion to Euler angles.\r\n\r\n        :param quaternion: A quaternion as a nump array.\r\n\r\n        :return: The Euler angles representation of the quaternion.\r\n        \"\"\"\r\n\r\n        x = quaternion[0]\r\n        y = quaternion[1]\r\n        z = quaternion[2]\r\n        w = quaternion[3]\r\n        ysqr = y * y\r\n\r\n        t0 = +2.0 * (w * x + y * z)\r\n        t1 = +1.0 - 2.0 * (x * x + ysqr)\r\n        ex = np.degrees(np.arctan2(t0, t1))\r\n\r\n        t2 = +2.0 * (w * y - z * x)\r\n        t2 = np.where(t2 > +1.0, +1.0, t2)\r\n\r\n        t2 = np.where(t2 < -1.0, -1.0, t2)\r\n        ey = np.degrees(np.arcsin(t2))\r\n\r\n        t3 = +2.0 * (w * z + x * y)\r\n        t4 = +1.0 - 2.0 * (ysqr + z * z)\r\n        ez = np.degrees(np.arctan2(t3, t4))\r\n\r\n        return np.array([ex, ey, ez])\r\n\r\n    @staticmethod\r\n    def get_y_angle(q1: np.array, q2: np.array) -> float:\r\n        \"\"\"\r\n        Source: https:\/\/en.wikipedia.org\/wiki\/Conversion_between_quaternions_and_Euler_angles\r\n\r\n        :param q1: The first quaternion.\r\n        :param q2: The second quaternion.\r\n\r\n        :return: The angle between the two quaternions in degrees around the y axis.\r\n        \"\"\"\r\n\r\n        qd = QuaternionUtils.multiply(QuaternionUtils.get_conjugate(q1), q2)\r\n\r\n        return np.rad2deg(2 * np.arcsin(qd[1]))\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_16","text":"import os\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.io import loadmat\nfrom svm import SVM\n\n#  Exercise 6 | Support Vector Machines\n\ndef linearKernel(x1, x2):\n    return x1.T @ x2\n\ndef gaussianKernel(x1, x2, sigma):\n    diff = x1 - x2\n    return np.exp(-(diff.T @ diff)\/(2*sigma*sigma))\n\ndef plotData(x, y):\n    pos = np.where(y==1)\n    neg = np.where(y==0)\n    plt.plot(x[pos[0],0], x[pos[0],1], 'b+', lw = 1.5, ms = 4)\n    plt.plot(x[neg[0],0], x[neg[0],1], 'ko', mfc = 'y', ms = 4)\n\n\ndef visualizeBoundaryLinear(X, y, model):\n    w = model.w\n    b = model.b\n    xp = np.linspace(min(X[:,0]), max(X[:,0]), 100)\n    yp = - (w[0] * xp + b)\/w[1]\n    plotData(X, y)\n    plt.plot(xp, yp, '-b')\n\ndef visualizeBoundary(X, y, model):\n    #VISUALIZEBOUNDARY plots a non-linear decision boundary learned by the SVM\n\n    # Plot the training data on top of the boundary\n    plotData(X, y)\n\n    # Make classification predictions over a grid of values\n    x1plot = np.linspace(min(X[:,0]), max(X[:,0]), 100)\n    x2plot = np.linspace(min(X[:,1]), max(X[:,1]), 100)\n    X1, X2 = np.meshgrid(x1plot, x2plot)\n    vals = np.zeros(X1.shape)\n    for i in range(X1.shape[1]):\n        this_X = np.c_[X1[:, i], X2[:, i]]\n        vals[:, i] = model.svmPredict(this_X)\n\n    # Plot the SVM boundary\n    plt.contour(X1, X2, vals, [0.5])\n\ndef dataset3Params(X, y, Xval, yval):\n    Cs = np.array([0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30])\n    sigmas = Cs\n    model = SVM()\n\n    costs = np.zeros((Cs.size, sigmas.size))\n    for i in range(Cs.size):\n        for j in range(sigmas.size):\n            sigma = sigmas[j]\n            #need to define gaussianKernelLambda lambda here again to capture sigma\n            gaussianKernelLambda = lambda x1, x2: (gaussianKernel(x1, x2, sigma))\n            gaussianKernelLambda.__name__ = 'gaussianKernel'\n\n            model.svmTrain(X, y.astype(float), Cs[i], gaussianKernelLambda)\n            predictions = model.svmPredict(Xval)\n            costs[i, j] = np.mean(predictions != yval)\n    i, j = np.unravel_index(np.argmin(costs), costs.shape)\n    return (Cs[i], sigmas[j])\n\n## =============== Part 1: Loading and Visualizing Data ================\nprint('Loading and Visualizing Data ...')\n\n# Load from ex6data1: \n# You will have X, y in your environment\nscriptdir = os.path.dirname(os.path.realpath(__file__))\ndata = loadmat(scriptdir + '\/\/ex6data1.mat')\nX = data['X']\ny = data['y'].ravel()\n# Plot training data\nplotData(X, y)\nplt.show()\n\ninput('Program paused. Press enter to continue.')\n\n\n## ==================== Part 2: Training Linear SVM ====================\n#  The following code will train a linear SVM on the dataset and plot the\n#  decision boundary learned.\n\nprint('\\nTraining Linear SVM ...')\n\n# You should try to change the C value below and see how the decision\n# boundary varies (e.g., try C = 1000)\nC = 1\nmodel = SVM()\n#we passed y.astype(float), firstly to be sure y -1 can be assigned to singed int. \n#secondly we want to preserve original y to 0 and 1\nmodel.svmTrain(X, y.astype(float), C, linearKernel, 1e-3, 20) \n\nvisualizeBoundaryLinear(X, y, model)\nplt.show()\ninput('Program paused. Press enter to continue.\\n')\n\n## =============== Part 3: Implementing Gaussian Kernel ===============\n\nprint('\\nEvaluating the Gaussian Kernel ...')\n\nx1 = np.array([1, 2, 1])\nx2 = np.array([0, 4, -1])\nsigma = 2\n\n#use lambda to be able to pass sigma\ngaussianKernelLambda = lambda x1, x2: (gaussianKernel(x1, x2, sigma))\ngaussianKernelLambda.__name__ = 'gaussianKernel'\n\n\nsim = gaussianKernelLambda(x1, x2)\n\nprint(f'Gaussian Kernel between x1 = [1c 2, 1], x2 = [0, 4, -1], sigma = {sigma} :')\nprint(f'\\t{sim}\\n(for sigma = 2, this value should be about 0.324652)\\n')\n\ninput('Program paused. Press enter to continue.\\n')\n\n\n## =============== Part 4: Visualizing Dataset 2 ================\n\nprint('Loading and Visualizing Data ...')\n\n# Load from ex6data2: \n# You will have X, y in your environment\ndata = loadmat(scriptdir + '\/\/ex6data2.mat')\nX = data['X']\ny = data['y'].ravel()\n\n# Plot training data\nplotData(X, y)\nplt.show()\n\ninput('Program paused. Press enter to continue.\\n')\n\n## ========== Part 5: Training SVM with RBF Kernel (Dataset 2) ==========\n\nprint('\\nTraining SVM with RBF Kernel (this may take 1 to 2 minutes) ...')\n\n# SVM Parameters\nC = 1; sigma = 0.1\n\n# We set the tolerance and max_passes lower here so that the code will run\n# faster. However, in practi ce, you will want to run the training to\n# convergence.\nmodel.svmTrain(X, y.astype(float), C, gaussianKernelLambda)\nvisualizeBoundary(X, y, model)\nplt.show()\ninput('Program paused. Press enter to continue.')\n\n\n## =============== Part 6: Visualizing Dataset 3 ================\n\nprint('Loading and Visualizing Data ...')\n\n# Load from ex6data3: \n# You will have X, y in your environment\ndata = loadmat(scriptdir + '\/\/ex6data3.mat')\n\nX = data['X']\ny = data['y'].ravel()\nXval = data['Xval']\nyval = data['yval'].ravel()\n\n# Plot training data\nplotData(X, y)\nplt.show()\n\ninput('Program paused. Press enter to continue.\\n')\n\n## ========== Part 7: Training SVM with RBF Kernel (Dataset 3) ==========\n\n#  This is a different dataset that you can use to experiment with. Try\n#  different values of C and sigma here. \n\n\n# Try different SVM Parameters here\nC, sigma = dataset3Params(X, y, Xval, yval)\n# Train the SVM\nmodel.svmTrain(X, y.astype(float), C, gaussianKernelLambda)\nvisualizeBoundary(X, y, model)\nplt.show()\ninput('Program paused. Press enter to continue.\\n')"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_18","text":"import os\nimport cv2\nimport glob\nimport h5py\nimport json\nimport joblib\nimport argparse\nimport numpy as np\nfrom tqdm import tqdm\nimport os.path as osp\nimport scipy.io as sio\n\nimport sys\nsys.path.append('.')\n\nfrom lib.models import spin\nfrom lib.core.config import TCMR_DB_DIR, BASE_DATA_DIR\nfrom lib.utils.utils import tqdm_enumerate\nfrom lib.data_utils._kp_utils import convert_kps\nfrom lib.data_utils._img_utils import get_bbox_from_kp2d\nfrom lib.data_utils._feature_extractor import extract_features\n\nfrom lib.data_utils._occ_utils import load_occluders\nfrom lib.models.smpl import H36M_TO_J14, SMPL_MODEL_DIR, SMPL\nfrom lib.utils.smooth_bbox import get_smooth_bbox_params, get_all_bbox_params\nfrom lib.utils.vis import draw_skeleton\n\n\nVIS_THRESH = 0.3\n\n\ndef cam2pixel(cam_coord, f, c):\n    x = cam_coord[:,0] \/ cam_coord[:,2] * f[0] + c[0]\n    y = cam_coord[:,1] \/ cam_coord[:,2] * f[1] + c[1]\n    z = cam_coord[:,2]\n    return np.stack((x,y,z),1)\n\ndef pixel2cam(pixel_coord, f, c):\n    x = (pixel_coord[:,0] - c[0]) \/ f[0] * pixel_coord[:,2]\n    y = (pixel_coord[:,1] - c[1]) \/ f[1] * pixel_coord[:,2]\n    z = pixel_coord[:,2]\n    return np.stack((x,y,z),1)\n\ndef world2cam(world_coord, R, t):\n    cam_coord = np.dot(R, world_coord.transpose(1,0)).transpose(1,0) + t.reshape(1,3)\n    return cam_coord\n\ndef cam2world(cam_coord, R, t):\n    world_coord = np.dot(np.linalg.inv(R), (cam_coord - t.reshape(1,3)).transpose(1,0)).transpose(1,0)\n    return world_coord\n\n\ndef read_data_train(dataset_path, set='train', debug=False):\n    dataset = {\n        'vid_name': [],\n        'frame_id': [],\n        'joints3D': [],\n        'joints2D': [],\n        'shape': [],\n        'pose': [],\n        'bbox': [],\n        'img_name': [],\n        'features': [],\n    }\n\n    # occluders = load_occluders('.\/data\/VOC2012')\n\n    model = spin.get_pretrained_hmr()\n\n    if set == 'train':\n        subjects = [1,5,6,7,8]\n    else:\n        subjects= [9, 11]\n    for subject in subjects:\n        annot_path = osp.join(dataset_path, 'annotations')\n        # camera load\n        with open(osp.join(annot_path, 'Human36M_subject' + str(subject) + '_camera.json'), 'r') as f:\n            cameras = json.load(f)\n        # joint coordinate load\n        with open(osp.join(annot_path, 'Human36M_subject' + str(subject) + '_joint_3d.json'), 'r') as f:\n            joints = json.load(f)\n        # SMPL parameters obtained by NeuralAnnot will be released (https:\/\/arxiv.org\/abs\/2011.11232) after publication\n        # # smpl parameter load\n        # with open(osp.join(annot_path, 'Human36M_subject' + str(subject) + '_SMPL_NeuralAnnot.json'), 'r') as f:\n        #     smpl_params = json.load(f)\n\n        seq_list = sorted(glob.glob(dataset_path + f'\/images\/s_{subject:02d}*'))\n        for seq in tqdm(seq_list):\n            seq_name = seq.split('\/')[-1]\n            act = str(int(seq_name.split('_act_')[-1][0:2]))\n            subact = str(int(seq_name.split('_subact_')[-1][0:2]))\n            cam = str(int(seq_name.split('_ca_')[-1][0:2]))\n            # if cam != '4':  # front camera (Table 6)\n            #     continue\n            print(\"seq name: \", seq)\n\n            img_paths = sorted(glob.glob(seq + '\/*.jpg'))\n            num_frames = len(img_paths)\n            if num_frames < 1:\n                continue\n            # camera parameter\n            cam_param = cameras[cam]\n            R, t, f, c = np.array(cam_param['R'], dtype=np.float32), np.array(cam_param['t'], dtype=np.float32), np.array(\n                cam_param['f'], dtype=np.float32), np.array(cam_param['c'], dtype=np.float32)\n\n            # img starts from index 1, and annot starts from index 0\n            poses = np.zeros((num_frames, 72), dtype=np.float32)\n            shapes = np.zeros((num_frames, 10), dtype=np.float32)\n            j3ds = np.zeros((num_frames, 49, 3), dtype=np.float32)\n            j2ds = np.zeros((num_frames, 49, 3), dtype=np.float32)\n\n            for img_i in tqdm(range(num_frames)):\n                # smpl_param = smpl_params[act][subact][str(img_i)][cam]\n                # pose = np.array(smpl_param['pose'], dtype=np.float32)\n                # shape = np.array(smpl_param['shape'], dtype=np.float32)\n\n                joint_world = np.array(joints[act][subact][str(img_i)], dtype=np.float32)\n                # match right, left\n                match = [[1, 4], [2, 5], [3, 6]]\n                for m in match:\n                    l, r = m\n                    joint_world[l], joint_world[r] = joint_world[r].copy(), joint_world[l].copy()\n                joint_cam = world2cam(joint_world, R, t)\n                joint_img = cam2pixel(joint_cam, f, c)\n\n                j3d = convert_kps(joint_cam[None, :, :] \/ 1000, \"h36m\", \"spin\").reshape((-1, 3))\n                j3d = j3d - j3d[39]  # 4 is the root\n\n                joint_img[:, 2] = 1\n                j2d = convert_kps(joint_img[None, :, :], \"h36m\", \"spin\").reshape((-1,3))\n\n                # poses[img_i] = pose\n                # shapes[img_i] = shape\n                j3ds[img_i] = j3d\n                j2ds[img_i] = j2d\n\n                \"\"\"\n                import torch\n                smpl = SMPL(SMPL_MODEL_DIR, batch_size=1, create_transl=False)\n    \n                p = torch.from_numpy(pose).float().reshape(1,-1,3)\n                s = torch.from_numpy(shape).float().reshape(1,-1)\n                J_regressor = torch.from_numpy(np.load(osp.join(TCMR_DATA_DIR, 'J_regressor_h36m.npy'))).float()\n                output = smpl(betas=s, body_pose=p[:, 3:], global_orient=p[:, :3])\n                vertices = output.vertices\n                J_regressor_batch = J_regressor[None, :].expand(vertices.shape[0], -1, -1).to(vertices.device)\n                temp_j3d = torch.matmul(J_regressor_batch, vertices) * 1000\n                # temp_j3d = temp_j3d - temp_j3d[:, 0, :]\n                temp_j3d = temp_j3d[0, H36M_TO_J14, :]\n    \n                gt_j3d = joint_cam - joint_cam[0, :]\n                gt_j3d = gt_j3d[H36M_TO_J14, :]\n    \n                print(\"CHECK: \", (temp_j3d-gt_j3d))\n                \"\"\"\n\n            bbox_params, time_pt1, time_pt2 = get_smooth_bbox_params(j2ds, vis_thresh=VIS_THRESH, sigma=8)\n            # bbox_params, time_pt1, time_pt2 = get_all_bbox_params(j2ds, vis_thresh=VIS_THRESH)\n\n            \"\"\"\n            img = cv2.imread(img_paths[0])\n            temp = draw_skeleton(img, j2ds[0], dataset='spin', unnormalize=False, thickness=2)\n            cv2.imshow('img', temp)\n            cv2.waitKey(0)\n            cv2.destroyAllWindows()\n            cv2.waitKey(1)\n            \"\"\"\n\n            # process bbox_params\n            c_x = bbox_params[:, 0]\n            c_y = bbox_params[:, 1]\n            scale = bbox_params[:, 2]\n\n            w = h = 150. \/ scale\n            w = h = h * 0.9  # 1.1 for h36m_train_25fps_occ_db.pt\n            bbox = np.vstack([c_x, c_y, w, h]).T\n\n            img_paths_array = np.array(img_paths)[time_pt1:time_pt2][::2]\n            bbox = bbox[::2]\n            # subsample frame to 25 fps\n\n            dataset['vid_name'].append(np.array([f'{seq}_{subject}'] * num_frames)[time_pt1:time_pt2][::2])\n            dataset['frame_id'].append(np.arange(0, num_frames)[time_pt1:time_pt2][::2])\n            dataset['joints3D'].append(j3ds[time_pt1:time_pt2][::2])\n            dataset['joints2D'].append(j2ds[time_pt1:time_pt2][::2])\n            dataset['shape'].append(shapes[time_pt1:time_pt2][::2])\n            dataset['pose'].append(poses[time_pt1:time_pt2][::2])\n\n            dataset['img_name'].append(img_paths_array)\n            dataset['bbox'].append(bbox)\n\n            features = extract_features(model, None, img_paths_array, bbox,\n                                        kp_2d=j2ds[time_pt1:time_pt2][::2], debug=debug, dataset='h36m', scale=1.0)  # 1.2 for h36m_train_25fps_occ_db.pt\n\n            dataset['features'].append(features)\n\n    for k in dataset.keys():\n        dataset[k] = np.concatenate(dataset[k])\n        print(k, dataset[k].shape)\n\n    return dataset\n\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser()\n    parser.add_argument('--dir', type=str, help='dataset directory', default='data\/h36m')\n    parser.add_argument('--set', type=str, help='select train\/test set', default='train')\n\n    args = parser.parse_args()\n\n    # import torch\n    # torch.set_num_threads(8)\n\n    dataset = read_data_train(args.dir, args.set)\n    joblib.dump(dataset, osp.join(TCMR_DB_DIR, f'h36m_{args.set}_25fps_tight_db.pt'))  # h36m_train_25fps_occ_db.pt\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_19","text":"import numpy as np\nfrom scipy.optimize import fsolve\n# from sympy import symbols, exp, solve\n# from sympy import Symbol\n\n# mu_m, lam, t = symbols('mu_m, lam, t')\nv = - 1\/3\nA = 281.6 * 1000\n\nINITIAL_WEIGHT = 10\nONE_YEAR_WEIGHT = 35\n\n\ndef rechards_equations(A, v, mu_m, lam, t):\n    temp1 = (mu_m \/ A) * ((1+v) ** (1 + 1\/v)) * (lam - t)\n    temp2 = np.exp(temp1)\n    temp3 = v * np.exp(1 + v) * temp2\n    temp4 = A * (1 + temp3)**(-1\/v)\n\n    return temp4\n\ndef equations(p):\n    mu_m, lam = p\n    return (rechards_equations(A, v, mu_m, lam, 0) - INITIAL_WEIGHT, rechards_equations(A, v, mu_m, lam, 1)-ONE_YEAR_WEIGHT)\n\n\n\n# print(equations((mu_m, lam)))\n\n\n\n# (15.954190216465834, -11.657871577866423)\n\nerror = 10000\nbest_mu_0 = 0\nbest_lam_0 = 0\nmu_res = 0\nlam_res = 0\nfor mu_m_0 in range(1, 1000, 10):\n    for lam_0 in range(1, 1000, 10):\n        print('=======')\n        print('mu_m_0 = ', mu_m_0)\n        print('lam_0 = ', lam_0)\n        mu_m, lam = fsolve(equations, (mu_m_0, lam_0))\n        temp1 = rechards_equations(A, v, mu_m, lam, 0) - INITIAL_WEIGHT\n        temp2 = rechards_equations(A, v, mu_m, lam, 1) - ONE_YEAR_WEIGHT\n        print(temp1)\n        print(temp2)\n        if np.abs(temp1) + np.abs(temp2) < error:\n            error = np.abs(temp1) + np.abs(temp2)\n            best_lam_0 = lam_0\n            best_mu_0 = mu_m_0\n            mu_res = mu_m\n            lam_res = lam\n        print()\n    \nprint('best_mu_0 = ', best_mu_0)\nprint('best_lam_0 = ', best_lam_0)\nprint('error = ', error)\n\nprint('mu_res = ', mu_res)\nprint('lam_res = ', lam_res)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_20","text":"import sys\nimport os\nimport subprocess\nimport json\nfrom scipy import stats\nfrom argparse import ArgumentParser\n\nparser = ArgumentParser(description=\"Get Ideogram.js annotations for an SRR\")\nparser.add_argument(\"--acc\", required=True, help=\"SRR accession\")\nargs = parser.parse_args()\n\nacc = args.acc\nout = acc + \"_counts\"\n\nos.chdir(\"counting\")\n\nsubprocess.call([\"python\", \"counter.py\", \"--inp\", acc, \"--out\", out])\n\nos.chdir(\"..\/formatter\")\nsubprocess.call([\n    \"python\", \"formatter.py\", \"--type\", \"srr\", \"--lookup\", \"gene_lookup_GRCh37.tsv\", \n    \"--inp\", \"..\/counting\/\" + out + \"_norm.tsv\", \"--out\", acc + \".json\"\n])\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_21","text":"'''\n    @author <NAME>.\n    @version 2019.3.19\n    @function\n        Use 'rdpcap()' to read packet file captured by Wireshark\n        Use 'pkt.time' to get packet receiving time in ms\n        Use 'pkt.len' to get RadioTap dummy length\n        Use 'len(pkt)' to get whole frame length\n        Use dtw to calculate distance between time series\n'''\n\nfrom scapy.utils import rdpcap\nfrom scapy.layers.dot11 import RadioTap\nimport numpy as np\n\nall_packets = rdpcap('data\/evil-twin-20190318-part1.pcapng')\nclient_packets = []\nap_packets = []\n\nfor i in range(0, len(all_packets)):\n    time = all_packets[i].time\n    length = len(all_packets[i]) - all_packets[i].len\n    point = [time, length]\n    if '50:5b:c2:d8:d1:21' in all_packets[i].addr2:\n        client_packets.append(point)\n    else:\n        ap_packets.append(point)\n\nx = np.array(client_packets)\ny = np.array(ap_packets)\n\nfrom scipy.spatial.distance import euclidean\nfrom fastdtw import fastdtw\n\ndistance, path = fastdtw(x, y, dist=euclidean)\nprint(distance)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_22","text":"\nimport numpy as np\nfrom scipy import linalg\nimport pathlib, sys\nfile_path = pathlib.Path(__file__).parent.absolute()\n\nfrom pressio4py import ode, rom\nfrom pressio4py.apps.burgers1d import Burgers1d\n\ngold = np.array(\n  [5.0081542681376, 5.016629490569,\n   5.025433912557,  5.0345792953115,\n   5.0440827179355, 5.0539568295087,\n   5.0642107801363, 5.074857742734,\n   5.0859146000515, 5.0974001265619,\n   5.1093302710968, 5.1217197481536,\n   5.1345846667293, 5.1479436063682,\n   5.1618137609004, 5.1762071980595,\n   5.1911395190849, 5.2066322357211,\n   5.222706587389,  5.2393822195142,\n   5.2566784890019, 5.274617970535,\n   5.2932246323729, 5.3125186218141,\n   5.3325236627322, 5.3532729201416,\n   5.3747971779128, 5.3971189932731,\n   5.4202577535351, 5.4442348269811,\n   5.469078757402,  5.4948202159561,\n   5.5214859714822, 5.5491009348394,\n   5.5776911098501, 5.6072849195866,\n   5.6379131952825, 5.6696069037791,\n   5.7023980878343, 5.7363239274031,\n   5.7714263431002, 5.807744410524,\n   5.8453128737429, 5.884168702448,\n   5.9243510856362, 5.9658923478856,\n   6.0088164545724, 6.0531503069487,\n   6.0989210765093, 6.1461565470309])\n\n#----------------------------------------\nclass OdeObserver:\n  def __init__(self, fomRec):\n    self.fomRec = fomRec\n\n  def __call__(self, timeStep, time, state):\n    fs = self.fomRec(state)\n    assert(fs.shape[0]==50)\n\n#----------------------------------------\ndef test_euler():\n  meshSize = 50\n  romSize  = 20\n  Nsteps   = 3500\n  dt       = 0.01\n\n  # create fom object\n  appObj = Burgers1d(meshSize)\n  # reference state\n  yRef = np.ones(meshSize)\n\n  # I have to make phi a column-major array to ensure\n  # pressio does not make a copy of this\n  basisFile = str(file_path) + \"\/basis_euler.txt\"\n  phi = np.copy(np.loadtxt(basisFile), order='F')\n  decoder = rom.Decoder(phi)\n\n  # create rom state\n  yRom = np.zeros(romSize)\n  # create problem\n  scheme = ode.stepscheme.ForwardEuler\n  problem = rom.galerkin.DefaultExplicitProblem(scheme, appObj, decoder, yRom, yRef)\n\n  fomRecon = problem.fomStateReconstructor()\n  # the observer is called to monitor evolution of rom_state and\n  # uses the reconstructor object to reconstruct FOM state\n  myObs = OdeObserver(fomRecon)\n  ode.advance_n_steps_and_observe(problem, yRom, 0., dt, Nsteps, myObs)\n\n  # reconstruct full state at the end\n  yFomFinal = fomRecon(yRom)\n  print(yFomFinal)\n\n  # check solution is right\n  for y1,y2 in zip(gold, yFomFinal):\n    assert( np.abs(y1-y2) < 1e-12)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_23","text":"<gh_stars>1-10\nfrom astropy.io import fits\nfrom astropy.convolution import convolve, Box1DKernel\n\nimport scipy as sp\nimport matplotlib\nimport matplotlib.pyplot as plt\n\nimport glob\n\n'''\nO 436\nB 582\nA 745\nF 766\nG 596\nK 759\nM 306\n'''\n\n'''\nO 476, 8773, 9818\nB 96, 378, 462, 489, 492\nA 17, 114, 120, 136\nF 52, 158\nG 25, 27, 30, 85\nK 61, 65\nM 256, 291, 300\n'''\n\ni = [476, 378, 17, 158, 30, 61, 256]\n\nc = ['O', 'B', 'A', 'F', 'G', 'K', 'M'][::-1]\n\nloc = 5891\n\nfiles = [glob.glob('\/data2\/cpb405\/Training_2\/*.fits')[j] for j in i][::-1]\n\nfig, ax = plt.subplots(figsize = (5,0.9*5*sp.sqrt(2)))\n\nax.axvline(6565, c = 'r', alpha = 0.1)\nax.text(6600, 7, 'Ha', color = 'r')\nax.axvline(4862, c = 'r', alpha = 0.1)\nax.text(4900, 7, 'Hb', color = 'r')\nax.axvline(4342, c = 'r', alpha = 0.1)\nax.text(4400, 7, 'Hg', color = 'r')\n\nfor idx in range(len(files)):\n    \n    with fits.open(files[idx]) as hdulist:\n        flux = hdulist[0].data[0]\n        init = hdulist[0].header['COEFF0']\n        disp = hdulist[0].header['COEFF1']\n        CLS = hdulist[0].header['CLASS']\n        SCLS = hdulist[0].header['SUBCLASS'][0]\n        #print('{}, {}, {}'.format(idx, CLS, SCLS))\n    \n    wavelength = 10**sp.arange(init, init+disp*(len(flux)-0.9), disp)\n    \n    wavelength = wavelength[:-100]\n    flux = flux[:-100]\n    \n    flux = sp.array(flux)\n\n    wi = sp.searchsorted(wavelength, loc)\n    \n    #wi = -1\n    \n    flux = flux\/sp.amax(flux)\n        \n    ax.plot(wavelength, flux + idx, label = c[idx], c = '#1f77b4')\n    \n    ax.annotate(c[idx], xy = (wavelength[sp.argmax(flux)]-75, idx+1.03))\n\n\nax.set_title('Stellar Spectra')\nax.set_xlabel('Wavelength \\ Angstroms')\nax.set_ylabel('Normalised Flux')\nplt.yticks([],\" \")\n#ax.set_yticklabels([])\n#ax.get_yaxis().set_visible(False)\nplt.tight_layout()\nplt.savefig('MK.pdf')\nplt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_24","text":"from TCP_monitor import TCP_monitor\nfrom OnlineHeart import OnlineHeart\nfrom Silver import Silver\nfrom LotteryResult import LotteryResult\nfrom Tasks import Tasks\nfrom connect import connect\nfrom rafflehandler import Rafflehandler\nimport asyncio\nfrom login import login\nfrom printer import Printer\nfrom statistics import Statistics\nfrom bilibili import bilibili\nimport biliconsole\nfrom pkLottery import PKLottery\nfrom guardLottery import GuardLottery\nfrom schedule import Schedule\nimport configloader\nimport os\n\nfileDir = os.path.dirname(os.path.realpath('__file__'))\nfile_user = fileDir + \"\/conf\/user.conf\"\ndic_user = configloader.load_user(file_user)\n\nloop = asyncio.get_event_loop()\nprinter = Printer(dic_user['thoroughly_log']['on'])\nbilibili()\nStatistics()\nrafflehandler = Rafflehandler()\nbiliconsole.Biliconsole()\n\ntask = OnlineHeart()  # 在线心跳\ntask1 = Silver()  # 领取银瓜子\ntask2 = Tasks()  # 获取每日包裹奖励，签到功能，领取每日任务奖励，应援团签到，过期礼物处理，银瓜子兑换硬币，硬币换瓜子，将当前佩戴的勋章亲密度送满，\ntask3 = LotteryResult()  # 广播抽奖检测\ntask4 = connect()  # 新的战疫分区直播间实际上没有弹幕区???\ntask5 = PKLottery()  # 大乱斗抽奖？\ntask6 = GuardLottery()  # 上船奖励？\n\ntasks1 = [\n    login().login_new()\n]\nloop.run_until_complete(asyncio.wait(tasks1))\n\n# 任务\n# import threading\n# console_thread = threading.Thread(target=biliconsole.controler)\n# console_thread.start()\n\n\ntasks = [\n    task.run(),\n    task1.run(),\n    task2.run(),\n    biliconsole.Biliconsole().run(),#？？？？？\n    task4.create(),\n    task3.query(),\n    rafflehandler.run(),\n    task5.run(),\n    task6.run()\n]\n\nif dic_user['monitoy_server']['on']:#监控服务器\n    monitor = TCP_monitor()\n    task_tcp_conn = monitor.connectServer(\n        dic_user['monitoy_server']['host'], dic_user['monitoy_server']['port'], dic_user['monitoy_server']['key'])\n    task_tcp_heart = monitor.HeartbeatLoop()\n    tasks.append(task_tcp_conn)\n    tasks.append(task_tcp_heart)\n\nschedule = Schedule()\nif dic_user['regular_sleep']['on']:\n    tasks.append(schedule.run(dic_user['regular_sleep']['schedule']))\n    Schedule().scheduled_sleep = True\n\ntasks = list(map(asyncio.ensure_future, tasks))\nloop.run_until_complete(asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION))\nPrinter().printer('\\n'.join(map(repr, asyncio.Task.all_tasks())), \"Info\", \"green\")\nfor task in tasks:\n    Printer().printer(repr(task._state), \"Info\", \"green\")\n    if task._state == 'FINISHED':\n        Printer().printer(f\"Task err: {repr(task.exception())}\", \"Error\", \"red\")\nloop.close()\n\n# console_thread.join()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_26","text":"\"\"\"This module contains auxiliary functions for the robust optimization problem.\"\"\"\nfrom functools import partial\n\nimport numpy as np\nfrom scipy.optimize import fminbound\n\nfrom robupy.tests.resources.pre_numba.checks import pre_numba_checks\nfrom robupy.tests.resources.pre_numba.config import EPS_FLOAT\nfrom robupy.tests.resources.pre_numba.config import MAX_FLOAT\n\n\ndef pre_numba_criterion_full(v, q, beta, lambda_):\n    \"\"\"This is the criterion function for ...\"\"\"\n    pre_numba_checks(\"criterion_full_in\", v, q, beta, lambda_)\n\n    # We want to rule out an infinite logarithm.\n    arg_ = np.clip(np.sum(q * np.exp(v \/ lambda_)), EPS_FLOAT, None)\n\n    rslt = lambda_ * np.log(arg_) + lambda_ * beta\n\n    pre_numba_checks(\"criterion_full_out\", rslt)\n\n    return rslt\n\n\ndef pre_numba_calculate_p(v, q, lambda_):\n    \"\"\"This function return the optimal ...\"\"\"\n    pre_numba_checks(\"calculate_p_in\", v, q, lambda_)\n\n    p = q * np.clip(np.exp(v \/ lambda_), None, MAX_FLOAT)\n    p = p \/ np.sum(p)\n\n    pre_numba_checks(\"calculate_p_out\", p)\n\n    return p\n\n\ndef pre_numba_get_worst_case_probs(v, q, beta, is_cost=True):\n    \"\"\"This function return the worst case measure.\"\"\"\n    pre_numba_checks(\"get_worst_case_in\", v, q, beta)\n\n    if beta == 0.0:\n        return q.copy()\n\n    # We can use this function to determine the worst case if we pass in costs or if we pass in\n    # utility.\n    if not is_cost:\n        v_intern = -np.array(v).copy()\n    else:\n        v_intern = np.array(v)\n\n    # We scale the value function to avoid too large evaluations of the exponential function in\n    # the calculate_p() function.\n    v_scaled = v_intern \/ max(abs(v_intern))\n\n    upper = np.clip(\n        (max(v_scaled) - np.matmul(q, v_scaled)) \/ beta, 2 * EPS_FLOAT, None\n    )\n    lower = EPS_FLOAT\n\n    criterion = partial(pre_numba_criterion_full, v_scaled, q, beta)\n\n    rslt = fminbound(criterion, lower, upper, xtol=EPS_FLOAT, full_output=True)\n    p = pre_numba_calculate_p(v_scaled, q, rslt[0])\n\n    pre_numba_checks(\"get_worst_case_out\", p, q, beta, rslt)\n\n    return p\n\n\ndef pre_numba_get_worst_case_outcome(v, q, beta, is_cost=True):\n    \"\"\"This function calculates the worst case outcome.\"\"\"\n    pre_numba_checks(\"get_worst_case_outcome_in\", v, q, beta)\n\n    # We want to handle two cases explicitly. First we deal with the case that there is no\n    # ambiguity in the transition probabilities. Second, we look at the case where the all mass\n    # assigned to the worst-case realization is inside the feasible set.\n    if beta == 0:\n        return np.matmul(q, v)\n    elif beta >= max(-np.log(q)):\n        if is_cost:\n            return max(v)\n        else:\n            return min(v)\n\n    p = pre_numba_get_worst_case_probs(v, q, beta, is_cost)\n    rslt = np.matmul(p, v)\n\n    pre_numba_checks(\"get_worst_case_outcome_out\", v, q, beta, is_cost, rslt)\n\n    return rslt\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_27","text":"# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import, division, print_function, unicode_literals\nimport torch\nimport copy\nimport six  # NOQA\nimport torch.nn as nn\nimport torchvision\nimport ubelt as ub\nimport numpy as np\nfrom collections import OrderedDict\nfrom netharn.analytic.output_shape_for import OutputShapeFor\nfrom netharn.analytic import analytic_for\nfrom distutils.version import LooseVersion\n# try:\n# from netharn.device import MountedModel\n# except ImportError:\n#     MountedModel = None\n\nREGISTERED_TYPES = []\n\n\nif LooseVersion(torch.__version__) >= LooseVersion('1.5.0'):\n    CONV_TRANSPOSE_TYPES = (nn.modules.conv._ConvTransposeNd,)\nelse:\n    CONV_TRANSPOSE_TYPES = (nn.modules.conv._ConvTransposeMixin,)\n\n\ndef ensure_array_nd(data, n):\n    if ub.iterable(data):\n        return np.array(data)\n    else:\n        return np.array([data] * n)\n\n\ndef compute_type(*types):\n    def _wrap(func):\n        for type in types:\n            if type is not None:\n                REGISTERED_TYPES.append((type, func))\n        return func\n    return _wrap\n\n\nclass ReceptiveFieldTypeError(TypeError):\n    pass\n\n\nclass ReceptiveField(OrderedDict, analytic_for.Output):\n    \"\"\"\n    container for holding a receptive feild\n\n    Example:\n        >>> self = ReceptiveField.coerce({\n        >>>     'stride': np.array([4]),\n        >>>     'shape': np.array([1]),\n        >>>     'crop': np.array([0]),\n        >>> })\n        >>> self_copy = copy.deepcopy(self)\n    \"\"\"\n    def __init__(self, data, hidden=None):\n        # Inheriting from an odict consistently between python 2\/3 is weird\n        data2 = OrderedDict(sorted(OrderedDict(data).items()))\n        OrderedDict.__init__(self, data2)\n        self.data = data2\n        self.hidden = hidden\n\n    def __copy__(self):\n        self_copy = ReceptiveField(self.data, self.hidden)\n        return self_copy\n\n    def __deepcopy__(self, memo):\n        data_copy = copy.deepcopy(self.data, memo)\n        hidden_copy = copy.deepcopy(self.hidden, memo)\n        self_copy = ReceptiveField(data_copy, hidden_copy)\n        return self_copy\n\n    @classmethod\n    def coerce(cls, data, hidden=None):\n        \"\"\"\n        Example:\n            >>> # test weird python2 failure case\n            >>> from netharn.analytic.receptive_field_for import *\n            >>> cls = ReceptiveField\n            >>> data = [(0, ReceptiveFieldFor.input())]\n            >>> self = cls.coerce(data)\n            >>> print(ub.repr2(self, with_dtype=False))\n            {\n                0: {\n                    'crop': np.array([0., 0.]),\n                    'shape': np.array([1., 1.]),\n                    'stride': np.array([1., 1.]),\n                },\n            }\n        \"\"\"\n        # TODO: make this work like OutputShape\n        if data is None:\n            self = ReceptiveFieldFor.input()\n            self.hidden = hidden\n        elif isinstance(data, cls):\n            if hidden is None:\n                self = data\n            else:\n                self = data.__class__(data, hidden)\n        else:\n            self = cls(data, hidden)\n        return self\n\n    # def __getitem__(self, key):\n    #     return self.data[key]\n\n\nclass HiddenFields(analytic_for.Hidden):\n    \"\"\"\n    Augments normal hidden fields dicts with a convinience setitem\n    \"\"\"\n    pass\n\n\nclass _TorchMixin(object):\n    \"\"\"\n    Receptive field formulas for PyTorch primatives\n    \"\"\"\n\n    @staticmethod\n    def input(input_field=None, n=2):\n        \"\"\"\n        Basic input receptive field is just a single pixel.\n        \"\"\"\n        if input_field is not None:\n            raise ValueError('nothing can precede the input')\n        input_field = ReceptiveField.coerce({\n            # The input receptive field stride \/ scale factor is 1.\n            'stride': ensure_array_nd(1.0, n),\n            # The input receptive field shape is 1 pixel.\n            'shape': ensure_array_nd(1.0, n),\n            # Use the coordinate system where the top left corner is 0, 0 ( This is unlike [1], which uses 0.5)\n            'crop': ensure_array_nd(0.0, n),\n        })\n        return input_field\n\n    @staticmethod\n    def _kernelized(module, input_field=None, ndim=None):\n        \"\"\"\n        Receptive field formula for general sliding kernel based layers\n        This works for both convolutional and pooling layers.\n\n        Notes:\n            Baseline formulas are from [1]. Information about how to include\n            dilation (atrous) convolutions can be found in [2, 3].  Better info\n            seems to be available in [4].\n\n            * tensorflow has similar functionality\n            https:\/\/github.com\/tensorflow\/tensorflow\/blob\/master\/tensorflow\/contrib\/receptive_field\/python\/util\/receptive_field.py\n\n            * To preserve spatial extent, padding should equal `(k - 1) * d \/ 2`.\n\n        References:\n            [1] https:\/\/medium.com\/mlreview\/a-guide-to-receptive-field-arithmetic-for-convolutional-neural-networks-e0f514068807\n            [2] http:\/\/www.erogol.com\/dilated-convolution\/\n            [3] https:\/\/stackoverflow.com\/questions\/35582521\/how-to-calculate-receptive-field-shape\n            [4] https:\/\/arxiv.org\/pdf\/1603.07285.pdf\n\n        Example:\n            >>> module = nn.Conv2d(1, 1, kernel_size=5, stride=2, padding=2, dilation=3)\n            >>> field = ReceptiveFieldFor._kernelized(module)\n            >>> print(ub.repr2(field, nl=0, with_dtype=False))\n            {'crop': np.array([4., 4.]), 'shape': np.array([13., 13.]), 'stride': np.array([2., 2.])}\n\n            >>> module = nn.MaxPool2d(kernel_size=3, stride=2, padding=2, dilation=2)\n            >>> field = ReceptiveFieldFor._kernelized(module)\n            >>> print(ub.repr2(field, nl=0, with_dtype=False))\n            {'crop': np.array([0., 0.]), 'shape': np.array([5., 5.]), 'stride': np.array([2., 2.])}\n\n            >>> module = nn.MaxPool2d(kernel_size=3, stride=2, padding=2, dilation=1)\n            >>> field = ReceptiveFieldFor._kernelized(module)\n            >>> print(ub.repr2(field, nl=0, with_dtype=False))\n            {'crop': np.array([-1., -1.]), 'shape': np.array([3., 3.]), 'stride': np.array([2., 2.])}\n\n            >>> module = nn.AvgPool2d(kernel_size=3, stride=2, padding=2)\n            >>> field = ReceptiveFieldFor._kernelized(module)\n            >>> print(ub.repr2(field, nl=0, with_dtype=False))\n            {'crop': np.array([-1., -1.]), 'shape': np.array([3., 3.]), 'stride': np.array([2., 2.])}\n        \"\"\"\n        # impl = ReceptiveFieldFor.impl\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n\n        # Hack to get the number of space-time dimensions\n        if ndim is None:\n            try:\n                if module.__class__.__name__.endswith('1d'):\n                    ndim = 1\n                elif module.__class__.__name__.endswith('2d'):\n                    ndim = 2\n                elif module.__class__.__name__.endswith('3d'):\n                    ndim = 3\n            except AttributeError:\n                if module.__name__.endswith('1d'):\n                    ndim = 1\n                elif module.__name__.endswith('2d'):\n                    ndim = 2\n                elif module.__name__.endswith('3d'):\n                    ndim = 3\n        if ndim is None:\n            raise ValueError('Cannot infer ndim from {}'.format(module))\n\n        k = ensure_array_nd(module.kernel_size, ndim)\n        s = ensure_array_nd(module.stride, ndim)\n        p = ensure_array_nd(module.padding, ndim)\n        d = ensure_array_nd(getattr(module, 'dilation', 1), ndim)\n\n        # To calculate receptive feild we first need to find the SUPPORT of\n        # this layer. The support is the number\/extent of extra surrounding\n        # pixels adding this layer will take into account. Given this, we can\n        # compute the receptive feild wrt the original input by combining this\n        # information with the previous receptive feild.\n        #\n        # In the normal case (with no dilation, d=1) the support is (k - 1).\n        # This is because because the operation is able to see a window of shape\n        # k in the input, and produces a single output pixel (hence the k). The\n        # center input pixel corresponds with the output, so it does not expand\n        # the receptive feild (hence the -1), but all other input pixels do\n        # expand the field (thus the k-1).\n        #\n        # The stride of this layer will not affect the support.\n        #\n        # The dilation of the current layer DOES impact the support.\n        # This expands the effective kernel shape, but it does cause the data\n        # each operation sees to become more diffuse. However, even though what\n        # it sees in that extent is more diffuse, the RF is just a bound, so we\n        # can ignore the diffuseness effect and simply scale the input kernel\n        # shape by the dilation amount. Hense we get\n        support = (k - 1) * d\n\n        \"\"\"\n        Note the above is correct because:\n\n            import sympy as sym\n            k, d = sym.symbols('k, d')\n\n            # Compute the support from formula in 5.1 of [4]\n            # To understand the relationship tying the dilation rate d and the\n            # output shape o, it is useful to think of the impact of d on the\n            # effective kernel shape. A kernel of shape k dilated by a factor d\n            # has an effective shape.\n            effective_kernel_size = k + (k - 1) * (d - 1)\n            support_v1 = sym.expand(effective_kernel_size - 1)\n\n            # Compute support from our method\n            support_v2 = sym.expand((k - 1) * d)\n\n            # They are equivalent. QED\n            assert sym.Eq(support_v1, support_v2)\n        \"\"\"\n\n        # Compute how many pixels this layer takes off the side Note that an\n        # even shape kernel results in half pixel crops.  This is expected and\n        # correct. To use the crop in practice take the floor \/ ceil of the\n        # final result, but in this intermediate stage, subpixel crops are\n        # perfectly valid.\n        crop = ((support \/ 2.0) - p)\n\n        field = ReceptiveField.coerce({\n            # The new stride only depends on the layer stride and the previous\n            # stride.\n            'stride': input_field['stride'] * s,\n\n            # The stride of the current layer does not impact the receptive\n            # feild, however the stride of the previous layer does. This is\n            # because each pixel in the incoming layer really corresponds\n            # `input_field['stride']` pixels in the original input.\n            'shape':   input_field['shape'] + support * input_field['stride'],\n\n            # Padding does not influence the RF shape, but it does influence\n            # where the start pixel is (i.e. without the right amount of\n            # padding the the edge of the previous layer is cropped).\n            'crop': input_field['crop'] + crop * input_field['stride'],\n        })\n        return field\n\n    @staticmethod\n    def _unchanged(module, input_field=None):\n        \"\"\" Formula for layers that do not change the receptive field \"\"\"\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n        return input_field\n\n    @staticmethod\n    @compute_type(nn.Linear)\n    def linear(module, input_field=None):\n        # Linear layers (sort-of) dont change the RF\n        return ReceptiveFieldFor._unchanged(module, input_field)\n        # Perhaps we could do this if we knew the input shape\n        # raise NotImplementedError(\n        #     'Cannot compute receptive field shape on a Linear layer')\n\n    @staticmethod\n    def _kernelized_tranpose(module, input_field=None):\n        \"\"\"\n        Receptive field formula for pooling layers\n\n        Example:\n            >>> from netharn.analytic.receptive_field_for import *\n            >>> from netharn.analytic.output_shape_for import *\n            >>> module = nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, padding=2)\n            >>> ReceptiveFieldFor(module)()\n\n            >>> # This network should effectively invert itself\n            >>> module = nn.Sequential(ub.odict([\n            >>>     #('a', nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)),\n            >>>     ('c1', nn.Conv2d(1, 1, kernel_size=3, stride=2)),\n            >>>     ('c2', nn.Conv2d(1, 1, kernel_size=3, stride=2)),\n            >>>     ('c3', nn.Conv2d(1, 1, kernel_size=3, stride=2)),\n            >>>     ('c3T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2)),\n            >>>     ('c2T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2)),\n            >>>     ('c1T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2)),\n            >>> ]))\n            >>> print(ub.repr2(ReceptiveFieldFor(module)()))\n            >>> ReceptiveFieldFor(module)()\n            >>> OutputShapeFor(module)._check_consistency([1, 1, 32, 32])\n\n            >>> module = nn.Sequential(ub.odict([\n            >>>     #('a', nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)),\n            >>>     ('c1', nn.Conv2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>>     ('c2', nn.Conv2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>>     ('c3', nn.Conv2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>>     ('c3T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>>     ('c2T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>>     ('c1T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, dilation=2)),\n            >>> ]))\n            >>> print(ub.repr2(ReceptiveFieldFor(module)()))\n\n            >>> # This network is pathological\n            >>> module = nn.Sequential(ub.odict([\n            >>>     #('a', nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1)),\n            >>>     ('c1', nn.Conv2d(1, 1, kernel_size=3, stride=7, dilation=2)),\n            >>>     ('c2', nn.Conv2d(1, 1, kernel_size=5, stride=6, padding=1)),\n            >>>     ('c3', nn.Conv2d(1, 1, kernel_size=7, stride=5)),\n            >>>     ('c3T', nn.ConvTranspose2d(1, 1, kernel_size=7, stride=6)),\n            >>>     ('c2T', nn.ConvTranspose2d(1, 1, kernel_size=5, stride=7, padding=1)),\n            >>>     ('c1T', nn.ConvTranspose2d(1, 1, kernel_size=3, stride=8, dilation=2)),\n            >>> ]))\n            >>> print(ub.repr2(ReceptiveFieldFor(module)()))\n            >>> ReceptiveFieldFor(module)()\n            >>> OutputShapeFor(module)([1, 1, 900, 900])\n            >>> OutputShapeFor(module)([1, 1, 900, 900]).hidden\n            >>> OutputShapeFor(module)._check_consistency([1, 1, 900, 900])\n\n            >>> module = nn.Sequential(\n            >>>     nn.Conv2d(1, 1, kernel_size=3, stride=2),\n            >>>     nn.Conv2d(1, 1, kernel_size=3, stride=2),\n            >>>     nn.Conv2d(1, 1, kernel_size=3, stride=2),\n            >>>     nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2),\n            >>>     nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2),\n            >>>     nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2),\n            >>> )\n            >>> ReceptiveFieldFor(module)()\n\n            >>> module = nn.Conv2d(1, 1, kernel_size=3, stride=2, padding=1)\n            >>> ReceptiveFieldFor(module)()\n\n            >>> OutputShapeFor(nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, padding=0, output_padding=(1, 1)))._check_consistency([1, 1, 1, 1])\n\n            >>> # Figure 4.4\n            >>> OutputShapeFor(nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=2))([1, 1, 5, 5])\n            >>> OutputShapeFor(nn.ConvTranspose2d(1, 1, kernel_size=3, stride=1, padding=2))._check_consistency([1, 1, 5, 5])\n            >>> OutputShapeFor(nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=0))([1, 1, 7, 7])\n\n            >>> # Figure 4.5\n            >>> OutputShapeFor(nn.ConvTranspose2d(1, 1, kernel_size=3, stride=2, padding=0))._check_consistency([1, 1, 5, 5])\n            >>> OutputShapeFor(nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=0))([1, 1, 7, 7])\n\n            >>> ReceptiveFieldFor(module)()\n        \"\"\"\n        # impl = ReceptiveFieldFor.impl\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n\n        # Hack to get the number of space-time dimensions\n        ndim = None\n        try:\n            if module.__name__.endswith('1d'):\n                ndim = 1\n            elif module.__name__.endswith('2d'):\n                ndim = 2\n            elif module.__name__.endswith('3d'):\n                ndim = 3\n        except AttributeError:\n            pass\n\n        if ndim is None:\n            if hasattr(module, '_dim'):\n                ndim = module._dim\n\n        # A non-trivial transpose convolution should:\n        # * decrease the stride (because the stride is fractional)\n        # the padding has to be equal to the shape of the kernel minus one\n        \"\"\"\n        From [4]:\n\n        A convolution described by k, s and p has an associated transposed convolution described by:\n        * k' = k,\n        * s' = 1,\n        * p' = k - p - 1,\n        * i' = the shape of the stretched input obtained by adding s − 1 zeros\n            between each input unit,\n        * a = (i + 2p − k) % s, represents the number of zeros added to the\n         bottom and right edges of the input,\n\n         And has output shape:\n             o' = s(i' - 1) + a + k - 2p\n\n        For convT it is always the case that s'=1, howver, note that s' is not\n        what we use to compute the new stride of the output, because that is\n        actually a fractional stride.\n        \"\"\"\n\n        # Definitions:\n        # In the following comments we discuss 3 distinct layers\n        # (1) The original convolution (conv)\n        # (2) The transpose convolution that inverts the original (convT)\n        # (3) The regular convolution that is equivalent to the transpose\n        # convolution given a specially transformed input tensor (convE)\n\n        # The parameters of a convT are actually the parameters of conv, the\n        # convolution we are trying to \"undo\", but we will refer to them as\n        # parameters of convT (because they are that as well).\n        k_ = ensure_array_nd(module.kernel_size, ndim)\n        s_ = ensure_array_nd(module.stride, ndim)\n        p_ = ensure_array_nd(module.padding, ndim)\n        d_ = ensure_array_nd(getattr(module, 'dilation', 1), ndim)\n\n        # TODO: incorporate output padding and right-side padding \/ cropping\n        # Note: output padding does not impact the receptive field, however it\n        # does cause some \"right-side\" croping, which we are not computing here\n        # yet.\n\n        out_pad = ensure_array_nd(module.output_padding, ndim)  # NOQA\n        # if not np.all(out_pad == 0):\n        #     raise NotImplementedError('cannot handle nonzero output_padding yet')\n\n        # Howver, there is an equivalent way of forumulating a convT as convE:\n        # a regular conv applied on a specially padded input tensor.\n        # The parameters that define convE are:\n        k = k_\n        d = d_\n        s = 1  # stride is always 1 because of the special input transform\n        # p = k_ - p_ - 1  # NOTE: original formula likely assumed dilation=1\n        p = (k_ - 1) * d_ - p_\n\n        # In order for convE to be equivalent to convT, we need to apply convE\n        # to a specially transformed (padded) input tensor.\n        # The padding applied to the input tensor puts extra zeros between each\n        # row\/col. The number of extra zeros is the stride of the convT - 1.\n        # The left and right sides of the input tensor are also padded but that\n        # wont factor into the RF calculation.\n        extra_zeros = s_ - 1\n        # This means that the effective support added to the RF shape by convE\n        # will be less than it normally would because we don't count the extra\n        # zeros in our transformed input as real pixels.\n        effective_support = (k - 1 - extra_zeros) * d\n        # NOTE; if the stride is larger than the kernel, some output pixels\n        # will actually just be zeros and have no receptive feild.\n        effective_support = np.maximum(0, effective_support)\n\n        # This special input transform also has the effect of decreasing the RF\n        # stride.  Transpose conv are sometimes called fractional-stride\n        # convolutions This is because they have an effective stride of 1 \/ s_\n        effective_stride = 1 \/ s_\n\n        # We calculate the support of convE as if were applied to a normal\n        # input tensor in order to calculate how the start (top-left) pixel\n        # position is modified.\n        support = (k - 1) * d\n\n        # After transformation the effective stride of the input is\n        effective_input_stride = input_field['stride'] * effective_stride\n\n        # how many pixels does this layer crop off the sides of the input\n        crop = ((support \/ 2) - p)\n\n        # print('effective_support = {!r}'.format(effective_support))\n\n        field = ReceptiveField.coerce({\n            # The new stride only depends on the layer stride and the previous\n            # stride.\n            'stride': effective_input_stride * s,\n\n            # The stride of the current layer does not impact the receptive\n            # feild, however the stride of the previous layer does. This is\n            # because each pixel in the incoming layer really corresponds\n            # `input_field['stride']` pixels in the original input.\n            'shape':   input_field['shape'] + effective_support * input_field['stride'],\n\n            # Padding does not influence the RF shape, but it does influence\n            # where the start pixel is (i.e. without the right amount of\n            # padding the the edge of the previous layer is cropped).\n            'crop': input_field['crop'] + crop * effective_input_stride,\n        })\n\n        return field\n        # raise NotImplementedError('todo')\n\n    @compute_type(*CONV_TRANSPOSE_TYPES)\n    def convT(module, input_field=None):\n        return ReceptiveFieldFor._kernelized_tranpose(module, input_field)\n\n    @compute_type(nn.modules.conv.Conv1d, nn.modules.conv.Conv2d, nn.modules.conv.Conv3d)\n    def convnd(module, input_field=None):\n        return ReceptiveFieldFor._kernelized(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.modules.pooling._MaxPoolNd)\n    def maxpoolnd(module, input_field=None):\n        return ReceptiveFieldFor._kernelized(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.modules.pooling._AvgPoolNd)\n    def avepoolnd(module, input_field=None):\n        return ReceptiveFieldFor._kernelized(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.modules.pooling._AdaptiveMaxPoolNd, nn.modules.pooling._AdaptiveAvgPoolNd)\n    def adaptive_avepoolnd(module, input_field=None):\n        \"\"\"\n        it is not possible to analytically compute an adaptive receptive field.\n\n        References:\n            https:\/\/forums.fast.ai\/t\/ideas-behind-adaptive-max-pooling\/12634\/3\n            https:\/\/arxiv.org\/abs\/1406.4729\n        \"\"\"\n        raise Exception('not possible to compute adaptive RF without knowning the input_shape ahead of time')\n        # return ReceptiveFieldFor._kernelized(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.ReLU)\n    def relu(module, input_field=None):\n        return ReceptiveFieldFor._unchanged(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.ReLU6, nn.PReLU, nn.LeakyReLU, nn.ELU, nn.CELU, nn.SELU)\n    def _unchanged_activation(module, input_field=None):\n        return ReceptiveFieldFor._unchanged(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.functional.relu, nn.functional.relu6)\n    def _unchanged_activation_func(input_field=None):\n        # return ReceptiveFieldFor._unchanged(module, input_field)\n        return ReceptiveFieldFor._unchanged(None, input_field)\n\n    @staticmethod\n    @compute_type(nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d,\n                  nn.modules.normalization.GroupNorm,\n                  nn.modules.normalization.LocalResponseNorm,\n                  nn.modules.normalization.LayerNorm, nn.CrossMapLRN2d,\n                  nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d)\n    def normalization(module, input_field=None):\n        return ReceptiveFieldFor._unchanged(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.modules.dropout._DropoutNd)\n    def dropout(module, input_field=None):\n        return ReceptiveFieldFor._unchanged(module, input_field)\n\n    @staticmethod\n    @compute_type(nn.Sequential)\n    def sequential(module, input_field=None):\n        \"\"\"\n        Example:\n            >>> import netharn as nh\n            >>> self = nn.Sequential(\n            >>>     nn.Conv2d(2, 3, kernel_size=3),\n            >>>     nn.Conv2d(3, 5, kernel_size=3),\n            >>>     nn.Conv2d(5, 7, kernel_size=3),\n            >>> )\n            >>> rfield = nh.ReceptiveFieldFor(self)()\n            >>> print('rfield = {}'.format(ub.repr2(rfield, nl=1, with_dtype=False)))\n            rfield = {\n                'crop': np.array([3., 3.]),\n                'shape': np.array([7., 7.]),\n                'stride': np.array([1., 1.]),\n            }\n        \"\"\"\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n        rfield = input_field\n        hidden = HiddenFields()\n        iter_ = iter(module._modules.items())\n        for key, child in module._modules.items():\n            key, child = next(iter_)\n            if hasattr(child, 'receptive_field_for'):\n                rfield = hidden[key] = child.receptive_field_for(rfield)\n            else:\n                rfield = hidden[key] = ReceptiveFieldFor(child)(rfield)\n        rfield = ReceptiveField.coerce(rfield)\n        rfield.hidden = hidden\n        return rfield\n\n    @staticmethod\n    @compute_type(torch.nn.DataParallel)\n    def data_parallel(module, *args, **kw):\n        return ReceptiveFieldFor(module.module)(*args, **kw)\n\n\nclass _TorchvisionMixin(object):\n    \"\"\"\n    Compute receptive fields for components of torchvision models\n    \"\"\"\n\n    @staticmethod\n    @compute_type(torchvision.models.resnet.BasicBlock)\n    def resent_basic_block(module, input_field=None):\n        \"\"\"\n        Example:\n            >>> # xdoctest: +REQUIRES(--network)\n            >>> import torchvision  # NOQA\n            >>> module = torchvision.models.resnet18().layer1[0]\n            >>> field = ReceptiveFieldFor(module)()\n            >>> print(ub.repr2(field.hidden, nl=1, with_dtype=False))\n            {\n                'conv1': {'crop': np.array([0., 0.]), 'shape': np.array([3., 3.]), 'stride': np.array([1., 1.])},\n                'bn1': {'crop': np.array([0., 0.]), 'shape': np.array([3., 3.]), 'stride': np.array([1., 1.])},\n                'relu1': {'crop': np.array([0., 0.]), 'shape': np.array([3., 3.]), 'stride': np.array([1., 1.])},\n                'conv2': {'crop': np.array([0., 0.]), 'shape': np.array([5., 5.]), 'stride': np.array([1., 1.])},\n                'bn2': {'crop': np.array([0., 0.]), 'shape': np.array([5., 5.]), 'stride': np.array([1., 1.])},\n                'relu2': {'crop': np.array([0., 0.]), 'shape': np.array([5., 5.]), 'stride': np.array([1., 1.])},\n            }\n        \"\"\"\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n        hidden = HiddenFields()\n\n        rfield = input_field\n\n        rfield = hidden['conv1'] = ReceptiveFieldFor(module.conv1)(rfield)\n        rfield = hidden['bn1'] = ReceptiveFieldFor(module.bn1)(rfield)\n        rfield = hidden['relu1'] = ReceptiveFieldFor(module.relu)(rfield)\n\n        rfield = hidden['conv2'] = ReceptiveFieldFor(module.conv2)(rfield)\n        rfield = hidden['bn2'] = ReceptiveFieldFor(module.bn2)(rfield)\n        rfield = hidden['relu2'] = ReceptiveFieldFor(module.relu)(rfield)\n\n        if module.downsample is not None:\n            hidden['downsample'] = ReceptiveFieldFor(module.downsample)(input_field)\n\n        rfield = ReceptiveFieldFor(module.relu)(rfield)\n        rfield.hidden = hidden\n        return rfield\n\n    @staticmethod\n    @compute_type(torchvision.models.resnet.Bottleneck)\n    def resent_bottleneck(module, input_field=None):\n        \"\"\"\n        CommandLine:\n            xdoctest -m netharn.analytic.receptive_field_for _TorchvisionMixin.resent_bottleneck --network\n\n        Example:\n            >>> # xdoctest: +REQUIRES(--network)\n            >>> import torchvision  # NOQA\n            >>> module = torchvision.models.resnet50().layer1[0]\n            >>> field = ReceptiveFieldFor(module)()\n            >>> print(ub.repr2(field.hidden.shallow(1), nl=1, with_dtype=False))\n            {\n                'conv1': {'crop': ...([0., 0.]), 'shape': ...([1., 1.]), 'stride': ...([1., 1.])},\n                'bn1': {'crop': ...([0., 0.]), 'shape': ...([1., 1.]), 'stride': ...([1., 1.])},\n                'relu1': {'crop': ...([0., 0.]), 'shape': ...([1., 1.]), 'stride': ...([1., 1.])},\n                'conv2': {'crop': ...([0., 0.]), 'shape': ...([3., 3.]), 'stride': ...([1., 1.])},\n                'bn2': {'crop': ...([0., 0.]), 'shape': ...([3., 3.]), 'stride': ...([1., 1.])},\n                'relu2': {'crop': ...([0., 0.]), 'shape': ...([3., 3.]), 'stride': ...([1., 1.])},\n                'conv3': {'crop': ...([0., 0.]), 'shape': ...([3., 3.]), 'stride': ...([1., 1.])},\n                'bn3': {'crop': ...([0., 0.]), 'shape': ...([3., 3.]), 'stride': ...([1., 1.])},\n                'downsample': {'crop': ...([0., 0.]), 'shape': ...([1., 1.]), 'stride': ...([1., 1.])},\n            }\n        \"\"\"\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n        rfield = input_field\n        hidden = HiddenFields()\n\n        rfield = hidden['conv1'] = ReceptiveFieldFor(module.conv1)(rfield)\n        rfield = hidden['bn1'] = ReceptiveFieldFor(module.bn1)(rfield)\n        rfield = hidden['relu1'] = ReceptiveFieldFor(module.relu)(rfield)\n\n        rfield = hidden['conv2'] = ReceptiveFieldFor(module.conv2)(rfield)\n        rfield = hidden['bn2'] = ReceptiveFieldFor(module.bn2)(rfield)\n        rfield = hidden['relu2'] = ReceptiveFieldFor(module.relu)(rfield)\n\n        rfield = hidden['conv3'] = ReceptiveFieldFor(module.conv3)(rfield)\n        rfield = hidden['bn3'] = ReceptiveFieldFor(module.bn3)(rfield)\n\n        if module.downsample is not None:\n            hidden['downsample'] = ReceptiveFieldFor(module.downsample)(input_field)\n\n        rfield = ReceptiveFieldFor(module.relu)(rfield)\n        rfield.hidden = hidden\n        return rfield\n\n    @staticmethod\n    @compute_type(torchvision.models.resnet.ResNet)\n    def resnet_model(module, input_field=None, input_shape=None):\n        \"\"\"\n        CommandLine:\n            xdoctest -m netharn.analytic.receptive_field_for _TorchvisionMixin.resnet_model --network\n\n        Example:\n            >>> # DISABLE_DOCTEST\n            >>> # Note: newest torchvision breaks this\n            >>> # xdoctest: +REQUIRES(--network)\n            >>> from netharn.analytic.receptive_field_for import *\n            >>> module = torchvision.models.resnet50()\n            >>> input_shape = (1, 3, 224, 224)\n            >>> field = ReceptiveFieldFor(module)(input_shape=input_shape)\n            >>> print(ub.repr2(field.hidden.shallow(1), nl=1, with_dtype=False))\n            {\n                'conv1': {'crop': ...([0., 0.]), 'shape': ...([7., 7.]), 'stride': ...([2., 2.])},\n                'bn1': {'crop': ...([0., 0.]), 'shape': ...([7., 7.]), 'stride': ...([2., 2.])},\n                'relu1': {'crop': ...([0., 0.]), 'shape': ...([7., 7.]), 'stride': ...([2., 2.])},\n                'maxpool': {'crop': ...([0., 0.]), 'shape': ...([11., 11.]), 'stride': ...([4., 4.])},\n                'layer1': {'crop': ...([0., 0.]), 'shape': ...([35., 35.]), 'stride': ...([4., 4.])},\n                'layer2': {'crop': ...([0., 0.]), 'shape': ...([91., 91.]), 'stride': ...([8., 8.])},\n                'layer3': {'crop': ...([0., 0.]), 'shape': ...([267., 267.]), 'stride': ...([16., 16.])},\n                'layer4': {'crop': ...([0., 0.]), 'shape': ...([427., 427.]), 'stride': ...([32., 32.])},\n                'avgpool': {'crop': ...([96., 96.]), 'shape': ...([619., 619.]), 'stride': ...([32., 32.])},\n                'flatten': {'crop': ...([96., 96.]), 'shape': ...([811., 811.]), 'stride': ...([32., 32.])},\n                'fc': {'crop': ...([96., 96.]), 'shape': ...([811., 811.]), 'stride': ...([32., 32.])},\n            }\n\n        \"\"\"\n        if input_field is None:\n            input_field = ReceptiveFieldFor.input()\n        rfield = input_field\n        hidden = HiddenFields()\n        rfield = hidden['conv1'] = ReceptiveFieldFor(module.conv1)(rfield)\n        rfield = hidden['bn1'] = ReceptiveFieldFor(module.bn1)(rfield)\n        rfield = hidden['relu1'] = ReceptiveFieldFor(module.relu)(rfield)\n        rfield = hidden['maxpool'] = ReceptiveFieldFor(module.maxpool)(rfield)\n\n        rfield = hidden['layer1'] = ReceptiveFieldFor(module.layer1)(rfield)\n        rfield = hidden['layer2'] = ReceptiveFieldFor(module.layer2)(rfield)\n        rfield = hidden['layer3'] = ReceptiveFieldFor(module.layer3)(rfield)\n        rfield = hidden['layer4'] = ReceptiveFieldFor(module.layer4)(rfield)\n\n        rfield = hidden['avgpool'] = ReceptiveFieldFor(module.avgpool)(rfield)\n\n        if input_shape is None:\n            raise ValueError('input shape is required')\n\n        output_shape = OutputShapeFor(module)(input_shape)\n        avgpool_shape = output_shape.hidden.shallow(1)['layer4']\n        spatial_shape = np.array(avgpool_shape[2:])\n\n        # Keep everything the same except increase the RF shape\n        # based on how many output pixels there are.\n        rfield_flatten = ReceptiveField.coerce(dict(**rfield))\n        # not sure if this is 100% correct\n        rfield_flatten['shape'] = rfield['shape'] + (spatial_shape - 1) * rfield['stride']\n        rfield = hidden['flatten'] = rfield_flatten\n\n        # The reshape operation will blend the receptive fields of the inputs\n        # but it will depend on the output shape of the layer.\n        # rfield = (rfield[0], prod(rfield[1:]))\n\n        rfield = hidden['fc'] = ReceptiveFieldFor(module.fc)(rfield)\n        rfield.hidden = hidden\n        return rfield\n\n\nclass ReceptiveFieldFor(analytic_for.OutputFor, _TorchMixin, _TorchvisionMixin):\n    \"\"\"\n    Knows how to compute the receptive fields for many pytorch primatives and\n    some torchvision components.\n\n    References:\n        https:\/\/medium.com\/mlreview\/a-guide-to-receptive-field-arithmetic-for-convolutional-neural-networks-e0f514068807\n\n    Returns:\n        Tuple[object, Dict]:\n            fields: object: The hidden layer recepvive fields (can be complex due to nesting)\n            field: Dict: a dictionary containing receptive field information.\n\n    Notes:\n        A 1-D Pixel\n            +-----+\n            ^  ^  ^\n          left |  L right\n               |\n             center\n\n    Example:\n        >>> # Case where we have a registered func\n        >>> from netharn.analytic.receptive_field_for import *\n        >>> self = nn.Sequential(\n        >>>     nn.Conv2d(2, 3, kernel_size=3),\n        >>>     nn.Conv2d(3, 5, kernel_size=3),\n        >>> )\n        >>> rfield = ReceptiveFieldFor(self)()\n        >>> print('rfield.hidden = {}'.format(ub.repr2(rfield.hidden, nl=3, with_dtype=False)))\n        >>> print('rfield = {}'.format(ub.repr2(rfield, nl=1, with_dtype=False)))\n        rfield.hidden = {\n            '0': {\n                'crop': np.array([1., 1.]),\n                'shape': np.array([3., 3.]),\n                'stride': np.array([1., 1.]),\n            },\n            '1': {\n                'crop': np.array([2., 2.]),\n                'shape': np.array([5., 5.]),\n                'stride': np.array([1., 1.]),\n            },\n        }\n        rfield = {\n            'crop': np.array([2., 2.]),\n            'shape': np.array([5., 5.]),\n            'stride': np.array([1., 1.]),\n        }\n\n    Example:\n        >>> # Case where we haven't registered a func\n        >>> self = nn.Conv2d(2, 3, kernel_size=3)\n        >>> rfield = ReceptiveFieldFor(self)()\n        >>> print('rfield = {}'.format(ub.repr2(rfield, nl=1, with_dtype=False)))\n        rfield = {\n            'crop': np.array([1., 1.]),\n            'shape': np.array([3., 3.]),\n            'stride': np.array([1., 1.]),\n        }\n\n    Example:\n        >>> # xdoctest: +REQUIRES(--network)\n        >>> import torchvision  # NOQA\n        >>> module = torchvision.models.alexnet().features\n        >>> field = ReceptiveFieldFor(module)()\n        >>> print(ub.repr2(field, nl=1, with_dtype=False))\n        {\n            'crop': np.array([31., 31.]),\n            'shape': np.array([195., 195.]),\n            'stride': np.array([32., 32.]),\n        }\n    \"\"\"\n    # impl = math  # for hacking in sympy\n\n    def __init__(self, module):\n        self.module = module\n        self._func = getattr(module, 'receptive_field_for', None)\n        if self._func is None:\n            # Lookup rfield func if we can't find it\n            found = []\n            for type, _func in REGISTERED_TYPES:\n                try:\n                    if module is type or isinstance(module, type):\n                        found.append(_func)\n                except TypeError:\n                    pass\n            if len(found) == 1:\n                self._func = found[0]\n            elif len(found) == 0:\n                raise ReceptiveFieldTypeError('Unknown (rf) module type {}'.format(module))\n            else:\n                raise AssertionError('Ambiguous (rf) module {}. Found {}'.format(module, found))\n\n    def __call__(self, *args, **kwargs):\n        if isinstance(self.module, nn.Module):\n            # bound methods dont need module\n            is_bound  = hasattr(self._func, '__func__') and getattr(self._func, '__func__', None) is not None\n            is_bound |= hasattr(self._func, 'im_func') and getattr(self._func, 'im_func', None) is not None\n            if is_bound:\n                rfield = self._func(*args, **kwargs)\n            else:\n                # nn.Module with state\n                rfield = self._func(self.module, *args, **kwargs)\n        else:\n            # a simple pytorch func\n            rfield = self._func(*args, **kwargs)\n\n        rfield = ReceptiveField.coerce(rfield)\n        return rfield\n\n    # @staticmethod\n    # def view(arr, *args):\n    #     \"\"\"\n    #     Wraps view calls\n\n    #     Example:\n    #         >>> arr = (2, 32, 9, 9)\n    #         >>> result = OutputShapeFor.view(arr, -1)\n    #         >>> assert result == (5184,)\n    #     \"\"\"\n    #     from netharn import layers\n    #     reshape = layers.Reshape(*args)\n    #     return reshape.output_shape_for(arr)\n\n    # @staticmethod\n    def shape(arr):\n        \"\"\"\n        Wraps shape calls\n        \"\"\"\n        raise ReceptiveFieldTypeError('RF is currently unable to inspect output shape')\n\n    @staticmethod\n    def _elementwise(field1, field2):\n        # Combines two receptive fields in an elementwise fashion\n        field = ReceptiveField({\n            'shape': np.maximum(field1['shape'], field2['shape']),\n            'crop': np.maximum(field1['crop'], field2['crop']),\n            'stride': np.maximum(field1['stride'], field2['stride']),\n        })\n        return field\n\n    @staticmethod\n    def add(field1, field2):\n        return ReceptiveFieldFor._elementwise(field1, field2)\n\n    @staticmethod\n    def mul(field1, field2):\n        return ReceptiveFieldFor._elementwise(field1, field2)\n\n    @staticmethod\n    def sub(field1, field2):\n        return ReceptiveFieldFor._elementwise(field1, field2)\n\n    @staticmethod\n    def div(field1, field2):\n        return ReceptiveFieldFor._elementwise(field1, field2)\n\n\ndef effective_receptive_feild(module, inputs, output_key=None, sigma=0,\n                              thresh=1.00, ignore_norms=True,\n                              ignore_extra=None):\n    \"\"\"\n    Empirically measures the effective receptive feild of a network\n\n    Method from [0], implementation loosely based on [1].\n\n    Args:\n        module (torch.nn.Module) : the network\n\n        inputs (torch.nn.Tensor) : the input to the network. Must share the\n            same device as `module`.\n\n        output_key (None | str | Callable): If the network outputs a non-tensor\n            then this should be a function that does postprocessing and returns\n            a relevant Tensor that can be used to compute gradients. If the\n            output is a dictionary then this can also be a string-based key\n            used to lookup the appropriate output.\n\n        sigma (float, default=0): smoothness factor (via gaussian blur)\n\n        thresh (float, default=1.00): only consider this fraction of the\n            data as meaningful (i.e. find the effective RF shape that explains\n            95% of the data). A threshold of 1.0 or greater does nothing.\n\n        ignore_norms (bool, default=True): if True ignores normalization layers\n            like batch and group norm which adds negligable, but non-zero\n            impact everywhere and causes the ERF shape estimation to be\n            dramatically greater than it should be (although the impact still\n            makes sense).\n\n        ignore_extra (List[type], optioanl): if specified, any layer that is a\n            subclass of one of these types is also ignored.\n\n    Returns:\n        dict: containing keys\n            'shape' containing the effective RF shape and\n            'impact' which contains the thresholded distribution\n\n    References:\n        [0] https:\/\/arxiv.org\/pdf\/1701.04128.pdf\n        [1] https:\/\/github.com\/rogertrullo\/Receptive-Field-in-Pytorch\/blob\/master\/compute_RF.py\n\n    Example:\n        >>> from netharn.analytic.receptive_field_for import *\n        >>> import torchvision  # NOQA\n        >>> module = nn.Sequential(*[nn.Conv2d(1, 1, 3) for i in range(10)])\n        >>> inputs = torch.rand(1, 1, 200, 200)\n        >>> emperical_field = effective_receptive_feild(module, inputs)\n        >>> theoretic_field = ReceptiveFieldFor(module)()\n        >>> # The emperical results should never be bigger than the theoretical\n        >>> assert np.all(emperical_field['shape'] <= theoretic_field['shape'])\n\n        >>> # xdoctest: +REQUIRES(--slow)\n        >>> module = torchvision.models.alexnet().features\n        >>> inputs = torch.rand(1, 3, 224, 224)\n        >>> emperical_field = effective_receptive_feild(module, inputs)\n        >>> theoretic_field = ReceptiveFieldFor(module)()\n        >>> # The emperical results should never be bigger than the theoretical\n        >>> assert np.all(emperical_field['shape'] <= theoretic_field['shape'])\n\n        >>> # xdoctest: +REQUIRES(--slow)\n        >>> import netharn as nh\n        >>> xpu = nh.XPU.coerce('auto')\n        >>> module = xpu.move(torchvision.models.vgg11_bn().features)\n        >>> inputs = xpu.move(torch.rand(1, 3, 224, 224))\n        >>> emperical_field = effective_receptive_feild(module, inputs)\n        >>> theoretic_field = ReceptiveFieldFor(module)()\n        >>> # The emperical results should never be bigger than the theoretical\n        >>> assert np.all(emperical_field['shape'] <= theoretic_field['shape'])\n\n        >>> # xdoctest: +REQUIRES(--show)\n        >>> import kwplot\n        >>> kwplot.autompl()\n        >>> kwplot.imshow(emperical_field['impact'], doclf=True)\n\n    Ignore:\n        >>> def forward(self, x):\n        >>>     # See note [TorchScript super()]\n        >>>     x = self.conv1(x)\n        >>>     x = self.bn1(x)\n        >>>     x = self.relu(x)\n        >>>     x = self.maxpool(x)\n        >>> #\n        >>>     x = self.layer1(x)\n        >>>     x = self.layer2(x)\n        >>>     x = self.layer3(x)\n        >>>     x = self.layer4(x)\n        >>> #\n        >>>     #x = self.avgpool(x)\n        >>>     #x = torch.flatten(x, 1)\n        >>>     #x = self.fc(x)\n        >>>     return x\n        >>> xpu = nh.XPU.coerce('auto')\n        >>> module1 = torchvision.models.resnet50()\n        >>> ub.inject_method(module1, forward)\n        >>> module1 = xpu.move(module1)\n        >>> module2 = torchvision.models.resnet50(pretrained=True)\n        >>> module2 = xpu.move(module2)\n        >>> ub.inject_method(module2, forward)\n        >>> import kwimage\n        >>> img = kwimage.grab_test_image(dsize=(224, 224))\n        >>> inputs = torch.from_numpy(img.transpose(2, 0, 1)[None, :] \/ 255.).float()\n        >>> inputs = xpu.move(inputs)\n        >>> #inputs = xpu.move(torch.rand(8, 3, 224, 224))\n        >>> ignore_norms = 1\n        >>> emperical_field1 = effective_receptive_feild(module1, inputs, ignore_norms=ignore_norms)\n        >>> emperical_field2 = effective_receptive_feild(module2, inputs, ignore_norms=ignore_norms)\n        >>> import kwplot\n        >>> kwplot.autompl()\n        >>> kwplot.imshow(inputs[0].data.cpu().numpy(), fnum=1, pnum=(1, 3, 1), title='input', doclf=1)\n        >>> kwplot.imshow(emperical_field1['impact'], fnum=1, pnum=(1, 3, 2), title='pretrained=False')\n        >>> kwplot.imshow(emperical_field2['impact'], doclf=0, fnum=1, pnum=(1, 3, 3), title='pretrained=True')\n    \"\"\"\n    import netharn as nh\n\n    # zero gradients\n    for p in module.parameters():\n        if p.grad is not None:\n            p.grad.detach_()\n            p.grad.zero_()\n\n    if inputs.grad is not None:\n        inputs.grad.detach_()\n        inputs.grad.zero_()\n\n    inputs.requires_grad = True\n    # if inputs.grad is not None:\n    #     raise ValueError('inputs alread has accumulated gradients')\n\n    # Completely ignore BatchNorm layers as they will give the entire input\n    # some negligable but non-zero effect on the receptive feild.\n    ignored = []\n    if ignore_norms:\n        ignored += [\n            nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d,\n            nn.modules.normalization.GroupNorm,\n            nn.modules.normalization.LocalResponseNorm,\n            nn.modules.normalization.LayerNorm, nn.CrossMapLRN2d,\n            nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d,\n            nh.layers.L2Norm,\n        ]\n    if ignore_extra:\n        ignored += ignore_extra\n    with nh.util.IgnoreLayerContext(module, tuple(ignored)):\n        outputs = module(inputs)\n\n    # Note: grab a single (likely FCN) output channel\n    if output_key is None:\n        output_y = outputs\n    elif callable(output_key):\n        output_y = output_key(outputs)\n    else:\n        output_y = outputs[output_key]\n    # elif isinstance(output_key, (six.string_types, int)):\n    # else:\n    #     raise TypeError('output_key={} is not understood'.format(output_key))\n\n    if not isinstance(output_y, torch.Tensor):\n        raise TypeError(\n            'The output is a {}, not a tensor. Please specify '\n            'output_key and ensure it returns a Tensor.'.format(type(outputs)))\n\n    # Note: this still does the right thing if there is no spatial component.\n    # because all outputs are center outputs.\n    center_dims = (np.array(output_y.shape[2:]) \/\/ 2).tolist()\n    center_slice = [slice(None), slice(None)] + center_dims\n\n    # We dont need to compute a loss because we can explicitly set gradients.\n    # Yay torch!\n    # Explicilty set ∂l\/∂y[:] = 0\n    # Explicilty set ∂l\/∂y[center] = 1\n    grad_loss_wrt_y = torch.zeros_like(output_y)\n    grad_loss_wrt_y[...] = 0\n    grad_loss_wrt_y[center_slice] = 1\n\n    # Backpropogate as if the grad of the loss wrt to y[center] was 1.\n    # Note: this can take a long time on the CPU (sometimes?)\n    output_y.backward(gradient=grad_loss_wrt_y)\n\n    # The input gradient is now a measure of how much it can impact the output.\n    impact = inputs.grad.abs()\n\n    # Average the impact over all batches and all channels\n    average_impact = impact.mean(dim=0).mean(dim=0)\n\n    if isinstance(average_impact, torch.Tensor):\n        average_impact = average_impact.data.cpu().numpy()\n\n    idx_nonzeros = np.where(average_impact != 0)\n    rf_bounds = [(0, 0) if len(idx) == 0 else (idx.min(), idx.max()) for idx in idx_nonzeros]\n    rf_shape = [(mx - mn + 1) for mn, mx in rf_bounds]\n    rf_slice = tuple([slice(mn, mx + 1) for mn, mx in rf_bounds])\n\n    # Crop out the average impact zone for visualization\n    # Normalize to have a maximum value of 1.0\n    rf_impact = average_impact[rf_slice]\n    rf_impact \/= rf_impact.max()\n\n    rf_impact = torch.FloatTensor(rf_impact)\n    if sigma > 0:\n        # Smooth things out\n        _blur = nh.layers.GaussianBlurNd(dim=1, num_features=1, sigma=sigma)\n        _blur.to(rf_impact.device)\n        rf_impact = _blur(rf_impact[None, None])[0, 0]\n\n    if thresh < 1:\n        density = rf_impact.contiguous().view(-1).cpu().numpy().copy()\n        density.sort()\n        density = density[::-1]\n        # Find the value threshold that explains thresh (e.g. 95%) of the data\n        idx = np.where(density.cumsum() > thresh * density.sum())[0]\n        lowval = float(density[idx[0]])\n\n        effective_impact = rf_impact * (rf_impact > lowval).float()\n        effective_idx_nonzeros = np.where(effective_impact != 0)\n        effective_rf_bounds = [(idx.min(), idx.max()) for idx in effective_idx_nonzeros]\n        effective_shape = [(mx - mn + 1) for mn, mx in effective_rf_bounds]\n    else:\n        effective_impact = rf_impact\n        effective_rf_bounds = rf_shape\n        effective_shape = rf_shape\n\n    emperical_field = {\n        'shape': effective_shape,\n        'impact': effective_impact,\n        'thresh': thresh,\n    }\n    return emperical_field\n\n\nif __name__ == '__main__':\n    \"\"\"\n    CommandLine:\n        xdoctest -m netharn.analytic.receptive_field_for all --network\n    \"\"\"\n    import xdoctest\n    xdoctest.doctest_module(__file__)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_28","text":"#!\/usr\/bin\/env python\n# CREATED:2014-01-18 14:09:05 by <NAME> <<EMAIL>>\n# unit tests for util routines\n\n# Disable cache\nimport os\n\ntry:\n    os.environ.pop(\"LIBROSA_CACHE_DIR\")\nexcept:\n    pass\n\nimport platform\nimport numpy as np\nimport scipy.sparse\nimport pytest\nimport warnings\nimport librosa\n\nfrom test_core import srand\n\nnp.set_printoptions(precision=3)\n\n\ndef test_example_audio_file():\n\n    assert os.path.exists(librosa.util.example_audio_file())\n\n\n@pytest.mark.parametrize(\"frame_length\", [4, 8])\n@pytest.mark.parametrize(\"hop_length\", [2, 4])\n@pytest.mark.parametrize(\"y\", [np.random.randn(32)])\n@pytest.mark.parametrize(\"axis\", [0, -1])\ndef test_frame1d(frame_length, hop_length, axis, y):\n\n    y_frame = librosa.util.frame(y, frame_length=frame_length, hop_length=hop_length, axis=axis)\n\n    if axis == -1:\n        y_frame = y_frame.T\n\n    for i in range(y_frame.shape[0]):\n        assert np.allclose(y_frame[i], y[i * hop_length : (i * hop_length + frame_length)])\n\n\n@pytest.mark.parametrize(\"frame_length\", [4, 8])\n@pytest.mark.parametrize(\"hop_length\", [2, 4])\n@pytest.mark.parametrize(\n    \"y, axis\", [(np.asfortranarray(np.random.randn(16, 32)), -1), (np.ascontiguousarray(np.random.randn(16, 32)), 0)]\n)\ndef test_frame2d(frame_length, hop_length, axis, y):\n\n    y_frame = librosa.util.frame(y, frame_length=frame_length, hop_length=hop_length, axis=axis)\n\n    if axis == -1:\n        y_frame = y_frame.T\n        y = y.T\n\n    for i in range(y_frame.shape[0]):\n        assert np.allclose(y_frame[i], y[i * hop_length : (i * hop_length + frame_length)])\n\n\ndef test_frame_0stride():\n    x = np.arange(10)\n    xpad = x[np.newaxis]\n\n    xpad2 = np.atleast_2d(x)\n\n    xf = librosa.util.frame(x, 3, 1)\n    xfpad = librosa.util.frame(xpad, 3, 1)\n    xfpad2 = librosa.util.frame(xpad2, 3, 1)\n\n    assert np.allclose(xf, xfpad)\n    assert np.allclose(xf, xfpad2)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_frame_badtype():\n    librosa.util.frame([1, 2, 3, 4], frame_length=2, hop_length=1)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"axis\", [0, -1])\n@pytest.mark.parametrize(\"x\", [np.arange(16)])\ndef test_frame_too_short(x, axis):\n    librosa.util.frame(x, frame_length=17, hop_length=1, axis=axis)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_frame_bad_hop():\n    librosa.util.frame(np.arange(16), frame_length=4, hop_length=0)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"axis\", [1, 2])\ndef test_frame_bad_axis(axis):\n    librosa.util.frame(np.zeros((3, 3, 3)), frame_length=2, hop_length=1, axis=axis)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"x, axis\", [(np.zeros((4, 4), order=\"C\"), -1), (np.zeros((4, 4), order=\"F\"), 0)])\ndef test_frame_bad_contiguity(x, axis):\n    librosa.util.frame(x, frame_length=2, hop_length=1, axis=axis)\n\n\n@pytest.mark.parametrize(\"y\", [np.ones((16,)), np.ones((16, 16))])\n@pytest.mark.parametrize(\"m\", [0, 10])\n@pytest.mark.parametrize(\"axis\", [0, -1])\n@pytest.mark.parametrize(\"mode\", [\"constant\", \"edge\", \"reflect\"])\ndef test_pad_center(y, m, axis, mode):\n\n    n = m + y.shape[axis]\n    y_out = librosa.util.pad_center(y, n, axis=axis, mode=mode)\n\n    n_len = y.shape[axis]\n    n_pad = int((n - n_len) \/ 2)\n\n    eq_slice = [slice(None)] * y.ndim\n    eq_slice[axis] = slice(n_pad, n_pad + n_len)\n\n    assert np.allclose(y, y_out[tuple(eq_slice)])\n\n\n@pytest.mark.parametrize(\"y\", [np.ones((16,)), np.ones((16, 16))])\n@pytest.mark.parametrize(\"n\", [0, 10])\n@pytest.mark.parametrize(\"axis\", [0, -1])\n@pytest.mark.parametrize(\"mode\", [\"constant\", \"edge\", \"reflect\"])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_pad_center_fail(y, n, axis, mode):\n    librosa.util.pad_center(y, n, axis=axis, mode=mode)\n\n\n@pytest.mark.parametrize(\"y\", [np.ones((16,)), np.ones((16, 16))])\n@pytest.mark.parametrize(\"m\", [-5, 0, 5])\n@pytest.mark.parametrize(\"axis\", [0, -1])\ndef test_fix_length(y, m, axis):\n    n = m + y.shape[axis]\n\n    y_out = librosa.util.fix_length(y, n, axis=axis)\n\n    eq_slice = [slice(None)] * y.ndim\n    eq_slice[axis] = slice(y.shape[axis])\n\n    if n > y.shape[axis]:\n        assert np.allclose(y, y_out[tuple(eq_slice)])\n    else:\n        assert np.allclose(y[tuple(eq_slice)], y)\n\n\n@pytest.mark.parametrize(\"frames\", [np.arange(20, 100, step=15)])\n@pytest.mark.parametrize(\"x_min\", [0, 20])\n@pytest.mark.parametrize(\"x_max\", [20, 70, 120])\n@pytest.mark.parametrize(\"pad\", [False, True])\ndef test_fix_frames(frames, x_min, x_max, pad):\n\n    f_fix = librosa.util.fix_frames(frames, x_min=x_min, x_max=x_max, pad=pad)\n\n    if x_min is not None:\n        if pad:\n            assert f_fix[0] == x_min\n        assert np.all(f_fix >= x_min)\n\n    if x_max is not None:\n        if pad:\n            assert f_fix[-1] == x_max\n        assert np.all(f_fix <= x_max)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"frames\", [np.arange(-20, 100)])\n@pytest.mark.parametrize(\"x_min\", [None, 0, 20])\n@pytest.mark.parametrize(\"x_max\", [None, 0, 20])\n@pytest.mark.parametrize(\"pad\", [False, True])\ndef test_fix_frames_fail_negative(frames, x_min, x_max, pad):\n    librosa.util.fix_frames(frames, x_min, x_max, pad)\n\n\n@pytest.mark.parametrize(\"norm\", [np.inf, -np.inf, 0, 0.5, 1.0, 2.0, None])\n@pytest.mark.parametrize(\"ndims,axis\", [(1, 0), (1, -1), (2, 0), (2, 1), (2, -1), (3, 0), (3, 1), (3, 2), (3, -1)])\ndef test_normalize(ndims, norm, axis):\n    srand()\n    X = np.random.randn(*([4] * ndims))\n    X_norm = librosa.util.normalize(X, norm=norm, axis=axis)\n\n    # Shape and dtype checks\n    assert X_norm.dtype == X.dtype\n    assert X_norm.shape == X.shape\n\n    if norm is None:\n        assert np.allclose(X, X_norm)\n        return\n\n    X_norm = np.abs(X_norm)\n\n    if norm == np.inf:\n        values = np.max(X_norm, axis=axis)\n    elif norm == -np.inf:\n        values = np.min(X_norm, axis=axis)\n    elif norm == 0:\n        # XXX: normalization here isn't quite right\n        values = np.ones(1)\n\n    else:\n        values = np.sum(X_norm ** norm, axis=axis) ** (1.0 \/ norm)\n\n    assert np.allclose(values, np.ones_like(values))\n\n\n@pytest.mark.parametrize(\"norm\", [\"inf\", -0.5, -2])\n@pytest.mark.parametrize(\"X\", [np.ones((3, 3))])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_normalize_badnorm(X, norm):\n    librosa.util.normalize(X, norm=norm)\n\n\n@pytest.mark.parametrize(\"badval\", [np.nan, np.inf, -np.inf])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_normalize_bad_input(badval):\n    X = np.ones((3, 3))\n    X[0] = badval\n    librosa.util.normalize(X, norm=np.inf, axis=0)\n\n\n@pytest.mark.parametrize(\"fill\", [7, \"foo\"])\n@pytest.mark.parametrize(\"X\", [np.ones((2, 2))])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_normalize_badfill(X, fill):\n    librosa.util.normalize(X, fill=fill)\n\n\n@pytest.mark.parametrize(\"x\", [np.asarray([[0, 1, 2, 3]])])\n@pytest.mark.parametrize(\n    \"threshold, result\",\n    [(None, [[0, 1, 1, 1]]), (1, [[0, 1, 1, 1]]), (2, [[0, 1, 1, 1]]), (3, [[0, 1, 2, 1]]), (4, [[0, 1, 2, 3]])],\n)\ndef test_normalize_threshold(x, threshold, result):\n    assert np.allclose(librosa.util.normalize(x, threshold=threshold), result)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"x\", [np.asarray([[0, 1, 2, 3]])])\n@pytest.mark.parametrize(\"threshold\", [0, -1])\ndef test_normalize_threshold_fail(x, threshold):\n    librosa.util.normalize(x, threshold=threshold)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_normalize_fill_l0():\n    X = np.ones((2, 2))\n    librosa.util.normalize(X, fill=True, norm=0)\n\n\n@pytest.mark.parametrize(\"norm\", [1, 2, np.inf])\n@pytest.mark.parametrize(\"X\", [np.zeros((3, 3))])\ndef test_normalize_fill_allaxes(X, norm):\n    Xn = librosa.util.normalize(X, fill=True, axis=None, norm=norm)\n    if norm is np.inf:\n        assert np.allclose(Xn, 1)\n    else:\n        assert np.allclose(np.sum(Xn ** norm) ** (1.0 \/ norm), 1)\n\n\n@pytest.mark.parametrize(\"norm\", [1, 2, np.inf])\n@pytest.mark.parametrize(\"X\", [np.zeros((3, 3))])\ndef test_normalize_nofill(X, norm):\n    Xn = librosa.util.normalize(X, fill=False, norm=norm)\n    assert np.allclose(Xn, 0)\n\n\n@pytest.mark.parametrize(\"X\", [np.asarray([[0.0, 1], [0, 1]])])\n@pytest.mark.parametrize(\"norm,value\", [(1, 0.5), (2, np.sqrt(2) \/ 2), (np.inf, 1)])\n@pytest.mark.parametrize(\"threshold\", [0.5, 2])\ndef test_normalize_fill(X, threshold, norm, value):\n    Xn = librosa.util.normalize(X, fill=True, norm=norm, threshold=threshold)\n    assert np.allclose(Xn, value)\n\n\n@pytest.mark.parametrize(\"ndim\", [1, 3])\n@pytest.mark.parametrize(\"axis\", [0, 1, -1])\n@pytest.mark.parametrize(\"index\", [False, True])\n@pytest.mark.parametrize(\"value\", [None, np.min, np.mean, np.max])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_axis_sort_badndim(ndim, axis, index, value):\n    data = np.zeros([2] * ndim)\n    librosa.util.axis_sort(data, axis=axis, index=index, value=value)\n\n\n@pytest.mark.parametrize(\"ndim\", [2])\n@pytest.mark.parametrize(\"axis\", [0, 1, -1])\n@pytest.mark.parametrize(\"index\", [False, True])\n@pytest.mark.parametrize(\"value\", [None, np.min, np.mean, np.max])\ndef test_axis_sort(ndim, axis, index, value):\n    srand()\n    data = np.random.randn(*([10] * ndim))\n    if index:\n        Xsorted, idx = librosa.util.axis_sort(data, axis=axis, index=index, value=value)\n\n        cmp_slice = [slice(None)] * ndim\n        cmp_slice[axis] = idx\n\n        assert np.allclose(data[tuple(cmp_slice)], Xsorted)\n\n    else:\n        Xsorted = librosa.util.axis_sort(data, axis=axis, index=index, value=value)\n\n    compare_axis = np.mod(1 - axis, 2)\n\n    if value is None:\n        value = np.argmax\n\n    sort_values = value(Xsorted, axis=compare_axis)\n\n    assert np.allclose(sort_values, np.sort(sort_values))\n\n\n@pytest.mark.parametrize(\n    \"int_from, int_to\",\n    [\n        (np.asarray([[0, 2], [0, 4], [3, 6]]), np.empty((0, 2), dtype=int)),\n        (np.empty((0, 2), dtype=int), np.asarray([[0, 2], [0, 4], [3, 6]])),\n    ],\n)\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_match_intervals_empty(int_from, int_to):\n    librosa.util.match_intervals(int_from, int_to)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_match_intervals_strict_fail():\n    int_from = np.asarray([[0, 3], [2, 4], [5, 7]])\n    int_to = np.asarray([[0, 2], [0, 4]])\n    librosa.util.match_intervals(int_from, int_to, strict=True)\n\n\n@pytest.mark.parametrize(\"int_from\", [np.asarray([[0, 3], [2, 4], [5, 7]])])\n@pytest.mark.parametrize(\"int_to\", [np.asarray([[0, 2], [0, 4], [3, 6]])])\n@pytest.mark.parametrize(\"matches\", [np.asarray([1, 1, 2])])\ndef test_match_intervals_strict(int_from, int_to, matches):\n\n    test_matches = librosa.util.match_intervals(int_from, int_to, strict=True)\n    assert np.array_equal(matches, test_matches)\n\n\n@pytest.mark.parametrize(\"int_from\", [np.asarray([[0, 3], [2, 4], [5, 7]])])\n@pytest.mark.parametrize(\n    \"int_to,matches\",\n    [\n        (np.asarray([[0, 2], [0, 4], [3, 6]]), np.asarray([1, 1, 2])),\n        (np.asarray([[0, 2], [0, 4]]), np.asarray([1, 1, 1])),\n    ],\n)\ndef test_match_intervals_nonstrict(int_from, int_to, matches):\n    test_matches = librosa.util.match_intervals(int_from, int_to, strict=False)\n    assert np.array_equal(matches, test_matches)\n\n\n@pytest.mark.parametrize(\"n\", [1, 5, 20, 100])\n@pytest.mark.parametrize(\"m\", [1, 5, 20, 100])\ndef test_match_events(n, m):\n\n    srand()\n    ev1 = np.abs(np.random.randn(n))\n    ev2 = np.abs(np.random.randn(m))\n\n    match = librosa.util.match_events(ev1, ev2)\n\n    for i in range(len(match)):\n        values = np.asarray([np.abs(ev1[i] - e2) for e2 in ev2])\n        assert not np.any(values < values[match[i]])\n\n\n@pytest.mark.parametrize(\"ev1,ev2\", [(np.array([]), np.arange(5)), (np.arange(5), np.array([]))])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_match_events_failempty(ev1, ev2):\n    librosa.util.match_events(ev1, ev2)\n\n\n@pytest.mark.parametrize(\"events_from\", [np.asarray([5, 15, 25])])\n@pytest.mark.parametrize(\"events_to\", [np.asarray([0, 10, 20, 30])])\n@pytest.mark.parametrize(\"left,right,target\", [(False, True, [10, 20, 30]), (True, False, [0, 10, 20])])\ndef test_match_events_onesided(events_from, events_to, left, right, target):\n\n    events_from = np.asarray(events_from)\n    events_to = np.asarray(events_to)\n    match = librosa.util.match_events(events_from, events_to, left=left, right=right)\n\n    assert np.allclose(target, events_to[match])\n\n\ndef test_match_events_twosided():\n    events_from = np.asarray([5, 15, 25])\n    events_to = np.asarray([5, 15, 25, 30])\n    match = librosa.util.match_events(events_from, events_to, left=False, right=False)\n    assert np.allclose(match, [0, 1, 2])\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\n    \"events_from,events_to,left,right\",\n    [\n        ([40, 15, 25], [0, 10, 20, 30], False, True),  # right-sided fail\n        ([-1, 15, 25], [0, 10, 20, 30], True, False),  # left-sided fail\n        ([-1, 15, 25], [0, 10, 20, 30], False, False),  # two-sided fail\n    ],\n)\ndef test_match_events_onesided_fail(events_from, events_to, left, right):\n    events_from = np.asarray(events_from)\n    events_to = np.asarray(events_to)\n    librosa.util.match_events(events_from, events_to, left=left, right=right)\n\n\n@pytest.mark.parametrize(\"ndim, axis\", [(n, m) for n in range(1, 5) for m in range(n)])\ndef test_localmax(ndim, axis):\n\n    srand()\n\n    data = np.random.randn(*([7] * ndim))\n    lm = librosa.util.localmax(data, axis=axis)\n\n    for hits in np.argwhere(lm):\n        for offset in [-1, 1]:\n            compare_idx = hits.copy()\n            compare_idx[axis] += offset\n\n            if compare_idx[axis] < 0:\n                continue\n\n            if compare_idx[axis] >= data.shape[axis]:\n                continue\n\n            if offset < 0:\n                assert data[tuple(hits)] > data[tuple(compare_idx)]\n            else:\n                assert data[tuple(hits)] >= data[tuple(compare_idx)]\n\n\n@pytest.mark.parametrize(\"x\", [np.random.randn(_) ** 2 for _ in [1, 5, 10, 100]])\n@pytest.mark.parametrize(\"pre_max\", [0, 1, 10])\n@pytest.mark.parametrize(\"post_max\", [1, 10])\n@pytest.mark.parametrize(\"pre_avg\", [0, 1, 10])\n@pytest.mark.parametrize(\"post_avg\", [1, 10])\n@pytest.mark.parametrize(\"wait\", [0, 1, 10])\n@pytest.mark.parametrize(\"delta\", [0.05, 100.0])\ndef test_peak_pick(x, pre_max, post_max, pre_avg, post_avg, delta, wait):\n    peaks = librosa.util.peak_pick(x, pre_max, post_max, pre_avg, post_avg, delta, wait)\n\n    for i in peaks:\n        # Test 1: is it a peak in this window?\n        s = i - pre_max\n        if s < 0:\n            s = 0\n        t = i + post_max\n\n        diff = x[i] - np.max(x[s:t])\n        assert diff > 0 or np.isclose(diff, 0, rtol=1e-3, atol=1e-4)\n\n        # Test 2: is it a big enough peak to count?\n        s = i - pre_avg\n        if s < 0:\n            s = 0\n        t = i + post_avg\n\n        diff = x[i] - (delta + np.mean(x[s:t]))\n        assert diff > 0 or np.isclose(diff, 0, rtol=1e-3, atol=1e-4)\n\n    # Test 3: peak separation\n    assert not np.any(np.diff(peaks) <= wait)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"x\", [np.random.randn(_) ** 2 for _ in [1, 5, 10, 100]])\n@pytest.mark.parametrize(\n    \"pre_max,post_max,pre_avg,post_avg,delta,wait\",\n    [\n        (-1, 1, 1, 1, 0.05, 1),  # negative pre-max\n        (1, -1, 1, 1, 0.05, 1),  # negative post-max\n        (1, 0, 1, 1, 0.05, 1),  # 0 post-max\n        (1, 1, -1, 1, 0.05, 1),  # negative pre-avg\n        (1, 1, 1, -1, 0.05, 1),  # negative post-avg\n        (1, 1, 1, 0, 0.05, 1),  # zero post-avg\n        (1, 1, 1, 1, -0.05, 1),  # negative delta\n        (1, 1, 1, 1, 0.05, -1),  # negative wait\n    ],\n)\ndef test_peak_pick_fail(x, pre_max, post_max, pre_avg, post_avg, delta, wait):\n    librosa.util.peak_pick(x, pre_max, post_max, pre_avg, post_avg, delta, wait)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_peak_pick_shape_fail():\n    # Can't pick peaks on 2d inputs\n    librosa.util.peak_pick(np.eye(2), 1, 1, 1, 1, 0.5, 1)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"ndim\", [3, 4])\ndef test_sparsify_rows_ndimfail(ndim):\n    X = np.zeros([2] * ndim)\n    librosa.util.sparsify_rows(X)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"quantile\", [1.0, -1, 2.0])\n@pytest.mark.parametrize(\"X\", [np.ones((3, 3))])\ndef test_sparsify_rows_badquantile(X, quantile):\n    librosa.util.sparsify_rows(X, quantile=quantile)\n\n\n@pytest.mark.parametrize(\"ndim\", [1, 2])\n@pytest.mark.parametrize(\"d\", [1, 5, 10, 100])\n@pytest.mark.parametrize(\"q\", [0.0, 0.01, 0.25, 0.5, 0.99])\ndef test_sparsify_rows(ndim, d, q):\n    srand()\n\n    X = np.random.randn(*([d] * ndim)) ** 4\n\n    X = np.asarray(X)\n\n    xs = librosa.util.sparsify_rows(X, quantile=q)\n\n    if ndim == 1:\n        X = X.reshape((1, -1))\n\n    assert np.allclose(xs.shape, X.shape)\n\n    # And make sure that xs matches X on nonzeros\n    xsd = np.asarray(xs.todense())\n\n    for i in range(xs.shape[0]):\n        assert np.allclose(xsd[i, xs[i].indices], X[i, xs[i].indices])\n\n    # Compute row-wise magnitude marginals\n    v_in = np.sum(np.abs(X), axis=-1)\n    v_out = np.sum(np.abs(xsd), axis=-1)\n\n    # Ensure that v_out retains 1-q fraction of v_in\n    assert np.all(v_out >= (1.0 - q) * v_in)\n\n\n@pytest.mark.parametrize(\n    \"searchdir\", [os.path.join(os.path.curdir, \"tests\"), os.path.join(os.path.curdir, \"tests\", \"data\")]\n)\n@pytest.mark.parametrize(\"ext\", [None, \"wav\", \"WAV\", [\"wav\"], [\"WAV\"]])\n@pytest.mark.parametrize(\"recurse\", [True])\n@pytest.mark.parametrize(\"case_sensitive\", list({False} | {platform.system() != \"Windows\"}))\n@pytest.mark.parametrize(\"limit\", [None, 1, 2])\n@pytest.mark.parametrize(\"offset\", [0, 1, -1])\n@pytest.mark.parametrize(\n    \"output\",\n    [\n        [\n            os.path.join(os.path.abspath(os.path.curdir), \"tests\", \"data\", s)\n            for s in [\"test1_22050.mp3\", \"test1_22050.wav\", \"test1_44100.wav\", \"test2_8000.wav\"]\n        ]\n    ],\n)\ndef test_find_files(searchdir, ext, recurse, case_sensitive, limit, offset, output):\n    files = librosa.util.find_files(\n        searchdir, ext=ext, recurse=recurse, case_sensitive=case_sensitive, limit=limit, offset=offset\n    )\n\n    targets = output\n    if ext is not None:\n        # If we're only seeking wavs, bump off the mp3 file\n        targets = targets[1:]\n\n    s1 = slice(offset, None)\n    s2 = slice(limit)\n\n    if case_sensitive and ext not in (None, \"wav\", [\"wav\"]):\n        assert len(files) == 0\n    else:\n        assert set(files) == set(targets[s1][s2])\n\n\ndef test_find_files_nonrecurse():\n    files = librosa.util.find_files(os.path.join(os.path.curdir, \"tests\"), recurse=False)\n    assert len(files) == 0\n\n\n# fail if ext is not none, we're case-sensitive, and looking for WAV\n@pytest.mark.parametrize(\"ext\", [\"WAV\", [\"WAV\"]])\ndef test_find_files_case_sensitive(ext):\n    files = librosa.util.find_files(os.path.join(os.path.curdir, \"tests\"), ext=ext, case_sensitive=True)\n    # On windows, this test won't work\n    if platform.system() != \"Windows\":\n        assert len(files) == 0\n\n\n@pytest.mark.parametrize(\"x_in\", np.linspace(-2, 2, num=6))\n@pytest.mark.parametrize(\"cast\", [None, np.floor, np.ceil])\ndef test_valid_int(x_in, cast):\n\n    z = librosa.util.valid_int(x_in, cast)\n\n    assert isinstance(z, int)\n    if cast is None:\n        assert z == int(np.floor(x_in))\n    else:\n        assert z == int(cast(x_in))\n\n\n@pytest.mark.parametrize(\"x\", np.linspace(-2, 2, num=3))\n@pytest.mark.parametrize(\"cast\", [7])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_valid_int_fail(x, cast):\n    # Test with a non-callable cast operator\n    librosa.util.valid_int(x, cast)\n\n\n@pytest.mark.parametrize(\n    \"ivals\", [np.asarray([[0, 1], [1, 2]]), np.asarray([[0, 0], [1, 1]]), np.asarray([[0, 2], [1, 2]])]\n)\ndef test_valid_intervals(ivals):\n    librosa.util.valid_intervals(ivals)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\n    \"ivals\", [np.asarray([]), np.arange(2), np.ones((2, 2, 2)), np.ones((2, 3))]  # ndim=0  # ndim=1  # ndim=3\n)  # ndim=2, shape[1] != 2\ndef test_valid_intervals_badshape(ivals):\n    #   fail if ndim != 2 or shape[1] != 2\n    librosa.util.valid_intervals(ivals)\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\n@pytest.mark.parametrize(\"intval\", [np.asarray([[0, 1], [2, 1]])])\ndef test_valid_intervals_fail(intval):\n    # Test for issue #712: intervals must have non-negative duration\n    librosa.util.valid_intervals(intval)\n\n\ndef test_warning_deprecated():\n    @librosa.util.decorators.deprecated(\"old_version\", \"new_version\")\n    def __dummy():\n        return True\n\n    with warnings.catch_warnings(record=True) as out:\n        x = __dummy()\n\n        # Make sure we still get the right value\n        assert x is True\n\n        # And that the warning triggered\n        assert len(out) > 0\n\n        # And that the category is correct\n        assert out[0].category is DeprecationWarning\n\n        # And that it says the right thing (roughly)\n        assert \"deprecated\" in str(out[0].message).lower()\n\n\ndef test_warning_moved():\n    @librosa.util.decorators.moved(\"from\", \"old_version\", \"new_version\")\n    def __dummy():\n        return True\n\n    with warnings.catch_warnings(record=True) as out:\n        x = __dummy()\n\n        # Make sure we still get the right value\n        assert x is True\n\n        # And that the warning triggered\n        assert len(out) > 0\n\n        # And that the category is correct\n        assert out[0].category is DeprecationWarning\n\n        # And that it says the right thing (roughly)\n        assert \"moved\" in str(out[0].message).lower()\n\n\ndef test_warning_rename_kw_pass():\n\n    warnings.resetwarnings()\n    warnings.simplefilter(\"always\")\n\n    ov = librosa.util.Deprecated()\n    nv = 23\n\n    with warnings.catch_warnings(record=True) as out:\n        v = librosa.util.rename_kw(\"old\", ov, \"new\", nv, \"0\", \"1\")\n\n        assert v == nv\n\n        # Make sure no warning triggered\n        assert len(out) == 0\n\n\ndef test_warning_rename_kw_fail():\n\n    warnings.resetwarnings()\n    warnings.simplefilter(\"always\")\n\n    ov = 27\n    nv = 23\n\n    with warnings.catch_warnings(record=True) as out:\n        v = librosa.util.rename_kw(\"old\", ov, \"new\", nv, \"0\", \"1\")\n\n        assert v == ov\n\n        # Make sure the warning triggered\n        assert len(out) > 0\n\n        # And that the category is correct\n        assert out[0].category is DeprecationWarning\n\n        # And that it says the right thing (roughly)\n        assert \"renamed\" in str(out[0].message).lower()\n\n\n@pytest.mark.parametrize(\"idx\", [np.arange(10, 90, 10), np.arange(10, 90, 15)])\n@pytest.mark.parametrize(\"idx_min\", [None, 5, 15])\n@pytest.mark.parametrize(\"idx_max\", [None, 85, 100])\n@pytest.mark.parametrize(\"step\", [None, 2])\n@pytest.mark.parametrize(\"pad\", [False, True])\ndef test_index_to_slice(idx, idx_min, idx_max, step, pad):\n\n    slices = librosa.util.index_to_slice(idx, idx_min=idx_min, idx_max=idx_max, step=step, pad=pad)\n\n    if pad:\n        if idx_min is not None:\n            assert slices[0].start == idx_min\n            if idx.min() != idx_min:\n                slices = slices[1:]\n        if idx_max is not None:\n            assert slices[-1].stop == idx_max\n            if idx.max() != idx_max:\n                slices = slices[:-1]\n\n    if idx_min is not None:\n        idx = idx[idx >= idx_min]\n\n    if idx_max is not None:\n        idx = idx[idx <= idx_max]\n\n    idx = np.unique(idx)\n    assert len(slices) == len(idx) - 1\n\n    for sl, start, stop in zip(slices, idx, idx[1:]):\n        assert sl.start == start\n        assert sl.stop == stop\n        assert sl.step == step\n\n\n@pytest.mark.parametrize(\"aggregate\", [None, np.mean, np.sum])\n@pytest.mark.parametrize(\"ndim,axis\", [(1, 0), (1, -1), (2, 0), (2, 1), (2, -1), (3, 0), (3, 2), (3, -1)])\ndef test_sync(aggregate, ndim, axis):\n    data = np.ones([6] * ndim, dtype=np.float)\n\n    # Make some slices that don't fill the entire dimension\n    slices = [slice(1, 3), slice(3, 4)]\n    dsync = librosa.util.sync(data, slices, aggregate=aggregate, axis=axis)\n\n    # Check the axis shapes\n    assert dsync.shape[axis] == len(slices)\n\n    s_test = list(dsync.shape)\n    del s_test[axis]\n    s_orig = list(data.shape)\n    del s_orig[axis]\n    assert s_test == s_orig\n\n    # The first slice will sum to 2 and have mean 1\n    idx = [slice(None)] * ndim\n    idx[axis] = 0\n    if aggregate is np.sum:\n        assert np.allclose(dsync[idx], 2)\n    else:\n        assert np.allclose(dsync[idx], 1)\n\n    # The second slice will sum to 1 and have mean 1\n    idx[axis] = 1\n    assert np.allclose(dsync[idx], 1)\n\n\n@pytest.mark.parametrize(\"aggregate\", [np.mean, np.max])\ndef test_sync_slices(aggregate):\n    x = np.arange(8, dtype=float)\n    slices = [slice(0, 2), slice(2, 4), slice(4, 6), slice(6, 8)]\n    xsync = librosa.util.sync(x, slices, aggregate=aggregate)\n    if aggregate is np.mean:\n        assert np.allclose(xsync, [0.5, 2.5, 4.5, 6.5])\n    elif aggregate is np.max:\n        assert np.allclose(xsync, [1, 3, 5, 7])\n    else:\n        assert False\n\n\n@pytest.mark.parametrize(\"aggregate\", [np.mean, np.max])\n@pytest.mark.parametrize(\"atype\", [list, np.asarray])\ndef test_sync_frames(aggregate, atype):\n    x = np.arange(8, dtype=float)\n    frames = atype([0, 2, 4, 6, 8])\n    xsync = librosa.util.sync(x, frames, aggregate=aggregate)\n    if aggregate is np.mean:\n        assert np.allclose(xsync, [0.5, 2.5, 4.5, 6.5])\n    elif aggregate is np.max:\n        assert np.allclose(xsync, [1, 3, 5, 7])\n    else:\n        assert False\n\n\n@pytest.mark.parametrize(\"atype\", [list, np.asarray])\n@pytest.mark.parametrize(\"pad\", [False, True])\ndef test_sync_frames_pad(atype, pad):\n    x = np.arange(8, dtype=float)\n    frames = atype([2, 4, 6])\n    xsync = librosa.util.sync(x, frames, pad=pad)\n    if pad:\n        assert np.allclose(xsync, [0.5, 2.5, 4.5, 6.5])\n    else:\n        assert np.allclose(xsync, [2.5, 4.5])\n\n\n@pytest.mark.parametrize(\"data\", [np.mod(np.arange(135), 5)])\n@pytest.mark.parametrize(\"idx\", [[\"foo\", \"bar\"], [None], [slice(None), None]])\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_sync_fail(data, idx):\n    librosa.util.sync(data, idx)\n\n\n@pytest.mark.parametrize(\"power\", [1, 2, 50, 100, np.inf])\n@pytest.mark.parametrize(\"split_zeros\", [False, True])\ndef test_softmask(power, split_zeros):\n\n    srand()\n\n    X = np.abs(np.random.randn(10, 10))\n    X_ref = np.abs(np.random.randn(10, 10))\n\n    # Zero out some rows\n    X[3, :] = 0\n    X_ref[3, :] = 0\n\n    M = librosa.util.softmask(X, X_ref, power=power, split_zeros=split_zeros)\n\n    assert np.all(0 <= M) and np.all(M <= 1)\n\n    if split_zeros and np.isfinite(power):\n        assert np.allclose(M[3, :], 0.5)\n    else:\n        assert not np.any(M[3, :]), M[3]\n\n\ndef test_softmask_int():\n    X = 2 * np.ones((3, 3), dtype=np.int32)\n    X_ref = np.vander(np.arange(3))\n\n    M1 = librosa.util.softmask(X, X_ref, power=1)\n    M2 = librosa.util.softmask(X_ref, X, power=1)\n\n    assert np.allclose(M1 + M2, 1)\n\n\n@pytest.mark.parametrize(\n    \"x,x_ref,power,split_zeros\",\n    [\n        (-np.ones(3), np.ones(3), 1, False),\n        (np.ones(3), -np.ones(3), 1, False),\n        (np.ones(3), np.ones(4), 1, False),\n        (np.ones(3), np.ones(3), 0, False),\n        (np.ones(3), np.ones(3), -1, False),\n    ],\n)\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_softmask_fail(x, x_ref, power, split_zeros):\n    librosa.util.softmask(x, x_ref, power=power, split_zeros=split_zeros)\n\n\n@pytest.mark.parametrize(\n    \"x,value\",\n    [\n        (1, np.finfo(np.float32).tiny),\n        (np.ones(3, dtype=int), np.finfo(np.float32).tiny),\n        (np.ones(3, dtype=np.float32), np.finfo(np.float32).tiny),\n        (1.0, np.finfo(np.float64).tiny),\n        (np.ones(3, dtype=np.float64), np.finfo(np.float64).tiny),\n        (1j, np.finfo(np.complex128).tiny),\n        (np.ones(3, dtype=np.complex64), np.finfo(np.complex64).tiny),\n        (np.ones(3, dtype=np.complex128), np.finfo(np.complex128).tiny),\n    ],\n)\ndef test_tiny(x, value):\n    assert value == librosa.util.tiny(x)\n\n\ndef test_util_fill_off_diagonal_8_8():\n    # Case 1: Square matrix (N=M)\n    mut_x = np.ones((8, 8))\n    librosa.util.fill_off_diagonal(mut_x, 0.25)\n\n    gt_x = np.array(\n        [\n            [1, 1, 0, 0, 0, 0, 0, 0],\n            [1, 1, 1, 0, 0, 0, 0, 0],\n            [0, 1, 1, 1, 0, 0, 0, 0],\n            [0, 0, 1, 1, 1, 0, 0, 0],\n            [0, 0, 0, 1, 1, 1, 0, 0],\n            [0, 0, 0, 0, 1, 1, 1, 0],\n            [0, 0, 0, 0, 0, 1, 1, 1],\n            [0, 0, 0, 0, 0, 0, 1, 1],\n        ]\n    )\n\n    assert np.array_equal(mut_x, gt_x)\n    assert np.array_equal(mut_x, gt_x.T)\n\n\ndef test_util_fill_off_diagonal_8_12():\n    # Case 2a: N!=M\n    mut_x = np.ones((8, 12))\n    librosa.util.fill_off_diagonal(mut_x, 0.25)\n\n    gt_x = np.array(\n        [\n            [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],\n            [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],\n            [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],\n            [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],\n            [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0],\n            [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0],\n            [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],\n            [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],\n        ]\n    )\n\n    assert np.array_equal(mut_x, gt_x)\n\n    # Case 2b: (N!=M).T\n    mut_x = np.ones((8, 12)).T\n    librosa.util.fill_off_diagonal(mut_x, 0.25)\n\n    assert np.array_equal(mut_x, gt_x.T)\n\n\n@pytest.mark.parametrize(\"dtype_A\", [np.float32, np.float64])\n@pytest.mark.parametrize(\"dtype_B\", [np.float32, np.float64])\ndef test_nnls_vector(dtype_A, dtype_B):\n    srand()\n\n    # Make a random basis\n    A = np.random.randn(5, 7).astype(dtype_A)\n\n    # Make a random latent vector\n    x = np.random.randn(A.shape[1]) ** 2\n\n    B = A.dot(x).astype(dtype_B)\n\n    x_rec = librosa.util.nnls(A, B)\n\n    assert np.all(x_rec >= 0)\n    assert np.sqrt(np.mean((B - A.dot(x_rec)) ** 2)) <= 1e-6\n\n\n@pytest.mark.parametrize(\"dtype_A\", [np.float32, np.float64])\n@pytest.mark.parametrize(\"dtype_B\", [np.float32, np.float64])\n@pytest.mark.parametrize(\"x_size\", [3, 30])\ndef test_nnls_matrix(dtype_A, dtype_B, x_size):\n    srand()\n\n    # Make a random basis\n    A = np.random.randn(5, 7).astype(dtype_A)\n\n    # Make a random latent matrix\n    #   when x_size is 3, B is 7x3 (smaller than A)\n    x = np.random.randn(A.shape[1], x_size) ** 2\n\n    B = A.dot(x).astype(dtype_B)\n\n    x_rec = librosa.util.nnls(A, B)\n\n    assert np.all(x_rec >= 0)\n    assert np.sqrt(np.mean((B - A.dot(x_rec)) ** 2)) <= 1e-5\n\n\n@pytest.mark.parametrize(\"dtype_A\", [np.float32, np.float64])\n@pytest.mark.parametrize(\"dtype_B\", [np.float32, np.float64])\n@pytest.mark.parametrize(\"x_size\", [16, 64, 256])\ndef test_nnls_multiblock(dtype_A, dtype_B, x_size):\n    srand()\n\n    # Make a random basis\n    A = np.random.randn(7, 1025).astype(dtype_A)\n\n    # Make a random latent matrix\n    #   when x_size is 3, B is 7x3 (smaller than A)\n    x = np.random.randn(A.shape[1], x_size) ** 2\n\n    B = A.dot(x).astype(dtype_B)\n\n    x_rec = librosa.util.nnls(A, B)\n\n    assert np.all(x_rec >= 0)\n    assert np.sqrt(np.mean((B - A.dot(x_rec)) ** 2)) <= 1e-4\n\n\n@pytest.fixture\ndef psig():\n\n    # [[0, 1, 2, 3, 4]]\n    # axis=1 or -1 ==> [-1.5, 1, 1, 1, -1.5]\n    # axis=0 ==> [0, 0, 0, 0, 0]\n    return np.arange(0, 5, dtype=float)[np.newaxis]\n\n\n@pytest.mark.parametrize(\"edge_order\", [1, 2])\n@pytest.mark.parametrize(\"axis\", [0, 1, -1])\ndef test_cyclic_gradient(psig, edge_order, axis):\n    grad = librosa.util.cyclic_gradient(psig, edge_order=edge_order, axis=axis)\n\n    assert grad.shape == psig.shape\n    assert grad.dtype == psig.dtype\n\n    # Check the values\n    if axis == 0:\n        assert np.allclose(grad, 0)\n    else:\n        assert np.allclose(grad, [-1.5, 1, 1, 1, -1.5])\n\n\ndef test_shear_dense():\n\n    E = np.eye(3)\n\n    E_shear = librosa.util.shear(E, factor=1, axis=0)\n    assert np.allclose(E_shear, np.asarray([[1, 0, 0], [0, 0, 1], [0, 1, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=1, axis=1)\n    assert np.allclose(E_shear, np.asarray([[1, 0, 0], [0, 0, 1], [0, 1, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=-1, axis=1)\n    assert np.allclose(E_shear, np.asarray([[1, 1, 1], [0, 0, 0], [0, 0, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=-1, axis=0)\n    assert np.allclose(E_shear, np.asarray([[1, 0, 0], [1, 0, 0], [1, 0, 0]]))\n\n\n@pytest.mark.parametrize(\"fmt\", [\"csc\", \"csr\", \"lil\", \"dok\"])\ndef test_shear_sparse(fmt):\n    E = scipy.sparse.identity(3, format=fmt)\n\n    E_shear = librosa.util.shear(E, factor=1, axis=0)\n    assert E_shear.format == fmt\n    assert np.allclose(E_shear.toarray(), np.asarray([[1, 0, 0], [0, 0, 1], [0, 1, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=1, axis=1)\n    assert E_shear.format == fmt\n    assert np.allclose(E_shear.toarray(), np.asarray([[1, 0, 0], [0, 0, 1], [0, 1, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=-1, axis=1)\n    assert E_shear.format == fmt\n    assert np.allclose(E_shear.toarray(), np.asarray([[1, 1, 1], [0, 0, 0], [0, 0, 0]]))\n\n    E_shear = librosa.util.shear(E, factor=-1, axis=0)\n    assert E_shear.format == fmt\n    assert np.allclose(E_shear.toarray(), np.asarray([[1, 0, 0], [1, 0, 0], [1, 0, 0]]))\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_shear_badfactor():\n    librosa.util.shear(np.eye(3), factor=None)\n\n\ndef test_stack_contig():\n    x1 = np.ones(3)\n    x2 = -np.ones(3)\n\n    xs = librosa.util.stack([x1, x2], axis=0)\n\n    assert xs.flags[\"F_CONTIGUOUS\"]\n    assert np.allclose(xs, [[1, 1, 1], [-1, -1, -1]])\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_stack_fail_shape():\n    x1 = np.ones(3)\n\n    x2 = np.ones(2)\n    librosa.util.stack([x1, x2])\n\n\n@pytest.mark.xfail(raises=librosa.ParameterError)\ndef test_stack_fail_empty():\n    librosa.util.stack([])\n\n\n@pytest.mark.parametrize(\"axis\", [0, 1, -1])\n@pytest.mark.parametrize(\"x\", [np.random.randn(5, 10, 20)])\ndef test_stack_consistent(x, axis):\n    xs = librosa.util.stack([x, x], axis=axis)\n    xsnp = np.stack([x, x], axis=axis)\n\n    assert np.allclose(xs, xsnp)\n    if axis != 0:\n        assert xs.flags[\"C_CONTIGUOUS\"]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_29","text":"<reponame>AVoss84\/gauss_mix\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nimport os\nfrom scipy.stats import wishart, multivariate_normal, norm, randint, bernoulli, beta, multinomial, gamma, dirichlet, uniform\n\n\ndef exp_normalize(x):\n    b = x.max()\n    y = np.exp(x - b)\n    return y \/ y.sum()\n\n\nclass mvt2mixture:\n    \n    def __init__(self, thetas = {'mean1' : None, 'mean2' : None, \\\n                               'Sigma1' : None, 'Sigma2' : None, \\\n                               'nu1': None, 'nu2': None}, seed = None, gaussian = False):\n        \"\"\"\n        Multivariate 2-component Student-t mixture random generator. \n        Direct random sampling via using the Student-t representation as a continous scale mixture distr.   \n        -------\n        Input:\n        -------\n        thetas: Component-wise parameters; note that Sigma1,2 are the scale matrices of the \n                Wishart priors of the precision matrices of the Student-t's.\n        gaussian: boolean, generate from Gaussian mixture if True, otherwise from Student-t    \n        seed: set seed for rng.\n        \"\"\"\n        self.thetas = thetas ; self.seed = seed ; self.gaussian = gaussian\n        if self.seed is not None:\n            np.random.seed(seed)\n    \n    def draw(self, n_samples = 100, k = 2, p = .5): \n        \"\"\"\n        Random number generator:\n        Input:\n        -------\n        n_samples: Number of realizations to generate\n        k:         Number of features (Dimension of the t-distr.)\n        p:         Success probability Bernoulli(p) p.m.f. \n        \"\"\"\n        self.n_samples = n_samples ; self.k = k; self.p = p ; \n        m = 2                # number of mixture components\n        assert (len(self.thetas['mean1']) == k) & (self.thetas['Sigma1'].shape[0] == k), 'Number of dimensions does not match k!'\n\n        if self.gaussian:\n            cov1, cov2 = self.thetas['Sigma1'], self.thetas['Sigma2']  \n        else:    \n            cov1 = wishart.rvs(df = self.thetas['nu1'], scale = self.thetas['Sigma1'], size=1)\n            cov2 = wishart.rvs(df = self.thetas['nu2'], scale = self.thetas['Sigma2'], size=1)\n\n        self.var1 = self.thetas['nu1']\/(self.thetas['nu1']-2)*cov1       # variance covariance matrix of first Student-t component\n        self.var2 = self.thetas['nu2']\/(self.thetas['nu2']-2)*cov2\n        self.phi_is = bernoulli.rvs(p = self.p, size = self.n_samples)          # m=2\n        Phi = np.tile(self.phi_is, self.k).reshape(self.k,self.n_samples).T              # repeat phi vector to match with random matrix\n        rn1 = np.random.multivariate_normal(self.thetas['mean1'], cov1, self.n_samples)\n        rn2 = np.random.multivariate_normal(self.thetas['mean2'], cov2, self.n_samples)\n        self.sum1 = np.multiply(Phi, rn1)\n        self.sum2 = np.multiply(1-Phi, rn2)\n        self.x_draws = np.add(self.sum1,self.sum2)\n        return self.phi_is, self.x_draws\n\n\n    def show2D(self, save_plot=False, legend_on = True, **kwargs):\n        \"\"\"\n        Make scatter plot for first two dimensions of the random draws\n        \"\"\"\n        x_comp1,y_comp1 = self.sum1[:,0], self.sum1[:,1]\n        x_comp2,y_comp2 = self.sum2[:,0], self.sum2[:,1]\n        fig = plt.figure() ; \n        la = plt.scatter(x_comp1, y_comp1, c=\"blue\", **kwargs)\n        lb = plt.scatter(x_comp2, y_comp2, c=\"orange\", **kwargs)\n        lc = plt.scatter([self.thetas['mean1'][0], self.thetas['mean2'][0]], \n                         [self.thetas['mean1'][1],self.thetas['mean2'][1]], c=\"black\", s=6**2, alpha=.5)\n        #plt.title(\"Draws from 2-component \\nmultivariate Student-t mixture \\n(first two dimensions shown)\")\n        plt.xlabel(r'$x_{1}$') ; plt.ylabel(r'$x_{2}$')\n        if legend_on:\n            plt.legend((la, lb), ('Outlier', 'Inlier'),\n                            scatterpoints=1, loc='lower right', ncol=3, fontsize=8)\n        plt.show() ;\n        if save_plot:\n            fig.savefig('mixturePlot2D.jpg')\n            print(\"Saved to:\", os.getcwd())\n\n    def show3D(self, save_plot=False, legend_on = True, **kwargs):\n        \"\"\"\n        Make scatter plot for first three dimensions of the random draws\n        \"\"\"\n        fig = plt.figure() ; ax = Axes3D(fig)\n        x_comp1,y_comp1, z_comp1 = self.sum1[:,0], self.sum1[:,1], self.sum1[:,2]\n        x_comp2,y_comp2, z_comp2 = self.sum2[:,0], self.sum2[:,1], self.sum2[:,2]\n        la = ax.scatter(x_comp1, y_comp1, z_comp1, c=\"blue\", **kwargs) \n        lb = ax.scatter(x_comp2, y_comp2, z_comp2, c=\"orange\", **kwargs)  \n        lc = ax.scatter([self.thetas['mean1'][0], self.thetas['mean2'][0]], \n                     [self.thetas['mean1'][1],self.thetas['mean2'][1]], \n                     [self.thetas['mean1'][2],self.thetas['mean2'][2]], c=\"black\", s=6**2, alpha=.2)\n\n        #plt.title(\"Draws from 2-component \\nmultivariate mixture \\n(first three dimensions shown)\")\n        ax.set_xlabel(r'$x_{1}$') ; ax.set_ylabel(r'$x_{2}$') ;ax.set_zlabel(r'$x_{3}$')\n        if legend_on:\n            ax.legend((la, lb), ('Outlier', 'Inlier'),\n                        scatterpoints=1, loc='lower left', ncol=3, fontsize=8)    \n        plt.show();\n        if save_plot:\n            fig.savefig('mixturePlot3D.jpg')\n            print(\"Saved to:\", os.getcwd())\n\n\n# NEW!!!\n#-------------------------------------------------------------------------------------\nclass mvt_tmix:\n    \n    def __init__(self, seed = None):\n         self.seed = seed\n    \n    def draw(self, K = 10, N = 1*10**5, m = 3, gaussian = False):\n        \n        \"\"\"\n        Inputs:\n        -------\n        N: sample size\n        K: Dimension of Normal\/Student distr.\n        m: number of mixture components\n        \"\"\"\n        np.random.seed(self.seed)     \n        self.st0 = np.random.get_state()   # get initial state of RNG\n        #np.random.set_state(self.st0)\n        print(\"Drawing from\", m,\"component mixture distribution.\")\n        alphas = gamma.rvs(5, size=m)               # shape parameter\n        #print(sum(alphas))                              # equivalent sample size\n        self.p = dirichlet.rvs(alpha = alphas, size = 1)[0]\n        self.phi_is = multinomial.rvs(1, self.p, size=N)       # draw from categorical p.m.f\n        \n        self.x_draws = np.zeros((N,K))\n        self.hyper_loc, self.hyper_scale, self.thetas, self.var, self.covs, self.rdraws = dict(), dict(), dict(), tuple(), tuple(), tuple()\n        \n        for i in range(m):\n        \n              self.hyper_loc[\"mean\"+str(i+1)] = norm.rvs(size = 1, loc = 0, scale = 5)\n              self.hyper_scale[\"scale\"+str(i+1)] = 1\/gamma.rvs(5, size=1)\n              \n              self.thetas[\"mean\"+str(i+1)] = norm.rvs(size = K, loc = self.hyper_loc[\"mean\"+str(i+1)], \n                          scale = self.hyper_scale[\"scale\"+str(i+1)])\n              self.thetas[\"Sigma\"+str(i+1)] = np.eye(K)*(1\/gamma.rvs(5, size=K))\n              self.thetas[\"nu\"+str(i+1)] = randint.rvs(K+2, K+10, size=1)[0]\n        \n              if gaussian:\n                 self.covs += (self.thetas['Sigma'+str(i+1)], )\n              else:\n                 self.covs += (wishart.rvs(df = self.thetas['nu'+str(i+1)], scale = self.thetas['Sigma'+str(i+1)], size=1),)\n                 self.var += (self.thetas[\"nu\"+str(i+1)]\/(self.thetas[\"nu\"+str(i+1)]-2)*self.covs[i],)       # variance covariance matrix of first Student-t component\n              self.rdraws += (np.random.multivariate_normal(self.thetas[\"mean\"+str(i+1)], self.covs[i], N),)\n        \n              self.Phi = np.tile(self.phi_is[:,i], K).reshape(K,N).T              # repeat phi vector to match with random matrix\n              self.x_draws += np.multiply(self.Phi, self.rdraws[i])          \n              \n        return self.x_draws, np.argmax(self.phi_is,1)   # X, latent\n\n\n    def plot(self, draws = None, save_plot=False, legend_on = True, plot_type = ['2D', '3D'], **kwargs):\n        \"\"\"\n        Make scatter plot for first two dimensions of the random draws\n        \"\"\"\n        if draws is not None:\n            self.draws = draws\n            \n        #if plot_type[0] == '2D':\n        x_comp1,y_comp1 = self.x_draws[:,0], self.x_draws[:,1]\n        #x_comp2,y_comp2 = self.sum2[:,0], self.sum2[:,1]\n        fig = plt.figure() ; \n        la = plt.scatter(x_comp1, y_comp1, c=\"blue\", **kwargs)\n        #lb = plt.scatter(x_comp2, y_comp2, c=\"orange\", **kwargs)\n        #lc = plt.scatter([self.thetas['mean1'][0], self.thetas['mean2'][0]], \n        #                 [self.thetas['mean1'][1],self.thetas['mean2'][1]], c=\"black\", s=6**2, alpha=.5)\n        #plt.title(\"Draws from 2-component \\nmultivariate Student-t mixture \\n(first two dimensions shown)\")\n        plt.xlabel(r'$x_{1}$') ; plt.ylabel(r'$x_{2}$')\n        \n        if plot_type[0] == '3D':\n            fig = plt.figure() ; ax = Axes3D(fig)\n            x_comp1, y_comp1, z_comp1 = self.x_draws[:,0], self.x_draws[:,1], self.x_draws[:,2]\n            #x_comp2,y_comp2, z_comp2 = self.sum2[:,0], self.sum2[:,1], self.sum2[:,2]\n            la = ax.scatter(x_comp1, y_comp1, z_comp1, c=\"blue\", **kwargs) \n            #lb = ax.scatter(x_comp2, y_comp2, z_comp2, c=\"orange\", **kwargs)  \n            #lc = ax.scatter([self.thetas['mean1'][0], self.thetas['mean2'][0]], \n            #             [self.thetas['mean1'][1],self.thetas['mean2'][1]], \n            #             [self.thetas['mean1'][2],self.thetas['mean2'][2]], c=\"black\", s=6**2, alpha=.2)\n    \n            #plt.title(\"Draws from 2-component \\nmultivariate mixture \\n(first three dimensions shown)\")\n            ax.set_xlabel(r'$x_{1}$') ; ax.set_ylabel(r'$x_{2}$') ;ax.set_zlabel(r'$x_{3}$')\n            #if legend_on:\n            #    ax.legend((la, lb), ('Outlier', 'Inlier'),\n            #                scatterpoints=1, loc='lower left', ncol=3, fontsize=8)                            \n        #if legend_on:\n        #    plt.legend((la, lb), ('Outlier', 'Inlier'),\n        #                    scatterpoints=1, loc='lower right', ncol=3, fontsize=8)\n        plt.show() ;\n        #if save_plot:\n        #    fig.savefig('mixturePlot2D.jpg')\n        #    print(\"Saved to:\", os.getcwd())\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_31","text":"<reponame>koukyo1994\/atmaCup5\nimport logging\n\nimport numpy as np\nimport pandas as pd\n\nfrom pathlib import Path\nfrom typing import Any, Dict, Optional, Union, Tuple, List\n\nfrom scipy.sparse import csr_matrix\n\n\nclass RunningState:\n    def __init__(self, config: dict, logger: logging.Logger):\n        self.config = config\n\n        self.logger = logger\n\n        self.feature_dir = Path(\"features\")\n        self.output_dir = Path(\"output\")\n\n        self.dataframes: Dict[str, pd.DataFrame] = {}\n        self.dataframe_roles: Dict[str, str] = {}\n\n        self.callbacks: Dict[str, Dict[str, list]] = {}\n\n        self.data_stats: Dict[str, Optional[Union[str, dict]]] = {}\n\n        self.target_name = \"\"\n        self.target: Optional[Union[pd.DataFrame, Union[pd.Series, np.\n                                                        ndarray]]] = None\n        self.id_columns: Dict[str, Optional[str]] = {}\n        self.connect_to: Dict[str, Optional[str]] = {}\n        self.connect_on: Dict[str, Optional[str]] = {}\n\n        self.features: Dict[\n            str, Dict[str, Union[pd.DataFrame, Dict[str, csr_matrix]]]] = {}\n        self.importances: Dict[str, Union[Dict[str, float], pd.DataFrame]] = {}\n\n        self.splits: List[Tuple[np.ndarray, np.ndarray]] = []\n\n        self.models: Dict[str, Dict[str, Any]] = {}\n        self.metrics: Dict[str, Dict[str, float]] = {}\n\n        self.predictions: Dict[str, np.ndarray] = {}\n\n        self.misc: Dict[str, Any] = {}\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_17","text":"<gh_stars>0\n\"\"\"\n<NAME>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\nThis code is used to train retention time predictors and store\npredictions from a CV procedure for further analysis.\n\nThis project was made possible by MASSTRPLAN. MASSTRPLAN received funding \nfrom the Marie Sklodowska-Curie EU Framework for Research and Innovation \nHorizon 2020, under Grant Agreement No. 675132.\n\"\"\"\n\nfrom pygam import LinearGAM, s\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nimport numpy as np\nfrom scipy.stats import pearsonr, spearmanr\n\ndef call_ghostbusters(infile_known=\"temp\/tempKnownsl2.csv\",infile_unknown=\"temp\/tempUnknownsl2.csv\",fold_list=\"temp\/tempFolds.txt\"): #df_known,df_unknown,\n    \"\"\"\n    Get the dataframe associated with this analysis\n    \n    Parameters\n    ----------\n    infile_known : str\n        location of a file with known retention time, for Layer 2\n    infile_unknown : str\n        location of a file with umknown retention time, for Layer 2\n    fold_list : str\n        the folds to be used in Layer 2\n    \n    Returns\n    -------\n    pd.DataFrame\n        test predictions\n\tpd.DataFrame\n\t\ttrain predictions\n    \"\"\"\n    cmd = \"Rscript makeGAM.R %s %s %s\" % (infile_known,infile_unknown,fold_list)\n    print(\"Executing: \",cmd)\n    p = subprocess.Popen(cmd, stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True)\n    out, err = p.communicate()\n    \n    preds = pd.read_csv(\"GAMpredTemp.csv\")\n    train_preds = pd.read_csv(\"GAMtrainTemp.csv\")\n\n    return(preds,train_preds)\n\ndef apply_l2(known_all,unknown_all,name=\"cake\",ignore_cols=[\"IDENTIFIER\",\"time\"],cv_list=None,min_cor=0.75):\n    \"\"\"\n    Get the dataframe associated with this analysis\n    \n    Parameters\n    ----------\n    known_all : pd.DataFrame\n        dataframe with known retention time, for Layer 2\n\tunknown_all : pd.DataFrame\n\t\tdataframe with unknown retention time, for Layer 2\n    ignore_cols : list\n        ignore these columns\n    cv_list : list\n        the folds to be used in Layer 2\n    \n    Returns\n    -------\n    pd.DataFrame\n        test predictions\n\tpd.DataFrame\n\t\ttrain predictions\n    \"\"\"\n    ret_preds = []\n    ret_preds_train = []\n    cnames = []\n    \n    known_all.index = known_all[\"IDENTIFIER\"]\n    unknown_all.index = unknown_all[\"IDENTIFIER\"]\n\n    df_return_train = pd.DataFrame(np.zeros((len(known_all.index), len(known_all.columns))))\n    df_return_train.columns = known_all.columns\n    df_return_train.index = known_all.index\n    df_return_train[\"IDENTIFIER\"] = known_all[\"IDENTIFIER\"]\n    df_return_train[\"time\"] = known_all[\"time\"]\n\n    df_return_test = pd.DataFrame(np.zeros((len(unknown_all.index), len(unknown_all.columns))))\n    df_return_test.columns = unknown_all.columns\n    df_return_test.index = unknown_all.index\n    df_return_test[\"IDENTIFIER\"] = unknown_all[\"IDENTIFIER\"]\n\n    for c in known_all.columns:\n        try:\n            if c in [\"IDENTIFIER\",\"time\"]:\n                continue\n            try:\n                cor = spearmanr(known_all[c], known_all[\"time\"])[0]\n            except:\n                continue\n            \n            if abs(cor) < min_cor:\n                continue\n\n            if cor < 0.0:\n                constr = \"monotonic_dec\"\n            else:\n                constr = \"monotonic_inc\"\n\n            unique_cv = list(set(cv_list))\n\n            for cv_num in unique_cv:\n                selection_instances = [True if fold_num != cv_num else False for fold_num in cv_list]\n                selection_instances_test = [False if fold_num != cv_num else True for fold_num in cv_list]\n\n                X_train = known_all.loc[selection_instances,c]\n                y_train = known_all.loc[selection_instances,\"time\"]\n\n                X_test = known_all.loc[selection_instances_test,c]\n                y_test = known_all.loc[selection_instances_test,\"time\"]\n\n                gam_model_cv = LinearGAM(s(0, constraints=constr, n_splines=10), verbose=True).fit(X_train, y_train)\n                df_return_train.loc[selection_instances_test,c] = list(gam_model_cv.predict(X_test))\n            \n            print(\"--------------------------------\")\n            gam_model = LinearGAM(s(0, constraints=constr, n_splines=10), verbose=True).fit(known_all[c], known_all[\"time\"])\n            df_return_test.loc[:,c] = list(gam_model.predict(unknown_all[c]))\n        except KeyError:\n            continue\n    non_feature_cols = [\"IDENTIFIER\",\"time\"]\n    \n    df_return_test.columns = [c+\"+RtGAM\" if c not in non_feature_cols else c for c in df_return_test.columns]\n    df_return_train.columns = [c+\"+RtGAM\" if c not in non_feature_cols else c for c in df_return_train.columns]\n    \n    return(df_return_test,df_return_train)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_25","text":"<filename>nga_binaural\/binaural_wrapper.py<gh_stars>1-10\nimport copy\nfrom ear.options import Option, OptionsHandler\nfrom ear.core.metadata_input import ObjectRenderingItem\nfrom ear.core import point_source\nfrom ear.fileio.adm.elements import ObjectPolarPosition\nimport numpy as np\nfrom scipy import signal\nfrom . import sofa, binaural_point_source\nfrom .matrix_convolver import MatrixBlockConvolver\nfrom .convolver import VariableBlockSizeAdapter\nfrom .align_irs import align_irs\nfrom .binaural_layout import BinauralOutput\n\nbinaural_output_options = OptionsHandler(\n    block_size=Option(\n        default=512,\n        description=\"block size for convolution\",\n    ),\n    virtual_layout_hrir=Option(\n        default=(\"binaural\", \"all_defined\"),\n        description=\"loudspeaker layout to render to before applying HRIRs\",\n    ),\n    virtual_layout_brir=Option(\n        default=(\"binaural\", \"BRIR\"),\n        description=\"loudspeaker layout to render to before applying BRIRs\",\n    ),\n    hrir_file=Option(\n        default=\"resource:data\/HRIR_FULL2DEG.sofa\",\n        description=\"SOFA file to get HRIRs from\",\n    ),\n    brir_file=Option(\n        default=\n        \"resource:data\/BRIR_KU100_60ms.sofa\",\n        description=\"SOFA file to get BRIRs from\",\n    ),\n)\n\nclass BinauralWrapper(object):\n    \"\"\"Wrapper around multiple loudspeaker renderers which returns the binaural rendering.\"\"\"\n    @binaural_output_options.with_defaults\n    def __init__(self,\n                 renderer_cls,\n                 layout,\n                 virtual_layout,\n                 sr,\n                 block_size,\n                 virtual_layout_hrir,\n                 virtual_layout_brir,\n                 hrir_file,\n                 brir_file,\n                 renderer_opts={}):\n\n        point_source.configure = binaural_point_source.configure\n\n        \"\"\"load layouts for all three renderings\"\"\"\n        \n        if virtual_layout is None:\n            hrir_layout = sofa.get_binaural_layout(virtual_layout_hrir)\n        else:\n            hrir_layout = sofa.get_binaural_layout(('bs2051', virtual_layout))\n        if len(hrir_layout.channels) < 22:\n            brir_layout = hrir_layout\n        else:\n            brir_layout = sofa.get_binaural_layout(virtual_layout_brir)\n        dirir_layout = sofa.get_binaural_layout((\"binaural\", \"binaural_direct\"))\n\n        \"\"\"define three renderers\"\"\"\n        self.renderer_hrir = renderer_cls(hrir_layout, **renderer_opts)\n        self.renderer_brir = renderer_cls(brir_layout, **renderer_opts)\n        self.renderer_direct = renderer_cls(dirir_layout, **renderer_opts)\n\n        \"\"\"load impulse responses according to the prior defined layouts and apply gain and delay for correct summation\"\"\"\n        hrir_sofa_file = sofa.SOFAFileHRIR(sofa.load_hdf5(hrir_file))\n        hrirs = hrir_sofa_file.irs_for_positions(hrir_layout.positions)\n        hrirs = align_irs(hrirs)\n        if hrir_sofa_file.check_fs() != sr:\n            hrirs = signal.resample(\n                hrirs, int(len(hrirs) \/ hrir_sofa_file.check_fs() * sr))\n        hrirs = hrirs \/ sofa.calc_gain_of_irs(hrirs) * 0.20885643426029013 \/ 2\n\n        brir_sofa_file = sofa.SOFAFileHRIR(sofa.load_hdf5(brir_file))\n        brirs = brir_sofa_file.irs_for_positions(brir_layout.positions)\n        if brir_sofa_file.check_fs() != sr:\n            brirs = signal.resample(\n                brirs, int(len(brirs) \/ brir_sofa_file.check_fs() * sr))\n        brirs = brirs \/ sofa.calc_gain_of_irs(\n            brirs) * 0.05542830927315457 \/ 2 \n        brirs = np.concatenate(\n            (np.zeros([len(brirs), 2,\n                       int(sofa.calc_delay_of_irs(hrirs)) - 1]), brirs), axis=2)\n\n        dirirs = np.concatenate((np.zeros(\n            [2, 2, int(sofa.calc_delay_of_irs(hrirs)) - 1]), np.ones([2, 2, 1])), axis=2)\n        dirirs = dirirs * 0.37\n\n        \"\"\"prepare filter matrix for MatrixBlockConvolver\"\"\"\n        filter_matrix_hrir = [(in_ch, out_ch, ir)\n                              for in_ch, ir_pair in enumerate(hrirs)\n                              for out_ch, ir in enumerate(ir_pair)]\n\n        filter_matrix_brir = [(in_ch, out_ch, ir)\n                              for in_ch, ir_pair in enumerate(brirs)\n                              for out_ch, ir in enumerate(ir_pair)]\n\n        filter_matrix_dirir = [(in_ch, out_ch, ir)\n                               for in_ch, ir_pair in enumerate(dirirs)\n                               for out_ch, ir in enumerate(ir_pair)]\n\n        \"\"\"define convolver for all three parts\"\"\"\n        convolver_hrir = MatrixBlockConvolver(block_size,\n                                              len(hrir_layout.channels), 2,\n                                              filter_matrix_hrir)\n\n        convolver_brir = MatrixBlockConvolver(block_size,\n                                              len(brir_layout.channels), 2,\n                                              filter_matrix_brir)\n\n        convolver_dirir = MatrixBlockConvolver(block_size,\n                                               len(dirir_layout.channels), 2,\n                                               filter_matrix_dirir)\n\n        \"\"\"convolution with variable block size\"\"\"\n        self.convolver_vbs_hrir = VariableBlockSizeAdapter(\n            block_size, (len(hrir_layout.channels), 2),\n            convolver_hrir.filter_block)\n\n        self.convolver_vbs_brir = VariableBlockSizeAdapter(\n            block_size, (len(brir_layout.channels), 2),\n            convolver_brir.filter_block)\n\n        self.convolver_vbs_dirir = VariableBlockSizeAdapter(\n            block_size, (len(dirir_layout.channels), 2),\n            convolver_dirir.filter_block)\n\n\n    \"\"\"filter items to be rendered for different renderers (binaural, non-binaural)\"\"\"\n    def filter_rendering_items_hrir(self, rendering_items):\n        rendering_items_hrir = copy.deepcopy(rendering_items)\n\n        for objects in enumerate(rendering_items_hrir):\n            if isinstance(objects[1], ObjectRenderingItem):\n\n                for audioBlock in objects[1].adm_path.audioChannelFormat.audioBlockFormats[:]:\n                    if isinstance(audioBlock.position, ObjectPolarPosition):\n                        if audioBlock.position.distance <= 0.3:\n                            audioBlock.gain *= (audioBlock.position.distance \/ 0.3)\n                        audioBlock.position.distance = 1\n\n        return rendering_items_hrir\n\n    def filter_rendering_items_brir(self, rendering_items):\n        rendering_items_brir = copy.deepcopy(rendering_items)\n\n        for objects in enumerate(rendering_items_brir):\n            if isinstance(objects[1], ObjectRenderingItem):\n\n                for audioBlock in objects[1].adm_path.audioChannelFormat.audioBlockFormats[:]:\n                    if isinstance(audioBlock.position, ObjectPolarPosition):\n                        if audioBlock.position.distance <= 1 and audioBlock.position.distance > 0.2:\n                            audioBlock.gain *= (audioBlock.position.distance - 0.2) \/ 0.8\n                        if audioBlock.position.distance <= 0.2:\n                            audioBlock.gain = 0\n                        audioBlock.position.distance = 1\n\n        return rendering_items_brir\n\n    def filter_rendering_items_direct(self, rendering_items):\n        rendering_items_direct = copy.deepcopy(rendering_items)\n\n        for objects in enumerate(rendering_items_direct):\n            if isinstance(objects[1], ObjectRenderingItem):\n\n                for audioBlock in objects[1].adm_path.audioChannelFormat.audioBlockFormats[:]:\n                    if isinstance(audioBlock.position, ObjectPolarPosition):\n                        if audioBlock.position.distance > 0.3:\n                            audioBlock.gain = 0\n                        if audioBlock.position.distance <= 0.3:\n                            audioBlock.gain *= 1 - (audioBlock.position.distance \/ 0.3)\n                        audioBlock.position.distance = 1\n                    else:\n                        audioBlock.gain = 0\n\n            else:\n                rendering_items_direct = []\n\n        return rendering_items_direct\n\n    \"\"\"sets rendering items and applies filtering\"\"\"\n    def set_rendering_items(self, rendering_items):\n\n        self.renderer_brir.set_rendering_items(self.filter_rendering_items_brir(rendering_items))\n        self.renderer_hrir.set_rendering_items(self.filter_rendering_items_hrir(rendering_items))\n        self.renderer_direct.set_rendering_items(self.filter_rendering_items_direct(rendering_items))\n\n    @property\n    def overall_delay(self):\n        \"\"\"check delays for all renderers\"\"\"\n\n        return self.convolver_vbs_hrir.delay(self.renderer_hrir.overall_delay)\n\n    \"\"\"take output of all rednerers and convolve accordingly, return complete summed rendering\"\"\"\n    def render(self, sample_rate, start_sample, samples):\n\n        loudspeaker_signals_brir = self.renderer_brir.render(\n            sample_rate, start_sample, samples)\n        brir_rendering = self.convolver_vbs_brir.process(\n            loudspeaker_signals_brir)\n\n        loudspeaker_signals_hrir = self.renderer_hrir.render(\n            sample_rate, start_sample, samples)\n        hrir_rendering = self.convolver_vbs_hrir.process(\n            loudspeaker_signals_hrir)\n\n        loudspeaker_signals_direct = self.renderer_direct.render(\n            sample_rate, start_sample, samples)\n        direct_rendering = self.convolver_vbs_dirir.process(\n            loudspeaker_signals_direct)\n\n        rendering = (hrir_rendering + brir_rendering + direct_rendering) \/ 2\n\n        return rendering\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_30","text":"<filename>bounding_phase.py<gh_stars>0\nimport math\r\nimport sympy as sym\r\n\r\nprint(\"BOUNDING PHASE METHOD\")\r\nx = sym.Symbol('x')\r\n\r\n\r\n### Function ###\r\n\r\nf = x**2 - 5*x + x**2 \r\n\r\n################\r\n\r\ndef substitute(k):\r\n    return (f.subs(x,k))\r\n\r\nwhile(1):\r\n    delta = float(input(\"Enter the delta value : \"))\r\n    x_o = 0.6 #initial guess\r\n    x_minus_delta = x_o - delta\r\n    x_plus_delta = x_o + delta\r\n    \r\n    f_minus_delta = substitute(x_minus_delta)\r\n    f_plus_delta = substitute(x_plus_delta)\r\n    f_o = substitute(x_o)\r\n    print(\"x_minus_delta = {}  x = {}  x_plus_delta = {}\".format(x_minus_delta,x_o,x_plus_delta))\r\n    print(\"f(x-$) = {}  f(x) = {}  f(x+$) = {}\".format(f_minus_delta,f_o,f_plus_delta))\r\n    \r\n    if(f_minus_delta>=f_o and f_o>=f_plus_delta):\r\n        delta = delta\r\n        break\r\n    elif(f_minus_delta<=f_o and f_o<=f_plus_delta):\r\n        delta = -delta\r\n        break\r\n    else:\r\n        continue\r\n    \r\n\r\na = []\r\na.append(x_o)\r\nk = 0\r\nf_o_plus_1 = f_o - 1\r\nwhile(f_o_plus_1 < f_o):\r\n    x_o_plus_1 = x_o + (2**k)*delta\r\n    a.append(x_o_plus_1)\r\n    k = k + 1\r\n    f_o_plus_1 = substitute(x_o_plus_1)\r\n    f_o = substitute(x_o)\r\n    print(\"step :\", k)\r\n    print(\"x_o = {} , x_o_plus_1 = {}\".format(x_o,x_o_plus_1))\r\n    print(\"f_o = {}  f_o_plus_1 = {}\".format(f_o,f_o_plus_1))\r\n    x_o = x_o_plus_1\r\n  \r\n    \r\nprint(\"( {} , {}  )\".format(a[-3],x_o_plus_1))\r\n    \r\n    \r\n    \r\n\r\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_480","text":"<filename>DeformationTransfer.py<gh_stars>1-10\n#Code by <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, and <NAME>\nimport sys\nimport numpy as np\nfrom scipy import sparse\nimport scipy.io as sio\nfrom scipy.linalg import norm\nfrom scipy.sparse.linalg import lsqr\n\ndef saveOffFileExternal(filename, VPos, VColors, ITris):\n    #Save off file given buffers, not necessarily in the PolyMesh object\n    nV = VPos.shape[0]\n    nF = ITris.shape[0]\n    fout = open(filename, \"w\")\n    if VColors.size == 0:\n        fout.write(\"OFF\\n%i %i %i\\n\"%(nV, nF, 0))\n    else:\n        fout.write(\"COFF\\n%i %i %i\\n\"%(nV, nF, 0))\n    for i in range(nV):\n        fout.write(\"%g %g %g\"%tuple(VPos[i, :]))\n        if VColors.size > 0:\n            fout.write(\" %g %g %g\"%tuple(VColors[i, :]))\n        fout.write(\"\\n\")\n    for i in range(nF):\n        fout.write(\"3 %i %i %i\\n\"%tuple(ITris[i, :]))\n    fout.close()\n\n#Return VPos, VColors, and ITris without creating any structure\n#(Assumes triangle mesh)\ndef loadOffFileExternal(filename):\n    fin = open(filename, 'r')\n    nVertices = 0\n    nFaces = 0\n    lineCount = 0\n    face = 0\n    vertex = 0\n    divideColor = False\n    VPos = np.zeros((0, 3))\n    VColors = np.zeros((0, 3))\n    ITris = np.zeros((0, 3))\n    for line in fin:\n        lineCount = lineCount+1\n        fields = line.split() #Splits whitespace by default\n        if len(fields) == 0: #Blank line\n            continue\n        if fields[0][0] in ['#', '\\0', ' '] or len(fields[0]) == 0:\n            continue\n        #Check section\n        if nVertices == 0:\n            if fields[0] == \"OFF\" or fields[0] == \"COFF\":\n                if len(fields) > 2:\n                    fields[1:4] = [int(field) for field in fields]\n                    [nVertices, nFaces, nEdges] = fields[1:4]  \n                    print \"nVertices = %i, nFaces = %i\"%(nVertices, nFaces)\n                    #Pre-allocate vertex arrays    \n                    VPos = np.zeros((nVertices, 3)) \n                    VColors = np.zeros((nVertices, 3))\n                    ITris = np.zeros((nFaces, 3))\n                if fields[0] == \"COFF\":\n                    divideColor = True            \n            else:\n                fields[0:3] = [int(field) for field in fields]\n                [nVertices, nFaces, nEdges] = fields[0:3]\n                VPos = np.zeros((nVertices, 3)) \n                VColors = np.zeros((nVertices, 3))\n                ITris = np.zeros((nFaces, 3))\n        elif vertex < nVertices:\n            fields = [float(i) for i in fields]\n            P = [fields[0],fields[1], fields[2]]\n            color = np.array([0.5, 0.5, 0.5]) #Gray by default\n            if len(fields) >= 6:\n                #There is color information\n                if divideColor:\n                    color = [float(c)\/255.0 for c in fields[3:6]]\n                else:\n                    color = [float(c) for c in fields[3:6]]\n            VPos[vertex, :] = P\n            VColors[vertex, :] = color\n            vertex = vertex+1\n        elif face < nFaces:\n            #Assume the vertices are specified in CCW order\n            fields = [int(i) for i in fields]\n            ITris[face, :] = fields[1:fields[0]+1]\n            face = face+1\n    fin.close()\n    VPos = np.array(VPos, np.float64)\n    VColors = np.array(VColors, np.float64)\n    ITris = np.array(ITris, np.int32)\n    return (VPos, VColors, ITris) \n\ndef loadBaselKeypointMesh():\n    (VPos, VColors, ITris) = loadOffFileExternal(\"BUMesh.off\")    \n    return (VPos, ITris)\n\ndef getBaselBUKeypointsIdx():\n    idx = sio.loadmat(\"BaselBUKeypointsIdx\")['idx']-1\n    idx = idx.flatten()\n    return idx\n\nclass VideoMesh(object):\n    def __init__(self):\n        self.Frames = np.array([])\n        self.ITris = np.array([])\n\n    #Initialize the basel video with the first (neutral) frame filled in\n    #and the rest blank\n    def initBaselVideo(self, filename, NFrames):\n        (a, b, self.ITris) = loadOffFileExternal(\"BUMesh.off\")\n        #Grab the keypoints of the chosen basel model\n        shape = sio.loadmat(filename)['shape']\n        shape = np.reshape(shape, [len(shape)\/3, 3])\n        idx = getBaselBUKeypointsIdx()\n        shape = shape[idx, :]\n        self.Frames = np.zeros((NFrames, shape.shape[0], shape.shape[1]))\n        self.Frames[0, :, :] = shape\n    \n    #Load in a bunch of bnd files, assuming the first one is a neutral\n    #expression\n    def initBUVideo(self, paths):\n        (a, b, self.ITris) = loadOffFileExternal(\"BUMesh.off\")\n        X1 = np.loadtxt(paths[0])\n        X1 = X1[:, 1::]\n        NFrames = len(paths)\n        self.Frames = np.zeros((NFrames, X1.shape[0], X1.shape[1]))\n        self.Frames[0, :, :] = X1\n        for i in range(1, NFrames):\n            X = np.loadtxt(paths[i])\n            X = X[:, 1::]\n            self.Frames[i, :, :] = X\n    \n    def saveFramesOff(self, prefix):\n        for i in range(self.Frames.shape[0]):\n            VPos = self.Frames[i, :, :]\n            fout = open(\"%s%i.off\"%(prefix, i), \"w\")\n            fout.write(\"OFF\\n%i %i 0\\n\"%(VPos.shape[0], self.ITris.shape[0]))\n            for i in range(VPos.shape[0]):\n                fout.write(\"%g %g %g\\n\"%(VPos[i, 0], VPos[i, 1], VPos[i, 2]))\n            for i in range(self.ITris.shape[0]):\n                fout.write(\"3 %g %g %g\\n\"%(self.ITris[i, 0], self.ITris[i, 1], self.ITris[i, 2]))\n            fout.close()\n        \n\ndef getLaplacianMatrixCotangent(VPos, ITris, anchorsIdx, anchorWeights = 1):\n    N = VPos.shape[0]\n    M = ITris.shape[0]\n    #Allocate space for the sparse array storage, with 2 entries for every\n    #edge for every triangle (6 entries per triangle); one entry for directed \n    #edge ij and ji.  Note that this means that edges with two incident triangles\n    #will have two entries per directed edge, but sparse array will sum them \n    I = np.zeros(M*6)\n    J = np.zeros(M*6)\n    V = np.zeros(M*6)\n    \n    #Keep track of areas of incident triangles and the number of incident triangles\n    IA = np.zeros(M*3)\n    VA = np.zeros(M*3) #Incident areas\n    VC = 1.0*np.ones(M*3) #Number of incident triangles\n    \n    #Step 1: Compute cotangent weights\n    for shift in range(3): \n        #For all 3 shifts of the roles of triangle vertices\n        #to compute different cotangent weights\n        [i, j, k] = [shift, (shift+1)%3, (shift+2)%3]\n        dV1 = VPos[ITris[:, i], :] - VPos[ITris[:, k], :]\n        dV2 = VPos[ITris[:, j], :] - VPos[ITris[:, k], :]\n        Normal = np.cross(dV1, dV2)\n        #Cotangent is dot product \/ mag cross product\n        NMag = np.sqrt(np.sum(Normal**2, 1))\n        cotAlpha = np.sum(dV1*dV2, 1)\/NMag\n        I[shift*M*2:shift*M*2+M] = ITris[:, i]\n        J[shift*M*2:shift*M*2+M] = ITris[:, j] \n        V[shift*M*2:shift*M*2+M] = cotAlpha\n        I[shift*M*2+M:shift*M*2+2*M] = ITris[:, j]\n        J[shift*M*2+M:shift*M*2+2*M] = ITris[:, i] \n        V[shift*M*2+M:shift*M*2+2*M] = cotAlpha\n        if shift == 0:\n            #Compute contribution of this triangle to each of the vertices\n            for k in range(3):\n                IA[k*M:(k+1)*M] = ITris[:, k]\n                VA[k*M:(k+1)*M] = 0.5*NMag\n    \n    #Step 2: Create laplacian matrix\n    L = sparse.coo_matrix((V, (I, J)), shape=(N, N)).tocsr()\n    #Create the diagonal by summing the rows and subtracting off the nondiagonal entries\n    L = sparse.dia_matrix((L.sum(1).flatten(), 0), L.shape) - L\n    \n    #Step 3: Add anchors\n    L = L.tocoo()\n    I = L.row.tolist()\n    J = L.col.tolist()\n    V = L.data.tolist()\n    I = I + range(N, N+len(anchorsIdx))\n    J = J + anchorsIdx.tolist()\n    V = V + [anchorWeights]*len(anchorsIdx)\n    L = sparse.coo_matrix((V, (I, J)), shape=(N+len(anchorsIdx), N)).tocsr()\n    return L\n\ndef solveLaplacianMesh(VPos, ITris, anchorsIdx, anchors):\n    N = VPos.shape[0]\n    L = getLaplacianMatrixCotangent(VPos, ITris, anchorsIdx)\n    delta = L.dot(VPos)\n    delta[N:, :] = anchors\n    sio.savemat(\"System.mat\", {\"L\":L, \"delta\":delta})\n    VPosNew = np.zeros((N, 3))\n    for k in range(3):\n        print \"Solving Laplacian mesh coordinates %i of %i...\"%(k+1, 3)\n        VPosNew[:, k] = lsqr(L, delta[:, k])[0]\n    return VPosNew\n\nclass DeformationTransferer:\n    def __init__(self, origVideo, warpedVideo):\n        self.origVideo = origVideo\n        self.warpedVideo = warpedVideo\n        self.origFrames = self.origVideo.Frames\n        self.warpedFrames = self.warpedVideo.Frames\n        self.NFrames = self.origFrames.shape[0]\n        self.ITris = self.origVideo.ITris\n        self.NFaces = self.ITris.shape[0]\n\n        self.count = 0\n        self.NVertices = self.origFrames.shape[1]\n        self.NVertices4 = self.NVertices + self.NFaces #original vertices plus 1 new vertex (4th vector) for each face\n        # Tris4 is Tris plus 4th col indexing 4th vector (which should be mapped to the N to N+F-1 index of VPos4)\n        self.Tris4 = np.hstack((self.ITris,\n                                    np.reshape(np.arange(self.NVertices, self.NVertices4), (self.NFaces, 1))))\n        print \"#####debug info: initial values#########\"\n        print \"origFrame shape (NFrames x NVertices x 3):\", self.origFrames.shape\n        print \"warpedFrame shape (NFrames x NVertices x 3): \", self.warpedFrames.shape\n        print \"ITris shape:\", self.ITris.shape\n        print \"#####end: initial values#########\"\n\n    def beginDeformationTransfer(self):\n        resultFrames = np.empty([self.NFrames, self.NVertices, 3])  # this is result array to fill in\n        resultFrames[0, :, :] = self.warpedFrames[0, :, :]\n        origOldVPos4 = self.getVPos4(self.origFrames[0, :, :], self.ITris)  # old VPos with extra NFaces vectors\n        warpedOldVPos4 = self.getVPos4(self.warpedFrames[0, :, :], self.ITris)\n        for i in range(1, self.NFrames):\n            # 1 orig: get newVPos4\n            origNewVPos4 = self.getVPos4(self.origFrames[i, :, :], self.ITris)\n            # 2 orig: use old and new VPos4 to get S-matrix which shape is 3 x 3NFaces\n            S = self.getSMatrix(origOldVPos4, origNewVPos4, self.Tris4)\n            # 3 warped: use old VPos4 to get A (coefficient) sparse matrix which shape is 3NFaces x NVertices\n            A = self.getAMatrix(warpedOldVPos4, self.Tris4)\n            origOldVPos4 = origNewVPos4\n            warpedOldVPos4[:, 0] = lsqr(A, S[0, :])[0]\n            warpedOldVPos4[:, 1] = lsqr(A, S[1, :])[0]\n            warpedOldVPos4[:, 2] = lsqr(A, S[2, :])[0]\n           # print \"new VPos4 shape:\", warpedOldVPos4[np.arange(self.NVertices), :].shape\n            resultFrames[i, :, :] = warpedOldVPos4[np.arange(self.NVertices), :]\n        self.warpedVideo.Frames = resultFrames\n\n\n\n    #get VPos4 (each face has 4 vertices) from VPos3 (each face 3 vertices) with mesh topology given\n    def getVPos4(self, VPos3, ITris3):\n        V4 = self.get4thVertex(VPos3, ITris3)\n        VPos4 = np.vstack((VPos3, V4))\n        return VPos4\n\n    # get4thVertex for each face, aka face normal scaled by reciprocal of sqrt of its length\n    # (3 vertices's index are stored in every row in ITris)\n    def get4thVertex(self, VPos3, ITris3):\n        V1 = VPos3[ITris3[:, 1], :] - VPos3[ITris3[:, 0], :]\n        V2 = VPos3[ITris3[:, 2], :] - VPos3[ITris3[:, 0], :]\n        FNormals = np.cross(V1, V2)\n\n        FNormalsSqrtLength = np.sqrt(np.sum(FNormals**2, 1))[:, None]\n        F = FNormals\/FNormalsSqrtLength\n        Vertex4 = VPos3[ITris3[:, 0], :] + F\n        return Vertex4\n\n    def getSMatrix(self, oldVPos4, newVPos4, Tris4):\n        v2subv1 = oldVPos4[Tris4[:, 1], :] - oldVPos4[Tris4[:, 0], :]\n        v3subv1 = oldVPos4[Tris4[:, 2], :] - oldVPos4[Tris4[:, 0], :]\n        v4subv1 = oldVPos4[Tris4[:, 3], :] - oldVPos4[Tris4[:, 0], :]\n        tildev2subv1 = newVPos4[Tris4[:, 1], :] - newVPos4[Tris4[:, 0], :]\n        tildev3subv1 = newVPos4[Tris4[:, 2], :] - newVPos4[Tris4[:, 0], :]\n        tildev4subv1 = newVPos4[Tris4[:, 3], :] - newVPos4[Tris4[:, 0], :]\n        assert self.NFaces == Tris4.shape[0]\n        S = np.zeros((3, 0))\n        for i in range(0, self.NFaces):\n            vInv = np.linalg.inv((np.vstack((v2subv1[i, :], v3subv1[i, :], v4subv1[i, :]))).T)\n            tildev = (np.vstack((tildev2subv1[i, :], tildev3subv1[i, :], tildev4subv1[i, :]))).T\n            S = np.hstack((S, np.dot(tildev, vInv)))\n        return S\n\n    def getAMatrix(self, VPos4, Tris4):\n        # I, J, and V are parallel numpy arrays that hold the rows, columns, and values of nonzero elements\n        I = []\n        J = []\n        V = []\n        v2subv1 = VPos4[Tris4[:, 1], :] - VPos4[Tris4[:, 0], :]\n        v3subv1 = VPos4[Tris4[:, 2], :] - VPos4[Tris4[:, 0], :]\n        v4subv1 = VPos4[Tris4[:, 3], :] - VPos4[Tris4[:, 0], :]\n        assert self.NFaces == Tris4.shape[0]\n\n        for i in range(0, self.NFaces):\n            idxRow = i * 3\n            vInv = np.linalg.inv((np.vstack((v2subv1[i, :], v3subv1[i, :], v4subv1[i, :]))).T)  # 3x3\n            sumOfNegativevInv = np.sum(-1 * vInv, axis = 0) # shape is (3,)\n            ###################   ######\n            # -A-D-G, A, D, G #   # x1 #\n            # -B-E-H, B, E, H # X # x2 #\n            # -C-F-I, C, F, I #   # x3 #\n            ###################   # x4 #\n                                  ######\n\n            # sumOfNegativevInv current looks like this, take care when fill in I, J, V\n            ##########################\n            # -A-D-G, -B-E-H, -C-F-I #\n            ##########################\n            for j in range(0, 3):\n                I.append(idxRow + j)\n                J.append(Tris4[i, 0])\n                V.append(sumOfNegativevInv[j])\n            # vInv current looks like this. Same, be careful.\n            ###########\n            # A, B, C #\n            # D, E, F #\n            # G, H, I #\n            ###########\n            for j in range(0, 3):\n                for k in range(0, 3):\n                    I.append(idxRow + k)\n                    J.append(Tris4[i, j + 1])\n                    V.append(vInv[j, k])\n        A = sparse.coo_matrix((V, (I, J)), shape = (3 * self.NFaces, self.NVertices4)).tocsr()\n        return A\n\n\nif __name__ == '__main__':\n    #Load in BU bnd files\n    buVideo = VideoMesh()\n    buVideo.initBUVideo([\"bu3\/F0012\/F0012_AN01WH_F3D.bnd\", \"bu3\/F0012\/F0012_HA04WH_F3D.bnd\"])\n    NFrames = buVideo.Frames.shape[0]\n    \n    #Load in basel mesh\n    baselVertsFile = \"BaselVerts.mat\"\n    ITris = sio.loadmat(\"BaselTris.mat\")['ITris']\n    VPos = sio.loadmat(baselVertsFile)['shape']\n    VPos = np.reshape(VPos, [len(VPos)\/3, 3])\n    \n    #Create basel video placeholder\n    baselVideo = VideoMesh()\n    baselVideo.initBaselVideo(baselVertsFile, NFrames)\n    \n    #Do coarse deformation transfer\n    T = DeformationTransferer(buVideo, baselVideo)\n    T.beginDeformationTransfer()\n    #Save coarse frames to hard drive\n    baselVideo.saveFramesOff(\"Basel\")\n    \n    #Do fine deformation transfer with Laplacian mesh using coarse\n    #vertices as anchors\n    idx = getBaselBUKeypointsIdx()\n    L = getLaplacianMatrixCotangent(VPos, ITris, idx)\n    VPosNew = solveLaplacianMesh(VPos, ITris, idx, baselVideo.Frames[1, :, :])\n    saveOffFileExternal(\"BaselTransfer.off\", VPosNew, np.array([]), ITris)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_481","text":"<filename>astrobase\/lcmath.py<gh_stars>10-100\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n# lcmath.py - <NAME> (<EMAIL>) - Feb 2015\n\n'''\nContains various useful tools for calculating various things related to\nlightcurves (like phasing, sigma-clipping, finding and filling gaps, etc.)\n\n'''\n\n#############\n## LOGGING ##\n#############\n\nimport logging\nfrom astrobase import log_sub, log_fmt, log_date_fmt\n\nDEBUG = False\nif DEBUG:\n    level = logging.DEBUG\nelse:\n    level = logging.INFO\nLOGGER = logging.getLogger(__name__)\nlogging.basicConfig(\n    level=level,\n    style=log_sub,\n    format=log_fmt,\n    datefmt=log_date_fmt,\n)\n\nLOGDEBUG = LOGGER.debug\nLOGINFO = LOGGER.info\nLOGWARNING = LOGGER.warning\nLOGERROR = LOGGER.error\nLOGEXCEPTION = LOGGER.exception\n\n\n#############\n## IMPORTS ##\n#############\n\nimport numpy as np\nfrom numpy import (\n    isfinite as npisfinite, median as npmedian, mean as npmean,\n    abs as npabs, std as npstddev\n)\n\nfrom scipy.spatial import cKDTree\nfrom scipy.signal import savgol_filter\nimport scipy.stats\n\n\n############################\n## NORMALIZING MAG SERIES ##\n############################\n\ndef find_lc_timegroups(lctimes, mingap=4.0):\n    '''Finds gaps in the provided time-series and indexes them into groups.\n\n    This finds the gaps in the provided `lctimes` array, so we can figure out\n    which times are for consecutive observations and which represent gaps\n    between seasons or observing eras.\n\n    Parameters\n    ----------\n\n    lctimes : array-like\n        This contains the times to analyze for gaps; assumed to be some form of\n        Julian date.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    Returns\n    -------\n\n    tuple\n        A tuple of the form: `(ngroups, [slice(start_ind_1, end_ind_1), ...])`\n        is returned.  This contains the number of groups as the first element,\n        and a list of Python `slice` objects for each time-group found. These\n        can be used directly to index into the array of times to quickly get\n        measurements associated with each group.\n\n    '''\n\n    lc_time_diffs = np.diff(lctimes)\n    group_start_indices = np.where(lc_time_diffs > mingap)[0]\n\n    if len(group_start_indices) > 0:\n\n        group_indices = []\n\n        for i, gindex in enumerate(group_start_indices):\n\n            if i == 0:\n                group_indices.append(slice(0,gindex+1))\n            else:\n                group_indices.append(slice(group_start_indices[i-1]+1,gindex+1))\n\n        # at the end, add the slice for the last group to the end of the times\n        # array\n        group_indices.append(slice(group_start_indices[-1]+1,len(lctimes)))\n\n    # if there's no large gap in the LC, then there's only one group to worry\n    # about\n    else:\n        group_indices = [slice(0,len(lctimes))]\n\n    return len(group_indices), group_indices\n\n\ndef normalize_magseries(times,\n                        mags,\n                        mingap=4.0,\n                        normto='globalmedian',\n                        magsarefluxes=False,\n                        debugmode=False):\n    '''This normalizes the magnitude time-series to a specified value.\n\n    This is used to normalize time series measurements that may have large time\n    gaps and vertical offsets in mag\/flux measurement between these\n    'timegroups', either due to instrument changes or different filters.\n\n    NOTE: this works in-place! The mags array will be replaced with normalized\n    mags when this function finishes.\n\n    Parameters\n    ----------\n\n    times,mags : array-like\n        The times (assumed to be some form of JD) and mags (or flux)\n        measurements to be normalized.\n\n    mingap : float\n        This defines how much the difference between consecutive measurements is\n        allowed to be to consider them as parts of different timegroups. By\n        default it is set to 4.0 days.\n\n    normto : {'globalmedian', 'zero'} or a float\n        Specifies the normalization type::\n\n          'globalmedian' -> norms each mag to the global median of the LC column\n          'zero'         -> norms each mag to zero\n          a float        -> norms each mag to this specified float value.\n\n    magsarefluxes : bool\n        Indicates if the input `mags` array is actually an array of flux\n        measurements instead of magnitude measurements. If this is set to True,\n        then:\n\n        - if `normto` is 'zero', then the median flux is divided from each\n          observation's flux value to yield normalized fluxes with 1.0 as the\n          global median.\n\n        - if `normto` is 'globalmedian', then the global median flux value\n          across the entire time series is multiplied with each measurement.\n\n        - if `norm` is set to a `float`, then this number is multiplied with the\n          flux value for each measurement.\n\n    debugmode : bool\n        If this is True, will print out verbose info on each timegroup found.\n\n    Returns\n    -------\n\n    times,normalized_mags : np.arrays\n        Normalized magnitude values after normalization. If normalization fails\n        for some reason, `times` and `normalized_mags` will both be None.\n\n    '''\n\n    ngroups, timegroups = find_lc_timegroups(times,\n                                             mingap=mingap)\n\n    # find all the non-nan indices\n    finite_ind = np.isfinite(mags)\n\n    if any(finite_ind):\n\n        # find the global median\n        global_mag_median = np.median(mags[finite_ind])\n\n        # go through the groups and normalize them to the median for\n        # each group\n        for tgind, tg in enumerate(timegroups):\n\n            finite_ind = np.isfinite(mags[tg])\n\n            # find this timegroup's median mag and normalize the mags in\n            # it to this median\n            group_median = np.median((mags[tg])[finite_ind])\n\n            if magsarefluxes:\n                mags[tg] = mags[tg]\/group_median\n            else:\n                mags[tg] = mags[tg] - group_median\n\n            if debugmode:\n                LOGDEBUG('group %s: elems %s, '\n                         'finite elems %s, median mag %s' %\n                         (tgind,\n                          len(mags[tg]),\n                          len(finite_ind),\n                          group_median))\n\n        # now that everything is normalized to 0.0, add the global median\n        # offset back to all the mags and write the result back to the dict\n        if isinstance(normto, str) and normto == 'globalmedian':\n\n            if magsarefluxes:\n                mags = mags * global_mag_median\n            else:\n                mags = mags + global_mag_median\n\n        # if the normto is a float, add everything to that float and return\n        elif isinstance(normto, float):\n\n            if magsarefluxes:\n                mags = mags * normto\n            else:\n                mags = mags + normto\n\n        # anything else just returns the normalized mags as usual\n        return times, mags\n\n    else:\n        LOGERROR('measurements are all nan!')\n        return None, None\n\n\n####################\n## SIGMA-CLIPPING ##\n####################\n\ndef sigclip_magseries(times, mags, errs,\n                      sigclip=None,\n                      iterative=False,\n                      niterations=None,\n                      meanormedian='median',\n                      magsarefluxes=False):\n    '''Sigma-clips a magnitude or flux time-series.\n\n    Selects the finite times, magnitudes (or fluxes), and errors from the passed\n    values, and apply symmetric or asymmetric sigma clipping to them.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude or flux time-series arrays to sigma-clip. This doesn't\n        assume all values are finite or if they're positive\/negative. All of\n        these arrays will have their non-finite elements removed, and then will\n        be sigma-clipped based on the arguments to this function.\n\n        `errs` is optional. Set it to None if you don't have values for these. A\n        'faked' `errs` array will be generated if necessary, which can be\n        ignored in the output as well.\n\n    sigclip : float or int or sequence of two floats\/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints\/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux\/mag values; the second element in this\n        list is the sigma value to use for brighter flux\/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    iterative : bool\n        If this is set to True, will perform iterative sigma-clipping. If\n        `niterations` is not set and this is True, sigma-clipping is iterated\n        until no more points are removed.\n\n    niterations : int\n        The maximum number of iterations to perform for sigma-clipping. If None,\n        the `iterative` arg takes precedence, and `iterative=True` will\n        sigma-clip until no more points are removed.  If `niterations` is not\n        None and `iterative` is False, `niterations` takes precedence and\n        iteration will occur for the specified number of iterations.\n\n    meanormedian : {'mean', 'median'}\n        Use 'mean' for sigma-clipping based on the mean value, or 'median' for\n        sigma-clipping based on the median value.  Default is 'median'.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    Returns\n    -------\n\n    (stimes, smags, serrs) : tuple\n        The sigma-clipped and nan-stripped time-series.\n\n    '''\n\n    returnerrs = True\n\n    # fake the errors if they don't exist\n    # this is inconsequential to sigma-clipping\n    # we don't return these dummy values if the input errs are None\n    if errs is None:\n        # assume 0.1% errors if not given\n        # this should work for mags and fluxes\n        errs = 0.001*mags\n        returnerrs = False\n\n    # filter the input times, mags, errs; do sigclipping and normalization\n    find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)\n    ftimes, fmags, ferrs = times[find], mags[find], errs[find]\n\n    # get the center value and stdev\n    if meanormedian == 'median':  # stddev = 1.483 x MAD\n\n        center_mag = npmedian(fmags)\n        stddev_mag = (npmedian(npabs(fmags - center_mag))) * 1.483\n\n    elif meanormedian == 'mean':\n\n        center_mag = npmean(fmags)\n        stddev_mag = npstddev(fmags)\n\n    else:\n        LOGWARNING(\"unrecognized meanormedian value given to \"\n                   \"sigclip_magseries: %s, defaulting to 'median'\" %\n                   meanormedian)\n        meanormedian = 'median'\n        center_mag = npmedian(fmags)\n        stddev_mag = (npmedian(npabs(fmags - center_mag))) * 1.483\n\n    # sigclip next for a single sigclip value\n    if sigclip and isinstance(sigclip, (float, int)):\n\n        if not iterative and niterations is None:\n\n            sigind = (npabs(fmags - center_mag)) < (sigclip * stddev_mag)\n\n            stimes = ftimes[sigind]\n            smags = fmags[sigind]\n            serrs = ferrs[sigind]\n\n        else:\n\n            #\n            # iterative version adapted from scipy.stats.sigmaclip\n            #\n\n            # First, if niterations is not set, iterate until covergence\n            if niterations is None:\n\n                delta = 1\n\n                this_times = ftimes\n                this_mags = fmags\n                this_errs = ferrs\n\n                while delta:\n\n                    if meanormedian == 'mean':\n                        this_center = npmean(this_mags)\n                        this_stdev = npstddev(this_mags)\n                    elif meanormedian == 'median':\n                        this_center = npmedian(this_mags)\n                        this_stdev = (\n                            npmedian(npabs(this_mags - this_center))\n                        ) * 1.483\n                    this_size = this_mags.size\n\n                    # apply the sigclip\n                    tsi = (\n                        (npabs(this_mags - this_center)) <\n                        (sigclip * this_stdev)\n                    )\n\n                    # update the arrays\n                    this_times = this_times[tsi]\n                    this_mags = this_mags[tsi]\n                    this_errs = this_errs[tsi]\n\n                    # update delta and go to the top of the loop\n                    delta = this_size - this_mags.size\n\n            else:  # If iterating only a certain number of times\n\n                this_times = ftimes\n                this_mags = fmags\n                this_errs = ferrs\n\n                iter_num = 0\n                delta = 1\n                while iter_num < niterations and delta:\n\n                    if meanormedian == 'mean':\n\n                        this_center = npmean(this_mags)\n                        this_stdev = npstddev(this_mags)\n\n                    elif meanormedian == 'median':\n\n                        this_center = npmedian(this_mags)\n                        this_stdev = (npmedian(npabs(this_mags -\n                                                     this_center))) * 1.483\n                    this_size = this_mags.size\n\n                    # apply the sigclip\n                    tsi = (\n                        (npabs(this_mags - this_center)) <\n                        (sigclip * this_stdev)\n                    )\n\n                    # update the arrays\n                    this_times = this_times[tsi]\n                    this_mags = this_mags[tsi]\n                    this_errs = this_errs[tsi]\n\n                    # update the number of iterations and delta and\n                    # go to the top of the loop\n                    delta = this_size - this_mags.size\n                    iter_num += 1\n\n            # final sigclipped versions\n            stimes, smags, serrs = this_times, this_mags, this_errs\n\n    # this handles sigclipping for asymmetric +ve and -ve clip values\n    elif sigclip and isinstance(sigclip, (list,tuple)) and len(sigclip) == 2:\n\n        # sigclip is passed as [dimmingclip, brighteningclip]\n        dimmingclip = sigclip[0]\n        brighteningclip = sigclip[1]\n\n        if not iterative and niterations is None:\n\n            if magsarefluxes:\n                nottoodimind = (\n                    (fmags - center_mag) > (-dimmingclip*stddev_mag)\n                )\n                nottoobrightind = (\n                    (fmags - center_mag) < (brighteningclip*stddev_mag)\n                )\n            else:\n                nottoodimind = (\n                    (fmags - center_mag) < (dimmingclip*stddev_mag)\n                )\n                nottoobrightind = (\n                    (fmags - center_mag) > (-brighteningclip*stddev_mag)\n                )\n\n            sigind = nottoodimind & nottoobrightind\n\n            stimes = ftimes[sigind]\n            smags = fmags[sigind]\n            serrs = ferrs[sigind]\n\n        else:\n\n            #\n            # iterative version adapted from scipy.stats.sigmaclip\n            #\n            if niterations is None:\n\n                delta = 1\n\n                this_times = ftimes\n                this_mags = fmags\n                this_errs = ferrs\n\n                while delta:\n\n                    if meanormedian == 'mean':\n\n                        this_center = npmean(this_mags)\n                        this_stdev = npstddev(this_mags)\n\n                    elif meanormedian == 'median':\n                        this_center = npmedian(this_mags)\n                        this_stdev = (npmedian(npabs(this_mags -\n                                                     this_center))) * 1.483\n                    this_size = this_mags.size\n\n                    if magsarefluxes:\n                        nottoodimind = (\n                            (this_mags - this_center) >\n                            (-dimmingclip*this_stdev)\n                        )\n                        nottoobrightind = (\n                            (this_mags - this_center) <\n                            (brighteningclip*this_stdev)\n                        )\n                    else:\n                        nottoodimind = (\n                            (this_mags - this_center) <\n                            (dimmingclip*this_stdev)\n                        )\n                        nottoobrightind = (\n                            (this_mags - this_center) >\n                            (-brighteningclip*this_stdev)\n                        )\n\n                    # apply the sigclip\n                    tsi = nottoodimind & nottoobrightind\n\n                    # update the arrays\n                    this_times = this_times[tsi]\n                    this_mags = this_mags[tsi]\n                    this_errs = this_errs[tsi]\n\n                    # update delta and go to top of the loop\n                    delta = this_size - this_mags.size\n\n            else:  # If iterating only a certain number of times\n                this_times = ftimes\n                this_mags = fmags\n                this_errs = ferrs\n\n                iter_num = 0\n                delta = 1\n\n                while iter_num < niterations and delta:\n\n                    if meanormedian == 'mean':\n                        this_center = npmean(this_mags)\n                        this_stdev = npstddev(this_mags)\n                    elif meanormedian == 'median':\n                        this_center = npmedian(this_mags)\n                        this_stdev = (npmedian(npabs(this_mags -\n                                                     this_center))) * 1.483\n                    this_size = this_mags.size\n\n                    if magsarefluxes:\n                        nottoodimind = (\n                            (this_mags - this_center) >\n                            (-dimmingclip*this_stdev)\n                        )\n                        nottoobrightind = (\n                            (this_mags - this_center) <\n                            (brighteningclip*this_stdev)\n                        )\n                    else:\n                        nottoodimind = (\n                            (this_mags - this_center) < (dimmingclip*this_stdev)\n                        )\n                        nottoobrightind = (\n                            (this_mags - this_center) >\n                            (-brighteningclip*this_stdev)\n                        )\n\n                    # apply the sigclip\n                    tsi = nottoodimind & nottoobrightind\n\n                    # update the arrays\n                    this_times = this_times[tsi]\n                    this_mags = this_mags[tsi]\n                    this_errs = this_errs[tsi]\n\n                    # update the number of iterations and delta\n                    # and go to top of the loop\n                    delta = this_size - this_mags.size\n                    iter_num += 1\n\n            # final sigclipped versions\n            stimes, smags, serrs = this_times, this_mags, this_errs\n\n    else:\n\n        stimes = ftimes\n        smags = fmags\n        serrs = ferrs\n\n    if returnerrs:\n        return stimes, smags, serrs\n    else:\n        return stimes, smags, None\n\n\ndef sigclip_magseries_with_extparams(times, mags, errs, extparams,\n                                     sigclip=None,\n                                     iterative=False,\n                                     magsarefluxes=False):\n    '''Sigma-clips a magnitude or flux time-series and associated measurement\n    arrays.\n\n    Selects the finite times, magnitudes (or fluxes), and errors from the passed\n    values, and apply symmetric or asymmetric sigma clipping to them.  Uses the\n    same array indices as these values to filter out the values of all arrays in\n    the `extparams` list. This can be useful for simultaneously sigma-clipping a\n    magnitude\/flux time-series along with their associated values of external\n    parameters, such as telescope hour angle, zenith distance, temperature, moon\n    phase, etc.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude or flux time-series arrays to sigma-clip. This doesn't\n        assume all values are finite or if they're positive\/negative. All of\n        these arrays will have their non-finite elements removed, and then will\n        be sigma-clipped based on the arguments to this function.\n\n        `errs` is optional. Set it to None if you don't have values for these. A\n        'faked' `errs` array will be generated if necessary, which can be\n        ignored in the output as well.\n\n    extparams : list of np.array\n        This is a list of all external parameter arrays to simultaneously filter\n        along with the magnitude\/flux time-series. All of these arrays should\n        have the same length as the `times`, `mags`, and `errs` arrays.\n\n    sigclip : float or int or sequence of two floats\/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints\/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux\/mag values; the second element in this\n        list is the sigma value to use for brighter flux\/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    iterative : bool\n        If this is set to True, will perform iterative sigma-clipping. If\n        `niterations` is not set and this is True, sigma-clipping is iterated\n        until no more points are removed.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    Returns\n    -------\n\n    (stimes, smags, serrs) : tuple\n        The sigma-clipped and nan-stripped time-series in `stimes`, `smags`,\n        `serrs` and the associated values of the `extparams` in `sextparams`.\n\n    '''\n\n    returnerrs = True\n\n    # fake the errors if they don't exist\n    # this is inconsequential to sigma-clipping\n    # we don't return these dummy values if the input errs are None\n    if errs is None:\n        # assume 0.1% errors if not given\n        # this should work for mags and fluxes\n        errs = 0.001*mags\n        returnerrs = False\n\n    # filter the input times, mags, errs; do sigclipping and normalization\n    find = npisfinite(times) & npisfinite(mags) & npisfinite(errs)\n    ftimes, fmags, ferrs = times[find], mags[find], errs[find]\n\n    # apply the same indices to the external parameters\n    for epi, eparr in enumerate(extparams):\n        extparams[epi] = eparr[find]\n\n    # get the median and stdev = 1.483 x MAD\n    median_mag = npmedian(fmags)\n    stddev_mag = (npmedian(npabs(fmags - median_mag))) * 1.483\n\n    # sigclip next for a single sigclip value\n    if sigclip and isinstance(sigclip, (float, int)):\n\n        if not iterative:\n\n            sigind = (npabs(fmags - median_mag)) < (sigclip * stddev_mag)\n\n            stimes = ftimes[sigind]\n            smags = fmags[sigind]\n            serrs = ferrs[sigind]\n\n            # apply the same indices to the external parameters\n            for epi, eparr in enumerate(extparams):\n                extparams[epi] = eparr[sigind]\n\n        else:\n\n            #\n            # iterative version adapted from scipy.stats.sigmaclip\n            #\n            delta = 1\n\n            this_times = ftimes\n            this_mags = fmags\n            this_errs = ferrs\n\n            while delta:\n\n                this_median = npmedian(this_mags)\n                this_stdev = (npmedian(npabs(this_mags - this_median))) * 1.483\n                this_size = this_mags.size\n\n                # apply the sigclip\n                tsi = (npabs(this_mags - this_median)) < (sigclip * this_stdev)\n\n                # update the arrays\n                this_times = this_times[tsi]\n                this_mags = this_mags[tsi]\n                this_errs = this_errs[tsi]\n\n                # apply the same indices to the external parameters\n                for epi, eparr in enumerate(extparams):\n                    extparams[epi] = eparr[tsi]\n\n                # update delta and go to the top of the loop\n                delta = this_size - this_mags.size\n\n            # final sigclipped versions\n            stimes, smags, serrs = this_times, this_mags, this_errs\n\n    # this handles sigclipping for asymmetric +ve and -ve clip values\n    elif sigclip and isinstance(sigclip, (list, tuple)) and len(sigclip) == 2:\n\n        # sigclip is passed as [dimmingclip, brighteningclip]\n        dimmingclip = sigclip[0]\n        brighteningclip = sigclip[1]\n\n        if not iterative:\n\n            if magsarefluxes:\n                nottoodimind = (\n                    (fmags - median_mag) > (-dimmingclip*stddev_mag)\n                )\n                nottoobrightind = (\n                    (fmags - median_mag) < (brighteningclip*stddev_mag)\n                )\n            else:\n                nottoodimind = (\n                    (fmags - median_mag) < (dimmingclip*stddev_mag)\n                )\n                nottoobrightind = (\n                    (fmags - median_mag) > (-brighteningclip*stddev_mag)\n                )\n\n            sigind = nottoodimind & nottoobrightind\n\n            stimes = ftimes[sigind]\n            smags = fmags[sigind]\n            serrs = ferrs[sigind]\n\n            # apply the same indices to the external parameters\n            for epi, eparr in enumerate(extparams):\n                extparams[epi] = eparr[sigind]\n\n        else:\n\n            #\n            # iterative version adapted from scipy.stats.sigmaclip\n            #\n            delta = 1\n\n            this_times = ftimes\n            this_mags = fmags\n            this_errs = ferrs\n\n            while delta:\n\n                this_median = npmedian(this_mags)\n                this_stdev = (npmedian(npabs(this_mags - this_median))) * 1.483\n                this_size = this_mags.size\n\n                if magsarefluxes:\n                    nottoodimind = (\n                        (this_mags - this_median) > (-dimmingclip*this_stdev)\n                    )\n                    nottoobrightind = (\n                        (this_mags - this_median) < (brighteningclip*this_stdev)\n                    )\n                else:\n                    nottoodimind = (\n                        (this_mags - this_median) < (dimmingclip*this_stdev)\n                    )\n                    nottoobrightind = (\n                        (this_mags - this_median) >\n                        (-brighteningclip*this_stdev)\n                    )\n\n                # apply the sigclip\n                tsi = nottoodimind & nottoobrightind\n\n                # update the arrays\n                this_times = this_times[tsi]\n                this_mags = this_mags[tsi]\n                this_errs = this_errs[tsi]\n\n                # apply the same indices to the external parameters\n                for epi, eparr in enumerate(extparams):\n                    extparams[epi] = eparr[tsi]\n\n                # update delta and go to top of the loop\n                delta = this_size - this_mags.size\n\n            # final sigclipped versions\n            stimes, smags, serrs = this_times, this_mags, this_errs\n\n    else:\n\n        stimes = ftimes\n        smags = fmags\n        serrs = ferrs\n\n    if returnerrs:\n        return stimes, smags, serrs, extparams\n    else:\n        return stimes, smags, None, extparams\n\n\n#################\n## PHASING LCS ##\n#################\n\ndef phase_magseries(times, mags, period, epoch, wrap=True, sort=True):\n    '''Phases a magnitude\/flux time-series using a given period and epoch.\n\n    The equation used is::\n\n        phase = (times - epoch)\/period - floor((times - epoch)\/period)\n\n    This phases the given magnitude timeseries using the given period and\n    epoch. If wrap is True, wraps the result around 0.0 (and returns an array\n    that has twice the number of the original elements). If sort is True,\n    returns the magnitude timeseries in phase sorted order.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The magnitude\/flux time-series values to phase using the provided\n        `period` and `epoch`. Non-fiinite values will be removed.\n\n    period : float\n        The period to use to phase the time-series.\n\n    epoch : float\n        The epoch to phase the time-series. This is usually the time-of-minimum\n        or time-of-maximum of some periodic light curve\n        phenomenon. Alternatively, one can use the minimum time value in\n        `times`.\n\n    wrap : bool\n        If this is True, the returned phased time-series will be wrapped around\n        phase 0.0, which is useful for plotting purposes. The arrays returned\n        will have twice the number of input elements because of this wrapping.\n\n    sort : bool\n        If this is True, the returned phased time-series will be sorted in\n        increasing phase order.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phase': the phase values,\n             'mags': the mags\/flux values at each phase,\n             'period': the input `period` used to phase the time-series,\n             'epoch': the input `epoch` used to phase the time-series}\n\n    '''\n\n    # find all the finite values of the magnitudes and times\n    finiteind = np.isfinite(mags) & np.isfinite(times)\n\n    finite_times = times[finiteind]\n    finite_mags = mags[finiteind]\n\n    magseries_phase = (\n        (finite_times - epoch)\/period -\n        np.floor(((finite_times - epoch)\/period))\n    )\n\n    outdict = {'phase':magseries_phase,\n               'mags':finite_mags,\n               'period':period,\n               'epoch':epoch}\n\n    if sort:\n        sortorder = np.argsort(outdict['phase'])\n        outdict['phase'] = outdict['phase'][sortorder]\n        outdict['mags'] = outdict['mags'][sortorder]\n\n    if wrap:\n        outdict['phase'] = np.concatenate((outdict['phase']-1.0,\n                                           outdict['phase']))\n        outdict['mags'] = np.concatenate((outdict['mags'],\n                                          outdict['mags']))\n\n    return outdict\n\n\ndef phase_magseries_with_errs(times, mags, errs, period, epoch,\n                              wrap=True, sort=True):\n    '''Phases a magnitude\/flux time-series using a given period and epoch.\n\n    The equation used is::\n\n        phase = (times - epoch)\/period - floor((times - epoch)\/period)\n\n    This phases the given magnitude timeseries using the given period and\n    epoch. If wrap is True, wraps the result around 0.0 (and returns an array\n    that has twice the number of the original elements). If sort is True,\n    returns the magnitude timeseries in phase sorted order.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude\/flux time-series values and associated measurement errors\n        to phase using the provided `period` and `epoch`. Non-fiinite values\n        will be removed.\n\n    period : float\n        The period to use to phase the time-series.\n\n    epoch : float\n        The epoch to phase the time-series. This is usually the time-of-minimum\n        or time-of-maximum of some periodic light curve\n        phenomenon. Alternatively, one can use the minimum time value in\n        `times`.\n\n    wrap : bool\n        If this is True, the returned phased time-series will be wrapped around\n        phase 0.0, which is useful for plotting purposes. The arrays returned\n        will have twice the number of input elements because of this wrapping.\n\n    sort : bool\n        If this is True, the returned phased time-series will be sorted in\n        increasing phase order.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phase': the phase values,\n             'mags': the mags\/flux values at each phase,\n             'errs': the err values at each phase,\n             'period': the input `period` used to phase the time-series,\n             'epoch': the input `epoch` used to phase the time-series}\n\n    '''\n\n    # find all the finite values of the magnitudes and times\n    finiteind = np.isfinite(mags)\n    finite_times = times[finiteind]\n    finite_mags = mags[finiteind]\n    finite_errs = errs[finiteind]\n\n    magseries_phase = (\n        (finite_times - epoch)\/period -\n        np.floor(((finite_times - epoch)\/period))\n    )\n\n    outdict = {'phase':magseries_phase,\n               'mags':finite_mags,\n               'errs':finite_errs,\n               'period':period,\n               'epoch':epoch}\n\n    if sort:\n        sortorder = np.argsort(outdict['phase'])\n        outdict['phase'] = outdict['phase'][sortorder]\n        outdict['mags'] = outdict['mags'][sortorder]\n        outdict['errs'] = outdict['errs'][sortorder]\n\n    if wrap:\n        outdict['phase'] = np.concatenate((outdict['phase']-1.0,\n                                           outdict['phase']))\n        outdict['mags'] = np.concatenate((outdict['mags'],\n                                          outdict['mags']))\n        outdict['errs'] = np.concatenate((outdict['errs'],\n                                          outdict['errs']))\n\n    return outdict\n\n\n#################\n## BINNING LCs ##\n#################\n\ndef time_bin_magseries(times, mags,\n                       binsize=540.0,\n                       minbinelems=7):\n    '''Bins the given mag\/flux time-series in time using the bin size given.\n\n    Parameters\n    ----------\n\n    times,mags : np.array\n        The magnitude\/flux time-series to bin in time. Non-finite elements will\n        be removed from these arrays. At least 10 elements in each array are\n        required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in time. This is in seconds.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'jdbin_indices': a list of the index arrays into the nan-filtered\n                              input arrays per each bin,\n             'jdbins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedtimes': the time values associated with each time bin;\n                            this is the median of the times in each bin,\n             'binnedmags': the mag\/flux values associated with each time bin;\n                           this is the median of the mags\/fluxes in each bin}\n\n    '''\n\n    # check if the input arrays are ok\n    if not(times.shape and mags.shape and len(times) > 9 and len(mags) > 9):\n\n        LOGERROR(\"input time\/mag arrays don't have enough elements\")\n        return\n\n    # find all the finite values of the magnitudes and times\n    finiteind = np.isfinite(mags) & np.isfinite(times)\n    finite_times = times[finiteind]\n    finite_mags = mags[finiteind]\n\n    # convert binsize in seconds to JD units\n    binsizejd = binsize\/(86400.0)\n    nbins = int(np.ceil((np.nanmax(finite_times) -\n                         np.nanmin(finite_times))\/binsizejd) + 1)\n\n    minjd = np.nanmin(finite_times)\n    jdbins = [(minjd + x*binsizejd) for x in range(nbins)]\n\n    # make a KD-tree on the JDs so we can do fast distance calculations.  we\n    # need to add a bogus y coord to make this a problem that KD-trees can\n    # solve.\n    time_coords = np.array([[x,1.0] for x in finite_times])\n    jdtree = cKDTree(time_coords)\n    binned_finite_timeseries_indices = []\n\n    collected_binned_mags = {}\n\n    for jd in jdbins:\n        # find all bin indices close to within binsizejd of this point\n        # using the cKDTree query. we use the p-norm = 1 (I think this\n        # means straight-up pairwise distance? FIXME: check this)\n        bin_indices = jdtree.query_ball_point(np.array([jd,1.0]),\n                                              binsizejd\/2.0, p=1.0)\n\n        # if the bin_indices have already been collected, then we're\n        # done with this bin, move to the next one. if they haven't,\n        # then this is the start of a new bin.\n        if (bin_indices not in binned_finite_timeseries_indices and\n            len(bin_indices) >= minbinelems):\n\n            binned_finite_timeseries_indices.append(bin_indices)\n\n    # convert to ndarrays\n    binned_finite_timeseries_indices = [np.array(x) for x in\n                                        binned_finite_timeseries_indices]\n\n    collected_binned_mags['jdbins_indices'] = binned_finite_timeseries_indices\n    collected_binned_mags['jdbins'] = jdbins\n    collected_binned_mags['nbins'] = len(binned_finite_timeseries_indices)\n\n    # collect the finite_times\n    binned_jd = np.array([np.median(finite_times[x])\n                          for x in binned_finite_timeseries_indices])\n    collected_binned_mags['binnedtimes'] = binned_jd\n    collected_binned_mags['binsize'] = binsize\n\n    # median bin the magnitudes according to the calculated indices\n    collected_binned_mags['binnedmags'] = (\n        np.array([np.median(finite_mags[x])\n                  for x in binned_finite_timeseries_indices])\n    )\n\n    return collected_binned_mags\n\n\ndef time_bin_magseries_with_errs(times, mags, errs,\n                                 binsize=540.0,\n                                 minbinelems=7):\n    '''Bins the given mag\/flux time-series in time using the bin size given.\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude\/flux time-series and associated measurement errors to bin\n        in time. Non-finite elements will be removed from these arrays. At least\n        10 elements in each array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in time. This is in seconds.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'jdbin_indices': a list of the index arrays into the nan-filtered\n                              input arrays per each bin,\n             'jdbins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedtimes': the time values associated with each time bin;\n                            this is the median of the times in each bin,\n             'binnedmags': the mag\/flux values associated with each time bin;\n                           this is the median of the mags\/fluxes in each bin,\n             'binnederrs': the err values associated with each time bin;\n                           this is the median of the errs in each bin}\n\n    '''\n\n    # check if the input arrays are ok\n    if not(times.shape and mags.shape and errs.shape and\n           len(times) > 9 and len(mags) > 9):\n\n        LOGERROR(\"input time\/mag\/err arrays don't have enough elements\")\n        return\n\n    # find all the finite values of the magnitudes and times\n    finiteind = np.isfinite(mags) & np.isfinite(times) & np.isfinite(errs)\n    finite_times = times[finiteind]\n    finite_mags = mags[finiteind]\n    finite_errs = errs[finiteind]\n\n    # convert binsize in seconds to JD units\n    binsizejd = binsize\/(86400.0)\n    nbins = int(np.ceil((np.nanmax(finite_times) -\n                         np.nanmin(finite_times))\/binsizejd) + 1)\n\n    minjd = np.nanmin(finite_times)\n    jdbins = [(minjd + x*binsizejd) for x in range(nbins)]\n\n    # make a KD-tree on the JDs so we can do fast distance calculations.  we\n    # need to add a bogus y coord to make this a problem that KD-trees can\n    # solve.\n    time_coords = np.array([[x,1.0] for x in finite_times])\n    jdtree = cKDTree(time_coords)\n    binned_finite_timeseries_indices = []\n\n    collected_binned_mags = {}\n\n    for jd in jdbins:\n\n        # find all bin indices close to within binsize of this point using the\n        # cKDTree query. we use the p-norm = 1 for pairwise Euclidean distance.\n        bin_indices = jdtree.query_ball_point(np.array([jd,1.0]),\n                                              binsizejd\/2.0, p=1.0)\n\n        # if the bin_indices have already been collected, then we're\n        # done with this bin, move to the next one. if they haven't,\n        # then this is the start of a new bin.\n        if (bin_indices not in binned_finite_timeseries_indices and\n            len(bin_indices) >= minbinelems):\n\n            binned_finite_timeseries_indices.append(bin_indices)\n\n    # convert to ndarrays\n    binned_finite_timeseries_indices = [np.array(x) for x in\n                                        binned_finite_timeseries_indices]\n\n    collected_binned_mags['jdbins_indices'] = binned_finite_timeseries_indices\n    collected_binned_mags['jdbins'] = np.array(jdbins)\n    collected_binned_mags['nbins'] = len(binned_finite_timeseries_indices)\n\n    # collect the finite_times\n    binned_jd = np.array([np.median(finite_times[x])\n                          for x in binned_finite_timeseries_indices])\n    collected_binned_mags['binnedtimes'] = binned_jd\n    collected_binned_mags['binsize'] = binsize\n\n    # median bin the magnitudes according to the calculated indices\n    collected_binned_mags['binnedmags'] = (\n        np.array([np.median(finite_mags[x])\n                  for x in binned_finite_timeseries_indices])\n    )\n\n    # FIXME: calculate the error in the median-binned magnitude correctly\n    # for now, just take the median of the errors in this bin\n    collected_binned_mags['binnederrs'] = (\n        np.array([np.median(finite_errs[x])\n                  for x in binned_finite_timeseries_indices])\n    )\n\n    return collected_binned_mags\n\n\ndef phase_bin_magseries(phases, mags,\n                        binsize=0.005,\n                        minbinelems=7):\n    '''Bins a phased magnitude\/flux time-series using the bin size provided.\n\n    Parameters\n    ----------\n\n    phases,mags : np.array\n        The phased magnitude\/flux time-series to bin in phase. Non-finite\n        elements will be removed from these arrays. At least 10 elements in each\n        array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phasebin_indices': a list of the index arrays into the\n                                 nan-filtered input arrays per each bin,\n             'phasebins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedphases': the phase values associated with each phase bin;\n                            this is the median of the phase value in each bin,\n             'binnedmags': the mag\/flux values associated with each phase bin;\n                           this is the median of the mags\/fluxes in each bin}\n\n    '''\n\n    # check if the input arrays are ok\n    if not(phases.shape and mags.shape and len(phases) > 10 and len(mags) > 10):\n\n        LOGERROR(\"input time\/mag arrays don't have enough elements\")\n        return\n\n    # find all the finite values of the magnitudes and phases\n    finiteind = np.isfinite(mags) & np.isfinite(phases)\n    finite_phases = phases[finiteind]\n    finite_mags = mags[finiteind]\n\n    nbins = int(np.ceil((np.nanmax(finite_phases) -\n                         np.nanmin(finite_phases))\/binsize) + 1)\n\n    minphase = np.nanmin(finite_phases)\n    phasebins = [(minphase + x*binsize) for x in range(nbins)]\n\n    # make a KD-tree on the PHASEs so we can do fast distance calculations.  we\n    # need to add a bogus y coord to make this a problem that KD-trees can\n    # solve.\n    time_coords = np.array([[x,1.0] for x in finite_phases])\n    phasetree = cKDTree(time_coords)\n    binned_finite_phaseseries_indices = []\n\n    collected_binned_mags = {}\n\n    for phase in phasebins:\n\n        # find all bin indices close to within binsize of this point using the\n        # cKDTree query. we use the p-norm = 1 for pairwise Euclidean distance.\n        bin_indices = phasetree.query_ball_point(np.array([phase,1.0]),\n                                                 binsize\/2.0, p=1.0)\n\n        # if the bin_indices have already been collected, then we're\n        # done with this bin, move to the next one. if they haven't,\n        # then this is the start of a new bin.\n        if (bin_indices not in binned_finite_phaseseries_indices and\n            len(bin_indices) >= minbinelems):\n\n            binned_finite_phaseseries_indices.append(bin_indices)\n\n    # convert to ndarrays\n    binned_finite_phaseseries_indices = [np.array(x) for x in\n                                         binned_finite_phaseseries_indices]\n\n    collected_binned_mags['phasebins_indices'] = (\n        binned_finite_phaseseries_indices\n    )\n    collected_binned_mags['phasebins'] = phasebins\n    collected_binned_mags['nbins'] = len(binned_finite_phaseseries_indices)\n\n    # collect the finite_phases\n    binned_phase = np.array([np.median(finite_phases[x])\n                             for x in binned_finite_phaseseries_indices])\n    collected_binned_mags['binnedphases'] = binned_phase\n    collected_binned_mags['binsize'] = binsize\n\n    # median bin the magnitudes according to the calculated indices\n    collected_binned_mags['binnedmags'] = (\n        np.array([np.median(finite_mags[x])\n                  for x in binned_finite_phaseseries_indices])\n    )\n\n    return collected_binned_mags\n\n\ndef phase_bin_magseries_with_errs(phases, mags, errs,\n                                  binsize=0.005,\n                                  minbinelems=7,\n                                  weights=None):\n    '''Bins a phased magnitude\/flux time-series using the bin size provided.\n\n    Parameters\n    ----------\n\n    phases,mags,errs : np.array\n        The phased magnitude\/flux time-series and associated errs to bin in\n        phase. Non-finite elements will be removed from these arrays. At least\n        10 elements in each array are required for this function to operate.\n\n    binsize : float\n        The bin size to use to group together measurements closer than this\n        amount in phase. This is in units of phase.\n\n    minbinelems : int\n        The minimum number of elements required per bin to include it in the\n        output.\n\n    weights : np.array or None\n        Optional weight vector to be applied during binning. If if is passed,\n        `np.average` is used to bin, rather than `np.median`. A good choice\n        would be to pass ``weights=1\/errs**2``, to weight by the inverse variance.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'phasebin_indices': a list of the index arrays into the\n                                 nan-filtered input arrays per each bin,\n             'phasebins': list of bin boundaries for each bin,\n             'nbins': the number of bins generated,\n             'binnedphases': the phase values associated with each phase bin;\n                            this is the median of the phase value in each bin,\n             'binnedmags': the mag\/flux values associated with each phase bin;\n                           this is the median of the mags\/fluxes in each bin,\n             'binnederrs': the err values associated with each phase bin;\n                           this is the median of the errs in each bin}\n\n    '''\n\n    # check if the input arrays are ok\n    if not(phases.shape and mags.shape and len(phases) > 10 and len(mags) > 10):\n\n        LOGERROR(\"input time\/mag arrays don't have enough elements\")\n        return\n\n    # find all the finite values of the magnitudes and phases\n    finiteind = np.isfinite(mags) & np.isfinite(phases) & np.isfinite(errs)\n    finite_phases = phases[finiteind]\n    finite_mags = mags[finiteind]\n    finite_errs = errs[finiteind]\n    if weights is not None and len(weights) > 10:\n        finite_weights = weights[finiteind]\n    else:\n        finite_weights = None\n\n    nbins = int(np.ceil((np.nanmax(finite_phases) -\n                         np.nanmin(finite_phases))\/binsize) + 1)\n\n    minphase = np.nanmin(finite_phases)\n    phasebins = [(minphase + x*binsize) for x in range(nbins)]\n\n    # make a KD-tree on the PHASEs so we can do fast distance calculations.  we\n    # need to add a bogus y coord to make this a problem that KD-trees can\n    # solve.\n    time_coords = np.array([[x,1.0] for x in finite_phases])\n    phasetree = cKDTree(time_coords)\n    binned_finite_phaseseries_indices = []\n\n    collected_binned_mags = {}\n\n    for phase in phasebins:\n\n        # find all bin indices close to within binsize of this point using the\n        # cKDTree query. we use the p-norm = 1 for pairwise Euclidean distance.\n        bin_indices = phasetree.query_ball_point(np.array([phase,1.0]),\n                                                 binsize\/2.0, p=1.0)\n\n        # if the bin_indices have already been collected, then we're\n        # done with this bin, move to the next one. if they haven't,\n        # then this is the start of a new bin.\n        if (bin_indices not in binned_finite_phaseseries_indices and\n            len(bin_indices) >= minbinelems):\n\n            binned_finite_phaseseries_indices.append(bin_indices)\n\n    # convert to ndarrays\n    binned_finite_phaseseries_indices = [np.array(x) for x in\n                                         binned_finite_phaseseries_indices]\n\n    collected_binned_mags['phasebins_indices'] = (\n        binned_finite_phaseseries_indices\n    )\n    collected_binned_mags['phasebins'] = phasebins\n    collected_binned_mags['nbins'] = len(binned_finite_phaseseries_indices)\n\n    # collect the finite_phases\n    binned_phase = np.array([np.median(finite_phases[x])\n                             for x in binned_finite_phaseseries_indices])\n    collected_binned_mags['binnedphases'] = binned_phase\n    collected_binned_mags['binsize'] = binsize\n\n    # median bin the magnitudes according to the calculated indices\n    if finite_weights is None:\n        collected_binned_mags['binnedmags'] = (\n            np.array([np.median(finite_mags[x])\n                      for x in binned_finite_phaseseries_indices])\n        )\n    else:\n        collected_binned_mags['binnedmags'] = (\n            np.array([np.average(finite_mags[x], weights=finite_weights[x])\n                      for x in binned_finite_phaseseries_indices])\n        )\n\n    collected_binned_mags['binnederrs'] = (\n        np.array([np.median(finite_errs[x])\n                  for x in binned_finite_phaseseries_indices])\n    )\n\n    return collected_binned_mags\n\n\n#############################\n## FILLING TIMESERIES GAPS ##\n#############################\n\ndef fill_magseries_gaps(times, mags, errs,\n                        fillgaps=0.0,\n                        sigclip=3.0,\n                        magsarefluxes=False,\n                        filterwindow=11,\n                        forcetimebin=None,\n                        verbose=True):\n    '''This fills in gaps in a light curve.\n\n    This is mainly intended for use in ACF period-finding, but maybe useful\n    otherwise (i.e. when we figure out ARMA stuff for LCs). The main steps here\n    are:\n\n    - normalize the light curve to zero\n    - remove giant outliers\n    - interpolate gaps in the light curve\n      (since ACF requires evenly spaced sampling)\n\n    From McQuillan+ 2013a (https:\/\/doi.org\/10.1093\/mnras\/stt536):\n\n        \"The ACF calculation requires the light curves to be regularly sampled\n        and normalized to zero. We divided the flux in each quarter by its\n        median and subtracted unity. Gaps in the light curve longer than the\n        Kepler long cadence were filled using linear interpolation with added\n        white Gaussian noise. This noise level was estimated using the variance\n        of the residuals following subtraction of a smoothed version of the\n        flux. To smooth the flux, we applied an iterative non-linear filter\n        which consists of a median filter followed by a boxcar filter, both with\n        11-point windows, with iterative 3σ clipping of outliers.\"\n\n    Parameters\n    ----------\n\n    times,mags,errs : np.array\n        The magnitude\/flux time-series and associated measurement errors to\n        operate on. Non-finite elements will be removed from these arrays. At\n        least 10 elements in each array are required for this function to\n        operate.\n\n    fillgaps : {'noiselevel', 'nan'} or float\n        If `fillgap='noiselevel'`, fills the gaps with the noise level obtained\n        via the procedure above. If `fillgaps='nan'`, fills the gaps with\n        `np.nan`. Otherwise, if `fillgaps` is a float, will use that value to\n        fill the gaps. The default is to fill the gaps with 0.0 (as in\n        McQuillan+ 2014) to \"...prevent them contributing to the ACF\".\n\n    sigclip : float or int or sequence of two floats\/ints or None\n        If a single float or int, a symmetric sigma-clip will be performed using\n        the number provided as the sigma-multiplier to cut out from the input\n        time-series.\n\n        If a list of two ints\/floats is provided, the function will perform an\n        'asymmetric' sigma-clip. The first element in this list is the sigma\n        value to use for fainter flux\/mag values; the second element in this\n        list is the sigma value to use for brighter flux\/mag values. For\n        example, `sigclip=[10., 3.]`, will sigclip out greater than 10-sigma\n        dimmings and greater than 3-sigma brightenings. Here the meaning of\n        \"dimming\" and \"brightening\" is set by *physics* (not the magnitude\n        system), which is why the `magsarefluxes` kwarg must be correctly set.\n\n        If `sigclip` is None, no sigma-clipping will be performed, and the\n        time-series (with non-finite elems removed) will be passed through to\n        the output.\n\n    magsareflux : bool\n        True if your \"mags\" are in fact fluxes, i.e. if \"fainter\" corresponds to\n        `mags` getting smaller.\n\n    filterwindow : int\n        The number of time-series points to include in the Savitsky-Golay filter\n        operation when smoothing the light curve. This should be an odd integer.\n\n    forcetimebin : float or None\n        If `forcetimebin` is a float, this value will be used to generate the\n        interpolated time series, effectively binning the light curve to this\n        cadence. If `forcetimebin` is None, the mode of the gaps (the forward\n        difference between successive time values in `times`) in the provided\n        light curve will be used as the effective cadence. NOTE: `forcetimebin`\n        must be in the same units as `times`, e.g. if times are JD then\n        `forcetimebin` must be in days as well\n\n    verbose : bool\n        If this is True, will indicate progress at various stages in the\n        operation.\n\n    Returns\n    -------\n\n    dict\n        A dict of the following form is returned::\n\n            {'itimes': the interpolated time values after gap-filling,\n             'imags': the interpolated mag\/flux values after gap-filling,\n             'ierrs': the interpolated mag\/flux values after gap-filling,\n             'cadence': the cadence of the output mag\/flux time-series}\n\n    '''\n\n    # remove nans\n    finind = np.isfinite(times) & np.isfinite(mags) & np.isfinite(errs)\n    ftimes, fmags, ferrs = times[finind], mags[finind], errs[finind]\n\n    # remove zero errs\n    nzind = np.nonzero(ferrs)\n    ftimes, fmags, ferrs = ftimes[nzind], fmags[nzind], ferrs[nzind]\n\n    # sigma-clip\n    stimes, smags, serrs = sigclip_magseries(ftimes, fmags, ferrs,\n                                             magsarefluxes=magsarefluxes,\n                                             sigclip=sigclip)\n\n    # normalize to zero\n    if magsarefluxes:\n        smags = smags \/ np.median(smags) - 1.0\n    else:\n        smags = smags - np.median(smags)\n\n    if isinstance(fillgaps, float):\n\n        gapfiller = fillgaps\n\n    elif isinstance(fillgaps, str) and fillgaps == 'noiselevel':\n\n        # figure out the gaussian noise level by subtracting a Savitsky-Golay\n        # filtered version of the light curve\n        smoothed = smags - savgol_filter(smags, filterwindow, 2)\n        noiselevel = 1.483 * np.median(np.abs(smoothed - np.median(smoothed)))\n        gapfiller = noiselevel\n\n    elif isinstance(fillgaps, str) and fillgaps == 'nan':\n\n        gapfiller = np.nan\n\n    # figure out the gap size and where to interpolate. we do this by figuring\n    # out the most common gap (this should be the cadence). to do this, we need\n    # to calculate the mode of the gap distribution.\n\n    # get the gaps\n    gaps = np.diff(stimes)\n\n    # just use scipy.stats.mode instead of our hacked together nonsense earlier.\n    gapmoderes = scipy.stats.mode(gaps)\n    gapmode = gapmoderes[0].item()\n\n    LOGINFO('auto-cadence for mag series: %.5f' % gapmode)\n\n    # sort the gaps\n    if forcetimebin:\n        LOGWARNING('forcetimebin is set, forcing cadence to %.5f' %\n                   forcetimebin)\n        gapmode = forcetimebin\n\n    if gapmode == 0.0:\n        LOGERROR('the smallest cadence of this light curve appears to be 0.0, '\n                 'the automatic cadence finder probably failed. '\n                 'try setting forcetimebin?')\n        return None\n\n    starttime, endtime = np.min(stimes), np.max(stimes)\n    ntimes = int(np.ceil((endtime - starttime)\/gapmode) + 1)\n    if verbose:\n        LOGINFO('generating new time series with %s measurements' % ntimes)\n\n    # first, generate the full time series\n    interpolated_times = np.linspace(starttime, endtime, ntimes)\n    interpolated_mags = np.full_like(interpolated_times, gapfiller)\n    interpolated_errs = np.full_like(interpolated_times, gapfiller)\n\n    for ind, itime in enumerate(interpolated_times[:-1]):\n\n        nextitime = itime + gapmode\n        # find the mags between this and the next time bin\n        itimeind = np.where((stimes > itime) & (stimes < nextitime))\n\n        # if there's more than one elem in this time bin, median them\n        if itimeind[0].size > 1:\n\n            interpolated_mags[ind] = np.median(smags[itimeind[0]])\n            interpolated_errs[ind] = np.median(serrs[itimeind[0]])\n\n        # otherwise, if there's only one elem in this time bin, take it\n        elif itimeind[0].size == 1:\n\n            interpolated_mags[ind] = smags[itimeind[0]]\n            interpolated_errs[ind] = serrs[itimeind[0]]\n\n    return {'itimes':interpolated_times,\n            'imags':interpolated_mags,\n            'ierrs':interpolated_errs,\n            'cadence':gapmode}\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_482","text":"<reponame>gkmngrgn\/gork<filename>gork\/palette.py\nimport scipy.spatial as sp\nfrom gork.structs import Color\n\nCOLORS = [\n    Color(\"#ffffff\", name=\"Black\"),\n    Color(\"#f7f7f7\", name=\"Maroon\"),\n    Color(\"#efefef\", name=\"Green\"),\n    Color(\"#e7e7e7\", name=\"Olive\"),\n    Color(\"#dfdfdf\", name=\"Navy\"),\n    Color(\"#d7d7d7\", name=\"Purple\"),\n    Color(\"#cfcfcf\", name=\"Teal\"),\n    Color(\"#c7c7c7\", name=\"Silver\"),\n    Color(\"#bfbfbf\", name=\"Grey\"),\n    Color(\"#b7b7b7\", name=\"Red\"),\n    Color(\"#afafaf\", name=\"Lime\"),\n    Color(\"#a7a7a7\", name=\"Yellow\"),\n    Color(\"#9f9f9f\", name=\"Blue\"),\n    Color(\"#979797\", name=\"Fuchsia\"),\n    Color(\"#8f8f8f\", name=\"Aqua\"),\n    Color(\"#878787\", name=\"White\"),\n    Color(\"#7f7f7f\", name=\"Grey0\"),\n    Color(\"#777777\", name=\"NavyBlue\"),\n    Color(\"#6f6f6f\", name=\"DarkBlue\"),\n    Color(\"#676767\", name=\"Blue3\"),\n    Color(\"#5f5f5f\", name=\"Blue3\"),\n    Color(\"#575757\", name=\"Blue1\"),\n    Color(\"#4f4f4f\", name=\"DarkGreen\"),\n    Color(\"#474747\", name=\"DeepSkyBlue4\"),\n    Color(\"#3f3f3f\", name=\"DeepSkyBlue4\"),\n    Color(\"#373737\", name=\"DeepSkyBlue4\"),\n    Color(\"#2f2f2f\", name=\"DodgerBlue3\"),\n    Color(\"#272727\", name=\"DodgerBlue2\"),\n    Color(\"#1f1f1f\", name=\"Green4\"),\n    Color(\"#171717\", name=\"SpringGreen4\"),\n    Color(\"#0f0f0f\", name=\"Turquoise4\"),\n    Color(\"#070707\", name=\"DeepSkyBlue3\"),\n    Color(\"#000000\", name=\"DeepSkyBlue3\"),\n    Color(\"#bfa78f\", name=\"DodgerBlue1\"),\n    Color(\"#b7a088\", name=\"Green3\"),\n    Color(\"#af9880\", name=\"SpringGreen3\"),\n    Color(\"#a79078\", name=\"DarkCyan\"),\n    Color(\"#9f8971\", name=\"LightSeaGreen\"),\n    Color(\"#968169\", name=\"DeepSkyBlue2\"),\n    Color(\"#8e7961\", name=\"DeepSkyBlue1\"),\n    Color(\"#86725a\", name=\"Green3\"),\n    Color(\"#7e6a52\", name=\"SpringGreen3\"),\n    Color(\"#75624a\", name=\"SpringGreen2\"),\n    Color(\"#6d5a42\", name=\"Cyan3\"),\n    Color(\"#65533b\", name=\"DarkTurquoise\"),\n    Color(\"#5d4b33\", name=\"Turquoise2\"),\n    Color(\"#54432b\", name=\"Green1\"),\n    Color(\"#4c3c24\", name=\"SpringGreen2\"),\n    Color(\"#43331b\", name=\"SpringGreen1\"),\n    Color(\"#bf7b4b\", name=\"MediumSpringGreen\"),\n    Color(\"#b37347\", name=\"Cyan2\"),\n    Color(\"#ab6f43\", name=\"Cyan1\"),\n    Color(\"#a36b3f\", name=\"DarkRed\"),\n    Color(\"#9b633b\", name=\"DeepPink4\"),\n    Color(\"#8f5f37\", name=\"Purple4\"),\n    Color(\"#875733\", name=\"Purple4\"),\n    Color(\"#7f532f\", name=\"Purple3\"),\n    Color(\"#774f2b\", name=\"BlueViolet\"),\n    Color(\"#6b4727\", name=\"Orange4\"),\n    Color(\"#5f4323\", name=\"Grey37\"),\n    Color(\"#533f1f\", name=\"MediumPurple4\"),\n    Color(\"#4b371b\", name=\"SlateBlue3\"),\n    Color(\"#3f2f17\", name=\"SlateBlue3\"),\n    Color(\"#332b13\", name=\"RoyalBlue1\"),\n    Color(\"#2b230f\", name=\"Chartreuse4\"),\n    Color(\"#ffebdf\", name=\"DarkSeaGreen4\"),\n    Color(\"#ffe3d3\", name=\"PaleTurquoise4\"),\n    Color(\"#ffdbc7\", name=\"SteelBlue\"),\n    Color(\"#ffd3bb\", name=\"SteelBlue3\"),\n    Color(\"#ffcfb3\", name=\"CornflowerBlue\"),\n    Color(\"#ffc7a7\", name=\"Chartreuse3\"),\n    Color(\"#ffbf9b\", name=\"DarkSeaGreen4\"),\n    Color(\"#ffbb93\", name=\"CadetBlue\"),\n    Color(\"#ffb383\", name=\"CadetBlue\"),\n    Color(\"#f7ab7b\", name=\"SkyBlue3\"),\n    Color(\"#efa373\", name=\"SteelBlue1\"),\n    Color(\"#e79b6b\", name=\"Chartreuse3\"),\n    Color(\"#df9363\", name=\"PaleGreen3\"),\n    Color(\"#d78b5b\", name=\"SeaGreen3\"),\n    Color(\"#cf8353\", name=\"Aquamarine3\"),\n    Color(\"#cb7f4f\", name=\"MediumTurquoise\"),\n    Color(\"#ffeedc\", name=\"SteelBlue1\"),\n    Color(\"#ffdcb9\", name=\"Chartreuse2\"),\n    Color(\"#ffcb97\", name=\"SeaGreen2\"),\n    Color(\"#ffb975\", name=\"SeaGreen1\"),\n    Color(\"#ffa855\", name=\"SeaGreen1\"),\n    Color(\"#ff9736\", name=\"Aquamarine1\"),\n    Color(\"#ff8619\", name=\"DarkSlateGray2\"),\n    Color(\"#ff7500\", name=\"DarkRed\"),\n    Color(\"#f36d00\", name=\"DeepPink4\"),\n    Color(\"#e56500\", name=\"DarkMagenta\"),\n    Color(\"#d85d00\", name=\"DarkMagenta\"),\n    Color(\"#cb5500\", name=\"DarkViolet\"),\n    Color(\"#be4d00\", name=\"Purple\"),\n    Color(\"#b14500\", name=\"Orange4\"),\n    Color(\"#a43d00\", name=\"LightPink4\"),\n    Color(\"#973600\", name=\"Plum4\"),\n    Color(\"#ffffef\", name=\"MediumPurple3\"),\n    Color(\"#ffffcf\", name=\"MediumPurple3\"),\n    Color(\"#ffffaf\", name=\"SlateBlue1\"),\n    Color(\"#ffff8f\", name=\"Yellow4\"),\n    Color(\"#ffff6f\", name=\"Wheat4\"),\n    Color(\"#ffff4f\", name=\"Grey53\"),\n    Color(\"#ffff2f\", name=\"LightSlateGrey\"),\n    Color(\"#ffff0f\", name=\"MediumPurple\"),\n    Color(\"#ffff00\", name=\"LightSlateBlue\"),\n    Color(\"#cfcf00\", name=\"Yellow4\"),\n    Color(\"#afaf00\", name=\"DarkOliveGreen3\"),\n    Color(\"#8f8f00\", name=\"DarkSeaGreen\"),\n    Color(\"#6f6f00\", name=\"LightSkyBlue3\"),\n    Color(\"#4f4f00\", name=\"LightSkyBlue3\"),\n    Color(\"#2f2f00\", name=\"SkyBlue2\"),\n    Color(\"#0f0f00\", name=\"Chartreuse2\"),\n    Color(\"#ffff73\", name=\"DarkOliveGreen3\"),\n    Color(\"#ebdb57\", name=\"PaleGreen3\"),\n    Color(\"#d7bb43\", name=\"DarkSeaGreen3\"),\n    Color(\"#c39b2f\", name=\"DarkSlateGray3\"),\n    Color(\"#af7b1f\", name=\"SkyBlue1\"),\n    Color(\"#9b5b13\", name=\"Chartreuse1\"),\n    Color(\"#874307\", name=\"LightGreen\"),\n    Color(\"#732b00\", name=\"LightGreen\"),\n    Color(\"#ffdfdf\", name=\"PaleGreen1\"),\n    Color(\"#ffbfbf\", name=\"Aquamarine1\"),\n    Color(\"#ff9f9f\", name=\"DarkSlateGray1\"),\n    Color(\"#ff7f7f\", name=\"Red3\"),\n    Color(\"#ff5f5f\", name=\"DeepPink4\"),\n    Color(\"#ff3f3f\", name=\"MediumVioletRed\"),\n    Color(\"#ff1f1f\", name=\"Magenta3\"),\n    Color(\"#ff0000\", name=\"DarkViolet\"),\n    Color(\"#ef0000\", name=\"Purple\"),\n    Color(\"#df0000\", name=\"DarkOrange3\"),\n    Color(\"#cf0000\", name=\"IndianRed\"),\n    Color(\"#bf0000\", name=\"HotPink3\"),\n    Color(\"#af0000\", name=\"MediumOrchid3\"),\n    Color(\"#9f0000\", name=\"MediumOrchid\"),\n    Color(\"#8f0000\", name=\"MediumPurple2\"),\n    Color(\"#7f0000\", name=\"DarkGoldenrod\"),\n    Color(\"#6f0000\", name=\"LightSalmon3\"),\n    Color(\"#5f0000\", name=\"RosyBrown\"),\n    Color(\"#4f0000\", name=\"Grey63\"),\n    Color(\"#3f0000\", name=\"MediumPurple2\"),\n    Color(\"#2f0000\", name=\"MediumPurple1\"),\n    Color(\"#1f0000\", name=\"Gold3\"),\n    Color(\"#0f0000\", name=\"DarkKhaki\"),\n    Color(\"#ffb7b7\", name=\"NavajoWhite3\"),\n    Color(\"#f3a3a3\", name=\"Grey69\"),\n    Color(\"#e78f8f\", name=\"LightSteelBlue3\"),\n    Color(\"#db7b7b\", name=\"LightSteelBlue\"),\n    Color(\"#cb6b6b\", name=\"Yellow3\"),\n    Color(\"#bf5b5b\", name=\"DarkOliveGreen3\"),\n    Color(\"#b34f4f\", name=\"DarkSeaGreen3\"),\n    Color(\"#a73f3f\", name=\"DarkSeaGreen2\"),\n    Color(\"#8e2e00\", name=\"LightCyan3\"),\n    Color(\"#862700\", name=\"LightSkyBlue1\"),\n    Color(\"#7e2000\", name=\"GreenYellow\"),\n    Color(\"#751900\", name=\"DarkOliveGreen2\"),\n    Color(\"#6d1200\", name=\"PaleGreen1\"),\n    Color(\"#650b00\", name=\"DarkSeaGreen2\"),\n    Color(\"#5d0500\", name=\"DarkSeaGreen1\"),\n    Color(\"#550000\", name=\"PaleTurquoise1\"),\n    Color(\"#77ff4f\", name=\"Red3\"),\n    Color(\"#70f04b\", name=\"DeepPink3\"),\n    Color(\"#69e046\", name=\"DeepPink3\"),\n    Color(\"#61d041\", name=\"Magenta3\"),\n    Color(\"#5ac03c\", name=\"Magenta3\"),\n    Color(\"#52b037\", name=\"Magenta2\"),\n    Color(\"#4ba032\", name=\"DarkOrange3\"),\n    Color(\"#43902d\", name=\"IndianRed\"),\n    Color(\"#3c8028\", name=\"HotPink3\"),\n    Color(\"#357023\", name=\"HotPink2\"),\n    Color(\"#2d601e\", name=\"Orchid\"),\n    Color(\"#265019\", name=\"MediumOrchid1\"),\n    Color(\"#1e4014\", name=\"Orange3\"),\n    Color(\"#17300f\", name=\"LightSalmon3\"),\n    Color(\"#0f200a\", name=\"LightPink3\"),\n    Color(\"#070f04\", name=\"Pink3\"),\n    Color(\"#deffa8\", name=\"Plum3\"),\n    Color(\"#c7e494\", name=\"Violet\"),\n    Color(\"#adc880\", name=\"Gold3\"),\n    Color(\"#95ad6b\", name=\"LightGoldenrod3\"),\n    Color(\"#7c9258\", name=\"Tan\"),\n    Color(\"#647744\", name=\"MistyRose3\"),\n    Color(\"#4a5a30\", name=\"Thistle3\"),\n    Color(\"#323f1d\", name=\"Plum2\"),\n    Color(\"#00ff00\", name=\"Yellow3\"),\n    Color(\"#00df00\", name=\"Khaki3\"),\n    Color(\"#00bf00\", name=\"LightGoldenrod2\"),\n    Color(\"#009f00\", name=\"LightYellow3\"),\n    Color(\"#007f00\", name=\"Grey84\"),\n    Color(\"#005f00\", name=\"LightSteelBlue1\"),\n    Color(\"#003f00\", name=\"Yellow2\"),\n    Color(\"#001f00\", name=\"DarkOliveGreen1\"),\n    Color(\"#ff6fff\", name=\"DarkOliveGreen1\"),\n    Color(\"#ff00ff\", name=\"DarkSeaGreen1\"),\n    Color(\"#df00df\", name=\"Honeydew2\"),\n    Color(\"#bf00bf\", name=\"LightCyan1\"),\n    Color(\"#9f009f\", name=\"Red1\"),\n    Color(\"#7f007f\", name=\"DeepPink2\"),\n    Color(\"#5f005f\", name=\"DeepPink1\"),\n    Color(\"#3f003f\", name=\"DeepPink1\"),\n    Color(\"#e9e9f3\", name=\"Magenta2\"),\n    Color(\"#c4c4e1\", name=\"Magenta1\"),\n    Color(\"#9d9dce\", name=\"OrangeRed1\"),\n    Color(\"#7777bb\", name=\"IndianRed1\"),\n    Color(\"#5454a7\", name=\"IndianRed1\"),\n    Color(\"#414183\", name=\"HotPink\"),\n    Color(\"#2e2e5c\", name=\"HotPink\"),\n    Color(\"#1b1b34\", name=\"MediumOrchid1\"),\n    Color(\"#d5f1ff\", name=\"DarkOrange\"),\n    Color(\"#bfebff\", name=\"Salmon1\"),\n    Color(\"#aae3ff\", name=\"LightCoral\"),\n    Color(\"#95ddff\", name=\"PaleVioletRed1\"),\n    Color(\"#80d6ff\", name=\"Orchid2\"),\n    Color(\"#6acfff\", name=\"Orchid1\"),\n    Color(\"#55c8ff\", name=\"Orange1\"),\n    Color(\"#3fbfff\", name=\"SandyBrown\"),\n    Color(\"#379ddf\", name=\"LightSalmon1\"),\n    Color(\"#2f8fbf\", name=\"LightPink1\"),\n    Color(\"#27779f\", name=\"Pink1\"),\n    Color(\"#1f5f7f\", name=\"Plum1\"),\n    Color(\"#00bfbf\", name=\"Gold1\"),\n    Color(\"#007f7f\", name=\"LightGoldenrod2\"),\n    Color(\"#005f5f\", name=\"LightGoldenrod2\"),\n    Color(\"#003f3f\", name=\"NavajoWhite1\"),\n    Color(\"#e7e7ff\", name=\"MistyRose1\"),\n    Color(\"#c6c6ff\", name=\"Thistle1\"),\n    Color(\"#adadff\", name=\"Yellow1\"),\n    Color(\"#8c8cff\", name=\"LightGoldenrod1\"),\n    Color(\"#7373ff\", name=\"Khaki1\"),\n    Color(\"#5252ff\", name=\"Wheat1\"),\n    Color(\"#3131ff\", name=\"Cornsilk1\"),\n    Color(\"#1818ff\", name=\"Grey100\"),\n    Color(\"#0000ff\", name=\"Grey3\"),\n    Color(\"#0000e7\", name=\"Grey7\"),\n    Color(\"#0000ce\", name=\"Grey11\"),\n    Color(\"#0000b5\", name=\"Grey15\"),\n    Color(\"#00009c\", name=\"Grey19\"),\n    Color(\"#000084\", name=\"Grey23\"),\n    Color(\"#00006b\", name=\"Grey27\"),\n    Color(\"#000052\", name=\"Grey30\"),\n    Color(\"#00004f\", name=\"Grey35\"),\n    Color(\"#00003f\", name=\"Grey39\"),\n    Color(\"#000037\", name=\"Grey42\"),\n    Color(\"#000027\", name=\"Grey46\"),\n    Color(\"#00001f\", name=\"Grey50\"),\n    Color(\"#00000f\", name=\"Grey54\"),\n    Color(\"#000007\", name=\"Grey58\"),\n    Color(\"#00ffff\", name=\"Grey62\"),\n    Color(\"#cf7fcf\", name=\"Grey66\"),\n    Color(\"#b76fb7\", name=\"Grey70\"),\n    Color(\"#9f5f9f\", name=\"Grey74\"),\n    Color(\"#874f87\", name=\"Grey78\"),\n    Color(\"#6f3f6f\", name=\"Grey82\"),\n    Color(\"#572f57\", name=\"Grey85\"),\n    Color(\"#3f1f3f\", name=\"Grey89\"),\n    Color(\"#270f27\", name=\"Grey93\"),\n]\nCOLOR_COUNT = len(COLORS)\nPALETTE = [c.as_rgb.as_tuple for c in COLORS]\nCOLOR_TREE = sp.KDTree(PALETTE)\nDEFAULT_WIDTH = 78  # FIXME: remove this line\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_484","text":"<reponame>dpazel\/music_rep<filename>transformation\/shift\/t_shift_example.py\n\"\"\"\nFile: T_shift_example.py\nPurpose: examples of t_shift applied to a melody.\n\"\"\"\nfrom fractions import Fraction\n\nfrom tonalmodel.interval import Interval as TonalInterval\nfrom tonalmodel.modality import ModalityType\nfrom transformation.shift.t_shift import TShift\nfrom tonalmodel.tonality import Tonality\n\ndef duration_ltr(duration):\n    if duration.duration == Fraction(1, 8):\n        return 'i'\n    elif duration.duration == Fraction(1, 4):\n        return 'q'\n    elif duration.duration == Fraction(1, 2):\n        return 'h'\n    elif duration.duration == Fraction(1):\n        return 'w'\n    return '>'\n\ndef print_line(line):\n    notes = line.get_all_notes()\n    prior_octave = None\n    prior_duration = None\n    note_annotations = list()\n    for note in notes:\n        annotation = ''\n        d = duration_ltr(note.duration)\n        if d != prior_duration:\n            annotation += d\n            prior_duration = d\n        annotation += str(note.diatonic_pitch.diatonic_tone.diatonic_symbol)\n        o = note.diatonic_pitch.octave\n        if o != prior_octave:\n            annotation += \":\" + str(o)\n            prior_octave = o\n        note_annotations.append(annotation)\n    s = ' '.join(annotation for annotation in note_annotations)\n    print(s)\n\ndef print_hct(hct):\n    hc_annotations = list()\n    for hc in hct.hc_list():\n        s = '<{0}: {1}>({2})'.format(hc.tonality, hc.chord, hc.duration)\n        hc_annotations.append(s)\n    hcs = ' '.join(hc_str for hc_str in hc_annotations)\n    print(hcs)\n\n\ndef simple_shift_example():\n    print('----- Simple Shift Example -----')\n    source_expression = '{<C-Major: I> iC:4 C qD E <:IV> iF G hA <:V> ig b qf g <:VI> ie e qd ic d <:I> h@c}'\n\n    t_shift = TShift.create(source_expression, TonalInterval.parse('M:3'))\n    print('Shift examples based on:')\n    print_line(t_shift.source_line)\n    print()\n\n    print('Shift up M:3')\n    target_line, target_hct = t_shift.apply()\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n    t_shift = TShift.create(source_expression, TonalInterval.parse('-m:2'))\n\n    target_line, target_hct = t_shift.apply()\n\n    print('Shift down m:2')\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\ndef shift_change_modality():\n    print('----- Shift Change Modality Example -----')\n    source_expression = '{<C-Major: I> iC:4 C qD E <:IV> iF G hA <:V> ig b qf g <:VI> ie e qd ic d <:i> h@c}'\n\n    t_shift = TShift.create(source_expression, TonalInterval.parse('P:4'))\n    print('Shift examples based on:')\n    print_line(t_shift.source_line)\n    print()\n\n    print('Shift up P:4, modality MelodicMinor')\n    target_line, target_hct = t_shift.apply(range_modality_type=ModalityType.MelodicMinor)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n    print('Shift up P:4, modality NaturalMinor')\n    target_line, target_hct = t_shift.apply(range_modality_type=ModalityType.NaturalMinor)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\ndef shift_change_modal_index():\n    print('----- Shift Change Modal Index Example -----')\n    source_expression = '{<C-Major: I> iC:4 C qD E <:IV> iF G hA <:V> ig b qf g <:VI> ie e qd ic d <:i> h@c}'\n\n    t_shift = TShift.create(source_expression)\n    print('Shift examples based on:')\n    print_line(t_shift.source_line)\n    print()\n\n    print('Shift to modal index 4 (Mixolydian)')\n    target_line, target_hct = t_shift.apply(modal_index=4)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n    print('Shift to C as modal index 3 (lydian) on a melodic minor scale (G)')\n    target_line, target_hct = t_shift.apply(range_modality_type=ModalityType.MelodicMinor, modal_index=3)\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\ndef shift_change_modal_index_modality_and_shift():\n    print('----- Shift Change Modal Index, modality, shift Example -----')\n    source_expression = '{<C-Major: I> iC:4 C qD E <:IV> iF G hA <:V> ig b qf g <:VI> ie e qd ic d <:i> h@c}'\n\n    t_shift = TShift.create(source_expression)\n    print('Shift examples based on:')\n    print_line(t_shift.source_line)\n    print()\n\n    print('Shift to modal index 1 (dorian)')\n    target_line, target_hct = t_shift.apply(root_shift_interval=TonalInterval.parse('M:2'), modal_index=1)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n    t_shift = TShift(target_line, target_hct)\n\n    print('Shift P:4 to modal index 2 (phrygian) of MelodicMinor')\n    target_line, target_hct = t_shift.apply(root_shift_interval=TonalInterval.parse('P:4'),\n                                            range_modality_type=ModalityType.MelodicMinor, modal_index=2)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n\n\ndef example():\n    print('----- Book example of shifted tonality on modal not 0 -----')\n    source_expression = '{<D-Major(1): I> iE:4 F# G A qE B}'\n\n    t_shift = TShift.create(source_expression,\n                            TonalInterval.parse('P:4'))\n    target_line, target_hct = t_shift.apply(range_modality_type=ModalityType.MelodicMinor, modal_index=2)\n    print(t_shift.source_hct)\n    print(target_line)\n    print(target_hct)\n\ndef example1():\n    print('----- Book example of shifted secondary tonality  -----')\n    source_expression = '{<C-Major: V\/iii> iD#:4 F# G A qD#:5 B:4}'\n\n    t_shift = TShift.create(source_expression, TonalInterval.parse('P:5'))\n    target_line, target_hct = t_shift.apply(range_modality_type=ModalityType.MelodicMinor)\n    print(t_shift.source_hct)\n    print(target_line)\n    print(target_hct)\n\ndef example2():\n    print('----- Debug meaning of modal index change and hct -----')\n\n    # example tonality with modal index\n    # Create a harmonic minor tonality of some basis root which as Mixolydian has F as the root.\n    #       The answer is Bb-HarmonicMinor F(4)\n\n    source_expression = '{<C-Major: I> iC:4}'\n\n    t_shift = TShift.create(source_expression)\n    print('Shift examples based on:')\n    print_line(t_shift.source_line)\n    print()\n\n    print('Shift to modal index 4 (Mixolydian)')\n    # This makes C the Mixolydian of F-Major\n    target_line, target_hct = t_shift.apply(modal_index=4)\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n    # if you wanted G Mixolydian based on C\n    print('Shift as if moving tomodal index 4 (Mixolydian) in C')\n    target_line, target_hct = t_shift.apply(\n           root_shift_interval=TonalInterval.parse('P:5'), modal_index=4)\n\n    print_line(target_line)\n    print_hct(target_hct)\n    print()\n\n\n#simple_shift_example()\n#shift_change_modality()\nshift_change_modal_index()\n#shift_change_modal_index_modality_and_shift()\n#example2()\n#example1()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_485","text":"<filename>ChrisFuncs\/ChrisFuncs.py<gh_stars>0\n# Import smorgasbord\nimport pdb\nimport pdb\n\"\"\"from IPython import get_ipython\nget_ipython().run_line_magic('pdb','on')\"\"\"\nimport sys\nimport os\n#sys.path.append( os.path.split( os.path.realpath(__file__) )[:-1][0] )\n#sys.path.append( os.path.split( os.path.split( os.path.realpath(__file__) )[:-1][0] )[:-1][0] )\n#sys.path.insert(0, '..\/')\nimport numpy as np\nimport scipy.stats\nimport scipy.ndimage\nimport scipy.ndimage.measurements\nimport scipy.spatial\n#import matplotlib\n#matplotlib.use('Agg')\nimport matplotlib.pyplot as plt\nimport matplotlib.cm\nimport matplotlib.patches\nimport astropy\nastropy.log.setLevel('ERROR')\nimport astropy.io.fits\nimport astropy.wcs\nimport astropy.convolution\nimport astropy.coordinates\nimport astropy.units\nimport astroquery.irsa_dust\nimport shutil\nimport wget\nimport glob\nimport time\nimport re\nimport copy\n\n# A python 2\/3 compatability hack for stirng type handling\ntry:\n  basestring\nexcept NameError:\n  basestring = str\n\n\n\n# Function to sum all elements in an ellipse centred on the middle of a given array\n# Args: Array, semi-major axis (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse\n# Returns: Numpy array containing the sum of the pixel values in the ellipse, total number of pixels counted, and an array containing the pixel values\ndef EllipseSum(array, rad, axial_ratio, angle, i_centre, j_centre):\n    from . import Photom\n    return Photom.EllipseSum(array, rad, axial_ratio, angle, i_centre, j_centre)\n\n\n\n# Function to sum all elements in an annulus centred upon the middle of the given array\n# Args: Array, semi-major axis of inside edge of annulus (pix), width of annulus (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse\n# Returns: Numpy array containing the sum of the pixel values in the annulus, the total number of pixels counted, and an array containing the pixel values\ndef AnnulusSum(array, rad_inner, width, axial_ratio, angle, i_centre, j_centre):\n    from . import Photom\n    return Photom.AnnulusSum(array, rad_inner, width, axial_ratio, angle, i_centre, j_centre)\n\n\n\n# Function to make annular photometry faster by pre-preparing arrays of transposed coords that are to be repeatedly used\n# Args: Array, semi-major axis of inside edge of annulus (pix), width of annulus (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse\n# Returns: List containing i & j transposed coords\ndef AnnulusQuickPrepare(array, angle, i_centre, j_centre):\n    from . import Photom\n    return Photom.AnnulusQuickPrepare(array, angle, i_centre, j_centre)\n\n\n\n# Function to sum all elements in an annulus centred upon the middle of the given array, usingpre-prepared transposed coord arrays\n# Args: Array, semi-major axis of inside edge of annulus (pix), width of annulus (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse, i & j transposed coord arrays\n# Returns: Numpy array containing the sum of the pixel values in the annulus, the total number of pixels counted, and an array containing the pixel values\ndef AnnulusQuickSum(array, rad_inner, width, axial_ratio, angle, i_centre, j_centre, i_trans, j_trans):\n    from . import Photom\n    return Photom.AnnulusQuickSum(array, rad_inner, width, axial_ratio, angle, i_centre, j_centre, i_trans, j_trans)\n\n\n\n# Function to sum all elements in an annulus centred upon the middle of the given array, using pre-prepared transposed coord arrays\n# Args: Array, semi-major axis of ellipse (pix), position angle (deg), i & j coords of centre of ellipse, i & j transposed coord arrays\n# Returns: Numpy array containing the sum of the pixel values in the ellipse, the total number of pixels counted, and an array containing the pixel values\ndef EllipseQuickSum(array, rad, axial_ratio, angle, i_centre, j_centre, i_trans, j_trans):\n    from . import Photom\n    return Photom.EllipseQuickSum(array, rad, axial_ratio, angle, i_centre, j_centre, i_trans, j_trans)\n\n\n\n# Function to return a mask identifying all pixels within an ellipse of given parameters\n# Args: Array, semi-major axis (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse\n# Returns: Mask array of same dimensions as input array where pixels that lie within ellipse have value 1\ndef EllipseMask(array, rad, axial_ratio, angle, i_centre, j_centre):\n    from . import Photom\n    return Photom.EllipseMask(array, rad, axial_ratio, angle, i_centre, j_centre)\n\n\n\n# Function to sum all pixel elements inside a given circle... the old-fashioned way\n# Args: Array to be used, i & j coordinates of centre of circle, radius of circle\n# Returns: Sum of elements within circle, number of pixels within circle\ndef CircleSum(fits, i_centre, j_centre, r):\n    from . import Photom\n    return Photom.CircleSum(fits, i_centre, j_centre, r)\n\n\n\n# Function to sum all pixel elements inside a given circle... the old-fashioned way\n# Args: Array to be used, i & j coordinates of centre of circle, radius of circle\n# Returns: Sum of elements within circle, number of pixels within circle\ndef CircleAnnulusSum(fits, i_centre, j_centre, r, width):\n    from . import Photom\n    return Photom.CircleAnnulusSum(fits, i_centre, j_centre, r, width)\n\n\n\n# Function to sum all elements in an ellipse centred on the middle of an array that has been resized to allow better pixel sampling\n# Args: Array, semi-major axis (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse, upscaling factor\n# Returns: Numpy array containing the sum of the pixel values in the ellipse, the total number of pixels counted, and an array containing the pixel values\ndef EllipseSumUpscale(cutout, rad, axial_ratio, angle, i_centre, j_centre, upscale=1):\n    from . import Photom\n    return Photom.EllipseSumUpscale(cutout, rad, axial_ratio, angle, i_centre, j_centre, upscale=1)\n\n\n\n# Function to sum all elements in an annulus centred upon the middle of an array that has been resized to allow better pixel sampling\n# Args: Array, semi-major axis of inside edge of annulus (pix), width of annulus (pix), axial ratio, position angle (deg), i & j coords of centre of ellipse, upscaling factor\n# Returns: Numpy array containing the sum of the pixel values in the annulus, the total number of pixels counted, and an array containing the pixel values\ndef AnnulusSumUpscale(cutout, rad_inner, width, axial_ratio, angle, i_centre, j_centre, upscale=1):\n    from . import Photom\n    return Photom.AnnulusSumUpscale(cutout, rad_inner, width, axial_ratio, angle, i_centre, j_centre, upscale=1)\n\n\n\n# Function to iteratively calculate SPIRE aperture noise of photometry cutout using randomly-placed (annular-background-subtracted) circular aperture\n# Args: Map, radius of aperture (pix), area of aperture (pix), boolean of whether or not to sky-subtract the noise apertures, relative radius of inner edge of annulus, relative width of annulus, angle of source ellipse, axial ratio of source ellipse\n# Returns: Aperture standard deviation, and list of mean background values, list of aperture sum values\ndef CircularApertureStandardDeviationFinder(fits, area, ann=True, ann_inner=1.5, ann_width=1.0, angle=0.0, axial_ratio=1.0, apertures=100):\n    from . import Photom\n    return Photom.CircularApertureStandardDeviationFinder(fits, area, ann=True, ann_inner=1.5, ann_width=1.0, angle=0.0, axial_ratio=1.0, apertures=100)\n\n\n\n# Function to find all contiguous pixels that lie above a given flux limit\n# Args: Array, radius of guess region (pix), i & j coords of centre of guess region, cutoff value for pixel selection\n# Returns: Array of ones and zeros indicating contiguous region\ndef ContiguousPixels(cutout, rad_initial, i_centre, j_centre, cutoff):\n    from . import Photom\n    return Photom.ContiguousPixels(cutout, rad_initial, i_centre, j_centre, cutoff)\n\n\n\n# Function that combines all of the ellipse-fitting steps (finds convex hull, fits ellipse to this, then finds properties of ellipse)\n# Args: x & y coordinates to which the ellipse is to be fitted\n# Returns: Array of x & y coordinates of ellipse centre, array of ellipse's major & minor axes, ellipse's position angle\ndef EllipseFit(x,y):\n    from . import Photom\n    return Photom.EllipseFit(x,y)\n\n\n\n# Function to calculate the coordinates of the centre of an ellipse produced by EllipseFit\n# Args: Ellipse produced by EllipseFit\n# Returns: Array of x & y coordinates of ellipse centre\ndef EllipseCentre(a):\n    from . import Photom\n    return Photom.EllipseCentre(a)\n\n\n\n# Function to calculate the lengths of the axes of an ellipse produced by EllipseFit\n# Args: Ellipse produced by EllipseFit\n# Returns: Array of ellipse's major & minor axes\ndef EllipseAxes(a):\n    from . import Photom\n    return Photom.EllipseAxes(a)\n\n\n\n# Function to calculat the position angle of the centre of an ellipse produced by EllipseFit\n# Args: Ellipse produced by EllipseFit\n# Returns: Ellipse's position angle\ndef EllipseAngle(a):\n    from . import Photom\n    return Photom.EllipseAngle(a)\n\n\n\n# Function to create a cutout of a fits file - NOW JUST A WRAPPER OF AN ASTROPY FUNCTION\n# Args: Input fits, cutout central ra (deg), cutout central dec (deg), cutout radius (arcsec), pixel width (arcsec), fits image extension, boolean of whether to reproject, boolean stating if an output variable is desired, output fits pathname if required\n# Returns: HDU of new file\ndef FitsCutout(pathname, ra, dec, rad_arcsec, pix_width_arcsec=None, exten=0, reproj=False, variable=False, outfile=False, parallel=True, fast=True):\n    from . import Fits\n    return Fits.FitsCutout(pathname, ra, dec, rad_arcsec, pix_width_arcsec=pix_width_arcsec, exten=exten, reproj=reproj, variable=variable, outfile=outfile, parallel=parallel, fast=fast)\n\n\n\n# Function to embed a fits file in a larger array of NaNs (for APLpy or the like)\n# Args: Input fits pathname, margin to place around array, fits extension of interest, boolean stating if margin is in arcseconds, no pixelsboolean stating if an output variable is desired, output fits pathname\n# Returns: HDU of new file\ndef FitsEmbed(pathname, margin, exten=0, variable=False, outfile=False):\n    from . import Fits\n    return Fits.FitsEmbed(pathname, margin, exten=exten, variable=variable, outfile=outfile)\n\n\n\n# Define function to generate a generic FITS header for a given projection\n# Args: Central right ascension (deg), central declination (deg), image width (deg), pixel size (arcsec)\n# Returns: FITS header\ndef FitsHeader(ra, dec, map_width_deg, pix_width_arcsec):\n    from . import Fits\n    return Fits.FitsHeader(ra, dec, map_width_deg, pix_width_arcsec)\n\n\n\n# Function to perform a sigma clip upon a set of values\n# Args: Array of values, convergence tolerance, state if median instead of mean should be used for clip centrepoint, clipping threshold, boolean for whether sigma of zero can be accepted\n# Returns: List containing the clipped standard deviation, the average, and the values themselves\ndef SigmaClip(values, tolerance=0.001, median=False, sigma_thresh=3.0, no_zeros=False):\n\n    # Remove NaNs from input values\n    values = np.array(values)\n    values = values[ np.where(np.isnan(values)==False) ]\n    values_original = np.copy(values)\n\n    # Continue loop until result converges\n    diff = 10E10\n    while diff>tolerance:\n\n        # Assess current input iteration\n        if median == False:\n            average = np.mean(values)\n        elif median == True:\n            average = np.median(values)\n        sigma_old = np.std(values)\n\n        # Mask those pixels that lie more than 3 stdev away from mean\n        check = np.zeros([len(values)])\n        check[ np.where( values>(average+(sigma_thresh*sigma_old)) ) ] = 1\n        check[ np.where( values<(average-(sigma_thresh*sigma_old)) ) ] = 1\n        values = values[ np.where(check<1) ]\n\n        # Re-measure sigma and test for convergence\n        sigma_new = np.std(values)\n        diff = abs(sigma_old-sigma_new) \/ sigma_old\n\n    # Perform final mask\n    check = np.zeros([len(values)])\n    check[ np.where( values>(average+(sigma_thresh*sigma_old)) ) ] = 1\n    check[ np.where( values<(average-(sigma_thresh*sigma_old)) ) ] = 1\n    values = values[ np.where(check<1) ]\n\n    # If required, check if calculated sigma is zero\n    if no_zeros==True:\n        if sigma_new==0.0:\n            sigma_new = np.std(values_original)\n            if median==False:\n                average = np.mean(values)\n            elif median==True:\n                average = np.median(values)\n\n    # Return results\n    return [sigma_new, average, values]\n\n\n\n# Keflavich function to downsample an array\n# Args: Array to downsample, downsampling factor, and estiamtor\n# Returns: Downsampled array\ndef Downsample(myarr, factor, estimator=np.nanmean):\n    ys,xs = myarr.shape\n    crarr = myarr[:ys-(ys % int(factor)),:xs-(xs % int(factor))]\n    dsarr = estimator( np.concatenate([[crarr[i::factor,j::factor]\n        for i in range(factor)]\n        for j in range(factor)]), axis=0)\n    return dsarr\n\n\n\n# A function to fit and remove a background polynomial to an image, masking a central ellipse\n# Args: Array to process, i-coord of masked central ellipse, j-coord of masked central ellipse, semimajor axis of masked central ellipse, axial ratio of masked central ellipse, position angle of masked central ellipse, order of polynomial, sigma threshold at which bright pixels cut off, downsampling factor to use, boolean of whether to only apply polynomial if it makes significant difference to image\n# Returns: Poynomial-filtered array, array of the polynomial filter\ndef PolySub(image_in, mask_centre_i, mask_centre_j, mask_semimaj_pix, mask_axial_ratio, mask_angle, poly_order=5, cutoff_sigma=2.0, downsample=1.0, change_check=False):\n\n    # If requested, downsample image to improve processing time\n    downsample_factor = np.round(np.int(downsample))\n    if downsample_factor>=2:\n        image_ds = Downsample(image_in, downsample_factor)\n    else:\n        image_ds = image_in\n\n    # Downsample related values accordingly\n    mask_semimaj_pix = mask_semimaj_pix \/ downsample_factor\n    mask_centre_i = int(round(float((0.5*mask_centre_i)-1.0)))\n    mask_centre_j = int(round(float((0.5*mask_centre_j)-1.0)))\n\n    # Find cutoff for excluding bright pixels by sigma-clipping map\n    clip_value = SigmaClip(image_ds, tolerance=0.01, sigma_thresh=2.0, median=True)\n    noise_value = clip_value[0]\n    field_value = clip_value[1]\n    cutoff = field_value + ( cutoff_sigma * noise_value )\n\n    # Mask all image pixels in masking region around source\n    image_masked = image_ds.copy()\n    ellipse_mask = EllipseMask(image_ds, mask_semimaj_pix, mask_axial_ratio, mask_angle, mask_centre_i, mask_centre_j)\n    image_masked[ np.where( ellipse_mask==1 ) ] = np.nan\n\n    # Mask all image pixels identified as being high SNR\n    image_masked[ np.where( image_masked>cutoff ) ] = np.nan\n\n    # Use astropy to fit 2-dimensional polynomial to the image\n    image_masked[ np.where( np.isnan(image_masked)==True ) ] = field_value\n    poly_model = astropy.modeling.models.Polynomial2D(degree=poly_order)\n    i_coords, j_coords = np.mgrid[:image_masked.shape[0], :image_masked.shape[1]]\n    fitter = astropy.modeling.fitting.LevMarLSQFitter()\n    i_coords = i_coords.flatten()\n    j_coords = j_coords.flatten()\n    image_flattened = image_masked.flatten()\n    good = np.where(np.isnan(image_flattened)==False)\n    i_coords = i_coords[good]\n    j_coords = j_coords[good]\n    image_flattened = image_flattened[good]\n    fit = fitter(poly_model, i_coords, j_coords, image_flattened)\n\n    # Create final polynomial filter (undoing downsampling using lorenzoriano GitHub script)\n    i_coords, j_coords = np.mgrid[:image_ds.shape[0], :image_ds.shape[1]]\n    poly_fit = fit(i_coords, j_coords)\n    poly_full = scipy.ndimage.interpolation.zoom(poly_fit, [ float(image_in.shape[0])\/float(poly_fit.shape[0]), float(image_in.shape[1])\/float(poly_fit.shape[1]) ], mode='nearest')\n\n    # Establish background variation before application of filter\n    sigma_thresh = 2.0\n    clip_in = SigmaClip(image_in, tolerance=0.005, median=True, sigma_thresh=sigma_thresh)\n    bg_in = image_in[ np.where( image_in<clip_in[1] ) ]\n    spread_in = np.mean( np.abs( bg_in - clip_in[1] ) )\n\n    # How much reduction in background variation there was due to application of the filter\n    image_sub = image_in - poly_full\n    clip_sub = SigmaClip(image_sub, tolerance=0.005, median=True, sigma_thresh=sigma_thresh)\n    bg_sub = image_sub[ np.where( image_sub<clip_sub[1] ) ]\n    spread_sub = np.mean( np.abs( bg_sub - clip_sub[1] ) )\n    spread_diff = spread_in \/ spread_sub\n\n    # If the filter made significant difference, apply to image and return it; otherwise, just return the unaltered map\n    if change_check:\n        if spread_diff>1.1:\n            image_out = image_sub\n            poly_out = poly_full\n        else:\n            image_out = image_ds\n            poly_out = np.zeros(image_in.shape)\n    else:\n        image_out = image_sub\n        poly_out = poly_full\n    return image_out, poly_out\n\n\n\n# Function that provides Galactic extinction correction, via IRSA dust extinction service (which uses the Schlafly & Finkbeiner 2011 prescription)\n# Args: RA of target coord (deg), dec of target coord (deg), name of band of interest, (boolean of whether function should be verbose, and meaningless verbose output prefix string)\n# Returns: Extinction correction factor (ie, multiply uncorrected flux by this value to yield corrected flux)\ndef ExtCorrrct(ra, dec, band_name, verbose=True, verbose_prefix=''):\n\n    # Make sure there's a space at the end of the verbose prefix\n    if verbose_prefix!='':\n        if verbose_prefix[-1:]!=' ':\n            verbose_prefix += ' '\n\n    # Offset RA or Dec if either is exactly 0, as this can confuse IRSA\n    if np.abs(ra)<0.01:\n        ra = 0.01\n    if np.abs(dec)<0.01:\n        dec = 0.01\n\n    # List bands for which IRSA provids corrections\n    excorr_possible = ['GALEX_FUV','GALEX_NUV','SDSS_u','SDSS_g','SDSS_r','SDSS_i','SDSS_z','CTIO_U','CTIO_B','CTIO_V','CTIO_R','CTIO_I','DSS_B','DSS_R','DSS_I','2MASS_J','2MASS_H','2MASS_Ks','UKIRT_Y','UKIRT_J','UKIRT_H','UKIRT_K','Spitzer_3.6','Spitzer_4.5','Spitzer_5.8','Spitzer_8.0','WISE_3.4','WISE_4.6']\n\n    # Check if corrections are available for this band\n    photom_band_parsed = BandParse(band_name)\n    if photom_band_parsed==None:\n        if verbose: print(verbose_prefix+'Unable to parse band name; not conducting Galactic extinction correction for this band.')\n        excorr = 1.0\n        return excorr\n    if photom_band_parsed not in excorr_possible:\n        if verbose: print(verbose_prefix+'Galactic extinction correction not available for this band.')\n        excorr = 1.0\n        return excorr\n\n    # Else if extinction correction is possible, prepare query IRSA dust extinction service\n    if verbose: print(verbose_prefix+'Retreiving extinction corrections from IRSA Galactic Dust Reddening & Extinction Service.')\n    query_count = 0\n    query_success = False\n    query_limit = 10\n\n    # Keep trying to access extinction corrections, until it works\n    while not query_success:\n        if query_count>=query_limit:\n            break\n\n        # Carry out query\n        try:\n            sys.stdout = open(os.devnull, \"w\")\n            irsa_query = astroquery.irsa_dust.IrsaDust.get_extinction_table( str(ra)+', '+str(dec) )\n            sys.stdout = sys.__stdout__\n            query_success = True\n            break\n\n        # Handle exceptions\n        except Exception as exception:\n            sys.stdout = sys.__stdout__\n            if query_count==0:\n                if hasattr(exception, 'message'):\n                    print(verbose_prefix+'IRSA Galactic Dust Reddening & Extinction Service query failed with error: \\\"'+repr(exception.message)+'\\\" - reattempting.')\n                else:\n                    print(verbose_prefix+'IRSA Galactic Dust Reddening & Extinction Service query failed: reattempting (exception not caught).')\n            query_count += 1\n            time.sleep(10.0)\n    if not query_success:\n        print(verbose_prefix+'Unable to access IRSA Galactic Dust Reddening & Extinction Service after '+str(query_limit)+' attemps.')\n        raise ValueError('Unable to access IRSA Galactic Dust Reddening & Extinction Service after '+str(query_limit)+' attemps.')\n\n    # Loop over entries in the IRSA table, looking for the current band\n    irsa_band_exists = False\n    for irsa_band_raw in irsa_query['Filter_name'].tolist():\n        irsa_band_parsed = BandParse(irsa_band_raw)\n        if irsa_band_parsed==None:\n            continue\n\n        # If band found in IRSA table, apply quoted Schlafly & Finkbeiner extinction correction\n        if irsa_band_parsed==photom_band_parsed:\n            irsa_band_index = np.where( irsa_query['Filter_name']==irsa_band_raw )[0][0]\n            irsa_band_excorr_mag = irsa_query['A_SandF'][irsa_band_index]\n            irsa_band_excorr = 10.0**( irsa_band_excorr_mag \/ 2.51 )\n            irsa_band_exists = True\n            break\n\n    # If band is GALEX, determine appropriate extinction correction using reddening coefficients derived from Cardelli (1989) extinction law (cf Gil de Paz 2007, arXiv:1009.4705, arXiv:1108.2837)\n    if (irsa_band_exists==False) and (photom_band_parsed in ['GALEX_FUV','GALEX_NUV']):\n\n        # Get the A(V) \/ E(B-V) extinction-to-excess ratio in V-band\n        irsa_v_index = np.where( irsa_query['Filter_name']=='CTIO V' )[0][0]\n        irsa_av_ebv_ratio = irsa_query[\"A_over_E_B_V_SandF\"][irsa_v_index]\n\n        # Get the A(V) attenuation in V-band\n        irsa_av = irsa_query[\"A_SandF\"][irsa_v_index]\n\n        # Determine the factor\n        if photom_band_parsed=='GALEX_FUV':\n            reddening_coeff = 7.9\n        elif photom_band_parsed=='GALEX_NUV':\n            reddening_coeff = 8.0\n\n        # Calculate and apply the extincton correction\n        irsa_band_excorr_mag = reddening_coeff * ( irsa_av \/ irsa_av_ebv_ratio )\n        irsa_band_excorr = 10.0**( irsa_band_excorr_mag \/ 2.51 )\n\n    # If band is Y-band, use point 36.557% of way between z-band and J-band corrections\n    if (irsa_band_exists==False) and (photom_band_parsed=='UKIRT_Y'):\n        irsa_z_index = np.where( irsa_query['Filter_name']=='SDSS z' )[0][0]\n        irsa_J_index = np.where( irsa_query['Filter_name']=='UKIRT J')[0][0]\n        irsa_band_excorr_mag = irsa_query['A_SandF'][irsa_J_index] + ( (1.0-0.36557) * (irsa_query['A_SandF'][irsa_z_index] - irsa_query['A_SandF'][irsa_J_index]) )\n        irsa_band_excorr = 10.0**( irsa_band_excorr_mag \/ 2.51 )\n        irsa_band_exists = True\n\n    # Report result and return extinction correction\n    import FromGitHub.randlet\n    if verbose: print(verbose_prefix+'Galactic extinction correction factor is '+str(FromGitHub.randlet.ToPrecision(irsa_band_excorr,4))+' (ie, '+str(FromGitHub.randlet.ToPrecision(irsa_band_excorr_mag,4))+' magnitudes).')\n    return irsa_band_excorr\n\n\n\n# A function to determine what particular band a given band name refers to\n# Args: The band name to be parsed\n# Returns: The parsed band name\ndef BandParse(band_name_target):\n\n    # Define dictionary containing lists of possible alternate names for each band\n    band_names_dict = {'GALEX_FUV':['GALEX_FUV','FUV','FUV-band','GALEX_f','f','f-band'],\n                       'GALEX_NUV':['GALEX_NUV','NUV','NUV-band','GALEX_n','n','n-band'],\n                       'SDSS_u':['SDSS_u','u','u-band','SDSS_u-band'],\n                       'SDSS_g':['SDSS_g','g','g-band','SDSS_g-band'],\n                       'SDSS_r':['SDSS_r','r','r-band','SDSS_r-band'],\n                       'SDSS_i':['SDSS_i','i','i-band','SDSS_i-band'],\n                       'SDSS_z':['SDSS_z','z','z-band','SDSS_z-band','VISTA_Z','VISTA_Z-band'],\n                       'CTIO_U':['CTIO_U','CTIO_U-band'],\n                       'CTIO_B':['CTIO_B','CTIO_B-band','B','B-band'],\n                       'CTIO_V':['CTIO_V','CTIO_V-band','V','V-band'],\n                       'CTIO_R':['CTIO_R','CTIO_R-band'],\n                       'CTIO_I':['CTIO_I','CTIO_I-band'],\n                       'DSS_B':['DSS_B','DSS1_B','DSSI_B','DSS2_B','DSSII_B','DSS_B-band','DSS1_B-band','DSSI_B-band','DSS2_B-band','DSSII_B-band','DSS_G','DSS1_G','DSSI_G','DSS2_G','DSSII_G','DSS_G-band','DSS1_G-band','DSSI_G-band','DSS2_G-band','DSSII_G-band'],\n                       'DSS_R':['DSS_R','DSS1_R','DSSI_R','DSS2_R','DSSII_R','DSS_R-band','DSS1_R-band','DSSI_R-band','DSS2_R-band','DSSII_R-band'],\n                       'DSS_I':['DSS_I','DSS1_I','DSSI_I','DSS2_I','DSSII_I','DSS_I-band','DSS1_I-band','DSSI_I-band','DSS2_I-band','DSSII_I-band'],\n                       '2MASS_J':['2MASS_J','J','J-band','2MASS_J-band'],\n                       '2MASS_H':['2MASS_H','H','H-band','2MASS_H-band'],\n                       '2MASS_Ks':['2MASS_Ks','Ks','Ks-band','2MASS_Ks-band','2MASS_K','2MASS_K-band','VISTA_Ks','VISTA_Ks-band','VISTA_K','VISTA_K-band','VIRCAM_Ks','VIRCAM_Ks-band','VIRCAM_K','VIRCAM_K-band'],\n                       'UKIRT_Y':['UKIRT_Y','UKIRT_Y-band','UKIDSS_Y','UKIDSS_Y-band','WFCAM_Y','WFCAM_Y-band','VISTA_Y','VISTA_Y-band','VIRCAM_Y','VIRCAM_Y-band'],\n                       'UKIRT_J':['UKIRT_J','UKIRT_J-band','UKIDSS_J','UKIDSS_J-band','WFCAM_J','WFCAM_J-band','VISTA_J','VISTA_J-band','VIRCAM_J','VIRCAM_J-band'],\n                       'UKIRT_H':['UKIRT_H','UKIRT_H-band','UKIDSS_H','UKIDSS_H-band','WFCAM_H','WFCAM_H-band','VISTA_H','VISTA_H-band','VIRCAM_H','VIRCAM_H-band'],\n                       'UKIRT_K':['UKIRT_K','UKIRT_K-band','K','K-band','UKIDSS_K','UKIDSS_K-band','WFCAM_K','WFCAM_K-band'],\n                       'Spitzer_3.6':['Spitzer_3.6','Spitzer_3.6um','Spitzer_3.6mu','Spitzer_IRAC_3.6','Spitzer_IRAC_3.6um','Spitzer_IRAC_3.6mu','Spitzer_IRAC1','Spitzer_I1','IRAC_3.6','IRAC_3.6um','IRAC_3.6mu','IRAC1','I1','Spitzer_IRAC1-band','IRAC1-band','I1-band','3.6','3.6um','3.6mu'],\n                       'Spitzer_4.5':['Spitzer_4.5','Spitzer_4.5um','Spitzer_4.5mu','Spitzer_IRAC_4.5','Spitzer_IRAC_4.5um','Spitzer_IRAC_4.5mu','Spitzer_IRAC2','Spitzer_I2','IRAC_4.5','IRAC_4.5um','IRAC_4.5mu','IRAC2','I2','Spitzer_IRAC2-band','IRAC2-band','I2-band','4.5','4.5um','4.5mu'],\n                       'Spitzer_5.8':['Spitzer_5.8','Spitzer_5.8um','Spitzer_5.8mu','Spitzer_IRAC_5.8','Spitzer_IRAC_5.8um','Spitzer_IRAC_5.8mu','Spitzer_IRAC3','Spitzer_I3','IRAC_5.8','IRAC_5.8um','IRAC_5.8mu','IRAC3','I3','Spitzer_IRAC3-band','IRAC3-band','I3-band','5.8','5.8um','5.8mu'],\n                       'Spitzer_8.0':['Spitzer_8.0','Spitzer_8.0um','Spitzer_8.0mu','Spitzer_IRAC_8.0','Spitzer_IRAC_8.0um','Spitzer_IRAC_8.0mu','Spitzer_IRAC4','Spitzer_I4','IRAC_8.0','IRAC_8.0um','IRAC_8.0mu','IRAC4','I4','Spitzer_IRAC4-band','IRAC4-band','I4-band','8.0','8.0um','8.0mu','Spitzer_8','Spitzer_8m','Spitzer_8mu','Spitzer_IRAC_8','Spitzer_IRAC_8um','Spitzer_IRAC_8mu','IRAC_8','IRAC_8um','IRAC_8mu','8','8um','8mu'],\n                       'WISE_3.4':['WISE_3.4','WISE_3.4um','WISE_3.4mu','WISE1','WISE1-band','W1','W1-band','WISE_W1','WISE_W1-band'],\n                       'WISE_4.6':['WISE_4.6','WISE_4.6um','WISE_4.6mu','WISE2','WISE2-band','W2','W2-band','WISE_W2','WISE_W2-band'],\n                       'PACS_70':['PACS_70','Herschel_70','Herschel-PACS_70'],\n                       'PACS_100':['PACS_100','Herschel_100','Hercshel-PACS_100'],\n                       'PACS_160':['PACS_160','Herschel_160','Herschel-PACS_160'],\n                       'SPIRE_250':['SPIRE_250','Hercshel_250','Hercshel-SPIRE_250'],\n                       'SPIRE_350':['SPIRE_350','Hercshel_350','Hercshel-SPIRE_350'],\n                       'SPIRE_500':['SPIRE_500','Hercshel_500','Hercshel-SPIRE_500'],\n                       'Planck_350':['Planck_857','Planck-HFI_350','Planck-HFI_857','HFI_350','HFI_857'],\n                       'Planck_550':['Planck_545','Planck-HFI_550','Planck-HFI_545','HFI_550','HFI_545'],\n                       'Planck_850':['Planck_353','Planck-HFI_850','Planck-HFI_353','HFI_850','HFI_353'],\n                       'Planck_1380':['Planck_217','Planck-HFI_1380','Planck-HFI_217','HFI_1380','HFI_217'],\n                       'Planck_2100':['Planck_143','Planck-HFI_2100','Planck-HFI_143','HFI_2100','HFI_143'],\n                       'Planck_3000':['Planck_100','Planck-HFI_3000','Planck-HFI_100','HFI_3000','HFI_100'],\n                       'Planck_4260':['Planck_70','Planck-LFI_4260','Planck_LFI_70','LFI_4260','LFI_70'],\n                       'Planck_6810':['Planck_44','Planck-LFI_6810','Planck_LFI_44','LFI_6810','LFI_44'],\n                       'Planck_10600':['Planck_30','Planck-LFI_10600','Planck_LFI_30','LFI_10600','LFI_30'],}\n\n    # Loop over alternate band name dictionary entries\n    band_altnames_matches = []\n    for band_name_key in band_names_dict.keys():\n        for band_altname in band_names_dict[band_name_key]:\n\n            # Make band names all-lowercase and alphanumeric-only, for ease of comparison\n            band_name_target_comp = re.sub(r'\\W+', '', band_name_target).replace('_','').lower()\n            band_altname_comp = re.sub(r'\\W+', '', band_altname).replace('_','').lower()\n\n            # Strip away wavelength and frequency units suffixes, for ease of comparison\n            unit_suffixes = ['um','micron','mm','GHz','MHz']\n            for unit in unit_suffixes:\n                band_name_target_comp = band_name_target_comp.replace(unit,'')\n                band_altname_comp = band_altname_comp.replace(unit,'')\n\n            # If target and alternate band names match, record\n            if band_name_target_comp==band_altname_comp:\n                band_altnames_matches.append(band_name_key)\n\n    # If no matches found, or more than one match found, report null output\n    if len(band_altnames_matches)==0:\n        return None\n    elif len(band_altnames_matches)>1:\n        raise Exception('Band name has multiple possible matches! Can you be more specific?')\n\n    # Else if a good match is found, return it\n    elif len(band_altnames_matches)==1:\n        return band_altnames_matches[0]\n\n\n\n# Function to read in file containing transmission functions for instruments, and convert to a dictionary\n# Kwargs: Path of a file containing transmisison information for all the bands (or, optionally, leave blank to look for Transmissions.dat in same directory as script).\n    # The first row for a given band takes form 'band,[BAND NAME]'.\n    # The following row for a given band is optional, and gives information about that band's reference spectrum, taking the form 'ref,[SPECTRUM_DESCRIPTION]'; the spectrum description can be either nu_X, where X is replaced by a number giving the index of some frequency-dependent power law spectrum; of BB_T, where T is replaced by a number giving the temperature of a blackbody spectrum.\n    # All subsequent rows for a given band then take the form '[SOME WAVELENGTH IN MICRONS],[TRANSMISSION FRACTION]'.\n    # This format can be repeated to fit transmissions data for any number of bands in one file.\n# Returns: Dictionary of filter transmissions\ndef TransmissionDict(path=None):\n\n    # If no path given, assume Tramsissions.dat file is in same directory as script\n    if path == None:\n        path = os.path.join(os.path.dirname(os.path.realpath(__file__)),'Transmissions.dat')\n\n    # Read in transmission curves file, and loop over lines\n    trans_dict = {'refs':{}}\n    with open(path) as curve_file:\n        curve_list = curve_file.readlines()\n    for i in range(0,len(curve_list)):\n        curve_line = curve_list[i]\n\n        # Check if this line indicates start of a new band; if so, start recording new band\n        if curve_line[:4] == 'band':\n            band = curve_line[5:].replace('\\n','')\n            trans_dict[band] = []\n\n        # Check if this line contains reference spectrun information; if so, place in the 'refs' dictionary entry\n        elif curve_line[:3] == 'ref':\n            trans_dict['refs'][band] = curve_line[4:].replace('\\n','')\n\n        # Check if this line contains regular transmission information; if so, record\n        else:\n            trans_dict[band].append(curve_line.replace('\\n','').split(','))\n\n    # Loop over filters in filter dict, setting them to be arrays\n    for curve in trans_dict.keys():\n        if curve != 'refs':\n            trans_dict[curve] = np.array(trans_dict[curve]).astype(float)\n\n    # Return finished dictionary\n    return trans_dict\n\n\n\n# Function to colour correct a flux density, for a given source SED, reference SED, and response curve\n# Args: Wavelength of source flux density (in metres), the source spectrum (a Nx2 array, of wavelengths in metres, and fluxes in whatever),\n    # the band filter (either a string giving name of a filter in Transmissions.dat, or a Nx2 array of wavelenghts in metres, and transmission fractions),\n# Kwargs: Reference spectrum (a Nx2 array of wavelengths in metres, and fluxes; although this can be left to None if this band is in Transmissions.dat),\n    # a dictionary containing transmission curves (optional, in case a custom dictionary is desired; must be in same format as yielded by TransmissionDict)\n    # and a boolean for fail-unsafe mode (where a correction factor of 1 will be returned if band name not recognised)\n# Returns: Colour correction factor (yes, FACTOR)\ndef ColourCorrect(wavelength, source_spec, band_filter, ref_spec=None, trans_dict=None, fail_unsafe=False):\n\n    # Define physical constants\n    c = 3E8\n    h = 6.64E-34\n    k = 1.38E-23\n\n    # Check if a filter curve has been provided, or if a band name has been given for a common band in Transmissions.dat\n    if isinstance(band_filter, np.ndarray):\n        band_name = False\n    elif isinstance(band_filter, str):\n        band_name = copy.copy(band_filter)\n\n        # If a dictionary of curves has already been provided, use it; else read in Transmissions.dat\n        if trans_dict == None:\n            trans_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),'Transmissions.dat')\n            if os.path.exists(trans_path):\n                trans_dict = TransmissionDict(trans_path)\n            else:\n                raise Exception('Dictionary of band transmissions not given, and no Transmissions.dat file found in same directory as script')\n\n        # Check that requested filter is actually in dictionary; if it is, grab it, and convert wavelengths from microns to metres\n        if band_filter not in trans_dict.keys():\n            if fail_unsafe:\n                return 1.0\n            else:\n                raise Exception('Reqested filter not in database of common filters; please provide as an array instead')\n        else:\n            band_filter = trans_dict[band_filter].copy()\n            band_filter[:,0] \/= 1E6\n\n    # Check if reference spectrum present in transmission dictionary; if it is, construct spectrum array\n    if isinstance(ref_spec, np.ndarray):\n        pass\n    elif (isinstance(band_name, str)) and (ref_spec == None) and (band_name in trans_dict.keys()) and (band_name in trans_dict['refs'].keys()):\n        nu = (c \/ band_filter[:,0])\n\n        # If reference is a power law, turn into corresponding array of values at same wavelength intervals as filter curve\n        if trans_dict['refs'][band_name][:2] == 'nu':\n            index = float(trans_dict['refs'][band_name][3:])\n            ref_spec = np.zeros(band_filter.shape)\n            ref_spec[:,0] = band_filter[:,0]\n            ref_spec[:,1] = nu**index\n            #ref_spec[:,1] \/= np.max(ref_spec[:,1])\n\n        # If reference spectrum is a blackbody, turn into a corresponding array of values at same wavelength intervals as filter curve\n        if trans_dict['refs'][band_name][:2] == 'BB':\n            temp = float(trans_dict['refs'][band_name][3:])\n            ref_spec = np.zeros(band_filter.shape)\n            ref_spec[:,0] = band_filter[:,0]\n            planck_prefactor = np.divide((2.0 * h * nu**3.0), c**2.0)\n            planck_exponent = (h * nu) \/ (k * temp)\n            ref_spec[:,1] = planck_prefactor * (np.e**planck_exponent - 1)**-1.0\n            #ref_spec[:,1] \/= np.max(ref_spec[:,1])\n\n    # If reference spectrum not in Transmission.dat, nor provided by user, raise exception\n    else:\n        raise Exception('Reference spectrum not given, nor found in dictionary of band transmissions; please provide reference spectrum')\n\n    # Normalise source and reference SEDs to have observed flux at (interpolated) nominal wavelength\n    source_spec[:,1] \/= np.interp(wavelength, source_spec[:,0], source_spec[:,1])\n    ref_spec[:,1] \/= np.interp(wavelength, ref_spec[:,0], ref_spec[:,1])\n\n    # Filter SEDs by response curve (appropriately resampled in wavelength intervals), to record observed flux\n    source_obs = source_spec[:,1] * np.interp(source_spec[:,0], band_filter[:,0], band_filter[:,1])\n    ref_obs = ref_spec[:,1] * np.interp(ref_spec[:,0], band_filter[:,0], band_filter[:,1])\n\n    # Integrate observed filtered SEDs (in intervals of freqency, as Jy are in terms of Hz)\n    source_int = np.trapz(source_obs, x=(c\/source_spec[:,0]))\n    ref_int = np.trapz(ref_obs, x=(c\/ref_spec[:,0]))\n\n    # Calculate and return colour correction factor from integrals\n    colour_corr_factor = ref_int \/ source_int\n    return colour_corr_factor\n\n\n\n# Function to find uncertainty in an array, in terms of distance from given value, out to a certain percentile limit\n# Args: Array of numbers to find uncertainty of, percentile range to find uncertainty out to, boolean of whether to return up-and-down bound values\n# Returns: Percentile uncertainty\ndef PercentileError(data, value, percentile=68.27, bounds=False):\n    data = Nanless(data)\n    percentile = np.float(percentile)\n    if bounds==False:\n        error = ( np.sort( np.abs( data - value ) ) )[ np.int( (percentile\/100.0) * data.shape[0] ) ]\n        return error\n    elif bounds==True:\n        data_up = data[ np.where( data>=value ) ]\n        data_down = data[ np.where( data<value ) ]\n        error_up = np.percentile( np.sort(np.abs(data_up-value)), percentile )\n        error_down = np.percentile( np.sort(np.abs(data_down-value)), percentile )\n        return (error_down, error_up)\n\n\n\n# Function to find the uncertainty on a median (or mean) of a dataset by bootstrapping\n# Args: Data in question; (int of number of boostrap resmaples to use; boolean of whether to use mean instead of median; boolean False or quantile to use if using percentile instead of standard deviation)\n# Returns: Computed uncertainty on average\ndef AvgUncBootstrap(data, n_samples=100, mean=False, percentile=False):\n\n    # Make sure input data is a flat numpy array\n    data = np.array(data)\n    data = data.flatten()\n\n    # Take average\n    if not mean:\n        avg = np.nanmedian(data)\n    else:\n        avg = np.nanmean(data)\n\n    # Generate boostrap resamples, and take averages of them\n    samples = np.array([np.random.choice(data,size=len(data),replace=True) for i in range(n_samples)])\n    if not mean:\n        samples_avgs = np.nanmedian(samples, axis=1)\n    else:\n        samples_avgs = np.nanmean(samples, axis=1)\n\n    # Find uncertainty on sample averages\n    if percentile == False:\n        avg_unc = np.std(samples_avgs)\n    else:\n        avg_unc = np.nanpercentile(np.abs(samples_avgs-avg), percentile)\n\n    # Return result\n    return avg_unc\n\n\n\n# Function to find the uncertainty on a median (or mean) of a dataset containing a selection of subsets by bootstrapping\n# Args: 2D array of data in question [n_subsets X n_datapoints]; (int of number of boostrap resmaples to use; boolean of whether to use mean instead of median; boolean False or quantile to use if using percentile instead of standard deviation)\n# Returns: Computed uncertainty on average\ndef SubsetAvgUncBootstrap(data, n_samples=100, mean=False, percentile=False):\n\n    # Take average\n    if not mean:\n        avg = np.nanmedian(data)\n    else:\n        avg = np.nanmean(data)\n\n    # Generate boostrap resamples, by drawing a random sample of the subsets\n    samples = np.nan * np.zeros([data.shape[0], data.shape[1], n_samples])\n    for b in range(n_samples):\n        indxs = np.random.choice(np.arange(data.shape[0]), size=data.shape[0], replace=True)\n        samples[:,:,b] = data[indxs,:]\n\n    # Take averages of resampled data\n    if not mean:\n        samples_avgs = np.nanmedian(samples, axis=(0,1))\n    else:\n        samples_avgs = np.nanmean(samples, axis=2)\n\n    # Find uncertainty on sample averages\n    if percentile == False:\n        avg_unc = np.std(samples_avgs)\n    else:\n        avg_unc = np.nanpercentile(np.abs(samples_avgs-avg), percentile)\n\n    # Return result\n    return avg_unc\n\n\n\n# Function to trim an array to a given size\n# Args: Array to be trimmed, i & j coordinates of centre of trimmed region, width of trimmed region\n# Returns: Trimmed array\ndef Trim(data, i_centre, j_centre, width):\n    box_rad  = int(round(float(width)\/2.0))\n    i_cutout_min = max([0, i_centre-box_rad])\n    i_cutout_max = min([(data.shape)[0], i_centre+box_rad])\n    j_cutout_min = max([0, j_centre-box_rad])\n    j_cutout_max = min([(data.shape)[1], j_centre+box_rad])\n    trimmed = data[ int(round(i_cutout_min)):int(round(i_cutout_max)), int(round(j_cutout_min)):int(round(j_cutout_max)) ]\n    i_centre = (int(round(float(trimmed.shape[0])\/2.0))+1) + ( (i_centre-box_rad) - (int(round(i_cutout_min))) )\n    j_centre = (int(round(float(trimmed.shape[1])\/2.0))+1) + ( (j_centre-box_rad) - (int(round(j_cutout_min))) )\n    return trimmed, [i_centre, j_centre]\n\n\n\n# Wrapper around Scipy grid interpolation function, to inpute NaN pixels in 2D data\n# Args: Image to have NaN pixels imputed over\n# Returns: Image with NaN pixels imputed\ndef ImputeImage(img_in):\n    bad_coords = np.where(np.isnan(img_in))\n    good_coords = np.where(np.isnan(img_in) == False)\n    good_values = img_in[good_coords]\n    bad_values_interp = scipy.interpolate.griddata(good_coords, good_values, bad_coords, method='cubic')\n    img_out = img_in.copy()\n    img_out[bad_coords] = bad_values_interp\n    return img_out\n\n\n\n# Function that uses Driver & Robotham (2010) foruma to give percentage cosmic variance\n# Args: Survey volume (in Mpc^3, assuming H0=70 km s^-1 Mpc^-1), number of survey fields, survey field aspect ratio\n# Returns: Percentage cosmic variance\ndef CosmicVariance(v, n, x):\n    v, n, x = float(v), float(n), float(x)\n    first_term = 1.00 - ( 0.03 * np.sqrt(x-1.0) )\n    second_term = ( 219.7 - (52.4*np.log10(v)) + (3.21*(np.log10(v))**2.0) ) \/ n**0.5\n    cv = first_term * second_term\n    return cv\n\n\n\n# Function to convert the bin-edge output of np.histogram to be bin-centred (and this of same dimensions as bin totals)\n# Args: Array of bin edges\n# Returns: Array of bin centres\ndef HistBinMerge(bin_edges):\n    bin_edges = np.array(bin_edges)\n    bin_centres = np.zeros([bin_edges.shape[0]-1])\n    for i in range(0, bin_edges.shape[0]-1):\n        bin_centres[i] = np.mean([bin_edges[i],bin_edges[i+1]])\n    return bin_centres\n\n\n\n# Function to perform gaussian fit to data\n# Args: Array of data to be fit\n# Returns: Mean of fit, standard deviation of fit\ndef GaussFit(data, n_bins=50):\n    def QuickGauss(x, *p):\n        A, mu, sigma = p\n        return A * np.exp( (-((x-mu)**2.0)) \/ (2.0*sigma**2.0) )\n    hist_tots, hist_bins = np.histogram(data, bins=n_bins)\n    hist_bins = HistBinMerge(hist_bins)\n    hist_guesses = [np.max(hist_tots), np.mean(data), np.std(data)]\n    hist_fit = scipy.optimize.curve_fit(QuickGauss, hist_bins, hist_tots, p0=hist_guesses)\n    return abs(hist_fit[0][1]), abs(hist_fit[0][2])\n\n\n\n# Function to convert an observed brightness into a luminosity\n# Args: Flux (Jy), distance (pc) frequency or boolean for nuSnu luminosity (Hz or False), boolean to switch flux input to AB magnitudes\n# Output; Luminosity in bolometric solar luminosities\ndef FluxToLum(flux, dist, freq=False, mags=False):\n    if mags==True:\n        flux = ABMagsToJy(flux)\n    watts_per_hz = 10.0**-26.0 * flux * 4.0 * np.pi * ( dist * 3.26 * 9.5E15 )**2.0\n    if freq==False:\n        watts = watts_per_hz\n    elif (freq!=False) and (freq>0):\n        watts = watts_per_hz * freq\n    Lsol = watts \/ 3.846E26\n    return Lsol\n\n\n\n# Function to convert SDSS-III \"nanomaggies\" (nMgy) into pogson magnitudes\n# Args: Value to be converted (nanomaggies)\n# Returns: Pogson magnitudes (mags; duh)\ndef nMaggiesToMags(nMaggies):\n    mag = 22.5 - ( 2.5*np.log10(nMaggies) )\n    return mag\n\n\n\n# Function to convert GAMA data units into AB pogson magnitudes\n# Args: Value to be converted (data units)\n# Returns: AB pogson magnitudes (mags; duh)\ndef GAMACountsToMags(GAMA):\n    mag = 30.0 - ( 2.5*np.log10(GAMA) )\n    return mag\n\n\n\n# Function to convert from AB pogson magnitudes into GAMA data units\n# Args: Value to be converted (mags)\n# Returns: AB pogson magnitudes (data units)\ndef GAMAMagsToCounts(mag):\n    GAMA = 10.0**( (30.0-mag) \/ 2.5 )\n    return GAMA\n\n\n\n# Function to convert from AB pogson magnitudes into flux in janskys\n# Args: Value to be converted (mags)\n# Returns: Source flux density (Jy)\ndef ABMagsToJy(mag):\n    Jy = 1E-6 * 10.0**((23.9-mag)\/2.5)\n    return Jy\n\n\n\n# Function to convert from flux in janskys to AB pogson magnitudes\n# Args: Value to be converted (mags)\n# Returns: Source flux density (Jy)\ndef JyToABMags(Jy):\n    mag = 23.9 - ( 2.5 * np.log10( Jy * 10**6.0 ) )\n    return mag\n\n\n\n# Function to convert an uncertainty in AB pogson magnitudes to an uncertainty in janskys\n# Args: Uncertainty to be converted (mags), and its associated measurement (mags)\n# Returns: Uncertainty in flux density (Jy)\ndef ErrABMagsToJy(err, mag):\n    Jy_down = ABMagsToJy(mag) - ABMagsToJy(mag + err)\n    Jy_up = ABMagsToJy(mag - err) - ABMagsToJy(mag)\n    Jy = ( Jy_down + Jy_up ) \/ 2.0\n    return Jy\n\n\n\n# Function to convery absolute AB pogson magnitudes into solar luminosities\n# Args: Absolute AB pogson magnitude (Mags)\n# Returns: Luminosity (Lsol):\ndef ABAbsToLsol(Mag):\n    Lsol = 10.0**( (4.58 - Mag ) \/ 2.51 )\n    return Lsol\n\n\n\n# Function to convert an RMS deviation in relative linear flux to magnitudes\n# Args: Relative RMS deviation in flux\n# Returns: RMS deviation in mangitude\ndef RMSFluxToMags(S_rms):\n    M_rms = abs( 2.5 * np.log10(1.0-S_rms) )\n    return M_rms\n\n\n\n# Function to convert an RMS deviation in magnitude to relative linear flux\n# Args: RMS deviation in magnitude\n# Returns: RMS deviation in relative flux\ndef RMSMagsToFlux(m_rms):\n    S_rms = 1.0 - abs( 10.0**(m_rms\/-2.5) )\n    return S_rms\n\n\n\n# New function to convert an uncertainty to log space\n# Args: Value, uncertainty\n# Returns: Logarithmic uncertainty\ndef LogError(value, error):\n    value, error = np.array(value), np.array(error)\n    frac = 1.0 + (error\/value)\n    error_up = value * frac\n    error_down = value \/ frac\n    log_error_up = np.abs( np.log10(error_up) - np.log10(value) )\n    log_error_down = np.abs( np.log10(value) - np.log10(error_down) )\n    return 0.5*(log_error_up+log_error_down)\n\n\n\n# Function to convert a logarithmic uncertainty to linear space\n# Args: Logarithmic value, logarithmic uncertainty, boolean of whether average unlogged errors or return them asymetrically\n# Returns: Linear uncertainty\ndef UnlogError(log_value, log_error, bounds=False):\n    if bounds==False:\n        value = 10**log_value\n        log_up = log_value + log_error\n        log_down = log_value - log_error\n        lin_up = 10**log_up\n        lin_down = 10**log_down\n        rel_up = lin_up \/ value\n        rel_down = lin_down \/ value\n        frac = (0.5 * (rel_up + (rel_down**-1))) - 1.0\n        return frac * value\n    elif bounds==True:\n        error_up = 10.0**(log_value + log_error) - 10.0**log_value\n        error_down = 10.0**(log_value - log_error) - 10.0**log_value\n        return [error_up, error_down]\n\n\n\n# Function to generate appropriate dimensions plot divisions of a figure in along a given direction\n# Args: Index of plot element in question, total number of plot elements, dimension of figure, x or y axis,\n# Returns: Starting position of plot, dimension of plot\ndef GridPos(n_plot, n_tot, img_dim, axis='y', nonstandard=False, gaps=False):\n    if nonstandard>0:\n        base = nonstandard\n    elif nonstandard==False:\n        if axis=='y':\n            base = 6.0\n        elif axis=='x':\n            base = 8.0\n    n_plot, n_tot, img_dim = float(n_plot), float(n_tot), float(img_dim)\n    margin_start = 0.125 * (base \/ img_dim)\n    margin_end = (1.0 - 0.95) * (base \/ img_dim)\n    fig_start = margin_start\n    fig_end = 1.0 - margin_end\n    fig_dim = fig_end - fig_start\n    plot_dim = fig_dim \/ n_tot\n    plot_start = fig_start + (n_plot * plot_dim)\n    if gaps>0:\n        plot_start += (0.5 * gaps) * plot_dim\n        plot_dim *= 1.0 - (0.5 * gaps)\n    return plot_start, plot_dim\n\n\n\n# Function to find the Sheather-Jones bandwidth estimator (<NAME>, 1991), adapted from: https:\/\/github.com\/Neojume\/pythonABC\n# Args: Array of values of which bandwidth will be found\n# Returns: Sheather-Jones bandwidth of array\ndef SheatherJonesBW(x, weights=None):\n\n    # Define Equation 12 from Sheather & Jones (1991)\n    def sj12(x, h):\n        phi6 = lambda x: (x ** 6 - 15 * x ** 4 + 45 * x ** 2 - 15) * scipy.stats.norm.pdf(x, loc=0.0, scale=1.0)\n        phi4 = lambda x: (x ** 4 - 6 * x ** 2 + 3) * scipy.stats.norm.pdf(x, loc=0.0, scale=1.0)\n        n = len(x)\n        one = np.ones((1, n))\n        lam = np.percentile(x, 75) - np.percentile(x, 25)\n        a = 0.92 * lam * n ** (-1 \/ 7.0)\n        b = 0.912 * lam * n ** (-1 \/ 9.0)\n        W = np.tile(x, (n, 1))\n        W = W - W.T\n        W1 = phi6(W \/ b)\n        tdb = np.dot(np.dot(one, W1), one.T)\n        tdb = -tdb \/ (n * (n - 1) * b ** 7)\n        W1 = phi4(W \/ a)\n        sda = np.dot(np.dot(one, W1), one.T)\n        sda = sda \/ (n * (n - 1) * a ** 5)\n        alpha2 = 1.357 * (abs(sda \/ tdb)) ** (1 \/ 7.0) * h ** (5 \/ 7.0)\n        W1 = phi4(W \/ alpha2)\n        sdalpha2 = np.dot(np.dot(one, W1), one.T)\n        sdalpha2 = sdalpha2 \/ (n * (n - 1) * alpha2 ** 5)\n        return (scipy.stats.norm.pdf(0, loc=0, scale=np.sqrt(2)) \/\n                (n * abs(sdalpha2[0, 0]))) ** 0.2 - h\n\n    # Bandwidth estimator for normal case (From paragraph 2.4.2 of Bowman & Azzalini, 1997)\n    def hnorm(x, weights=None):\n        wmean = lambda x,w: sum(x * w) \/ float(sum(w))\n        wvar = lambda x,w: sum(w * (x - wmean(x, w)) ** 2) \/ float(sum(w) - 1)\n        x = np.asarray(x)\n        if weights is None:\n            weights = np.ones(len(x))\n        n = float(sum(weights))\n        if len(x.shape) == 1:\n            sd = np.sqrt(wvar(x, weights))\n            return sd * (4 \/ (3 * n)) ** (1 \/ 5.0)\n        if len(x.shape) == 2:\n            ndim = x.shape[1]\n            sd = np.sqrt(np.apply_along_axis(wvar, 1, x, weights))\n            return (4.0 \/ ((ndim + 2.0) * n) ** (1.0 \/ (ndim + 4.0))) * sd\n\n    # Actual calculator of bandwidth\n    h0 = hnorm(x)\n    v0 = sj12(x, h0)\n    if v0 > 0:\n        hstep = 1.1\n    else:\n        hstep = 0.9\n    h1 = h0 * hstep\n    v1 = sj12(x, h1)\n    while v1 * v0 > 0:\n        h0 = h1\n        v0 = v1\n        h1 = h0 * hstep\n        v1 = sj12(x, h1)\n    return h0 + (h1 - h0) * abs(v0) \/ (abs(v0) + abs(v1))\n\n\n\n# Function to remove all NaN entries from an array\n# Args: Array to be cleansed\n# Returns: Purified array\ndef Nanless(bad):\n    bad = np.array(bad)\n    good = bad[np.where(np.isnan(bad)==False)]\n    return good\n\n\n\n\n# Function to aappend an arbitrarily long list of arrays into 1 array:\n# Args: List of numpy arrays\n# Returns: One big appended (1D) numpy array\ndef PanAppend(arr_list):\n    n_arr = len(arr_list)\n    arr_app = np.array([])\n    for i in range(0,n_arr):\n        arr_app = np.append( arr_app, np.array( arr_list[i] ) )\n    return arr_app\n\n\n\n# Function to wget a file from a given URL to a given directory\n# Args: String of target url, string of output filepath, boolean for clobbering, boolean for auto-retrying, boolean for verbosity\n# Returns: None\ndef wgetURL(url, filename, overwrite=True, auto_retry=False):\n    if os.path.exists(filename):\n        if overwrite:\n            os.remove(filename)\n        else:\n            raise Exception('Output file already exists; if you\\'re happy to overwrite it, re-run wgetURL with overwrite=True.')\n    success = False\n    while success==False:\n        try:\n            try:\n                wget.download(url, out=filename)\n            except:\n                os.system('wget \\\"'+url+'\\\" -O '+filename)\n            print('Successful acquisition of '+url)\n            success = True\n        except:\n            print('Failure! Retrying acquistion of '+url)\n            time.sleep(0.1)\n            success = False\n            if not auto_retry:\n                raise Exception('Unsuccessful wget attempt.')\n\n\n\n# Function to delete a directory \"as best it can\"; fully if possible, else by recursievely removing all delete-able files\n# Args: Path of directory to delete\n# Returns: None\ndef RemoveCrawl(directory):\n    try:\n        shutil.rmtree(directory)\n    except:\n        for glob_path in glob.glob(os.path.join(directory,'**'), recursive=True):\n            if os.path.isfile(glob_path):\n                try:\n                    os.remove(glob_path)\n                except:\n                    pass\n\n\n\n# Function to estimate time until a task completes\n# Args: List of time taken by each iteration in units of seconds since Unix epoch, total number of iterations\n# Returns: Python time string of estimated time\/date of completion\ndef TimeEst(time_list, total, plot=False, raw=False):\n\n    # Convert times into log space, fit trend, project, and un-log\n    time_list_log = np.log10(np.array(time_list))\n    iter_list = np.arange( 0.0, float(len(time_list)) )\n    time_fit_log = np.polyfit(iter_list, time_list_log, 1)\n\n    # Find offset between most recent time value, and fit at that point\n    time_latest_actual = time_list[-1:][0]\n    time_latest_predicted_log = ( time_fit_log[0] * (float(np.array(time_list).shape[0])-1.0) ) + time_fit_log[1]\n    time_latest_offset_log = np.log10(time_latest_actual) - time_latest_predicted_log\n    time_fit_log[1] += time_latest_offset_log\n\n    # Predict time of completion\n    time_end_log = ( time_fit_log[0] * total ) + time_fit_log[1]\n    time_end = 10.0**time_end_log\n\n    # If requested, create plot\n    if plot:\n        fig = plt.figure(figsize=(8,6))\n        ax_dims = [0.125, 0.125, 0.825, 0.825]\n        ax = fig.add_axes(ax_dims)\n\n        # Create plotting arrays\n        time_list_hours = ( np.array(time_list) - time_list[0] ) \/ 3600.0\n        time_end_hours = ( time_end - time_list[0] ) \/ 3600.0\n        line_x = np.linspace(0, total, 10000)\n        line_y_log = ( time_fit_log[0] * line_x ) + time_fit_log[1]\n        line_y = ( 10.0**( line_y_log ) - time_list[0] ) \/ 3600.0\n\n        # Plot points, and line of best fit\n        ax.scatter(iter_list, time_list_hours, c='#4D78C9', marker='o', s=25, linewidths=0)\n        ax.scatter(total, time_end_hours, c='#C03030', marker='H', s=100, linewidths=0)\n        ax.plot(line_x, line_y, ls='--', lw=1.0, c='#C03030')\n\n        # Format axis limts and labels\n        ax.set_xlabel(r'Iteration', fontsize=15)\n        ax.set_ylabel(r'Time Since Start (hrs)', fontsize=15)\n        ax.set_xlim(0.0,1.1*line_x.max())\n        ax.set_ylim(0.0,1.1*line_y.max())\n        for xlabel in ax.get_xticklabels():\n            xlabel.set_fontproperties(matplotlib.font_manager.FontProperties(size=15))\n        for ylabel in ax.get_yticklabels():\n            ylabel.set_fontproperties(matplotlib.font_manager.FontProperties(size=15))\n        ax.grid(linestyle='dotted')\n        ax.xaxis.set_minor_locator(matplotlib.ticker.AutoMinorLocator())\n        ax.yaxis.set_minor_locator(matplotlib.ticker.AutoMinorLocator())\n\n    # Produce human-readable output, if required\n    if not raw:\n        time_end = time.strftime('%H:%M:%S %a %d %b %Y', time.localtime(time_end))\n\n    # Return estimate (and plot, if requested)\n    if plot:\n        return time_end, fig\n    elif not plot:\n        return time_end\n\n\n\n# Function that uses small files in a temporary folder to track progress of parallel functions\n# Input; Progress directory to use, total number of iterations to be completed\n# Outut: How many iterations have completed, and estimated completion time\ndef ProgressDir(prog_dir, iter_total, raw=False):\n\n    # If directory doens't seem to exist, wait a bit to see if some parallel process makes it first\n    prog_dir_exists = False\n    for i in range(0,5):\n        if os.path.exists(prog_dir):\n            prog_dir_exists = True\n            break\n        else:\n            time.sleep(1.0 + (5.0 * np.random.random()))\n\n    # If directory definately doesn't already exist, create it, add time file, and finish up\n    if not prog_dir_exists:\n        try:\n            os.mkdir(prog_dir)\n            prog_file = open( os.path.join(prog_dir, str(time.time())), 'w')\n            prog_file.close()\n            return 1, 'pending'\n        except:\n            prog_dir_exists = True\n\n    # Else if progress directroy does indeed exist, carry on\n    if prog_dir_exists:\n\n        # Create file in directory, with filename recording the current time (assuming no identically-named file exists)\n        while True:\n            prog_filename = os.path.join(prog_dir, str(time.time()))\n            if not os.path.exists(prog_filename):\n                prog_file = open(prog_filename, 'w')\n                prog_file.close()\n                break\n\n        # List of all files in directory, and convert to list of completion times, and record completed iterations\n        prog_list = np.array([ float(prog_time) for prog_time in os.listdir(prog_dir) ])\n        prog_list.sort()\n        prog_list = prog_list.tolist()\n        iter_complete = len(prog_list)\n\n        # Estimate time until completion\n        time_est = TimeEst(prog_list, iter_total, raw=raw)\n\n        # If this was the final iteration, clean up\n        if iter_complete == iter_total:\n            time.sleep(10)\n            shutil.rmtree(prog_dir)\n\n        # Return results\n        return iter_complete, time_est\n\n\n\n# A context manager to suppress console output, even from external code (like IDL)\n# Input: Optional choice of where to redirect output to\n# Output: None\ndef StdOutRedirect(to=os.devnull):\n    raise Exception('Just use with contextlib.redirect_stdout(None) instead')\n\n\n\n\n\n\"\"\"\n# IDIUT'S GUIDE TO ELLIPTICAL APERTURES\nI assume you also know the location of the ellipse's center. Call that (x0,y0).\nLet t be the counterclockwise angle the major axis makes with respect to the\nx-axis. Let a and b be the semi-major and semi-minor axes, respectively. If\nP = (x,y) is an arbitrary point then do this:\n\nX = (x-x0)*cos(t)+(y-y0)*sin(t); % Translate and rotate coords.\nY = -(x-x0)*sin(t)+(y-y0)*cos(t); % to align with ellipse\n\nIf\n\nX^2\/a^2+Y^2\/b^2\n\nis less than 1, the point P lies inside the ellipse. If it equals 1, it is right on\nthe ellipse. If it is greater than 1, P is outside.\n\"\"\"\n\n\"\"\"\ntarget = wcs_in.wcs_world2pix(np.array([[178.54283, 0.1388639]]), 0)\ncutout_inviolate = ChrisFuncs.PurgeStarPieter(cutout_inviolate, 298.49901264, 304.47718041, 0, 5)\nChrisFuncs.FitsCutout('E:\\\\Work\\\\H-ATLAS\\\\HAPLESS_Cutouts\\\\HAPLESS_1_NUV.fits', 178.55113899, 0.13662582, 1000, exten=0, variable=False, outfile='E:\\\\Work\\\\NUV.fits')\n\"\"\"\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_487","text":"<filename>examples\/multidaq_sync.py\n\"\"\"\nSynchronised multiple daqs\n==========================\n\nThis examples demonstrates the use of multiple daq devices in a synchronised\nfashion. To synchronise the two daqs, we have to oversample the slower one.\nDaqs need not have sampling rates that are integer multiples of one another,\nyet, it makes sense to set their read_sizes such that it takes \"roughly\" the\nsame time to perform a read operation from the various devices. A DumbDaq is\nused as a master daq to control the main program update rate (i.e. master\nclock). We might want to set the properties of the master daq to be equal to\nthat of the faster of the real daqs. This is however not strict; we could\nalso set the read time of the  master daq to be even faster (but not slower).\nIn that case, we would end up also oversampling the faster daq. An alternative\nwould be to use the faster daq as the master daq. When each daq is updated\nwe store its values in a cache. When the master clock ticks, the cache from\neach daq is queried. Note that by \"fast\" and \"slow\", we do not refer to the\nsampling rate of the daq, but rather the time needed to complete a `read()`\noperation, which is dependent on both the rate and the read_size.\n\nThe example demonstrates how to store the raw data from the multiple devices\nand also how to combine (through concatenation) and store their processed data.\nThe various devices may provide series of different lengths but interpolation\nis not required as the final step of the processing pipeline includes a\nfeature computation that is performed along the time axis.\n\nIf ``rate_m``, ``read_size_m`` and ``counter_m`` are the sampling rate, read\nsize and the counter limit, respectively, of the master daq, and ``rate`` and\n``read_size`` are the rate and read size of a real daq, then the output raw\ndata array for this device is expected to have shape:\n(n_channels, rate * int(counter_m * read_size_m \/ rate_m)).\n\nThe concatenated processed data array will have shape:\n(n_total_channels, counter_m), where ``n_total_channels`` is the sum of the\nnumber of channels of the various devices.\n\"\"\"\n\nimport numpy as np\nfrom scipy.signal import butter\n\nfrom axopy.experiment import Experiment\nfrom axopy.task import Task\nfrom axopy.timing import Counter\nfrom axopy.gui.canvas import Canvas, Text\nfrom axopy.features import mean_absolute_value\nfrom axopy.pipeline import Pipeline, Windower, Callable, Filter\n\n\nclass CountTask(Task):\n    def __init__(self, rate, readsize):\n        super().__init__()\n        self.rate = rate\n        self.readsize = readsize\n        self.pipeline = {\n            'daq_1': self.make_pipeline(rate=self.rate['daq_1'],\n                                        readsize=self.readsize['daq_1'],\n                                        winsize=250,\n                                        lowpass=100,\n                                        highpass=500),\n            'daq_2': self.make_pipeline(rate=self.rate['daq_2'],\n                                        readsize=self.readsize['daq_2'],\n                                        winsize=15,\n                                        lowpass=5,\n                                        highpass=15)\n        }\n        # This is where the data from the multiple streams will be stored\n        # after they have been processed.\n        self.cache = {'daq_1': None, 'daq_2': None}\n\n    def make_pipeline(self, rate, readsize, winsize, lowpass, highpass):\n        b, a = butter(4, (lowpass\/rate\/2., highpass\/rate\/2.), 'bandpass')\n        pipeline = Pipeline([\n            Windower(winsize),\n            # overlap = winsize - read_rate\n            Filter(b, a=a, overlap=winsize-readsize),\n            Callable(mean_absolute_value,\n                     func_kwargs={'axis': 1, 'keepdims': True})\n        ])\n\n        return pipeline\n\n    def prepare_design(self, design):\n        block = design.add_block()\n        block.add_trial()\n\n    def prepare_graphics(self, container):\n        self.text0 = Text('Master: 0')\n        self.text0.pos = -0.2, 0.5\n\n        self.text1 = Text('Daq 1: 0')\n        self.text1.pos = -0.2, 0\n\n        self.text2 = Text('Daq 2: 0')\n        self.text2.pos = -0.2, -0.5\n\n        canvas = Canvas()\n        canvas.add_item(self.text0)\n        canvas.add_item(self.text1)\n        canvas.add_item(self.text2)\n        container.set_widget(canvas)\n\n    def prepare_daq(self, daqstream):\n        # The master counter will determine trial time, i.e.\n        # trial_time = counter_limit * read_daq \/ rate_daq\n        self.counter0 = Counter(101, reset_on_timeout=False)\n        self.counter1 = Counter(1000)\n        self.counter2 = Counter(1000)\n\n        self.counter0.timeout.connect(self.finish_trial)\n\n        self.daqstream = daqstream\n\n    def prepare_storage(self, storage):\n        self.writer = storage.create_task('async_daqs')\n\n    def run_trial(self, trial):\n        trial.add_array('dev_1_raw', stack_axis=1)\n        trial.add_array('dev_2_raw', stack_axis=1)\n        trial.add_array('dev_12_processed', stack_axis=1)\n\n        self.daqstream['daq_0'].start()\n        self.daqstream['daq_1'].start()\n        self.daqstream['daq_2'].start()\n\n        self.daqstream['daq_0'].updated.connect(self.update_daq0)\n        self.daqstream['daq_1'].updated.connect(self.update_daq1)\n        self.daqstream['daq_2'].updated.connect(self.update_daq2)\n\n    def update_daq0(self):\n        # Daq 0 is the \"master\" Daq, i.e. an update happens when daq 0 is\n        # updated. The check is used to ensure that updates start only after\n        # the two streams have started providing data.\n        if not any(elem is None for elem in self.cache.values()):\n            daq1data = self.cache['daq_1'].copy()\n            daq2data = self.cache['daq_2'].copy()\n            data_c = np.concatenate((daq1data, daq2data), axis=0)\n\n            self.trial.arrays['dev_12_processed'].stack(data_c)\n\n            self.counter0.increment()\n            self.text0.qitem.setText(\"Master: \" + str(self.counter0.count))\n\n    def update_daq1(self, data):\n        self.counter1.increment()\n        self.text1.qitem.setText(\"Daq 1: \" + str(self.counter1.count))\n\n        data_proc = self.pipeline['daq_1'].process(data)\n        self.cache['daq_1'] = data_proc\n        self.trial.arrays['dev_1_raw'].stack(data)\n\n    def update_daq2(self, data):\n        self.counter2.increment()\n        self.text2.qitem.setText(\"Daq 2: \" + str(self.counter2.count))\n\n        data_proc = self.pipeline['daq_2'].process(data)\n        self.cache['daq_2'] = data_proc\n        self.trial.arrays['dev_2_raw'].stack(data)\n\n    def finish_trial(self):\n        self.writer.write(self.trial)\n\n        self.daqstream['daq_0'].updated.disconnect(self.update_daq0)\n        self.daqstream['daq_1'].updated.disconnect(self.update_daq1)\n        self.daqstream['daq_2'].updated.disconnect(self.update_daq2)\n\n        # use wait=False so these don't hang up the final graphics update\n        self.daqstream['daq_0'].stop(wait=False)\n        self.daqstream['daq_1'].stop(wait=False)\n        self.daqstream['daq_2'].stop(wait=False)\n\n        self.finish()\n\n\nif __name__ == '__main__':\n    from axopy.daq import NoiseGenerator, DumbDaq\n    rate = {'daq_0': 1000, 'daq_1': 2000, 'daq_2': 42}\n    readsize = {'daq_0': 100, 'daq_1': 200, 'daq_2': 10}\n\n    daq0 = DumbDaq(rate=rate['daq_0'], read_size=readsize['daq_0'])\n    daq1 = NoiseGenerator(num_channels=4, rate=rate['daq_1'],\n                          read_size=readsize['daq_1'])\n    daq2 = NoiseGenerator(num_channels=2, rate=rate['daq_2'],\n                          read_size=readsize['daq_2'])\n\n    exp = Experiment(daq={'daq_0': daq0, 'daq_1': daq1, 'daq_2': daq2},\n                     subject='test', allow_overwrite=True)\n    exp.run(CountTask(rate, readsize))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_488","text":"<reponame>ChriPiv\/stinespring-algo-paper\n# (C) Copyright IBM 2020.\n#\n# This code is licensed under the Apache License, Version 2.0. You may\n# obtain a copy of this license in the LICENSE.txt file in the root directory\n# of this source tree or at http:\/\/www.apache.org\/licenses\/LICENSE-2.0.\n#\n# Any modifications or derivative works of this code must retain this\n# copyright notice, and modified files need to carry a notice indicating\n# that they have been altered from the originals.\n\nimport autograd\nimport autograd.numpy as np\nfrom scipy.optimize import minimize\nfrom qiskit import *\nfrom qiskit.quantum_info import *\nfrom qiskit.aqua.components.variational_forms import *\nfrom qiskit.providers.aer.noise import NoiseModel\nfrom qiskit.providers.aer.utils import insert_noise\n\nsys.path.append(\"..\")\nfrom json_tools import *\nfrom channels import *\nfrom variational_approximation import error_mean, get_approx_circuit, get_varform_circuit\nfrom diamond_norm import *\nimport autograd.numpy as np\n\nn_qubits = 3\nfull_connectivity = False\n\n\nU = random_unitary(2**n_qubits, seed=1234).data\nnoise_model = NoiseModel.from_dict(json_from_file(\"2020_04_08.json\"))\nnoise_model.add_quantum_error(noise_model._local_quantum_errors['cx']['2,3'], 'cx', [0,2])\nnoise_model.add_quantum_error(noise_model._local_quantum_errors['cx']['3,2'], 'cx', [2,0])\n\ndef dilation_channel(data, is_unitary=True, ideal=False):\n    exp = channel_expand(n_qubits-1,1)\n    if is_unitary:\n        qc = QuantumCircuit(n_qubits)\n        qc.unitary(data, list(range(n_qubits)))\n    else:\n        qc = data\n    if not ideal:\n        if not full_connectivity:\n            qc = qiskit.compiler.transpile(qc, basis_gates=noise_model.basis_gates,\n                                               coupling_map=[[0,1],[1,2]])\n        qc = insert_noise(qc, noise_model, transpile=True)\n    qc = SuperOp(qc)\n    tr = channel_trace(n_qubits-1,1)\n    channel = exp.compose(qc.compose(tr))\n    return Choi(channel).data\n\nch_ideal = dilation_channel(U, ideal=True)\nch_ref = dilation_channel(U)\nassert Choi(ch_ideal).is_tp()\nassert Choi(ch_ideal).is_cp()\nassert Choi(ch_ref).is_tp()\nassert Choi(ch_ref).is_cp()\nprint(\"Ref:\", dnorm(ch_ideal - ch_ref))\n\nif full_connectivity:\n    depth_list = [1,2,3,4,5,6,7,8,9,10,15]\nelse:\n    depth_list = [1,3,4,5,6,7,8,9,10,15,20,30,40]\nfor depth in depth_list:\n    U_approx,params = get_approx_circuit(U, n_qubits, depth, full_connectivity)\n    qc = get_varform_circuit(params, n_qubits, depth, full_connectivity)\n    ch = dilation_channel(qc, is_unitary=False)\n    print(depth, error_mean(U, U_approx, 2), dnorm(ch - ch_ideal))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_489","text":"<reponame>machendos\/graphics-lab<gh_stars>0\nimport cv2\nimport skimage as s\nimport scipy.ndimage as sc\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# prewitt mask\nmoon = cv2.imread('..\/images\/moon.jpg', 0)\nimg = s.img_as_int(moon)\nprewittVert = np.array(\n  [[-1,0,1],[-1,0,1],[-1,0,1]], dtype='float64'\n)\nprewittVertOut = s.img_as_ubyte(sc.convolve(img, prewittVert, mode='constant', cval=0.0))\nplt.imshow(prewittVertOut, cmap='gray')\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_490","text":"import cPickle\nimport numpy as n\nimport astropy.cosmology as co\nimport astropy.units as uu\naa =co.Planck13\nimport time\nfrom astropy.io import fits\nimport os \nfrom os.path import join\nimport matplotlib.pyplot as p\nfrom scipy.interpolate import interp1d\nmockDir = join(\"..\",\"MD_1Gpc\",\"density_field\")\n\ninFiles = n.array([\"dmdens_cic_104_DFhist.dat\", \"dmdens_cic_101_DFhist.dat\", \"dmdens_cic_097_DFhist.dat\", \"dmdens_cic_087_DFhist.dat\"])\n# ZS = 0.7 0.8 1.0 1.48\n\ndef getNN0_sim(inSim,NR=10):\n\tf=open(join(mockDir, inSim))\n\tbins, HDF0 = cPickle.load(f)\n\tf.close()\n\t#bins = n.hstack((0,n.logspace(-3, 4, 1000)))\n\txb = (bins[1:]+bins[:-1])\/2.\n\tdx = bins[1:] - bins[:-1]\n\tX, Y = n.meshgrid(xb,xb)\n\tN0 = HDF0 \/dx \/ (1000.-2*1000.\/2048)**3.\n\tHDF0R = n.array([HDF0[ii::NR] for ii in range(NR)]).sum(axis=0)\n\tbinsR = bins[::NR]\n\tN0R = HDF0R \/ ((binsR[1:] - binsR[:-1]) * 250.**3.)\n\treturn N0, bins, N0R, binsR\n\n\nN0z07s, binsz07s, N0z07, binsz07 = getNN0_sim(inFiles[0])\nxb = (binsz07[1:]+binsz07[:-1])\/2.\n\nf=open(join(mockDir,'Planck-ng512-L250.0.HDF0.pkl'),'r')\nbins, HDF0, N0 = cPickle.load(f)\nf.close()\n\nNR = 10\nHDF0R = n.array([HDF0[ii::NR] for ii in range(NR)]).sum(axis=0)\nbinsR = bins[::NR]\nN0R = HDF0R \/ ((binsR[1:] - binsR[:-1]) * 250.**3.)\nN0R_sig = n.array([N0[ii::NR] for ii in range(NR)]).std(axis=0)\n\nmuscleDelta = interp1d( N0R, (binsR[:-1]+binsR[1:])\/2.)\nmdplDelta = interp1d( N0z07, xb)\nok=(N0R>0)&(N0R<=100)#n.max(N0z07))\ntrueDelta = mdplDelta(N0R[ok])\nindex=n.argsort(N0R[ok])\ndeltaMuscle = (binsR[:-1]+binsR[1:])\/2.\nn.savetxt(join(mockDir,\"delta-conversion-muscle-mdpl.txt\"),n.transpose([deltaMuscle[ok][index],trueDelta[index]]),header=\"deltaMuscle deltaMDPL\")\n\np.figure(0)\np.title('QSO')\np.plot(xb, N0z07,'kx', rasterized=True, label='z=0.7 all')\np.plot(xb, N0,'bx', rasterized=True, label='z=0.7 muscle')\np.plot((binsR[:-1]+binsR[1:])\/2., N0R,'rx', rasterized=True, label='z=0.7 muscle resampled')\np.plot(trueDelta[index], N0R[ok][index], 'm--', lw=2, rasterized=True, label='z=0.7 muscle corr')\np.xlabel(r'$\\delta_0$')\np.ylabel(r'N')\np.xscale('log')\np.yscale('log')\np.ylim((1e-10, 1e2))\np.xlim((0.1, 1e4))\ngl = p.legend(loc=3)\ngl.set_frame_on(False)\np.grid()\np.savefig(join(mockDir,\"plots\",\"muscle-delta-HDF0.png\"))\np.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_491","text":"<reponame>doanmanhduy0210\/cosface\n# Code referenced from https:\/\/gist.github.com\/gyglim\/1f8dfb1b5c82627ae3efcfbbadb9f514\n# tensorboard --logdir='.\/logs' --port=6006\n# tensorboard --logdir=old:out\/2019-07-20___18-13-10\/tensorboard,new:out\/2019-07-21___14-45-41\/tensorboard --port=6006\n\nimport os\nimport sys\nimport argparse\n\nimport tensorflow as tf\nimport numpy as np\nimport scipy.misc \ntry:\n    from StringIO import StringIO  # Python 2.7\nexcept ImportError:\n    from io import BytesIO         # Python 3.x\n\n\nclass Logger(object):\n    \n    def __init__(self, log_dir):\n        \"\"\"Create a summary writer logging to log_dir.\"\"\"\n        self.writer = tf.summary.FileWriter(log_dir)\n\n    def scalar_summary(self, tag, value, step):\n        \"\"\"Log a scalar variable.\"\"\"\n        summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)])\n        self.writer.add_summary(summary, step)\n\n    def image_summary(self, tag, images, step):\n        \"\"\"Log a list of images.\"\"\"\n\n        img_summaries = []\n        for i, img in enumerate(images):\n            # Write the image to a string\n            try:\n                s = StringIO()\n            except:\n                s = BytesIO()\n            scipy.misc.toimage(img).save(s, format=\"png\")\n\n            # Create an Image object\n            img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),\n                                       height=img.shape[0],\n                                       width=img.shape[1])\n            # Create a Summary value\n            img_summaries.append(tf.Summary.Value(tag='%s\/%d' % (tag, i), image=img_sum))\n\n        # Create and write Summary\n        summary = tf.Summary(value=img_summaries)\n        self.writer.add_summary(summary, step)\n        \n    def histo_summary(self, tag, values, step, bins=1000):\n        \"\"\"Log a histogram of the tensor of values.\"\"\"\n\n        # Create a histogram using numpy\n        counts, bin_edges = np.histogram(values, bins=bins)\n\n        # Fill the fields of the histogram proto\n        hist = tf.HistogramProto()\n        hist.min = float(np.min(values))\n        hist.max = float(np.max(values))\n        hist.num = int(np.prod(values.shape))\n        hist.sum = float(np.sum(values))\n        hist.sum_squares = float(np.sum(values**2))\n\n        # Drop the start of the first bin\n        bin_edges = bin_edges[1:]\n\n        # Add bin edges and counts\n        for edge in bin_edges:\n            hist.bucket_limit.append(edge)\n        for c in counts:\n            hist.bucket.append(c)\n\n        # Create and write Summary\n        summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\n        self.writer.add_summary(summary, step)\n        self.writer.flush()\n\n\n\ndef main(ARGS):\n    out_dir = os.path.expanduser(ARGS.out_dir)\n    assert os.path.isdir(out_dir), \"Path {} does not exist \".format(ARGS.out_dir)\n\n    print(\"\\nStarting Tensorboard\")\n\n    date_folders = []\n    files = os.listdir(out_dir)\n    if len(files):\n        for f in files:\n            date_folders.append(f)\n\n    assert date_folders, \"No tensorboard folders\"\n\n    command_string = \"tensorboard --logdir=\"\n    date_folders.sort()  \n    for i,folder in enumerate(date_folders):\n        tensorboard_path = os.path.join(os.path.join(out_dir, folder), 'tensorboard')\n        # print(\"Full Tensorboard Path: {}\".format(tensorboard_path))\n        command_string += str(i+1) + \":\" + tensorboard_path\n        if i != len(date_folders)-1:\n            command_string += \",\"\n\n    # Port\n    command_string += \" --port={}\".format(ARGS.tensorboard_port)\n\n    print(\"FINAL Command String: {}\".format(command_string))\n    print(\"\\n\")\n    os.system(command_string)\n\n    \ndef parse_arguments(argv):\n    parser = argparse.ArgumentParser()\n    parser.add_argument('--out_dir', type=str,  help='Directory where models and event logs are stored.', default='.\/out')\n    parser.add_argument('--tensorboard_port', type=int, help='Tensorboard port for command', default=6006)\n    return parser.parse_args(argv)\n  \nif __name__ == '__main__':\n    main(parse_arguments(sys.argv[1:]))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_492","text":"<filename>code\/baselines\/utils_phy12.py\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport torch\nimport random\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\nimport time\n\nfrom sklearn.metrics import roc_auc_score\nfrom sklearn.metrics import average_precision_score\n\n\ndef get_data_split(base_path, split_path, split_type='random', reverse=False, baseline=True, dataset='P12', predictive_label='mortality'):\n    # load data\n    if dataset == 'P12':\n        Pdict_list = np.load(base_path + '\/processed_data\/PTdict_list.npy', allow_pickle=True)\n        arr_outcomes = np.load(base_path + '\/processed_data\/arr_outcomes.npy', allow_pickle=True)\n        dataset_prefix = ''\n    elif dataset == 'P19':\n        Pdict_list = np.load(base_path + '\/processed_data\/PT_dict_list_6.npy', allow_pickle=True)\n        arr_outcomes = np.load(base_path + '\/processed_data\/arr_outcomes_6.npy', allow_pickle=True)\n        dataset_prefix = 'P19_'\n    elif dataset == 'eICU':\n        Pdict_list = np.load(base_path + '\/processed_data\/PTdict_list.npy', allow_pickle=True)\n        arr_outcomes = np.load(base_path + '\/processed_data\/arr_outcomes.npy', allow_pickle=True)\n        dataset_prefix = 'eICU_'\n    elif dataset == 'PAM':\n        Pdict_list = np.load(base_path + '\/processed_data\/PTdict_list.npy', allow_pickle=True)\n        arr_outcomes = np.load(base_path + '\/processed_data\/arr_outcomes.npy', allow_pickle=True)\n        dataset_prefix = ''  # not applicable\n\n    show_statistics = False\n    if show_statistics:\n        idx_under_65 = []\n        idx_over_65 = []\n\n        idx_male = []\n        idx_female = []\n\n        # variables for statistics\n        all_ages = []\n        female_count = 0\n        male_count = 0\n        all_BMI = []\n\n        X_static = np.zeros((len(Pdict_list), len(Pdict_list[0]['extended_static'])))\n        for i in range(len(Pdict_list)):\n            X_static[i] = Pdict_list[i]['extended_static']\n            age, gender_0, gender_1, height, _, _, _, _, weight = X_static[i]\n            if age > 0:\n                all_ages.append(age)\n                if age < 65:\n                    idx_under_65.append(i)\n                else:\n                    idx_over_65.append(i)\n            if gender_0 == 1:\n                female_count += 1\n                idx_female.append(i)\n            if gender_1 == 1:\n                male_count += 1\n                idx_male.append(i)\n            if height > 0 and weight > 0:\n                all_BMI.append(weight \/ ((height \/ 100) ** 2))\n\n        # plot statistics\n        plt.hist(all_ages, bins=[i * 10 for i in range(12)])\n        plt.xlabel('Years')\n        plt.ylabel('# people')\n        plt.title('Histogram of patients ages, age known in %d samples.\\nMean: %.1f, Std: %.1f, Median: %.1f' %\n                  (len(all_ages), np.mean(np.array(all_ages)), np.std(np.array(all_ages)), np.median(np.array(all_ages))))\n        plt.show()\n\n        plt.hist(all_BMI, bins=[5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60])\n        all_BMI = np.array(all_BMI)\n        all_BMI = all_BMI[(all_BMI > 10) & (all_BMI < 65)]\n        plt.xlabel('BMI')\n        plt.ylabel('# people')\n        plt.title('Histogram of patients BMI, height and weight known in %d samples.\\nMean: %.1f, Std: %.1f, Median: %.1f' %\n                  (len(all_BMI), np.mean(all_BMI), np.std(all_BMI), np.median(all_BMI)))\n        plt.show()\n        print('\\nGender known: %d,  Male count: %d,  Female count: %d\\n' % (male_count + female_count, male_count, female_count))\n\n    # np.save('saved\/idx_under_65.npy', np.array(idx_under_65), allow_pickle=True)\n    # np.save('saved\/idx_over_65.npy', np.array(idx_over_65), allow_pickle=True)\n    # np.save('saved\/idx_male.npy', np.array(idx_male), allow_pickle=True)\n    # np.save('saved\/idx_female.npy', np.array(idx_female), allow_pickle=True)\n\n    # transformer_path = True\n    if baseline==True:\n        BL_path = ''\n    else:\n        BL_path = 'baselines\/'\n\n    if split_type == 'random':\n        # load random indices from a split\n        idx_train, idx_val, idx_test = np.load(base_path + split_path, allow_pickle=True)\n    elif split_type == 'age':\n        if reverse == False:\n            idx_train = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_under_65.npy', allow_pickle=True)\n            idx_vt = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_over_65.npy', allow_pickle=True)\n        elif reverse == True:\n            idx_train = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_over_65.npy', allow_pickle=True)\n            idx_vt = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_under_65.npy', allow_pickle=True)\n\n        np.random.shuffle(idx_vt)\n        idx_val = idx_vt[:round(len(idx_vt) \/ 2)]\n        idx_test = idx_vt[round(len(idx_vt) \/ 2):]\n    elif split_type == 'gender':\n        if reverse == False:\n            idx_train = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_male.npy', allow_pickle=True)\n            idx_vt = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_female.npy', allow_pickle=True)\n        elif reverse == True:\n            idx_train = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_female.npy', allow_pickle=True)\n            idx_vt = np.load(BL_path+'saved\/' + dataset_prefix + 'idx_male.npy', allow_pickle=True)\n\n        np.random.shuffle(idx_vt)\n        idx_val = idx_vt[:round(len(idx_vt) \/ 2)]\n        idx_test = idx_vt[round(len(idx_vt) \/ 2):]\n\n    # extract train\/val\/test examples\n    Ptrain = Pdict_list[idx_train]\n    Pval = Pdict_list[idx_val]\n    Ptest = Pdict_list[idx_test]\n\n    # extract mortality labels\n    if dataset == 'P12' or dataset == 'P19' or dataset == 'PAM':\n        if predictive_label == 'mortality':\n            y = arr_outcomes[:, -1].reshape((-1, 1))\n        elif predictive_label == 'LoS':  # for P12 only\n            y = arr_outcomes[:, 3].reshape((-1, 1))\n            y = np.array(list(map(lambda los: 0 if los <= 3 else 1, y)))[..., np.newaxis]\n    elif dataset == 'eICU':\n        y = arr_outcomes[..., np.newaxis]\n    ytrain = y[idx_train]\n    yval = y[idx_val]\n    ytest = y[idx_test]\n\n    return Ptrain, Pval, Ptest, ytrain, yval, ytest\n\n\ndef getStats(P_tensor):\n    N, T, F = P_tensor.shape\n    Pf = P_tensor.transpose((2, 0, 1)).reshape(F, -1)\n    mf = np.zeros((F, 1))\n    stdf = np.ones((F, 1))\n    eps = 1e-7\n    for f in range(F):\n        vals_f = Pf[f, :]\n        vals_f = vals_f[vals_f > 0]\n        mf[f] = np.mean(vals_f)\n        stdf[f] = np.std(vals_f)\n        stdf[f] = np.max([stdf[f], eps])\n    return mf, stdf\n\n\ndef get_features_mean(X_features):\n    \"\"\"\n    Calculate means of all time series features (36 features in P12 dataset).\n\n    :param X_features: time series features for all samples in training set\n    :return: list of means for all features\n    \"\"\"\n    samples, timesteps, features = X_features.shape\n    X = np.reshape(X_features, newshape=(samples*timesteps, features)).T\n    means = []\n    for row in X:\n        row = row[row > 0]\n        means.append(np.mean(row))\n    return means\n\n\ndef mean_imputation(X_features, X_time, mean_features, missing_value_num):\n    \"\"\"\n    Fill X_features missing values with mean values of all train samples.\n\n    :param X_features: time series features for all samples\n    :param X_time: times, when observations were measured\n    :param mean_features: mean values of features from the training set\n    :return: X_features, filled with mean values instead of zeros (missing observations)\n    \"\"\"\n    time_length = []\n    for times in X_time:\n        if np.where(times == missing_value_num)[0].size == 0:\n            time_length.append(times.shape[0])\n        elif np.where(times == missing_value_num)[0][0] == 0:\n            time_length.append(np.where(times == missing_value_num)[0][1])\n        else:\n            time_length.append(np.where(times == missing_value_num)[0][0])\n\n    # check for inconsistency\n    for i in range(len(X_features)):\n        if np.any(X_features[i, time_length[i]:, :]):\n            print('Inconsistency between X_features and X_time: features are measured without time stamp.')\n\n    # impute times series features\n    for i, sample in enumerate(X_features):\n        X_features_relevant = sample[:time_length[i], :]\n        missing_values_idx = np.where(X_features_relevant == missing_value_num)\n        for row, col in zip(*missing_values_idx):\n            X_features[i, row, col] = mean_features[col]\n\n    return X_features\n\n\ndef forward_imputation(X_features, X_time, missing_value_num):\n    \"\"\"\n    Fill X_features missing values with values, which are the same as its last measurement.\n\n    :param X_features: time series features for all samples\n    :param X_time: times, when observations were measured\n    :return: X_features, filled with last measurements instead of zeros (missing observations)\n    \"\"\"\n    time_length = []\n    for times in X_time:\n        if np.where(times == missing_value_num)[0].size == 0:\n            time_length.append(times.shape[0])\n        elif np.where(times == missing_value_num)[0][0] == 0:\n            time_length.append(np.where(times == missing_value_num)[0][1])\n        else:\n            time_length.append(np.where(times == missing_value_num)[0][0])\n\n    # impute times series features\n    for i, sample in enumerate(X_features):\n        for j, ts in enumerate(sample.T):   # note the transposed matrix\n            first_observation = True\n            current_value = -1\n            for k, observation in enumerate(ts[:time_length[i]]):\n                if X_features[i, k, j] == missing_value_num and first_observation:\n                    continue\n                elif X_features[i, k, j] != missing_value_num:\n                    current_value = X_features[i, k, j]\n                    first_observation = False\n                elif X_features[i, k, j] == missing_value_num and not first_observation:\n                    X_features[i, k, j] = current_value\n\n    return X_features\n\n\ndef cubic_spline_imputation(X_features, X_time, missing_value_num):\n    \"\"\"\n    Fill X_features missing values with cubic spline interpolation.\n\n    :param X_features: time series features for all samples\n    :param X_time: times, when observations were measured\n    :return: X_features, filled with interpolated values\n    \"\"\"\n    from scipy.interpolate import CubicSpline\n\n    time_length = []\n    for times in X_time:\n        if np.where(times == missing_value_num)[0].size == 0:\n            time_length.append(times.shape[0])\n        elif np.where(times == missing_value_num)[0][0] == 0:\n            time_length.append(np.where(times == missing_value_num)[0][1])\n        else:\n            time_length.append(np.where(times == missing_value_num)[0][0])\n\n    # impute times series features\n    for i, sample in enumerate(X_features):\n        for j, ts in enumerate(sample.T):   # note the transposed matrix\n            valid_ts = ts[:time_length[i]]\n            zero_idx = np.where(valid_ts == missing_value_num)[0]\n            non_zero_idx = np.nonzero(valid_ts)[0]\n            y = valid_ts[non_zero_idx]\n\n            if len(y) > 1:   # we need at least 2 observations to fit cubic spline\n                x = X_time[i, :time_length[i], 0][non_zero_idx]\n                x2interpolate = X_time[i, :time_length[i], 0][zero_idx]\n\n                cs = CubicSpline(x, y)\n                interpolated_ts = cs(x2interpolate)\n                valid_ts[zero_idx] = interpolated_ts\n\n                # set values before first measurement to the value of first measurement\n                first_obs_index = non_zero_idx[0]\n                valid_ts[:first_obs_index] = np.full(shape=first_obs_index, fill_value=valid_ts[first_obs_index])\n\n                # set values after last measurement to the value of last measurement\n                last_obs_index = non_zero_idx[-1]\n                valid_ts[last_obs_index:] = np.full(shape=time_length[i] - last_obs_index, fill_value=valid_ts[last_obs_index])\n\n                X_features[i, :time_length[i], j] = valid_ts\n\n    return X_features\n\n\ndef mask_normalize(P_tensor, mf, stdf):\n    \"\"\" Normalize time series variables. Missing ones are set to zero after normalization. \"\"\"\n    N, T, F = P_tensor.shape\n    Pf = P_tensor.transpose((2,0,1)).reshape(F,-1)\n    M = 1*(P_tensor>0) + 0*(P_tensor<=0)\n    M_3D = M.transpose((2, 0, 1)).reshape(F, -1)\n    for f in range(F):\n        Pf[f] = (Pf[f]-mf[f])\/(stdf[f]+1e-18)\n    Pf = Pf * M_3D\n    Pnorm_tensor = Pf.reshape((F,N,T)).transpose((1,2,0))\n    Pfinal_tensor = np.concatenate([Pnorm_tensor, M], axis=2)\n    return Pfinal_tensor\n\n\ndef getStats_static(P_tensor, dataset='P12'):\n    N, S = P_tensor.shape\n    Ps = P_tensor.transpose((1, 0))\n    ms = np.zeros((S, 1))\n    ss = np.ones((S, 1))\n\n    if dataset == 'P12':\n        # ['Age' 'Gender=0' 'Gender=1' 'Height' 'ICUType=1' 'ICUType=2' 'ICUType=3' 'ICUType=4' 'Weight']\n        bool_categorical = [0, 1, 1, 0, 1, 1, 1, 1, 0]\n    elif dataset == 'P19':\n        # ['Age' 'Gender' 'Unit1' 'Unit2' 'HospAdmTime' 'ICULOS']\n        bool_categorical = [0, 1, 0, 0, 0, 0]\n    elif dataset == 'eICU':\n        # ['apacheadmissiondx' 'ethnicity' 'gender' 'admissionheight' 'admissionweight'] -> 399 dimensions\n        bool_categorical = [1] * 397 + [0] * 2\n\n    for s in range(S):\n        if bool_categorical[s] == 0:  # if not categorical\n            vals_s = Ps[s, :]\n            vals_s = vals_s[vals_s > 0]\n            ms[s] = np.mean(vals_s)\n            ss[s] = np.std(vals_s)\n    return ms, ss\n\n\ndef mask_normalize_static(P_tensor, ms, ss):\n    N, S = P_tensor.shape\n    Ps = P_tensor.transpose((1, 0))\n\n    # input normalization\n    for s in range(S):\n        Ps[s] = (Ps[s] - ms[s]) \/ (ss[s] + 1e-18)\n\n    # set missing values to zero after normalization\n    for s in range(S):\n        idx_missing = np.where(Ps[s, :] <= 0)\n        Ps[s, idx_missing] = 0\n\n    # reshape back\n    Pnorm_tensor = Ps.reshape((S, N)).transpose((1, 0))\n    return Pnorm_tensor\n\n\ndef tensorize_normalize(P, y, mf, stdf, ms, ss):\n    T, F = P[0]['arr'].shape\n    D = len(P[0]['extended_static'])\n\n    P_tensor = np.zeros((len(P), T, F))\n    P_time = np.zeros((len(P), T, 1))\n    P_static_tensor = np.zeros((len(P), D))\n    for i in range(len(P)):\n        P_tensor[i] = P[i]['arr']\n        P_time[i] = P[i]['time']\n        P_static_tensor[i] = P[i]['extended_static']\n    P_tensor = mask_normalize(P_tensor, mf, stdf)\n    P_tensor = torch.Tensor(P_tensor)\n\n    P_time = torch.Tensor(P_time) \/ 60.0  # convert mins to hours\n    P_static_tensor = mask_normalize_static(P_static_tensor, ms, ss)\n    P_static_tensor = torch.Tensor(P_static_tensor)\n\n    y_tensor = y\n    y_tensor = torch.Tensor(y_tensor[:, 0]).type(torch.LongTensor)\n    return P_tensor, P_static_tensor, P_time, y_tensor\n\n\ndef tensorize_normalize_other(P, y, mf, stdf):\n    T, F = P[0].shape\n\n    P_time = np.zeros((len(P), T, 1))\n    for i in range(len(P)):\n        tim = torch.linspace(0, T, T).reshape(-1, 1)\n        P_time[i] = tim\n    P_tensor = mask_normalize(P, mf, stdf)\n    P_tensor = torch.Tensor(P_tensor)\n\n    P_time = torch.Tensor(P_time) \/ 60.0\n\n    y_tensor = y\n    y_tensor = torch.Tensor(y_tensor[:, 0]).type(torch.LongTensor)\n    return P_tensor, None, P_time, y_tensor\n\n\ndef masked_softmax(A, epsilon=0.000000001):\n    A_max = torch.max(A, dim=1, keepdim=True)[0]\n    A_exp = torch.exp(A - A_max)\n    A_exp = A_exp * (A != 0).float()\n    A_softmax = A_exp \/ (torch.sum(A_exp, dim=0, keepdim=True) + epsilon)\n    return A_softmax\n\n\ndef random_sample(idx_0, idx_1, B, replace=False):\n    \"\"\" Returns a balanced sample of tensors by randomly sampling without replacement. \"\"\"\n    idx0_batch = np.random.choice(idx_0, size=int(B \/ 2), replace=replace)\n    idx1_batch = np.random.choice(idx_1, size=int(B \/ 2), replace=replace)\n    idx = np.concatenate([idx0_batch, idx1_batch], axis=0)\n    return idx\n\n\ndef random_sample_8(ytrain, B, replace=False):\n    \"\"\" Returns a balanced sample of tensors by randomly sampling without replacement. \"\"\"\n    idx0_batch = np.random.choice(np.where(ytrain == 0)[0], size=int(B \/ 8), replace=replace)\n    idx1_batch = np.random.choice(np.where(ytrain == 1)[0], size=int(B \/ 8), replace=replace)\n    idx2_batch = np.random.choice(np.where(ytrain == 2)[0], size=int(B \/ 8), replace=replace)\n    idx3_batch = np.random.choice(np.where(ytrain == 3)[0], size=int(B \/ 8), replace=replace)\n    idx4_batch = np.random.choice(np.where(ytrain == 4)[0], size=int(B \/ 8), replace=replace)\n    idx5_batch = np.random.choice(np.where(ytrain == 5)[0], size=int(B \/ 8), replace=replace)\n    idx6_batch = np.random.choice(np.where(ytrain == 6)[0], size=int(B \/ 8), replace=replace)\n    idx7_batch = np.random.choice(np.where(ytrain == 7)[0], size=int(B \/ 8), replace=replace)\n    idx = np.concatenate([idx0_batch, idx1_batch, idx2_batch, idx3_batch, idx4_batch, idx5_batch, idx6_batch, idx7_batch], axis=0)\n    return idx\n\n\ndef evaluate(model, P_tensor, P_time_tensor, P_static_tensor, batch_size=100, n_classes=2, static=1):\n    model.eval()\n    P_tensor = P_tensor.cuda()\n    P_time_tensor = P_time_tensor.cuda()\n    if static is None:\n        Pstatic = None\n    else:\n        P_static_tensor = P_static_tensor.cuda()\n        N, Fs = P_static_tensor.shape\n\n    T, N, Ff = P_tensor.shape\n\n    n_batches, rem = N \/\/ batch_size, N % batch_size\n\n    out = torch.zeros(N, n_classes)\n    start = 0\n    for i in range(n_batches):\n        P = P_tensor[:, start:start + batch_size, :]\n        Ptime = P_time_tensor[:, start:start + batch_size]\n        if P_static_tensor is not None:\n            Pstatic = P_static_tensor[start:start + batch_size]\n        lengths = torch.sum(Ptime > 0, dim=0)\n        out[start:start + batch_size] = model.forward(P, Pstatic, Ptime, lengths).detach().cpu()\n        start += batch_size\n    if rem > 0:\n        P = P_tensor[:, start:start + rem, :]\n        Ptime = P_time_tensor[:, start:start + rem]\n        if P_static_tensor is not None:\n            Pstatic = P_static_tensor[start:start + batch_size]\n        lengths = torch.sum(Ptime > 0, dim=0)\n        out[start:start + rem] = model.forward(P, Pstatic, Ptime, lengths).detach().cpu()\n    return out\n\n\ndef evaluate_standard(model, P_tensor, P_time_tensor, P_static_tensor, batch_size=100, n_classes=2, static=1):\n    P_tensor = P_tensor.cuda()\n    P_time_tensor = P_time_tensor.cuda()\n    if static is None:\n        P_static_tensor = None\n    else:\n        P_static_tensor = P_static_tensor.cuda()\n\n    lengths = torch.sum(P_time_tensor > 0, dim=0)\n    out = model.forward(P_tensor, P_static_tensor, P_time_tensor, lengths)\n    return out\n\n\ndef evaluate_MTGNN(model, P_tensor, P_static_tensor, static=1):\n    P_tensor = P_tensor.cuda()\n\n    P_tensor = torch.permute(P_tensor, (1, 0, 2))\n    P_tensor = torch.unsqueeze(P_tensor, dim=1)\n    P_tensor = P_tensor.transpose(2, 3)\n\n    if static is None:\n        P_static_tensor = None\n    else:\n        P_static_tensor = P_static_tensor.cuda()\n\n    out = model.forward(P_tensor, P_static_tensor)\n    return out\n\n\ndef evaluate_DGM2(model, P_tensor, P_static_tensor, static=1):\n    # suppose P_time is equal in all patients\n    P_time = torch.arange(P_tensor.size()[0])\n\n    P_tensor = P_tensor.cuda()\n    P_tensor = torch.permute(P_tensor, (1, 0, 2))\n\n    if static is None:\n        P_static_tensor = None\n    else:\n        P_static_tensor = P_static_tensor.cuda()\n\n    out = model.forward(P_tensor, P_time, P_static_tensor)\n    return out\n\n\ndef linspace_vector(start, end, n_points):\n    # start is either one value or a vector\n    size = np.prod(start.size())\n\n    assert(start.size() == end.size())\n    if size == 1:\n        # start and end are 1d-tensors\n        res = torch.linspace(start, end, n_points)\n    else:\n        # start and end are vectors\n        res = torch.Tensor()\n        for i in range(0, start.size(0)):\n            res = torch.cat((res,\n                torch.linspace(start[i], end[i], n_points)),0)\n        res = torch.t(res.reshape(start.size(0), n_points))\n    return res\n\n\n# Adam using warmup\nclass NoamOpt:\n    \"Optim wrapper that implements rate.\"\n\n    def __init__(self, model_size, factor, warmup, optimizer):\n        self.optimizer = optimizer\n        self._step = 0\n        self.warmup = warmup\n        self.factor = factor\n        self.model_size = model_size\n        self._rate = 0\n\n    def step(self):\n        \"Update parameters and rate\"\n        self._step += 1\n        rate = self.rate()\n        for p in self.optimizer.param_groups:\n            p['lr'] = rate\n        self._rate = rate\n        self.optimizer.step()\n\n    def rate(self, step=None):\n        \"Implement `lrate` above\"\n        if step is None:\n            step = self._step\n        return self.factor * \\\n               (self.model_size ** (-0.5) *\n                min(step ** (-0.5), step * self.warmup ** (-1.5)))\n\n    def zero_grad(self):\n        self.optimizer.zero_grad()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_493","text":"from tqdm import tqdm\r\nfrom itertools import chain\r\n\r\nfrom torch.nn import BCEWithLogitsLoss\r\nfrom torch_geometric.data import DataLoader\r\nfrom sklearn.metrics import roc_auc_score, average_precision_score\r\nfrom tensorboardX import SummaryWriter\r\nimport os\r\nfrom models import DGCNN\r\nimport argparse\r\nimport os.path as osp\r\n\r\nimport numpy as np\r\nimport pandas as pd\r\nimport scipy.sparse as sp\r\nfrom scipy.sparse.csgraph import shortest_path\r\nimport torch\r\nimport torch.nn.functional as F\r\n# from gae_huawei import train, test\r\nfrom models import GCN, SGC, GAT\r\n\r\nfrom torch_geometric.nn import GAE\r\nfrom torch_geometric.data import Data\r\nfrom torch_geometric.datasets import Planetoid\r\nfrom torch_geometric.utils import (negative_sampling, add_self_loops,\r\n                                   train_test_split_edges, k_hop_subgraph,\r\n                                   to_scipy_sparse_matrix)\r\n\r\nimport warnings\r\nwarnings.filterwarnings(\"ignore\")\r\n\r\nmax_z = 0\r\n\r\n\r\ndef set_seed(seed):\r\n    torch.manual_seed(seed)\r\n    torch.cuda.manual_seed_all(seed)\r\n    np.random.seed(seed)\r\n    torch.backends.cudnn.deterministic = True\r\n\r\n\r\ndef load_data(path):\r\n    alarm_graph = np.load(path, allow_pickle=True)\r\n    node_list = list(alarm_graph.nodes)\r\n    edge_tmp = []\r\n    for edge in list(alarm_graph.edges):\r\n        if edge[0] != edge[1]:\r\n            edge_tmp.append(edge)  # 这一步是为了保证没有self-loops\r\n    edge_list = []\r\n    for i in range(len(edge_tmp)):\r\n        a = node_list.index(edge_tmp[i][0])\r\n        b = node_list.index(edge_tmp[i][1])\r\n        edge_list.append([a, b])\r\n\r\n    alarm_names = []\r\n    for ne_name in list(alarm_graph.nodes):\r\n        for alarm in alarm_graph.nodes[ne_name].keys():\r\n            if alarm != 'NE_TYPE' and alarm not in alarm_names:\r\n                alarm_names.append(alarm)\r\n\r\n    labels = np.zeros([len(node_list), 3])\r\n    for i in range(len(alarm_graph.nodes)):\r\n        if alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'NODEB':\r\n            labels[i][0] = 1\r\n        elif alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'MICROWAVE':\r\n            labels[i][1] = 1\r\n        elif alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'ROUTER':\r\n            labels[i][2] = 1\r\n\r\n    label_list = []\r\n    for i in range(len(alarm_graph.nodes)):\r\n        if alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'NODEB':\r\n            label_list.append(1)\r\n        elif alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'MICROWAVE':\r\n            label_list.append(2)\r\n        elif alarm_graph.nodes[list(alarm_graph.nodes)[i]]['NE_TYPE'] == 'ROUTER':\r\n            label_list.append(3)\r\n\r\n    attribute_length = len(alarm_names)\r\n    num_of_nodes = len(alarm_graph.nodes)\r\n    attribute_one_hot = np.zeros([num_of_nodes, attribute_length])\r\n\r\n    # one-hot\r\n    for i in range(len(alarm_graph.nodes)):\r\n        for alarm in alarm_graph.nodes[list(alarm_graph.nodes)[i]].keys():\r\n            if alarm != 'NE_TYPE':\r\n                attribute_one_hot[i][alarm_names.index(alarm)] = 1\r\n    return node_list, edge_list, attribute_one_hot, labels, label_list\r\n\r\n\r\ndef drnl_node_labeling(edge_index, src, dst, num_nodes=None):\r\n    global max_z\r\n    # Double-radius node labeling (DRNL).\r\n    src, dst = (dst, src) if src > dst else (src, dst)\r\n    adj = to_scipy_sparse_matrix(edge_index, num_nodes=num_nodes).tocsr()\r\n\r\n    idx = list(range(src)) + list(range(src + 1, adj.shape[0]))\r\n    adj_wo_src = adj[idx, :][:, idx]\r\n\r\n    idx = list(range(dst)) + list(range(dst + 1, adj.shape[0]))\r\n    adj_wo_dst = adj[idx, :][:, idx]\r\n\r\n    dist2src = shortest_path(adj_wo_dst, directed=False, unweighted=True,\r\n                             indices=src)\r\n    dist2src = np.insert(dist2src, dst, 0, axis=0)\r\n    dist2src = torch.from_numpy(dist2src)\r\n\r\n    dist2dst = shortest_path(adj_wo_src, directed=False, unweighted=True,\r\n                             indices=dst - 1)\r\n    dist2dst = np.insert(dist2dst, src, 0, axis=0)\r\n    dist2dst = torch.from_numpy(dist2dst)\r\n\r\n    dist = dist2src + dist2dst\r\n    dist_over_2, dist_mod_2 = dist \/\/ 2, dist % 2\r\n\r\n    z = 1 + torch.min(dist2src, dist2dst)\r\n    z += dist_over_2 * (dist_over_2 + dist_mod_2 - 1)\r\n    z[src] = 1.\r\n    z[dst] = 1.\r\n    z[torch.isnan(z)] = 0.\r\n\r\n    max_z = max(int(z.max()), max_z)\r\n\r\n    return z.to(torch.long)\r\n\r\n\r\ndef extract_enclosing_subgraphs(data, link_index, edge_index, y):\r\n    data_list = []\r\n    for src, dst in tqdm(link_index.t().tolist(), desc='Extracting...'):\r\n        # src: source   dst: destination\r\n        sub_nodes, sub_edge_index, mapping, _ = k_hop_subgraph(\r\n            [src, dst], num_hops=2, edge_index=edge_index, relabel_nodes=True\r\n        )\r\n        src, dst = mapping.tolist()\r\n\r\n        # remove target link from the subgraph\r\n        mask1 = (sub_edge_index[0] != src) | (sub_edge_index[1] != dst)\r\n        mask2 = (sub_edge_index[0] != dst) | (sub_edge_index[1] != src)\r\n        sub_edge_index = sub_edge_index[:, mask1 & mask2]\r\n\r\n        # calculate node labeling\r\n        z = drnl_node_labeling(sub_edge_index, src, dst, num_nodes=sub_nodes.size(0))\r\n\r\n        sub_data = Data(x=data.x[sub_nodes], z=z, edge_index=sub_edge_index, y=y)\r\n        if 'pretrained_features' in data.keys:\r\n            sub_data.pretrained_features = data.pretrained_features[sub_nodes]\r\n        if 'alarm_features' in data.keys:\r\n            sub_data.alarm_features = data.alarm_features[sub_nodes]\r\n\r\n        data_list.append(sub_data)\r\n\r\n    return data_list\r\n\r\n\r\ndef load_huawei_dataset():\r\n    path = '..\/data\/alarm_project_hitsz\/preprocessed\/G'\r\n    nodes, edge_list, attribute, node_labels, labels = load_data(path)\r\n    dataset = Data(x=torch.tensor(attribute, dtype=torch.float),\r\n                   edge_index=torch.tensor(edge_list, dtype=torch.long).t().contiguous(),\r\n                   y=torch.tensor(node_labels, dtype=torch.float), labels=labels)\r\n    return dataset\r\n\r\n\r\ndef load_disease_dataset():\r\n    path = '..\/data\/disease_lp\/'\r\n    edges = pd.read_csv(path + 'disease_lp.edges.csv')\r\n    labels = np.load(path + 'disease_lp.labels.npy')\r\n    features = sp.load_npz(path + 'disease_lp.feats.npz').todense()\r\n    dataset = Data(\r\n        x=torch.tensor(features, dtype=torch.float),\r\n        edge_index=torch.tensor(edges.values).t().contiguous(),\r\n        y=F.one_hot(torch.tensor(labels))\r\n    )\r\n    return dataset\r\n\r\n\r\ndef load_cora_dataset():\r\n    path = osp.join(osp.dirname(osp.relpath('seal_dataset.py')), '..', 'data', 'Planetoid')\r\n    dataset = Planetoid(path, 'Cora')[0]\r\n    dataset.y = F.one_hot(dataset.y).to(torch.float)\r\n    # 这里做了一个处理，将标签转化维one-hot向量\r\n    return dataset\r\n\r\n\r\ndef pre_train(model, data, optimizer):\r\n    model.train()\r\n    optimizer.zero_grad()\r\n    z = model.encode(data.x, data.train_pos_edge_index)\r\n    loss = model.recon_loss(z, data.train_pos_edge_index)\r\n    loss.backward()\r\n    optimizer.step()\r\n    return float(loss), z\r\n\r\n\r\ndef pre_test(model, x, train_pos_edge_index, pos_edge_index, neg_edge_index):\r\n    model.eval()\r\n    with torch.no_grad():\r\n        z = model.encode(x, train_pos_edge_index)\r\n    return model.test(z, pos_edge_index, neg_edge_index)\r\n\r\n\r\ndef process(args):\r\n\r\n    seed = 327\r\n    set_seed(seed)\r\n\r\n    print('Loading dataset~~~')\r\n    if args.dataset == 'huawei':\r\n        dataset = load_huawei_dataset()\r\n        if args.use_alarm:\r\n            alarm_feature_path = '..\/data\/alarm_construct_graph\/embedding_10.pt'\r\n            dataset.alarm_features = torch.load(alarm_feature_path)\r\n    elif args.dataset == 'disease':\r\n        dataset = load_disease_dataset()\r\n    elif args.dataset == 'cora':\r\n        dataset = load_cora_dataset()\r\n    else:\r\n        raise ValueError(\"Invalid dataset type\")\r\n\r\n    data = train_test_split_edges(dataset, val_ratio=args.val_ratio, test_ratio=args.test_ratio)\r\n\r\n    # =============================================================================================\r\n    # the flowing step is just for huawei dataset\r\n    if args.dataset == 'huawei' and args.hierarchical:\r\n        # data.val_pos_edge_index\r\n        edge_index = data.val_pos_edge_index.t().tolist()\r\n        mask = [False] * len(edge_index)\r\n        for i in range(len(edge_index)):\r\n            if (data.labels[edge_index[i][0]] == 1 and data.labels[edge_index[i][1]] != 1) \\\r\n                    or (data.labels[edge_index[i][0]] != 1 and data.labels[edge_index[i][1]] == 1):\r\n                mask[i] = True\r\n        data.val_pos_edge_index = torch.tensor(edge_index, dtype=torch.long)[mask].t().contiguous()\r\n\r\n        # data.val_neg_edge_index\r\n        edge_index = data.val_neg_edge_index.t().tolist()\r\n        mask = [False] * len(edge_index)\r\n        for i in range(len(edge_index)):\r\n            if (data.labels[edge_index[i][0]] == 1 and data.labels[edge_index[i][1]] != 1) \\\r\n                    or (data.labels[edge_index[i][0]] != 1 and data.labels[edge_index[i][1]] == 1):\r\n                mask[i] = True\r\n        data.val_neg_edge_index = torch.tensor(edge_index, dtype=torch.long)[mask].t().contiguous()\r\n\r\n        # data.test_neg_edge_index\r\n        edge_index = data.test_pos_edge_index.t().tolist()\r\n        mask = [False] * len(edge_index)\r\n        for i in range(len(edge_index)):\r\n            if (data.labels[edge_index[i][0]] == 1 and data.labels[edge_index[i][1]] != 1) \\\r\n                    or (data.labels[edge_index[i][0]] != 1 and data.labels[edge_index[i][1]] == 1):\r\n                mask[i] = True\r\n        data.test_pos_edge_index = torch.tensor(edge_index, dtype=torch.long)[mask].t().contiguous()\r\n\r\n        # data.test_neg_edge_index\r\n        edge_index = data.test_neg_edge_index.t().tolist()\r\n        mask = [False] * len(edge_index)\r\n        for i in range(len(edge_index)):\r\n            if (data.labels[edge_index[i][0]] == 1 and data.labels[edge_index[i][1]] != 1) \\\r\n                    or (data.labels[edge_index[i][0]] != 1 and data.labels[edge_index[i][1]] == 1):\r\n                mask[i] = True\r\n        data.test_neg_edge_index = torch.tensor(edge_index, dtype=torch.long)[mask].t().contiguous()\r\n    # =================================================================================================\r\n\r\n    edge_index, _ = add_self_loops(data.train_pos_edge_index)\r\n    data.train_neg_edge_index = negative_sampling(\r\n        edge_index=edge_index,\r\n        num_nodes=data.num_nodes,\r\n        num_neg_samples=data.train_pos_edge_index.size(1)\r\n    )\r\n    print('The dataset and the split edges are done!!!')\r\n\r\n    if args.pretrain:\r\n        pretrained_data = data.clone()\r\n        pretrained_data.train_pos_edge_index = torch.cat(\r\n            (pretrained_data.train_pos_edge_index, pretrained_data.train_neg_edge_index), dim=1\r\n        )\r\n        pretrained_data.train_neg_edge_index = None\r\n        # 这个地方如果选择pretrain，应该采取negative injection的方式，重新训练得到特征\r\n        print('-' * 60)\r\n        print('Pretraining')\r\n        if args.pre_encoder == 'GCN':\r\n            pre_model = GAE(GCN(dataset.num_features, 32))\r\n        else:\r\n            raise ValueError('Invalid model type!')\r\n\r\n        optimizer = torch.optim.Adam(pre_model.parameters(), lr=0.001)\r\n\r\n        best_auc = 0\r\n        patience = 0\r\n        for pretrained_epoch in range(1, args.pretrained_epochs):\r\n            train_loss, node_embedding = pre_train(pre_model, pretrained_data, optimizer)\r\n            val_auc, val_ap = pre_test(pre_model, data.x, data.train_pos_edge_index,\r\n                                       data.val_pos_edge_index, data.val_neg_edge_index)\r\n            print(f\"Epoch: {pretrained_epoch:03d}, Loss: {train_loss:.4f}, Val_AUC: {val_auc:.4f}, Val_AP: {val_ap:.4f}\")\r\n            if val_auc > best_auc:\r\n                best_auc = val_auc\r\n                patience = 0\r\n            else:\r\n                patience += 1\r\n            if patience > args.patience:\r\n                break\r\n\r\n        print('-' * 60)\r\n        print('Finished pretraining')\r\n        data.pretrained_features = node_embedding.detach()\r\n\r\n    if args.embedding == 'DRNL':\r\n        pass\r\n    else:\r\n        data.x = data.y\r\n\r\n    print('Starting extracting subgraphs~~~')\r\n    # collect a list of subgraphs of training, validation and test\r\n    train_pos_list = extract_enclosing_subgraphs(\r\n        data, data.train_pos_edge_index, data.train_pos_edge_index, 1\r\n    )\r\n    train_neg_list = extract_enclosing_subgraphs(\r\n        data, data.train_neg_edge_index, data.train_pos_edge_index, 0\r\n    )\r\n\r\n    val_pos_list = extract_enclosing_subgraphs(\r\n        data, data.val_pos_edge_index, data.train_pos_edge_index, 1\r\n    )\r\n    val_neg_list = extract_enclosing_subgraphs(\r\n        data, data.val_neg_edge_index, data.train_pos_edge_index, 0\r\n    )\r\n\r\n    test_pos_list = extract_enclosing_subgraphs(\r\n        data, data.test_pos_edge_index, data.train_pos_edge_index, 1\r\n    )\r\n    test_neg_list = extract_enclosing_subgraphs(\r\n        data, data.test_neg_edge_index, data.train_pos_edge_index, 0\r\n    )\r\n    print('Finished extracting subgraphs.')\r\n\r\n    if args.embedding == 'DRNL':\r\n        # convert labels to one-hot features\r\n        for data in chain(train_pos_list, train_neg_list,\r\n                          val_pos_list, val_neg_list,\r\n                          test_pos_list, test_neg_list):\r\n            data.x = F.one_hot(data.z, max_z + 1).to(torch.float)\r\n    elif args.embedding == 'DRNL_SelfFeat':\r\n        for data in chain(train_pos_list, train_neg_list,\r\n                          val_pos_list, val_neg_list,\r\n                          test_pos_list, test_neg_list):\r\n            data.x = torch.cat((F.one_hot(data.z, max_z + 1).to(torch.float), data.x), dim=1)\r\n    elif args.embedding == 'SelfFeat':\r\n        pass\r\n    else:\r\n        raise ValueError(\"Unsupported embedding type.\")\r\n\r\n    if args.pretrain:\r\n        for data in chain(train_pos_list, train_neg_list,\r\n                          val_pos_list, val_neg_list,\r\n                          test_pos_list, test_neg_list):\r\n            data.x = torch.cat((data.x, data.pretrained_features), dim=1)\r\n            data.pretrained_features = None\r\n\r\n    if args.use_alarm:\r\n        for data in chain(train_pos_list, train_neg_list,\r\n                          val_pos_list, val_neg_list,\r\n                          test_pos_list, test_neg_list):\r\n            data.x = torch.cat((data.x, data.alarm_features), dim=1)\r\n            data.alarm_features = None\r\n\r\n    return train_pos_list + train_neg_list, val_pos_list + val_neg_list, test_pos_list + test_neg_list\r\n\r\n\r\ndef train(model, train_loader, device, optimizer, train_dataset):\r\n    model.train()\r\n\r\n    total_loss = 0\r\n    for data in train_loader:\r\n        data = data.to(device)\r\n        optimizer.zero_grad()\r\n        logits = model(data.x, data.edge_index, data.batch)\r\n        loss = BCEWithLogitsLoss()(logits.view(-1), data.y.to(torch.float))\r\n        loss.backward()\r\n        optimizer.step()\r\n        total_loss += loss.item() * data.num_graphs\r\n\r\n    return total_loss \/ len(train_dataset)\r\n\r\n\r\n@torch.no_grad()\r\ndef test(loader, model, device):\r\n    model.eval()\r\n\r\n    y_pred, y_true = [], []\r\n    for data in loader:\r\n        data = data.to(device)\r\n        logits = model(data.x, data.edge_index, data.batch)\r\n        y_pred.append(logits.view(-1).cpu())\r\n        y_true.append(data.y.view(-1).cpu().to(torch.float))\r\n\r\n    return roc_auc_score(torch.cat(y_true), torch.cat(y_pred)), \\\r\n           average_precision_score(torch.cat(y_true), torch.cat(y_pred))\r\n\r\n\r\ndef run():\r\n    parser = argparse.ArgumentParser(\"Configurations for seal\")\r\n    parser.add_argument('--dataset', default='huawei', type=str, help='dataset')\r\n    parser.add_argument('--embedding', default='DRNL', type=str,\r\n                        help='node encoding([\"DRNL\", \"DRNL_SelfFeat\", \"SelfFeat\"])')\r\n    parser.add_argument('--epochs', default=101, type=int, help='training epochs')\r\n    parser.add_argument('--cuda', default=torch.cuda.is_available(), type=bool, help='cuda')\r\n    parser.add_argument('--lr', default=0.0001, type=float, help='learning rate')\r\n    parser.add_argument('--weight_decay', default=5e-4, type=float, help='weight decay')\r\n    parser.add_argument('--val_ratio', default=0.05, type=float)\r\n    parser.add_argument('--test_ratio', default=0.10, type=float)\r\n    parser.add_argument('--batch_size', default=32, type=int, help='batch size')\r\n    parser.add_argument('--pretrain', action='store_true')\r\n    parser.add_argument('--pretrained_epochs', default=401, type=int)\r\n    parser.add_argument('--pre_encoder', default='GCN', type=str, choices=['GCN'])\r\n    parser.add_argument('--patience', default=50, type=int, help='early stop steps')\r\n    parser.add_argument('--use_alarm', action='store_true')\r\n    parser.add_argument('--hierarchical', action='store_true')\r\n    args = parser.parse_args()\r\n    print(args)\r\n\r\n    args.split_ratio = str(int((1-args.val_ratio-args.test_ratio)*100)) \\\r\n                       + str(int(args.val_ratio*100)) + str(int(args.test_ratio*100))\r\n\r\n    train_dataset, val_dataset, test_dataset = process(args)\r\n\r\n    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)\r\n    val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False)\r\n    test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False)\r\n\r\n    device = torch.device('cuda:1' if args.cuda else 'cpu')\r\n    model = DGCNN(train_dataset, hidden_channels=32, num_layers=3).to(device)\r\n    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)\r\n\r\n    trainWriter = SummaryWriter('..\/{}\/{}\/{}\/{}\/{}'.format(\r\n        'runs', 'SEAL', args.dataset + '_' + args.split_ratio + '_pretrained_' + str(args.pretrain),\r\n        args.embedding, 'Train'\r\n    ))\r\n    valWriter = SummaryWriter('..\/{}\/{}\/{}\/{}\/{}'.format(\r\n        'runs', 'SEAL', args.dataset + '_' + args.split_ratio + '_pretrained_' + str(args.pretrain),\r\n        args.embedding, 'Val'\r\n    ))\r\n\r\n    best_val_auc = test_auc = test_ap = 0\r\n\r\n    for epoch in range(1, args.epochs):\r\n        loss = train(model, train_loader, device, optimizer, train_dataset)\r\n        trainWriter.add_scalar(tag='Train Loss', scalar_value=loss, global_step=epoch)\r\n        val_auc, val_ap = test(val_loader, model, device)\r\n        valWriter.add_scalar(tag='Val AUC', scalar_value=val_auc, global_step=epoch)\r\n        valWriter.add_scalar(tag='Val AP', scalar_value=val_ap, global_step=epoch)\r\n        if val_auc > best_val_auc:\r\n            best_val_auc = val_auc\r\n            test_auc, test_ap = test(test_loader, model, device)\r\n            # saving model parameters\r\n            state = {'model': model.state_dict(), 'auc': test_auc, 'ap': test_ap, 'epoch': epoch}\r\n            save_path = '..\/checkpoint\/SEAL\/'\r\n            if not osp.exists(save_path):\r\n                os.mkdir(save_path)\r\n            torch.save(state, osp.join(save_path, args.dataset+'-'+args.split_ratio+'-'+args.embedding+'-'+'ckpt.pth'))\r\n\r\n        print(f'Epoch: {epoch:02d}, Loss: {loss:.4f}, Val_AUC: {val_auc:.4f}, Val_AP: {val_ap:.4f},'\r\n              f'Test_AUC: {test_auc:.4f}, Test_AP: {test_ap:.4f}')\r\n\r\n\r\nif __name__ == \"__main__\":\r\n    run()\r\n\r\n\r\n\r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_494","text":"<filename>python\/dataset\/common_voice_loader.py\n\"\"\"Load the Mozilla Common Voice dataset.\"\"\"\n\nimport sys\nimport os\nimport csv\nimport subprocess\n\nfrom multiprocessing import Pool, Lock, cpu_count\nfrom tqdm import tqdm\nfrom scipy.io import wavfile\n\nfrom python.params import MIN_EXAMPLE_LENGTH, MAX_EXAMPLE_LENGTH\nfrom python.dataset.config import CACHE_DIR, CORPUS_DIR\nfrom python.util.storage import delete_file_if_exists\nfrom python.dataset import download\nfrom python.dataset.txt_files import generate_txt\n\n\n# Path to the Mozilla Common Voice dataset.\n__URL = 'https:\/\/common-voice-data-download.s3.amazonaws.com\/cv_corpus_v1.tar.gz'\n__MD5 = 'f1007e78cf91ab76b7cd3f1e8f554110'\n__NAME = 'commonvoice'\n__FOLDER_NAME = 'cv_corpus_v1'\n__SOURCE_PATH = os.path.join(CACHE_DIR, __FOLDER_NAME)\n__TARGET_PATH = os.path.realpath(os.path.join(CORPUS_DIR, __FOLDER_NAME))\n\n# Define valid accents.\n__VALID_ACCENTS = ['us',\n                   'england',\n                   'canada',\n                   'australia',\n                   'wales',\n                   'newzealand',\n                   'ireland',\n                   'scotland',\n                   'wales',\n                   '']\n\n\ndef common_voice_loader(keep_archive):\n    \"\"\"Download and extract the common voice archive. Then build the output strings that can be\n    written to the desired TXT files.\n\n    Uses only the valid datasets, additional constraints are:\n    * Downvotes must be at maximum 1\/4 of upvotes.\n    * Valid accents are: 'us', 'england', 'canada', 'australia'.\n    * Accepting samples with only 1 upvote at the moment.\n\n    Args:\n        keep_archive (bool): Keep or delete the downloaded archive afterwards.\n\n    Returns:\n        Tuple[str]: Tuple containing the output strings that can be written to TXT files.\n    \"\"\"\n\n    # Download and extract the dataset if necessary.\n    download.maybe_download(__URL, md5=__MD5, cache_archive=keep_archive)\n    if not os.path.isdir(__SOURCE_PATH):\n        raise ValueError('\"{}\" is not a directory.'.format(__SOURCE_PATH))\n\n    # Folders for each target.\n    targets = [\n        {\n            'name': 'train',\n            'folders': ['cv-valid-train']\n        }, {\n            'name': 'test',\n            'folders': ['cv-valid-test']\n        }, {\n            'name': 'dev',\n            'folders': ['cv-valid-dev']\n        }\n    ]\n\n    txt_paths = []\n    for target in targets:\n        # Generate the WAV and a string for the `<target>.txt` file.\n        output = __common_voice_loader(target['folders'])\n        # Generate the `<target>.txt` file.\n        txt_paths.append(generate_txt(__NAME, target['name'], output))\n\n    # Cleanup extracted folder.\n    download.cleanup_cache(__FOLDER_NAME)\n\n    return tuple(txt_paths)\n\n\ndef __common_voice_loader(folders):\n    \"\"\"Build the output string that can be written to the desired TXT file.\n\n    Uses only the valid datasets, additional constraints are:\n    * Downvotes must be at maximum 1\/4 of upvotes.\n    * Valid accents are: 'us', 'england', 'canada', 'australia'.\n    * Accepting samples with only 1 upvote at the moment.\n\n    Args:\n        folders (List(str)): A list containing folder names, e.g. `['train-valid', 'train-other']`.\n\n    Returns:\n        List[str]: List containing the output string that can be written to *.txt file.\n    \"\"\"\n\n    output = []\n    for folder in tqdm(folders, desc='Converting Common Voice data', total=len(folders),\n                       file=sys.stdout, unit='CSVs', dynamic_ncols=True):\n        # Open .csv file.\n        with open('{}.csv'.format(os.path.join(__SOURCE_PATH, folder)), 'r') as csv_file:\n            csv_reader = csv.reader(csv_file, delimiter=',')\n            csv_lines = list(csv_reader)\n            # print('csv_header:', csv_lines[0])\n            # filename,text,up_votes,down_votes,age,gender,accent,duration\n\n            lock = Lock()\n            with Pool(processes=cpu_count()) as pool:\n                # Create target folder if necessary.\n                target_directory = os.path.join(__TARGET_PATH, folder)\n                if not os.path.exists(target_directory):\n                    os.makedirs(target_directory)\n\n                # First line contains header.\n                for result in pool.imap_unordered(__common_voice_loader_helper,\n                                                  csv_lines[1:], chunksize=1):\n                    if result is not None:\n                        lock.acquire()\n                        output.append(result)\n                        lock.release()\n\n    return output\n\n\ndef __common_voice_loader_helper(line):\n    # Helper method for thread pool.\n\n    # Cleanup label text.\n    text = line[1].strip().replace('  ', ' ')\n    # Enforce min label length.\n    if len(text) > 1:\n        # Check upvotes vs downvotes.\n        if int(line[2]) >= 1 and int(line[3]) \/ int(line[2]) <= 1 \/ 4:\n            # Check if speaker accent is valid.\n            if line[6] in __VALID_ACCENTS:\n                mp3_path = os.path.join(__SOURCE_PATH, line[0])\n                assert os.path.isfile(mp3_path)\n                wav_path = os.path.relpath('{}.wav'.format(mp3_path[:-4]), __SOURCE_PATH)\n                wav_path = os.path.join(__TARGET_PATH, wav_path)\n\n                delete_file_if_exists(wav_path)\n                # Convert MP3 to WAV, reduce volume to 0.95, downsample to 16kHz and mono sound.\n                subprocess.call(['sox', '-v', '0.95', mp3_path, '-r', '16k', wav_path,\n                                 'remix', '1'])\n                assert os.path.isfile(wav_path)\n\n                # Validate that the example length is within boundaries.\n                (sr, y) = wavfile.read(wav_path)\n                length_sec = len(y) \/ sr\n                if not MIN_EXAMPLE_LENGTH <= length_sec <= MAX_EXAMPLE_LENGTH:\n                    return None\n\n                # Add dataset relative to dataset path, label to TXT file buffer.\n                wav_path = os.path.relpath(wav_path, CORPUS_DIR)\n                return '{} {}\\n'.format(wav_path, text)\n\n    return None\n\n\n# Test download script.\nif __name__ == '__main__':\n    print('Common Voice txt_paths: ', common_voice_loader(True))\n    print('\\nDone.')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_483","text":"import scipy.sparse as sp\nimport numpy as np\nfrom typing import List\n\n\ndef create_adj_matrix(a_item2b_item: dict,\n                      ordered_list_a_item: list,\n                      ordered_list_b_item: list) -> sp.csr_matrix:\n    \"\"\"\n\n    Parameters\n    ----------\n    a_item2b_item: dict\n        dictionary from a_item to set of corresponding b_items\n    ordered_list_a_item: list\n        list with required a_items (unique)\n    ordered_list_b_item: list\n        list with required b_items (unique)\n\n    Returns\n    -------\n    sp.csc_matrix\n        adjacency matrix for a_items and b_items.\n        adjacency matrix[i, j] = 1 <=> b_item in a_item2b_item[a_item]\n        (a_item = ordered_list_a_item[i], b_item = ordered_list_b_item[i])\n\n    \"\"\"\n    num_a_item = len(ordered_list_a_item)\n    num_b_item = len(ordered_list_b_item)\n    b_item2idx = dict(zip(ordered_list_b_item, range(num_b_item)))\n    rows = []  # Non zero row indexes in adj_matrix\n    cols = []  # Non zero column indexes in adj_matrix\n    for i, a_item in enumerate(ordered_list_a_item):\n        correspond_b_items = a_item2b_item[a_item].intersection(\n            set(ordered_list_b_item))\n        for b_item in correspond_b_items:\n            rows.append(i)\n            cols.append(b_item2idx[b_item])\n\n    data = np.ones_like(rows)\n    adj_matrix = sp.csr_matrix((data, (rows, cols)),\n                               shape=(num_a_item, num_b_item))\n    return adj_matrix\n\n\ndef create_combo_adj(combo_a_item2b_item: dict,\n                     combo_a_item2a_item: dict,\n                     ordered_list_a_item: list,\n                     ordered_list_b_item: list) -> List[sp.csr_matrix]:\n    \"\"\"\n\n    Parameters\n    ----------\n    combo_a_item2b_item: dict\n         dict from combo a_items name to set of corresponding b_items\n         (e.g. drug-drug pair name -> names of corresponding side effects)\n    combo_a_item2a_item: dict\n        dict from combo a_items name to sequence of two individual a_item names\n        (e.g. combo drug-drug pair name -> np.array of two individual names)\n    ordered_list_a_item: list\n        list with required a_items (unique)\n        (e.g. ordered list of drugs)\n    ordered_list_b_item: list\n        list with required b_items (unique)\n        (e.g. ordered list of combo se)\n\n    Returns\n    -------\n    List[sp.csr_matrix]\n        list of adjacency matrices for a_items.\n        For each b_item this matrix creates separately.\n        (e.g. drug-drug adjacency matrix for each side effect.\n        se adjacency matrix element is nonzero for two drugs <=>\n        <=> corresponding two drugs have this se)\n\n\n    \"\"\"\n    num_a_item = len(ordered_list_a_item)\n    num_b_item = len(ordered_list_b_item)\n    a_item2idx = dict(zip(ordered_list_a_item, range(num_a_item)))\n    b_item2idx = dict(zip(ordered_list_b_item, range(num_b_item)))\n\n    # rows[i], cols[i] -- lists of non zero indexes in adj_matrix of ith b_item\n    rows = [[] for _ in range(num_b_item)]\n    cols = [[] for _ in range(num_b_item)]\n    for combo_a_item, set_b_item in combo_a_item2b_item.items():\n        a_item1, a_item2 = combo_a_item2a_item[combo_a_item]\n        if a_item1 not in ordered_list_a_item:\n            continue\n        if a_item2 not in ordered_list_a_item:\n            continue\n        idx_a_item1 = a_item2idx[a_item1]\n        idx_a_item2 = a_item2idx[a_item2]\n        correspond_b_items = combo_a_item2b_item[combo_a_item].intersection(\n            set(ordered_list_b_item))\n        for b_item in correspond_b_items:\n            idx_b_item = b_item2idx[b_item]\n\n            rows[idx_b_item].append(idx_a_item1)\n            cols[idx_b_item].append(idx_a_item2)\n\n            rows[idx_b_item].append(idx_a_item2)\n            cols[idx_b_item].append(idx_a_item1)\n    drug_drug_adj_list = [sp.csr_matrix((np.ones_like(rs), (rs, cs)),\n                                        shape=(num_a_item, num_a_item))\n                          for rs, cs in zip(rows, cols)]\n    return drug_drug_adj_list\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_486","text":"<filename>tayloralgebra.py\nimport operator\nimport numpy as np\n\nfrom scipy import special\nfrom scipy.special import factorial\n\nclass TaylorExpansion(object):\n\n    def __init__(self, coefficients, center=0, cut_off=10):\n        assert isinstance(coefficients, list) and all([isinstance(a, (float, int)) for a in coefficients])\n        self.coefficients = [float(a) for a in coefficients[:cut_off]]\n        self.center = center\n        self.cut_off = cut_off\n\n    @property\n    def degree(self):\n        return len(self) - 1\n\n    def __str__(self):\n        return self.coefficients.__str__()\n\n    def __call__(self, x):\n        if isinstance(x, TaylorExpansion):\n            return self.compose(x)\n        else:\n            return sum([a * (x - self.center)**k for k, a in enumerate(self.coefficients)])\n\n    def __len__(self):\n        return len(self.coefficients)\n\n    def __iter__(self):\n        return iter(self.coefficients)\n\n    def __getitem__(self, index):\n        return self.coefficients[index]\n\n    def __add__(self, other):\n        if isinstance(other, TaylorExpansion):\n            #assert self.center == other.center, \"You cannot sum Taylor series defined at different points (centers)\"\n            cut_off = self._get_cut_off(other)\n            longer, shorter = self._sort(other)\n            return TaylorExpansion([a + shorter[k] if k < len(shorter) else a\n                                    for k, a in enumerate(longer)], center=self.center, cut_off=cut_off)\n        elif isinstance(other, (int, float)):\n            return TaylorExpansion([a + other if k == 0 else a\n                                    for k, a in enumerate(self)], center=self.center, cut_off=self.cut_off)\n        else:\n            raise ValueError\n\n    def __neg__(self):\n        return -1 * self\n\n    def __sub__(self, other):\n        return self + -other\n\n    def __radd__(self, other):\n        return self + other\n\n    def __mul__(self, other):\n        if isinstance(other, (float, int)):\n            cut_off = self.cut_off\n            new_coefficients = [other * a for a in self.coefficients]\n        elif isinstance(other, (TaylorExpansion)):\n            #assert self.center == other.center, \"You cannot multiply Taylor series defined at different points (centers)\"\n            new_coefficients = []\n            longer, shorter = self._sort(other)\n            cut_off = self._get_cut_off(other)\n            for n in range(min(len(self) + len(other) - 1, cut_off)):\n                nth_coeff = sum([longer[k] * shorter[n - k] for k in range(len(longer))\n                                 if len(shorter) > (n - k) >= 0])\n                new_coefficients.append(nth_coeff)\n        else:\n            raise ValueError\n        return TaylorExpansion(new_coefficients, center=self.center, cut_off=cut_off)\n\n    def __rmul__(self, other):\n        return self * other\n\n    def __truediv__(self, other):\n        cut_off = self._get_cut_off(other)\n        inv = MultiplicativeInverse(other[0], cut_off)\n        return self * inv(other - other[0])\n\n    def compose(self, other):\n        assert self.center == other.coefficients[0], \"Error during composition: The constant coefficient of the internal function should be equal to the center of the external function\"\n        cut_off = self._get_cut_off(other)\n        power = (other - self.center)\n        result = self[0]\n        for k in range(1, min(len(self), cut_off)):\n            result += self[k] * power\n            power = power * (other - self.center)\n        return result if isinstance(result, TaylorExpansion) else TaylorExpansion(coefficients=[result],\n                                                                                  center=self.center,\n                                                                                  cut_off=self.cut_off)\n\n    def _sort(self, other):\n        longer = self if len(self) > len(other) else other\n        shorter = other if self is longer else self\n        return longer, shorter\n\n    def _get_cut_off(self, other):\n        return min(self.cut_off, other.cut_off)\n\n\n#class MultiplicativeInverse(TaylorExpansion):\n    #\n    # def __init__(self, a, cut_off):\n    #     if a == 0:\n    #         raise ZeroDivisionError\n    #     coefficients = [(-a) ** (-n) \/ a for n in range(cut_off)]\n    #     super().__init__(coefficients, cut_off)\n\n\ndef compose_operator(left, right):\n    return left(right)\n\n\nclass SymbolicFunction(object):\n\n    def get_expansion(self, center, cut_off):\n        pass #Abstract\n\n    def evaluate(self, x):\n        pass #abstract\n\n    def _apply_operator(self, other, op):\n        operation_list = [op, self, other]\n        return CompositeFunction(operation_list)\n\n    def __call__(self, x):\n        if isinstance(x, SymbolicFunction):\n            return self.compose(x)\n        else:\n            return self.evaluate(x)\n\n    def compose(self, other):\n        return self._apply_operator(other, compose_operator)\n\n    def __neg__(self):\n        return -1*self\n\n    def __add__(self, other):\n        return self._apply_operator(other, operator.add)\n\n    def __radd__(self, other):\n        return self.__add__(other)\n\n    def __sub__(self, other):\n        return self._apply_operator(other, operator.sub)\n\n    def __rsub__(self, other):\n        return -1*self.__sub__(other)\n\n    def __mul__(self, other):\n        return self._apply_operator(other, operator.mul)\n\n    def __rmul__(self, other):\n        return self.__mul__(other)\n\n    def __truediv__(self, other):\n        if isinstance(other, SymbolicFunction):\n            return self*(MultiplicativeInverse()(other))\n        else:\n            return self*(1\/other)\n\n    def __rtruediv__(self, other):\n        return self.__truediv__(other)**(-1)\n\n    def __pow__(self, other):\n        if isinstance(other, int):\n            return PowerFunction(other)(self)\n        else:\n            return ExponentialFunction()(other*LogarithmFunction()(self))\n\n    def __rpow__(self, other):\n        raise NotImplementedError\n\n\nclass PrimitiveFunction(SymbolicFunction):\n\n    def __init__(self, coeff_generator, fn, inv_fn=None):\n        self.coeff_generator = coeff_generator\n        self.fn = fn\n        self.inv_fn = inv_fn\n        self.taylor_expansion = {}\n\n    def evaluate(self, x):\n        return self.fn(x)\n\n    # def invert(self):\n    #     assert self.inv_fn is not None, \"The function cannot be inverted\"\n    #     inv_derivative_function = MultiplicativeInverse()(self.derivative())\n    #\n    #     def inv_coeff(c, n):\n    #         if n == 0:\n    #             return self.inv_fn(c)\n    #         elif n == 1:\n    #             return 1 \/ self.coeff_generator(self.inv_fn(c), n)\n    #         else:\n    #             return inv_derivative_function.get_expansion(self.inv_fn(c), n)[n-1]\n    #\n    #     return PrimitiveFunction(inv_coeff, self.inv_fn, self.fn)\n\n    def get_expansion(self, center, cut_off):\n        if (center, cut_off) not in self.taylor_expansion:\n            coefficients = [self.coeff_generator(center, n)\n                            for n in range(cut_off)]\n            self.taylor_expansion.update({(center, cut_off): TaylorExpansion(coefficients, center, cut_off)})\n        return self.taylor_expansion[(center, cut_off)]\n\n    def derivative(self):\n        pass #abstract\n\n\nclass ExponentialFunction(PrimitiveFunction):\n\n    def __init__(self):\n        coeff_generator = lambda c, n: np.exp(c)\/factorial(n)\n        fn = lambda x: np.exp(x)\n        inv_fn = lambda x: np.log(x)\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return ExponentialFunction()\n\n\nclass LogarithmFunction(PrimitiveFunction):\n\n    def __init__(self):\n        coeff_generator = lambda c, n: (-1)**(n+1)*c**(-n)\/n if n>0 else np.log(c)\n        fn = lambda x: np.log(x)\n        inv_fn = lambda x: np.exp(x)\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return MultiplicativeInverse()\n\n\nclass SineFunction(PrimitiveFunction):\n\n    def __init__(self):\n        coeff_generator = lambda c, n: np.sin(n*np.pi\/2. + c)\/factorial(n)\n        fn = lambda x: np.sin(x)\n        inv_fn = lambda x: np.arcsin(x)\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return CosineFunction()\n\n\nclass CosineFunction(PrimitiveFunction):\n\n    def __init__(self):\n        coeff_generator = lambda c, n: np.cos(n*np.pi\/2. + c)\/factorial(n)\n        fn = lambda x: np.cos(x)\n        inv_fn = lambda x: np.arccos(x)\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return SineFunction()\n\n\nclass LogGammaFunction(PrimitiveFunction):\n\n    def __init__(self):\n        fn = lambda x: np.log(special.gamma(x))\n        inv_fn = None\n\n        def coeff_generator(c, n):\n            if n == 0:\n                return fn(c)\n            else:\n                return special.polygamma(n-1, c)\/factorial(n)\n\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return SineFunction()\n\n\nclass MultiplicativeInverse(PrimitiveFunction):\n\n    def __init__(self):\n        coeff_generator = lambda c, n: (-1)**n*c**(-(n+1))\n        fn = lambda x: 1\/x\n        inv_fn = lambda x: 1\/x\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return -PowerFunction(2)(MultiplicativeInverse())\n\n\nclass PowerFunction(PrimitiveFunction):\n\n    def __init__(self, k):\n        def decreasing_factorial(k, n):\n            if n < 0:\n                return 0\n            elif n == 0:\n                return 1\n            elif n == 1:\n                return k\n            else:\n                return k*decreasing_factorial(k-1, n-1)\n        coeff_generator = lambda c, n: (decreasing_factorial(k, n)\/factorial(n))*c**(k-n) if n <= k else 0.\n        fn = lambda x: x**k\n        inv_fn = lambda x: x**(1\/k)\n        self.k = k\n        super().__init__(coeff_generator, fn, inv_fn)\n\n    def derivative(self):\n        return self.k*PowerFunction(self.k - 1)\n\nclass CompositeFunction(SymbolicFunction):\n\n    def __init__(self, operation_list):\n        self.operation_list = operation_list\n\n    def get_expansion(self, center, cut_off):\n        op, left, right = self.operation_list\n        if op is compose_operator:\n            left_center = right.get_expansion(center, cut_off)[0]\n        else:\n            left_center = center\n        return op(left.get_expansion(left_center, cut_off) if isinstance(left, SymbolicFunction) else left,\n                  right.get_expansion(center, cut_off) if isinstance(right, SymbolicFunction) else right)\n\n    def evaluate(self, x):\n        op, left, right = self.operation_list\n        if op is compose_operator:\n            return left.evaluate(right.evaluate(x))\n        else:\n            return op(left.evaluate(x) if isinstance(left, SymbolicFunction) else left,\n                      right.evaluate(x) if isinstance(right, SymbolicFunction) else right)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_495","text":"<filename>suncasa\/utils\/plot_mapX.py\n# import os\n# import matplotlib as mpl\nimport matplotlib.pyplot as plt\n# import matplotlib.colorbar as colorbar\n# import sunpy.cm.cm as cm  ## to bootstrap sdoaia color map\n# import matplotlib.cm as cm\n# import matplotlib.colors as colors\nimport astropy.units as u\n# from astropy.io import fits\n# import matplotlib.dates as mdates\n# from astropy.time import Time\nfrom sunpy import map as smap\n# import matplotlib.gridspec as gridspec\n# import numpy.ma as ma\n# import matplotlib.patches as patches\n# from suncasa.utils import stackplot as stp\n# from IPython import embed\n# from astropy.coordinates import SkyCoord\nimport numpy as np\nfrom suncasa.utils import DButil\nimport warnings\nimport matplotlib.patches as patches\nimport numpy.ma as ma\n\n\nclass Sunmap():\n\n    def __init__(self, sunmap, aia=False):\n        if aia:\n            try:\n                sunmap = DButil.normalize_aiamap(sunmap)\n            except:\n                pass\n            data = sunmap.data\n            data[data < 1.0] = 1.0\n            self.sunmap = smap.Map(data, sunmap.meta)\n        else:\n            self.sunmap = sunmap\n\n        try:\n            top_right_coord = self.sunmap.top_right_coord\n            bottom_left_coord = self.sunmap.bottom_left_coord\n            self.xrange = np.array([bottom_left_coord.Tx.to(u.arcsec).value, top_right_coord.Tx.to(u.arcsec).value])*u.arcsec\n            self.yrange = np.array([bottom_left_coord.Ty.to(u.arcsec).value, top_right_coord.Ty.to(u.arcsec).value])*u.arcsec\n        except:\n            self.xrange = self.sunmap.xrange\n            self.yrange = self.sunmap.yrange\n\n    def map2wcsgrids(self, sunpymap=None, cell=False):\n        '''\n\n        :param sunpymap:\n        :param cell: if True, return the coordinates of the pixel centers. if False, return the coordinates of the pixel boundaries\n        :return:\n        '''\n        # embed()\n        import astropy.units as u\n        if sunpymap is None:\n            sunpymap = self.sunmap\n        ny, nx = sunpymap.data.shape\n        x0, x1 = self.xrange.to(u.arcsec).value\n        y0, y1 = self.yrange.to(u.arcsec).value\n        dx = sunpymap.scale.axis1.to(u.arcsec \/ u.pix).value\n        dy = sunpymap.scale.axis2.to(u.arcsec \/ u.pix).value\n\n        if cell:\n            mapx, mapy = np.linspace(x0, x1, nx) - dx \/ 2.0, np.linspace(y0, y1, ny) - dy \/ 2.0\n            mapx = np.tile(mapx, ny).reshape(ny, nx)\n            mapy = np.tile(mapy, nx).reshape(nx, ny).transpose()\n        else:\n            nx += 1\n            ny += 1\n            mapx, mapy = np.linspace(x0 - dx, x1 + dx, nx), np.linspace(y0 - dy, y1 + dy, ny)\n            mapx = np.tile(mapx, ny).reshape(ny, nx)\n            mapy = np.tile(mapy, nx).reshape(nx, ny).transpose()\n        return mapx, mapy\n\n    def get_map_extent(self, sunpymap=None, rot=0, rangereverse=False):\n        if sunpymap is None:\n            sunpymap = self.sunmap\n        rot = rot % 360\n        if rot == 90:\n            extent = np.array(\n                self.yrange.to(u.arcsec).value[::-1].tolist() + self.xrange.to(u.arcsec).value.tolist())\n            extent = extent - np.array([sunpymap.scale.axis2.value] * 2 + [sunpymap.scale.axis1.value] * 2) \/ 2.0\n        elif rot == 180:\n            extent = np.array(\n                self.xrange.to(u.arcsec).value[::-1].tolist() + self.yrange.to(u.arcsec).value[::-1].tolist())\n            extent = extent - np.array([sunpymap.scale.axis1.value] * 2 + [sunpymap.scale.axis2.value] * 2) \/ 2.0\n        elif rot == 270:\n            extent = np.array(\n                self.yrange.to(u.arcsec).value.tolist() + self.xrange.to(u.arcsec).value[::-1].tolist())\n            extent = extent - np.array([sunpymap.scale.axis1.value] * 2 + [sunpymap.scale.axis2.value] * 2) \/ 2.0\n        else:\n            extent = np.array(self.xrange.to(u.arcsec).value.tolist() + self.yrange.to(u.arcsec).value.tolist())\n            extent = extent - np.array([sunpymap.scale.axis1.value] * 2 + [sunpymap.scale.axis2.value] * 2) \/ 2.0\n        if rangereverse:\n            x0, x1, y0, y1 = extent\n            extent = -np.array([x1, x0, y1, y0])\n        return extent\n\n    def imshow(self, axes=None, rot=0, rangereverse=False, maskon=False, image_enhance=False, **kwargs):\n        '''\n        :param sunpymap:\n        :param axes:\n        :param rot: rotation angle in degrees counter-clockwise. Must be an integer multiple of 90.\n        :param kwargs:\n        :return:\n        '''\n        sunpymap = self.sunmap\n        if axes is None:\n            axes = plt.subplot()\n        rot = rot % 360\n        if rot == 0:\n            imdata = sunpymap.data\n        elif rot == 90:\n            imdata = sunpymap.data.transpose()[:, ::-1]\n        elif rot == 180:\n            imdata = sunpymap.data[::-1, ::-1]\n        elif rot == 270:\n            imdata = sunpymap.data.transpose()[::-1, :]\n        else:\n            warnings.warn('rot must be an integer multiple of 90. rot not implemented!')\n            imdata = sunpymap.data\n            rot = 0\n        extent = self.get_map_extent(rot=rot, rangereverse=rangereverse)\n\n        if maskon:\n            if isinstance(maskon, bool):\n                imdataplt = ma.masked_invalid(imdata)\n                immask = imdataplt.mask\n            elif isinstance(maskon, dict):\n                if 'masked_equal' in maskon.keys():\n                    imdataplt = ma.masked_equal(imdata, maskon['masked_equal'])\n                elif 'masked_greater' in maskon.keys():\n                    imdataplt = ma.masked_greater(imdata, maskon['masked_greater'])\n                elif 'masked_less' in maskon.keys():\n                    imdataplt = ma.masked_less(imdata, maskon['masked_less'])\n                elif 'masked_greater_equal' in maskon.keys():\n                    imdataplt = ma.masked_greater_equal(imdata, maskon['masked_greater_equal'])\n                elif 'masked_less_equal' in maskon.keys():\n                    imdataplt = ma.masked_less_equal(imdata, maskon['masked_less_equal'])\n                elif 'masked_outside' in maskon.keys():\n                    v1, v2 = maskon['masked_outside']\n                    imdataplt = ma.masked_outside(imdata, v1, v2)\n                elif 'masked_inside' in maskon.keys():\n                    v1, v2 = maskon['masked_inside']\n                    imdataplt = ma.masked_inside(imdata, v1, v2)\n                elif 'masked_invalid' in maskon.keys():\n                    imdataplt = ma.masked_invalid(imdata)\n                else:\n                    raise ValueError('maskon key wrong.')\n                immask = imdataplt.mask\n            else:\n                raise TypeError('maskon must be bool or dict type.')\n        else:\n            imdataplt = imdata.copy()\n\n        if image_enhance:\n            dmax = np.nanmax(imdataplt)\n            dmin = np.nanmin(imdataplt)\n            from skimage.exposure import equalize_adapthist\n            if isinstance(image_enhance, dict):\n                imdataplt = equalize_adapthist(imdataplt, **image_enhance) * (dmax - dmin) + dmin\n            else:\n                imdataplt = equalize_adapthist(imdataplt) * (dmax - dmin) + dmin\n\n        if maskon:\n            imdataplt = ma.masked_array(imdataplt, immask)\n\n        if isinstance(axes, list):\n            ims = []\n            for ax in axes:\n                im = ax.imshow(imdataplt, extent=extent, origin='lower', **kwargs)\n                ims.append(im)\n                if rot == 0:\n                    ax.set_xlabel('Solar X [arcsec]')\n                    ax.set_ylabel('Solar Y [arcsec]')\n                elif rot == 90:\n                    ax.set_xlabel('-Solar Y [arcsec]')\n                    ax.set_ylabel('Solar X [arcsec]')\n                elif rot == 180:\n                    ax.set_xlabel('-Solar X [arcsec]')\n                    ax.set_ylabel('-Solar Y [arcsec]')\n                elif rot == 270:\n                    ax.set_xlabel('Solar Y [arcsec]')\n                    ax.set_ylabel('-Solar X [arcsec]')\n            return ims\n        else:\n            im = axes.imshow(imdataplt, extent=extent, origin='lower', **kwargs)\n\n            if rot == 0:\n                axes.set_xlabel('Solar X [arcsec]')\n                axes.set_ylabel('Solar Y [arcsec]')\n            elif rot == 90:\n                axes.set_xlabel('-Solar Y [arcsec]')\n                axes.set_ylabel('Solar X [arcsec]')\n            elif rot == 180:\n                axes.set_xlabel('-Solar X [arcsec]')\n                axes.set_ylabel('-Solar Y [arcsec]')\n            elif rot == 270:\n                axes.set_xlabel('Solar Y [arcsec]')\n                axes.set_ylabel('-Solar X [arcsec]')\n            return im\n\n    def contour(self, axes=None, rot=0, mapx=None, mapy=None, rangereverse=False, **kwargs):\n        sunpymap = self.sunmap\n        if axes is None:\n            axes = plt.subplot()\n        rot = rot % 360\n        if (mapx is None) or (mapy is None):\n            if rot == 0:\n                mapx, mapy = self.map2wcsgrids(cell=True)\n            elif rot == 90:\n                mapy, mapx = self.map2wcsgrids(cell=True)\n            elif rot == 180:\n                mapx, mapy = self.map2wcsgrids(cell=True)\n            elif rot == 270:\n                mapy, mapx = self.map2wcsgrids(cell=True)\n\n        if isinstance(axes, list):\n            ims = []\n            for ax in axes:\n                im = ax.contour(mapx, mapy, sunpymap.data, **kwargs)\n                ims.append(im)\n                extent = self.get_map_extent(rot=rot, rangereverse=rangereverse)\n                ax.set_xlim(extent[:2])\n                ax.set_ylim(extent[2:])\n            return ims\n        else:\n            im = axes.contour(mapx, mapy, sunpymap.data, **kwargs)\n            extent = self.get_map_extent(rot=rot, rangereverse=rangereverse)\n            axes.set_xlim(extent[:2])\n            axes.set_ylim(extent[2:])\n            return im\n\n    def contourf(self, axes=None, rot=0, mapx=None, mapy=None, rangereverse=False, **kwargs):\n        sunpymap = self.sunmap\n        if axes is None:\n            axes = plt.subplot()\n        rot = rot % 360\n        if (mapx is None) or (mapy is None):\n            if rot == 0:\n                mapx, mapy = self.map2wcsgrids(cell=True)\n            elif rot == 90:\n                mapy, mapx = self.map2wcsgrids(cell=True)\n            elif rot == 180:\n                mapx, mapy = self.map2wcsgrids(cell=True)\n            elif rot == 270:\n                mapy, mapx = self.map2wcsgrids(cell=True)\n\n        if isinstance(axes, list):\n            ims = []\n            for ax in axes:\n                im = ax.contourf(mapx, mapy, sunpymap.data, **kwargs)\n                ims.append(im)\n                extent = self.get_map_extent(rot=rot, rangereverse=rangereverse)\n                ax.set_xlim(extent[:2])\n                ax.set_ylim(extent[2:])\n            return ims\n        else:\n            im = axes.contourf(mapx, mapy, sunpymap.data, **kwargs)\n            extent = self.get_map_extent(rot=rot, rangereverse=rangereverse)\n            axes.set_xlim(extent[:2])\n            axes.set_ylim(extent[2:])\n            return im\n\n    def draw_limb(self, axes=None, rangereverse=False, **kwargs):\n        if 'c' not in kwargs and 'color' not in kwargs:\n            kwargs['c'] = 'w'\n        if 'ls' not in kwargs and 'linestyle' not in kwargs:\n            kwargs['ls'] = 'solid'\n        sunpymap = self.sunmap\n        if axes is None:\n            axes = plt.gca()\n\n        rsun = sunpymap.rsun_obs\n        phi = np.linspace(-180, 180, num=181) * u.deg\n        x = np.cos(phi) * rsun\n        y = np.sin(phi) * rsun\n        if isinstance(axes, list):\n            ims = []\n            for ax in axes:\n                ax.set_autoscale_on(False)\n                im = ax.plot(x, y, **kwargs)\n                ims.append(im)\n            return ims\n        else:\n            axes.set_autoscale_on(False)\n            im = axes.plot(x, y, **kwargs)\n            return im\n\n    def draw_grid(self, axes=None, rot=0, grid_spacing=None, **kwargs):\n        sunpymap = self.sunmap\n        if grid_spacing is None:\n            grid_spacing = 15 * u.deg\n\n        def hgs2hcc(rsun, lon, lat, B0, L0):\n            lon_L0 = lon - L0\n            x = rsun * np.cos(lat) * np.sin(lon)\n            y = rsun * (np.sin(lat) * np.cos(B0) - np.cos(lat) * np.cos(lon_L0) * np.sin(B0))\n            z = rsun * (np.sin(lat) * np.sin(B0) + np.cos(lat) * np.cos(lon_L0) * np.cos(B0))\n            return x, y, z\n\n        def hcc2hpc(x, y, z, dsun):\n            d = np.sqrt(x ** 2 + y ** 2 + (dsun - z) ** 2)\n            Tx = np.arctan2(x, dsun - z)\n            Ty = np.arcsin(y \/ d)\n            return Tx, Ty\n\n        if 'c' not in kwargs and 'color' not in kwargs:\n            kwargs['c'] = 'w'\n        if 'ls' not in kwargs and 'linestyle' not in kwargs:\n            kwargs['ls'] = 'dotted'\n        dsun = sunpymap.dsun\n        rsun = sunpymap.rsun_meters\n        if axes is None:\n            axes = plt.gca()\n        im = []\n        b0 = sunpymap.heliographic_latitude.to(u.deg)\n        l0 = sunpymap.heliographic_longitude.to(u.deg)\n        hg_longitude_deg = np.linspace(-90, 90, num=91) * u.deg\n        hg_latitude_deg = np.arange(0, 90, grid_spacing.to(u.deg).value)\n        hg_latitude_deg = np.hstack([-hg_latitude_deg[1:][::-1], hg_latitude_deg]) * u.deg\n        for lat in hg_latitude_deg:\n            c = hgs2hcc(rsun, hg_longitude_deg, lat * np.ones(91), b0, l0)\n            coords = hcc2hpc(c[0], c[1], c[2], dsun)\n            if rot in [90, 270]:\n                coords_ = [coords[1], coords[0]]\n            else:\n                coords_ = coords\n            if isinstance(axes, list):\n                for ax in axes:\n                    im += ax.plot(coords_[0].to(u.arcsec), coords_[1].to(u.arcsec), **kwargs)\n            else:\n                im += axes.plot(coords_[0].to(u.arcsec), coords_[1].to(u.arcsec), **kwargs)\n\n        hg_longitude_deg = np.arange(0, 90, grid_spacing.to(u.deg).value)\n        hg_longitude_deg = np.hstack([-hg_longitude_deg[1:][::-1], hg_longitude_deg]) * u.deg\n        hg_latitude_deg = np.linspace(-90, 90, num=91) * u.deg\n\n        for lon in hg_longitude_deg:\n            c = hgs2hcc(rsun, lon * np.ones(91), hg_latitude_deg, b0, l0)\n            coords = hcc2hpc(c[0], c[1], c[2], dsun)\n            if rot in [90, 270]:\n                coords_ = [coords[1], coords[0]]\n            else:\n                coords_ = coords\n            if isinstance(axes, list):\n                for ax in axes:\n                    im += ax.plot(coords_[0].to(u.arcsec), coords_[1].to(u.arcsec), **kwargs)\n            else:\n                im += axes.plot(coords_[0].to(u.arcsec), coords_[1].to(u.arcsec), **kwargs)\n        return im\n\n    def draw_rectangle(self, bottom_left, width, height, axes=None, **kwargs):\n        if 'ec' not in kwargs and 'edgecolor' not in kwargs:\n            kwargs['ec'] = 'w'\n        if 'ls' not in kwargs and 'linestyle' not in kwargs:\n            kwargs['ls'] = 'solid'\n        if 'fill' not in kwargs:\n            kwargs['fill'] = False\n        if axes is None:\n            axes = plt.gca()\n\n        if isinstance(axes, list):\n            ims = []\n            for ax in axes:\n                ax.set_autoscale_on(False)\n                im = ax.add_patch(patches.Rectangle(bottom_left, width, height, **kwargs))\n                ims.append(im)\n            return ims\n        else:\n            axes.set_autoscale_on(False)\n            im = axes.add_patch(patches.Rectangle(bottom_left, width, height, **kwargs))\n            return im\n\n    def imshow_RGB(self, maps, axes=None, returndataonly=False, rangereverse=False):\n        from scipy import ndimage\n        from astropy.coordinates import SkyCoord\n        mapR = maps[0]\n        znewR = mapR.data\n        aiamapx, aiamapy = self.map2wcsgrids(sunpymap=mapR, cell=False)\n        mapG = maps[1]\n        XX, YY = mapG.data_to_pixel(SkyCoord(aiamapx * u.arcsec, aiamapy * u.arcsec, frame=mapG.coordinate_frame))\n        znewG = ndimage.map_coordinates(mapG.data, [YY, XX], order=1)\n        mapB = maps[2]\n        XX, YY = mapB.data_to_pixel(SkyCoord(aiamapx * u.arcsec, aiamapy * u.arcsec, frame=mapB.coordinate_frame))\n        znewB = ndimage.map_coordinates(mapB.data, [YY, XX], order=1)\n\n        znewR = np.sqrt(znewR)\n        znewG = np.sqrt(znewG)\n        znewB = np.sqrt(znewB)\n\n        vmax, vmin = np.sqrt(5000), np.sqrt(10)\n        # clrange=DButil.sdo_aia_scale_dict(304)\n        znewR[znewR > vmax] = vmax\n        znewR[znewR < vmin] = vmin\n        # clrange=DButil.sdo_aia_scale_dict(94)\n        vmax, vmin = np.sqrt(20000), np.sqrt(200)\n        znewG[znewG > vmax] = vmax\n        znewG[znewG < vmin] = vmin\n        # clrange=DButil.sdo_aia_scale_dict(211)\n        vmax, vmin = np.sqrt(5000), np.sqrt(100)\n        znewB[znewB > vmax] = vmax\n        znewB[znewB < vmin] = vmin\n        znewR = (znewR - np.nanmin(znewR)) \/ (np.nanmax(znewR) - np.nanmin(znewR))\n        znewG = (znewG - np.nanmin(znewG)) \/ (np.nanmax(znewG) - np.nanmin(znewG))\n        znewB = (znewB - np.nanmin(znewB)) \/ (np.nanmax(znewB) - np.nanmin(znewB))\n        # znew1 = np.sqrt(znew1)\n        # znew2 = np.sqrt(znew2)\n        # imshow(np.sqrt(np.stack([znew0, znew1, znew2], axis=-1)), extent=list(aiamap.xrange.value) + list(aiamap.yrange.value),origin='lower')\n        if returndataonly:\n            return np.stack([znewR, znewG, znewB], axis=-1)\n        else:\n            if axes:\n                pass\n            else:\n                axes = plt.subplot()\n            extent = self.get_map_extent(sunpymap=mapR, rangereverse=rangereverse)\n            if isinstance(axes, list):\n                ims = []\n                for ax in axes:\n                    im = ax.imshow(np.stack([znewR, znewG, znewB], axis=-1),\n                                   extent=extent, origin='lower')\n                    ims.append(im)\n                return ims\n            else:\n                return axes.imshow(np.stack([znewR, znewG, znewB], axis=-1),\n                                   extent=extent, origin='lower')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_384","text":"<filename>tests.py\nfrom scipy.io import wavfile\n\nfps, bowl_sound = wavfile.read('voices\/enathu_peyar.wav')\ntones = range(-25,25)\ntransposed = [picthshift(bowl_sound,n) for n in tones]"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_385","text":"<reponame>Comp-Sound-Music\/interactive_piano\nimport unittest\nimport numpy as np\nfrom scipy import fftpack\nfrom piano import create_harmonies\nfrom conversion_table import name_to_key as table\n\nclass CreateHarmonies(unittest.TestCase):\n    def test_create_harmonies(self):\n        # reference (with permission): https:\/\/cs510sound-spring2021.zulip.cs.pdx.edu\/#narrow\/stream\/7-general\/topic\/HW.203.3A.20Chord.3F\/near\/2239\n        samp_rt = 48000\n        eps = 2.\n        act_freqs = [ \n            523.25,\n            554.37,\n            587.33,\n            622.25,\n            659.26,\n            698.46,\n            739.99,\n            783.99,\n            830.61,\n            880.0,\n            932.33,\n            987.77,\n            1046.5\n        ]\n        for i,k in enumerate(table.keys()):\n            v = table[k]\n            ret = create_harmonies([k])\n            x = fftpack.fft(ret)\n            freqs = fftpack.fftfreq(len(x)) * samp_rt\n            peaks = np.argsort(np.abs(x))[-6:]\n            peak = round(np.sort(freqs[peaks])[-1],2)\n            diff = round(np.abs(peak-act_freqs[i]),2)\n            print(f\"Test {k}  -- |{peak} - {act_freqs[i]}| = {diff}\")\n            self.assertTrue(diff <= eps)\n        return\n\nif __name__==\"__main__\":\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_386","text":"<reponame>yosagaf\/medical-biometrics<filename>assignement2\/viewing3DBrainMRI.py\n# import necessary packages\n\nimport imageio\nimport scipy.ndimage as ndi\nimport numpy as np\nimport SimpleITK as sitk\nimport matplotlib.pyplot as plt\n\n# the path of a T1-weighted brain .nii image\npath = \"data\/BRAIN.nii\"\n\n\n# read the .nii image containing the volume with the SimpleITK \nsitk_f = sitk.ReadImage(path)\n\n# access to the numpy array\nslices = sitk.GetArrayFromImage(sitk_f)\nprint(\"[INFOS] 2D Array slice data type :\", type(slices)) #-> numpy array\nprint(\"[INFOS] 3D sitk object type      :\", type(sitk_f)) #-> numpy array\nprint(\"[INFOS] Shape of 3D image array  :\", slices.shape)\nprint(\"[INFOS] Shape of 2D slice array  :\", slices[0].shape)\nprint(\"[INFOS] Number of slices         :\", slices.shape[0])\n\ndef removeKeymapConflicts(new_keys_set):\n    for prop in plt.rcParams:\n        if prop.startswith('keymap.'):\n            keys = plt.rcParams[prop]\n            remove_list = set(keys) & new_keys_set\n            for key in remove_list: \n                keys.remove(key)\n\ndef viewer3D(volume):\n    removeKeymapConflicts({'n', 'l'})\n    fig, ax = plt.subplots()\n    ax.volume = volume\n    ax.index = volume.shape[0] \/\/ 2\n    ax.imshow(volume[ax.index], cmap='gray')\n    fig.canvas.mpl_connect('key_press_event', processKey)\n\ndef processKey(event):\n    fig = event.canvas.figure\n    ax = fig.axes[0]\n    if event.key == 'n':\n        lSlice(ax)\n    elif event.key == 'l':\n        nSlice(ax)\n    fig.canvas.draw()\n\ndef lSlice(ax):\n    volume = ax.volume\n    ax.index = (ax.index - 1) % volume.shape[0]  # wrap around using %\n    ax.images[0].set_array(volume[ax.index])\n\ndef nSlice(ax):\n    volume = ax.volume\n    ax.index = (ax.index + 1) % volume.shape[0]\n    ax.images[0].set_array(volume[ax.index])\n\n\nmask3d_array = slices > 900\nmask3d_array = ndi.binary_dilation(mask3d_array, iterations=8)\nmask3d_array = ndi.binary_closing(mask3d_array, iterations=8)\n\nweights_edge = [[[1, 1, 1],\n                 [0, 0, 0], \n                 [1, -1, -1]],\n           \n                [[1, 1, 1],\n                 [0, 0, 0], \n                 [-1, -1, -1]],\n           \n                [[1, 1, 1],\n                 [0, 0, 0], \n                 [-1, -1, -1]]]\n\nim3d_edge = ndi.convolve(slices, weights_edge)\n\n#viewer3D(mask_array)\n#viewer3D(slices)\nviewer3D(im3d_edge)\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_387","text":"\"\"\"\nFunctions for testing brainlocate.\n\"\"\"\n\nimport pytest\nimport numpy as np\nimport os\nfrom numpy.testing import assert_array_equal, assert_allclose\nimport brainload as bl\nimport brainload.brainlocate as loc\n\n\nTHIS_DIR = os.path.dirname(os.path.abspath(__file__))\nTEST_DATA_DIR = os.path.join(THIS_DIR, os.pardir, 'test_data')\n\n# Respect the environment variable BRAINLOAD_TEST_DATA_DIR if it is set. If not, fall back to default.\nTEST_DATA_DIR = os.getenv('BRAINLOAD_TEST_DATA_DIR', TEST_DATA_DIR)\n\n\ndef test_closest_vertex_to_very_close_point_known_dist():\n    try:\n        from scipy.spatial.distance import cdist\n    except ImportError:\n        pytest.skip(\"Optional dependency scipy not installed, skipping tests which require scipy.\")\n    vert_coords = np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0]])\n    faces = np.array([0, 1, 2])\n    locator = loc.BrainLocate(vert_coords, faces)\n    query_coords = np.array([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [1.0, 1.1, 0.0], [0.1, 0.1, 0.1]])\n    res = locator.get_closest_vertex(query_coords)\n    assert res.shape == (4, )\n    assert res[0] == 1     # the closest vertex index in the mesh for query coordinate at index 0\n    assert res[1] == 2     # the closest vertex index in the mesh for query coordinate at index 1\n    assert res[2] == 2     # the closest vertex index in the mesh for query coordinate at index 2\n    assert res[3] == 0     # the closest vertex index in the mesh for query coordinate at index 3\n    dist_matrix = cdist(vert_coords, query_coords)\n    assert dist_matrix.shape == (3, 4)\n    assert dist_matrix[0][0] == pytest.approx(1.0, 0.00001)\n    assert dist_matrix[0][1] == pytest.approx(1.4142135623730951, 0.00001)   # This is sqrt(2)\n    assert dist_matrix[1][0] == pytest.approx(0.0, 0.00001)\n    min_index = np.argmin(dist_matrix, axis=0)\n    assert min_index.shape == (4, )    # we queried for 4 coordinates.\n    assert min_index[0] == res[0]\n    assert min_index[1] == res[1]\n    assert min_index[2] == res[2]\n    assert min_index[3] == res[3]\n\n\ndef test_closest_vertex_to_very_close_point():\n    try:\n        from scipy.spatial.distance import cdist\n    except ImportError:\n        pytest.skip(\"Optional dependency scipy not installed, skipping tests which require scipy.\")\n    vert_coords, faces, _ = bl.subject_mesh('subject1', TEST_DATA_DIR, surf='white', hemi='both')\n    locator = loc.BrainLocate(vert_coords, faces)\n    query_coords = np.array([[58.0 , -45.0, 75.0]])\n    res = locator.get_closest_vertex(query_coords)\n    assert res.shape == (1, )\n    assert res[0] == 210683     # the vertex index in the mesh\n    expected_vert_210683_coords = (58.005173, -44.736935,  74.418076)\n    assert_allclose(vert_coords[210683], np.array(expected_vert_210683_coords))\n    dist = cdist(np.array([expected_vert_210683_coords]), query_coords)\n    assert dist[0][0] == pytest.approx(0.6386434810831467, 0.001)\n\n\ndef test_closest_vertex_to_far_away_point():\n    try:\n        from scipy.spatial.distance import cdist\n    except ImportError:\n        pytest.skip(\"Optional dependency scipy not installed, skipping tests which require scipy.\")\n    vert_coords, faces, _ = bl.subject_mesh('subject1', TEST_DATA_DIR, surf='white', hemi='both')\n    locator = loc.BrainLocate(vert_coords, faces)\n    query_coords = np.array([[134.37332 , -57.259495, 149.267631], [134.37332 , -57.259495, 149.267631], [58.0 , -45.0, 75.0]])\n    res = locator.get_closest_vertex(query_coords)\n    assert res.shape == (3, )\n    assert res[0] == 209519     # the vertex index in the mesh\n    assert res[1] == 209519\n    assert res[2] == 210683\n    assert_allclose(vert_coords[209519], np.array((58.258751, -45.213722,  74.348068)))\n    dist = cdist(np.array([[58.258751, -45.213722,  74.348068]]), np.array([[134.37332 , -57.259495, 149.267631]]))\n    assert dist[0][0] == pytest.approx(107.47776133, 0.001)\n\n\ndef test_get_closest_vertex_and_distance_to_far_away_point():\n    try:\n        from scipy.spatial.distance import cdist\n    except ImportError:\n        pytest.skip(\"Optional dependency scipy not installed, skipping tests which require scipy.\")\n    vert_coords, faces, _ = bl.subject_mesh('subject1', TEST_DATA_DIR, surf='white', hemi='both')\n    locator = loc.BrainLocate(vert_coords, faces)\n    query_coords = np.array([[134.37332 , -57.259495, 149.267631], [134.37332 , -57.259495, 149.267631], [134.37332 , -57.259495, 149.267631]])  # just query 3 times for the same coord to see whether results and consistent\n    res = locator.get_closest_vertex_and_distance(query_coords)\n    assert res.shape == (3, 2)\n    assert res[0,0] == 209519              # the vertex index in the mesh\n    assert res[1,0] == 209519\n    assert res[2,0] == 209519\n    assert res[0,1] == 107.47776120258028  # the distance\n    assert res[1,1] == 107.47776120258028\n    assert res[2,1] == 107.47776120258028\n\n\ndef test_get_closest_vertex_to_vertex_0_coordinate():\n    try:\n        from scipy.spatial.distance import cdist\n    except ImportError:\n        pytest.skip(\"Optional dependency scipy not installed, skipping tests which require scipy.\")\n    vert_coords, faces, _ = bl.subject_mesh('subject1', TEST_DATA_DIR, surf='white', hemi='both')\n    locator = loc.BrainLocate(vert_coords, faces)\n    known_vertex_0_coord = (-1.85223234, -107.98274994, 22.76972961)    # coordinate for vertex 0 in the test data.\n    assert_allclose(vert_coords[0], np.array(known_vertex_0_coord))\n    query_coords = np.array([known_vertex_0_coord])\n    res = locator.get_closest_vertex_and_distance(query_coords)\n    assert res.shape == (1, 2)\n    assert res[0, 0] == 0    # vertex index of closest vertex. The query coordinate is the known coordinate of vertex 0, so this must be 0.\n    assert abs(res[0, 1]) <= 0.001   # distance to closest vertex. The query coordinate is the known coordinate of vertex 0, so this must be very close to 0.0\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_388","text":"import tensorflow as tf\nimport argparse\nimport os\nimport statistics as stat\n\n\n\nfrom models.utils import plot_test_images, plot_images, print_metrics\n\nfrom models.espcn.model_espcn import ESPCN as espcn\n\nfrom models.evsrnet.model_evsrnet import EVSRNet\n\nfrom models.rtsrgan.model_generator import G_RTSRGAN as g_rtsrgan\nfrom models.rtsrgan.model_discriminator import d_rtsrgan\nfrom models.rtsrgan.model_gan import GAN\n\nfrom models.rtvsrgan.model_generator import G_RTVSRGAN as g_rtvsrgan \nfrom models.rtvsrgan.KnowledgeDistillation import Distiller\n\nfrom models.rtvsrgan.model_discriminator import d_rtvsrgan, rad_rtvsrgan\nfrom models.rtvsrgan.model_ragan import RaGAN\n\nfrom models.percsr.model_discriminator import d_percsr, rad_percsr\nfrom models.percsr.model_percsr import PercSR\nfrom models.percsr.model_teacher import Teacher\n\n\nfrom models.imdn.model_imdn import IMDN\n\nfrom models.dataset import Dataset\nfrom models.metrics import psnr, ssim, rmse, lpips\nfrom models.losses import VGGLossNoActivation as VGGLoss, GANLoss\n\nfrom models.save_img_callback import SaveImageCallback\nfrom models.utils import scale_1 as scale\n\n\nhot_test= {'hot_test_generic': {\n  'lr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/generic\/lr\/270p_qp17\/\",\n  'hr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/generic\/hr\/1080p\/\"\n},\n'hot_test_game': {\n  'lr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/game\/lr\/270p_qp17\/\",\n  'hr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/game\/hr\/1080p\/\"\n},\n'hot_test_sport': {\n  'lr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/sport\/lr\/270p_qp17\/\",\n  'hr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/sport\/hr\/1080p\/\"\n},\n'hot_test_podcast': {\n  'lr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/podcast\/lr\/270p_qp17\/\",\n  'hr_hot_test_path': \"datasets\/loaded_harmonic\/img_hot_test\/podcast\/hr\/1080p\/\"\n}}\n\n\ntest= {\n'test_generic': {\n  'lr_test_path': \"\/home\/joao\/Documentos\/projetos\/sr-tf2\/datasets\/loaded_harmonic\/img_test\/lr\/270p_qp17\/\",\n  'hr_test_path': \"\/home\/joao\/Documentos\/projetos\/sr-tf2\/datasets\/loaded_harmonic\/img_test\/hr\/1080p\/\",\n  'logdir': \"test_logdir\/test\/generic\/\"\n},\n'test_game': {\n  'lr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/game\/img_test\/lr\/270p_qp17\/\",\n  'hr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/game\/img_test\/hr\/1080p\/\",\n  'logdir': \"test_logdir\/test\/game\/\"\n},\n'test_sport': {\n  'lr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/sport\/img_test\/lr\/270p_qp17\/\",\n  'hr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/sport\/img_test\/hr\/1080p\/\",\n  'logdir': \"test_logdir\/test\/sport\/\"\n},\n'test_podcast': {\n  'lr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/podcast\/img_test\/lr\/270p_qp17\/\",\n  'hr_test_path': \"\/media\/joao\/SAMSUNG\/Youtube\/podcast\/img_test\/hr\/1080p\/\",\n  'logdir': \"test_logdir\/test\/podcast\/\"\n}}\n\n\ntest_datasets = {\n'test_generic': {\n  'test_dataset_path': \"datasets\/loaded_harmonic\/output\/generic\/test\/4X\/270p_qp17\/dataset.tfrecords\",\n  'test_dataset_info_path': \"datasets\/loaded_harmonic\/output\/generic\/test\/4X\/270p_qp17\/dataset_info.txt\"\n},\n'test_game': {\n  'test_dataset_path': \"datasets\/loaded_harmonic\/output\/game\/test\/4X\/270p_qp17\/dataset.tfrecords\",\n  'test_dataset_info_path': \"datasets\/loaded_harmonic\/output\/game\/test\/4X\/270p_qp17\/dataset_info.txt\"\n},\n'test_sport': {\n  'test_dataset_path': \"datasets\/loaded_harmonic\/output\/sport\/test\/4X\/270p_qp17\/dataset.tfrecords\",\n  'test_dataset_info_path': \"datasets\/loaded_harmonic\/output\/sport\/test\/4X\/270p_qp17\/dataset_info.txt\"\n},\n'test_podcast': {\n  'test_dataset_path': \"datasets\/loaded_harmonic\/output\/podcast\/test\/4X\/270p_qp17\/dataset.tfrecords\",\n  'test_dataset_info_path': \"datasets\/loaded_harmonic\/output\/podcast\/test\/4X\/270p_qp17\/dataset_info.txt\"\n}}\n\n\n\nLIST_MODEL=['espcn','g_rtsrgan','rtsrgan','g_rtvsrgan','teacher','rtvsrgan','imdn','k_dist','percsr','evsrnet']\nMODEL='rtvsrgan'\nLIST_GENERATOR=[None,'espcn','g_rtsrgan','imdn','evsrnet','g_rtvsrgan']\nGENERATOR=None\nBATCH_SIZE = 32\nVAL_BATCH_SIZE = 16\nTEST_BATCH_SIZE = 4\nSHUFFLE_BUFFER_SIZE = 64\n\nLIST_TEST_CLUSTER = ['generic','game','sport','podcast']\nTEST_CLUSTER = ['sport']\n\nSCHEDULE_VALUES=[100]\n\n# Knowledge distillation model\nLOSS_FN='mae'\nDISTILLATION_RATE=0.8\nALPHA=0.3\nBETA=0.65\nLIST_WEIGHTS=[1e-5,1e-2,1e-2]\n\nTYPE_REDUCE_LR='schedules'\nLEARNING_RATE = 1e-4\nLEARNING_DECAY_RATE = 1e-1\nLEARNING_DECAY_EPOCHS = 20\nNUM_EPOCHS = 100\nSTEPS_PER_EPOCH = 100\nVAL_STEPS = 1\nTEST_STEPS = 0\nEPOCHS_PER_SAVE = 5\nLOGDIR = 'logdir'\nCHECKPOINT = 'checkpoint\/'\nTRAINNABLE_LAYER = 'final'\nPATH_TO_EVAL = 'test_logdir\/stats.txt'\nTEST_LOGDIR='test_logdir\/'\n\nHOT_TEST_SIZE=5\nLR_HOT_TEST_PATH=\"datasets\/loaded_harmonic\/img_test\/lr\/270p_qp28\/\"\nHR_HOT_TEST_PATH=\"datasets\/loaded_harmonic\/img_test\/hr\/1080p\/\"\n\nTRAIN_DATASET_PATH='datasets\/loaded_harmonic\/output\/train\/2X\/270p_qp17\/dataset.tfrecords'\nTRAIN_DATASET_INFO_PATH='datasets\/loaded_harmonic\/output\/train\/2X\/270p_qp17\/dataset_info.txt'\n\nVAL_DATASET_PATH='datasets\/loaded_harmonic\/output\/val\/2X\/270p_qp17\/dataset.tfrecords'\nVAL_DATASET_INFO_PATH='datasets\/loaded_harmonic\/output\/val\/2X\/270p_qp17\/dataset_info.txt'\n\nTEST_DATASET_PATH='datasets\/loaded_harmonic\/output\/test\/2X\/270p_qp17\/dataset.tfrecords'\nTEST_DATASET_INFO_PATH='datasets\/loaded_harmonic\/output\/test\/2X\/270p_qp17\/dataset_info.txt'\n\n\ndef get_arguments():\n    parser = argparse.ArgumentParser(description='train one of the models for image and video super-resolution')\n    parser.add_argument('--model', type=str, default=MODEL, choices=LIST_MODEL,\n                        help='What model to train', required=True)\n    parser.add_argument('--generator', type=str, default=GENERATOR, choices=LIST_GENERATOR,\n                        help='What model to train', required=False)\n    parser.add_argument('--batch_size', type=int, default=BATCH_SIZE,\n                        help='Number of images in batch', required=True)\n    parser.add_argument('--train_dataset_path', type=str, default=TRAIN_DATASET_PATH,\n                        help='Path to the train dataset', required=True)\n    parser.add_argument('--train_dataset_info_path', type=str, default=TRAIN_DATASET_INFO_PATH,\n                        help='Path to the train dataset info', required=True)\n    parser.add_argument('--num_epochs', type=int, default=NUM_EPOCHS,\n                        help='Number of training epochs', required=True)\n    parser.add_argument('--steps_per_epoch', type=int, default=STEPS_PER_EPOCH, \n                        help='Total number of steps (batches of samples) before declaring one epoch finished and starting the next epoch.')\n\n    parser.add_argument('--val_batch_size', type=int, default=VAL_BATCH_SIZE,\n                        help='Number of images in val batch')\n    parser.add_argument('--val_dataset_path', type=str, default=VAL_DATASET_PATH,\n                        help='Path to the val dataset')\n    parser.add_argument('--val_dataset_info_path', type=str, default=VAL_DATASET_INFO_PATH,\n                        help='Path to the val dataset info')\n    parser.add_argument('--validation_steps', type=int, default=VAL_STEPS, \n                        help='Total number of steps (batches of samples) to draw before stopping when performing validation at the end of every epoch.')\n    \n    parser.add_argument('--test_batch_size', type=int, default=TEST_BATCH_SIZE,\n                        help='Number of images in test batch')\n    parser.add_argument('--test_dataset_path', type=str, default=TEST_DATASET_PATH,\n                        help='Path to the test dataset')\n    parser.add_argument('--test_dataset_info_path', type=str, default=TEST_DATASET_INFO_PATH,\n                        help='Path to the test dataset info')\n    parser.add_argument('--test_steps', type=int, default=TEST_STEPS, \n                        help='Total number of steps (batches of samples) to draw before stopping when performing evaluate at the end of every epoch.')\n    parser.add_argument('--test_cluster', nargs='*', type=str, default=TEST_CLUSTER, choices=LIST_TEST_CLUSTER,\n                        help='What cluster dataset to eval', required=False)\n         \n\n    parser.add_argument('--hot_test_size', type=int, default=HOT_TEST_SIZE,\n                        help='Number of images in hot test')\n    parser.add_argument('--lr_hot_test_path', type=str, default=LR_HOT_TEST_PATH,\n                        help='Path to the hot test dataset')\n    parser.add_argument('--hr_hot_test_path', type=str, default=HR_HOT_TEST_PATH,\n                        help='Path to the hr hot test path')\n\n    parser.add_argument('--ckpt_path', default=CHECKPOINT,\n                        help='Path to the model checkpoint to evaluate')\n    parser.add_argument('--load_weights', action='store_true',\n                        help='Load weights')\n    parser.add_argument('--load_weights_perc', action='store_true',\n                        help='Load weights perceptual')\n    parser.add_argument('--eval', action='store_true',\n                        help='Avaluete model')\n    parser.add_argument('--range_to_save', type=int, default=10,\n                        help='Range of image to save for teste.' )                    \n    parser.add_argument('--transfer_learning', action='store_true',\n                        help='Transfer learning from lower-upscale model')\n    parser.add_argument('--trainable_layer', type=str, default=TRAINNABLE_LAYER,\n                        help='Transfer learning from lower-upscale model')\n    parser.add_argument('--scaleFrom', type=int, default=2,\n                        help='Perform transfer learning from lower-upscale model' )\n    parser.add_argument('--shuffle_buffer_size', type=int, default=SHUFFLE_BUFFER_SIZE,\n                        help='Buffer size used for shuffling examples in dataset')\n    parser.add_argument('--learning_rate', type=float, default=LEARNING_RATE,\n                        help='Learning rate used for training')\n    parser.add_argument('--lr_decay_rate', type=float, default=LEARNING_DECAY_RATE,\n                        help='Learning rate decay rate used in exponential decay')\n    parser.add_argument('--lr_decay_epochs', type=int, default=LEARNING_DECAY_EPOCHS,\n                        help='Number of epochs before full decay rate tick used in exponential decay')\n    parser.add_argument('--type_reduce_lr', type=str, default=TYPE_REDUCE_LR, choices=['plateau','schedules'],\n                        help='Type of reduce learning rate')\n    parser.add_argument('--schedule_values',nargs='*', type=int, default=SCHEDULE_VALUES,\n                        help='list of epochs values to reduce lr')\n\n    parser.add_argument('--loss_fn', type=str, default=LOSS_FN, choices=['mse','mae','huber', 'fea'],\n                        help='Set the loss function to knowledge distillation model')\n    parser.add_argument('--distillation_rate', type=float, default=DISTILLATION_RATE,\n                        help='Distillation rate in knowledge distillation model')\n    parser.add_argument('--alpha', type=float, default=ALPHA,\n                        help='Weight for distillation loss function in knowledge distillation model')\n    parser.add_argument('--beta', type=float, default=BETA,\n                        help='Weight for perceptual loss function in knowledge distillation model')\n    parser.add_argument('--list_weights', nargs='*', type=float, default=LIST_WEIGHTS,\n                        help='Auxiliary list to weight values')\n    parser.add_argument('--inter_method', type=str, default=None, choices=['bilinear','lanczos3','lanczos5','bicubic','nearest','mitchellcubic'],\n                        help='Type of interpolation resize used of same models')\n\n    parser.add_argument('--epochs_per_save', type=int, default=EPOCHS_PER_SAVE,\n                        help='How often to save checkpoints')\n    parser.add_argument('--logdir', type=str, default=LOGDIR,\n                        help='Where to save checkpoints and summaries')\n    parser.add_argument('--test_logdir', type=str, default=TEST_LOGDIR,\n                        help='Where to save tests images')\n    \n    parser.add_argument('--path_to_eval', type=str, default=PATH_TO_EVAL,\n                        help='Path to save evals')\n    \n\n    return parser.parse_args()\n\n\ndef main():\n    \n    args = get_arguments()\n    # train dataset\n    train_dataset = Dataset(args.batch_size,\n        args.train_dataset_path,\n        args.train_dataset_info_path,\n        args.shuffle_buffer_size)\n    \n    scale_factor = train_dataset.scale_factor\n\n    if args.steps_per_epoch == 0:\n        steps_per_epoch = train_dataset.examples_num \/\/ args.batch_size \\\n            if train_dataset.examples_num % args.batch_size != 0 else 0\n    else:\n        steps_per_epoch = args.steps_per_epoch\n    \n\n    train_dataset = train_dataset.get_data(args.num_epochs)\n    train_batch = train_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n    \n    # val dataset\n    val_dataset = Dataset(args.val_batch_size,\n        args.val_dataset_path,\n        args.val_dataset_info_path,\n        args.shuffle_buffer_size)\n\n    if args.validation_steps == 0:\n        validation_steps = val_dataset.examples_num \/\/ args.val_batch_size \\\n            if val_dataset.examples_num % args.val_batch_size != 0 else 0\n    else:\n        validation_steps = args.validation_steps\n    \n    val_dataset = val_dataset.get_data()\n    val_batch = val_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n    \n    # test dataset\n    test_dataset = Dataset(args.test_batch_size,\n        args.test_dataset_path,\n        args.test_dataset_info_path,\n        args.shuffle_buffer_size)\n\n    if args.test_steps == 0:\n        test_steps = test_dataset.examples_num \/\/ args.test_batch_size \\\n            if test_dataset.examples_num % args.test_batch_size != 0 else 0\n    else:\n        test_steps = args.test_steps\n    \n    test_dataset = test_dataset.get_data()\n    test_batch = test_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n\n\n    # hot test\n    lr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(args.lr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n    hr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(args.hr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n    test_print = [lr_img_paths,hr_img_paths]\n    \n    checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n    checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n        filepath=checkpoint_paph,\n        save_weights_only=True,\n        monitor='val_loss',\n        save_freq= 'epoch', \n        mode='min',\n        save_best_only=True)\n\n    tensorboard_callback = tf.keras.callbacks.TensorBoard(\n        log_dir=args.logdir+\"\/\"+args.model,\n        histogram_freq=1, \n        write_graph=True,\n        write_images=True, \n        write_steps_per_second=True,\n        update_freq='batch') \n    file_writer_cm = tf.summary.create_file_writer(args.logdir+\"\/\"+args.model + '\/validation')\n    \n    earlystopping = tf.keras.callbacks.EarlyStopping(\n            monitor='val_loss', \n            min_delta=1e-5,\n            patience=100, verbose=1,\n            mode='min', \n            restore_best_weights=True)\n    \n    if args.type_reduce_lr == 'plateau':\n        reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_rmse', factor=args.lr_decay_rate,\n                                        patience=args.lr_decay_epochs, mode='min', min_lr=1e-6,verbose=1)\n    elif args.type_reduce_lr == 'schedules':\n        def scheduler(epoch, lr):\n            if epoch in args.schedule_values:\n                return lr * tf.math.exp(-0.1)\n            else:\n                return lr\n        reduce_lr=tf.keras.callbacks.LearningRateScheduler(scheduler)\n    else: \n        print(\"--type_reduce_lr not valid!\")\n        exit(1)\n    \n    if args.model == 'espcn':    \n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr] \n        eval,run_time=train_espcn(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n        \n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    elif args.model == 'imdn':    \n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr] \n        eval,run_time=train_imdn(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n        \n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    \n    elif args.model == 'g_rtsrgan':\n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr] \n        eval, run_time=train_g_rtsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n\n    elif args.model == 'rtsrgan':\n        callbacks=[tensorboard_callback]\n        eval,run_time=train_rtsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n\n    elif args.model == 'evsrnet':\n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr]\n        eval,run_time=train_evsrnet(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n\n\n    # Ours models\n    elif args.model == 'g_rtvsrgan':\n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr] \n        eval,run_time=train_g_rtvsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    \n    elif args.model == 'teacher':\n        callbacks=[checkpoint_callback,tensorboard_callback,earlystopping,reduce_lr] \n        eval,run_time=train_teacher(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n\n    elif args.model == 'rtvsrgan':\n        callbacks=[tensorboard_callback,reduce_lr]\n        eval,run_time=train_rtvsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n\n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    \n    elif args.model == 'k_dist':    \n        callbacks=[tensorboard_callback, reduce_lr] \n        eval,run_time=train_k_distillation(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n        \n        print_eval(args.path_to_eval,eval,args.model+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    \n    elif args.model == 'percsr':\n        callbacks=[tensorboard_callback, reduce_lr] \n        print(\"CALLING MODEL {}\".format(args.model))\n        eval,run_time=train_percsr(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer=args.trainable_layer)\n        \n        print_eval(args.path_to_eval,eval,args.model+'_'+args.generator+\"_{}X_q{}\".format(str(scale_factor),str(args.train_dataset_path).split('_q')[-1]),run_time)\n    else:\n        exit(1)\n\n\ndef trainable_weights(model):\n    print(\"Weights:\", len(model.weights))\n    print(\"Trainable_weights:\", len(model.trainable_weights))\n    print(\"Non_trainable_weights:\", len(model.non_trainable_weights))\n\ndef trainable_layers(model, trainable_layer):\n    for i in range(len(model.layers)):\n        if(i+1 == trainable_layer):\n            break\n        else:\n            model.layers[i].trainable=False\n\n\ndef print_eval(file_stats,eval,model_name,run_time):\n    statsFile=open(file_stats,\"a\")\n    print(model_name, file = statsFile)\n    print(eval, file = statsFile)\n    print(run_time, file = statsFile)\n    statsFile.close()\n\ndef saved_model(model, filepath):\n    tf.keras.models.save_model(model, filepath, save_traces=True)\n\ndef train_espcn(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,\n                file_writer_cm,trainable_layer):\n    model = espcn(scale_factor=scale_factor)\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = espcn(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(model.layers[i].name))\n                model.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                model.layers[i].trainable=False\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n\n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval,model.get_run_time()\n\ndef train_imdn(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,\n                file_writer_cm,trainable_layer):\n    model = IMDN(scale_factor=scale_factor)\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = IMDN(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(model.layers[i].name))\n                model.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                model.layers[i].trainable=False\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n\n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval, model.get_run_time()\n\ndef train_g_rtsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,\n                file_writer_cm,trainable_layer):\n    model = g_rtsrgan(scale_factor=scale_factor)\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = g_rtsrgan(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(model.layers[i].name))\n                model.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                model.layers[i].trainable=False\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n\n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval,model.get_run_time()\n\ndef train_rtsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n    g=g_rtsrgan(scale_factor=scale_factor)\n    g.compile(metrics=[psnr,ssim,rmse,lpips])\n    \n    d=d_rtsrgan(input_shape=(36*scale_factor,36*scale_factor,1))\n    gan = GAN(discriminator = d, generator = g)\n\n    if args.loss_fn == \"mse\":\n        cont_loss = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        cont_loss = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        cont_loss = tf.keras.losses.MeanAbsoluteError()\n\n    shape_hr = (36*scale_factor,36*scale_factor,3)    \n    vgg_loss = VGGLoss(shape_hr,cont_loss)\n    perc_loss = vgg_loss.custom_perceptual_loss\n    adv_loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n    lbd = 1 * 1e-5\n    eta = 1 * 1e-2\n    mu = 1 * 1e-2\n    gan_loss=GANLoss(perc_loss, cont_loss, adv_loss,lbd,eta,mu)\n        \n    if (args.load_weights):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}g_rtsrgan_{}x\/model.ckpt\".format(args.ckpt_path,scale_factor) \n        gan.load_weights_gen(checkpoint_paph)\n        for i in range(len(g.layers)):\n            if(g.layers[i].name == trainable_layer):\n                break\n            else:\n                g.layers[i].trainable=False\n    \n    gan.compile(d_optimizer = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                g_optimizer = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                d_loss = gan_loss.discriminator_loss,\n                g_loss = gan_loss.generator_loss,\n                metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(gan)\n\n    save_img_callback = SaveImageCallback(\n        model=g,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor)\n    checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n        filepath=checkpoint_paph,\n        save_weights_only=True,\n        monitor='val_lpips',\n        save_freq= 'epoch', \n        mode='min',\n        save_best_only=True)\n    callbacks.append(checkpoint_callback)\n\n    gan.fit(train_batch, epochs=args.num_epochs,callbacks=callbacks,verbose=1,steps_per_epoch=steps_per_epoch)\n    checkpoint_paph=\"{}{}_{}x\/g_rtsrgan\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n    gan.save_weights_gen(checkpoint_paph)\n\n    print(\"Evaluate model\")\n    eval = g.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(g, 'saved_model\/{}\/'.format(args.model))\n    return eval, g.get_run_time()\n\n\ndef train_evsrnet(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,\n                file_writer_cm,trainable_layer):\n    model = EVSRNet(scale_factor=scale_factor,method=args.inter_method)\n    model.build((None, None, None,1))\n    #print(model.summary())\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\": # default\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n\n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval,model.get_run_time()\n\ndef train_teacher(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n    model = Teacher(channels=1,scale_factor=scale_factor,distillation_rate=args.distillation_rate)\n    model.build((None, None, None,1))\n    print(model.summary())\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        model.compile(metrics=[psnr,ssim,rmse,lpips])\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n\n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = g_rtvsrgan(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(model.layers[i].name))\n                model.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                model.layers[i].trainable=False\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n    if args.loss_fn == \"fea\":    \n        loss_aux = tf.keras.losses.MeanAbsoluteError()\n        shape_hr = (36*scale_factor,36*scale_factor,3)    \n        vgg_loss = VGGLoss(shape_hr,loss_aux)\n        loss_fn = vgg_loss.custom_perceptual_loss\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n   \n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    if args.loss_fn == \"fea\": \n        eval = []\n    else:\n        eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval, model.get_run_time()\n\n\ndef train_g_rtvsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n    model = g_rtvsrgan(scale_factor=scale_factor,method=args.inter_method)\n    if args.load_weights:\n        print(\"Loading weights...\")\n        model.load_weights(checkpoint_paph)\n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = g_rtvsrgan(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(model.layers[i].name))\n                model.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                model.layers[i].trainable=False\n    \n    opt = tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n\n    if args.loss_fn == \"mse\":\n        loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        loss_fn = tf.keras.losses.MeanAbsoluteError()\n\n    model.compile(optimizer=opt, loss=loss_fn, metrics=[psnr,ssim,rmse,lpips])\n    trainable_weights(model)\n\n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n        model.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        get_test_dataset(model,scale_factor,args)\n        exit(1)\n   \n    save_img_callback = SaveImageCallback(\n        model=model,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    model.fit(train_batch,epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n\n    print(\"Evaluate model\")\n    eval = model.evaluate(test_batch, verbose=1, steps=test_steps)\n    saved_model(model, 'saved_model\/{}\/'.format(args.model))\n    return eval,model.get_run_time()\n\n\ndef train_k_distillation(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n    \n    opt=tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0)\n    \n    if args.loss_fn == \"mse\":\n        aux_loss_fn = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        aux_loss_fn = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        aux_loss_fn = tf.keras.losses.MeanAbsoluteError()\n    \n    student_loss_fn = tf.keras.losses.MeanSquaredError()\n    distillation_loss_fn= tf.keras.losses.MeanAbsoluteError()    \n    \n    shape_hr = (36*scale_factor,36*scale_factor,3)    \n    vgg_loss = VGGLoss(shape_hr,aux_loss_fn)\n    perc_loss = vgg_loss.custom_perceptual_loss\n      \n    teacher = g_rtvsrgan(channels=1,scale_factor=scale_factor)\n    print(\"Loading teacher weights...\")\n    weights_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,'g_rtvsrgan',scale_factor)\n    teacher.load_weights(weights_paph)\n    student = g_rtvsrgan(channels=1,scale_factor=scale_factor) \n    student.build((None, None, None,1))\n\n    # Initialize and compile distiller\n    distiller = Distiller(student=student, teacher=teacher)\n    distiller.compile(\n        optimizer=opt,\n        metrics=[psnr,ssim,rmse,lpips],\n        student_loss_fn=student_loss_fn,\n        distillation_loss_fn=distillation_loss_fn,\n        perc_loss_fn=perc_loss,\n        alpha=args.alpha,\n        beta=args.beta\n    )\n    trainable_weights(student)\n    if args.load_weights:\n        print(\"Loading student weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,'g_rtvsrgan',scale_factor)\n        student.load_weights(checkpoint_paph)\n        trainable_layers(student, len(student.layers)-1)\n        trainable_weights(student)\n        \n    if args.transfer_learning:\n        checkpoint_paph_from=\"{}{}_{}x\/model.ckpt\".format(\"checkpoint\/\",args.model,args.scaleFrom)\n        print(\"Transfer learning from {}x-upscale model...\".format(args.scaleFrom))\n        modelFrom = student(scale_factor=args.scaleFrom)\n        modelFrom.load_weights(checkpoint_paph_from)\n        for i in range(len(modelFrom.layers)):\n            if(modelFrom.layers[i].name == trainable_layer):\n                break\n            else:\n                print(\"Set_weights in: {} layer\".format(student.layers[i].name))\n                student.layers[i].set_weights(modelFrom.layers[i].get_weights())\n                student.layers[i].trainable=False\n    \n   \n    save_img_callback = SaveImageCallback(\n        model=distiller.student,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)\n\n    callbacks.append(save_img_callback)\n\n    earlystopping = tf.keras.callbacks.EarlyStopping(\n        monitor='val_rmse', \n        min_delta=1e-5,\n        patience=50, verbose=1,\n        mode='min', \n        restore_best_weights=True)\n    \n    callbacks.append(earlystopping)\n \n    checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor)\n    checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n        filepath=checkpoint_paph,\n        save_weights_only=True,\n        monitor='val_lpips',\n        save_freq= 'epoch', \n        mode='min',\n        save_best_only=True)\n    callbacks.append(checkpoint_callback)\n\n    # Distill teacher to student\n    distiller.fit(train_batch, epochs=args.num_epochs,callbacks=callbacks,\n    verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n    checkpoint_paph=\"{}{}_{}x\/g_rtsrgan\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n    student.save_weights(checkpoint_paph)\n\n    print(\"Evaluate model\")\n    # Evaluate student on test dataset\n    eval = distiller.evaluate(test_batch, verbose=1, steps=test_steps)\n\n    saved_model(distiller.student, 'saved_model\/{}\/'.format(args.model))\n    return eval,distiller.student.get_run_time()\n\n\ndef train_rtvsrgan(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n    g=g_rtvsrgan(scale_factor=scale_factor)\n    g.build((None, None, None,1))\n\n    d=d_rtvsrgan(input_shape=(36*scale_factor,36*scale_factor,1))\n    ra_d=rad_rtvsrgan(discriminator=d,shape_hr=(36*scale_factor,36*scale_factor,1))\n    \n\n    if args.loss_fn == \"mse\":\n        aux_loss = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        aux_loss = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        aux_loss = tf.keras.losses.MeanAbsoluteError()\n\n    cont_loss = tf.keras.losses.MeanSquaredError()\n    shape_hr = (36*scale_factor,36*scale_factor,3)    \n    vgg_loss = VGGLoss(shape_hr,aux_loss)\n    perc_loss = vgg_loss.custom_perceptual_loss\n\n    adv_loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n    lbd = args.list_weights[0]\n    eta = args.list_weights[1]\n    mu = args.list_weights[2]\n    gan_loss=GANLoss(perc_loss, cont_loss, adv_loss,lbd,eta,mu)\n\n    ra_gan = RaGAN(ra_discriminator=ra_d, generator=g)\n    ra_gan.compile(d_optimizer=tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                g_optimizer=tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                ra_d_loss=gan_loss.discriminator_loss,\n                g_loss = gan_loss.generator_loss,\n                metrics=[psnr,ssim,rmse,lpips])\n    if (args.load_weights):\n        print(\"Loading weights...\") \n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,'g_rtvsrgan',scale_factor)\n        ra_gan.load_weights_gen(checkpoint_paph)\n        trainable_layers(g, len(g.layers)-1)\n        trainable_weights(g)\n        \n    save_img_callback = SaveImageCallback(\n        model=g,\n        model_name=args.model,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)    \n    callbacks.append(save_img_callback)\n\n\n    checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor)\n    checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n        filepath=checkpoint_paph,\n        save_weights_only=True,\n        monitor='val_lpips',\n        save_freq= 'epoch', \n        mode='min',\n        save_best_only=True)\n    callbacks.append(checkpoint_callback)\n\n    ra_gan.fit(train_batch, epochs=args.num_epochs,callbacks=callbacks,verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n    checkpoint_paph=\"{}{}_{}x\/g_rtvsrgan\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor) \n    ra_gan.save_weights_gen(checkpoint_paph)\n\n    print(\"Evaluate model\")\n    eval = ra_gan.evaluate(test_batch, verbose=1)\n    saved_model(ra_gan.generator, 'saved_model\/{}\/'.format(args.model))\n    return eval,ra_gan.student.get_run_time()\n    \n\ndef model_generator(args=None,scale_factor=None):\n    if args.generator== 'espcn':\n        model= espcn(scale_factor=scale_factor)\n    elif args.generator== 'g_rtsrgan':\n        model= g_rtsrgan(scale_factor=scale_factor)\n    elif args.generator== 'imdn':\n        model= IMDN(scale_factor=scale_factor)\n    elif args.generator== 'evsrnet':\n        model= EVSRNet(scale_factor=scale_factor,method=args.inter_method)\n    elif args.generator== 'g_rtvsrgan':\n        model= g_rtvsrgan(scale_factor=scale_factor)\n    elif args.generator== 'teacher':\n        model = Teacher(channels=1,scale_factor=scale_factor,distillation_rate=args.distillation_rate)\n    else:\n        exit(1)\n    return model\n\n\n\ndef print_hot_test(lr_hot_test_path,hr_hot_test_path,model=None,model_name=None,args=None,scale_factor=2): \n    time_elapsed = plot_test_images(model,lr_hot_test_path,hr_hot_test_path,\n             args.test_logdir,scale_factor=scale_factor,model_name=model_name,epoch=0)\n    return time_elapsed\n    \n\ndef get_test_dataset(model,scale_factor,args):\n    bic = True\n    if ('generic' in args.test_cluster): \n        # test dataset\n        test_dataset_path=test_datasets['test_generic']['test_dataset_path']\n        test_dataset_info_path=test_datasets['test_generic']['test_dataset_info_path']\n        test_dataset = Dataset(\n                                args.test_batch_size,\n                                test_dataset_path,\n                                test_dataset_info_path,\n                                args.shuffle_buffer_size)\n\n        if args.test_steps == 0:\n            test_steps = test_dataset.examples_num \/\/ args.test_batch_size \\\n                if test_dataset.examples_num % args.test_batch_size != 0 else 0\n        else:\n            test_steps = args.test_steps\n        \n        test_dataset = test_dataset.get_data()\n        test_batch = test_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n\n        name_dataset = args.model+'_'+args.generator+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) if args.generator!=None else args.model+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) \n        print(name_dataset,args.path_to_eval)\n\n\n        lr_path=test['test_generic']['lr_test_path']\n        hr_path=test['test_generic']['hr_test_path']\n        logdir=test['test_generic']['logdir']\n        lr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_path) if len(filenames)!=0][0])\n        hr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_path) if len(filenames)!=0][0])\n        if (bic):\n            print_metrics(lr_paths, hr_paths, scale_factor=scale_factor)\n            exit(1)\n        # plot_images(\"bi\", lr_paths, hr_paths, args, logdir+\"\/\"+\"bicubic\"+\"\/\",scale_factor=scale_factor)\n        # plot_images(\"hr\", lr_paths, hr_paths, args, logdir+\"\/\"+\"hr\"+\"\/\",scale_factor=scale_factor)\n        # run_time = plot_images(model, lr_paths, hr_paths, args, logdir+\"\/\"+args.generator+\"\/\",scale_factor=scale_factor)\n        run_time = print_hot_test(lr_paths,hr_paths,model=model,model_name=args.model,args=args,scale_factor=scale_factor)\n        eval = model.evaluate(test_batch, verbose=1)\n\n        lr_hot_test_path=hot_test['hot_test_generic']['lr_hot_test_path']\n        hr_hot_test_path=hot_test['hot_test_generic']['hr_hot_test_path']\n        lr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        hr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        test_print = [lr_img_paths,hr_img_paths]\n\n        name_model = \"generic\"+'_'+args.model+'_'+args.generator if args.generator != None else \"generic\"+'_'+args.model \n        # run_time = print_hot_test(test_print[0],test_print[1],model=model,model_name=name_model,args=args,scale_factor=scale_factor)\n        print_eval(args.path_to_eval,eval,name_dataset,stat.mean(run_time))\n\n    if ('game' in args.test_cluster):\n        # test dataset\n        test_dataset_path=test_datasets['test_game']['test_dataset_path']\n        test_dataset_info_path=test_datasets['test_game']['test_dataset_info_path']\n        test_dataset = Dataset(\n                                args.test_batch_size,\n                                test_dataset_path,\n                                test_dataset_info_path,\n                                args.shuffle_buffer_size)\n\n        if args.test_steps == 0:\n            test_steps = test_dataset.examples_num \/\/ args.test_batch_size \\\n                if test_dataset.examples_num % args.test_batch_size != 0 else 0\n        else:\n            test_steps = args.test_steps\n        \n        test_dataset = test_dataset.get_data()\n        test_batch = test_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n\n        name_dataset = args.model+'_'+args.generator+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) if args.generator != None else args.model+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) \n        print(name_dataset,args.path_to_eval)\n\n\n        lr_path=test['test_game']['lr_test_path']\n        hr_path=test['test_game']['hr_test_path']\n        logdir=test['test_game']['logdir']\n        lr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_path) if len(filenames)!=0][0])\n        hr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_path) if len(filenames)!=0][0])\n        if (bic):\n            print_metrics(lr_paths, hr_paths, scale_factor=scale_factor)\n            exit(1)\n        # plot_images(\"bi\", lr_paths, hr_paths, args, logdir+\"\/\"+\"bicubic\"+\"\/\",scale_factor=scale_factor)\n        # plot_images(\"hr\", lr_paths, hr_paths, args, logdir+\"\/\"+\"hr\"+\"\/\",scale_factor=scale_factor)\n        # run_time = plot_images(model, lr_paths, hr_paths, args, logdir+\"\/\"+args.generator+\"\/\",scale_factor=scale_factor)\n        run_time = print_hot_test(lr_paths,hr_paths,model=model,model_name=args.model,args=args,scale_factor=scale_factor)\n        eval = model.evaluate(test_batch, verbose=1)\n\n        lr_hot_test_path=hot_test['hot_test_game']['lr_hot_test_path']\n        hr_hot_test_path=hot_test['hot_test_game']['hr_hot_test_path']\n        lr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        hr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        test_print = [lr_img_paths,hr_img_paths]\n\n        name_model = \"game\"+'_'+args.model+'_'+args.generator if args.generator != None else \"game\"+'_'+args.model \n        # run_time = print_hot_test(test_print[0],test_print[1],model=model,model_name=name_model,args=args,scale_factor=scale_factor)\n        print_eval(args.path_to_eval,eval,name_dataset,stat.mean(run_time))\n    \n    if ('sport' in args.test_cluster):\n        # test dataset\n        test_dataset_path=test_datasets['test_sport']['test_dataset_path']\n        test_dataset_info_path=test_datasets['test_sport']['test_dataset_info_path']\n        test_dataset = Dataset(\n                                args.test_batch_size,\n                                test_dataset_path,\n                                test_dataset_info_path,\n                                args.shuffle_buffer_size)\n\n        if args.test_steps == 0:\n            test_steps = test_dataset.examples_num \/\/ args.test_batch_size \\\n                if test_dataset.examples_num % args.test_batch_size != 0 else 0\n        else:\n            test_steps = args.test_steps\n        \n        test_dataset = test_dataset.get_data()\n        test_batch = test_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n\n        name_dataset = args.model+'_'+args.generator+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) if args.generator != None else args.model+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) \n\n        print(name_dataset,args.path_to_eval)\n\n\n        lr_path=test['test_sport']['lr_test_path']\n        hr_path=test['test_sport']['hr_test_path']\n        logdir=test['test_sport']['logdir']\n        lr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_path) if len(filenames)!=0][0])\n        hr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_path) if len(filenames)!=0][0])\n        if (bic):\n            print_metrics(lr_paths, hr_paths, scale_factor=scale_factor)\n            exit(1)\n        # plot_images(\"bi\", lr_paths, hr_paths, args, logdir+\"\/\"+\"bicubic\"+\"\/\",scale_factor=scale_factor)\n        # plot_images(\"hr\", lr_paths, hr_paths, args, logdir+\"\/\"+\"hr\"+\"\/\",scale_factor=scale_factor)\n        # run_time = plot_images(model, lr_paths, hr_paths, args, logdir+\"\/\"+args.generator+\"\/\",scale_factor=scale_factor)\n        run_time = print_hot_test(lr_paths,hr_paths,model=model,model_name=args.model,args=args,scale_factor=scale_factor)\n        eval = model.evaluate(test_batch, verbose=1)\n\n        lr_hot_test_path=hot_test['hot_test_sport']['lr_hot_test_path']\n        hr_hot_test_path=hot_test['hot_test_sport']['hr_hot_test_path']\n        lr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        hr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        test_print = [lr_img_paths,hr_img_paths]\n\n        name_model = \"sport\"+'_'+args.model+'_'+args.generator if args.generator != None else \"sport\"+'_'+args.model \n        # run_time = print_hot_test(test_print[0],test_print[1],model=model,model_name=name_model,args=args,scale_factor=scale_factor)\n        print_eval(args.path_to_eval,eval,name_dataset,stat.mean(run_time))\n\n    if ('podcast' in args.test_cluster):\n        # test dataset\n        test_dataset_path=test_datasets['test_podcast']['test_dataset_path']\n        test_dataset_info_path=test_datasets['test_podcast']['test_dataset_info_path']\n        test_dataset = Dataset(\n                                args.test_batch_size,\n                                test_dataset_path,\n                                test_dataset_info_path,\n                                args.shuffle_buffer_size)\n\n        if args.test_steps == 0:\n            test_steps = test_dataset.examples_num \/\/ args.test_batch_size \\\n                if test_dataset.examples_num % args.test_batch_size != 0 else 0\n        else:\n            test_steps = args.test_steps\n        \n        test_dataset = test_dataset.get_data()\n        test_batch = test_dataset.map(lambda x0,x1,x2,y: (scale(x1),scale(y)))\n\n        name_dataset = args.model+'_'+args.generator+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) if args.generator != None else args.model+\"_{}_{}X_q{}\".format(str(test_dataset_path).split('\/')[3],str(scale_factor),str(test_dataset_path).split('_q')[-1]) \n        print(name_dataset,args.path_to_eval)\n\n\n        lr_path=test['test_podcast']['lr_test_path']\n        hr_path=test['test_podcast']['hr_test_path']\n        logdir=test['test_podcast']['logdir']\n        lr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_path) if len(filenames)!=0][0])\n        hr_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_path) if len(filenames)!=0][0])\n        if (bic):\n            print_metrics(lr_paths, hr_paths, scale_factor=scale_factor)\n            exit(1)\n        # plot_images(\"bi\", lr_paths, hr_paths, args, logdir+\"\/\"+\"bicubic\"+\"\/\",scale_factor=scale_factor)\n        # plot_images(\"hr\", lr_paths, hr_paths, args, logdir+\"\/\"+\"hr\"+\"\/\",scale_factor=scale_factor)\n        # run_time = plot_images(model, lr_paths, hr_paths, args, logdir+\"\/\"+args.generator+\"\/\",scale_factor=scale_factor)\n        run_time = print_hot_test(lr_paths,hr_paths,model=model,model_name=args.model,args=args,scale_factor=scale_factor)\n        eval = model.evaluate(test_batch, verbose=1)\n\n        lr_hot_test_path=hot_test['hot_test_podcast']['lr_hot_test_path']\n        hr_hot_test_path=hot_test['hot_test_podcast']['hr_hot_test_path']\n        lr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(lr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        hr_img_paths=sorted([[dp+filename for filename in filenames] for dp, dn, filenames in os.walk(hr_hot_test_path) if len(filenames)!=0][0])[0:args.hot_test_size]\n        test_print = [lr_img_paths,hr_img_paths]\n\n        name_model = \"podcast\"+'_'+args.model+'_'+args.generator if args.generator != None else \"podcast\"+'_'+args.model \n        # run_time = print_hot_test(test_print[0],test_print[1],model=model,model_name=name_model,args=args,scale_factor=scale_factor)\n        print_eval(args.path_to_eval,eval,name_dataset,stat.mean(run_time))\n\n\n\ndef train_percsr(train_batch,steps_per_epoch, validation_steps,val_batch, test_batch, test_steps, test_print, scale_factor,args,callbacks,checkpoint_paph,file_writer_cm,trainable_layer):\n\n    g=model_generator(scale_factor=scale_factor,args=args)\n    g.build((None, None, None,1))\n\n    d=d_percsr(input_shape=(36*scale_factor,36*scale_factor,1))\n    ra_d=rad_percsr(discriminator=d,shape_hr=(36*scale_factor,36*scale_factor,1))\n\n    if args.loss_fn == \"mse\":\n        aux_loss = tf.keras.losses.MeanSquaredError()        \n    if args.loss_fn == \"huber\":\n        aux_loss = tf.keras.losses.Huber()\n    if args.loss_fn == \"mae\":\n        aux_loss = tf.keras.losses.MeanAbsoluteError()\n\n    loss_pix = tf.keras.losses.MeanSquaredError()\n    shape_hr = (36*scale_factor,36*scale_factor,3)    \n    vgg_loss = VGGLoss(shape_hr,aux_loss)\n    loss_fea = vgg_loss.custom_perceptual_loss\n    loss_dis = tf.keras.losses.MeanAbsoluteError()\n    adv_loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n    \n    alfa = args.list_weights[0]\n    eta = args.list_weights[1]\n    lbd = args.list_weights[2]\n    mu = args.list_weights[3]\n\n    gan_loss=GANLoss(loss_pix, loss_fea, loss_dis, adv_loss, alfa, eta, lbd, mu)\n\n       \n    teacher = Teacher(channels=1,scale_factor=scale_factor,distillation_rate=args.distillation_rate)\n    print(\"Loading teacher weights...\")\n    weights_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,'teacher',scale_factor)\n    teacher.load_weights(weights_paph)\n    teacher.build((None, None, None,1))\n\n\n    ra_gan = PercSR(ra_discriminator=ra_d, generator=g,teacher=teacher)\n    ra_gan.compile(d_optimizer=tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                   g_optimizer=tf.keras.optimizers.Adam(learning_rate=args.learning_rate,clipnorm=1.0),\n                   perc_loss=gan_loss.generative_loss,\n                   metrics=[psnr,ssim,rmse,lpips])\n    \n    if(args.eval==True):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/{}\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor,args.generator)\n        ra_gan.load_weights(checkpoint_paph)\n        print(\"Evaluate model\")\n        g.compile(metrics=[psnr,ssim,rmse,lpips])\n        get_test_dataset(g,scale_factor,args)\n        exit(1)\n\n    if (args.load_weights):\n        print(\"Loading weights...\")\n        checkpoint_paph=\"{}{}_{}x\/model.ckpt\".format(args.ckpt_path,args.generator,scale_factor) \n        ra_gan.load_weights_gen(checkpoint_paph)\n        # trainable_layers(g, len(g.layers)-1)\n        trainable_weights(g)\n\n    if (args.load_weights_perc):\n        print(\"Loading weights perceptual...\")\n        checkpoint_paph=\"{}{}_{}x\/{}\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor,args.generator) \n        ra_gan.load_weights(checkpoint_paph)\n\n        for i in range(len(g.layers)):\n            print(\"Camada: {}\".format(g.layers[i].name))\n            if(g.layers[i].name == trainable_layer):\n                break\n            else:\n                g.layers[i].trainable=False\n        #trainable_layers(g, len(g.layers)-1)\n        trainable_weights(g)\n\n        \n\n\n    save_img_callback = SaveImageCallback(\n        model=g,\n        model_name=args.model+'_'+args.generator,\n        scale_factor=scale_factor,\n        epochs_per_save=args.epochs_per_save,\n        lr_paths=test_print[0],\n        hr_paths=test_print[1],\n        log_dir=args.test_logdir,\n        file_writer_cm=file_writer_cm)    \n    callbacks.append(save_img_callback)\n\n\n    checkpoint_paph=\"{}{}_{}x\/{}\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor,args.generator)\n    checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n        filepath=checkpoint_paph,\n        save_weights_only=True,\n        monitor='val_lpips',\n        save_freq= 'epoch', \n        mode='min',\n        save_best_only=True)\n    callbacks.append(checkpoint_callback)\n\n    ra_gan.fit(train_batch, epochs=args.num_epochs,callbacks=callbacks,verbose=1,steps_per_epoch=steps_per_epoch,validation_steps=validation_steps,validation_data=val_batch)\n    checkpoint_paph=\"{}{}_{}x\/{}\/{}\/model.ckpt\".format(args.ckpt_path,args.model,scale_factor,args.generator,'generator') \n    ra_gan.save_weights_gen(checkpoint_paph)\n        \n\n    print(\"Evaluate model\")\n    eval = ra_gan.evaluate(test_batch, verbose=1)\n    saved_model(ra_gan.generator, 'saved_model\/{}\/'.format(args.model))\n    return eval, ra_gan.generator.get_run_time()\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_389","text":"<reponame>matthaeusheer\/uncertify<filename>uncertify\/evaluation\/utils.py<gh_stars>1-10\nimport torch\nimport scipy.ndimage\n\nfrom uncertify.utils.custom_types import Tensor\n\n\ndef residual_l1_max(reconstruction: Tensor, original: Tensor) -> Tensor:\n    \"\"\"Construct l1 difference between original and reconstruction.\n\n    Note: Only positive values in the residual are considered, i.e. values below zero are clamped.\n    That means only cases where bright pixels which are brighter in the input (likely lesions) are kept.\"\"\"\n    residual = original - reconstruction\n    return torch.where(residual > 0.0, residual, torch.zeros_like(residual))\n\n\ndef residual_l1(reconstruction: Tensor, original: Tensor) -> Tensor:\n    \"\"\"Construct the absolute l1 difference between original and reconstruction images.\"\"\"\n    return torch.abs_(original - reconstruction)\n\n\ndef mask_background_to_zero(input_tensor: Tensor, mask: Tensor) -> Tensor:\n    return torch.where(mask, input_tensor, torch.zeros_like(input_tensor))\n\n\ndef mask_background_to_value(input_tensor: Tensor, mask: Tensor, value: float) -> Tensor:\n    return torch.where(mask, input_tensor, value * torch.ones_like(input_tensor))\n\n\ndef threshold_batch_to_one_zero(tensor: Tensor, threshold: float) -> Tensor:\n    \"\"\"Apply threshold, s.t. output values become zero if smaller then threshold and one if bigger than threshold.\"\"\"\n    zeros = torch.zeros_like(tensor)\n    ones = torch.ones_like(tensor)\n    return torch.where(tensor > threshold, ones, zeros)\n\n\ndef convert_segmentation_to_one_zero(segmentation: Tensor) -> Tensor:\n    \"\"\"The segmentation map might have multiple labels. Here we crush them to simply 1 (anomaly) or zero (healthy).\"\"\"\n    return torch.where(segmentation > 0, torch.ones_like(segmentation), torch.zeros_like(segmentation))\n\n\ndef erode_mask(mask: Tensor) -> Tensor:\n    \"\"\"Erode the boolean mask tensor inwards the get rid of edge effects on the residual mask.\"\"\"\n    dev = mask.device()\n    mask = mask.cpu()\n    mask = scipy.ndimage.binary_erosion(np.squeeze(brainmask), structure=strel, iterations=12)\n    mask = torch.tensor(mask.cuda())\n    return mask\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_390","text":"import numpy as np\nfrom typing import Union, List, Tuple, Optional, Any\nimport pandas as pd\nimport sympy\nfrom functools import partial\nfrom fastcore.all import partialler\n\nfrom sklearn.utils import resample\n\nfrom torch.tensor import Tensor\nimport torch\nimport torch.nn as nn\n\n__all__ = ['to_np', 'to_device', 'to_tensor', 'str2bool', 'to_binary_class', 'ids2unique', 'FowardHook', 'subsample_df', 'is_partially']\n\ndevice = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')  # TODO: make device choosable by user\n\n\ndef to_np(x:Tensor) -> np.ndarray:\n    r'''\n    Convert Tensor x to a Numpy array\n\n    Arguments:\n        x: Tensor to convert\n\n    Returns:\n        x as a Numpy array\n    '''\n    \n    return x.cpu().detach().numpy() if x is not None else None\n\n\ndef to_device(x:Union[Tensor,List[Tensor]], device:torch.device=device) -> Union[Tensor,List[Tensor]]:\n    r'''\n    Recursively place Tensor(s) onto device\n\n    Arguments:\n        x: Tensor(s) to place on device\n\n    Returns:\n        Tensor(s) on device\n    '''\n\n    if x is None: return x\n    if isinstance(x, list): return [to_device(o, device) for o in x]\n    return x.to(device)\n\n\ndef to_tensor(x:Union[np.ndarray,None]) -> Union[Tensor, None]: \n    r'''\n    Convert Numpy array to Tensor with possibility of a None being passed\n\n    Arguments:\n        x: Numpy array or None\n\n    Returns:\n        x as Tensor or None\n    '''\n    \n    return Tensor(x) if x is not None else None\n\n\ndef str2bool(string:Union[str,bool]) -> bool:\n    r'''\n    Convert string representation of Boolean to bool\n\n    Arguments:\n        string: string representation of Boolean (or a Boolean)\n\n    Returns:\n        bool if bool was passed else, True if lowercase string matches is in (\"yes\", \"true\", \"t\", \"1\")\n    '''\n\n    if isinstance(string, bool): return string\n    else:                        return string.lower() in (\"yes\", \"true\", \"t\", \"1\")\n\n\ndef to_binary_class(df:pd.DataFrame, zero_preds:List[str], one_preds:List[str]) -> None:\n    r'''\n    Map class precitions back to a binary prediction.\n    The maximum prediction for features listed in zero_preds is treated as the prediction for class 0, vice versa for one_preds.\n    The binary prediction is added to df in place as column 'pred'\n    \n    Arguments:\n        df: DataFrame containing prediction features\n        zero_preds: list of column names for predictions associated with class 0\n        one_preds: list of column names for predictions associated with class 0\n    '''\n\n    zero = df[zero_preds].max(axis=1)[:, None]\n    one = df[one_preds].max(axis=1)[:, None]\n    tup = np.hstack((zero, one))\n    predargs = np.argmax(tup, axis=1)\n    preds = np.max(tup, axis=1)\n    preds[predargs == 0] = 1-preds[predargs == 0]\n    df['pred'] = preds\n\n\ndef ids2unique(ids: Union[List[int], np.ndarray]) -> np.ndarray:\n    r'''\n    Map a permutaion of integers to a unique number, or a 2D array of integers to unique numbers by row.\n    Returned numbers are unique for a given permutation of integers.\n    This is achieved by computing the product of primes raised to powers equal to the integers. Beacause of this, it can be easy to produce numbers which are\n    too large to be stored if many (large) integers are passed.\n\n    Arguments:\n        ids: (array of) permutation(s) of integers to map\n\n    Returns:\n        (Array of) unique id(s) for given permutation(s)\n    '''\n\n    if not isinstance(ids, np.ndarray): ids = np.array(ids)[:,None]\n    primes = np.broadcast_to(np.array([sympy.prime(i) for i in range(1, 1+ids.shape[1])]), ids.shape)\n    return (primes**ids).prod(axis=-1)\n\n\nclass FowardHook():\n    r'''\n    Create a hook for performing an action based on the forward pass thorugh a nn.Module\n\n    Arguments:\n        module: nn.Module to hook\n        hook_fn: Optional function to perform. Default is to record input and output of module\n\n    Examples::\n        >>> hook = ForwardHook(model.tail.dense)\n        >>> model.predict(inputs)\n        >>> print(hook.inputs)\n    '''\n    def __init__(self, module:nn.Module, hook_fn:Optional=None):\n        self.input,self.output = None,None\n        if hook_fn is not None: self.hook_fn = partial(hook_fn, self)\n        self.hook = module.register_forward_hook(self.hook_fn)\n\n    def __del__(self): self.remove()\n        \n    def hook_fn(self, module:nn.Module, input:Union[Tensor,Tuple[Tensor]], output:Union[Tensor,Tuple[Tensor]]) -> None:\n        r'''\n        Default hook function records inputs and outputs of module\n\n        Arguments:\n            module: nn.Module to hook\n            input: input tensor\n            output: output tensor of module\n        '''\n\n        self.input,self.output = input,output\n        \n    def remove(self) -> None:\n        r'''\n        Call when finished to remove hook\n        '''\n\n        self.hook.remove()\n\n\ndef subsample_df(df:pd.DataFrame, objective:str, targ_name:str, n_samples:Optional[int]=None, replace:bool=False, strat_key:Optional[str]=None,\n                 wgt_name:Optional[str]=None) -> pd.DataFrame:\n    r'''\n    Subsamples, or samples with replacement, a DataFrame.\n    Will automatically reweight data such that weight sums remain the same as the original DataFrame (per class)\n\n    Arguments:\n        df: DataFrame to sample\n        objective: string representation of objective: either 'classification' or 'regression'\n        targ_name: name of column containing target data\n        n_samples: If set, will sample that number of data points, otherwise will sample with replacement a new DataFRame of the same size as the original\n        replace: whether to sample with replacement\n        strat_key: column name to use for stratified subsampling, if desired\n        wgt_name: name of column containing weight data. If set, will reweight subsampled data, otherwise will not\n    '''\n\n    tmp_df = df.loc[resample(df.index, replace=replace, n_samples=n_samples, stratify=None if strat_key is None else df[strat_key])]\n    \n    # Reweight resampled data\n    if wgt_name is not None:\n        if 'class' in objective.lower():\n            for c in tmp_df[targ_name].unique():\n                tmp_df.loc[tmp_df[targ_name] == c, wgt_name] *= df.loc[df[targ_name] == c, wgt_name].sum() \/ tmp_df.loc[tmp_df[targ_name] == c, wgt_name].sum()\n        else:\n            tmp_df[wgt_name] *= df[wgt_name].sum() \/ tmp_df[wgt_name].sum()\n    return tmp_df\n\n\ndef is_partially(var:Any) -> bool:\n    r'''\n    Retuns true if var is partial or partialler, else false.\n\n    Arguments:\n        var: variable to inspect\n\n    Return:\n        true if var is partial or partialler, else false\n    '''\n\n    return isinstance(var, partial) or isinstance(var, partialler)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_392","text":"import os\nimport sys\nimport pylab\nimport numpy\nimport torch\nimport time\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as colors\nimport matplotlib.gridspec as gridspec\nimport matplotlib.cm as cm\nimport copy\n\nfrom scipy.spatial.transform import Rotation as R\n\n\ndef calculate_contours(pdf_vals, bin_volumes, probs=[0.68, 0.95]):\n    totsum = 0.0\n    flattend_pdf = pdf_vals.flatten()\n    #flattend_volumes = bin_volumes.flatten()\n\n    sorta = numpy.argsort(flattend_pdf)[::-1]\n\n    contour_values = []\n\n    cur_prob_index = 0\n\n    for ind, pdf_eval in enumerate(flattend_pdf[sorta]):\n        totsum += pdf_eval*bin_volumes#flattend_volumes[sorta][ind]\n\n        if (totsum > probs[cur_prob_index]):\n            contour_values.append(pdf_eval)\n            cur_prob_index += 1\n\n        if (cur_prob_index >= len(probs)):\n            break\n\n    return contour_values\n\n\ndef get_bounds_from_contour(cres, boundary=0.1):\n\n    cont_min_x = 9999999.9\n    cont_max_x = -9999999.9\n\n    cont_min_y = 999999999.9\n    cont_max_y = -9999999999.9\n\n    for i in cres.allsegs[0]:\n\n        for j in i:\n\n            if (j[0] < cont_min_x):\n                cont_min_x = j[0]\n            if (j[0] > cont_max_x):\n                cont_max_x = j[0]\n\n            if (j[1] < cont_min_y):\n                cont_min_y = j[1]\n            if (j[1] > cont_max_y):\n                cont_max_y = j[1]\n\n    return cont_min_x, cont_max_x, cont_min_y, cont_max_y\n\n\ndef get_minmax_values(samples):\n    mins_maxs = []\n\n    for ind in range(samples.shape[1]):\n        min_val = min(samples[:, ind])\n        max_val = max(samples[:, ind])\n\n        mins_maxs.append((min_val, max_val))\n\n    return mins_maxs\n\n\ndef get_pdf_on_grid(mins_maxs, npts, model, conditional_input=None, s2_norm=\"standard\", s2_rotate_to_true_value=False, true_values=None):\n\n    side_vals = []\n\n    bin_volumes = 1.0#numpy.ones([npts]*len(mins_maxs))\n    glob_ind = 0\n    #has_high_dim_spheres = False\n    cinput = None\n\n    sin_zen_mask=[]\n\n    for pdf in model.pdf_defs_list:\n        this_sub_dim = int(pdf[1])\n        if (pdf == \"s2\" and s2_norm==\"lambert\"):\n            #has_high_dim_spheres = True\n            side_vals.append(numpy.linspace(-2, 2, npts))\n            bin_volumes *= (side_vals[-1][1] - side_vals[-1][0])\n\n            side_vals.append(numpy.linspace(-2, 2, npts))\n            bin_volumes *= (side_vals[-1][1] - side_vals[-1][0])\n\n            sin_zen_mask.extend([0,0])\n\n        elif(pdf==\"s2\" and s2_norm==\"standard\"):\n\n          sin_zen_mask.extend([1,0])\n          \n          zen_vals=numpy.linspace(mins_maxs[glob_ind][0]+1e-4, mins_maxs[glob_ind][1]-1e-4, npts)\n          side_vals.append(zen_vals)\n          bin_volumes*=(side_vals[-1][1] - side_vals[-1][0])\n\n          side_vals.append(numpy.linspace(1e-4, 2*numpy.pi-1e-4, npts))\n          bin_volumes *= (side_vals[-1][1] - side_vals[-1][0])\n\n        elif(pdf==\"s2\"):\n          raise Exception(\"s2_norm \", s2_norm, \" unknown .\")\n        else:\n            \n            for ind, mm in enumerate(mins_maxs[glob_ind:glob_ind +\n                                               this_sub_dim]):\n\n                side_vals.append(numpy.linspace(mm[0], mm[1], npts))\n                bin_volumes *= (side_vals[-1][1] - side_vals[-1][0])\n\n                sin_zen_mask.append(0)\n\n        glob_ind += this_sub_dim\n\n    eval_positions = numpy.meshgrid(*side_vals)\n\n    torch_positions = torch.from_numpy(\n        numpy.resize(\n            numpy.array(eval_positions).T,\n            (npts**len(mins_maxs), len(mins_maxs))))\n    eval_positions = torch_positions.clone()\n\n    mask_inner = torch.ones(len(torch_positions)) == 1\n\n    for ind, pdf_def in enumerate(model.pdf_defs_list):\n       \n        if (pdf_def == \"s2\" and s2_norm==\"lambert\"):\n\n            fix_point=None\n\n            if(s2_rotate_to_true_value and true_values is not None):\n              fix_point=true_values[model.target_dim_indices[ind][0]:model.target_dim_indices[ind][1]]\n           \n            mask_inner = mask_inner & (torch.sqrt(\n                (eval_positions[:, model.target_dim_indices[ind][0]:model.\n                                target_dim_indices[ind][1]]**2).sum(axis=1)) <\n                                       2)\n            ## transform s2 subdimensions from equal-area lambert dimension to real spherical dimensiosn the model can use\n\n            eval_positions[:, model.target_dim_indices[ind][0]:model.\n                           target_dim_indices[ind]\n                           [1]] = cartesian_lambert_to_spherical(\n                               eval_positions[:, model.\n                                              target_dim_indices[ind][0]:model.\n                                              target_dim_indices[ind][1]], fix_point=fix_point)\n\n    if (conditional_input is not None):\n        cinput = conditional_input.repeat(npts**len(mins_maxs), 1)[mask_inner]\n    \n\n    log_res, _, _ = model(eval_positions[mask_inner], conditional_input=cinput)\n \n    ## no conditional input and only s2 pdf .. mask bad regions\n    flagged_coords=numpy.array([])\n    if(conditional_input is None and model.pdf_defs_list[0]==\"s2\"):\n      \n      \n      problematic_pars=model.layer_list[0][0].return_problematic_pars_between_hh_and_intrinsic(eval_positions[mask_inner], flag_pole_distance=0.02)\n\n      if(problematic_pars.shape[0]>0):\n        if(s2_norm==\"lambert\"):\n          fix_point=None\n          if(s2_rotate_to_true_value and true_values is not None):\n              fix_point=true_values[model.target_dim_indices[ind][0]:model.target_dim_indices[ind][1]]\n          problematic_pars=spherical_to_cartesian_lambert(problematic_pars, fix_point=fix_point)\n      flagged_coords=problematic_pars.detach().numpy()\n\n    \"\"\"\n    lr_mask=numpy.exp(log_res)>1e4\n\n    print(\"############################# TEST\")\n    bad_res,_,_=model(eval_positions[mask_inner][lr_mask][:1], conditional_input=None)\n    \n    print(bad_res)\n    \n    \"\"\"\n \n    res = (-600.0)*torch.ones(len(torch_positions)).type_as(torch_positions)\n    res[mask_inner] = log_res  #.exp()\n   \n    res = res.detach().numpy()\n    numpy_positions=eval_positions.detach().numpy()\n    if((numpy.isfinite(res)==False).sum()>0):\n      print(\"Non-finite evaluation during PDF eval for plotting..\")\n      print((numpy.isfinite(res)==False).sum())\n      print(numpy_positions[(numpy.isfinite(res)==False)])\n\n      r,_,_=model(eval_positions[mask_inner][torch.isfinite(log_res)==False][:1], conditional_input=cinput)\n      print(r)\n      raise Exception()\n\n    #######################\n\n\n    res.resize([npts] * len(mins_maxs))\n\n    resized_torch_positions = torch_positions.detach().numpy()\n    resized_torch_positions.resize([npts] * len(mins_maxs) + [len(mins_maxs)])\n\n    ## add in sin(theta) factors into density\n\n    \n\n    for ind, sz in enumerate(sin_zen_mask):\n      if(sz==1):\n        slice_mask=(None,)*ind+(slice(None,None),)+(None,)*(len(sin_zen_mask)-1-ind)\n\n        zen_vals=numpy.sin(numpy.linspace(mins_maxs[ind][0]+1e-4, mins_maxs[ind][1]-1e-4, npts))\n\n        ## log val, adding zenith factors where needed\n        res+=numpy.log(zen_vals[slice_mask])\n\n\n    return resized_torch_positions, res, bin_volumes, sin_zen_mask, flagged_coords\n\ndef rotate_coords_to(theta, phi, target, reverse=False):\n\n  target_theta=target[0]\n  target_phi=target[1]\n\n\n  x=numpy.cos(target_phi)*numpy.sin(target_theta)\n  y=numpy.sin(target_phi)*numpy.sin(target_theta)\n  z=numpy.cos(target_theta)\n\n  ###########\n\n  axis=-numpy.cross(numpy.array([x,y,z]), numpy.array([0,0,1]))\n  axis_len=numpy.sqrt((axis**2).sum())\n  axis\/=axis_len\n\n  rot_angle=numpy.pi-target_theta\n  if(reverse):\n    rot_angle=-rot_angle\n\n\n  axis*=rot_angle.item()\n\n  rot_matrix = R.from_rotvec(axis)\n  ###########\n  \n  x=numpy.cos(phi)*numpy.sin(theta)\n  y=numpy.sin(phi)*numpy.sin(theta)\n  z=numpy.cos(theta)\n  vals=torch.cat([x[:,None], y[:,None],z[:,None]], dim=1)\n\n  res=torch.from_numpy(rot_matrix.apply(vals))\n  \n  ##########\n\n  theta=numpy.arccos(res[:,2])\n  non_finite_mask=numpy.isfinite(theta)==False\n  larger=non_finite_mask & (res[:,2] > 0)\n  smaller=non_finite_mask & (res[:,2] < 0)\n\n  theta[smaller]=numpy.pi\n  theta[larger]=0.0\n\n\n  phi=numpy.arctan2(res[:,1],res[:,0])\n\n  #phi_smaller_mask=phi<0\n  #phi[phi_smaller_mask]=phi[phi_smaller_mask]+2*numpy.pi\n \n  return theta, phi\n\ndef cartesian_lambert_to_spherical(xl, fix_point=None):\n\n    ## first go to spherical lambert\n\n    r = torch.sqrt((xl**2).sum(axis=1))\n    phi = torch.acos(xl[:, 0] \/ r)\n    larger_mask = (xl[:, 1] >= 0)\n\n    phi = larger_mask * phi + (larger_mask == 0) * (2 * numpy.pi - phi)\n    theta = 2 * torch.acos(r \/ 2.0)\n\n    if(fix_point is not None):\n\n      theta, phi = rotate_coords_to(theta, phi, fix_point, reverse=True)\n\n    ## now go to spherical real coordinates\n\n    return torch.cat([theta[:, None], phi[:, None]], dim=1)\n\n\ndef spherical_to_cartesian_lambert(spherical, fix_point=None):\n\n    #####################\n\n    theta = spherical[:, 0]\n    phi_lambert = spherical[:, 1]\n\n    ######################\n    if(fix_point is not None):\n      theta, phi_lambert = rotate_coords_to(theta, phi_lambert, fix_point)\n\n    #print(theta, phi_lambert)\n    ## first go to spherical lambert\n    r_lambert = 2 * torch.cos(theta \/ 2.0)\n\n    x_l = r_lambert * torch.cos(phi_lambert)\n    y_l = r_lambert * torch.sin(phi_lambert)\n\n    return torch.cat([x_l[:, None], y_l[:, None]], dim=1)\n\n\ndef show_sample_contours(ax,\n                         samples,\n                         bins=50,\n                         color=\"white\",\n                         contour_probs=[0.68, 0.95],\n                         sin_zen_mask=[0,0]):\n\n    ## if bins is a list, make sure samples are within bounds by artifical intervention\n\n    new_samples = samples\n    if (type(bins) == list):\n\n        bounds_x_mask = (samples[:, 0] < bins[0][-1]) & (samples[:, 0] >\n                                                         bins[0][0])\n        bounds_y_mask = (samples[:, 1] < bins[1][-1]) & (samples[:, 1] >\n                                                         bins[1][0])\n\n        total_included_mask = bounds_x_mask & bounds_y_mask\n\n        if (total_included_mask.sum() < 100):\n            print(\"TOTAL INCLUDED SUM \", total_included_mask.sum())\n            print(\n                \"too few SAMPLES IN PLOTTING RANGE ... fake entries to evaluate fake contour\"\n            )\n            somex = numpy.random.uniform(bins[0][0],\n                                         bins[0][-1],\n                                         size=len(samples))\n            somey = numpy.random.uniform(bins[1][0],\n                                         bins[1][-1],\n                                         size=len(samples))\n\n            new_samples = numpy.zeros_like(samples)\n            new_samples[:, 0] = somex\n            new_samples[:, 1] = somey\n\n\n\n    bin_fillings, xedges, yedges = numpy.histogram2d(new_samples[:, 0],\n                                                     new_samples[:, 1],\n                                                     bins=bins,\n                                                     density=True)\n\n  \n    xvals = 0.5 * (xedges[1:] + xedges[:-1])\n    yvals = 0.5 * (yedges[1:] + yedges[:-1])\n    bw = (xedges[1] - xedges[0]) * (yedges[1] - yedges[0])\n\n    bin_volumes=bw#*numpy.ones_like(bin_fillings)\n\n    \"\"\"\n    for ind, m in enumerate(sin_zen_mask):\n      if(m==1):\n        if(ind==0):\n          print(\"IND 0 \")\n          sin_zen=numpy.sin(0.5*(xedges[1:]+xedges[:-1]))\n          print(sin_zen)\n          bin_volumes*=sin_zen[:,None]\n        if(ind==1):\n          sin_zen=numpy.sin(0.5*(yedges[1:]+yedges[:-1]))\n          bin_volumes*=sin_zen[None,:]\n    \"\"\"\n    \n    contour_values = calculate_contours(bin_fillings, bin_volumes, probs=contour_probs)\n    ## reverse\n    contour_values = contour_values[::-1]\n\n    bounds=None\n\n    try:\n      ret = ax.contour(xvals,\n                       yvals,\n                       bin_fillings.T,\n                       levels=contour_values,\n                       colors=color)\n\n      fmt_dict = dict()\n\n      for ind, cprob in enumerate(contour_probs[::-1]):\n          if(ind<len(contour_values)):\n              fmt_dict[contour_values[ind]] = \"%d\" % (int(cprob * 100)) + r\" %\"\n\n      ax.clabel(ret,\n                fontsize=9,\n                inline=1,\n                fmt=fmt_dict,\n                levels=contour_values,\n                colors=color)\n\n     \n      bounds = get_bounds_from_contour(ret)\n    except:\n      return [[-1.0,1.0], [-1.0,1.0]]\n\n\n    return [[bounds[0], bounds[1]], [bounds[2], bounds[3]]]\n\n\ndef plot_density_with_contours(ax,\n                               log_evals,\n                               evalpositions,\n                               bin_volumes,\n                               pts_per_dim,\n                               color=\"black\",\n                               contour_probs=[0.68, 0.95]):\n  \n\n    xvals=evalpositions[:,0,0]\n    yvals=evalpositions[0,:,1]\n   \n    #xr = (evalpositions[:, :, 0].min(), evalpositions[:, :, 0].max())\n    #yr = (evalpositions[:, :, 1].min(), evalpositions[:, :, 1].max())\n\n    xr = (xvals[0], xvals[-1])\n    yr = (yvals[0], yvals[-1])\n\n    contour_values = calculate_contours(numpy.exp(log_evals), bin_volumes,\n                                        probs=contour_probs)\n\n   \n    ## reverse\n\n    contour_values = contour_values[::-1]\n\n    pcol_result = ax.pcolorfast(xr, yr, numpy.exp(log_evals).T)\n\n    #contour_x = numpy.linspace(evalpositions[:, :, 0].min(),\n    #                           evalpositions[:, :, 0].max(), pts_per_dim)\n    #contour_y = numpy.linspace(evalpositions[:, :, 1].min(),\n    #                           evalpositions[:, :, 1].max(), pts_per_dim)\n\n    valid_contour=True\n\n    if(len(contour_values)>=2):\n      if(contour_values[0]==contour_values[1]):\n        valid_contour=False\n\n    if(len(contour_probs) != len(contour_values)):\n      valid_contour=False\n\n    if(valid_contour):\n      contour_x=xvals\n      contour_y=yvals\n\n      bins = [contour_x, contour_y]\n\n      res = ax.contour(contour_x,\n                       contour_y,\n                       numpy.exp(log_evals).T,\n                       levels=contour_values,\n                       colors=color)\n\n      fmt_dict = dict()\n  \n      for ind, cprob in enumerate(contour_probs[::-1]):\n          fmt_dict[contour_values[ind]] = \"%d\" % (int(cprob * 100)) + r\" %\"\n\n      ax.clabel(res,\n                fontsize=9,\n                inline=1,\n                fmt=fmt_dict,\n                levels=contour_values,\n                colors=color)\n\n    pylab.colorbar(pcol_result, ax=ax)\n\ndef get_basic_gridlines():\n\n  n_theta=5\n  n_phi=10\n\n  gridlines=[]\n\n  for g in numpy.linspace(0.1,numpy.pi-0.1, n_theta):\n    azis=torch.linspace(0,2*numpy.pi, 100)\n    zens=torch.ones_like(azis)*g\n    gl=torch.cat( [zens[:,None], azis[:,None]], dim=1)\n    gridlines.append(gl)\n\n  for a in numpy.linspace(0,2*numpy.pi-2*numpy.pi\/n_phi, n_phi):\n    zens=torch.linspace(0,numpy.pi,100)\n    azis=torch.ones_like(zens)*a\n    gl=torch.cat( [zens[:,None], azis[:,None]], dim=1)\n    gridlines.append(gl)\n\n  return gridlines\n\ndef plot_joint_pdf(pdf,\n                   fig,\n                   gridspec,\n                   samples,\n                   subgridspec=None,\n                   conditional_input=None,\n                   bounds=None,\n                   multiplot=False,\n                   total_pdf_eval_pts=10000,\n                   true_values=None,\n                   plot_only_contours=False,\n                   contour_probs=[0.68, 0.95],\n                   contour_color=\"white\",\n                   autoscale=True,\n                   skip_plotting_density=False,\n                   hide_labels=False,\n                   s2_norm=\"standard\",\n                   colormap=cm.rainbow,\n                   s2_rotate_to_true_value=True,\n                   s2_show_gridlines=True,\n                   skip_plotting_samples=False):\n\n    plot_density = False\n    dim = len(samples[0])\n    if (pdf.total_target_dim == 1 and dim == pdf.total_target_dim):\n        plot_density = True\n\n    if (pdf.total_target_dim == 2 and dim == pdf.total_target_dim):\n        plot_density = True\n\n    if (conditional_input is not None):\n        if (conditional_input.shape[0] > 1):\n            plot_density = False\n\n    if (skip_plotting_density):\n        plot_density = False\n\n    mms = get_minmax_values(samples)\n\n    \n\n    if (bounds is not None):\n        mms = bounds\n\n    ## true positions are typically labels\n    plotted_true_values=None\n    if(true_values is not None):\n      plotted_true_values=copy.deepcopy(true_values)\n\n    ## if bounds contain torch .. change to float\n\n    pure_float_mms = []\n    for b in mms:\n        new_b = b\n        if (type(b[0]) == torch.Tensor):\n            new_b = [\n                float(b[0].detach().numpy()),\n                float(b[1].detach().numpy())\n            ]\n\n        pure_float_mms.append(new_b)\n\n\n    totalpts = total_pdf_eval_pts\n    pts_per_dim = int(totalpts**(1.0 \/ float(dim)))\n\n    samples = samples.detach().clone()\n\n    gridline_dict=None\n    if(s2_show_gridlines and \"s2\" in pdf.pdf_defs_list):\n      gridline_dict=dict()\n      for ind, pdf_type in enumerate(pdf.pdf_defs_list):\n        if(pdf_type==\"s2\"):\n          gridline_dict[(pdf.target_dim_indices[ind][0], pdf.target_dim_indices[ind][1])]=get_basic_gridlines()\n\n\n    ## transform samples to lambert space if necessary\n    for ind, pdf_type in enumerate(pdf.pdf_defs_list):\n        if (pdf_type == \"s2\" and s2_norm==\"lambert\"):\n            ## transform to labmert space\n\n            ## calculate fix point if rotation for visualtizion is desired\n            fix_point=None\n            \n\n            if(s2_rotate_to_true_value and true_values is not None):\n             \n              fix_point=true_values[pdf.target_dim_indices[ind][0]:pdf.target_dim_indices[ind][1]]\n\n            ## transform samples to lambert space\n            samples[:,\n                    pdf.target_dim_indices[ind][0]:pdf.target_dim_indices[ind]\n                    [1]] = spherical_to_cartesian_lambert(\n                        samples[:, pdf.target_dim_indices[ind][0]:pdf.\n                                target_dim_indices[ind][1]], fix_point=fix_point)\n\n            ## transform true value to lambert space\n            if(plotted_true_values is not None):\n              \n                res=spherical_to_cartesian_lambert(true_values[pdf.target_dim_indices[ind][0]:pdf.\n                target_dim_indices[ind][1]].unsqueeze(0), fix_point=fix_point)\n\n                plotted_true_values[pdf.target_dim_indices[ind][0]:pdf.\n                target_dim_indices[ind][1]]=res.squeeze(0)\n\n          \n            ## transform gridlines to lambert space\n            if(s2_show_gridlines):\n              tup=(pdf.target_dim_indices[ind][0],pdf.target_dim_indices[ind][1])\n\n              new_list=[]\n\n              for l in gridline_dict[tup]:\n                new_list.append(spherical_to_cartesian_lambert(l, fix_point=fix_point))\n\n              gridline_dict[tup]=new_list\n\n\n\n    samples = samples.numpy()\n\n    pdf_conditional_input = conditional_input\n\n    if (pdf_conditional_input is not None):\n        pdf_conditional_input = pdf_conditional_input[0:1]\n\n\n    evalpositions, log_evals, bin_volumes, sin_zen_mask, unreliable_spherical_regions= get_pdf_on_grid(\n        pure_float_mms,\n        pts_per_dim,\n        pdf,\n        conditional_input=pdf_conditional_input,\n        s2_norm=s2_norm,\n        s2_rotate_to_true_value=s2_rotate_to_true_value,\n        true_values=true_values)\n\n   \n    total_pdf_integral=numpy.exp(log_evals).sum()*bin_volumes\n    \n  \n    if (dim == 1):\n        ax = fig.add_subplot(gridspec)\n        ax.hist(samples[:, 0], bins=50, density=True)\n\n        if (plot_density):\n\n            ax.plot(evalpositions[:, 0], numpy.exp(log_evals), color=\"k\")\n\n        if (true_values is not None):\n            ax.axvline(true_values[0], color=\"red\", lw=2.0)\n\n        if (hide_labels):\n            ax.set_yticklabels([])\n            ax.set_xticklabels([])\n\n    elif (dim == 2 and multiplot == False):\n     \n        if (subgridspec is None):\n            subgridspec = gridspec.subgridspec(1, 1)\n\n        ax = fig.add_subplot(subgridspec[0, 0])\n\n        hist_bounds = 50\n        #if(bounds is not None):\n        #    hist_bounds=[numpy.linspace(bounds[0][0], bounds[0][1], 50),numpy.linspace(bounds[1][0], bounds[1][1], 50) ]\n\n        ## plot the density and contours from density\n        if (plot_density):\n\n            \n            if (contour_probs != [] and skip_plotting_samples==False):\n            \n              two_d_bounds_for_better_density = show_sample_contours(ax,\n                                                samples,\n                                                bins=50,\n                                                color=contour_color,\n                                                contour_probs=contour_probs,\n                                                sin_zen_mask=sin_zen_mask)\n\n              x_width=two_d_bounds_for_better_density[0][1]-two_d_bounds_for_better_density[0][0]\n              y_width=two_d_bounds_for_better_density[1][1]-two_d_bounds_for_better_density[1][0]\n\n              extra_x=x_width*0.2\n              extra_y=y_width*0.2\n\n              two_d_bounds_for_better_density[0][0]-=extra_x\n              two_d_bounds_for_better_density[0][1]+=extra_x\n\n              two_d_bounds_for_better_density[1][0]-=extra_y\n              two_d_bounds_for_better_density[1][1]+=extra_y\n\n\n              evalpositions_2d, log_evals_2d, bin_volumes_2d, _, _= get_pdf_on_grid(\n                two_d_bounds_for_better_density,\n                pts_per_dim,\n                pdf,\n                conditional_input=pdf_conditional_input,\n                s2_norm=s2_norm,\n                s2_rotate_to_true_value=s2_rotate_to_true_value,\n                true_values=true_values)\n             \n              plot_density_with_contours(ax, log_evals_2d, evalpositions_2d,\n                                         bin_volumes_2d, pts_per_dim)\n\n            else:\n              \n              plot_density_with_contours(ax, log_evals, evalpositions,\n                                         bin_volumes, pts_per_dim)\n     \n        ## plot a histogram density from samples\n\n        \n        if ( (plot_only_contours == False) and (plot_density == False) and (skip_plotting_samples==False)):\n           \n            ax.hist2d(samples[:, 0],\n                      samples[:, 1],\n                      bins=hist_bounds,\n                      density=True)\n        \n\n        ## plot contours from samples\n        new_bounds = None\n        if (contour_probs != [] and skip_plotting_samples==False):\n            \n            new_bounds = show_sample_contours(ax,\n                                              samples,\n                                              bins=hist_bounds,\n                                              color=contour_color,\n                                              contour_probs=contour_probs,\n                                              sin_zen_mask=sin_zen_mask)\n            \n       \n        if (bounds is not None):\n            new_bounds = bounds\n            \n       \n        ## mark poles\n        if(len(unreliable_spherical_regions)>0):\n          \n          ax.plot(unreliable_spherical_regions[:,0], unreliable_spherical_regions[:,1], color=\"orange\", marker=\"x\", lw=0.0)\n\n        ## plot true values\n        if (plotted_true_values is not None):\n            \n            ax.plot([plotted_true_values[0]], [plotted_true_values[1]],\n                    color=\"red\",\n                    marker=\"o\",\n                    ms=3.0)\n\n        ## plot gridlines if desired\n        if(s2_show_gridlines and gridline_dict is not None):\n          \n          for gl in gridline_dict[(0,2)]:\n            np_gl=gl.numpy()\n\n            ax.plot(np_gl.T[0], np_gl.T[1], color=\"gray\", alpha=0.5)\n       \n        ## adjust axis bounds\n\n        \n        if (new_bounds is not None):\n            ax.set_xlim(new_bounds[0][0], new_bounds[0][1])\n            ax.set_ylim(new_bounds[1][0], new_bounds[1][1]) \n        \n        ### overwrite any bounds for spherical\n        if(pdf.pdf_defs_list[0]==\"s2\"):\n          if(s2_norm==\"standard\"):\n            ax.set_xlim(0, numpy.pi)\n            ax.set_ylim(0, 2*numpy.pi) \n          else:\n            ax.set_xlim(-2.0,2.0)\n            ax.set_ylim(-2.0,2.0) \n            \n        if (hide_labels):\n            ax.set_yticklabels([])\n            ax.set_xticklabels([])\n       \n    else:\n\n        \n        if (subgridspec is None):\n            subgridspec = gridspec.subgridspec(dim, dim)\n\n        for ind1 in range(dim):\n            for ind2 in range(dim):\n               \n                if (ind2 < ind1):\n\n                    ax = fig.add_subplot(subgridspec[ind1, ind2])\n\n                    ## make sure background looks similar to histogram empty bins\n                    ax.set_facecolor(colormap(0.0))\n\n                    hist_bounds = 50\n                    #if(bounds is not None):\n                    #    hist_bounds=[numpy.linspace(bounds[ind2][0], bounds[ind2][1], 50),numpy.linspace(bounds[ind1][0], bounds[ind1][1], 50) ]\n\n                    if (plot_only_contours == False):\n                        ax.hist2d(samples[:, ind2],\n                                  samples[:, ind1],\n                                  bins=hist_bounds,\n                                  density=True,\n                                  cmap=colormap)\n\n                    if (true_values is not None):\n                        ax.plot([true_values[ind2]], [true_values[ind1]],\n                                color=\"red\",\n                                marker=\"o\",\n                                ms=3.0)\n\n                    new_samples = numpy.concatenate(\n                        [samples[:, ind2:ind2 + 1], samples[:, ind1:ind1 + 1]],\n                        axis=1)\n\n                    new_bounds = None\n                    if (contour_probs != []):\n                        new_bounds = show_sample_contours(\n                            ax,\n                            new_samples,\n                            bins=hist_bounds,\n                            color=contour_color,\n                            contour_probs=contour_probs)\n\n                    if (bounds is not None):\n                        new_bounds = [bounds[ind2], bounds[ind1]]\n\n                    if (autoscale and new_bounds is not None):\n\n                        ax.set_xlim(new_bounds[0][0], new_bounds[0][1])\n                        ax.set_ylim(new_bounds[1][0], new_bounds[1][1])\n\n                    if (hide_labels):\n                        ax.set_yticklabels([])\n                        ax.set_xticklabels([])\n\n                elif (ind2 == ind1):\n\n                    ax = fig.add_subplot(subgridspec[ind1, ind2])\n\n                    hist_bounds = 50\n                    if (bounds is not None):\n                        hist_bounds = numpy.linspace(bounds[ind2][0],\n                                                     bounds[ind2][1], 50)\n                    ax.hist(samples[:, ind1], bins=hist_bounds, density=True)\n\n                    if (true_values is not None):\n                        ax.axvline(true_values[ind1], color=\"red\", lw=2.0)\n\n                    if (autoscale):\n                        if (bounds is not None):\n                            ax.set_xlim(bounds[ind2][0], bounds[ind2][1])\n                    if (hide_labels):\n                        ax.set_yticklabels([])\n                        ax.set_xticklabels([])\n\n    \n    return subgridspec\n\n\ndef visualize_pdf(pdf,\n                  fig,\n                  gridspec=None,\n                  subgridspec=None,\n                  conditional_input=None,\n                  nsamples=10000,\n                  total_pdf_eval_pts=10000,\n                  bounds=None,\n                  true_values=None,\n                  plot_only_contours=False,\n                  contour_probs=[0.68, 0.95],\n                  contour_color=\"white\",\n                  autoscale=True,\n                  seed=None,\n                  skip_plotting_density=False,\n                  hide_labels=False,\n                  s2_norm=\"standard\",\n                  colormap=cm.rainbow,\n                  s2_rotate_to_true_value=True,\n                  s2_show_gridlines=True,\n                  skip_plotting_samples=False):\n\n    with torch.no_grad():\n      sample_conditional_input = conditional_input\n      if (conditional_input is not None):\n          if (len(conditional_input.shape) == 1):\n              sample_conditional_input = sample_conditional_input.unsqueeze(\n                  0)\n\n          if (sample_conditional_input.shape[0] == 1):\n              sample_conditional_input = sample_conditional_input.repeat(\n                  nsamples, 1)\n\n      if (gridspec is None):\n          gridspec = fig.add_gridspec(1, 1)[0, 0]\n\n      samples, samples_base, evals, evals_base = pdf.sample(\n          samplesize=nsamples,\n          conditional_input=sample_conditional_input,\n          seed=seed)\n\n      higher_dim_spheres = False\n\n      new_subgridspec = plot_joint_pdf(\n          pdf,\n          fig,\n          gridspec,\n          samples,\n          subgridspec=subgridspec,\n          conditional_input=conditional_input,\n          bounds=bounds,\n          multiplot=False,\n          total_pdf_eval_pts=total_pdf_eval_pts,\n          true_values=true_values,\n          plot_only_contours=plot_only_contours,\n          contour_probs=contour_probs,\n          contour_color=contour_color,\n          autoscale=autoscale,\n          skip_plotting_density=skip_plotting_density,\n          hide_labels=hide_labels,\n          s2_norm=s2_norm,\n          colormap=colormap,\n          s2_rotate_to_true_value=s2_rotate_to_true_value,\n          s2_show_gridlines=s2_show_gridlines,\n          skip_plotting_samples=skip_plotting_samples)\n        \n    \n    return samples, new_subgridspec\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_393","text":"<filename>metrics\/wasserstein.py<gh_stars>1-10\nimport numpy as np\nfrom scipy.linalg import sqrtm\n\n\ndef wasserstein_2(P, Q):\n    \"\"\"\n\n    :param P: (m, d) matrix. Reference data\n    :param Q: (n, d) matrix. Distribution we are evaluating\n    :return: float\n    \"\"\"\n\n    P_mean, P_cov = np.mean(P, axis=0), np.cov(P, rowvar=False)\n    Q_mean, Q_cov = np.mean(Q, axis=0), np.cov(Q, rowvar=False)\n\n    QP_diff = Q_mean - P_mean\n    return np.inner(QP_diff, QP_diff) + np.trace(Q_cov + P_cov - 2 * sqrtm(Q_cov @ P_cov))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_396","text":"<reponame>sharechanxd\/Risk-Index-Covid19\ndict_iso={'afghanistan': 'Afghanistan',\n 'albania': 'Albania',\n 'algeria': 'Algeria',\n 'andorra': 'Andorra',\n 'angola': 'Angola',\n 'antigua-and-barbuda': 'Antigua and Barbuda',\n 'argentina': 'Argentina',\n 'armenia': 'Armenia',\n 'aruba': 'Aruba',\n 'australia': 'Australia',\n 'austria': 'Austria',\n 'azerbaijan': 'Azerbaijan',\n 'bahamas': 'Bahamas',\n 'bahrain': 'Bahrain',\n 'bangladesh': 'Bangladesh',\n 'Barbados': 'Barbados',\n 'belarus': 'Belarus',\n 'belgium': 'Belgium',\n 'belize': 'Belize',\n 'benin': 'Benin',\n 'bermuda': 'Bermuda',\n 'bhutan': 'Bhutan',\n 'bolivia': 'Bolivia, Plurinational State of',\n 'bosnia-and-herzegovina': 'Bosnia and Herzegovina',\n 'botswana': 'Botswana',\n 'brazil': 'Brazil',\n 'bulgaria': 'Bulgaria',\n 'burkina-faso': 'Burkina Faso',\n 'burundi': 'Burundi',\n 'cabo-verde': 'Cape Verde',\n 'cambodia': 'Cambodia',\n 'cameroon': 'Cameroon',\n 'canada': 'Canada',\n 'cayman-islands': 'Cayman Islands',\n 'central-african-republic': 'Central African Republic',\n 'chad': 'Chad',\n 'chile': 'Chile',\n 'china': 'China',\n 'china-hong-kong-sar': 'Hong Kong,China',\n 'china-macao-sar': 'Macao,China',\n 'colombia': 'Colombia',\n 'comoros': 'Comoros',\n 'congo': 'Congo',\n 'costa-rica': 'Costa Rica',\n 'cote-d-ivoire': \"Côte d'Ivoire\",\n 'croatia': 'Croatia',\n 'cuba': 'Cuba',\n 'cyprus': 'Cyprus',\n 'czech-republic': 'Czech Republic',\n 'democratic-republic-of-the-congo': 'Congo, the Democratic Republic of the',\n 'denmark': 'Denmark',\n 'djibouti': 'Djibouti',\n 'dominican-republic': 'Dominican Republic',\n 'ecuador': 'Ecuador',\n 'egypt': 'Egypt',\n 'el-salvador': 'El Salvador',\n 'equatorial-guinea': 'Equatorial Guinea',\n 'eritrea': 'Eritrea',\n 'estonia': 'Estonia',\n 'ethiopia': 'Ethiopia',\n 'faeroe-islands': 'Faroe Islands',\n 'fiji': 'Fiji',\n 'finland': 'Finland',\n 'france': 'France',\n 'french-guiana': 'French Guiana',\n 'french-polynesia': 'French Polynesia',\n 'gabon': 'Gabon',\n 'gambia': 'Gambia',\n 'georgia': 'Georgia',\n 'germany': 'Germany',\n 'ghana': 'Ghana',\n 'gibraltar': 'Gibraltar',\n 'greece': 'Greece',\n 'grenada': 'Grenada',\n 'guadeloupe': 'Guadeloupe',\n 'guatemala': 'Guatemala',\n 'guinea': 'Guinea',\n 'guinea-bissau': 'Guinea-Bissau',\n 'guyana': 'Guyana',\n 'haiti': 'Haiti',\n 'honduras': 'Honduras',\n 'hungary': 'Hungary',\n 'iceland': 'Iceland',\n 'india': 'India',\n 'indonesia': 'Indonesia',\n 'iran': 'Iran, Islamic Republic of',\n 'iraq': 'Iraq',\n 'ireland': 'Ireland',\n 'israel': 'Israel',\n 'italy': 'Italy',\n 'jamaica': 'Jamaica',\n 'japan': 'Japan',\n 'jordan': 'Jordan',\n 'kazakhstan': 'Kazakhstan',\n 'kenya': 'Kenya',\n 'kuwait': 'Kuwait',\n 'kyrgyzstan': 'Kyrgyzstan',\n 'latvia': 'Latvia',\n 'lebanon': 'Lebanon',\n 'lesotho': 'Lesotho',\n 'liberia': 'Liberia',\n 'libya': 'Libya',\n 'liechtenstein': 'Liechtenstein',\n 'lithuania': 'Lithuania',\n 'luxembourg': 'Luxembourg',\n 'macedonia': 'North Macedonia',\n 'madagascar': 'Madagascar',\n 'malawi': 'Malawi',\n 'malaysia': 'Malaysia',\n 'maldives': 'Maldives',\n 'mali': 'Mali',\n 'malta': 'Malta',\n 'martinique': 'Martinique',\n 'mauritania': 'Mauritania',\n 'mauritius': 'Mauritius',\n 'mayotte': 'Mayotte',\n 'mexico': 'Mexico',\n 'moldova': 'Moldova, Republic of',\n 'monaco': 'Monaco',\n 'mongolia': 'Mongolia',\n 'montenegro': 'Montenegro',\n 'morocco': 'Morocco',\n 'mozambique': 'Mozambique',\n 'myanmar': 'Myanmar',\n 'namibia': 'Namibia',\n 'nepal': 'Nepal',\n 'netherlands': 'Netherlands',\n 'new-zealand': 'New Zealand',\n 'nicaragua': 'Nicaragua',\n 'niger': 'Niger',\n 'nigeria': 'Nigeria',\n 'norway': 'Norway',\n 'oman': 'Oman',\n 'pakistan': 'Pakistan',\n 'panama': 'Panama',\n 'papua-new-guinea': 'Papua New Guinea',\n 'paraguay': 'Paraguay',\n 'peru': 'Peru',\n 'philippines': 'Philippines',\n 'poland': 'Poland',\n 'portugal': 'Portugal',\n 'qatar': 'Qatar',\n 'reunion': 'Réunion',\n 'romania': 'Romania',\n 'russia': 'Russia',\n 'rwanda': 'Rwanda',\n 'saint-kitts-and-nevis': 'Saint Kitts and Nevis',\n 'saint-lucia': 'Saint Lucia',\n 'sao-tome-and-principe': 'Sao Tome and Principe',\n 'saudi-arabia': 'Saudi Arabia',\n 'senegal': 'Senegal',\n 'serbia': 'Serbia',\n 'seychelles': 'Seychelles',\n 'sierra-leone': 'Sierra Leone',\n 'singapore': 'Singapore',\n 'slovakia': 'Slovakia',\n 'slovenia': 'Slovenia',\n 'somalia': 'Somalia',\n 'south-africa': 'South Africa',\n 'south-korea': 'South Korea',\n 'spain': 'Spain',\n 'sri-lanka': 'Sri Lanka',\n 'state-of-palestine': 'Palestinian Territory, Occupied',\n 'sudan': 'Sudan',\n 'suriname': 'Suriname',\n 'swaziland': 'Swaziland',\n 'sweden': 'Sweden',\n 'switzerland': 'Switzerland',\n 'syria': 'Syrian Arab Republic',\n 'taiwan': 'Taiwan,China',\n 'tajikistan': 'Tajikistan',\n 'tanzania': 'Tanzania, United Republic of',\n 'thailand': 'Thailand',\n 'togo': 'Togo',\n 'trinidad-and-tobago': 'Trinidad and Tobago',\n 'tunisia': 'Tunisia',\n 'turkey': 'Turkey',\n 'turks-and-caicos-islands': 'Turks and Caicos Islands',\n 'uganda': 'Uganda',\n 'uk': 'United Kingdom',\n 'ukraine': 'Ukraine',\n 'united-arab-emirates': 'United Arab Emirates',\n 'uruguay': 'Uruguay',\n 'us': 'United States',\n 'uzbekistan': 'Uzbekistan',\n 'venezuela': 'Venezuela, Bolivarian Republic of',\n 'viet-nam': 'Viet Nam',\n 'western-sahara': 'Western Sahara',\n 'yemen': 'Yemen',\n 'zambia': 'Zambia',\n 'zimbabwe': 'Zimbabwe',\n 'faeroe-islands':'Faroe Islands',\n'saint-vincent-and-the-grenadines':'Saint Vincent & the Grenadines',\n'timor-leste':'Timor-Leste',\n'grenada':'Grenada',\n'new-caledonia':'New Caledonia',\n'laos':'Lao People\\'s Democratic Republic',\n'dominica':'Dominica',\n'falkland-islands-malvinas':'Falkland Islands',\n'greenland':'Greenland',\n'holy-see':'Holy See (Vatican City State)',\n'anguilla':'Anguilla',\n'south-sudan':'South Sudan'\n}\n\ncate={'china':'east asia',\n 'us':'north america',\n 'brazil':'south america',\n 'russia':'eastern europe',\n 'india':'south asia',\n 'uk':'western europe',\n 'spain':'western europe',\n 'peru':'south america',\n 'chile':'south america',\n 'italy':'western europe',\n 'iran':'west asia',\n 'mexico':'central america and mexico',\n 'pakistan':'west asia',\n 'turkey':'west asia',\n 'germany':'western europe',\n 'saudi-arabia':'west asia',\n 'france':'western europe',\n 'south-africa':'southern africa',\n 'bangladesh':'south asia',\n 'canada':'north america',\n 'qatar':'west asia',\n'democratic-republic-of-the-congo':'central africa',\n 'colombia':'south america',\n 'egypt':'south-east mediterranean',\n 'sweden':'western europe',\n 'belarus':'eastern europe',\n 'belgium':'western europe',\n 'argentina':'south america',\n 'ecuador':'south america',\n 'indonesia':'southeast asia',\n 'netherlands':'western europe',\n 'united-arab-emirates':'west asia',\n 'iraq':'west asia',\n 'kuwait':'west asia',\n 'singapore':'southeast asia',\n 'ukraine':'eastern europe',\n 'portugal':'western europe',\n 'oman':'west asia',\n 'philippines':'southeast asia',\n 'poland':'eastern europe',\n 'panama':'central america and mexico',\n 'switzerland':'western europe',\n 'dominican-republic':'caribbean',\n 'afghanistan':'west asia',\n 'bolivia':'south america',\n 'romania':'eastern europe',\n 'bahrain':'west asia',\n 'ireland':'western europe',\n 'armenia':'eastern europe',\n 'nigeria':'west africa',\n 'israel':'south-east mediterranean',\n 'kazakhstan':'central asia',\n 'japan':'east asia',\n 'austria':'western europe',\n 'honduras':'central america and mexico',\n'sao-tome-and-principe':'southeast asia',\n'central-african-republic':'central africa',\n'gabon':'central africa',\n 'ghana':'west africa',\n 'azerbaijan':'central asia',\n 'guatemala':'central america and mexico',\n 'moldova':'eastern europe',\n 'serbia':'eastern europe',\n 'algeria':'south-east mediterranean',\n 'nepal':'south asia',\n 'south-korea':'east asia',\n 'denmark':'western europe',\n 'cameroon':'central africa',\n 'morocco':'south-east mediterranean',\n 'czech-republic':'eastern europe',\n 'sudan':'east africa',\n 'cote-d-ivoire':'west africa',\n 'norway':'western europe',\n 'malaysia':'southeast asia',\n 'uzbekistan':'central asia',\n 'australia':'pacific region',\n 'finland':'western europe',\n 'saint-martin':'caribbean',\n 'senegal':'west africa',\n 'macedonia':'eastern europe',\n 'kenya':'east africa',\n 'el-salvador':'central america and mexico',\n 'guyana':'caribbean',\n 'tajikistan':'central asia',\n 'ethiopia':'east africa',\n 'guinea':'west africa',\n 'venezuela':'south america',\n 'jamaica':'caribbean',\n 'kyrgyzstan':'central asia',\n 'bulgaria':'eastern europe',\n 'djibouti':'east africa',\n 'luxembourg':'western europe',\n 'mauritania':'west africa',\n 'hungary':'eastern europe',\n 'bosnia-and-herzegovina':'eastern europe',\n 'french-guiana':'south america',\n 'grenada':'caribbean',\n 'greece':'western europe',\n 'thailand':'southeast asia',\n 'costa-rica':'central america and mexico',\n 'suriname':'caribbean',\n 'somalia':'east africa',\n 'croatia':'eastern europe',\n 'mayotte':'east africa',\n 'albania':'eastern europe',\n 'cuba':'caribbean',\n 'maldives':'south asia',\n 'nicaragua':'central america and mexico',\n 'equatorial-guinea':'central africa',\n 'mali':'west africa',\n 'paraguay':'south america',\n 'madagascar':'indian ocean islands',\n 'sri-lanka':'south asia',\n 'haiti':'caribbean',\n 'state-of-palestine':'missing',\n 'south-sudan':'east africa',\n 'estonia':'eastern europe',\n 'iceland':'western europe',\n 'lithuania':'eastern europe',\n 'lebanon':'south-east mediterranean',\n 'slovakia':'eastern europe',\n 'guinea-bissau':'west africa',\n 'slovenia':'eastern europe',\n 'zambia':'southern africa',\n 'new-zealand':'pacific region',\n 'sierra-leone':'west africa',\n 'china-hong-kong-sar':'east asia',\n 'tunisia':'south-east mediterranean',\n 'cabo-verde':'west africa',\n 'benin':'west africa',\n 'malawi':'southern africa',\n 'jordan':'south-east mediterranean',\n 'yemen':'west asia',\n 'latvia':'eastern europe',\n 'niger':'west africa',\n 'cyprus':'south-east mediterranean',\n 'burkina-faso':'west africa',\n 'uruguay':'south america',\n 'georgia':'eastern europe',\n 'rwanda':'east africa',\n 'chad':'west africa',\n 'mozambique':'southern africa',\n 'uganda':'east africa',\n 'andorra':'western europe',\n 'swaziland':'southern africa',\n 'liberia':'west africa',\n 'libya':'south-east mediterranean',\n 'malta':'south-east mediterranean',\n 'togo':'west africa',\n 'channel-islands':'western europe',\n 'zimbabwe':'southern africa',\n 'reunion':'indian ocean islands',\n 'tanzania':'southern africa',\n 'montenegro':'eastern europe',\n 'taiwan':'east asia',\n 'viet-nam':'southeast asia',\n 'mauritius':'west africa',\n 'myanmar':'southeast asia',\n 'comoros':'indian ocean islands',\n 'angola':'southern africa',\n 'syria':'south-east mediterranean',\n 'martinique':'eastern europe',\n 'mongolia':'east asia',\n 'cayman-islands':'north america',\n 'eritrea':'east africa',\n 'namibia':'southern africa',\n 'guadeloupe':'caribbean',\n 'gibraltar':'north africa',\n 'burundi':'east africa',\n 'bermuda':'north america',\n 'cambodia':'southeast asia',\n 'bahamas':'caribbean',\n 'monaco':'eastern europe',\n 'botswana':'southern africa',\n 'bhutan':'south asia',\n 'seychelles':'indian ocean islands',\n 'antigua-and-barbuda':'caribbean',\n 'french-polynesia':'pacific region',\n 'china-macao-sar':'east asia',\n 'gambia':'west africa',\n 'turks-and-caicos-islands':'southern africa',\n 'lesotho':'southern africa',\n 'belize':'caribbean',\n 'curacao':'north america',\n 'papua-new-guinea':'pacific region',\n 'western-sahara':'west africa',\n 'fiji':'pacific region',\n 'saint-kitts-and-nevis':'caribbean',\n 'saint-lucia':'caribbean',\n 'congo':'west africa',\n 'trinidad-and-tobago':'caribbean',\n 'faeroe-islands':'western europe',\n 'Barbados':'caribbean',\n 'liechtenstein':'western europe',\n 'aruba':'western europe',\n 'faeroe-islands':'western europe',\n'saint-vincent-and-the-grenadines':'caribbean',\n'timor-leste':'pacific region',\n'grenada':'caribbean',\n'new-caledonia':'pacific region',\n'laos':'southeast asia',\n'dominica':'caribbean',\n'falkland-islands-malvinas':'south america',\n'greenland':'north america',\n'holy-see':'western europe',\n'anguilla':'caribbean',\n }\nfrom tqdm import tqdm\nimport numpy as np\nimport pandas as pd\nfrom bs4 import BeautifulSoup\nimport requests\nimport json\nimport time\nimport random\nimport html5lib\nimport re\nimport scipy.stats as st\nfrom pandas.core.frame import DataFrame\nimport copy\nimport math\nimport os\nimport datetime\n#import datetime\nx0=datetime.date.today()\nx1=datetime.date.today()-datetime.timedelta(days=1)\nx2=datetime.date.today()-datetime.timedelta(days=2)\n# run_time\nts=[]\nts.append(x0.__format__('%Y%m%d'))\nts.append(x1.__format__('%Y%m%d'))\nts.append(x2.__format__('%Y%m%d'))\nprint(ts)\nheaders = { 'Connection': 'close',}\n# proxies={'http':'http:\/\/127.0.0.1:10080','https':'http:\/\/127.0.0.1:10080'}\nurl='https:\/\/www.worldometers.info\/coronavirus\/#countries'\n# url='https:\/\/www.worldometers.info\/coronavirus\/country\/us\/'\na=requests.get(url,headers=headers)\nsoup = BeautifulSoup(a.content,'html5lib')\nx=soup.body.find_all('tr', attrs={'style': ['','background-color:#F0F0F0','background-color:#EAF7D5']})\n# 190 210\ndef find_start_yesterday(i,j):\n    for start in range(i,j):\n        one=x[start]\n        two=x[start+1]\n        l1=one.find_all('a',attrs={'class':'mt_a'})\n        l2=two.find_all('a',attrs={'class':'mt_a'})\n        if l1==[] or l2==[]:\n            continue\n        s1=str(l1[0])\n        s2=str(l2[0])\n        coun1=s1.split('\/')\n        coun2=s2.split('\/')\n        if coun1[1]=='china' and coun2[1]=='us':\n            return start\n#385 410\n# def find_end_yesterday(i,j):\n#     for end in range(i,j):\n#         final_pre=x[end-1]\n#         final=x[end]\n#         l1=final_pre.find_all('a',attrs={'class':'mt_a'})\n#         l2=final.find_all('a',attrs={'class':'mt_a'})\n#         if l1==[] or l2==[]:\n#             continue\n#         s1=str(l1[0])\n#         s2=str(l2[0])\n#         coun1=s1.split('\/')\n#         coun2=s2.split('\/')\n#         if (coun1[1]=='anguilla' and coun2[1]=='saint-pierre-and-miquelon') or (coun2[1]=='anguilla' and coun1[1]=='saint-pierre-and-miquelon'):\n#             return end+1\n\ndef find_end_yesterday(i,j):\n    for end in range(i,j):\n        # final_pre=x[end-1]\n        final=x[end]\n        # l1=final_pre.find_all('a',attrs={'class':'mt_a'})\n        l2=final.find_all('a',attrs={'class':'mt_a'})\n        if l2==[]:\n            continue\n        # s1=str(l1[0])\n        s2=str(l2[0])\n        # coun1=s1.split('\/')\n        coun2=s2.split('\/')\n        if coun2[1]=='anguilla':\n            return end+1\n\nend=find_end_yesterday(400,440)\nend2=find_end_yesterday(630,700)\nstart=find_start_yesterday(190,250)\nstart2=find_start_yesterday(440,470)\nprint('start:{}\\tend:{}\\tstart2:{}\\tend2:{}'.format(start,end,start2,end2))\n\ncol_name=['0','#','Country,Other','TotalCases',\n 'NewCases','TotalDeaths','NewDeaths','TotalRecovered',\n 'NewRecovered','ActiveCases','Serious,Critical','Tot Cases\/1M pop',\n 'Deaths\/1M pop','TotalTests','Tests\/1M pop','Population',\n 'Continent','17',' 1 Caseevery X', 'ppl1 Deathevery',' X ppl1 Testevery ','X ppl','22',\n 'Cases Per 100K Population','Tests Per 100K Population','Active Cases Per 100k Population','Total Test:Positive Ratio',\n 'New Positive%','Case Fatality Rate%','New Confirmed Case Growth Rate','New Death Case Growth Rate','Average daily cases per 100,000 people in the past week',\n 'New Test','NPI','Region','key-id','Country\/District','7 days inc cases','7 days inc deaths']\n\nraw_data=[]\nfor i in tqdm(range(start,end)):\n    text_source=x[i]\n    l=text_source.find_all('a',attrs={'class':'mt_a'})\n    if l==[]:\n        continue\n    s=str(l[0])\n    coun=s.split('\/')\n    try:\n        region=cate[coun[1]]\n        iso=dict_iso[coun[1]]\n    except:\n        region='missing'\n    url='https:\/\/www.worldometers.info\/coronavirus\/country\/'+coun[1]+'\/'\n    print(coun[1])\n    a=''\n    while a=='':\n        try:\n            a=requests.get(url,headers=headers)\n        except:\n            a=''\n    soup = BeautifulSoup(a.content,'html5lib')\n    r=soup.body.find_all('script',attrs={'type':'text\/javascript'})\n    p=re.compile(r'categories: \\[(.*?)\\]',re.S)\n    rs=re.findall(p,r[0].text)\n    d=rs[0]\n    # d=re.sub(r'\\\"','',d)\n    str_pat = re.compile(r'\\\"(.*?)\\\"')\n    d = str_pat.findall(d)\n    date=d\n    p1=re.compile(r'name: \\'Cases\\'.*?\\[(.*?)\\]',re.S)\n    for j in range(10):\n        try:\n            rs=re.findall(p1,r[j].text)\n            d=rs[0]\n            d=re.sub(r'\\\"','',d)\n            case=d.split(',')\n        except:\n            # print('{} cases is not{}'.format(coun[1],j))    \n            continue\n    p1=re.compile(r'name: \\'Deaths\\'.*?\\[(.*?)\\]',re.S)\n    for j in range(10):\n        try:\n            rs=re.findall(p1,r[j].text)\n            d=rs[0]\n            d=re.sub(r'\\\"','',d)\n            TD=d.split(',')\n        except:\n            continue\n    j={'Date':date,'Total Cases':case,'Total Deaths':TD}\n    # print(j)\n    print(\"Date {} TC {} TD {}\".format(len(date),len(case),len(TD)))\n    if not len(set([len(date),len(case),len(TD)])) == 1:\n        continue\n    hist_data_of_coun_i=pd.DataFrame(j)\n    hist_data_of_coun_i['Total Deaths'][0]=0\n    for k in range(len(hist_data_of_coun_i['Total Deaths'])):\n        if hist_data_of_coun_i['Total Deaths'][k]=='null':\n            data['Total Deaths'][k]=0\n    hist_data_of_coun_i['Total Cases']=hist_data_of_coun_i['Total Cases'].astype(int)\n    hist_data_of_coun_i['Total Deaths']=hist_data_of_coun_i['Total Deaths'].astype(int)\n    hist_data_of_coun_i['case inc']=hist_data_of_coun_i['Total Cases'].diff()\n    hist_data_of_coun_i['death inc']=hist_data_of_coun_i['Total Deaths'].diff() \n    #七日新增死亡与cases\n    seven_cases=sum([hist_data_of_coun_i.loc[len(date)-i,'case inc'] for i in range(1,8)])\n    seven_deaths=sum([hist_data_of_coun_i.loc[len(date)-i,'death inc'] for i in range(1,8)])\n       \n    inc1=hist_data_of_coun_i.loc[len(date)-1,'case inc']\/(7*hist_data_of_coun_i.loc[len(date)-8,'case inc'])\n    inc2=hist_data_of_coun_i.loc[len(date)-1,'death inc']\/(7*hist_data_of_coun_i.loc[len(date)-8,'death inc'])\n    \n    inc_1=sum([hist_data_of_coun_i.loc[len(date)-i,'case inc'] for i in range(1,8)])\/sum([hist_data_of_coun_i.loc[len(date)-i,'case inc'] for i in range(8,15)])\n    inc_2=sum([hist_data_of_coun_i.loc[len(date)-i,'death inc'] for i in range(1,8)])\/sum([hist_data_of_coun_i.loc[len(date)-i,'death inc'] for i in range(8,15)])\n    adcp=sum([hist_data_of_coun_i.loc[len(date)-i,'case inc'] for i in range(1,8)])\/7\n    p=1\n    while inc1 ==0 and hist_data_of_coun_i.loc[len(date)-1,'Total Cases']>=10000:\n        p+=1\n        inc1=hist_data_of_coun_i.loc[len(date)-p,'case inc']\/(7*hist_data_of_coun_i.loc[len(date)-1-p,'case inc'])\n    dd=hist_data_of_coun_i.shift(5)\n    hist_data_of_coun_i['inc_p']=np.log(hist_data_of_coun_i['case inc']\/dd['case inc'])\/5\n    hist_data_of_coun_i=hist_data_of_coun_i[~hist_data_of_coun_i.isin([np.nan, np.inf, -np.inf]).any(1)]\n    da=hist_data_of_coun_i['inc_p'].values\n    try:\n        slope,intercept, r_value, p_value, std_err=st.linregress(list(range(30)), da[:30])\n    except:\n        slope=None\n\n    # print(x[i])\n    bo=x[i].text.split('\\n')\n    # print(bo)\n    if bo[6]=='' and bo[7]=='':\n        del bo[7]\n    if bo[17]=='' and bo[18]=='':\n        del bo[18]\n    for o in range(start2,end2):\n        s1=x[o]\n        l1=s1.find_all('a',attrs={'class':'mt_a'})\n        if l1==[]:\n            continue\n        s1=str(l1[0])\n        coun1=s1.split('\/')\n        if coun1[1]==coun[1]:\n            bo1=x[o].text.split('\\n')\n            break\n    for h in range(len(bo)):\n        bo[h]=bo[h].replace(',','')\n        bo[h]=bo[h].replace('+','')\n    for h in range(len(bo1)):\n        bo1[h]=bo1[h].replace(',','')\n        bo1[h]=bo1[h].replace('+','')\n    #Cases Per 100K Population\n    try:\n        bo.append(100000*int(bo[3])\/int(bo[15]))\n    except:\n        print(coun[1])\n        continue\n        # bo.append(np.nan)\n        # print('lack one')\n    #Tests Per 100K Population\n    try: \n        bo.append(100000*int(bo[13])\/int(bo[15]))\n    except:\n        print(coun[1])\n        continue\n        # bo.append(np.nan)\n        # print('lack one')   \n    #'Active Cases Per 100k Population'\n    try:\n        bo.append(int(bo[9])*100000\/int(bo[15]))\n    except:\n        bo.append(np.nan)\n        # print('lack one')\n    \n    #Total Test:Positive Ratio      \n    bo.append(int(bo[3])\/int(bo[13]))\n    #New Positive\n    try:        \n        bo.append((int(bo[3])-int(bo1[3]))\/(int(bo[13])-int(bo1[13])))\n    except:\n        bo.append(np.nan)\n        # print('lack one')\n    #Case Fatality Rate%  \n    try:\n        if bo[5]=='': \n            bo.append(0)\n        else:\n            bo.append(int(bo[5])\/int(bo[3]))\n    except:\n        bo.append(np.nan)\n    #New Confirmed Case Growth Rate\n#     try:\n#         q=2\n#         while (math.isnan(inc1) or inc1==np.inf) and q<=9:\n# #             print(inc1)\n#             inc1=hist_data_of_coun_i.loc[len(date)-q,'case inc']\/(7*hist_data_of_coun_i.loc[len(date)-q-7,'case inc'])  \n#             c=hist_data_of_coun_i.loc[len(date)-q,'case inc']\n#             q+=1\n# #         print(inc1)\n#         if math.isnan(inc1):\n#             bo.append(0)\n#         elif inc1==np.inf:\n#             bo.append(0.01)\n#     #    elif c<=100:\n#     #        bo.append(0.03)\n#         else:\n#             bo.append(inc1)\n#     except:\n#         bo.append(0)\n        # print('lack one')\n    #New Sum Confirmed Case Growth Rate\n    if math.isnan(inc_1) or inc_1=='':\n        bo.append(0)\n    elif inc_1==np.inf:\n        bo.append(0.01)\n    else:\n        bo.append(inc_1)\n    print(bo[-1])\n    #New Death Case Growth Rate   \n#     try:\n#         q=2\n#         while (math.isnan(inc2) or inc2==np.inf) and q<=9:\n# #             print(inc2)\n#             inc2=hist_data_of_coun_i.loc[len(date)-q,'death inc']\/(7*hist_data_of_coun_i.loc[len(date)-q-7,'death inc'])\n#             q+=1\n# #         print(inc2)\n#         if math.isnan(inc2):\n#             bo.append(0)\n#         elif inc2==np.inf:\n#             bo.append(0.1)\n#         else:\n#             bo.append(inc2)\n#     except:\n#         bo.append(0)\n        # print('lack one')\n    #New Sum Death Case Growth Rate\n    if math.isnan(inc_2) or inc_2=='':\n        bo.append(0)\n    elif inc_2==np.inf:\n        bo.append(0.1)\n    else:\n        bo.append(inc_2)\n    print(bo[-1])\n\n    #Average daily cases per 100,000 people in the past week\n    bo.append(adcp*100000\/int(bo[15]))\n\n    # New Test\n    try:\n        bo.append(int(bo[13])-int(bo1[13]))\n    except:\n        bo.append(np.nan)\n        # print('lack one')\n    \n    bo.append(slope)\n    if region=='missing':\n        continue\n    else:\n        bo.append(region)\n    bo.append(coun1[1])\n    bo.append(iso)\n    bo.append(seven_cases)\n    bo.append(seven_deaths)\n    print(len(bo))\n    print(bo)\n    if len(bo)!=39:\n        os.exit(-1)\n    raw_data.append(bo)\nraw_data=DataFrame(raw_data,columns=col_name)\nbrief_raw_data=raw_data[['Country,Other','key-id','Region','Country\/District','Population',\n'TotalCases','ActiveCases','TotalDeaths','NewDeaths','TotalRecovered','NewRecovered','Serious,Critical','NewCases','New Test','Cases Per 100K Population','Tests Per 100K Population',\n'Active Cases Per 100k Population','Total Test:Positive Ratio','New Positive%',\n          'Case Fatality Rate%','New Confirmed Case Growth Rate','New Death Case Growth Rate','Average daily cases per 100,000 people in the past week','NPI','7 days inc cases','7 days inc deaths']]\nbrief_raw_data['week death rate']=brief_raw_data['7 days inc deaths']\/brief_raw_data['7 days inc cases']\ntf=copy.deepcopy(brief_raw_data)\nuni_region=list(set(list(tf['Region'].values)))\n    \nuni_region.remove('western europe')\ndata_region=tf[tf['Region']=='western europe']\ndata_region=data_region.replace(np.nan,'shit')\ndata_region=data_region.replace(np.inf,'shit')\ndata_region=data_region.replace('N\/A','shit')\ndata_region=data_region.replace('',0)\ndata_region=data_region.replace(' ',0)\ndata_region.loc[data_region['NPI']=='shit','NPI']=0\ndata_region.loc[data_region['Case Fatality Rate%']=='shit','Case Fatality Rate%']=0\ndd=data_region[['TotalCases','ActiveCases','TotalRecovered','Case Fatality Rate%']]\nac=dd[(dd['TotalCases']!='shit')&(dd['ActiveCases']!='shit')&(dd['TotalRecovered']!='shit')&(dd['Case Fatality Rate%']!='shit')]\nactive_rate_region=sum(ac['ActiveCases'].astype(int))\/sum(ac['TotalCases'].astype(int))\ndata_region.loc[data_region['Active Cases Per 100k Population']=='shit','Active Cases Per 100k Population']=active_rate_region*100000*data_region.loc[data_region['Active Cases Per 100k Population']=='shit','TotalCases'].astype(int)\/data_region.loc[data_region['Active Cases Per 100k Population']=='shit','Population'].astype(int)\n\ndd=data_region[['NewCases','New Test']]\nac=dd[dd['New Test']!=0]\nnew_posi=sum(ac['NewCases'].astype(int))\/sum(ac['New Test'])\ndata_region.loc[data_region['New Test']==0,'New Positive%']=new_posi\nfinal=copy.deepcopy(data_region)\nfor distri in uni_region:   \n    data_region=tf[tf['Region']==distri]\n    data_region=data_region.replace(np.nan,'shit')\n    data_region=data_region.replace(np.inf,'shit')\n    data_region=data_region.replace('N\/A','shit')\n    data_region=data_region.replace('',0)\n    data_region=data_region.replace(' ',0)\n    data_region.loc[data_region['NPI']=='shit','NPI']=0\n    data_region.loc[data_region['Case Fatality Rate%']=='shit','Case Fatality Rate%']=0\n    dd=data_region[['TotalCases','ActiveCases','TotalRecovered','Case Fatality Rate%']]\n    ac=dd[(dd['TotalCases']!='shit')&(dd['ActiveCases']!='shit')&(dd['TotalRecovered']!='shit')&(dd['Case Fatality Rate%']!='shit')]\n    active_rate_region=sum(ac['ActiveCases'].astype(int))\/sum(ac['TotalCases'].astype(int))\n    data_region.loc[data_region['Active Cases Per 100k Population']=='shit','Active Cases Per 100k Population']=active_rate_region*100000*data_region.loc[data_region['Active Cases Per 100k Population']=='shit','TotalCases'].astype(int)\/data_region.loc[data_region['Active Cases Per 100k Population']=='shit','Population'].astype(int)\n\n    dd=data_region[['NewCases','New Test']]\n    ac=dd[dd['New Test']!=0]\n    try:\n        new_posi=sum(ac['NewCases'].astype(int))\/sum(ac['New Test'])\n    except:\n        new_posi=0\n    data_region.loc[data_region['New Test']==0,'New Positive%']=new_posi\n    data_region.loc[data_region['New Test']=='shit','New Positive%']=new_posi\n    final=pd.concat([final,data_region])\nfinal=final.reset_index(drop=True)\ntf2=final[['Country,Other','key-id','Country\/District','Region','TotalCases','Cases Per 100K Population','Tests Per 100K Population',\n'Active Cases Per 100k Population','Total Test:Positive Ratio','New Positive%',\n          'Case Fatality Rate%','New Confirmed Case Growth Rate','New Death Case Growth Rate','Average daily cases per 100,000 people in the past week','NPI']]\n\n#越高越好，即需要降序\n# for x in ['Cases Per 100K Population','Active Cases Per 100k Population','Total Test:Positive Ratio','New Positive%',]\nx='Tests Per 100K Population'\ndf=copy.deepcopy(tf2[['Country,Other',x]])\ndf2=df.sort_values(x,ascending=False,inplace=False)\ndf2 = df2.reset_index(drop=True)\ndf2['cum']=df.index+1\ndf2['cum_prob']=100*df2['cum']\/max(df2['cum'])\ndf3=pd.merge(df,df2,on=['Country,Other'])\n# tf2['IND_'+x]=df3['cum_prob']\ntf2['IND_'+x]=0\nfor h in list(tf2['Country,Other'].values):\n    tf2.loc[tf2['Country,Other']==h,'IND_'+x]=df3.loc[df3['Country,Other']==h,'cum_prob'].values[0]\n\n\n\nfor x in ['Cases Per 100K Population','Active Cases Per 100k Population','Total Test:Positive Ratio','New Positive%','Case Fatality Rate%','New Confirmed Case Growth Rate','New Death Case Growth Rate','Average daily cases per 100,000 people in the past week','NPI']:\n    i=1\n    df=copy.deepcopy(tf2[['Country,Other',x]])\n    print(x)\n    df2=df.sort_values(x,inplace=False)\n    df2 = df2.reset_index(drop=True)\n    df2['cum']=df.index+1\n    df2['cum_prob']=100*df2['cum']\/max(df2['cum'])\n    df3=pd.merge(df,df2,on=['Country,Other'])\n    tf2['IND_'+x]=0\n    for h in list(tf2['Country,Other'].values):\n        tf2.loc[tf2['Country,Other']==h,'IND_'+x]=df3.loc[df3['Country,Other']==h,'cum_prob'].values[0]\n    i+=1\n\ntf2['Comprehensive Index']=0.15*tf2['IND_Cases Per 100K Population']+0.08*tf2['IND_Tests Per 100K Population']+0.2*tf2['IND_Active Cases Per 100k Population']+0.1*tf2['IND_Total Test:Positive Ratio']+0.13*tf2['IND_New Positive%']+0.05*tf2['IND_Case Fatality Rate%']+ 0.22*tf2['IND_New Confirmed Case Growth Rate']+0.07*tf2['IND_New Death Case Growth Rate']\ntoday=datetime.datetime.now()\ntf4=tf2[['Country\/District','TotalCases','IND_Cases Per 100K Population','IND_Tests Per 100K Population','IND_Total Test:Positive Ratio',\n'IND_New Positive%','IND_Case Fatality Rate%','IND_New Confirmed Case Growth Rate','IND_New Death Case Growth Rate','IND_Active Cases Per 100k Population',\n'IND_NPI','IND_Average daily cases per 100,000 people in the past week','Comprehensive Index']]\ntf_c=copy.deepcopy(tf4)\ntf_c_rename=tf_c.rename({'TotalCases':'TOTAL CASE','IND_Cases Per 100K Population':'IND1_Cases Per 100K Population','IND_Tests Per 100K Population':'IND2_Tests Per 100K Population',\n'IND_Active Cases Per 100k Population':'IND8_Active Cases Per 100k Population','IND_Total Test:Positive Ratio':'IND3_Total Test:Positive Ratio',\n'IND_New Positive%':'IND4_New Positive%','IND_Case Fatality Rate%':'IND5_Case Fatality Rate%','IND_New Confirmed Case Growth Rate':'IND6_New Confirmed Case Growth Rate',\n'IND_New Death Case Growth Rate':'IND7_New Death Case Growth Rate','IND_NPI':'NPI'},axis='columns')\ntf_c_rename.to_excel('World_index_{}.xlsx'.format(today),sheet_name=ts[1],index=False)\ntf2.to_excel('World_raw_index_{}.xlsx'.format(today),sheet_name=ts[1],index=False)\n\nurl='https:\/\/raw.githubusercontent.com\/owid\/covid-19-data\/master\/public\/data\/vaccinations\/vaccinations.csv'\na=requests.get(url,headers=headers)\nwith open(\"vacc.csv\",'wb') as f:\n    f.write(a.content)\nvacc = pd.read_csv('vacc.csv',keep_default_na=False)\nct = list(dict(vacc['location'].value_counts()).keys())\nfor x in ['total_vaccinations','people_vaccinated','people_fully_vaccinated','total_boosters']:\n    vacc[x]=vacc[x].replace('',0)\n    vacc[x]=vacc[x].astype(float)\n    vacc[x]=vacc[x].astype(int)\nimg = dict()\nfor i in ct:\n    dt = vacc[vacc['location']==i]\n    d=[]\n    for x in ['total_vaccinations','people_vaccinated','people_fully_vaccinated','total_boosters']:\n        d.append(max(dt[x]))\n    img[i]=d\nbrief_raw_data['total_vaccinations']=0\nbrief_raw_data['people_vaccinated']=0\nbrief_raw_data['people_fully_vaccinated']=0\nbrief_raw_data['total_boosters']=0\nfor i in img.keys():\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'total_vaccinations'] = int(img[i][0])\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'people_vaccinated'] = int(img[i][1])\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'people_fully_vaccinated'] = int(img[i][2])\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'total_boosters'] = int(img[i][3])\n    \nbrief_raw_data['Population']=brief_raw_data['Population'].astype(int)\nbrief_raw_data['vacc_per_100']=brief_raw_data['total_vaccinations']*100\/brief_raw_data['Population']\nbrief_raw_data['cases_per_100']=brief_raw_data['Cases Per 100K Population']\/1000\nbrief_raw_data['total_immune']=brief_raw_data['cases_per_100']+brief_raw_data['vacc_per_100']*0.9   \n\ndef infer_vaccinated(one_row):\n    if one_row['total_vaccinations']!=0 and one_row['people_vaccinated']==0:\n        one_row['people_vaccinated']=int(0.7018*one_row['total_vaccinations'])\n    if one_row['total_vaccinations']!=0 and one_row['people_fully_vaccinated']==0:\n        one_row['people_fully_vaccinated']=int(0.2936*one_row['total_vaccinations'])\n    return one_row\nbrief_raw_data = brief_raw_data.apply(infer_vaccinated,axis=1)\n\nimport datetime\nfrom datetime import timedelta\nimport sys\nvacc = pd.read_csv('vacc.csv',keep_default_na=False)\nct = list(dict(vacc['location'].value_counts()).keys())\nvacc_daily=copy.deepcopy(vacc)\nvacc_daily['daily_vaccinations']=vacc_daily['daily_vaccinations'].replace('',-1)\nvacc_daily['daily_vaccinations']=vacc_daily['daily_vaccinations'].astype(int)\nvacc_daily = vacc_daily.drop(vacc_daily[vacc_daily['daily_vaccinations']==-1].index)\nvacc_daily['date']=pd.to_datetime(vacc_daily['date']).dt.date\ndaily=dict()\n# vacc_daily.loc[vacc_daily['date']==,'daily_vaccinations']\nfor i in ct:\n    rdd=[]\n    dt = vacc_daily[vacc_daily['location']==i]\n    today=datetime.date.today()\n    try:\n        a=max(dt['date'])\n    #     print(a)\n    #     print(today)\n    #     print(today-timedelta(14))\n#         if today-timedelta(14)<a:\n        x=dt.loc[(dt['date']<=today)&(dt['date']>=today-timedelta(14)),'daily_vaccinations']\n        note = sum(x)\/len(x)\n#         else:\n#             note = -2\n    except:\n        note =-2\n    daily[i]=int(note)\nfor x in ['total_vaccinations','people_vaccinated','people_fully_vaccinated','total_boosters']:\n    vacc[x]=vacc[x].replace('',-1)\n    vacc[x]=vacc[x].astype(float)\n    vacc[x]=vacc[x].astype(int)\nvacc = vacc.drop(vacc[vacc['total_vaccinations']==-1].index)\nvacc['date']=pd.to_datetime(vacc['date'])\nrd=dict()\nfor i in ct:\n    rdd=[]\n    dt = vacc[vacc['location']==i]\n    a=max(dt['date'])\n    b=min(dt['date'])\n    c=a-b\n    Vacc_Days=int(c.days)\n    if Vacc_Days==0:\n        Vacc_Days=1\n    Total_Vacc=int(max(dt['total_vaccinations']))\n    Avg_Vac_Daily=Total_Vacc\/Vacc_Days\n    d=a-timedelta(14)\n    if len(list(dt['date']))==1:\n        Avg_Vac_Last14D=Total_Vacc\n    elif daily[i]==-2:\n        Avg_Vac_Last14D=Total_Vacc\/Vacc_Days\n    else:\n        Avg_Vac_Last14D=daily[i]\n    rdd=[Vacc_Days,Total_Vacc,Avg_Vac_Daily,Avg_Vac_Last14D]\n    rd[i]=rdd        \n    \n\n# lst14days=pd.DataFrame(rd,columns=['Country','Vac_Days','Total_Vac','Avg_Vac_Daily','Avg_Vac_Last14D'])\nbrief_raw_data['累计感染率（%）']=brief_raw_data['Cases Per 100K Population']\/100000\nbrief_raw_data['接种率=（接种疫苗数\/总人口）']=brief_raw_data['vacc_per_100']\/100\nbrief_raw_data['VacSpeed_Last14D']=0.05\nbrief_raw_data['Population']=brief_raw_data['Population'].astype(int)\n\nbrief_raw_data['fully vaccinated %']=100*brief_raw_data['people_fully_vaccinated']\/brief_raw_data['Population']\nbrief_raw_data['at least 1 dose vaccinated %']=100*brief_raw_data['people_vaccinated']\/brief_raw_data['Population']\nbrief_raw_data['Fully Vac Ratio %']=100*brief_raw_data['fully vaccinated %']\/brief_raw_data['at least 1 dose vaccinated %']\n# brief_raw_data['加强针接种率']=brief_raw_data['total_boosters']\/brief_raw_data['Population']\n\nfor i in rd.keys():\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'VacSpeed_Last14D'] = 100*int(rd[i][3])\/brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'Population']\nvaccine_efficacy = pd.read_excel('Vaccine-Country.xlsx',sheet_name='Efficacy')\nvaccine_efficacy = vaccine_efficacy.set_index('Vaccine').T.to_dict('list')\nvaccine_map=pd.read_excel('Vaccine-Country.xlsx',sheet_name='Vac-Mapping')\nvaccine_map = dict(zip(vaccine_map['Location'],vaccine_map['首选疫苗']))\nbrief_raw_data['Vaccine1']='NA'\nbrief_raw_data['Vaccine_Efficacy']=0.8\nfor i in vaccine_map.keys():\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'Vaccine1'] = vaccine_map[i]\n    brief_raw_data.loc[((brief_raw_data['Country,Other']==i)|(brief_raw_data['Country\/District']==i)),'Vaccine_Efficacy'] = vaccine_efficacy[vaccine_map[i]][1]\n\nbrief_raw_data['total_immune_adj']=brief_raw_data['累计感染率（%）']*100+brief_raw_data['vacc_per_100']*brief_raw_data['Vaccine_Efficacy']\/2\nbrief_raw_data['DaystoReachHerdImmunity']=(0.7-brief_raw_data['累计感染率（%）']-brief_raw_data['接种率=（接种疫苗数\/总人口）']*brief_raw_data['Vaccine_Efficacy']\/2)\/(brief_raw_data['VacSpeed_Last14D']*brief_raw_data['Vaccine_Efficacy']*0.01\/2)\n\nimport datetime\ndef change_time(x):\n    in_date = ts[1]\n    # print(x)\n    if x<0:\n        out_date = 'already'\n        return out_date\n    elif math.isinf(x):\n        out_date = 'never'\n        return out_date\n    dt = datetime.datetime.strptime(in_date, \"%Y%m%d\")\n    try:\n        out_date = (dt + datetime.timedelta(days=int(x))).strftime(\"%Y-%m-%d\")\n    except:\n        out_date = 'never'\n    return out_date\n\n# brief_raw_data.to_excel('World_rawdata_test.xlsx')\nbrief_raw_data['HerdImmunityDate']=brief_raw_data['DaystoReachHerdImmunity'].map(change_time)\nbrief_raw_data['Total Boosters']=brief_raw_data['total_boosters']\nbrief_raw_data['加强针接种率']=brief_raw_data['total_boosters']\/brief_raw_data['Population']\nbrief_raw_data.to_excel('World_rawdata_{}.xlsx'.format(today),sheet_name=ts[1],index=False)\n\nuni_region=list(set(list(brief_raw_data['Region'].values)))\nwriter = pd.ExcelWriter('Region_World_Rawdata_{}.xlsx'.format(today))\nfor distri in uni_region:   \n    data_region=brief_raw_data[brief_raw_data['Region']==distri]\n    data_region.to_excel(writer,sheet_name=distri,index=False)\nwriter.save()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_397","text":"#!\/usr\/bin\/env python\n\n\"\"\"\nPlot distances between profiles.\n\n\"\"\"\nfrom __future__ import print_function\n\nfrom optparse import OptionParser\nimport numpy as np\nfrom scipy.spatial.distance import cdist\nimport matplotlib.pyplot as plt\nimport pylab\nimport cpa\nimport sys\nfrom .profiles import Profiles\n\ndef plot_distances(profiles, output_group_name=None):\n    if output_group_name:\n        input_group_r, input_colnames = cpa.db.group_map(profiles.group_name, \n                                                         reverse=True)\n        input_group_r = dict((tuple(map(str, k)), v) \n                             for k, v in input_group_r.items())\n        output_group, output_colnames = cpa.db.group_map(output_group_name)\n        d = {}\n        labels = []\n        for i, k in enumerate(profiles.keys()):\n            groups = [output_group[image] for image in input_group_r[k]]\n            if groups.count(groups[0]) != len(groups):\n                print('Error: Input group %r contains images in %d output groups' % (key, len(set(groups))), file=sys.stderr)\n                sys.exit(1)\n            d.setdefault(groups[0], []).append(i)\n            labels.append(groups[0])\n        ordering = [i for k in sorted(d.keys()) for i in d[k]]\n        labels = list(np.array(labels)[ordering])\n    else:\n        ordering = np.arange(len(profiles.keys))\n        labels = list(np.array(profiles.keys())[ordering])\n    labels = [' '.join(map(str, k)) for k in labels]\n    data = profiles.data[ordering]\n\n    for i in range(len(labels))[:0:-1]:\n        if labels[i] == labels[i - 1]:\n            labels[i] = ''\n\n    fig, ax = plt.subplots()\n    dist = cdist(data, data, 'cosine')\n    axes_image = ax.imshow(dist, cmap=pylab.cm.RdBu, interpolation='nearest')\n    fig.colorbar(axes_image, use_gridspec=True)\n    ax.set_yticks([i for i, l in enumerate(labels) if l != ''])\n    ax.set_yticklabels([l for l in labels if l != ''])\n    for tick in ax.yaxis.iter_ticks():\n        tick[0].label1.set_fontsize(8)\n    ax.set_xticks([i for i, l in enumerate(labels) if l != ''])\n    ax.set_xticklabels(['' for l in labels if l != ''])\n    plt.axis('image')\n    plt.tight_layout()\n    \n\ndef parse_arguments():\n    parser = OptionParser(\"usage: %prog PROPERTIES-FILE INPUT-FILENAME GROUP\")\n    parser.add_option('-o', dest='output_filename', help='file to store the profiles in')\n    options, args = parser.parse_args()\n    if len(args) != 3:\n        parser.error('Incorrect number of arguments')\n    return options, args\n\nif __name__ == '__main__':\n    options, (properties_file, input_filename, group_name) = parse_arguments()\n    cpa.properties.LoadFile(properties_file)\n    profiles = Profiles.load(input_filename)\n    plot_distances(profiles, group_name)\n    if options.output_filename:\n        pylab.savefig(options.output_filename)\n    else:\n        pylab.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_398","text":"<reponame>markflorisson\/minivect\n\"\"\"\nDetermine data dependences between two arbitrary numpy arrays.\nSee thesis\/thesis.pdf section 5.2.\n\"\"\"\n\nimport fractions\n\nimport numpy as np\n\na = np.empty((10, 10))\n\ndef get_start_end(a):\n    start = end = a.ctypes.data\n    for i in range(a.ndim):\n        if a.shape[i] == 0:\n            # Empty array, no overlap possible\n            return 0, 0\n        else:\n            offset = a.strides[i] * (a.shape[i] - 1)\n            if a.strides[i] > 0:\n                end += offset\n            else:\n                start += offset\n\n    return start, end\n\ndef overlap(a, b):\n    \"\"\"\n    >>> overlap(a, a)\n    True\n    >>> overlap(a[:5], a[5:])\n    False\n    >>> overlap(a[:6], a[5:])\n    True\n    >>> overlap(a[2:, 5:], a[5:, :6])\n    True\n    >>> overlap(a[2:3, 5:6], a[2:, 6:])\n    False\n    >>> overlap(a[2:3, 5:6], a[2:, 5:])\n    True\n    \"\"\"\n    start1, end1 = get_start_end(a)\n    start2, end2 = get_start_end(b)\n\n    if start1 < start2:\n        return end1 > start2\n    else:\n        return end2 > start1\n\ndef verify_containment(base, a):\n    base_start, base_end = get_start_end(base)\n    a_start, a_end = get_start_end(a)\n    assert a_start >= base_start and a_end <= base_end\n\ndef verify_base(base, a, b):\n    # verify ndim\n    assert base.ndim == a.ndim\n\n    # verify pointers\n    verify_containment(base, a)\n    verify_containment(base, b)\n\n    # verify strides\n    negative = base.strides[0] < 0\n    for i in range(base.ndim):\n        # base strides may not be 0, and must be either all positive, or all negative\n        assert base.strides[i] != 0\n        assert (base.strides[i] < 0) == negative\n\n        assert a.strides[i] % base.strides[i] == 0, (a.strides[i], base.strides[i])\n        assert b.strides[i] % base.strides[i] == 0, (b.strides[i], base.strides[i])\n\ndef array_order(a, is_base=False):\n    \"\"\"\n    Return the dimension indices corresponding to ascending stride order\n\n    >>> a = np.empty((10, 10, 10), order='C')\n    >>> array_order(a)\n    [2, 1, 0]\n    >>> array_order(a[::-1, ::-1])\n    [2, 1, 0]\n    >>> array_order(a.T)\n    [0, 1, 2]\n    >>> array_order(a.swapaxes(0, 1))\n    [2, 0, 1]\n    \"\"\"\n    stride_index_pairs = zip((abs(stride) for stride in a.strides), range(a.ndim))\n    stride_index_pairs.sort()\n    order = [index for stride, index in stride_index_pairs]\n    if is_base and a.strides[0] < 0:\n        return order[::-1]\n    return order\n\ndef dimensional_independence(a):\n    \"\"\"\n    >>> dimensional_independence(a)\n    >>> dimensional_independence(a[:1, ::2])\n    >>> dimensional_independence(a[::-2, ::-2])\n    >>> d = a.copy()\n    >>> d.strides = (10, 2) # 2 * 10 = 20, so columns overlap with rows\n    >>> dimensional_independence(d)\n    Traceback (most recent call last):\n       ...\n    AssertionError: (10, 18)\n    \"\"\"\n    order = array_order(a)\n    for previous_dim, dim in zip(order, order[1:]):\n        extent = a.strides[previous_dim] * (a.shape[previous_dim] - 1)\n        assert abs(a.strides[dim]) >= abs(extent), (a.strides[dim], extent)\n\ndef verify_dimensional_constraints(base, a, offsets, steps):\n    for i, (offset, step) in enumerate(zip(offsets, steps)):\n        assert 0 <= offset + (a.shape[i] - 1) * step < base.shape[i]\n\ndef offsets(base, a):\n    \"\"\"\n    >>> offsets(a, a[2:, 4:])\n    (2, 4)\n    >>> offsets(a, a[::-1, ::-1])\n    (9, 9)\n    >>> offsets(a, a[::-1])\n    (9, 0)\n    >>> offsets(a, a[:, ::-1])\n    (0, 9)\n    \"\"\"\n    # assert array_order(base) == array_order(a)\n    offsets = [None] * base.ndim\n    distance = a.ctypes.data - base.ctypes.data\n    for dim in reversed(array_order(base, is_base=True)):\n        offsets[dim] = distance \/\/ base.strides[dim]\n        assert 0 <= offsets[dim] < base.shape[dim], (offsets[dim], base.shape[dim])\n        distance = distance % base.strides[dim]\n\n    assert distance == 0\n\n    return tuple(offsets)\n\ndef steps(base, a):\n    steps = []\n    for i in range(base.ndim):\n        steps.append(a.strides[i] \/\/ base.strides[i])\n    return steps\n\ndef verify_solution(base, a, offsets_a, steps_a):\n    slices = []\n    for offset, step, extent in zip(offsets_a, steps_a, a.shape):\n        slices.append(slice(offset, offset + extent * step, step))\n\n    np.all(base[tuple(slices)] == a)\n\ndef verify(base, a, b):\n    \"\"\"\n    >>> verify(a, a[::2, ::2], a[1::2, 1::2])\n    ((0, 0), [2, 2], (1, 1), [2, 2])\n    >>> verify(a, a, a[::-1, ::-1])\n    ((0, 0), [1, 1], (9, 9), [-1, -1])\n    >>> verify(a, a, a[:, ::-1])\n    ((0, 0), [1, 1], (0, 9), [1, -1])\n    >>> verify(a, a[:, ::-1], a[::-1, :])\n    ((0, 9), [1, -1], (9, 0), [-1, 1])\n    >>> verify(a, a[:, 2::2], a[:, 8:0:-2])\n    ((0, 2), [1, 2], (0, 8), [1, -2])\n    \"\"\"\n    assert a.shape == b.shape\n\n    verify_base(base, a, b)\n\n    dimensional_independence(base)\n    dimensional_independence(a)\n    dimensional_independence(b)\n\n\n    offsets_a = offsets(base, a)\n    steps_a = steps(base, a)\n    verify_dimensional_constraints(base, a, offsets_a, steps_a)\n\n    offsets_b = offsets(base, b)\n    steps_b = steps(base, b)\n    verify_dimensional_constraints(base, b, offsets_b, steps_b)\n\n    verify_solution(base, a, offsets_a, steps_a)\n    verify_solution(base, b, offsets_b, steps_b)\n\n    return (offsets_a, steps_a, offsets_b, steps_b)\n\ndef siv(base, a, b, offsets_a, steps_a, offsets_b, steps_b):\n    direction_vector = []\n    for offset_a, offset_b, step_a, step_b, extent in zip(offsets_a, offsets_b,\n                                                          steps_a, steps_b, a.shape):\n        distance = offset_b - offset_a\n        if step_a == step_b:\n            # SIV test\n            if distance % step_a == 0 and abs(distance) < extent:\n                # dependence\n                if distance < 0:\n                    direction_vector.append('>')\n                elif distance == 0:\n                    direction_vector.append('=')\n                else:\n                    direction_vector.append('<')\n            else:\n                # independence\n                return None\n        elif distance % fractions.gcd(step_a, step_b) != 0:\n            # independence\n            return None\n        elif abs(step_a) == abs(step_b):\n            # Weak crossing SIV test\n            i = distance \/ (2*step_a)\n            if i % 0.5 == 0 and 0 <= i < extent:\n                # dependence\n                direction_vector.append('*')\n            else:\n                # independence\n                return None\n        else:\n            # possible dependence, further checking is needed (try banerjee). Remain conservative\n            direction_vector.append('*')\n\n    return tuple(direction_vector)\n\ndef direction_vector(a, b):\n    \"\"\"\n    Returns False in case of independence, or a direction vector if no\n    independence is proven\n\n    >>> [direction_vector(*slice_pair) for slice_pair in slice_pairs]\n    [False, False, False, False, False, False, ('*', '=')]\n\n    # Dependent, test direction vectors\n    >>> direction_vector(a[::2], a[8::-2])\n    ('*', '=')\n    >>> direction_vector(a[::2, 1:5], a[8::-2, 0:4])\n    ('*', '>')\n    >>> direction_vector(a[::2, 1:5], a[8::-2, 2:6])\n    ('*', '<')\n    \"\"\"\n    if not overlap(a, b):\n        return False\n\n    assert a.shape == b.shape\n\n    base = a\n    while base.base is not None:\n        base = base.base\n\n    base_b = b\n    while base_b.base is not None:\n        base_b = base_b.base\n\n    if not (base.ctypes.data == base_b.ctypes.data and\n            base.shape == base_b.shape and\n            base.strides == base_b.strides):\n        return True # assume dependence\n\n    offsets_steps = verify(base, a, b)\n\n    result = siv(base, a, b, *offsets_steps)\n    if result is None:\n        return False # no dependence\n\n    return result # direction vector\n\ndef general_gcd_test(a, b):\n    \"\"\"\n    Returns False in case of independence, otherwise there may or may not\n    be a dependence\n\n    >>> [general_gcd_test(*slice_pair) for slice_pair in slice_pairs]\n    [False, True, False, False, True, True, True]\n    \"\"\"\n    # perform the GCD test without prior transformation\n    if overlap(a, b):\n        gcd = fractions.gcd(reduce(fractions.gcd, a.strides),\n                            reduce(fractions.gcd, a.strides))\n        return (a.ctypes.data - b.ctypes.data) % gcd == 0\n\n    return False\n\n\nslice_pairs = [\n    # independent\n    (a[::2, ::2], a[1::2, 1::2]),\n    (a[::2], a[::-2]),\n    (a[:, ::2], a[:, ::-2]),\n    (a[:5], a[5:]),\n    (a[:, :5], a[:, 5:]),\n    (a[1:3, 4:8], a[2:4, 0:4]),\n    (a[0:4:3], a[2:5:2]), # rows (0, 3) and (2, 4)\n]\n\nif __name__ == '__main__':\n    import doctest\n    doctest.testmod()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_399","text":"<filename>crossval_hyper.py\n#Python2,3 compatible headers\r\nfrom __future__ import unicode_literals,division\r\nfrom builtins import int\r\nfrom builtins import range\r\n\r\n#System packages\r\nimport torch\r\nfrom torch.autograd import Variable,grad\r\nimport torch.nn.functional as F\r\nimport torch.nn as nn\r\nimport torch.optim as optim\r\nimport numpy\r\nimport scipy\r\nimport scipy.misc\r\nimport math\r\nimport time\r\nimport random\r\nimport argparse\r\nimport sys\r\nimport os\r\nimport re\r\nimport copy\r\nimport importlib\r\nfrom collections import namedtuple\r\nfrom collections import OrderedDict\r\nfrom itertools import chain\r\n\r\nimport PIL.Image\r\nimport torchvision.datasets.folder\r\nimport torchvision.transforms.functional as Ft\r\nimport torchvision.transforms as Ts\r\nimport PIL.Image as Image\r\n\r\nimport torch.utils.data.dataloader as myDataLoader\r\nimport skimage.io\r\n\r\nimport util.db as db\r\nimport util.smartparse as smartparse\r\nimport util.file\r\nimport util.session_manager as session_manager\r\nimport dataloader\r\n\r\nimport sklearn.metrics\r\nfrom hyperopt import hp, tpe, fmin\r\n\r\n# Training settings\r\ndef default_params():\r\n    params=smartparse.obj();\r\n    #Data\r\n    params.nsplits=5;\r\n    params.pct=0.8\r\n    #Model\r\n    params.arch='arch.mlpv2';\r\n    params.nh=256;\r\n    params.nlayers=3;\r\n    \r\n    #Optimization\r\n    params.batch=256;\r\n    params.lr=1e-3;\r\n    params.epochs=300;\r\n    params.decay=1e-4;\r\n    \r\n    \r\n    #MISC\r\n    params.session_dir=None;\r\n    params.budget=10000;\r\n    return params\r\n\r\ndef create_session(params):\r\n    session=session_manager.Session(session_dir=params.session_dir); #Create session\r\n    torch.save({'params':params},session.file('params.pt'));\r\n    pmvs=vars(params);\r\n    pmvs=dict([(k,pmvs[k]) for k in pmvs if not(k=='stuff')]);\r\n    print(pmvs);\r\n    util.file.write_json(session.file('params.json'),pmvs); #Write a human-readable parameter json\r\n    session.file('model','dummy');\r\n    return session;\r\n\r\n\r\nparams = smartparse.parse()\r\nparams = smartparse.merge(params, default_params())\r\nparams.argv=sys.argv;\r\n\r\ndata=dataloader.new('data_r4v2.pt');\r\ndata.cuda();\r\nparams.stuff=data.preprocess();\r\n\r\n\r\nsession=create_session(params);\r\nparams.session=session;\r\n\r\n#Hyperparam search config\r\nhp_config=[];\r\n\r\n#   Architectures\r\n#archs=['arch.mlpv2','arch.mlpv3','arch.mlpv4','arch.mlpv5','arch.mlpv6'];\r\narchs=['arch.mlp_set_color_v2xy'];\r\n\r\nhp_config.append(hp.choice('arch',archs));\r\nhp_config.append(hp.qloguniform('nh',low=math.log(16),high=math.log(384),q=4));\r\nhp_config.append(hp.qloguniform('nh2',low=math.log(16),high=math.log(384),q=4));\r\nhp_config.append(hp.quniform('nlayers',low=1,high=10,q=1));\r\nhp_config.append(hp.quniform('nlayers2',low=1,high=10,q=1));\r\nhp_config.append(hp.quniform('nlayers3',low=1,high=10,q=1));\r\n#   OPT\r\nhp_config.append(hp.qloguniform('epochs',low=math.log(5),high=math.log(200),q=1));\r\nhp_config.append(hp.loguniform('lr',low=math.log(1e-4),high=math.log(5e-2)));\r\nhp_config.append(hp.loguniform('decay',low=math.log(1e-6),high=math.log(1e-3)));\r\nhp_config.append(hp.qloguniform('batch',low=math.log(16),high=math.log(64),q=1));\r\n\r\n#Function to compute performance\r\ndef configure_pipeline(params,arch,nh,nh2,nlayers,nlayers2,nlayers3,epochs,lr,decay,batch):\r\n    params_=smartparse.obj();\r\n    params_.arch=arch;\r\n    params_.nh=int(nh);\r\n    params_.nh2=int(nh2);\r\n    params_.nlayers=int(nlayers);\r\n    params_.nlayers2=int(nlayers2);\r\n    params_.nlayers3=int(nlayers3);\r\n    params_.epochs=epochs;\r\n    params_.lr=lr;\r\n    params_.batch=batch;\r\n    params_=smartparse.merge(params_,params);\r\n    return params_;\r\n\r\ncrossval_splits=[];\r\nfor i in range(params.nsplits):\r\n    data_train,data_test=data.generate_random_crossval_split(pct=params.pct);\r\n    data_val,data_test=data_test.generate_random_crossval_split(pct=0.5);\r\n    crossval_splits.append((data_train,data_val,data_test));\r\n\r\nbest_loss_so_far=-1e10;\r\ndef run_crossval(p):\r\n    global best_loss_so_far\r\n    max_batch=16;\r\n    arch,nh,nh2,nlayers,nlayers2,nlayers3,epochs,lr,decay,batch=p;\r\n    params_=configure_pipeline(params,arch,nh,nh2,nlayers,nlayers2,nlayers3,epochs,lr,decay,batch);\r\n    arch_=importlib.import_module(params_.arch);\r\n    #Random splits N times\r\n    auc=[];\r\n    ce=[];\r\n    cepre=[];\r\n    results_by_key={};\r\n    t0=time.time();\r\n    ensemble=[];\r\n    for split_id,split in enumerate(crossval_splits):\r\n        data_train,data_val,data_test=split;\r\n        net=arch_.new(params_).cuda();\r\n        opt=optim.Adam(net.parameters(),lr=params_.lr); #params_.lr\r\n        \r\n        #Train loop\r\n        best_loss=-1e10;\r\n        best_net=copy.deepcopy(net);\r\n        \r\n        for iter in range(params_.epochs):\r\n            net.train();\r\n            loss_total=[];\r\n            for data_batch in data_train.batches(params_.batch,shuffle=True):\r\n                opt.zero_grad();\r\n                net.zero_grad();\r\n                data_batch.cuda();\r\n                C=data_batch['label'];\r\n                data_batch.delete_column('label');\r\n                scores_i=net(data_batch);\r\n                \r\n                #loss=F.binary_cross_entropy_with_logits(scores_i,C.float());\r\n                spos=scores_i.gather(1,C.view(-1,1)).mean();\r\n                sneg=torch.exp(scores_i).mean();\r\n                loss=-(spos-sneg+1);\r\n                #print(float(loss))\r\n                l2=0;\r\n                for p in net.parameters():\r\n                    l2=l2+(p**2).sum();\r\n                \r\n                loss=loss+l2*params_.decay;\r\n                loss.backward();\r\n                loss_total.append(float(loss));\r\n                opt.step();\r\n            \r\n            loss_total=sum(loss_total)\/len(loss_total);\r\n            \r\n            #Eval every epoch \r\n            #net.eval();\r\n            #scores=[];\r\n            #gt=[]\r\n            #for data_batch in data_val.batches(max_batch):\r\n            #    data_batch.cuda();\r\n            #    \r\n            #    C=data_batch['label'];\r\n            #    data_batch.delete_column('label');\r\n            #    scores_i=net(data_batch);\r\n            #    scores.append(scores_i.data.cpu());\r\n            #    gt.append(C.data.cpu());\r\n            \r\n            #scores=torch.cat(scores,dim=0);\r\n            #gt=torch.cat(gt,dim=0);\r\n            \r\n            #auc_i=sklearn.metrics.roc_auc_score(gt.numpy(),scores.numpy());\r\n            #loss_i=float(F.binary_cross_entropy_with_logits(scores,gt.float()));\r\n            #if best_loss<auc_i:\r\n            #    best_loss=auc_i;\r\n            #    best_net=copy.deepcopy(net);\r\n            \r\n            #print('train %.4f, loss %.4f, auc %.4f'%(float(loss_total),float(loss_i),float(auc_i)))\r\n        \r\n        #Temperature-scaling calibration on val\r\n        #net=best_net;\r\n        net.eval();\r\n        scores=[];\r\n        gt=[];\r\n        for data_batch in data_val.batches(max_batch):\r\n            data_batch.cuda();\r\n            \r\n            C=data_batch['label'];\r\n            data_batch.delete_column('label');\r\n            scores_i=net.logp(data_batch);\r\n            scores.append(scores_i.data);\r\n            gt.append(C);\r\n        \r\n        scores=torch.cat(scores,dim=0);\r\n        gt=torch.cat(gt,dim=0);\r\n        \r\n        T=torch.Tensor(1).fill_(0).cuda();\r\n        T.requires_grad_();\r\n        opt2=optim.Adamax([T],lr=3e-2);\r\n        for iter in range(500):\r\n            opt2.zero_grad();\r\n            loss=F.binary_cross_entropy_with_logits(scores*torch.exp(-T),gt.float());\r\n            loss.backward();\r\n            opt2.step();\r\n        \r\n        \r\n        #Eval\r\n        net.eval();\r\n        scores=[];\r\n        scores_pre=[];\r\n        gt=[]\r\n        for data_batch in data_test.batches(max_batch):\r\n            data_batch.cuda();\r\n            \r\n            C=data_batch['label'];\r\n            data_batch.delete_column('label');\r\n            scores_i=net.logp(data_batch);\r\n            \r\n            scores.append((scores_i*torch.exp(-T)).data.cpu());\r\n            scores_pre.append(scores_i.data.cpu());\r\n            \r\n            gt.append(C.data.cpu());\r\n        \r\n        scores=torch.cat(scores,dim=0);\r\n        scores_pre=torch.cat(scores_pre,dim=0);\r\n        gt=torch.cat(gt,dim=0);\r\n        \r\n        def compute_metrics(scores,gt,keys=None):\r\n            if not keys is None:\r\n                #slicing\r\n                categories=set([k for k in keys if not k is None]);\r\n                results={};\r\n                for c in categories:\r\n                    ind=[i for i,k in enumerate(keys) if k==c or k is None];\r\n                    scores_c=[scores[i] for i in ind];\r\n                    gt_c=[gt[i] for i in ind];\r\n                    auc_c,ce_c=compute_metrics(scores_c,gt_c);\r\n                    results[c]={'auc':auc_c,'ce':ce_c};\r\n                \r\n                return results;\r\n            else:\r\n                #Overall\r\n                auc=float(sklearn.metrics.roc_auc_score(torch.LongTensor(gt).numpy(),torch.Tensor(scores).numpy()));\r\n                ce=float(F.binary_cross_entropy_with_logits(torch.Tensor(scores),torch.Tensor(gt)));\r\n                return auc,ce;\r\n        \r\n        auc_i,ce_i=compute_metrics(scores.tolist(),gt.tolist());\r\n        _,ce_pre_i=compute_metrics(scores_pre.tolist(),gt.tolist());\r\n        results_i=compute_metrics(scores.tolist(),gt.tolist(),data_test.data['table_ann']['nclasses'])\r\n        for k in results_i:\r\n            if k in results_by_key:\r\n                results_by_key[k]['auc'].append(results_i[k]['auc'])\r\n                results_by_key[k]['ce'].append(results_i[k]['ce']);\r\n            else:\r\n                results_by_key[k]={'auc':[],'ce':[]};\r\n        \r\n        #results_i=compute_metrics(scores.tolist(),gt.tolist(),data_test.data['table_ann']['arch'])\r\n        #for k in results_i:\r\n        #    if k in results_by_key:\r\n        #        results_by_key[k]['auc'].append(results_i[k]['auc'])\r\n        #        results_by_key[k]['ce'].append(results_i[k]['ce']);\r\n        #    else:\r\n        #        results_by_key[k]={'auc':[],'ce':[]};\r\n        \r\n        results_i=compute_metrics(scores.tolist(),gt.tolist(),data_test.data['table_ann']['trigger'])\r\n        for k in results_i:\r\n            if k in results_by_key:\r\n                results_by_key[k]['auc'].append(results_i[k]['auc'])\r\n                results_by_key[k]['ce'].append(results_i[k]['ce']);\r\n            else:\r\n                results_by_key[k]={'auc':[],'ce':[]};\r\n\r\n        try:\r\n            results_i=compute_metrics(scores.tolist(),gt.tolist(),data_test.data['table_ann']['trigger_subtype'])\r\n        except:\r\n            results_i={};\r\n\r\n        for k in results_i:\r\n            if k in results_by_key:\r\n                results_by_key[k]['auc'].append(results_i[k]['auc'])\r\n                results_by_key[k]['ce'].append(results_i[k]['ce']);\r\n            else:\r\n                results_by_key[k]={'auc':[],'ce':[]};\r\n        \r\n        auc.append(auc_i);\r\n        ce.append(ce_i);\r\n        cepre.append(ce_pre_i);\r\n        session.log('Split %d, loss %.4f (%.4f), auc %.4f, time %f'%(split_id,ce_i,ce_pre_i,auc_i,time.time()-t0));\r\n        \r\n        ensemble.append({'net':net.cpu().state_dict(),'params':params_,'T':float(T.data.cpu())})\r\n        \r\n    \r\n    auc=torch.Tensor(auc);\r\n    ce=torch.Tensor(ce);\r\n    cepre=torch.Tensor(cepre);\r\n    \r\n    if float(auc.mean())>best_loss_so_far:\r\n        best_loss_so_far=float(auc.mean());\r\n        torch.save(ensemble,session.file('model.pt'))\r\n        \r\n    session.log('AUC: %f + %f, CE: %f + %f, CEpre: %f + %f (%s (%d,%d,%d), epochs %d, batch %d, lr %f, decay %f)'%(auc.mean(),2*auc.std(),ce.mean(),2*ce.std(),cepre.mean(),2*cepre.std(),arch,nlayers,nlayers2,nh,epochs,batch,lr,decay));\r\n    \r\n    goal=-float(auc.mean()-2*auc.std());\r\n    \r\n    for k in results_by_key:\r\n        auc=torch.Tensor(results_by_key[k]['auc']);\r\n        ce=torch.Tensor(results_by_key[k]['ce']);\r\n        session.log('\\t KEY %s, AUC: %f + %f, CE: %f + %f'%(k,auc.mean(),2*auc.std(),ce.mean(),2*ce.std()));\r\n    \r\n    return goal;\r\n\r\n\r\n\r\n#Get results from hyper parameter search\r\nbest=fmin(run_crossval,hp_config,algo=tpe.suggest,max_evals=params.budget)\r\n#best=util.macro.obj(best);\r\nparams_=configure_pipeline(**best);\r\nhyper_params_str=json.dumps(best);\r\nsession.log('Best hyperparam (%s)'%(hyper_params_str));\r\n\r\n\r\n\r\n#Load extracted features\r\n#fvs_0=torch.load('fvs.pt');\r\n#fvs_1=torch.load('fvs_1.pt');\r\n#fvs=db.union(db.Table.from_rows(fvs_0),db.Table.from_rows(fvs_1));\r\n#fvs.add_index('model_id');\r\n\r\n#Load labels\r\n#label=[];\r\n#for i in range(200):\r\n#    fname='\/work\/projects\/trojai-example\/data\/trojai-round0-dataset\/id-%08d\/ground_truth.csv'%i;\r\n#    f=open(fname,'r');\r\n#    for line in f:\r\n#        line.rstrip('\\n').rstrip('\\r')\r\n#        label.append(int(line));\r\n#        break;\r\n#    \r\n#    f.close();\r\n\r\n#fvs['label']=label;\r\n#data=db.DB({'table_ann':fvs});\r\n#data.save('data.pt');\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_391","text":"<filename>crystalmaths\/imagetools.py\nimport skimage\nimport functools\nimport os\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.fftpack import fft2, fftshift, ifft\nfrom skimage import img_as_float\nfrom skimage.color import rgb2gray\nfrom scipy.signal import get_window\nfrom skimage import io\nfrom skimage import transform\n\n\ndef setimage(google_shareable_link, output_filename, output_directory):\n    \"\"\"\n    This function is similar to \"show_image\", but it loads image from a\\\\\n     Google Drive instead of local directory.\n    Inputs for the function are:\n    (1) \"Shareable link\" from Google Drive provided as a string.\n        Example: google_shareable_link =\n        'https:\/\/drive.google.com\/open?id=1cFi0rOqN8bcJ7H5fpfPAGS5Rem7TtiII'\n        ***To get the link: go to the file in your Google Drive, right click,\\\\\n        select \"Get Shareable link\".\n    (2) Output file name including file extension provided as a string.\n        Example: output_filename = 'Hexagonal_18.bmp'\n    (3) Output Directory path provided as a string.\n        Example: output_directory = '\/Users\/elenashoushpanova\/Desktop\/'\n    Output is an array of image pixel values, image pixel resolution, as well\\\\\n        as the image itself.\n\n    Note: this function call for \"file_download\" and \"show_image\" functions.\n    \"\"\"\n    # Call for a \"file_download\" function: ############ Will need a name \\\\\n    # change to \"crystalmath.\"\n    dir_file = file_download(google_shareable_link, output_filename,\n                             output_directory)\n\n    # Call for a \"show_image\" function: ############ Will need a name change\\\\\n    #  to \"crystalmath.\"\n    image = show_image(dir_file)\n    return image, image.shape\n\n\ndef show_image(dir_file):\n    \"\"\"\n    This function loads image from a local directory.\n    Input is an image file path.\n    Output is an array of image pixel values, as well as the image itself.\n    \"\"\"\n    image = sio.imread(dir_file)\n    sio.imshow(image)\n    plt.axis('off')\n    return image\n\n\nclass ImageHandler():\n    \"\"\"\n    Class which takes as input an image filepath, turns it into an array, and\n    processes the FFT. Methods include get_planes, get_ratio.\n\n     If user chooses to apply window_type, window will be calculated based\n     on argument provided. New windowed_image_array attribute created.\n     The original array is still used for display purposes and identifying\n     scalebar. But the image_fft will be of the windowed image instead of\n     the original image.\n\n     Todo:\n    - create shifted points attribute which shifts the origin of the fft\n    \"\"\"\n    def __init__(self, image_filepath, window_type=None, scale_ratio=None):\n        self.image_filepath = image_filepath\n        self.image_array = skimage.io.imread(self.image_filepath, as_gray=True)\n        if window_type is not None:\n            window = self.apply_window(window_type)\n            self.windowed_image_array = self.image_array*window\n            image_fft = np.abs(np.fft.fftshift((np.fft.fft2(\n                self.windowed_image_array))))\n            self.image_fft_array = np.log(image_fft)\n        else:\n            image_fft = np.abs(np.fft.fftshift((np.fft.fft2(\n                self.image_array))))\n            self.image_fft_array = np.log(image_fft)\n\n    def show_image(self):\n        fig, axes = plt.subplots(1, 2)\n        axes[0].imshow(self.image_array, cmap='binary_r')\n        axes[0].set_title('Loaded Image')\n        axes[1].imshow(self.image_fft_array, cmap='binary_r')\n        axes[1].set_title('Image FFT')\n        plt.axis('off')\n\n    def get_scale_ratio(self, scale_ratio=None):\n        \"\"\"\n        This function can receive a pixel to nm ratio as its argument, which\\\nskips over defining the scalebar on the figure. If no ratio is provided,\\\nprompt is initiated. This will open up the image_array, and prompt user with\\\ninstructions.\n        \"\"\"\n        if scale_ratio is not None:\n            # assert(type(scale_ratio)==float)\n            self.scale_ratio = float(scale_ratio)\n        else:\n            prompt = 'Define the scalebar position. Pick end points using left\\\nmouse button. Right click once done. Middle mouse button removes most recent\\\npoint.'\n            fig, ax = plt.subplots()\n            plt.setp(plt.gca(), autoscale_on=True)\n            ax.imshow(self.image_array, cmap='binary_r')\n            plt.title(prompt, wrap=True)\n            points = []\n            length_nm = float(input(\"Enter scalebar length in nanometers.\"))\n\n            while len(points) < 2:\n                points = np.asarray(plt.ginput(n=2, show_clicks=True,\n                                    timeout=-1, mouse_add=1, mouse_stop=3,\n                                    mouse_pop=2))\n            length_pixel = np.abs(points[0][0]-points[1][0])\n            print(\"length_nm = \", length_nm)\n            print(\"length_pixel =\", length_pixel)\n            plt.close()\n            self.scale_ratio = length_pixel\/length_nm\n\n    def get_planes(self):\n        prompt = 'Pick two planes using left mouse button. Right click once\\\n done. Middle mouse button removes most recent point.'\n        message = \"Press keyboard button to save points, mouseclick to restart\"\n        print(prompt)\n        fig, ax = plt.subplots()\n        plt.setp(plt.gca(), autoscale_on=True)\n        ax.imshow(self.image_fft_array, cmap='binary_r')\n        # zoom = False\n        # while zoom is not True:\n        while True:\n            plt.title('Perform zoom if necessary, press down arrow key to\\\n continue with plane selection', wrap=True)\n            if plt.waitforbuttonpress(timeout=-1):\n                # zoom = True\n                break\n        while True:\n            plt.title(prompt, wrap=True)\n            fig.canvas.draw()\n            while True:\n                points = plt.ginput(n=2, show_clicks=True, timeout=-1,\n                                    mouse_add=1, mouse_stop=3, mouse_pop=2)\n                break\n            plt.title(message, wrap=True)\n            fig.canvas.draw()\n            print(\"Saved points = \", points)\n            print(message)\n            point_list = []\n            if plt.waitforbuttonpress():\n                for i in range(len(points)):\n                    point_col = int(points[i][0])\n                    point_row = int(points[i][1])\n                    point_list.append([point_col, point_row])\n                raw_point_coordinates = point_list\n                # The center of the image is shifted to index 0,0, to ease\n                # calculation of angles between points downstream.\n                p1, p2 = raw_point_coordinates\n                p1[0] = p1[0] - self.image_array.shape[0]\/2\n                p1[1] = p1[1] - self.image_array.shape[1]\/2\n                p2[0] = p2[0] - self.image_array.shape[0]\/2\n                p2[1] = p2[1] - self.image_array.shape[1]\/2\n                self.point_coordinates = [p1, p2]\n                plt.close()\n                break\n\n    def apply_window(self, window_type):\n        \"\"\"\n        Code taken from scikit-image window function. At time of writing\\\n        this the window function is only available in scikit-image development\\\n        build, and decision was made to not require that for this module.\n\n        This is an optional method which can be called at the time of class\\\n        initialization in order to apply a specified window to the image array\\\n        before performing FFT. The purpose is to reduce image edge and\\\n        scalebar artifacts.\n        \"\"\"\n        shape = self.image_array.shape\n        ndim = len(shape)\n        max_size = functools.reduce(max, shape)\n        w = get_window(window_type, max_size, fftbins=False)\n        w = np.reshape(w, (-1,)+(1,)*(ndim-1))\n\n        # Create coords for warping following `ndimage.map_coordinates`\n        # convention.\n        L = [np.arange(s, dtype=np.float32) * (max_size \/ s) for s in shape]\n\n        center = (max_size\/2)-0.5\n        dist = 0\n        for g in np.meshgrid(*L, sparse=True, indexing='ij'):\n            g -= center\n            dist = dist + g*g\n            dist = np.sqrt(dist)\n            coords = np.zeros((ndim,)+dist.shape, dtype=np.float32)\n            coords[0] = dist + center\n\n        return transform.warp(w, coords, mode='constant')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_394","text":"<gh_stars>1-10\nimport os\nimport json\nimport numpy as np\nfrom pathlib import Path\nfrom scipy import ndimage\nimport SimpleITK as sitk\n\nfrom report_guided_annotation import create_automatic_annotations_for_folder\n\n\ndef test_create_automatic_labels_for_folder():\n    # define input and output folders\n    input_dir = Path(\"tests\/input\/\")\n    output_dir = Path(\"tests\/output\/\")\n\n    # generate report-guided annotations\n    create_automatic_annotations_for_folder(\n        input_dir=input_dir,\n        output_dir=output_dir,\n        threshold='dynamic',\n        skip_if_insufficient_lesions=True,\n        num_workers=4,\n    )\n\n    # verify generated annotations exist\n    assert os.path.exists(output_dir \/ \"ProstateX-0000_07-07-2011-NA-MR prostaat kanker detectie WDSmc MCAPRODETW-05711.nii.gz\")\n\n    # read number of lesions there should be\n    with open(input_dir \/ \"num_lesions_to_retain_map.json\") as fp:\n        num_lesions_to_retain_map = json.load(fp)\n\n    # for each case, check the number of lesions\n    for subject_fn, num_lesions_to_retain in num_lesions_to_retain_map.items():\n        # read automatic annotation\n        automatic_annot = sitk.ReadImage(str(output_dir \/ subject_fn))\n        automatic_annot = sitk.GetArrayFromImage(automatic_annot)\n        _, num_blobs = ndimage.label(automatic_annot, structure=np.ones((3, 3, 3)))\n        assert num_lesions_to_retain == num_blobs\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_395","text":"<reponame>chinesefirewall\/Robotics\n# <NAME>\n# -*- coding: utf-8 -*-\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.optimize as opt\n\n# Fill the lists with your data\nX = [71, 78, 92, 109, 166, 261, 439] # Size [px]\nY = [1800, 1600, 1380, 1100, 700, 400, 200] # Distance [mm]\n\n\ndef blob_size_to_distance(blob_size, a, b):\n    \"\"\"\n    TASK: The cost function which parameters we are looking for, replace with correct function\n    \"\"\"\n\n    dist = (a\/blob_size) + b\n\n    return dist\n\n\nif __name__ == \"__main__\":\n    # The curve fitting happens here\n    optimized_parameters, pcov = opt.curve_fit(\n        blob_size_to_distance,\n        X,\n        Y,\n        bounds=([-np.inf, -np.inf], [np.inf, np.inf])\n    )\n\n    print(optimized_parameters)\n    a = optimized_parameters[0]\n    b = optimized_parameters[1]\n\n    print(\"Optimized parameters:\")\n    print(\"  a = \" + str(a))\n    print(\"  b = \" + str(b))\n\n    # Calculate points with the optimized parameters\n    x_data_fit = np.linspace(min(X), max(X), 100)\n    y_data_fit = blob_size_to_distance(x_data_fit, *optimized_parameters)\n\n    # Plot the data\n    plt.plot(X, Y, \".\", label=\"measured data\")\n    plt.plot(x_data_fit, y_data_fit, label=\"fitted data\")\n\n    # Show the graph\n    plt.legend()\n    plt.xlabel(\"Blob size (px)\")\n    plt.ylabel(\"Distance (mm)\")\n    plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_192","text":"<filename>big_data\/python_tools\/big_data_tools\/bokeh_tools\/find_dist.py\nfrom scipy import stats\nfrom scipy.stats import probplot\nimport math\nimport scipy\nimport numpy as np\nimport pprint\nfrom bokeh.plotting import figure, show\nfrom bokeh.layouts import gridplot\nimport pprint\n# \/home\/henry\/Envs\/class\/lib\/python3.5\/site-packages\/scipy\/stats\/distributions.py\nfrom scipy.stats import distributions\npp = pprint.PrettyPrinter(indent = 4)\n\nD = {'norm': stats.norm,\n    'pareto':stats.pareto,\n    'lognorm':stats.lognorm,\n    'poisson':stats.poisson,\n        }\n\n\ndef sse(y1, y2):\n    return math.sqrt(sum((y1- y2) * (y1- y2))\/len(y1))\n\ndef get_dist(dist_string):\n    return D[dist_string]\n\ndef pp_plot(data, dist, sparams = None, title= None):\n    if not title:\n        title = \"{dist} QQ Plot\".format(dist = dist)\n    series = probplot(data, dist=dist, sparams= sparams)\n    p = figure(title=title)\n    x = series[0][0]\n    y = series[0][1]\n    slope = series[1][0]\n    intercept = series[1][1]\n    y2 = [z * slope + intercept for z in x]\n    p.scatter(series[0][0],series[0][1], fill_color=\"red\")\n    p.line(x,y2, line_width =2)\n    e = sse(series[0][1], y2)\n    return p, e\n\ndef make_pps(data, dist, sparams = None, title= None):\n    if not title:\n        title = \"{dist} QQ Plot\".format(dist = dist)\n    series = probplot(data, dist=dist, sparams= sparams)\n    p = figure(title=title)\n    x = series[0][0]\n    y = series[0][1]\n    slope = series[1][0]\n    intercept = series[1][1]\n    y2 = [z * slope + intercept for z in x]\n    p.scatter(series[0][0],series[0][1], fill_color=\"red\")\n    p.line(x,y2, line_width =2)\n    return p\n\n#this seems wrong with the fit\ndef _make_pps(data, dists):\n    ps = []\n    es = []\n    for i in dists:\n        f = get_dist(i)\n        params = f.fit(data)\n        p, e =pp_plot(data, i, params) \n        ps.append(p)\n        es.append((i, e))\n    grid = gridplot(ps, ncols = 2, height=500, \n            width = 500)\n    show(grid)\n\ndef _find_best(data):\n    least_sse = np.inf\n    best_f = None\n    ps = []\n    for i in ['lognorm', 'pareto', 'norm', 'lognorm']:\n        f = get_dist(i)\n        p = figure(title = i)\n        hist, edges = np.histogram([x for x in data if x < f.ppf(0.99, b)], density=True )\n        ps.append(p)\n        p.quad(top = hist, bottom=0, left=edges[:-1], right=edges[1:], alpha = .4)\n        params = f.fit(data)\n        x = np.linspace(f.ppf(0.01, *params), f.ppf(0.99, *params), len(data))\n        pdf = f.pdf(x, *params)\n        p.line(x, pdf)\n        pdf = f.pdf(x, *params)\n        y, x = np.histogram(data, bins=1000, density=True)\n        e = sse(pdf, y)\n        print(i, e)\n        if e < least_sse:\n            least_sse = e\n            best_f = i\n    grid = gridplot(ps, ncols = 2, height=500, \n            width = 500)\n    show(grid)\n    return least_sse, best_f\n\ndef test_ppf_cdf():\n    \"\"\"ppf is percentiles\"\"\"\n    loc = 0\n    scale =1\n    ppf = .9\n    #inverse functions\n    result = stats.norm.cdf(x= stats.norm.ppf(q= ppf, loc=loc, scale=scale), loc=loc, scale = scale)\n    assert round(ppf,6) == round(result,6)\n    #what is the number for which 90% lies to the left\n    x = stats.norm.ppf(q= .9, loc=loc, scale=scale)\n    #1.28, the Z score for a normal dist\n    #what are lies to the left of 1.28?\n    per = stats.norm.cdf(x=1.28, loc= loc, scale = scale)\n    #.9\n\nif __name__ == '__main__':\n    #b = 2.62\n    #data = stats.pareto.rvs(b, loc = 3, size= 1000)\n    #dists are dir(distributions)\n    data = [.83, .88, .88, 1.4, 1.09, 1.12, 1.29, 1.31,\n            1.48, 1.49, 1.59, 1.62, 1.65, 1.71, 1.83]\n    dists = ['pareto', 'norm', 'lognorm']\n    d = stats.describe(data)\n    test_ppf_cdf()\n    #find_best(data, dists)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_193","text":"from sqlite3.dbapi2 import connect\nfrom data import database_manager as dm\nimport utils \nfrom matplotlib import pyplot\nfrom linear_algebra import curve_fitting as cf\nfrom numpy import arange, greater\nfrom scipy.optimize import curve_fit\n\n#####################################the sqlite section#########################################\n\n# create a connection to the database\nconnection = dm.create_connection(\"longley.db\")\n# To-Do : retrieve rows of the table \nROWS=dm.select_all(connection)\nprint(\"here are the rows of your longley table\")\ndm.print_rows(ROWS)\nprint(len(ROWS))\ndm.close_connection(connection) #close the connection to the db file\n\n#####################################the data type section#######################################\ndata=utils.convert_to_floats(ROWS)\nprint(data) #to see the format \n#####################################the data shape##############################################\nprint(\"the shape of our data is :\",data.shape)\n#####################################the linear algebra section#################################\n\n# Let's check if the two variables GNP.deflator and year  are correlated \ndef objective(x, a, b):\n    \treturn a * x + b\n \n# load the dataset\n\nx, y = data[:, 4], data[:, -1]\n\na, b=cf.get_result(x,y)\n\n# plotting the result \npyplot.scatter(x, y)\n# define a sequence of inputs between the smallest and largest known inputs\nx_line = arange(min(x), max(x), 1)\n# calculate the output for the range\ny_line = cf.set_objective(x_line, a, b)\n# create a line plot for the mapping function\npyplot.plot(x_line, y_line, '--', color='red')\npyplot.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_194","text":"<reponame>Polydynamical\/morfeus\n\"\"\"Pyramidalization code.\"\"\"\n\nimport functools\nimport itertools\nfrom typing import Any, Iterable, List, Optional, Sequence, Union\n\nimport numpy as np\nimport scipy.spatial\n\nfrom morfeus.io import read_geometry\nfrom morfeus.utils import get_connectivity_matrix\n\n\nclass Pyramidalization:\n    \"\"\"Calculates and stores results of pyramidalization and alpha angle.\n\n    As described in Struct. Chem. 1991, 2, 107 and alternatively according to bond\n    angles as in J. Comput. Chem. 2012, 33 (27), 2173–2179.\n\n    Args:\n        coordinates: Coordinates (Å)\n        atom_index: Index of pyramidalized atom (1-indexed)\n        neighbor_indices: Indices of neighbors to pyramidalized atom\n        elements: Elements as atomic symbols or numbers\n        radii: Covalent radii used to determine connectivity (Å)\n        radii_type: Covalent radii type: 'pyykko'\n        excluded_atoms: Indices of atoms to exclude\n        method: Method for detecting neighbors: 'connectivity' or 'distance'. Ignored if\n            neighbor_indices is given.\n\n    Attributes:\n        alpha: Average alpha angle (degrees)\n        alphas: Alpha angles for all permutations of neighbors (degrees)\n        neighbor_indices: Indices of neighbors to pyramidalized atom\n        P_angle: Pyramidalization according to Gavrish\n        P: Pyramidalization according to Radhakrishnan\n    \"\"\"\n\n    alpha: float\n    alphas: np.ndarray\n    neighbor_indices: List[int]\n    P_angle: float\n    P: float\n\n    def __init__(  # noqa: C901\n        self,\n        coordinates: Sequence[Sequence[float]],\n        atom_index: int,\n        neighbor_indices: Optional[Sequence[int]] = None,\n        elements: Optional[Union[Iterable[int], Iterable[str]]] = None,\n        radii: Optional[Sequence[float]] = None,\n        radii_type: str = \"pyykko\",\n        excluded_atoms: Optional[Sequence[int]] = None,\n        method: str = \"distance\",\n        scale_factor: float = 1.2,\n    ) -> None:\n        coordinates = np.array(coordinates)\n        atom_coordinates = coordinates[atom_index - 1]\n\n        if neighbor_indices is None:\n            neighbor_indices = []\n        else:\n            neighbor_indices = list(neighbor_indices)\n\n        if excluded_atoms is None:\n            excluded_atoms = []\n        excluded_atoms = excluded_atoms = np.array(excluded_atoms, dtype=bool)\n\n        # Get 3 closest neighbors\n        if len(neighbor_indices) > 0:\n            if len(neighbor_indices) != 3:\n                raise Exception(f\"Only {len(neighbor_indices)} neighbors.\")\n            neighbors = np.array(neighbor_indices) - 1\n        elif method == \"distance\":\n            # Generate mask for excluded atoms\n            mask = np.zeros(len(coordinates), dtype=bool)\n            mask[excluded_atoms - 1] = True\n            mask[atom_index - 1] = True\n\n            # Get three closest atoms not in the excluded atoms\n            distances = scipy.spatial.distance.cdist(\n                atom_coordinates.reshape(1, -1), coordinates\n            ).reshape(-1)\n            distances[mask] = np.inf\n            neighbors = np.argsort(distances)[:3]\n        elif method == \"connectivity\":\n            # Construct connectivity matrix and get closest neighbors.\n            if elements is None and radii is None:\n                raise Exception(\"Connectivity requires elements or radii.\")\n            # if radii is None:\n            #    radii = get_radii(elements, radii_type=\"pyykko\")\n            connectivity_matrix = get_connectivity_matrix(\n                coordinates,\n                elements=elements,\n                radii=radii,\n                radii_type=radii_type,\n                scale_factor=scale_factor,\n            )\n            connected_atoms = np.where(connectivity_matrix[atom_index - 1, :])[0]\n            neighbors = connected_atoms[~np.isin(connected_atoms, excluded_atoms - 1)]\n            if len(neighbors) != 3:\n                raise Exception(f\"{len(neighbors)} neighbors. 3 expected.\")\n\n        # Get unit vectors between central atom and neighbors\n        a = coordinates[neighbors[0]] - atom_coordinates\n        a \/= np.linalg.norm(a)\n        b = coordinates[neighbors[1]] - atom_coordinates\n        b \/= np.linalg.norm(b)\n        c = coordinates[neighbors[2]] - atom_coordinates\n        c \/= np.linalg.norm(c)\n\n        # Calculate alpha for all permutations\n        alphas = []\n        vectors = []\n        cos_alphas = []\n        thetas = []\n        for v_1, v_2, v_3 in itertools.permutations([a, b, c], 3):\n            # Calculate cos_alpha\n            normal = np.cross(v_1, v_2)\n            normal \/= np.linalg.norm(normal)\n            cos_alpha = np.dot(v_3, normal)\n\n            # Test if normal vector is colinear with v_3\n            if cos_alpha < 0:\n                continue\n            alpha = np.arccos(cos_alpha)\n\n            # Check for \"acute\" pyramid and correct angle\n            v_1_2 = v_1 + v_2\n            v_1_2 \/= np.linalg.norm(v_1_2)\n            cos_angle = np.dot(v_1_2, v_3)\n            if cos_angle > 0:\n                alpha = -alpha\n            alphas.append(alpha)\n            cos_alphas.append(cos_alpha)\n            vectors.append((v_1, v_2))\n\n            # Calculate theta angle\n            cos_theta = np.dot(v_1, v_2)\n            theta = np.rad2deg(np.arccos(cos_theta))\n            thetas.append(theta)\n\n        # Calculate P\n        v_1, v_2 = vectors[0]\n        sin_theta = np.linalg.norm(np.cross(v_1, v_2))\n        P = sin_theta * cos_alphas[0]\n\n        # Correct P if pyramid is \"acute\" on average\n        if np.mean(alphas) < 0:\n            P = 2 - P\n\n        # Calculate P according to Gavrish method\n        P_angle = np.sqrt(360 - sum(thetas))\n\n        # Store attributes\n        self.P = P\n        self.P_angle = P_angle\n        self.alpha = np.rad2deg(np.mean(alphas))\n        self.alphas = np.rad2deg(alphas)\n        self.neighbor_indices = (neighbors + 1).tolist()\n\n    def print_report(self) -> None:\n        \"\"\"Print report of results.\"\"\"\n        print(f\"P: {self.P:.3f}\")\n        print(f\"P_angle: {self.P_angle:.3f}\")\n\n    def __repr__(self) -> str:\n        return f\"{self.__class__.__name__}({round(self.P, 3)!r})\"\n\n\ndef cli(file: str) -> Any:\n    \"\"\"CLI for pyramidalization.\n\n    Args:\n        file: Geometry file\n\n    Returns:\n        Partially instantiated class\n    \"\"\"\n    elements, coordinates = read_geometry(file)\n    return functools.partial(Pyramidalization, coordinates, elements=elements)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_196","text":"#!\/usr\/bin\/env python\n\nimport matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import LogNorm, ListedColormap,BoundaryNorm\nimport numpy as np\nimport datetime as dt\nimport sys, os, pickle, time\nfrom scipy.ndimage.filters import gaussian_filter\nimport pandas as pd\nfrom mpl_toolkits.basemap import *\nfrom sklearn.calibration import CalibratedClassifierCV, calibration_curve\nfrom sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier\nfrom sklearn import metrics\nfrom sklearn.model_selection import train_test_split\nfrom keras.models import Model, save_model, load_model\nfrom keras.layers import Dense, Activation, Conv2D, Input, AveragePooling2D, Flatten, LeakyReLU\nfrom keras.layers import Dropout, BatchNormalization\nfrom keras.regularizers import l2\nfrom keras.optimizers import SGD, Adam\nimport keras.backend as K\nimport tensorflow as tf\nfrom scipy import spatial\nfrom netCDF4 import Dataset\nimport datetime as dt\n\nfrom ml_functions import read_csv_files, normalize_multivariate_data, log, get_features\n\ndef readNCLcm(name):\n    '''Read in NCL colormap for use in matplotlib'''\n    rgb, appending = [], False\n    rgb_dir_ch = '\/glade\/u\/apps\/ch\/opt\/ncl\/6.4.0\/intel\/16.0.3\/lib\/ncarg\/colormaps'\n    fh = open('%s\/%s.rgb'%(rgb_dir_ch,name), 'r')\n\n    for line in list(fh.read().splitlines()):\n        if appending: rgb.append(list(map(float,line.split())))\n        if ''.join(line.split()) in ['#rgb',';RGB']: appending = True\n    maxrgb = max([ x for y in rgb for x in y ])\n    if maxrgb > 1: rgb = [ [ x\/255.0 for x in a ] for a in rgb ]\n    return rgb\n\ndef brier_score_keras(obs, preds):\n    return K.mean((preds - obs) ** 2)\n\ndef brier_skill_score_keras(obs, preds):\n    climo = K.mean((obs - K.mean(obs)) ** 2)\n    bs = brier_score_keras(obs, preds)\n    ratio = (bs \/ climo)\n    return climo\n\ndef auc(obs, preds):\n    auc = tf.metrics.auc(obs, preds)[1]\n    K.get_session().run(tf.local_variables_initializer())\n    return auc\n\ndef bss(obs, preds):\n    bs = np.mean((preds - obs) ** 2)\n    climo = np.mean((obs - np.mean(obs)) ** 2)\n    return 1.0 - (bs\/climo)\n\ndef make_gridded_forecast(predictions, labels, dates, fhr):\n    ### reconstruct into grid by day (mask makes things more complex than a simple reshape)\n    gridded_predictions = np.zeros((num_dates,num_fhr,65*93), dtype=np.float64)\n    gridded_labels      = np.zeros((num_dates,num_fhr,65*93), dtype=np.float64)\n\n    # just grid predictions for this class\n    predictions = predictions.reshape((num_dates, num_fhr, -1))\n    labels      = labels.reshape((num_dates, num_fhr, -1))\n\n    for i, dt in enumerate(unique_forecasts):\n        for j, f in enumerate(unique_fhr):\n            gridded_predictions[i,j,thismask] = predictions[i,j,:]\n            gridded_labels[i,j,thismask]      = labels[i,j,:]\n        #print(dt, gridded_predictions[i,:].max())\n\n    # return only predictions for US points\n    return (gridded_predictions.reshape((num_dates, num_fhr, 65, 93)), gridded_labels.reshape((num_dates, num_fhr, 65, 93)))\n\ndef smooth_gridded_forecast(predictions_gridded):\n    smoothed_predictions = []\n    dim = predictions_gridded.shape\n    for k,s in enumerate(smooth_sigma):\n        if len(dim) == 4: smoothed_predictions.append(gaussian_filter(predictions_gridded, sigma=[0,0,s,s]))\n        if len(dim) == 3: smoothed_predictions.append(gaussian_filter(predictions_gridded, sigma=[0,s,s]))\n\n    # return only predictions for US points\n    return np.array(smoothed_predictions)\n\ndef plot_forecast(predictions, prefix=\"\", fhr=36):\n    test = readNCLcm('MPL_Greys')[25::] + [[1,1,1]] + readNCLcm('MPL_Reds')[10::]\n    #test = readNCLcm('perc2_9lev')[1::]\n    cmap = ListedColormap(test)\n    #cmap = plt.get_cmap('RdGy_r')\n    norm = BoundaryNorm(np.arange(0,1.1,0.1), ncolors=cmap.N, clip=True)\n\n    #print(predictions)\n\n    #awips = Basemap(projection='lcc', llcrnrlon=-133.459, llcrnrlat=12.19, urcrnrlon=-49.38641, urcrnrlat=57.2894, lat_1=25.0, lat_2=25.0, lon_0=-95, resolution='l', area_thresh=10000.)\n\n    #fig, axes, m  = pickle.load(open('\/glade\/u\/home\/sobash\/NSC_scripts\/ch_pk_files\/rt2015_ch_CONUS.pk', 'r'))\n    #fig, axes, m  = pickle.load(open('\/glade\/u\/home\/sobash\/NSC_scripts\/dav_pk_files\/rt2015_ch_CONUS.pk', 'rb'))\n    fig, axes, m = pickle.load(open('rt2015_ch_CONUS.pk', 'rb')) \n\n    lats, lons = predictions['lat'].values, predictions['lon'].values\n    x, y = m(lons, lats)\n\n    # do something convoluted here to only plot each point once\n    probmax = {}\n    for i,p in enumerate(predictions['predict_proba'].values):\n        thiskey = '%f%f'%(lats[i],lons[i])\n        if thiskey in probmax:\n            if p > probmax[thiskey]:\n                probmax[thiskey] = p\n        else:\n           probmax[thiskey] = p\n\n    # need to do this before calling text\n    #m.set_axes_limits(ax=axes)\n\n    for i,p in enumerate(predictions['predict_proba'].values):\n        thiskey = '%f%f'%(lats[i],lons[i])\n        thisvalue = probmax[thiskey]\n\n        color = cmap(norm([thisvalue])[0])\n        probmax[thiskey] = -999\n        if x[i] < m.xmax and x[i] > m.xmin and y[i] < m.ymax and y[i] > m.ymin and thisvalue > 0.05:\n        #if thisvalue >= 0.15:\n            a = axes.text(x[i], y[i], int(round(thisvalue*100)), fontsize=10, ha='center', va='center', family='monospace', color=color, fontweight='bold')\n           # a = axes.text(x[i], y[i], int(round(thisvalue*100)), fontsize=12, ha='center', va='center', family='monospace', color=color, fontweight='bold')\n    #a = m.scatter(x, y, s=50, c=predictions['predict_proba'].values, lw=0.5, edgecolors='k', cmap=cmap, norm=norm)\n\n    ax = plt.gca()\n    cdate = sdate + dt.timedelta(hours=fhr)\n    sdatestr = (cdate - dt.timedelta(hours=2)).strftime('%Y-%m-%d %H:%M:%S UTC')\n    edatestr = (cdate + dt.timedelta(hours=2)).strftime('%Y-%m-%d %H:%M:%S UTC')\n    #plt.text(0,1.01,'Probability of severe within 120-km of a point valid %s - %s'%(sdatestr, edatestr), fontsize=14, transform=ax.transAxes)\n    plt.text(0,1.01,'Max 4-h, 120-km all-severe NNPF over all forecast hours for WRF init %s'%sdate.strftime('%Y%m%d%H'), fontsize=14, transform=ax.transAxes)\n\n    # ADD COLORBAR\n    #cax = fig.add_axes([0.02,0.1,0.02,0.3])\n    #cb = plt.colorbar(a, cax=cax, orientation='vertical', extendfrac=0.0)\n    #cb.outline.set_linewidth(0.5)\n    #cb.ax.tick_params(labelsize=10)\n\n    # plot reflectivity\n    plot_cref = False\n    if plot_cref:\n        initstr = sdate.strftime('%Y%m%d00')\n        wrfcdate = cdate.strftime('%Y-%m-%d_%H_%M_%S')\n        fh = Dataset('\/glade\/p\/mmm\/parc\/sobash\/NSC\/3KM_WRF_POST_12sec_ts\/%s\/diags_d01_%s.nc'%(initstr,wrfcdate), 'r')\n        lats = fh.variables['XLAT'][0,:]\n        lons = fh.variables['XLONG'][0,:]\n        cref = fh.variables['REFL_COM'][0,:]\n        fh.close()\n\n        x, y = m(lons, lats)\n        plt.contourf(x, y, cref, levels=[35,1000], colors='k', alpha=0.5)\n\n    plt.savefig('forecast%s.png'%prefix, dpi=150)\n\ndef make_labels():\n    #labels   = ((df['hail_rptdist'+twin] < d) & (df['hail_rptdist'+twin] > 0)) |  \\\n    labels   = ((df['hailone_rptdist'+twin] < d) & (df['hailone_rptdist'+twin] > 0)) |  \\\n               ((df['wind_rptdist'+twin] < d) & (df['wind_rptdist'+twin] > 0)) | \\\n               ((df['torn_rptdist'+twin] < d) & (df['torn_rptdist'+twin] > 0))\n\n    labels_wind     =  ((df['wind_rptdist'+twin] < d) & (df['wind_rptdist'+twin] > 0))\n    labels_hailone  =  ((df['hailone_rptdist'+twin] < d) & (df['hailone_rptdist'+twin] > 0))\n    labels_torn     =  ((df['torn_rptdist'+twin] < d) & (df['torn_rptdist'+twin] > 0))\n    labels_sighail  =  ((df['sighail_rptdist'+twin] < d) & (df['sighail_rptdist'+twin] > 0))\n    labels_sigwind  =  ((df['sigwind_rptdist'+twin] < d) & (df['sigwind_rptdist'+twin] > 0))\n\n    # labels for multi-class neural network\n    if multiclass: labels = np.array([ labels, labels_wind, labels_hailone, labels_torn, labels_sighail, labels_sigwind ]).T\n    else: labels = np.array([ labels ]).T\n\n    return labels\n\ndef compute_optimal_uh():\n    predictions_gridded_uh, labels_gridded = make_gridded_forecast(uh120_all, labels_all[:,0], dates_all, fhr_all)\n\n    optimal_uh_warmseason, num_rpts_warm = pickle.load(open('\/glade\/work\/sobash\/NSC_objects\/optimal_uh_warmseason', 'rb'))\n    optimal_uh_coolseason, num_rpts_cool = pickle.load(open('\/glade\/work\/sobash\/NSC_objects\/optimal_uh_coolseason', 'rb'))\n\n    #months_all = months_all.reshape((num_dates, num_fhr, -1))\n    #months_all = months_all[:,0,0]\n    #for k,m in enumerate(months_all):\n\n    m = sdate.month  \n    print(num_fhr) \n    if m in [4,5,6,7]: this_uh = ( predictions_gridded_uh >= optimal_uh_warmseason[:num_fhr,:] )\n    else:              this_uh = ( predictions_gridded_uh >= optimal_uh_coolseason[:num_fhr,:] )\n        \n    this_uh = this_uh.reshape((num_fhr,-1))[:,thismask]\n\n    uh_binary = np.array(this_uh).flatten()\n    return uh_binary\n\ndef output_csv(fname):\n    # output probabilities for one forecast\n\n    # output 80-km grid locations\n    #awips = Basemap(projection='lcc', llcrnrlon=-133.459, llcrnrlat=12.19, urcrnrlon=-49.38641, urcrnrlat=57.2894, lat_1=25.0, lat_2=25.0, lon_0=-95, resolution=None, area_thresh=10000.)\n    #lons, lats = awips.makegrid(93, 65)\n    #np.savetxt('grid.out', np.array([lons.flatten(), lats.flatten(), thismask]).T, fmt='%.3f,%.3f,%.0d', header='lon,lat,mask')\n\n    idxarray = np.tile(np.arange(0,93*65)[np.newaxis,:], (num_fhr,1)).flatten()\n    #fhrarray = np.tile(np.arange(1,num_fhr+1)[:,np.newaxis], (1,93*65)).flatten()\n    fhrarray = np.tile(unique_fhr[:,np.newaxis], (1,93*65)).flatten()\n    usmask   = np.tile(thismask[np.newaxis,:], (num_fhr,1)).flatten()\n\n    all_probs = 100*predictions_all_gridded.reshape((7,-1)) #should become (7,num_fhr*93*65)\n    all_probs = np.where(all_probs<1, 0, all_probs)\n\n    # want to only include areas where ANY prob is non-zero and within US mask area (smoothed UH likely has probs outside of US, maybe ML too)\n    probmask =  ( np.any(all_probs, axis=0) & usmask )\n\n    np.savetxt(fname, np.array([idxarray[probmask], fhrarray[probmask], \\\n                                all_probs[0,probmask], all_probs[1,probmask], all_probs[2,probmask], \\\n                                all_probs[3,probmask], all_probs[4,probmask], all_probs[5,probmask], all_probs[6,probmask]]).T, \\\n                            delimiter=',', fmt='%.0d', comments='', header='idx,fhr,psvr,pwind,phail,ptorn,psighail,psigwind,puh')\n\n    #probarray =100*predictions_gridded[fmask,:,:].flatten()\n    #probmask = (probarray >= 1)\n    #np.savetxt('test.out', np.array([idxarray[probmask], fhrarray[probmask], probarray[probmask]]).T, delimiter=',', fmt='%.0d', header='idx,fhr,prob')\n\n### NEURAL NETWORK PARAMETERS ###\n\nnn_params = { 'num_layers': 1, 'num_neurons': [ 1024 ], 'dropout': 0.1, 'lr': 0.001, 'num_epochs': 10, \\\n              'report_window_space':[ 40,120 ], 'report_window_time':[ 2 ] }\n\nrf_params = { 'ntrees': 100, 'max_depth': 20, 'min_samples_split': 20, 'min_samples_leaf': 10 }\n#rf_params = { 'ntrees': 200, 'max_depth': 20, 'min_samples_split': 20 }\n\n#years         =  [2011,2012,2013,2014,2015,2016] #k-fold cross validation for these years\n#years         =  [ int(sys.argv[3]) ]\nmodel         =  sys.argv[2]\nmem           =  1\n\nplot          =  True\n\nmulticlass    =  True\nthin_data     =  True\nthin_fraction =  0.5\nsmooth_probs  =  False\nsmooth_sigma  =  1\nsimple_features = True\ndataset = 'HRRR'\nscaling_dataset = 'HRRR'\nscaling_dataset = 'HRRRX'\nsubset = 'all'\nuse_nschrrr_features = False\nexpname = 'epoch30'\nexpname = 'hrrrv4-epoch30'\n\n#mask  = pickle.load(open('\/glade\/u\/home\/sobash\/2013RT\/usamask.pk', 'rb'))\nmask  = pickle.load(open('\/glade\/work\/sobash\/NSC_objects\/HRRR\/usamask_mod.pk', 'rb'))\nthismask = mask.flatten()\n\ntrained_models_dir = '\/glade\/work\/sobash\/NSC_objects'\ntrained_models_dir = '\/glade\/work\/sobash\/NSC_objects\/trained_models_paper'\ntrained_models_dir = '\/glade\/work\/sobash\/NSC_objects\/HRRR\/trained_models'\n\n#sdate   = dt.datetime(2020,3,2,0,0,0)\n#edate   = dt.datetime(2020,3,2,0,0,0)\nsdate = dt.datetime.strptime(sys.argv[1], '%Y%m%d%H')\nedate = sdate\ndateinc = dt.timedelta(days=1)\n\n##################################\n\nif multiclass: numclasses = 6\nelse: numclasses = 1\ntwin = \"_%dhr\"%nn_params['report_window_time'][0]\n\nfeatures = get_features(subset, use_nschrrr_features)\n\nlog('Number of features %d'%len(features))\nlog(nn_params)\nlog(rf_params)\n\nlog('Reading Data')\n# read data and reassign data types to float32 to save memory\ntype_dict = {}\nfor f in features: type_dict[f]='float32'\ndf, numfcsts = read_csv_files(sdate, edate, dataset)\n\n# restrict hrrr values to min\/max range\n#with open('hrrrv3_minmax') as fh:\n#    for line in fh.read().splitlines()[1:]:\n#        r = line.split(',')\n#        if r[0] in ['fhr', 'xind', 'yind', 'lat', 'lon', 'year', 'month', 'hour', 'dayofyear']: continue        \n#        field, minv, maxv = r[0], float(r[1]), float(r[2])\n#        df.loc[df[field] > maxv, field] = maxv\n#        df.loc[df[field] < minv, field] = minv\n#        #print(field, df[field].min(), df[field].max())\n\nmask  = pickle.load(open('\/glade\/u\/home\/sobash\/2013RT\/usamask.pk', 'rb'))\nmask = mask.reshape((65,93))\n\n# what forecast points to use\nforecast_mask = ( (df['fhr'] >= 1) )\nthese_points = df[forecast_mask]\nyear = sdate.year\n\n#if year > 2016: year = 2016 #use NN without 2016 for any date past 2016\n#year = 2017\nyear = 2020\nyear = 2021\n#year = 2016\n\nclasses = { 0:'all', 1:'wind', 2:'hailone', 3:'torn', 4:'sighail', 5:'sigwind'}\nhazard_type = 0\n\nfhr_all  = df[forecast_mask]['fhr'].values\ndates_all = df[forecast_mask]['Date'].values\nunique_forecasts, unique_fhr = np.unique(dates_all), np.unique(fhr_all)\nsmooth_sigma, num_dates, num_fhr = [2.0], len(unique_forecasts), len(unique_fhr)  \n\nfor d in nn_params['report_window_space']:\n    labels_all = make_labels()\n\n    if model == 'nn':\n        scaling_values = pickle.load(open('\/glade\/work\/sobash\/NSC_objects\/HRRR\/scaling_values_all_%s.pk'%scaling_dataset, 'rb'))\n        norm_in_data, scaling_values = normalize_multivariate_data(df[features].values.astype(np.float32), features, scaling_values=scaling_values)\n        \n        this_in_data = norm_in_data[forecast_mask,:]\n        \n        dense_model = None\n        model_fname = '%s\/neural_network_%s_%dkm%s_nn%d_drop%.1f_%s.h5'%(trained_models_dir,year,d,twin,\\\n                                                                      nn_params['num_neurons'][0],nn_params['dropout'],expname)\n        dense_model = load_model(model_fname, custom_objects={'brier_score_keras': brier_score_keras, 'brier_skill_score_keras':brier_skill_score_keras, 'auc':auc })\n        print('Using', model_fname)\n       \n        predictions_all = dense_model.predict(this_in_data)\n\n        these_points['predict_proba'] = predictions_all[:,hazard_type]    \n\n    if model == 'rf':         \n        this_in_data = these_points[features].values\n\n        model_fname = '%s\/rf_gridded_%s_%dkm%s_n%d_d%d_m%d_l%d.pk'%(trained_models_dir,year,d,twin,rf_params['ntrees'],rf_params['max_depth'],rf_params['min_samples_split'],rf_params['min_samples_leaf'])\n        rf = pickle.load(open(model_fname, 'rb'))\n\n        predictions_all = rf.predict_proba(this_in_data)\n        predictions_all = np.array(predictions_all)[:,:,1].T #needs to be in shape (examples,classes)\n\n        these_points['predict_proba'] = predictions_all[:,hazard_type]\n\n    if d == 40 and twin == '_2hr': uh120_all  = df[forecast_mask]['UP_HELI_MAX-N1T5'].values\n    if d == 80 and twin == '_2hr': uh120_all  = df[forecast_mask]['UP_HELI_MAX80-N1T5'].values\n    if d == 120 and twin == '_2hr': uh120_all = df[forecast_mask]['UP_HELI_MAX120-N1T5'].values\n\n    #uh_binary = compute_optimal_uh()\n    #predictions_gridded_uh, labels_gridded  = make_gridded_forecast((uh_binary).astype(np.int32), labels_all[:,0], dates_all, fhr_all)\n\n    # convert predictions into grid and add UH probs\n    predictions_all_gridded = []\n    for i in range(6):\n        predictions_gridded, labels_gridded = make_gridded_forecast(predictions_all[:,i], labels_all[:,i], dates_all, fhr_all)\n        predictions_all_gridded.append(predictions_gridded)\n    \n    predictions_gridded_uh, labels_gridded  = make_gridded_forecast((uh120_all>75).astype(np.int32), labels_all[:,0], dates_all, fhr_all)\n    predictions_gridded_uh_smoothed = smooth_gridded_forecast(predictions_gridded_uh) \n    predictions_all_gridded.append(predictions_gridded_uh_smoothed[0,:])\n    predictions_all_gridded = np.array(predictions_all_gridded)\n\n    log('Outputting CSV')\n    fname = 'probs_%s_%s_%dkm.out'%(model,sdate.strftime('%Y%m%d%H'),d)\n    output_csv(fname)\n    \n    log('Outputting grib')\n    import write_grib as wg\n    #ofile = \".\/grib\/hrrr_ml_%dkm_2hr_%s.grb\"%(d,sdate.strftime('%Y%m%d%H'))\n    #wg.write_grib(predictions_gridded[0,:,:], sdate, 0, ofile) #write all forecast hours into one file\n\n    # write grib for each hour for each scale, combine hazard probs into one file\n    for i,f in enumerate(unique_fhr):\n        ofile = \".\/grib\/hrrr_ml_%dkm_2hr_%sf%03d.grb\"%(d,sdate.strftime('%Y%m%d%H'), f)\n        wg.write_grib(predictions_all_gridded[:6,0,i-1,:], sdate, f, ofile) #output first 6 elements (ignore UH)\n\nlog('Finished')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_197","text":"\"\"\"\nFollowing functions are specific to the analysis of the data saved\nwith BELLA control system\n\"\"\"\n\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport os\nimport glob\nimport re\nfrom numpy import unravel_index\nimport numpy as np\nfrom scipy import stats\nimport json\nfrom functions.data_analysis import df_outlier2none\n\ndef get_data(dir_date, nscan=None, para=None, trim_std=None):\n    '''Get DataFrame \n    dir_date: directory of a date where scan data is stored (str)\n    nscan: list of scan number(int)\n    para_list: list of parameters(str).No need to write the full name.\n    '''\n    path = get_scan_path(dir_date, nscan)\n    df = get_data_from_path(path, para)\n    \n    #parameters to consider getting rid of outliers...(don't consider scan)\n    para_vals = list(df.columns)\n    if 'scan' in para_vals:\n        para_vals.remove('scan')\n    if 'DateTime Timestamp' in para_vals:\n        para_vals.remove('DateTime Timestamp')\n    if 'Shotnumber' in para_vals:\n        para_vals.remove('Shotnumber')\n    \n    #get rid of outliers\n    if trim_std:\n        df_new = df_outlier2none(df, std=trim_std, columns = para_vals )\n    return df\n\n\ndef get_files_list(dirpath,f_format):\n    \"\"\"\n    get get path of all files with f_format in the directory\n    dir_date: directory path\n    f_format: ex) txt\n    \"\"\"\n    return sorted(glob.glob(dirpath+'\/*.'+f_format))\n    \n\ndef get_notebook_name():\n    \"\"\"\n    Return the full path of the jupyter notebook.\n    \"\"\"\n    import ipykernel\n    import requests\n    from requests.compat import urljoin\n    from notebook.notebookapp import list_running_servers\n    \n    kernel_id = re.search('kernel-(.*).json',\n                          ipykernel.connect.get_connection_file()).group(1)\n    servers = list_running_servers()\n    for ss in servers:\n        response = requests.get(urljoin(ss['url'], 'api\/sessions'),\n                                params={'token': ss.get('token', '')})\n        for nn in json.loads(response.text):\n            if nn['kernel']['id'] == kernel_id:\n                relative_path = nn['notebook']['path']\n                return os.path.join(ss['notebook_dir'], relative_path)\n\ndef save_dataframe(df, name, ipynb = None):\n    '''save dataframe under data\/\"current ipython name\"\/'''\n    \n    #get the file name of ipynb\n    if ipynb == None:\n        ipynb_fullpath = get_notebook_name()\n        ipynb = os.path.splitext(os.path.basename(ipynb_fullpath))[0]    \n    \n    #Open the data folder if doesnt exist\n    if not os.path.exists('data_ipynb'):\n        os.makedirs('data_ipynb')\n    if not os.path.exists('data_ipynb\/'+ipynb):\n        os.makedirs('data_ipynb\/'+ipynb)\n    #Save data\n    df.to_pickle('data_ipynb\/'+ipynb+'\/'+name+'.pkl')\n    print(name+' saved')\n    return None\n\ndef load_dataframe(name, ipynb = None):\n    \"\"\"load dataframe which was saved using the function save_dataframe\n    name: correspons to the name of the daframe you sppecified with save_dataframe\n    ipynb: the ipynb name you are running. If None, it will be automatically aquired. (NOt working sometime).\n    \"\"\"\n    #get the file name of ipynb\n    if ipynb == None:\n        ipynb_fullpath = get_notebook_name()\n        ipynb = os.path.splitext(os.path.basename(ipynb_fullpath))[0]\n    load_path = 'data_ipynb\/'+ipynb+'\/'+name+'.pkl'\n    \n    df = pd.read_pickle(load_path)\n    print(name+' loaded')\n    return df\n    \ndef get_data_from_path(path_list, para_list = None):\n    '''Get DataFrame from the file.\n    path_list: a filename or list of multiple filenames. they will append all data sets.\n    para_list: list of parameters (column names) you want to select from dataframe\n    output: dataframe\n    '''\n    data_list = []\n    for i in range(len(path_list)):\n        data_i = pd.read_csv(path_list[i], sep='\\t')\n        if para_list:\n            #get full name of the parameters\n            para_list_full = []\n            for j in para_list:\n                para_full = par_full(path_list[i], j)\n                if para_full:\n                    para_list_full = para_list_full+[para_full]\n            #If you can get all parameters, append the data of the scan\n            if len(para_list_full) == len(para_list):\n                data_i = data_i[para_list_full]\n                data_list.append(data_i)\n            else:\n                print('Skip saving data from', os.path.basename(path_list[i]))\n        else:\n            #if there is no para_list, get all the parameters that are saved\n            data_list.append(data_i)\n                        \n    data = pd.concat(data_list, sort=False)\n    \n    #rename column names to alias if exists\n    for col in data.columns:\n        if 'Alias:' in col:\n            alias = col.split('Alias:', 1)[1]\n            data = data.rename(columns={col:alias})\n    return data\n\ndef get_nscan_last(dir_date):\n    '''Get the last scan number which is already done'''\n    path = dir_date + '\\\\analysis'\n    if not os.path.isdir(path):\n        return 0\n    else:\n        # get last scan info file name\n        files = glob.glob(path + '\\\\s*info.txt')\n        file_last = os.path.basename(files[-1])\n        # regexp. find number in the file name\n        n_scans = int(re.findall(r\"\\d+\", file_last)[0])\n        return n_scans\n    \ndef get_scan_path(dir_date, nscan=None):\n    '''\n    Get a path of the scan file s**.txt in the analysis \n    nscan: List or int of scan number. if None, creat a list of all scan text paths\n    '''\n\n    #if nscan_list=None, make a list of all scan #s\n    if not nscan:\n        nscan_last = get_nscan_last(dir_date)\n        nscan_list = range(1, nscan_last+1)\n    elif isinstance(nscan, int):\n        nscan_list = [nscan]\n    else:\n        nscan_list = nscan\n    path_list = []\n    #make a list of all scan file paths\n    for i in nscan_list:\n        path = dir_date + '\\\\analysis\\\\s' + str(i) + '.txt'\n        path_list = path_list + [path]\n    return path_list\n    \ndef par_full(file, par):\n    '''get a full name of the parameter'''\n\n    data = pd.read_csv(file, sep='\\t')\n    indices = [k for k, s in enumerate(list(data)) if par in s]\n    if not indices or data.empty:\n        print(par, 'not found in', os.path.basename(file))\n        return None\n    elif len(indices) > 1:\n        for j in indices:\n            if list(data)[j]==par:\n                return list(data)[j]\n        raise NameError('Please Specify the Name. Several parameters match for ',par,list( list(data)[i] for i in indices )  )\n        return None\n    else:\n        return list(data)[indices[0]]\n\ndef show_time_xaxis():\n    '''X axis changed from timestamp to day time of california when you plot a graph with time stamp on x axis.\n    '''\n    from datetime import datetime\n    summer20_start = datetime.timestamp(datetime(2020,3,8,3,0))\n    summer20_end = datetime.timestamp(datetime(2020,11,1,2,0))\n    # get current axis\n    ax = plt.gca()\n    # get current xtick labels\n    xticks = ax.get_xticks()\n    if xticks[0] > summer20_start and xticks[0] <summer20_end:\n        xticks = xticks - 7*60*60\n    else:\n        xticks = xticks - 8*60*60\n    # convert all xtick labels to selected format from ms timestamp\n    ax.set_xticklabels([pd.to_datetime(tm, unit='s').strftime('%Y-%m-%d\\n %H:%M:%S') for tm in xticks],\n     rotation=50)\n    return None\n\ndef get_calib(Dict, device, axis = None):\n    '''Get paramters from calibration dictionary\n    device: device name except axis (drop off the X or Y in the device name)'''\n    \n    if device in Dict:\n        #get target position\n        try: target = Dict[device]['target'][axis]\n        except: target = 0\n\n        #get sign (positive or negative)\n        try: sign = Dict[device]['sign'][axis]\n        except: sign = 1\n\n        #get calibration\n        try: calib = Dict[device]['calib'][axis]\n        except: \n            try: calib = Dict[device]['calib']\n            except: calib = 1\n        \n        #get unit\n        try: unit = ' ('+Dict[device]['unit']+')'\n        except: unit = ''\n        \n        return target, sign, calib, unit\n            \n    #if 2ndmomW0, get calibration data from centroid data\n    elif device.split()[1]=='2ndmomW0' or '2ndmom' or '2mdmom' or 'FWHM':\n        device_centroid = device.split()[0]+' centroid'\n        return get_calib(Dict, device_centroid)\n    \n    else:\n        print('can not find a calibration for ', device)\n        return None, None, None, None\n    \ndef PT_time(lvtimestamp):\n    '''\n    Conert the labview timestamp to pacific time.\n    lvtimestamp: labview timestamp (float). should be 10 digit (36...)\n    \"'''\n    lv_dt = datetime.fromtimestamp(lvtimestamp) #labview time\n    utc_dt = lv_dt - relativedelta(years=66, days=1) #UTC time\n    #convert to Pacific time\n    ca_tz = timezone('America\/Los_Angeles')\n    ca_date = utc_dt.astimezone(ca_tz)\n\n    return ca_date\n    \n\ndef df_calib(df, Dict):\n    '''Return a new dataframe with calibrated values. Only those with calibration saved in Dict are stored in the\n    output dataframe.\n    df: DataFrame\n    Dict: calibration dictionary. It's in a separate file\n    ''' \n    #parameters of the DataFrame\n    para = df.columns\n    #define a new dataframe\n    df_new = pd.DataFrame()\n    \n    #get device name and axis for the camera\n    for i in para:\n        #if camera device\n        if i[:3]=='UC_':  \n            #if add column is used, strip ..T..., and find axis\n            if i.find(' T ') > -1:\n                axis = i[i.find(' T ')-1]\n                device = i[:i.find(' T ')-1].rstrip() #get rid of space in the end if exist\n            #if the name ends with x or y\n            elif i[-1]=='x' or i[-1]=='y':\n                axis = i[-1]\n                device=i[:-1]\n            else:\n                axis=''\n                device = i\n                print('cant identify the parameter ',i)\n                \n            #get the calibration and convert to the calibrated data\n            target, sign, calib, unit = get_calib(Dict, device, axis)\n            para_new = device[3:]+axis+unit\n            df_new[para_new]=sign*(df[i]-target)*calib                \n                        \n        #non camera device but exists in calibration dictionary\n        elif i in Dict:\n            if i[:2]=='U_':\n                df_new[i[2:]] = df[i]\n            else:\n                target, sign, calib, unit = get_calib(Dict, i)\n                df_new[i+unit] = sign*(df[i]-target)*calib\n                \n        #if it's timestamp\n        elif i=='DateTime Timestamp':            \n            df_new['DateTime (Pacific Time)'] = PT_time(df[i])\n        \n        else:\n            print('can not find a calibration data for ', para[i])\n    \n    if len(df_new.columns) < len(para):\n        print( len(para) - len(df_new.columns), 'parameters not saved to the calibrated dataframe' )\n    return df_new\n\n\n    \n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_198","text":"\"\"\"\n@ Author: ryanreadbooks\n@ Time: 9\/4\/2020, 19:51\n@ File name: metrics.py\n@ File description: some metric functions for calculating the scores\n\"\"\"\n\nimport math\nfrom typing import Tuple\n\nimport numpy as np\nfrom utils import project_3d_2d, transform_pts\nimport scipy.spatial as scipy_spatial\n\n\ndef mask_iou(pred: np.ndarray, truth: np.ndarray) -> float:\n\t\"\"\"\n\tCalculate the iou between two mask\n\t:param pred: the predicted mask, shape (h, w), with the value of masked region to be  1, background to be value 0\n\t:param truth: the ground truth mask, shape (h, w), with the value of masked region to be 1, background to be value 0\n\t:return: iou between these two masks\n\t\"\"\"\n\tintersection = np.logical_and(truth, pred)\n\tunion = np.logical_or(truth, pred)\n\tiou = np.sum(intersection) \/ np.sum(union)\n\treturn iou\n\n\ndef mask_miou(pred: np.ndarray, truth: np.ndarray) -> float:\n\t\"\"\"\n\tCalculate the mean IoU between masks\n\t:param pred: the predicted mask, shape (n, h, w)\n\t:param truth: the ground truth mask, shape (n, h ,w)\n\t:return: the mean IoU\n\t\"\"\"\n\tintersection: np.ndarray = np.logical_and(truth, pred).sum(axis=1).sum(axis=1)\n\tunion: np.ndarray = np.logical_or(truth, pred).sum(axis=1).sum(axis=1)\n\tious: np.ndarray = intersection \/ union\n\treturn ious.mean()\n\n\ndef calculate_add(pred_pose: np.ndarray, gt_pose: np.ndarray, points: np.ndarray) -> float:\n\tr\"\"\"\n\tCalculate the ADD metric. This metrics is more strict to the predicted pose\n\t:math:`ADD = \\sum[(R * x + T) - (R_p * x + T_p)] \/ m`\n\n\t:param pred_pose: the predicted pose, array with shape (3, 4), [R|t]\n\t:param gt_pose: the ground truth pose, array with shape (3, 4), [R|t]\n\t:param points: the model points to be transformed, array with shape (n, 3), n is the number of points\n\t:return: the ADD value\n\t\"\"\"\n\tpoints_pred: np.ndarray = transform_pts(points, pred_pose)\n\tpoints_gt: np.ndarray = transform_pts(points, gt_pose)\n\n\treturn np.linalg.norm(points_gt - points_pred, axis=1).mean()\n\n\ndef calculate_add_s(pred_pose: np.ndarray, gt_pose: np.ndarray, points: np.ndarray) -> float:\n\tr\"\"\"\n\tCalculate the ADD-S metric. This metric is less strict than ADD metric\n\t:math:`ADD-S = \\sum_{x1 \\in {M}}{min_{x2 \\in{M}} (R * x1 + T)-(R_p * x2 + T_p)} \/ m`\n\n\t:param pred_pose: the predicted pose, array with shape (3, 4), [R|t]\n\t:param gt_pose: the ground truth pose, array with shape (3, 4), [R|t]\n\t:param points: the model points to be transformed\n\t:return: the ADD-S value\n\t\"\"\"\n\n\tpoints_pred: np.ndarray = transform_pts(points, pred_pose)\n\tpoints_gt: np.ndarray = transform_pts(points, gt_pose)\n\tkdtree: scipy_spatial.cKDTree = scipy_spatial.cKDTree(points_pred)\n\tquery_result: Tuple[np.ndarray, np.ndarray] = kdtree.query(points_gt)  # query result: distances, index at points_pred\n\tnearest_distances = query_result[0]\n\tadd_s: float = nearest_distances.mean()\n\n\treturn add_s\n\n\ndef rotation_error(r_pred: np.ndarray, r_gt: np.ndarray) -> float:\n\t\"\"\"\n\tcalculate the rotation error between two rotation matrix.\n\toriginal implementation from https:\/\/github.com\/thodan\/bop_toolkit\/blob\/master\/bop_toolkit_lib\/pose_error.py\n\tmath is from Rodrigue's formula.\n\t:param r_pred: the predicted rotation matrix, shape of (3, 3)\n\t:param r_gt: the ground truth rotation matrix, shape of (3, 3)\n\t:return: the calculated error between them\n\t\"\"\"\n\tassert (r_pred.shape == r_gt.shape == (3, 3)), 'ground truth and predicted value must be of the same shape (3, 3)'\n\terror_cos = float(0.5 * (np.trace(r_pred.dot(np.linalg.inv(r_gt))) - 1.0))\n\n\t# Avoid invalid values due to numerical errors.\n\terror_cos = min(1.0, max(-1.0, error_cos))\n\n\terror = math.acos(error_cos)\n\terror = 180.0 * error \/ np.pi  # Convert [rad] to [deg].\n\treturn error\n\n\ndef translation_error(t_pred: np.ndarray, t_gt: np.ndarray) -> float:\n\t\"\"\"\n\tcalculate the translation error between two translation vector\n\toriginal implementation from https:\/\/github.com\/thodan\/bop_toolkit\/blob\/master\/bop_toolkit_lib\/pose_error.py\n\t:param t_pred: predicted translation vector, size of 3\n\t:param t_gt: ground truth translation vector, size of 3\n\t:return: the computed translation error\n\t\"\"\"\n\tassert (t_gt.size == t_pred.size == 3), 'invalid size for translation vector'\n\terror = np.linalg.norm(t_gt - t_pred)\n\treturn error\n\n\ndef projection_error(pts_3d: np.ndarray, camera_k: np.ndarray, pred_pose: np.ndarray, gt_pose: np.ndarray):\n\t\"\"\"\n\tAverage distance of projections of object model vertices [px]\n\t:param pts_3d: model points, shape of (n, 3)\n\t:param camera_k: camera intrinsic matrix, shape of (3, 3)\n\t:param pred_pose: predicted rotation and translation, shape (3, 4), [R|t]\n\t:param gt_pose: ground truth rotation and translation, shape (3, 4), [R|t]\n\t:return: the returned error, unit is pixel\n\t\"\"\"\n\t# projection shape (n, 2)\n\tpred_projection: np.ndarray = project_3d_2d(pts_3d=pts_3d, camera_intrinsic=camera_k, transformation=pred_pose)\n\tgt_projection: np.ndarray = project_3d_2d(pts_3d=pts_3d, camera_intrinsic=camera_k, transformation=gt_pose)\n\terror = np.linalg.norm(gt_projection - pred_projection, axis=1).mean()\n\treturn error\n\n\ndef check_pose_correct(val1: float, threshold1: float, metric: str, diameter: float = 0., val2: float = 0., threshold2: float = 0.):\n\t\"\"\"\n\tCheck if the pose_pred should be considered correct with respect to pose_gt based on the metric\n\t:param val1: value to check\n\t:param threshold1: threshold that determine the values are correct or not\n\t:param metric: criteria, add, add-s, projection error, 5cm5°\n\t:param diameter: in add(-s), you need diameter of the object\n\t:param val2: optional argument for 5cm5° metric\n\t:param threshold2: optional argument for 5cm5° metric\n\t:return: pose_pred should be considered correct of not. correct -> True, incorrect -> False\n\t\"\"\"\n\tif metric == 'add' or metric == 'add-s':\n\t\tassert diameter != 0\n\t\tif val1 <= threshold1 * diameter:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False\n\telif metric == '5cm5':\n\t\tif val1 <= threshold1 and val2 <= threshold2:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False\n\telif metric == 'projection':\n\t\tif val1 < threshold1:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_199","text":"<reponame>PiotrBenedysiuk\/qucat<filename>tests\/test_core.py\nimport sys\nimport os\nsys.path.append(os.path.join(os.path.join(os.path.dirname(os.path.dirname(__file__)),'src')))\nimport unittest\nimport core\nfrom math import isclose\nimport numpy as np\nfrom scipy.constants import e, pi, h, hbar\n\n# Run plt.ion() to avoid hanging on plt.show() calls\nimport matplotlib.pyplot as plt\nplt.ion()\n\ndef cutoff_digits(f,digits):\n    float_format = '%%.%de'%digits\n    return float(float_format%(np.real(f))) + 1j*float(float_format%(np.imag(f)))\n\nclass TestCaseAppended(unittest.TestCase):\n\n    def assertRelativelyClose(self,a,b,digits = 6):\n        a = cutoff_digits(a,digits)\n        b = cutoff_digits(b,digits)\n        self.assertEqual(a,b)\n\n    def assertArrayRelativelyClose(self,a,b,digits = 6):\n        a = np.array(a)\n        b = np.array(b)\n        self.assertTrue(a.shape==b.shape,msg = f'Arrays do not have the same dimension {a.shape}!={b.shape}')\n        for index,_ in np.ndenumerate(a):\n            a_comp = cutoff_digits(a[index],digits)\n            b_comp = cutoff_digits(b[index],digits)\n            self.assertEqual(a_comp,b_comp,\n                    msg = f'Components with index {index} do not match {a_comp}!={b_comp}')\n    \n    def open_gui_file(self,filename, edit = False, print_network=False,plot=False):\n        return core.GUI(os.path.join(\n            os.path.dirname(__file__),\n            'gui_testing_files',\n            filename),\n            edit = edit, print_network=print_network,plot=plot)\n\nclass SeriesRLC(TestCaseAppended):\n    '''\n    Series RLC circuit parameters\n    '''\n\n    def parameters(self,R,L,C):\n        circuit = core.Network([\n            core.C(0,1,C),\n            core.L(1,2,L),\n            core.R(0,2,R)\n        ])\n        return circuit.f_k_A_chi()\n\n    def test_frequency(self):\n        C = 100e-15\n        L = 10e-9\n        R = 100e-9\n        w,k,A,chi = self.parameters(R,L,C)\n        cpx_w = (1j*C*R + np.sqrt(4*C*L - C**2*R**2))\/(2.*C*L)\n        self.assertRelativelyClose(np.real(cpx_w)\/2\/np.pi,w)\n\n    def test_frequency2(self):\n        C = 1\n        L = 3\n        R = 0.5\n        w,k,A,chi = self.parameters(R,L,C)\n        cpx_w = (1j*C*R + np.sqrt(4*C*L - C**2*R**2))\/(2.*C*L)\n        self.assertRelativelyClose(np.real(cpx_w)\/2\/np.pi,w)\n\n\n    def test_dissipation(self):\n        C = 100e-15\n        L = 10e-9\n        R = 100e-9\n        w,k,A,chi = self.parameters(R,L,C)\n        cpx_w = (1j*C*R + np.sqrt(4*C*L - C**2*R**2))\/(2.*C*L)\n        self.assertRelativelyClose(np.imag(cpx_w)\/2\/np.pi,k)\n\nclass Other(TestCaseAppended):\n    def test_LC_double_series_L_double_series_C(self):\n        C = 1e-8\n        L = 3\n        circuit = core.Network([\n            core.C(0,1,C*2),\n            core.C(1,2,C*2),\n            core.L(2,3,L\/2),\n            core.L(3,0,L\/2)\n        ])\n        f,k,A,chi = circuit.f_k_A_chi()\n        f_expected = 1\/np.sqrt(L*C)\/2\/np.pi\n        self.assertRelativelyClose(f_expected,f)\n        \nclass Transmon(TestCaseAppended):\n    '''\n    Transmon circuit parameters\n    '''\n\n    def parameters(self,C,Lj):\n        circuit = core.Network([\n            core.C(0,1,C),\n            core.J(0,1,Lj)\n        ])\n        return circuit.f_k_A_chi()\n\n    def test_frequency(self):\n        C = 100e-15\n        Lj = 10e-9\n        w,k,A,chi = self.parameters(C,Lj)\n        self.assertRelativelyClose(1\/(np.sqrt(C*Lj)*2.*pi),w)\n\n    def test_anharmonicity(self):\n        C = 100e-15\n        Lj = 10e-9\n        w,k,A,chi = self.parameters(C,Lj)\n        self.assertRelativelyClose(e**2\/2.\/C\/h,A[0])\n\n    def test_phi_zpf(self):\n        Cj = 100e-15\n        Lj = 10e-9\n        junction = core.J(0,1,Lj)\n        circuit = core.Network([\n            core.C(0,1,Cj),\n            junction,\n            core.R(0,1,1e6)\n        ])\n        phi_0 = hbar\/2\/e\n        Z = np.sqrt(Lj\/Cj)\n        phi_zpf = np.sqrt(hbar*Z\/2)\n        self.assertRelativelyClose(phi_zpf\/phi_0,junction.zpf(mode=0,quantity = 'flux'))\n\n        \n    def test_q_zpf(self):\n        Cj = 100e-15\n        Lj = 10e-9\n        junction = core.J(0,1,Lj)\n        circuit = core.Network([\n            core.C(0,1,Cj),\n            junction,\n            core.R(0,1,1e6)\n        ])\n        Z = np.sqrt(Lj\/Cj)\n        q_zpf = np.sqrt(hbar\/Z\/2)\n        self.assertRelativelyClose(q_zpf\/e,np.absolute(junction.zpf(mode=0,quantity = 'charge')))\n\n    def test_anharmonicity_using_hamiltonian(self):\n        Cj = 1e-10\n        circuit = core.Network([\n            core.C(0,1,Cj),\n            core.J(0,1,10e-9)\n        ])\n        H = circuit.hamiltonian(modes = [0],taylor = 4,excitations = [10])\n        ee = H.eigenenergies()\n        A = np.absolute((ee[1]-ee[0])-(ee[2]-ee[1]))\n        # Due to higher order terms, the mismatch with e**2\/2\/Cj\/h is\n        # (193702.3+0j) != (194712.7+0j)\n        A_expected = 194712.7\n        self.assertRelativelyClose(A_expected,A)\n\n    def test_double_series_capacitor(self):\n        C = 100e-15\n        Lj = 10e-9\n        circuit = core.Network([\n            core.C(0,1,C*2),\n            core.C(1,2,C*2),\n            core.J(0,2,Lj)\n        ])\n        f,k,A,chi = circuit.f_k_A_chi()\n        self.assertArrayRelativelyClose([e**2\/2.\/C\/h,1\/(np.sqrt(C*Lj)*2.*pi)],[A[0],f[0]])\n\nclass ShuntedJosephsonRing(TestCaseAppended):\n    '''\n    Shunted Josephson ring\n    '''\n    \n    def parameters(self,C,L):\n        circuit = core.Network([\n            core.C(0,2,C),\n            core.C(1,3,C),\n            core.J(0,1,L),\n            core.J(1,2,L),\n            core.J(2,3,L),\n            core.J(3,0,L)\n        ])\n        return circuit.f_k_A_chi()\n\n    def test_number_of_modes_nHz(self):\n        C = 2.e9\n        L = 3.e11\n        w,k,A,chi = self.parameters(C,L)\n        self.assertEqual(len(w),2,msg = f\"f_res = {w}\")\n    def test_number_of_modes_Hz(self):\n        C = 2.\n        L = 3. \n        w,k,A,chi = self.parameters(C,L)\n        self.assertEqual(len(w),2,msg = f\"f_res = {w}\")\n\n    def test_number_of_modes_GHz(self):\n        C = 1e-13\n        L = 1e-8\n        w,k,A,chi = self.parameters(C,L)\n        self.assertEqual(len(w),2,msg = f\"f_res = {w}\")\n\n    def test_frequency_0(self):\n        C = 1e-13\n        L = 1e-8\n        w,k,A,chi = self.parameters(C,L)\n        self.assertRelativelyClose(w[0],1\/np.sqrt(L*C)\/2.\/np.pi)\n\n    def test_frequency_1(self):\n        C = 1e-13\n        L = 1e-8\n        w,k,A,chi = self.parameters(C,L)\n        self.assertRelativelyClose(w[1],1\/np.sqrt(L*C)\/2.\/np.pi)\n\n    def test_anharmonicity_0(self):\n        C = 1e-13\n        L = 1e-8\n        w,k,A,chi = self.parameters(C,L)\n        self.assertRelativelyClose(A[0],e**2\/2.\/(8*C)\/h)\n\n    def test_anharmonicity_1(self):\n        C = 1e-13\n        L = 1e-8\n        w,k,A,chi = self.parameters(C,L)\n        self.assertRelativelyClose(A[1],e**2\/2.\/(8*C)\/h)\n\nclass CoupledTransmonRLC(TestCaseAppended):\n    '''\n    Coupled transmon\/RLC\n    '''\n    def test_sweeping_LJ_in_fkAchi(self):\n        cir = core.Network([\n            core.C(0,1,100e-15),\n            core.J(0,1,'L_J'),\n            core.C(1,2,1e-15),\n            core.C(2,0,100e-15),\n            core.L(2,0,10e-9),\n            core.R(2,0,1e6)\n            ])\n        [cir.f_k_A_chi(L_J=x) for x in [1e-9,2e-9]]\n\nclass TestGraphics(TestCaseAppended):   \n\n    def test_error_when_trying_to_plot_from_Network_show(self):\n        circuit = core.Network([\n            core.C(0,1,'C'),\n            core.J(0,1,'Lj')\n        ])\n        with self.assertRaises(TypeError):\n            circuit.show()\n            \n    def test_error_when_trying_to_plot_from_Network_show_normal_modes(self):\n        circuit = core.Network([\n            core.C(0,1,'C'),\n            core.J(0,1,'Lj')\n        ])\n        with self.assertRaises(TypeError):\n            circuit.show_normal_mode()\n        \n    def test_generate_graphics(self):\n        import _generate_graphics\n    \n    def test_show_transmon_RLC(self):\n        cir=self.open_gui_file('show_normal_mode_transmon_RLC_Lj_as_parameter.txt')\n        cir.show()\n\n    def test_show_normal_mode_transmon_RLC_Lj_as_parameter(self):\n        cir=self.open_gui_file('show_normal_mode_transmon_RLC_Lj_as_parameter.txt')\n        for quantity in ['flux','voltage','charge','current']:\n            cir.show_normal_mode(0,quantity,Lj=1e-9)\n\nclass TestNetworkAnalysis(TestCaseAppended):\n\n    def test_transfer_left_right_port_identical(self):\n        '''\n        Trivial cases\n        '''\n        net = core._Network([core.R(0,1,'Z2')])\n        self.assertEqual(net.transfer(0,1,0,1),1)\n\n    def test_transfer_left_right_port_indentical_inverted(self):\n        '''\n        Trivial cases\n        '''\n        net = core._Network([core.R(0,1,'Z2')])\n        self.assertEqual(net.transfer(0,1,1,0),-1)\n\n    def test_transfer_voltage_divider(self):\n        '''\n        Voltage divider, see:\n        https:\/\/en.wikipedia.org\/wiki\/Voltage_divider\n        We add an extra resistor between Vin and ground\n        '''\n\n        # Compute the bridge transfer function\n        net = core._Network([\n            core.R(0,1,'Z2'),\n            core.R(1,2,'Z1'),\n            core.R(2,0,'Zg'),\n            ])\n        transfer = net.transfer(0,2,0,1)\n\n        # What the tranfer function should be\n        def transfer_theory(Z1,Z2,Zg):\n            return Z2\/(Z1+Z2)\n\n        # Define some numerical values\n        # for the resistors\n        test_parameters = {\n            'Z1':1,\n            'Z2':2,\n            'Zg':3\n        }\n        \n        self.assertRelativelyClose(\n            transfer.evalf(subs = test_parameters),\n            transfer_theory(**test_parameters))\n\n    def test_transfer_wheatstone(self):\n        '''\n        Wheatstone bridge, see:\n        https:\/\/en.wikipedia.org\/wiki\/Wheatstone_bridge\n        Note that the correct definitions of the voltages V_G and V_S can be found here:\n        http:\/\/www.ece.lsu.edu\/ee4770\/1999\/lsli04.4up.pdf\n        '''\n\n        # Compute the bridge transfer function\n        net = core._Network([\n            core.R(0,1,'R_3'),\n            core.R(1,2,'R_x'),\n            core.R(2,3,'R_2'),\n            core.R(3,0,'R_1'),\n            ])\n        transfer = net.transfer(0,2,3,1)\n\n        # What the tranfer function should be\n        def transfer_theory(R_1,R_2,R_3,R_x):\n            return R_2\/(R_1+R_2)-R_x\/(R_x+R_3)\n\n        # Define some numerical values\n        # for the bridge resistors\n        test_parameters = {\n            'R_1':1,\n            'R_2':2,\n            'R_3':3,\n            'R_x':4,\n        }\n\n        self.assertRelativelyClose(\n            transfer.evalf(subs = test_parameters),\n            transfer_theory(**test_parameters))\n\n    def test_transfer_wheatstone_all_equal(self):\n        '''\n        Case where all resistors of the bridge are equal, and\n        there is potential for these lines:\n            A_lattice = (Ya + Yb)*(Yd + Yc)\/(Ya*Yd-Yb*Yc)\n            B_lattice = (Ya + Yb + Yc + Yd)\/(Ya*Yd-Yb*Yc)\n        to raise an error.\n        Note: I made sure with a break-point that this code\n        actually calls those two lines.\n        '''\n\n        # Compute the bridge transfer function\n        net = core._Network([\n            core.R(0,1,'R_3'),\n            core.R(1,2,'R_x'),\n            core.R(2,3,'R_2'),\n            core.R(3,0,'R_1'),\n            ])\n        transfer = net.transfer(0,2,3,1)\n\n        # Define some numerical values\n        # for the bridge resistors\n        test_parameters = {\n            'R_1':1,\n            'R_2':1,\n            'R_3':1,\n            'R_x':1,\n        }\n\n        # We just run this to check wether it raises an error\n        transfer.evalf(subs = test_parameters)\n\n    def test_transfer_square_symmetrical_lattice(self):\n        '''\n        Square symmetrical lattice\n        '''\n\n        # Compute the transfer function\n        left_minus = 0 \n        left_plus = 1\n        right_minus = 2\n        right_plus = 3\n        net = core._Network([\n            core.R(left_minus,left_plus,'Zs'),\n            core.R(right_minus,right_plus,'Zl'),\n            core.Admittance(left_minus,right_plus,0),\n            core.Admittance(right_minus,left_plus,0),\n            core.R(left_minus,right_minus,'Za'),\n            core.R(right_plus,left_plus,'Za')\n            ])\n        transfer = net.transfer(left_minus,left_plus,right_minus,right_plus)\n\n        # What the tranfer function should be\n        def transfer_theory(Zs,Zl,Za):\n            return Zl\/(2*Za+Zl)\n\n        # Define some numerical values\n        # for the resistors\n        test_parameters = {\n            'Zs':1,\n            'Zl':2,\n            'Za':3,\n        }\n\n        self.assertRelativelyClose(\n            transfer.evalf(subs = test_parameters),\n            transfer_theory(**test_parameters))\n\n    def test_open_or_series_check(self):\n        with self.assertRaises(ValueError):\n            net = core._Network([\n                core.R(0,1,'Z'),\n                core.C(1,2,'Z'),\n                core.J(2,3,'Z'),\n                ])\n\n    def test_connectivity_check_single_element_not_connected(self):\n        with self.assertRaises(ValueError):\n            net = core._Network([\n                core.R(0,1,'Z'),\n                core.C(1,2,'Z'),\n                core.J(3,4,'Z'),\n                ])\n    def test_connectivity_check_subcircuit_not_connected(self):\n        with self.assertRaises(ValueError):\n            net = core._Network([\n                core.R(0,1,'Z'),\n                core.C(1,2,'Z'),\n                core.J(3,4,'Z'),\n                core.J(3,4,'Z'),\n                core.J(4,5,'Z'),\n                ])\n\nif __name__ == \"__main__\":\n    unittest.main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_201","text":"<gh_stars>1-10\n#!\/usr\/bin\/env python\n# coding: utf-8\n\n# # MCMC Comparison\n# \n# ## surmise\n# \n# 1. Train a GP (using surmise) to emulate the $S$-factor. \n# 2. Use that GP to calculate the $R$-matrix parameter posteriors.\n# 3. Calculate the $R$-matrix parameter posteriors using the $R$-matrix prediction *directly*.\n# \n# * range of energies\n# * use parameter samples near the true values *exclusively*\n# * use increasingly wider distributions to generate training samples\n#     * If we use flat distributions, the results are crap. With narrow (10%) Gaussians, the results are significantly better. As the Gaussians get wider, we expect to recover our original bad results. Where does this happen?\n# * use fewer training points and see how things change\n\nimport os\nimport sys\nimport subprocess\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom corner import corner\nimport seaborn as sns\nfrom scipy import stats\nfrom surmise.emulation import emulator\nimport emcee\nimport h5py\nfrom corner import corner\n\nfrom dt import cross_section, s_factor\nimport constants as const\n\nrel_unc = float(sys.argv[1])\nnt = int(sys.argv[2])\nntrain = 250\n\nplt.style.use('science')\ngr = (1 + np.sqrt(5)) \/ 2\nh = 3\nplt.rcParams['figure.dpi'] = 300\n\n\n# Our physics model.\ndef f(energy, theta):\n    er, gd2, gn2 = theta\n    return s_factor(energy, er, er, gd2, gn2, const.AD, const.AN, const.UE, const.A)\n\nparameter_labels = [r'$E_r$', r'$\\gamma_d^2$', r'$\\gamma_n^2$']\n\ntrain = np.loadtxt(f'datfiles\/better_training_data_{rel_unc:.2f}.txt')\ntest = np.loadtxt(f'datfiles\/better_testing_data_{rel_unc:.2f}.txt')\n\nns, nd = train.shape\nnk = np.unique(train[:, 0]).size # number of momenta\n\nx = train[::ntrain, 0].reshape(-1, 1) # input\/location\/momentum\nw = train[:nt, 1:4] # parameters that we want to emulate\n\ny = train[:, -1].reshape(nk, ntrain) # output\/cross section\ny = y[:, :nt]\n\n\n# Set up the surmise emulator.\nargs = {'epsilon' : 0.0, 'warnings' : True}\n# args = {'epsilon': 0.1, ‘hypregmean’: -8}\nemu = emulator(x=x, theta=w, f=y, method='PCGPwM', args=args)\n\nbounds = np.copy(const.BOUNDS)\npriors = [stats.uniform(b[0], b[1]-b[0]) for b in bounds]\n\nenergies, data, data_err = np.loadtxt('datfiles\/data.txt', unpack=True)\ntheta_true = np.loadtxt('datfiles\/theta_true.txt')[:3]\n\ndef ln_prior(theta):\n    return np.sum([p.logpdf(t) for (p, t) in zip(priors, theta)])\n\n\nclass Model:\n    def __init__(self, predict):\n        self.predict_func = predict\n    \n    \n    def ln_likelihood(self, theta):\n        mu, var = self.predict_func(theta)\n        var_tot = data_err**2 + var\n        return np.sum(-np.log(np.sqrt(2*np.pi*var_tot)) - (data - mu)**2 \/ var_tot)\n\n\n    def ln_posterior(self, theta):\n        lnpi = ln_prior(theta)\n        if lnpi == -np.inf:\n            return -np.inf\n        return lnpi + self.ln_likelihood(theta)\n\n\ndef gp_func(theta):\n    p = emu.predict(theta=theta)\n    mu = p.mean().T[0]\n    var = p.var().T[0]\n    return mu, var\n\n\ndef r_func(theta):\n    return np.array([f(ei, theta) for ei in energies]), np.zeros(energies.size)\n\n\nmodel_gp = Model(gp_func)\nmodel_r = Model(r_func)\n\n\nnd = 3\nnw = 2*nd\n\np0 = np.array(\n    [stats.norm(theta_true, 0.01*np.abs(theta_true)).rvs() for _ in range(nw)]\n)\n\nmoves = [(emcee.moves.DEMove(), 0.2), (emcee.moves.DESnookerMove(), 0.8)]\nsampler_gp = emcee.EnsembleSampler(nw, nd, model_gp.ln_posterior, moves=moves)\nsampler_r = emcee.EnsembleSampler(nw, nd, model_r.ln_posterior, moves=moves)\n\n\nstate = sampler_gp.run_mcmc(p0, 1000, thin_by=10, tune=True, progress=True)\nstate = sampler_r.run_mcmc(p0, 1000, thin_by=10, tune=True, progress=True)\n\nfig, ax = plt.subplots(ncols=2, figsize=(2*gr*h, h))\nfig.patch.set_facecolor('white')\n\nnb_gp = 100\nnb_r = nb_gp\n\nax[0].plot(sampler_gp.get_log_prob(discard=nb_gp))\nax[1].plot(sampler_r.get_log_prob(discard=nb_r));\n\n\nflat_chain_gp = sampler_gp.get_chain(flat=True, discard=nb_gp)\nflat_chain_r = sampler_r.get_chain(flat=True, discard=nb_r)\n\n# Corner plots\n\nfig = corner(flat_chain_gp, labels=parameter_labels, show_titles=True, quantiles=[0.16, 0.5, 0.84], color='C0')\nfig = corner(flat_chain_r, color='C1', fig=fig, truths=theta_true, truth_color='C3')\n# fig = corner(w, color='C2', fig=fig)\nfig.patch.set_facecolor('white')\nplt.savefig(f'figures\/corner_{rel_unc:.2f}_{nt}.pdf')\n\n\n# Chains\nfig, ax = plt.subplots(3, figsize=(gr*h, 3*h))\nfig.patch.set_facecolor('white')\n\nfor i in range(3):\n    ax[i].plot(flat_chain_gp[:, i], label='GP')\n    ax[i].plot(flat_chain_r[:, i], label='R-matrix')\n#     ax[i].plot(w[:, i], label='Train')\n    low_68, high_68 = np.quantile(w[:, i], [0.16, 0.84])\n    low_95, high_95 = np.quantile(w[:, i], [0.05, 0.95])\n    ax[i].fill_between(np.arange(flat_chain_gp[:, i].size), low_68, high_68, color='C2', alpha=0.5)\n    ax[i].fill_between(np.arange(flat_chain_gp[:, i].size), low_95, high_95, color='C2', alpha=0.25)\n    ax[i].set_ylabel(parameter_labels[i])\n    ax[i].axhline(theta_true[i], color='C3', label='True')\n    ax[i].legend()\n\nplt.savefig(f'figures\/chains_{rel_unc:.2f}_{nt}.pdf')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_202","text":"<reponame>PerryXDeng\/adversarial_mnist_attacks\nimport neural_network_configuration as conf\nimport numpy as np\nimport scipy.special as ss\n\n\ndef sigmoid(z):\n  \"\"\"\n  sigmoid\/softmax activation, uses ss.expit to avoid numeric instability\n  :param z: vectorized values to be activated\n  :return: vectorized activated values\n  \"\"\"\n  return ss.expit(z)\n\n\ndef cross_entropy(h, y):\n  \"\"\"\n  cross entropy cost function\n  :param h: vectorized hypothesis value\n  :param y: vectorized actual value\n  :return: cross entropy loss\n  \"\"\"\n  return -np.sum(y * np.log(h+1e-6))\n\n\ndef activation(prev, weights, bias):\n  \"\"\"\n  a neural network layer\n  :param prev: activations of previous layer\n  :param weights: weights of this layer\n  :param bias: biases of this layer\n  :return: activations of this layer\n  \"\"\"\n  prev_copy = np.r_[np.ones(prev.shape[1])[np.newaxis], prev]\n  weights_copy = np.c_[bias, weights]\n  return sigmoid(np.matmul(weights_copy, prev_copy))\n\n\ndef feed_forward(x, weights, bias):\n  \"\"\"\n  feeds forward the input through the neural network\n  :param x: input\n  :param weights: weights\n  :param bias: biases\n  :return: activations for all the layers (last layer is the output)\n  \"\"\"\n  # activation value matrices of the two twin networks and the joined network\n  activations = np.ndarray(conf.LAYERS_NUM, dtype=np.matrix)\n\n  # transposing horizontal input vectors (or matrices) into feature vectors\n  if len(x.shape) == 1:\n    activations[0] = x[np.newaxis].T\n  else:\n    activations[0] = x.T\n\n  # forward propagation\n  for i in range(1, conf.LAYERS_NUM):\n    activations[i] = activation(activations[i - 1], weights[i - 1], bias[i - 1])\n\n  return activations\n\n\ndef regularize(weights, cost, gradients):\n  \"\"\"\n  regularize the gradients and costs\n  :param weights: weights\n  :param cost: cost function value\n  :param gradients: gradients value\n  :return: regularized cost and gradietns\n  \"\"\"\n  for n in range(1, conf.LAYERS_NUM):\n    weights_without_bias = np.c_[(np.zeros(weights[n - 1].shape[0]),\n                                  weights[n - 1])]\n    regularization_offset = conf.REG_CONST * weights_without_bias\n    gradients[n - 1] += regularization_offset\n    cost += conf.REG_CONST * np.sum(np.multiply(weights[n - 1], weights[n - 1])) \/ 2\n  return cost, gradients\n\n\ndef cost_derivatives(x, y, weights, bias):\n  \"\"\"\n  gets the gradients of cost w.r.t. biases & weights\n  :param x: input\n  :param y: vectorized labels\n  :param weights: weights\n  :param bias: biases\n  :return: cost and gradients(for both biases and weights)\n  \"\"\"\n  # zero initializes cost and gradients\n  cost = np.float(0)\n  transformations_derivatives = np.ndarray(conf.LAYERS_NUM - 1,\n                                           dtype=np.ndarray)\n  gradients = np.ndarray(conf.LAYERS_NUM - 1, dtype=np.matrix)\n  for i in range(1, conf.LAYERS_NUM):\n    gradients[i - 1] = np.matrix(\n        np.zeros((conf.LAYERS_UNITS[i], conf.LAYERS_UNITS[i - 1] + 1)))\n\n  # sum up the derivatives of cost for each sample\n  activations = feed_forward(x, weights, bias)\n  for i in range(0, x.shape[0]):\n    cost += cross_entropy(activations[conf.LAYERS_NUM - 1][:, i], y[:, i])\n\n    # backpropagate\n    transformations_derivatives[conf.LAYERS_NUM - 2] = \\\n        activations[conf.LAYERS_NUM - 1][:, i] - y[:, i]\n\n    for n in reversed(range(0, conf.LAYERS_NUM - 2)):\n      # n is the n + 1 layer in the network\n      next_layer_transforms_gradients = transformations_derivatives[\n          n + 1]\n      next_layer_weights = weights[n + 1]\n      this_layer_activations_gradients = activations[n + 1][:, i] \\\n                                         * (1 - activations[n + 1][:, i])\n      transformations_derivatives[n] = np.multiply(\n          np.matmul(next_layer_weights.T, next_layer_transforms_gradients),\n          this_layer_activations_gradients)\n\n    # calculate gradients of weights in relation to their transformations\n    for n in range(1, conf.LAYERS_NUM):\n      ad = np.r_[np.ones(1), activations[n - 1][:, i]][np.newaxis]\n      gradients[n - 1] += \\\n          np.matmul(transformations_derivatives[n - 1][np.newaxis].T, ad)\n\n  # take their mean\n  cost \/= x.shape[0]\n  for n in range(1, conf.LAYERS_NUM):\n    gradients[n - 1] \/= x.shape[0]\n\n  return cost, gradients\n\n\ndef predict(x, weights=None, bias=None):\n  \"\"\"\n  gives discrete output (labels) based on input (vectorized images)\n  :param x: input\n  :param weights: weights of the neural network\n  :param bias: biases of the neural network\n  :return: predicted labels\n  \"\"\"\n  if weights is None:\n    weights = np.ndarray(conf.LAYERS_NUM - 1, dtype=np.matrix)\n    bias = np.ndarray(conf.LAYERS_NUM - 1, dtype=np.ndarray)\n    weights[0] = np.load(\"neural_network\/weights_1.npy\")\n    weights[1] = np.load(\"neural_network\/weights_2.npy\")\n    bias[0] = np.load(\"neural_network\/bias_1.npy\")\n    bias[1] = np.load(\"neural_network\/bias_2.npy\")\n  h = feed_forward(x, weights, bias)\n  return np.argmax(h[-1], axis=0)\n\n\ndef accuracy(x, labels, weights, bias):\n  \"\"\"\n  a performance metric\n  :param x: dataset inputs\n  :param labels: dataset labels\n  :param weights: neural network weights\n  :param bias: neural network biases\n  :return: accuracy between 0 and 1\n  \"\"\"\n  out = predict(x, weights, bias)\n  results = [(out[i] == labels[i])\n             for i in range(x.shape[0])]\n  return sum(result for result in results) \/ x.shape[0]\n\n\n# def numerical_derivative_approximation(x, y, weights, bias, i, j, l, cost):\n#   # make two copies of the weights and biases\n#   weights_copy = np.ndarray(nn_conf.LAYERS_NUM - 1, dtype=np.matrix)\n#   bias_copy = np.ndarray(nn_conf.LAYERS_NUM - 1, dtype=np.ndarray)\n#   for n in range(1, nn_conf.LAYERS_NUM):\n#     weights_copy[n - 1] = weights[n - 1]\n#     bias_copy[n - 1] = bias[n - 1]\n#\n#   # copy and modify the weight\/bias matrices at (i, j, l)\n#   if j == 0:\n#     new_bias = np.ndarray.copy(bias_copy[l])\n#     new_bias[i] += nn_conf.NUMERICAL_DELTA\n#     bias_copy[l] = new_bias\n#   else:\n#     new_weights = np.ndarray.copy(weights_copy[l])\n#     # j - 1 due to lack of biases\n#     new_weights[i][j - 1] += nn_conf.NUMERICAL_DELTA\n#     weights_copy = new_weights\n#   # forward propagate\n#   out = feed_forward(x, weights_copy, bias_copy)\n#   # calculate costs for both sets of weights\n#   new_cost = cross_entropy(out[nn_conf.LAYERS_NUM - 1], y)\n#   # print(\"numerical costs: \" + str(cost_1) + \", \" + str(cost_2))\n#   return (new_cost - cost) \/ nn_conf.NUMERICAL_DELTA\n#\n#\n# def num_approx_aggregate(x, y, weights, bias):\n#   out = feed_forward(x, weights, bias)\n#   cost = cross_entropy(out[nn_conf.LAYERS_NUM - 1], y)\n#   weights_gradients = np.ndarray(nn_conf.LAYERS_NUM - 1, dtype=np.matrix)\n#   for l in range(nn_conf.LAYERS_NUM - 1):\n#     mat = np.zeros(shape=(nn_conf.LAYERS_UNITS[l + 1], nn_conf.LAYERS_UNITS[l] + 1))\n#     for i in range(nn_conf.LAYERS_UNITS[l + 1]):\n#       for j in range(nn_conf.LAYERS_UNITS[l] + 1):\n#         mat[i][j] = numerical_derivative_approximation(x, y, weights, bias,\n#                                                        i, j, l, cost)\n#     weights_gradients[l] = mat\n#   return weights_gradients\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_203","text":"<gh_stars>0\nfrom statistics import mean\n\nclass Match_db:\n    \n    def __init__(self, sn, name, pid, alg_len, e_val, missmatch, gaps, gaps_o, read):\n        self.short_name = sn\n        self.name = name\n        self.count = 1\n        self.pid = [pid]\n        self.alg_len = [alg_len]\n        self.e_val= [e_val]\n        self.missmatch = [missmatch]\n        self.gaps = [gaps]\n        self.gap_openings = [gaps_o]\n        self.read = [read]\n    \n    def add_read(self, read, pid, alg_len, e_val, missmatch, gaps, gaps_o):\n        self.count += 1\n        self.read.append(read)\n        self.pid.append(pid)\n        self.alg_len.append(alg_len)\n        self.e_val.append(e_val)\n        self.missmatch.append(missmatch)\n        self.gaps.append(gaps)\n        self.gap_openings.append(gaps_o)\n\n    def __repr__(self):\n        return '''Match_db([{sn},{n}, {c}, {pid}, {al}, {e}, {m}, {g}, {go}, {r}])''' .format(sn=self.short_name, n=self.name, \\\n                            c=self.count, pid=self.pid, \\\n                            al=self.alg_len, e=self.e_val, \\\n                            m=self.missmatch, g=self.gaps, \\\n                            go=self.gap_openings, r=self.read)\n\n    def __str__(self):\n        def preview(lst):\n            if len(lst) == 0:\n                return \"\"\n            elif len(lst) <= 3:\n                return \", \".join(lst)\n            else:\n                return \", \".join(lst[:3]) + \",...\"\n\n        return '''Name: {} \\nCount: {} \\n%ID-avg: {} \\nAlign Len-avg: {} \\nE-val-avg: {} \\nMissmatch-avg: {} \\nGaps-avg: {} \\nGap openings-avg: {} \\nReads: {}'''.format(self.short_name, self.count, mean(self.pid), mean(self.alg_len), mean(self.e_val), mean(self.missmatch), mean(self.gaps), mean(self.gap_openings), preview(self.read) )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_205","text":"import os\nimport numpy as np\nimport math\nimport cv2\nfrom scipy import ndimage\nimport time\n\nlabel1= np.load('\/mnt\/sda1\/downloads\/BlazePose-tensorflow-master\/data_configs_aic\/aic_pre_cropped_17_single.npy')\nfile_name = np.load('\/mnt\/sda1\/downloads\/BlazePose-tensorflow-master\/data_configs_aic\/files_aic_pre_cropped_17_single.npy')\np_a='\/mnt\/sda1\/downloads\/cocoapi-master\/PythonAPI\/aic_persons_17_single\/'\n\ndef rot(im_rot,image, xy, a):\n    # im_rot = ndimage.rotate(image,angle) \n    org_center = (np.array(image.shape[:2][::-1])-1)\/2.\n    rot_center = (np.array(im_rot.shape[:2][::-1])-1)\/2.\n    org = xy-org_center\n    # a = np.deg2rad(angle)\n    new = np.array([org[0]*np.cos(a) + org[1]*np.sin(a),\n            -org[0]*np.sin(a) + org[1]*np.cos(a) ])\n    return new+rot_center    \n\ndef align_im(img,labels):\n    \n    if labels.shape[1]>2.5:\n        labels=labels[:,0:2]\n    s_max=int(2*max(img.shape))\n    if s_max%2==1:\n        s_max=s_max+1\n    filler=np.zeros((s_max,s_max,3)).astype(np.uint8)\n    \n\n    \n    # translation\n    \n    mid_hip=np.array([0.5*(labels[9,0]+labels[6,0]),0.5*(labels[9,1]+labels[6,1])]).astype(int)\n    mid_sh=np.array([0.5*(labels[0,0]+labels[3,0]),0.5*(labels[0,1]+labels[3,1])]).astype(int)\n    stpoint=np.array([int(s_max\/2-mid_hip[1]),int(s_max\/2-mid_hip[0])])\n    filler[stpoint[0]:stpoint[0]+img.shape[0],stpoint[1]:stpoint[1]+img.shape[1],:]=img\n\n    for u in range(labels.shape[0]):\n        labels[u,0]=labels[u,0]+stpoint[1]\n        labels[u,1]=labels[u,1]+stpoint[0]\n    # labels[:,0] += stpoint[1]\n    # labels[:,1] += stpoint[0]\n    \n    mid_hip=np.array([0.5*(labels[9,0]+labels[6,0]),0.5*(labels[9,1]+labels[6,1])]).astype(int)\n    mid_sh=np.array([0.5*(labels[0,0]+labels[3,0]),0.5*(labels[0,1]+labels[3,1])]).astype(int)\n    body_vec = mid_hip-mid_sh\n    img = cv2.line(img,tuple(mid_hip),tuple(mid_sh),(255,0,0),5)\n    body_vec[1]=-body_vec[1]\n    body_vec=-body_vec\n    \n    angle=np.arcsin(body_vec[0]\/(body_vec[0] ** 2+body_vec[1]**2)**0.5)\n    angle_deg=math.degrees(angle)\n    \n    filler_rot = ndimage.rotate(filler, angle_deg,reshape=False,order=0)\n    \n    # if body_vec[0]<0:\n    #     angle=angle+90\n    mid_hip_old=mid_hip\n    for u in range(labels.shape[0]):\n        labels[u,:]=rot(filler_rot,filler,labels[u,:],angle)\n    \n    mid_hip=np.array([0.5*(labels[9,0]+labels[6,0]),0.5*(labels[9,1]+labels[6,1])]).astype(int)\n    mid_sh=np.array([0.5*(labels[0,0]+labels[3,0]),0.5*(labels[0,1]+labels[3,1])]).astype(int)\n    \n    diam=int(np.linalg.norm(mid_hip-mid_sh))\n    final=filler_rot[mid_hip[0]-int(diam*2.2):mid_hip[0]+int(diam*2.2),mid_hip[1]-int(diam*1.5):mid_hip[1]+int(diam*1.7),:]\n    \n\n\n    for u in range(labels.shape[0]):\n        # labels[u,:]=rot(filler_rot,filler,labels[u,:],angle)\n        labels[u,0]=labels[u,0]-(mid_hip[1]-int(diam*1.5))\n        labels[u,1]=labels[u,1]-(mid_hip[0]-int(diam*2.2))\n\n    # labels[:,0] += (-(mid_hip[1]-int(diam*1.5)))\n    # labels[:,1] += (-(mid_hip[0]-int(diam*2.2)))\n\n    \n    return final,labels\n\n# label1= np.load('data_configs\/cocos_mids_new_aligned_pc.npy')\n# file_name = np.load('data_configs\/files_mids_new_aligned_pc.npy')\n\n\n\n\nnew_file_name=list()\nlabel=label1[0:file_name.shape[0],0:17,:]\nnew_label=np.copy(label)\n\ntot_data=label.shape[0]\n\n\naa=time.time()\nbb=time.time()\n\n\n\nomitted_list=list()\nnew_labels=np.zeros((len(file_name),label1.shape[1],3))\n\nc=0\nfor i in range(tot_data):\n    try:\n        if c<10000000:\n            if i%100==0:\n                print(i)\n                print('just for that: {}'.format((time.time()-aa)))\n                print('just for that: {}'.format((time.time()-bb)))\n    \n                aa=time.time()\n            # FileName = \".\/dataset\/lsp\/images\/im%04d.jpg\" % (i + 1)\n            FileName = p_a+file_name[i]\n            # ii=cv2.imread(file_name[i])\n            img = cv2.imread(FileName)\n            if img.shape\n            labels=np.copy(label[i,:,:])\n            img1,labels2=align_im(img, np.copy(label[i,:,:]))\n            # FileNames=FileName[0:45]+\"aligned_\"+FileName[45:]\n            FileNames=FileName[0:45]+\"aligned_\"+FileName[45:]\n    \n            cv2.imwrite(FileNames, img1)\n            for k in range(labels2.shape[0]):\n                if label[i,k,2]==0: \n                    labels2[k,0]=0\n                    labels2[k,1]=0\n\n            new_labels[c,:,0:2]=labels2.astype(float)\n            new_labels[c,:,2]=label[i,:,2].astype(float)\n            new_file_name.append(FileNames)\n    \n            c=c+1\n            # new_label[i,:,2]=np.zeros((new_label.shape[1],))          \n \n    except:\n        print('none')\n        omitted_list.append(i)\n        \nnew_labels1=new_labels[0:c]\n\n# new_labels=np.zeros((len(new_file_name),new_label.shape[1],3))\n\n# c=0\n# for t in range(len(file_name)): \n#     if t not in omitted_list:\n#         new_labels[c,:,:]=new_label[t,:,:]\n#         c=c+1\n# print(c-len(new_file_name))\n\n# np.save('data_configs_aic\/aic_mids_croped.npy',new_labels1)\n# np.save('data_configs_aic\/files_aic_mids_cropped.npy',np.array(new_file_name))  \n\n# np.save('data_configs\/mpii_croped.npy',new_labels1)\n# np.save('data_configs\/files_mpii_cropped.npy',np.array(new_file_name))  \n        \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_206","text":"from __future__ import absolute_import\nimport traceback\nfrom .utils import Eval, latexify, arguments, removeSymPy, \\\n    custom_implicit_transformation, synonyms, OTHER_SYMPY_FUNCTIONS, \\\n    close_matches\nfrom .resultsets import find_result_set, get_card, format_by_type, \\\n    is_function_handled, find_learn_more_set\nfrom sympy import latex\nimport sympy\nfrom sympy.core.function import FunctionClass\nfrom sympy.parsing.sympy_parser import stringify_expr, eval_expr, \\\n    standard_transformations, convert_xor, TokenError\nfrom six.moves import map\n\nPREEXEC = \"\"\"from __future__ import division\nfrom sympy import *\nimport sympy\nfrom sympy.solvers.diophantine import diophantine\n\"\"\"\n\n\ndef mathjax_latex(*args):\n    tex_code = []\n    for obj in args:\n        if hasattr(obj, 'as_latex'):\n            tex_code.append(obj.as_latex())\n        else:\n            tex_code.append(latex(obj))\n\n    tag = '<script type=\"math\/tex; mode=display\">'\n    if len(args) == 1:\n        obj = args[0]\n        if (isinstance(obj, sympy.Basic) and\n            not obj.free_symbols and not obj.is_Integer and\n            not obj.is_Float and\n            obj.is_finite is not False and\n            hasattr(obj, 'evalf')):\n            tag = '<script type=\"math\/tex; mode=display\" data-numeric=\"true\" ' \\\n                  'data-output-repr=\"{}\" data-approximation=\"{}\">'.format(\n                      repr(obj), latex(obj.evalf(15)))\n\n    tex_code = ''.join(tex_code)\n\n    return ''.join([tag, tex_code, '<\/script>'])\n\n\nclass SymPyGamma(object):\n\n    def eval(self, s):\n        result = None\n\n        try:\n            result = self.eval_input(s)\n        except TokenError:\n            return [\n                {\"title\": \"Input\", \"input\": s},\n                {\"title\": \"Error\", \"input\": s, \"error\": \"Invalid input\"}\n            ]\n        except Exception as e:\n            return self.handle_error(s, e)\n\n        if result:\n            parsed, arguments, evaluator, evaluated = result\n\n            cards = []\n\n            close_match = close_matches(s, sympy.__dict__)\n            if close_match:\n                cards.append({\n                    \"ambiguity\": close_match,\n                    \"description\": \"\"\n                })\n\n            try:\n                cards.extend(self.prepare_cards(parsed, arguments, evaluator, evaluated))\n            except ValueError as e:\n                return self.handle_error(s, e)\n\n            return cards\n\n    def handle_error(self, s, e):\n        if isinstance(e, SyntaxError):\n            error = {\n                \"msg\": str(e),\n                \"offset\": e.offset\n            }\n            if e.text:\n                error[\"input_start\"] = e.text[:e.offset]\n                error[\"input_end\"] = e.text[e.offset:]\n            return [\n                {\"title\": \"Input\", \"input\": s},\n                {\"title\": \"Error\", \"input\": s, \"exception_info\": error}\n            ]\n        elif isinstance(e, ValueError):\n            return [\n                {\"title\": \"Input\", \"input\": s},\n                {\"title\": \"Error\", \"input\": s, \"error\": str(e)}\n            ]\n        else:\n            trace = traceback.format_exc()\n            trace = (\"There was an error in Gamma.\\n\"\n                     \"For reference, the stack trace is:\\n\\n\" + trace)\n            return [\n                {\"title\": \"Input\", \"input\": s},\n                {\"title\": \"Error\", \"input\": s, \"error\": trace}\n            ]\n\n    def disambiguate(self, arguments):\n        if arguments[0] == 'factor':\n            if arguments.args and isinstance(arguments.args[0], sympy.Number):\n                return ('factorint({})'.format(arguments.args[0]),\n                        \"<var>factor<\/var> factors polynomials, while <var>factorint<\/var> factors integers.\")\n        return None\n\n    def eval_input(self, s):\n        namespace = {}\n        exec(PREEXEC, {}, namespace)\n\n        def plot(f=None, **kwargs):\n            \"\"\"Plot functions. Not the same as SymPy's plot.\n\n            This plot function is specific to Gamma. It has the following syntax::\n\n                plot([x^2, x^3, ...])\n\n            or::\n\n                plot(y=x,y1=x^2,r=sin(theta),r1=cos(theta))\n\n            ``plot`` accepts either a list of single-variable expressions to\n            plot or keyword arguments indicating expressions to plot. If\n            keyword arguments are used, the plot will be polar if the keyword\n            argument starts with ``r`` and will be an xy graph otherwise.\n\n            Note that Gamma will cut off plot values above and below a\n            certain value, and that it will **not** warn the user if so.\n\n            \"\"\"\n            pass\n        namespace.update({\n            'plot': plot,  # prevent textplot from printing stuff\n            'help': lambda f: f\n        })\n\n        evaluator = Eval(namespace)\n        # change to True to spare the user from exceptions:\n        if not len(s):\n            return None\n\n        transformations = []\n        transformations.append(synonyms)\n        transformations.extend(standard_transformations)\n        transformations.extend((convert_xor, custom_implicit_transformation))\n        parsed = stringify_expr(s, {}, namespace, transformations)\n        try:\n            evaluated = eval_expr(parsed, {}, namespace)\n        except SyntaxError:\n            raise\n        except Exception as e:\n            raise ValueError(str(e))\n        input_repr = repr(evaluated)\n        namespace['input_evaluated'] = evaluated\n\n        return parsed, arguments(parsed, evaluator), evaluator, evaluated\n\n    def get_cards(self, arguments, evaluator, evaluated):\n        first_func_name = arguments[0]\n        # is the top-level function call to a function such as factorint or\n        # simplify?\n        is_function = False\n        # is the top-level function being called?\n        is_applied = arguments.args or arguments.kwargs\n\n        first_func = evaluator.get(first_func_name)\n        is_function = (\n            first_func and\n            not isinstance(first_func, FunctionClass) and\n            not isinstance(first_func, sympy.Atom) and\n            first_func_name and first_func_name[0].islower() and\n            not first_func_name in OTHER_SYMPY_FUNCTIONS)\n\n        if is_applied:\n            convert_input, cards = find_result_set(arguments[0], evaluated)\n        else:\n            convert_input, cards = find_result_set(None, evaluated)\n\n        components = convert_input(arguments, evaluated)\n        if 'input_evaluated' in components:\n            evaluated = components['input_evaluated']\n\n        evaluator.set('input_evaluated', evaluated)\n\n        return components, cards, evaluated, (is_function and is_applied)\n\n    def prepare_cards(self, parsed, arguments, evaluator, evaluated):\n        components, cards, evaluated, is_function = self.get_cards(arguments, evaluator, evaluated)\n\n        if is_function:\n            latex_input = ''.join(['<script type=\"math\/tex; mode=display\">',\n                                   latexify(parsed, evaluator),\n                                   '<\/script>'])\n        else:\n            latex_input = mathjax_latex(evaluated)\n\n        result = []\n\n        ambiguity = self.disambiguate(arguments)\n        if ambiguity:\n            result.append({\n                \"ambiguity\": ambiguity[0],\n                \"description\": ambiguity[1]\n            })\n\n        result.append({\n            \"title\": \"SymPy\",\n            \"input\": removeSymPy(parsed),\n            \"output\": latex_input\n        })\n\n        if cards:\n            if any(get_card(c).is_multivariate() for c in cards):\n                result[-1].update({\n                    \"num_variables\": len(components['variables']),\n                    \"variables\": list(map(repr, components['variables'])),\n                    \"variable\": repr(components['variable'])\n                })\n\n        # If no result cards were found, but the top-level call is to a\n        # function, then add a special result card to show the result\n        if not cards and not components['variable'] and is_function:\n            result.append({\n                'title': 'Result',\n                'input': removeSymPy(parsed),\n                'output': format_by_type(evaluated, arguments, mathjax_latex)\n            })\n        else:\n            var = components['variable']\n\n            # If the expression is something like 'lcm(2x, 3x)', display the\n            # result of the function before the rest of the cards\n            if is_function and not is_function_handled(arguments[0]):\n                result.append(\n                    {\"title\": \"Result\", \"input\": \"\",\n                     \"output\": format_by_type(evaluated, arguments, mathjax_latex)})\n\n            line = \"simplify(input_evaluated)\"\n            simplified = evaluator.eval(line,\n                                        use_none_for_exceptions=True,\n                                        repr_expression=False)\n            if (simplified != None and\n                simplified != evaluated and\n                arguments.args and\n                len(arguments.args) > 0 and\n                simplified != arguments.args[0]):\n                result.append(\n                    {\"title\": \"Simplification\", \"input\": repr(simplified),\n                     \"output\": mathjax_latex(simplified)})\n            elif arguments.function == 'simplify':\n                result.append(\n                    {\"title\": \"Simplification\", \"input\": \"\",\n                     \"output\": mathjax_latex(evaluated)})\n\n            for card_name in cards:\n                card = get_card(card_name)\n\n                if not card:\n                    continue\n\n                try:\n                    result.append({\n                        'card': card_name,\n                        'var': repr(var),\n                        'title': card.format_title(evaluated),\n                        'input': card.format_input(repr(evaluated), components),\n                        'pre_output': latex(\n                            card.pre_output_function(evaluated, var)),\n                        'parameters': card.card_info.get('parameters', [])\n                    })\n                except (SyntaxError, ValueError) as e:\n                    pass\n\n            if is_function:\n                learn_more = find_learn_more_set(arguments[0])\n                if learn_more:\n                    result.append({\n                        \"title\": \"Learn More\",\n                        \"input\": '',\n                        \"output\": learn_more\n                    })\n        return result\n\n    def get_card_info(self, card_name, expression, variable):\n        card = get_card(card_name)\n\n        if not card:\n            raise KeyError\n\n        _, arguments, evaluator, evaluated = self.eval_input(expression)\n        variable = sympy.Symbol(variable)\n        components, cards, evaluated, _ = self.get_cards(arguments, evaluator, evaluated)\n        components['variable'] = variable\n\n        return {\n            'var': repr(variable),\n            'title': card.format_title(evaluated),\n            'input': card.format_input(repr(evaluated), components),\n            'pre_output': latex(card.pre_output_function(evaluated, variable))\n        }\n\n    def eval_card(self, card_name, expression, variable, parameters):\n        card = get_card(card_name)\n\n        if not card:\n            raise KeyError\n\n        _, arguments, evaluator, evaluated = self.eval_input(expression)\n        variable = sympy.Symbol(variable)\n        components, cards, evaluated, _ = self.get_cards(arguments, evaluator, evaluated)\n        components['variable'] = variable\n        evaluator.set(str(variable), variable)\n        result = card.eval(evaluator, components, parameters)\n\n        return {\n            'value': repr(result),\n            'output': card.format_output(result, mathjax_latex)\n        }\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_207","text":"import os\nimport cv2\nimport torch\nimport numpy as np\nfrom scipy.io import loadmat\nfrom types import SimpleNamespace\nfrom typing import Union, Optional, List, Dict\nfrom .tddfa import mobilenet_v1\nfrom .tddfa.utils.inference import parse_roi_box_from_landmark, crop_img, predict_68pts\nfrom .tddfa_utils import parse_param_pose, reconstruct_from_3dmm\n\n\n__all__ = ['TDDFAPredictor']\n\n\nclass TDDFAPredictor(object):\n    tri = loadmat(os.path.join(os.path.dirname(__file__), 'tddfa', 'visualize', 'tri.mat'))['tri']\n\n    def __init__(self, device: Union[str, torch.device] = 'cuda:0', model: Optional[SimpleNamespace] = None,\n                 config: Optional[SimpleNamespace] = None) -> None:\n        self.device = device\n        if model is None:\n            model = TDDFAPredictor.get_model()\n        if config is None:\n            config = TDDFAPredictor.create_config()\n        self.config = SimpleNamespace(**model.config.__dict__, **config.__dict__)\n        self.net = getattr(mobilenet_v1, self.config.arch)(num_classes=62).to(self.device)\n        pretrained_dict = torch.load(model.weights, map_location=self.device)\n        if 'state_dict' in pretrained_dict.keys():\n            pretrained_dict = {key.split('module.', 1)[-1] if key.startswith('module.') else key: value\n                               for key, value in pretrained_dict['state_dict'].items()}\n        else:\n            pretrained_dict = {key.split('module.', 1)[-1] if key.startswith('module.') else key: value\n                               for key, value in pretrained_dict.items()}\n        self.net.load_state_dict(pretrained_dict)\n        self.net.eval()\n        if self.config.use_jit:\n            self.net = torch.jit.trace(self.net, torch.rand(1, 3, self.config.input_size,\n                                                            self.config.input_size).to(self.device))\n\n    @staticmethod\n    def get_model(name: str = 'mobilenet1') -> SimpleNamespace:\n        name = name.lower()\n        if name == 'mobilenet1':\n            return SimpleNamespace(weights=os.path.join(os.path.dirname(mobilenet_v1.__file__),\n                                                        'models', 'phase1_wpdc_vdc.pth.tar'),\n                                   config=SimpleNamespace(arch='mobilenet_1', input_size=120))\n        else:\n            raise ValueError('name must be set to mobilenet')\n\n    @staticmethod\n    def create_config(use_jit: bool = True) -> SimpleNamespace:\n        return SimpleNamespace(use_jit=use_jit)\n\n    @torch.no_grad()\n    def __call__(self, image: np.ndarray, landmarks: np.ndarray, rgb: bool = True,\n                 two_steps: bool = False) -> np.ndarray:\n        if landmarks.size > 0:\n            # Preparation\n            if rgb:\n                image = image[..., ::-1]\n            if landmarks.ndim == 2:\n                landmarks = landmarks[np.newaxis, ...]\n\n            # Crop the face patches\n            roi_boxes = []\n            face_patches = []\n            for lms in landmarks:\n                roi_boxes.append(parse_roi_box_from_landmark(lms.T))\n                face_patches.append(cv2.resize(crop_img(image, roi_boxes[-1]),\n                                               (self.config.input_size, self.config.input_size)))\n            face_patches = (torch.from_numpy(np.array(face_patches).transpose(\n                (0, 3, 1, 2)).astype(np.float32)).to(self.device) - 127.5) \/ 128.0\n\n            # Get 3DMM parameters\n            params = self.net(face_patches).cpu().numpy()\n            if two_steps:\n                landmarks = []\n                for param, roi_box in zip(params, roi_boxes):\n                    landmarks.append(predict_68pts(param, roi_box).T)\n                return self.__call__(image, np.array(landmarks), rgb=False, two_steps=False)\n            else:\n                return np.hstack((np.array(roi_boxes, dtype=np.float32), params))\n        else:\n            return np.empty(shape=(0, 66), dtype=np.float32)\n\n    @staticmethod\n    def decode(tdmm_params: np.ndarray) -> List[Dict]:\n        if tdmm_params.size > 0:\n            if tdmm_params.ndim > 1:\n                return [TDDFAPredictor.decode(x) for x in tdmm_params]\n            else:\n                roi_box = tdmm_params[:4]\n                params = tdmm_params[4:]\n                vertex, pts68, fR, T = reconstruct_from_3dmm(params)\n                camera_transform = {'fR': fR, 'T': T}\n                yaw, pitch, roll, t3d, f = parse_param_pose(params)\n                face_pose = {'yaw': yaw, 'pitch': pitch, 'roll': roll, 't3d': t3d, 'f': f}\n                return {'roi_box': roi_box, 'params': params, 'vertex': vertex, 'pts68': pts68,\n                        'face_pose': face_pose, 'camera_transform': camera_transform}\n        else:\n            return []\n\n    def project_vertex(self, tddfa_result: Dict, dense: bool = True) -> np.ndarray:\n        vertex = (tddfa_result['camera_transform']['fR'] @\n                  (tddfa_result['vertex'] if dense else tddfa_result['pts68']) +\n                  tddfa_result['camera_transform']['T'])\n\n        sx, sy, ex, ey = tddfa_result['roi_box']\n        scale_x = (ex - sx) \/ self.config.input_size\n        scale_y = (ey - sy) \/ self.config.input_size\n        vertex[0, :] = vertex[0, :] * scale_x + sx\n        vertex[1, :] = (self.config.input_size + 1 - vertex[1, :]) * scale_y + sy\n\n        s = (scale_x + scale_y) \/ 2\n        vertex[2, :] *= s\n\n        return vertex.T\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_195","text":"# Copyright (c) 2015, <NAME>\n# See LICENSE file for details: <https:\/\/github.com\/moble\/scri\/blob\/master\/LICENSE>\n\nfrom . import Inertial, WaveformModes, SpinWeights, DataNames\nfrom . import h, hdot, sigma, news, psi0, psi1, psi2, psi3, psi4\nfrom .waveform_base import WaveformBase, waveform_alterations\n\nimport sys\nimport warnings\nimport pprint\nimport numbers\nimport math\nimport numpy as np\nfrom scipy import interpolate\nimport quaternion\nimport spherical_functions as sf\nimport spinsfast\n\n\ndef process_transformation_kwargs(ell_max, **kwargs):\n    # Build the supertranslation and spacetime_translation arrays\n    supertranslation = np.zeros((4,), dtype=complex)  # For now; may be resized below\n    ell_max_supertranslation = 1  # For now; may be increased below\n    if \"supertranslation\" in kwargs:\n        supertranslation = np.array(kwargs.pop(\"supertranslation\"), dtype=complex)\n        if supertranslation.dtype != \"complex\" and supertranslation.size > 0:\n            # I don't actually think this can ever happen...\n            raise TypeError(\n                \"\\nInput argument `supertranslation` should be a complex array with size>0.\\n\"\n                \"Got a {} array of shape {}.\".format(supertranslation.dtype, supertranslation.shape)\n            )\n        # Make sure the array has size at least 4, by padding with zeros\n        if supertranslation.size <= 4:\n            supertranslation = np.lib.pad(\n                supertranslation, (0, 4 - supertranslation.size), \"constant\", constant_values=(0.0,)\n            )\n        # Check that the shape is a possible array of scalar modes with complete (ell,m) data\n        ell_max_supertranslation = int(np.sqrt(len(supertranslation))) - 1\n        if (ell_max_supertranslation + 1) ** 2 != len(supertranslation):\n            raise ValueError(\n                \"\\nInput supertranslation parameter must contain modes from ell=0 up to some ell_max, \"\n                \"including\\nall relevant m modes in standard order (see `spherical_functions` \"\n                \"documentation for details).\\nThus, it must be an array with length given by a \"\n                \"perfect square; its length is {}\".format(len(supertranslation))\n            )\n        # Check that the resulting supertranslation will be real\n        for ell in range(ell_max_supertranslation + 1):\n            for m in range(ell + 1):\n                i_pos = sf.LM_index(ell, m, 0)\n                i_neg = sf.LM_index(ell, -m, 0)\n                a = supertranslation[i_pos]\n                b = supertranslation[i_neg]\n                if abs(a - (-1.0) ** m * b.conjugate()) > 3e-16 + 1e-15 * abs(b):\n                    raise ValueError(\n                        f\"\\nsupertranslation[{i_pos}]={a}  # (ell,m)=({ell},{m})\\n\"\n                        + \"supertranslation[{}]={}  # (ell,m)=({},{})\\n\".format(i_neg, b, ell, -m)\n                        + \"Will result in an imaginary supertranslation.\"\n                    )\n    spacetime_translation = np.zeros((4,), dtype=float)\n    spacetime_translation[0] = sf.constant_from_ell_0_mode(supertranslation[0]).real\n    spacetime_translation[1:4] = -sf.vector_from_ell_1_modes(supertranslation[1:4]).real\n    if \"spacetime_translation\" in kwargs:\n        st_trans = np.array(kwargs.pop(\"spacetime_translation\"), dtype=float)\n        if st_trans.shape != (4,) or st_trans.dtype != \"float\":\n            raise TypeError(\n                \"\\nInput argument `spacetime_translation` should be a float array of shape (4,).\\n\"\n                \"Got a {} array of shape {}.\".format(st_trans.dtype, st_trans.shape)\n            )\n        spacetime_translation = st_trans[:]\n        supertranslation[0] = sf.constant_as_ell_0_mode(spacetime_translation[0])\n        supertranslation[1:4] = sf.vector_as_ell_1_modes(-spacetime_translation[1:4])\n    if \"space_translation\" in kwargs:\n        s_trans = np.array(kwargs.pop(\"space_translation\"), dtype=float)\n        if s_trans.shape != (3,) or s_trans.dtype != \"float\":\n            raise TypeError(\n                \"\\nInput argument `space_translation` should be an array of floats of shape (3,).\\n\"\n                \"Got a {} array of shape {}.\".format(s_trans.dtype, s_trans.shape)\n            )\n        spacetime_translation[1:4] = s_trans[:]\n        supertranslation[1:4] = sf.vector_as_ell_1_modes(-spacetime_translation[1:4])\n    if \"time_translation\" in kwargs:\n        t_trans = kwargs.pop(\"time_translation\")\n        if not isinstance(t_trans, float):\n            raise TypeError(\"\\nInput argument `time_translation` should be a single float.\\n\" \"Got {}.\".format(t_trans))\n        spacetime_translation[0] = t_trans\n        supertranslation[0] = sf.constant_as_ell_0_mode(spacetime_translation[0])\n\n    # Decide on the number of points to use in each direction.  A nontrivial supertranslation will introduce\n    # power in higher modes, so for best accuracy, we need to account for that.  But we'll make it a firm\n    # requirement to have enough points to capture the original waveform, at least\n    w_ell_max = ell_max\n    ell_max = w_ell_max + ell_max_supertranslation\n    n_theta = kwargs.pop(\"n_theta\", 2 * ell_max + 1)\n    n_phi = kwargs.pop(\"n_phi\", 2 * ell_max + 1)\n    if n_theta < 2 * ell_max + 1 and abs(supertranslation[1:]).max() > 0.0:\n        warning = (\n            f\"n_theta={n_theta} is small; because of the supertranslation, \"\n            + f\"it will lose accuracy for anything less than 2*ell+1={ell_max}\"\n        )\n        warnings.warn(warning)\n    if n_theta < 2 * w_ell_max + 1:\n        raise ValueError(f\"n_theta={n_theta} is too small; \" + \"must be at least 2*ell+1={}\".format(2 * w_ell_max + 1))\n    if n_phi < 2 * ell_max + 1 and abs(supertranslation[1:]).max() > 0.0:\n        warning = (\n            f\"n_phi={n_phi} is small; because of the supertranslation, \"\n            + f\"it will lose accuracy for anything less than 2*ell+1={ell_max}\"\n        )\n        warnings.warn(warning)\n    if n_phi < 2 * w_ell_max + 1:\n        raise ValueError(f\"n_phi={n_phi} is too small; \" + \"must be at least 2*ell+1={}\".format(2 * w_ell_max + 1))\n\n    # Get the rotor for the frame rotation\n    frame_rotation = np.quaternion(*np.array(kwargs.pop(\"frame_rotation\", [1, 0, 0, 0]), dtype=float))\n    if frame_rotation.abs() < 3e-16:\n        raise ValueError(f\"frame_rotation={frame_rotation} should be a unit quaternion\")\n    frame_rotation = frame_rotation.normalized()\n\n    # Get the boost velocity vector\n    boost_velocity = np.array(kwargs.pop(\"boost_velocity\", [0.0] * 3), dtype=float)\n    beta = np.linalg.norm(boost_velocity)\n    if boost_velocity.shape != (3,) or beta >= 1.0:\n        raise ValueError(\n            \"Input boost_velocity=`{}` should be a 3-vector with \"\n            \"magnitude strictly less than 1.0.\".format(boost_velocity)\n        )\n    gamma = 1 \/ math.sqrt(1 - beta ** 2)\n    varphi = math.atanh(beta)\n\n    # These are the angles in the transformed system at which we need to know the function values\n    thetaprm_j_phiprm_k = np.array(\n        [\n            [[thetaprm_j, phiprm_k] for phiprm_k in np.linspace(0.0, 2 * np.pi, num=n_phi, endpoint=False)]\n            for thetaprm_j in np.linspace(0.0, np.pi, num=n_theta, endpoint=True)\n        ]\n    )\n\n    # Construct the function that modifies our rotor grid to account for the boost\n    if beta > 3e-14:  # Tolerance for beta; any smaller and numerical errors will have greater effect\n        vhat = boost_velocity \/ beta\n\n        def Bprm_j_k(thetaprm, phiprm):\n            \"\"\"Construct rotor taking r' to r\n\n            I derived this result in a different way, but I've also found it described in Penrose-Rindler Vol. 1,\n            around Eq. (1.3.5).  Note, however, that their discussion is for the past celestial sphere,\n            so there's a sign difference.\n\n            \"\"\"\n            # Note: It doesn't matter which we use -- r' or r; all we need is the direction of the bivector\n            # spanned by v and r', which is the same as the direction of the bivector spanned by v and r,\n            # since either will be normalized, and one cross product is zero iff the other is zero.\n            rprm = np.array(\n                [math.cos(phiprm) * math.sin(thetaprm), math.sin(phiprm) * math.sin(thetaprm), math.cos(thetaprm)]\n            )\n            Thetaprm = math.acos(np.dot(vhat, rprm))\n            Theta = 2 * math.atan(math.exp(-varphi) * math.tan(Thetaprm \/ 2.0))\n            rprm_cross_vhat = np.quaternion(0.0, *np.cross(rprm, vhat))\n            if rprm_cross_vhat.abs() > 1e-200:\n                return (rprm_cross_vhat.normalized() * (Thetaprm - Theta) \/ 2).exp()\n            else:\n                return quaternion.one\n\n    else:\n\n        def Bprm_j_k(thetaprm, phiprm):\n            return quaternion.one\n\n    # Set up rotors that we can use to evaluate the SWSHs in the original frame\n    R_j_k = np.empty(thetaprm_j_phiprm_k.shape[:2], dtype=np.quaternion)\n    for j in range(thetaprm_j_phiprm_k.shape[0]):\n        for k in range(thetaprm_j_phiprm_k.shape[1]):\n            thetaprm_j, phiprm_k = thetaprm_j_phiprm_k[j, k]\n            R_j_k[j, k] = (\n                Bprm_j_k(thetaprm_j, phiprm_k) * frame_rotation * quaternion.from_spherical_coords(thetaprm_j, phiprm_k)\n            )\n\n    return (\n        supertranslation,\n        ell_max_supertranslation,\n        ell_max,\n        n_theta,\n        n_phi,\n        boost_velocity,\n        beta,\n        gamma,\n        varphi,\n        R_j_k,\n        Bprm_j_k,\n        thetaprm_j_phiprm_k,\n        kwargs,\n    )\n\n\nclass WaveformGrid(WaveformBase):\n    def __init__(self, *args, **kwargs):\n        \"\"\"Initializer for WaveformGrid object\"\"\"\n        # Do not directly access __n_theta or __n_phi; use n_theta or n_phi instead\n        self.__n_theta = kwargs.pop(\"n_theta\", 0)\n        self.__n_phi = kwargs.pop(\"n_phi\", 0)\n        super().__init__(*args, **kwargs)\n\n    @waveform_alterations\n    def ensure_validity(self, alter=True, assertions=False):\n        \"\"\"Try to ensure that the `WaveformGrid` object is valid\n\n        See `WaveformBase.ensure_validity` for the basic tests.  This function also includes tests that `data` is\n        complex, and consistent with the n_theta and n_phi values.\n\n        \"\"\"\n        import numbers\n\n        errors = []\n        alterations = []\n\n        if assertions:\n            from .waveform_base import test_with_assertions\n\n            test = test_with_assertions\n        else:\n            from .waveform_base import test_without_assertions\n\n            test = test_without_assertions\n\n        test(\n            errors,\n            isinstance(self.__n_theta, numbers.Integral),\n            \"isinstance(self.__n_theta, numbers.Integral)  # type(self.__n_theta)={}\".format(type(self.__n_theta)),\n        )\n        test(\n            errors,\n            isinstance(self.__n_phi, numbers.Integral),\n            \"isinstance(self.__n_phi, numbers.Integral)  # type(self.__n_phi)={}\".format(type(self.__n_phi)),\n        )\n        test(errors, self.__n_theta >= 0, f\"self.__n_theta>=0 # {self.__n_theta}\")\n        test(errors, self.__n_phi >= 0, f\"self.__n_phi>=0 # {self.__n_phi}\")\n\n        test(\n            errors,\n            self.data.dtype == np.dtype(complex),\n            f\"self.data.dtype == np.dtype(complex)  # self.data.dtype={self.data.dtype}\",\n        )\n        test(errors, self.data.ndim >= 2, f\"self.data.ndim >= 2 # self.data.ndim={self.data.ndim}\")\n        test(\n            errors,\n            self.data.shape[1] == self.__n_theta * self.__n_phi,\n            \"self.data.shape[1] == self.__n_theta * self.__n_phi  \"\n            \"# self.data.shape={}; self.__n_theta * self.__n_phi={}\".format(\n                self.data.shape[1], self.__n_theta * self.__n_phi\n            ),\n        )\n\n        if alterations:\n            self._append_history(alterations)\n            print(\"The following alterations were made:\\n\\t\" + \"\\n\\t\".join(alterations))\n        if errors:\n            print(\"The following conditions were found to be incorrectly False:\\n\\t\" + \"\\n\\t\".join(errors))\n            return False\n\n        # Call the base class's version\n        super().ensure_validity(alter, assertions)\n\n        self.__history_depth__ -= 1\n        self._append_history(\"WaveformModes.ensure_validity\" + f\"({self}, alter={alter}, assertions={assertions})\")\n\n        return True\n\n    @property\n    def n_theta(self):\n        return self.__n_theta\n\n    @property\n    def n_phi(self):\n        return self.__n_phi\n\n    def to_modes(self, ell_max=None, ell_min=None):\n        \"\"\"Transform to modes of a spin-weighted spherical harmonic expansion\n\n        Parameters\n        ----------\n        self : WaveformGrid object\n            This is the object to be transformed to SWSH modes\n        ell_max : int, optional\n            The largest ell value to include in the output data.  Default value\n            is deduced from n_theta and n_phi.\n        ell_min : int, optional\n            The smallest ell value to include in the output data.  Default value\n            is abs(spin_weight).\n\n        \"\"\"\n        s = SpinWeights[self.dataType]\n        if ell_max is None:\n            ell_max = int((max(self.n_theta, self.n_phi) - 1) \/\/ 2)\n        if ell_min is None:\n            ell_min = abs(s)\n        if not isinstance(ell_max, numbers.Integral) or ell_max < 0:\n            raise ValueError(f\"Input `ell_max` should be a nonnegative integer; got `{ell_max}`.\")\n        if not isinstance(ell_min, numbers.Integral) or ell_min < 0 or ell_min > ell_max:\n            raise ValueError(f\"Input `ell_min` should be an integer between 0 and {ell_max}; got `{ell_min}`.\")\n\n        final_dim = int(np.prod(self.data.shape[2:]))\n        old_data = self.data.reshape((self.n_times, self.n_theta, self.n_phi, final_dim))\n        new_data = np.empty((self.n_times, sf.LM_total_size(ell_min, ell_max), final_dim), dtype=complex)\n        # Note that spinsfast returns all modes, including ell<abs(s).  So we just chop those off\n        for i_time in range(self.n_times):\n            for i_final in range(final_dim):\n                new_data[i_time, :, i_final] = spinsfast.map2salm(old_data[i_time, :, :, i_final], s, ell_max)[\n                    sf.LM_index(ell_min, -ell_min, 0) :\n                ]\n        new_data = new_data.reshape((self.n_times, sf.LM_total_size(ell_min, ell_max)) + self.data.shape[2:])\n\n        # old_data = self.data.reshape((self.n_times, self.n_theta, self.n_phi)+self.data.shape[2:])\n        # new_data = np.empty((self.n_times, sf.LM_total_size(ell_min, ell_max))+self.data.shape[2:], dtype=complex)\n        # # Note that spinsfast returns all modes, including ell<abs(s).  So we just chop those off\n        # for i_time in range(self.n_times):\n        #     new_data[i_time, :] = spinsfast.map2salm(old_data[i_time, :, :], s, ell_max)\\\n        #         [sf.LM_index(ell_min, -ell_min, 0):]\n\n        m = WaveformModes(\n            t=self.t,\n            data=new_data,\n            history=self.history,\n            ell_min=ell_min,\n            ell_max=ell_max,\n            frameType=self.frameType,\n            dataType=self.dataType,\n            r_is_scaled_out=self.r_is_scaled_out,\n            m_is_scaled_out=self.m_is_scaled_out,\n            constructor_statement=f\"{self}.to_modes({ell_max})\",\n        )\n        return m\n\n    @classmethod\n    def from_modes(cls, w_modes, **kwargs):\n        \"\"\"Construct grid object from modes, with optional BMS transformation\n\n        This \"constructor\" is designed with the goal of transforming the frame in which the modes are measured.  If\n        this is not desired, it can be called without those parameters.\n\n        It is important to note that the input transformation parameters are applied in the order listed in the\n        parameter list below:\n          1. (Super)Translations\n          2. Rotation (about the origin of the translated system)\n          3. Boost\n        All input parameters refer to the transformation required to take the mode's inertial frame onto the inertial\n        frame of the grid's inertial observers.  In what follows, the inertial frame of the modes will be unprimed,\n        while the inertial frame of the grid will be primed.  NOTE: These are passive transformations, e.g. supplying\n        the option space_translation=[0, 0, 5] to a Schwarzschild spacetime will move the coordinates to z'=z+5 and so\n        the center of mass will be shifted in the negative z direction by 5 in the new coordinates.\n\n        The translations (space, time, spacetime, or super) can be given in various ways, which may override each\n        other.  Ultimately, however, they are essentially combined into a single function `alpha`, representing the\n        supertranslation, which transforms the asymptotic time variable `u` as\n          u'(theta, phi) = u - alpha(theta, phi)\n        A simple time translation would correspond to\n          alpha(theta, phi) = time_translation\n        A pure spatial translation would correspond to\n          alpha(theta, phi) = np.dot(space_translation, -nhat(theta, phi))\n        where `np.dot` is the usual dot product, and `nhat` is the unit vector in the given direction.\n\n\n        Parameters\n        ----------\n        w_modes : WaveformModes\n            The object storing the modes of the original waveform, which will be converted to values on a grid in\n            this function.  This is the only required argument to this function.\n        n_theta : int, optional\n        n_phi : int, optional\n            Number of points in the equi-angular grid in the colatitude (theta) and azimuth (phi) directions. Each\n            defaults to 2*ell_max+1, which is optimal for accuracy and speed.  However, this ell_max will typically\n            be greater than the input waveform's ell_max by at least one, or the ell_max of the input\n            supertranslation (whichever is greater).  This is to minimally account for the power at higher orders\n            that such a supertranslation introduces.  You may wish to increase this further if the spatial size of\n            your supertranslation is large compared to the smallest wavelength you wish to capture in your data\n            [e.g., ell_max*Omega_orbital_max\/speed_of_light], or if your boost speed is close to the speed of light.\n        time_translation : float, optional\n            Defaults to zero.  Nonzero overrides spacetime_translation and supertranslation.\n        space_translation : float array of length 3, optional\n            Defaults to empty (no translation).  Non-empty overrides spacetime_translation and supertranslation.\n        spacetime_translation : float array of length 4, optional\n            Defaults to empty (no translation).  Non-empty overrides supertranslation.\n        supertranslation : complex array, optional\n            This gives the complex components of the spherical-harmonic expansion of the supertranslation in standard\n            form, starting from ell=0 up to some ell_max, which may be different from the ell_max of the input\n            WaveformModes object.  Supertranslations must be real, so these values must obey the condition\n              alpha^{ell,m} = (-1)^m \\bar{alpha}^{ell,-m}\n            Defaults to empty, which causes no supertranslation.\n        frame_rotation : quaternion, optional\n            Transformation applied to (x,y,z) basis of the mode's inertial frame.  For example, the basis z vector of\n            the new grid frame may be written as\n              z' = frame_rotation * z * frame_rotation.inverse()\n            Defaults to 1, corresponding to the identity transformation (no frame_rotation).\n        boost_velocity : float array of length 3, optional\n            This is the three-velocity vector of the grid frame relative to the mode frame.  The norm of this vector\n            is checked to ensure that it is smaller than 1.  Defaults to [], corresponding to no boost.\n        psi4_modes : WaveformModes, required only if w_modes is type psi3, psi2, psi1, or psi0\n        psi3_modes : WaveformModes, required only if w_modes is type psi2, psi1, or psi0\n        psi2_modes : WaveformModes, required only if w_modes is type psi1 or psi0\n        psi1_modes : WaveformModes, required only if w_modes is type psi0\n            The objects storing the modes of the original waveforms of the same spacetime that\n            w_modes belongs to. A BMS transformation of an asymptotic Weyl scalar requires mode\n            information from all higher index Weyl scalars. E.g. if w_modes is of type scri.psi2,\n            then psi4_modes and psi3_modes will be required. Note: the WaveformModes objects\n            supplied to these arguments will themselves NOT be transformed. Please use the\n            AsymptoticBondiData class to efficiently transform all asymptotic data at once.\n\n        Returns\n        -------\n        WaveformGrid\n\n        \"\"\"\n        # Check input object type and frame type\n        #\n        # The data in `w_modes` is given in the original frame.  We need to get the value of the field on a grid of\n        # points corresponding to the points in the new grid frame.  But we must also remember that this is a\n        # spin-weighted and boost-weighted field, which means that we need to account for the frame_rotation due to\n        # `frame_rotation` and `boost_velocity`.  The way to do this is to use rotors to transform the points as needed,\n        # and evaluate the SWSHs.  But for now, let's just reject any waveforms in a non-inertial frame\n        if not isinstance(w_modes, WaveformModes):\n            raise TypeError(\n                \"\\nInput waveform object must be an instance of `WaveformModes`; \"\n                \"this is of type `{}`\".format(type(w_modes).__name__)\n            )\n        if w_modes.frameType != Inertial:\n            raise ValueError(\n                \"\\nInput waveform object must be in an inertial frame; \"\n                \"this is in a frame of type `{}`\".format(w_modes.frame_type_string)\n            )\n\n        # The first task is to establish a set of constant u' slices on which the new grid should be evaluated.  This\n        # is done simply by translating the original set of slices by the time translation (the lowest moment of the\n        # supertranslation).  But some of these slices (at the beginning and end) will not have complete data,\n        # because of the direction-dependence of the rest of the supertranslation.  That is, in some directions,\n        # the data for the complete slice (data in all directions on the sphere) of constant u' will actually refer to\n        # spacetime events that were not in the original set of time slices; we would have to extrapolate the original\n        # data.  So, for nontrivial supertranslations, the output data will actually represent a proper subset of the\n        # input data.\n        #\n        # We can invert the equation for u' to obtain u as a function of angle assuming constant u'\n        #   u'(theta, phi) = u + alpha(theta, phi) + u * np.dot(boost_velocity, nhat(theta, phi))\n        #   u(theta, phi) = (u' - alpha(theta, phi)) \/ (1 + np.dot(boost_velocity, nhat(theta, phi)))\n        # But really, we want u'(theta', phi') for given values\n        #\n        # Note that `space_translation` (and the spatial part of `spacetime_translation`) get reversed signs when\n        # transformed into supertranslation modes, because these pieces enter the time transformation with opposite\n        # sign compared to the time translation, as can be seen by looking at the retarded time: `t-r`.\n\n        original_kwargs = kwargs.copy()\n\n        (\n            supertranslation,\n            ell_max_supertranslation,\n            ell_max,\n            n_theta,\n            n_phi,\n            boost_velocity,\n            beta,\n            gamma,\n            varphi,\n            R_j_k,\n            Bprm_j_k,\n            thetaprm_j_phiprm_k,\n            kwargs,\n        ) = process_transformation_kwargs(w_modes.ell_max, **kwargs)\n\n        # TODO: Incorporate the w_modes.frame information into rotors, which will require time dependence throughout\n        # It would be best to leave the waveform in its frame.  But we'll have to apply the frame_rotation to the BMS\n        # elements, which will be a little tricky.  Still probably not as tricky as applying to the waveform...\n\n        # We need values of (1) waveform, (2) conformal factor, and (3) supertranslation, at each point of the\n        # transformed grid, at each instant of time.\n        SWSH_j_k = sf.SWSH_grid(R_j_k, w_modes.spin_weight, ell_max)\n        SH_j_k = sf.SWSH_grid(R_j_k, 0, ell_max_supertranslation)  # standard (spin-zero) spherical harmonics\n        r_j_k = np.array([(R * quaternion.z * R.inverse()).vec for R in R_j_k.flat]).T\n        kconformal_j_k = 1.0 \/ (gamma * (1 - np.dot(boost_velocity, r_j_k).reshape(R_j_k.shape)))\n        alphasupertranslation_j_k = np.tensordot(supertranslation, SH_j_k, axes=([0], [2])).real\n        fprm_i_j_k = np.tensordot(\n            w_modes.data,\n            SWSH_j_k[\n                :,\n                :,\n                sf.LM_index(w_modes.ell_min, -w_modes.ell_min, 0) : sf.LM_index(w_modes.ell_max, w_modes.ell_max, 0)\n                + 1,\n            ],\n            axes=([1], [2]),\n        )\n        if beta != 0 or (supertranslation[1:] != 0).any():\n            if w_modes.dataType == h:\n                # Note that SWSH_j_k will use s=-2 in this case, so it can be used in the tensordot correctly\n                supertranslation_deriv = 0.5 * sf.ethbar_GHP(sf.ethbar_GHP(supertranslation, 0, 0), -1, 0)\n                supertranslation_deriv_values = np.tensordot(\n                    supertranslation_deriv,\n                    SWSH_j_k[:, :, : sf.LM_index(ell_max_supertranslation, ell_max_supertranslation, 0) + 1],\n                    axes=([0], [2]),\n                )\n                fprm_i_j_k -= supertranslation_deriv_values[np.newaxis, :, :]\n            elif w_modes.dataType == sigma:\n                # Note that SWSH_j_k will use s=+2 in this case, so it can be used in the tensordot correctly\n                supertranslation_deriv = 0.5 * sf.eth_GHP(sf.eth_GHP(supertranslation, 0, 0), 1, 0)\n                supertranslation_deriv_values = np.tensordot(\n                    supertranslation_deriv,\n                    SWSH_j_k[:, :, : sf.LM_index(ell_max_supertranslation, ell_max_supertranslation, 0) + 1],\n                    axes=([0], [2]),\n                )\n                fprm_i_j_k -= supertranslation_deriv_values[np.newaxis, :, :]\n            elif w_modes.dataType in [psi0, psi1, psi2, psi3]:\n                from scipy.special import comb\n\n                eth_alphasupertranslation_j_k = np.tensordot(\n                    1 \/ np.sqrt(2) * sf.eth_GHP(supertranslation, spin_weight=0),\n                    sf.SWSH_grid(R_j_k, 1, ell_max_supertranslation),\n                    axes=([0], [2]),\n                )\n                v_dot_rhat = np.insert(sf.vector_as_ell_1_modes(boost_velocity), 0, 0.0)\n                eth_v_dot_rhat_j_k = np.tensordot(\n                    1 \/ np.sqrt(2) * v_dot_rhat, sf.SWSH_grid(R_j_k, 1, 1), axes=([0], [2])\n                )\n                eth_uprm_over_kconformal_i_j_k = (\n                    (w_modes.t[:, np.newaxis, np.newaxis] - alphasupertranslation_j_k[np.newaxis, :, :])\n                    * gamma\n                    * kconformal_j_k[np.newaxis, :, :]\n                    * eth_v_dot_rhat_j_k[np.newaxis, :, :]\n                    - eth_alphasupertranslation_j_k[np.newaxis, :, :]\n                )\n                # Loop over the Weyl scalars of higher index than w_modes, and sum\n                # them with appropriate prefactors.\n                for DT in range(w_modes.dataType + 1, psi4 + 1):\n                    try:\n                        w_modes_temp = kwargs.pop(\"psi{}_modes\".format(DataNames[DT][-1]))\n                    except KeyError:\n                        raise ValueError(\n                            \"\\nA BMS transformation of {} requires information from {}, which \"\n                            \"has not been supplied.\".format(w_modes.data_type_string, DataNames[DT])\n                        )\n                    SWSH_temp_j_k = sf.SWSH_grid(R_j_k, w_modes_temp.spin_weight, w_modes_temp.ell_max)\n                    f_i_j_k = np.tensordot(\n                        w_modes_temp.data,\n                        SWSH_temp_j_k[\n                            :,\n                            :,\n                            sf.LM_index(w_modes_temp.ell_min, -w_modes_temp.ell_min, 0) : sf.LM_index(\n                                w_modes_temp.ell_max, w_modes_temp.ell_max, 0\n                            )\n                            + 1,\n                        ],\n                        axes=([1], [2]),\n                    )\n                    fprm_i_j_k += (\n                        comb(5 - w_modes.dataType, 5 - DT)\n                        * f_i_j_k\n                        * eth_uprm_over_kconformal_i_j_k ** (DT - w_modes.dataType)\n                    )\n            elif w_modes.dataType not in [psi4, hdot, news]:\n                warning = (\n                    \"\\nNo BMS transformation is implemented for waveform objects \"\n                    \"of dataType '{}'. Proceeding with the transformation as if it \"\n                    \"were dataType 'Psi4'.\".format(w_modes.data_type_string)\n                )\n                warnings.warn(warning)\n\n        fprm_i_j_k *= (kconformal_j_k ** w_modes.conformal_weight)[np.newaxis, :, :]\n\n        # Determine the new time slices.  The set u' is chosen so that on each slice of constant u'_i, the average value\n        # of u is precisely u_i.  But then, we have to narrow that set down, so that every physical point on all the\n        # u'_i' slices correspond to data in the range of input data.\n        time_translation = sf.constant_from_ell_0_mode(supertranslation[0]).real\n        uprm_i = (1 \/ gamma) * (w_modes.t - time_translation)\n        uprm_min = (kconformal_j_k * (w_modes.t[0] - alphasupertranslation_j_k)).max()\n        uprm_max = (kconformal_j_k * (w_modes.t[-1] - alphasupertranslation_j_k)).min()\n        uprm_iprm = uprm_i[(uprm_i >= uprm_min) & (uprm_i <= uprm_max)]\n\n        # Interpolate along each grid line to the new time in that direction.  Note that if there are additional\n        # dimensions in the waveform data, InterpolatedUnivariateSpline will not be able to handle them automatically,\n        # so we have to loop over them explicitly; an Ellipsis can't handle them.  Also, we are doing all time steps in\n        # one go, for each j,k,... value, which means that we can overwrite the original data\n        final_dim = int(np.prod(fprm_i_j_k.shape[3:]))\n        fprm_i_j_k = fprm_i_j_k.reshape(fprm_i_j_k.shape[:3] + (final_dim,))\n        for j in range(n_theta):\n            for k in range(n_phi):\n                uprm_i_j_k = kconformal_j_k[j, k] * (w_modes.t - alphasupertranslation_j_k[j, k])\n                for final_indices in range(final_dim):\n                    re_fprm_iprm_j_k = interpolate.InterpolatedUnivariateSpline(\n                        uprm_i_j_k, fprm_i_j_k[:, j, k, final_indices].real\n                    )\n                    im_fprm_iprm_j_k = interpolate.InterpolatedUnivariateSpline(\n                        uprm_i_j_k, fprm_i_j_k[:, j, k, final_indices].imag\n                    )\n                    fprm_i_j_k[: len(uprm_iprm), j, k, final_indices] = re_fprm_iprm_j_k(\n                        uprm_iprm\n                    ) + 1j * im_fprm_iprm_j_k(uprm_iprm)\n\n        # Delete the extra rows from fprm_i_j_k, corresponding to values of u' outside of [u'min, u'max]\n        fprm_iprm_j_k = np.delete(fprm_i_j_k, np.s_[len(uprm_iprm) :], 0)\n\n        # Reshape, to have correct final dimensions\n        fprm_iprm_j_k = fprm_iprm_j_k.reshape((fprm_iprm_j_k.shape[0], n_theta * n_phi) + w_modes.data.shape[2:])\n\n        # Encapsulate into a new grid waveform\n        g = cls(\n            t=uprm_iprm,\n            data=fprm_iprm_j_k,\n            history=w_modes.history,\n            n_theta=n_theta,\n            n_phi=n_phi,\n            frameType=w_modes.frameType,\n            dataType=w_modes.dataType,\n            r_is_scaled_out=w_modes.r_is_scaled_out,\n            m_is_scaled_out=w_modes.m_is_scaled_out,\n            constructor_statement=f\"{cls.__name__}.from_modes({w_modes}, **{original_kwargs})\",\n        )\n\n        if kwargs:\n            warnings.warn(\"\\nUnused kwargs passed to this function:\\n{}\".format(pprint.pformat(kwargs, width=1)))\n\n        return g\n\n    @classmethod\n    def transform(cls, w_modes, **kwargs):\n        \"\"\"Transform modes by some BMS transformation\n\n        This simply applies the `WaveformGrid.from_modes` function, followed by the `WaveformGrid.to_modes` function.\n        See their respective docstrings for more details.  However, note that the `ell_max` parameter used in the\n        second function call defaults here to the `ell_max` value in the input waveform.  This is slightly different\n        from the usual default, because `WaveformGrid.from_modes` usually increases the effective ell value by 1.\n\n        \"\"\"\n        if not isinstance(w_modes, WaveformModes):\n            raise TypeError(\n                \"Expected WaveformModes object in argument 1; \" \"got `{}` instead.\".format(type(w_modes).__name__)\n            )\n        ell_max = kwargs.pop(\"ell_max\", w_modes.ell_max)\n        return WaveformGrid.from_modes(w_modes, **kwargs).to_modes(ell_max)\n\n    def __repr__(self):\n        # \"The goal of __str__ is to be readable; the goal of __repr__ is to be unambiguous.\" --- stackoverflow\n        rep = super().__repr__()\n        rep += f\"\\n# n_theta={self.n_theta}, n_phi={self.n_phi}\"\n        return rep\n\n\n# Now, we can assign WaveformModes objects new capabilities based on WaveformGrid functions\nWaveformModes.to_grid = lambda w_modes, **kwargs: WaveformGrid.from_modes(w_modes, **kwargs)\nWaveformModes.from_grid = classmethod(lambda cls, w_grid, ell_max: WaveformGrid.to_modes(w_grid, ell_max))\n#WaveformModes.transform = lambda w_mode, **kwargs: WaveformGrid.transform(w_mode, **kwargs)  # Move to WaveformModes class\nif sys.version_info[0] == 2:\n    WaveformModes.to_grid.__func__.__doc__ = WaveformGrid.from_modes.__doc__\n    WaveformModes.from_grid.__func__.__doc__ = WaveformGrid.to_modes.__doc__\n    # WaveformModes.transform.__func__.__doc__ = WaveformGrid.transform.__doc__\nelse:\n    WaveformModes.to_grid.__doc__ = WaveformGrid.from_modes.__doc__\n    WaveformModes.from_grid.__func__.__doc__ = WaveformGrid.to_modes.__doc__\n    # WaveformModes.transform.__doc__ = WaveformGrid.transform.__doc__\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_200","text":"#!\/usr\/bin\/env python\n\nimport sys\nimport argparse\nimport os.path\nimport pandas as pd\nimport csv\nimport gzip\nimport statistics\n\nfrom Bio import SeqIO\n\n\ndef parse_args(args=None):\n    parser = argparse.ArgumentParser()\n    parser.add_argument('-b', '--bins'         , required=True, nargs=\"+\", metavar='FILE'                             , help=\"Bins: FASTA containing all contigs.\")\n    parser.add_argument('-d', '--depths'       , required=True           , metavar='FILE'                             , help=\"(Compressed) TSV file containing contig depths for each sample: contigName, contigLen, totalAvgDepth, sample1_avgDepth, sample1_var [, sample2_avgDepth, sample2_var, ...].\")\n    parser.add_argument('-a', '--assembly_name', required=True                           , type=str                   , help=\"Assembly name.\")\n    parser.add_argument('-o', \"--out\"          , required=True           , metavar='FILE', type=argparse.FileType('w'), help=\"Output file containing depth for each bin.\")\n    return parser.parse_args(args)\n\ndef main(args=None):\n    args = parse_args(args)\n\n    # load contig depths for all samples into dict (could use pandas as well)\n    sample_names = []\n    dict_contig_depths = {}\n    with gzip.open(args.depths, \"rt\") as infile:\n        reader = csv.reader(infile, delimiter = \"\\t\")\n        # process header\n        header = next(reader)\n        for sample in range(int((len(header)-3)\/2)):\n            col_name = header[3+2*sample]\n            # retrieve sample name: \"<assembly_name>-<sample_name>.bam\"\n            sample_name = col_name[len(args.assembly_name)+1:-4]\n            sample_names.append(sample_name)\n        # process contig depths\n        for row in reader:\n            contig_depths = []\n            for sample in range(int((len(row)-3)\/2)):\n                contig_depths.append(float(row[3+2*sample]))\n            dict_contig_depths[str(row[0])] = contig_depths\n\n    n_samples = len(sample_names)\n    # for each bin, access contig depths and compute mean bin depth (for all samples)\n    print(\"bin\", '\\t'.join(sample_names), sep='\\t', file=args.out)\n    for file in args.bins:\n        all_depths = [[] for i in range(n_samples)]\n        with open(file, \"rt\") as infile:\n            for rec in SeqIO.parse(infile,'fasta'):\n                contig_depths = dict_contig_depths[rec.id]\n                for sample in range(n_samples):\n                    all_depths[sample].append(contig_depths[sample])\n        print(os.path.basename(file), '\\t'.join(str(statistics.median(sample_depths)) for sample_depths in all_depths), sep='\\t', file=args.out)\n\n\nif __name__ == \"__main__\":\n    sys.exit(main())\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_204","text":"<filename>test_anwei.py\nfrom modulefinder import Module\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport os\nimport sys\n# from numpy import linspace\n#\nfrom data.data_loader import Dataset_ETT_hour\nimport time\nimport pandas as pd\nfrom scipy.fftpack import dct, idct\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n#### FOURRIER\n# # preprocessing\ndata = pd.read_csv('\/Users\/marc-antoine\/Documents\/S7\/物理实验\/gch\/erhao.csv', sep=';')\ntemps = data['Temps'].to_numpy()[20:]\nvolt = data['EA1'].rolling(10).mean().to_numpy()[20:]\n# volt *= 1.0293\nvolt -= volt.mean()\n# temps = np.concatenate((temps, np.linspace(80, 90, 10000)))\n# volt = np.concatenate((volt, volt[74980:79980]\/2))\n# volt = np.concatenate((volt, volt[74980:79980]\/2))\nfont2 = {'weight': 'normal',\n         'size': 14,\n         }\n\n# I(t)\nplt.plot(temps, (volt+1.356)*1.0293-0.5508, linewidth=0.5, color='black')\nplt.xlabel('T\/s', font2)\nplt.ylabel('I\/cd', font2)\nplt.grid()\nplt.xlim(43, 80)\nplt.ylim(0.5, 2)\nplt.savefig('\/Users\/marc-antoine\/Documents\/S7\/物理实验\/gch\/I(t).jpg')\nplt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_432","text":"<reponame>YileC928\/finm-portfolio-2021\n\"\"\"\nMean models to use with ARCH processes.  All mean models must inherit from\n:class:`ARCHModel` and provide the same methods with the same inputs.\n\"\"\"\nfrom __future__ import annotations\n\nimport copy\nimport sys\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Callable,\n    Dict,\n    List,\n    Mapping,\n    Optional,\n    Sequence,\n    Tuple,\n    Union,\n    cast,\n)\n\nimport numpy as np\nfrom pandas import DataFrame, Index\nfrom scipy.optimize import OptimizeResult\nfrom statsmodels.tsa.tsatools import lagmat\n\nfrom arch.__future__._utility import check_reindex\nfrom arch.typing import ArrayLike, ArrayLike1D, DateLike, Label, NDArray\nfrom arch.univariate.base import (\n    ARCHModel,\n    ARCHModelForecast,\n    ARCHModelResult,\n    implicit_constant,\n)\nfrom arch.univariate.distribution import (\n    Distribution,\n    GeneralizedError,\n    Normal,\n    SkewStudent,\n    StudentsT,\n)\nfrom arch.univariate.volatility import (\n    ARCH,\n    EGARCH,\n    FIGARCH,\n    GARCH,\n    HARCH,\n    ConstantVariance,\n    VolatilityProcess,\n)\nfrom arch.utility.array import (\n    AbstractDocStringInheritor,\n    cutoff_to_index,\n    ensure1d,\n    parse_dataframe,\n)\nfrom arch.vendor import cached_property\n\nif sys.version_info >= (3, 8):\n    from typing import Literal\nelif TYPE_CHECKING:\n    from typing_extensions import Literal\n\n__all__ = [\"HARX\", \"ConstantMean\", \"ZeroMean\", \"ARX\", \"arch_model\", \"LS\"]\n\nCOV_TYPES = {\n    \"white\": \"White's Heteroskedasticity Consistent Estimator\",\n    \"classic_ols\": \"Homoskedastic (Classic)\",\n    \"robust\": \"Bollerslev-Wooldridge (Robust) Estimator\",\n    \"mle\": \"ML Estimator\",\n    \"classic\": \"ML Estimator\",\n}\n\n\ndef _forecast_pad(count: int, forecasts: NDArray) -> NDArray:\n    shape = list(forecasts.shape)\n    shape[0] = count\n    fill = np.full(tuple(shape), np.nan)\n    return np.concatenate((fill, forecasts))\n\n\ndef _ar_forecast(\n    y: NDArray,\n    horizon: int,\n    start_index: int,\n    constant: float,\n    arp: NDArray,\n    x: NDArray,\n    exogp: NDArray,\n) -> NDArray:\n    \"\"\"\n    Generate mean forecasts from an AR-X model\n\n    Parameters\n    ----------\n    y : ndarray\n    horizon : int\n    start_index : int\n    constant : float\n    arp : ndarray\n    exogp : ndarray\n    x : ndarray\n\n    Returns\n    -------\n    forecasts : ndarray\n    \"\"\"\n    t = y.shape[0]\n    p = arp.shape[0]\n    fcasts = np.empty((t - start_index, p + horizon))\n    for i in range(p):\n        first = start_index - p + i + 1\n        last = t - p + i + 1\n        fcasts[:, i] = y[first:last]\n    arp_rev = arp[::-1]\n    for i in range(p, horizon + p):\n        fcasts[:, i] = constant + fcasts[:, i - p : i].dot(arp_rev)\n        if x.shape[0] > 0:\n            fcasts[:, i] += x[:, :, i - p].T @ exogp\n    fcasts = fcasts[:, p:]\n\n    return fcasts\n\n\ndef _ar_to_impulse(steps: int, params: NDArray) -> NDArray:\n    p = params.shape[0]\n    impulse = np.zeros(steps)\n    impulse[0] = 1\n    if p == 0:\n        return impulse\n\n    for i in range(1, steps):\n        k = min(p - 1, i - 1)\n        st = max(i - p, 0)\n        impulse[i] = impulse[st:i].dot(params[k::-1])\n\n    return impulse\n\n\nclass HARX(ARCHModel, metaclass=AbstractDocStringInheritor):\n    r\"\"\"\n    Heterogeneous Autoregression (HAR), with optional exogenous regressors,\n    model estimation and simulation\n\n    Parameters\n    ----------\n    y : {ndarray, Series}\n        nobs element vector containing the dependent variable\n    x : {ndarray, DataFrame}, optional\n        nobs by k element array containing exogenous regressors\n    lags : {scalar, ndarray}, optional\n        Description of lag structure of the HAR.\n\n        * Scalar included all lags between 1 and the value.\n        * A 1-d n-element array includes the HAR lags 1:lags[0]+1,\n          1:lags[1]+1, ... 1:lags[n]+1.\n        * A 2-d (2,n)-element array that includes the HAR lags of the form\n          lags[0,j]:lags[1,j]+1 for all columns of lags.\n\n    constant : bool, optional\n        Flag whether the model should include a constant\n    use_rotated : bool, optional\n        Flag indicating to use the alternative rotated form of the HAR where\n        HAR lags do not overlap\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    volatility : VolatilityProcess, optional\n        Volatility process to use in the model\n    distribution : Distribution, optional\n        Error distribution to use in the model\n    rescale : bool, optional\n        Flag indicating whether to automatically rescale data if the scale of the\n        data is likely to produce convergence issues when estimating model parameters.\n        If False, the model is estimated on the data without transformation.  If True,\n        than y is rescaled and the new scale is reported in the estimation results.\n\n    Examples\n    --------\n    Standard HAR with average lags 1, 5 and 22\n\n    >>> import numpy as np\n    >>> from arch.univariate import HARX\n    >>> y = np.random.RandomState(1234).randn(100)\n    >>> harx = HARX(y, lags=[1, 5, 22])\n    >>> res = harx.fit()\n\n\n    A standard HAR with average lags 1 and 6 but holding back 10 observations\n\n    >>> from pandas import Series, date_range\n    >>> index = date_range('2000-01-01', freq='M', periods=y.shape[0])\n    >>> y = Series(y, name='y', index=index)\n    >>> har = HARX(y, lags=[1, 6], hold_back=10)\n\n    Models with equivalent parametrizations of lags. The first uses\n    overlapping lags.\n\n    >>> harx_1 = HARX(y, lags=[1,5,22])\n\n    The next uses rotated lags so that they do not overlap.\n\n    >>> harx_2 = HARX(y, lags=[1,5,22], use_rotated=True)\n\n    The third manually specified overlapping lags.\n\n    >>> harx_3 = HARX(y, lags=[[1, 1, 1], [1, 5, 22]])\n\n    The final manually specified non-overlapping lags\n\n    >>> harx_4 = HARX(y, lags=[[1, 2, 6], [1, 5, 22]])\n\n    It is simple to verify that these are the equivalent by inspecting the R2.\n\n    >>> models = [harx_1, harx_2, harx_3, harx_4]\n    >>> print([mod.fit().rsquared for mod in models])\n    0.085, 0.085, 0.085, 0.085\n\n    Notes\n    -----\n    The HAR-X model is described by\n\n    .. math::\n\n        y_t = \\mu + \\sum_{i=1}^p \\phi_{L_{i}} \\bar{y}_{t-L_{i,0}:L_{i,1}}\n        + \\gamma' x_t + \\epsilon_t\n\n    where :math:`\\bar{y}_{t-L_{i,0}:L_{i,1}}` is the average value of\n    :math:`y_t` between :math:`t-L_{i,0}` and :math:`t - L_{i,1}`.\n    \"\"\"\n\n    def __init__(\n        self,\n        y: Optional[ArrayLike] = None,\n        x: Optional[ArrayLike] = None,\n        lags: Optional[\n            Union[int, Sequence[int], Sequence[Sequence[int]], NDArray]\n        ] = None,\n        constant: bool = True,\n        use_rotated: bool = False,\n        hold_back: Optional[int] = None,\n        volatility: Optional[VolatilityProcess] = None,\n        distribution: Optional[Distribution] = None,\n        rescale: Optional[bool] = None,\n    ) -> None:\n        super().__init__(\n            y,\n            hold_back=hold_back,\n            volatility=volatility,\n            distribution=distribution,\n            rescale=rescale,\n        )\n        self._x = x\n        self._x_names: List[str] = []\n        self._x_index: Optional[Union[NDArray, Index]] = None\n        self.lags: Optional[\n            Union[int, Sequence[int], Sequence[Sequence[int]], NDArray]\n        ] = lags\n        self._lags = np.empty(0)\n        self.constant: bool = constant\n        self.use_rotated: bool = use_rotated\n        self.regressors: np.ndarray[Any, np.dtype[np.float64]] = np.empty(\n            (0, 0), dtype=np.float64\n        )\n\n        self._name = \"HAR\"\n        if self._x is not None:\n            self._name += \"-X\"\n        if lags is not None:\n            max_lags = int(np.max(np.asarray(lags, dtype=np.int32)))\n        else:\n            max_lags = 0\n        self._max_lags = max_lags\n\n        self._hold_back = max_lags if hold_back is None else hold_back\n\n        if self._hold_back < max_lags:\n            from warnings import warn\n\n            warn(\n                \"hold_back is less then the minimum number given the lags selected\",\n                RuntimeWarning,\n            )\n            self._hold_back = max_lags\n\n        self._init_model()\n\n    @property\n    def x(self) -> ArrayLike:\n        \"\"\"Gets the value of the exogenous regressors in the model\"\"\"\n        return self._x\n\n    def parameter_names(self) -> List[str]:\n        return self._generate_variable_names()\n\n    def _model_description(self, include_lags: bool = True) -> Dict[str, str]:\n        \"\"\"Generates the model description for use by __str__ and related\n        functions\"\"\"\n        lagstr = \"none\"\n        if include_lags and self.lags is not None:\n            assert self._lags is not None\n            lagstr_comp = [f\"[{lag[0]}:{lag[1]}]\" for lag in self._lags.T]\n            lagstr = \", \".join(lagstr_comp)\n        xstr = str(self._x.shape[1]) if self._x is not None else \"0\"\n        conststr = \"yes\" if self.constant else \"no\"\n        od = {\"constant\": conststr}\n        if include_lags:\n            od[\"lags\"] = lagstr\n        od[\"no. of exog\"] = xstr\n        od[\"volatility\"] = self.volatility.__str__()\n        od[\"distribution\"] = self.distribution.__str__()\n        return od\n\n    def __str__(self) -> str:\n        descr = self._model_description()\n        descr_str = self.name + \"(\"\n        for key, val in descr.items():\n            if val and key:\n                descr_str += key + \": \" + val + \", \"\n        descr_str = descr_str[:-2]  # Strip final ', '\n        descr_str += \")\"\n\n        return descr_str\n\n    def __repr__(self) -> str:\n        txt = self.__str__()\n        txt.replace(\"\\n\", \"\")\n        return txt + \", id: \" + hex(id(self))\n\n    def _repr_html_(self) -> str:\n        \"\"\"HTML representation for IPython Notebook\"\"\"\n        descr = self._model_description()\n        html = \"<strong>\" + self.name + \"<\/strong>(\"\n        for key, val in descr.items():\n            html += \"<strong>\" + key + \": <\/strong>\" + val + \",\\n\"\n        html += \"<strong>ID: <\/strong> \" + hex(id(self)) + \")\"\n        return html\n\n    def resids(\n        self,\n        params: NDArray,\n        y: Optional[ArrayLike] = None,\n        regressors: Optional[ArrayLike] = None,\n    ) -> ArrayLike:\n        regressors = self._fit_regressors if y is None else regressors\n        y = self._fit_y if y is None else y\n        assert regressors is not None\n        return y - regressors.dot(params)\n\n    @cached_property\n    def num_params(self) -> int:\n        \"\"\"\n        Returns the number of parameters\n        \"\"\"\n        assert self.regressors is not None\n        return int(self.regressors.shape[1])\n\n    def simulate(\n        self,\n        params: Union[NDArray, Sequence[float]],\n        nobs: int,\n        burn: int = 500,\n        initial_value: Optional[Union[float, NDArray]] = None,\n        x: Optional[ArrayLike] = None,\n        initial_value_vol: Optional[Union[float, NDArray]] = None,\n    ) -> DataFrame:\n        \"\"\"\n        Simulates data from a linear regression, AR or HAR models\n\n        Parameters\n        ----------\n        params : ndarray\n            Parameters to use when simulating the model.  Parameter order is\n            [mean volatility distribution] where the parameters of the mean\n            model are ordered [constant lag[0] lag[1] ... lag[p] ex[0] ...\n            ex[k-1]] where lag[j] indicates the coefficient on the jth lag in\n            the model and ex[j] is the coefficient on the jth exogenous\n            variable.\n        nobs : int\n            Length of series to simulate\n        burn : int, optional\n            Number of values to simulate to initialize the model and remove\n            dependence on initial values.\n        initial_value : {ndarray, float}, optional\n            Either a scalar value or `max(lags)` array set of initial values to\n            use when initializing the model.  If omitted, 0.0 is used.\n        x : {ndarray, DataFrame}, optional\n            nobs + burn by k array of exogenous variables to include in the\n            simulation.\n        initial_value_vol : {ndarray, float}, optional\n            An array or scalar to use when initializing the volatility process.\n\n        Returns\n        -------\n        simulated_data : DataFrame\n            DataFrame with columns data containing the simulated values,\n            volatility, containing the conditional volatility and errors\n            containing the errors used in the simulation\n\n        Examples\n        --------\n        >>> import numpy as np\n        >>> from arch.univariate import HARX, GARCH\n        >>> harx = HARX(lags=[1, 5, 22])\n        >>> harx.volatility = GARCH()\n        >>> harx_params = np.array([1, 0.2, 0.3, 0.4])\n        >>> garch_params = np.array([0.01, 0.07, 0.92])\n        >>> params = np.concatenate((harx_params, garch_params))\n        >>> sim_data = harx.simulate(params, 1000)\n\n        Simulating models with exogenous regressors requires the regressors\n        to have nobs plus burn data points\n\n        >>> nobs = 100\n        >>> burn = 200\n        >>> x = np.random.randn(nobs + burn, 2)\n        >>> x_params = np.array([1.0, 2.0])\n        >>> params = np.concatenate((harx_params, x_params, garch_params))\n        >>> sim_data = harx.simulate(params, nobs=nobs, burn=burn, x=x)\n        \"\"\"\n\n        k_x = 0\n        if x is None:\n            x = np.empty((nobs + burn, 0))\n        else:\n            x = np.asarray(x)\n        k_x = x.shape[1]\n        if x.shape[0] != nobs + burn:\n            raise ValueError(\"x must have nobs + burn rows\")\n        assert self._lags is not None\n        mc = int(self.constant) + self._lags.shape[1] + k_x\n        vc = self.volatility.num_params\n        dc = self.distribution.num_params\n        num_params = mc + vc + dc\n        params = cast(NDArray, ensure1d(params, \"params\", series=False))\n        if params.shape[0] != num_params:\n            raise ValueError(\n                \"params has the wrong number of elements. \"\n                \"Expected \" + str(num_params) + \", got \" + str(params.shape[0])\n            )\n\n        dist_params = [] if dc == 0 else params[-dc:]\n        vol_params = params[mc : mc + vc]\n        simulator = self.distribution.simulate(dist_params)\n        sim_data = self.volatility.simulate(\n            vol_params, nobs + burn, simulator, burn, initial_value_vol\n        )\n        errors = sim_data[0]\n        vol = cast(NDArray, np.sqrt(sim_data[1]))\n\n        max_lag = np.max(self._lags)\n        y = np.zeros(nobs + burn)\n        if initial_value is None:\n            initial_value = 0.0\n        elif not np.isscalar(initial_value):\n            initial_value = ensure1d(initial_value, \"initial_value\")\n            if initial_value.shape[0] != max_lag:\n                raise ValueError(\"initial_value has the wrong shape\")\n        y[:max_lag] = initial_value\n\n        for t in range(max_lag, nobs + burn):\n            ind = 0\n            if self.constant:\n                y[t] = params[ind]\n                ind += 1\n            for lag in self._lags.T:\n                y[t] += params[ind] * y[t - lag[1] : t - lag[0]].mean()\n                ind += 1\n            for i in range(k_x):\n                y[t] += params[ind] * x[t, i]\n            y[t] += errors[t]\n\n        df = dict(data=y[burn:], volatility=vol[burn:], errors=errors[burn:])\n        df = DataFrame(df)\n        return df\n\n    def _generate_variable_names(self) -> List[str]:\n        \"\"\"Generates variable names or use in summaries\"\"\"\n        variable_names = []\n        lags = self._lags\n        if self.constant:\n            variable_names.append(\"Const\")\n        if lags is not None and lags.size:\n            variable_names.extend(self._generate_lag_names())\n        if self._x is not None:\n            variable_names.extend(self._x_names)\n        return variable_names\n\n    def _generate_lag_names(self) -> List[str]:\n        \"\"\"Generates lag names.  Overridden by other models\"\"\"\n        lags = self._lags\n        names = []\n        var_name = self._y_series.name\n        if len(var_name) > 10:\n            var_name = var_name[:4] + \"...\" + var_name[-3:]\n        for i in range(lags.shape[1]):\n            names.append(var_name + \"[\" + str(lags[0, i]) + \":\" + str(lags[1, i]) + \"]\")\n        return names\n\n    def _check_specification(self) -> None:\n        \"\"\"Checks the specification for obvious errors \"\"\"\n        if self._x is not None:\n            if self._x.ndim == 1:\n                self._x = self._x[:, None]\n            if self._x.ndim != 2 or self._x.shape[0] != self._y.shape[0]:\n                raise ValueError(\n                    \"x must be nobs by n, where nobs is the same as \"\n                    \"the number of elements in y\"\n                )\n            def_names = [\"x\" + str(i) for i in range(self._x.shape[1])]\n            names, self._x_index = parse_dataframe(self._x, def_names)\n            self._x_names = [str(name) for name in names]\n            self._x = np.asarray(self._x)\n\n    def _reformat_lags(self) -> None:\n        \"\"\"\n        Reformat input lags to be a 2 by m array, which simplifies other\n        operations.  Output is stored in _lags\n        \"\"\"\n\n        if self.lags is None:\n            return\n        lags = np.asarray(self.lags)\n        if np.any(lags < 0):\n            raise ValueError(\"Input to lags must be non-negative\")\n\n        if lags.ndim == 0:\n            lags = np.arange(1, int(lags) + 1)\n\n        if lags.ndim == 1:\n            if np.any(lags <= 0):\n                raise ValueError(\n                    \"When using the 1-d format of lags, values must be positive\"\n                )\n            lags = np.unique(lags)\n            temp = np.array([lags, lags])\n            if self.use_rotated:\n                temp[0, 1:] = temp[0, 0:-1]\n                temp[0, 0] = 0\n            else:\n                temp[0, :] = 0\n            self._lags = temp\n        elif lags.ndim == 2:\n            if lags.shape[0] != 2:\n                raise ValueError(\"When using a 2-d array, lags must by k by 2\")\n            if np.any(lags[0] <= 0) or np.any(lags[1] < lags[0]):\n                raise ValueError(\n                    \"When using a 2-d array, all values must be larger than 0 and \"\n                    \"lags[0,j] <= lags[1,j] for all lags values.\"\n                )\n            ind = np.lexsort(np.flipud(lags))\n            lags = lags[:, ind]\n            test_mat = np.zeros((lags.shape[1], np.max(lags)))\n            # Subtract 1 so first is 0 indexed\n            lags = lags - np.array([[1], [0]])\n            for i in range(lags.shape[1]):\n                test_mat[i, lags[0, i] : lags[1, i]] = 1.0\n            rank = np.linalg.matrix_rank(test_mat)\n            if rank != lags.shape[1]:\n                raise ValueError(\"lags contains redundant entries\")\n\n            self._lags = lags\n            if self.use_rotated:\n                from warnings import warn\n\n                warn(\"Rotation is not available when using the 2-d lags input format\")\n        else:\n            raise ValueError(\"Incorrect format for lags\")\n\n    def _har_to_ar(self, params: NDArray) -> NDArray:\n        if self._max_lags == 0:\n            return params\n        har = params[int(self.constant) :]\n        ar = np.zeros(self._max_lags)\n        for value, lag in zip(har, self._lags.T):\n            ar[lag[0] : lag[1]] += value \/ (lag[1] - lag[0])\n        if self.constant:\n            ar = np.concatenate((params[:1], ar))\n        return ar\n\n    def _init_model(self) -> None:\n        \"\"\"Should be called whenever the model is initialized or changed\"\"\"\n        self._reformat_lags()\n        self._check_specification()\n\n        nobs_orig = self._y.shape[0]\n        if self.constant:\n            reg_constant = np.ones((nobs_orig, 1), dtype=np.float64)\n        else:\n            reg_constant = np.ones((nobs_orig, 0), dtype=np.float64)\n\n        if self.lags is not None and nobs_orig > 0:\n            maxlag = np.max(self.lags)\n            lag_array = lagmat(self._y, maxlag)\n            reg_lags = np.empty((nobs_orig, self._lags.shape[1]), dtype=np.float64)\n            for i, lags in enumerate(self._lags.T):\n                reg_lags[:, i] = np.mean(lag_array[:, lags[0] : lags[1]], 1)\n        else:\n            reg_lags = np.empty((nobs_orig, 0), dtype=np.float64)\n\n        if self._x is not None:\n            reg_x = self._x\n        else:\n            reg_x = np.empty((nobs_orig, 0), dtype=np.float64)\n\n        self.regressors = np.hstack((reg_constant, reg_lags, reg_x))\n\n    def _r2(self, params: NDArray) -> float:\n        y = self._fit_y\n        constant = False\n        x = self._fit_regressors\n        if x is not None and x.shape[1] > 0:\n            constant = self.constant or implicit_constant(x)\n        if constant:\n            if x.shape[1] == 1:\n                # Shortcut for constant only\n                return 0.0\n            y = y - np.mean(y)\n        tss = float(y.dot(y))\n        if tss <= 0.0:\n            return np.nan\n        e = self.resids(params)\n\n        return 1.0 - float(e.T.dot(e)) \/ tss\n\n    def _adjust_sample(\n        self,\n        first_obs: Optional[Union[int, DateLike]],\n        last_obs: Optional[Union[int, DateLike]],\n    ) -> None:\n        index = self._y_series.index\n        _first_obs_index = cutoff_to_index(first_obs, index, 0)\n        _first_obs_index += self._hold_back\n        _last_obs_index = cutoff_to_index(last_obs, index, self._y.shape[0])\n        if _last_obs_index <= _first_obs_index:\n            raise ValueError(\"first_obs and last_obs produce in an empty array.\")\n        self._fit_indices = [_first_obs_index, _last_obs_index]\n        self._fit_y = self._y[_first_obs_index:_last_obs_index]\n        reg = self.regressors\n        self._fit_regressors = reg[_first_obs_index:_last_obs_index]\n        self.volatility.start, self.volatility.stop = self._fit_indices\n\n    def _fit_no_arch_normal_errors_params(self) -> NDArray:\n        \"\"\"\n        Estimates model parameters excluding sigma2\n\n        Returns\n        -------\n        params : ndarray\n            Array of estiamted parameters\n        \"\"\"\n        assert self._fit_y is not None\n        nobs = self._fit_y.shape[0]\n\n        if nobs < self.num_params:\n            raise ValueError(\n                \"Insufficient data, \"\n                + str(self.num_params)\n                + \" regressors, \"\n                + str(nobs)\n                + \" data points available\"\n            )\n        x = self._fit_regressors\n        y = self._fit_y\n\n        return np.empty(0) if x.shape[1] == 0 else np.linalg.pinv(x).dot(y)\n\n    def _fit_no_arch_normal_errors(\n        self, cov_type: Literal[\"robust\", \"classic\"] = \"robust\"\n    ) -> ARCHModelResult:\n        \"\"\"\n        Estimates model parameters\n\n        Parameters\n        ----------\n        cov_type : str, optional\n            Covariance estimator to use when estimating parameter variances and\n            covariances.  'robust' for Whites's covariance estimator, or 'classic' for\n            the classic estimator appropriate for homoskedastic data.  'robust' is the\n            the default.\n\n        Returns\n        -------\n        result : ARCHModelResult\n            Results class containing parameter estimates, estimated parameter\n            covariance and related estimates\n\n        Notes\n        -----\n        See :class:`ARCHModelResult` for details on computed results\n        \"\"\"\n        assert self._fit_y is not None\n        nobs = self._fit_y.shape[0]\n\n        if nobs < self.num_params:\n            raise ValueError(\n                \"Insufficient data, \"\n                + str(self.num_params)\n                + \" regressors, \"\n                + str(nobs)\n                + \" data points available\"\n            )\n        x = self._fit_regressors\n        y = self._fit_y\n\n        # Fake convergence results, see GH #87\n        opt = OptimizeResult({\"status\": 0, \"message\": \"\"})\n\n        if x.shape[1] > 0:\n            regression_params = np.linalg.pinv(x).dot(y)\n            xpxi = np.linalg.inv(x.T.dot(x) \/ nobs)\n            fitted = x.dot(regression_params)\n        else:\n            regression_params = np.empty(0)\n            xpxi = np.empty((0, 0))\n            fitted = 0.0\n\n        e = y - fitted\n        sigma2 = e.T.dot(e) \/ nobs\n\n        params = np.hstack((regression_params, sigma2))\n        hessian = np.zeros((self.num_params + 1, self.num_params + 1))\n        hessian[: self.num_params, : self.num_params] = -xpxi\n        hessian[-1, -1] = -1\n        if cov_type in (\"classic\",):\n            param_cov = sigma2 * -hessian\n            param_cov[self.num_params, self.num_params] = 2 * sigma2 ** 2.0\n            param_cov \/= nobs\n            cov_type_name = COV_TYPES[\"classic_ols\"]\n        elif cov_type in (\"robust\",):\n            scores = np.zeros((nobs, self.num_params + 1))\n            scores[:, : self.num_params] = x * e[:, None]\n            scores[:, -1] = e ** 2.0 - sigma2\n            score_cov = np.asarray(scores.T.dot(scores) \/ nobs)\n            param_cov = (hessian @ score_cov @ hessian) \/ nobs\n            cov_type_name = COV_TYPES[\"white\"]\n        else:\n            raise ValueError(\"Unknown cov_type\")\n\n        r2 = self._r2(regression_params)\n\n        first_obs, last_obs = self._fit_indices\n        resids = np.empty_like(self._y, dtype=np.float64)\n        resids.fill(np.nan)\n        resids[first_obs:last_obs] = e\n        vol = np.zeros_like(resids)\n        vol.fill(np.nan)\n        vol[first_obs:last_obs] = np.sqrt(sigma2)\n        names = self._all_parameter_names()\n        loglikelihood = self._static_gaussian_loglikelihood(e)\n\n        # Throw away names in the case of starting values\n        num_params = params.shape[0]\n        if len(names) != num_params:\n            names = [\"p\" + str(i) for i in range(num_params)]\n\n        fit_start, fit_stop = self._fit_indices\n        return ARCHModelResult(\n            params,\n            param_cov,\n            r2,\n            resids,\n            vol,\n            cov_type_name,\n            self._y_series,\n            names,\n            loglikelihood,\n            self._is_pandas,\n            opt,\n            fit_start,\n            fit_stop,\n            copy.deepcopy(self),\n        )\n\n    def _reformat_forecast_x(\n        self,\n        x: Union[None, Dict[Label, ArrayLike], ArrayLike],\n        horizon: int,\n        start: int,\n    ) -> NDArray:\n        \"\"\"\n        Always return a correctly formatted 3-d array\n\n        Parameters\n        ----------\n        x: Union[None, Dict[Label, ArrayLike], ArrayLike] = None\n            The input data to reformat\n\n        Returns\n        -------\n        ndarray\n            The 3-d array suitable for computing forecasts. Always has shape\n            (nx, nobs - start, horizon).\n        \"\"\"\n        if x is None:\n            if self._x is None:\n                return np.empty(0)\n            else:\n                raise TypeError(\n                    \"x is None but the model contains exogenous variables. You must \"\n                    \"provide expected values to use for the exogenous variables to \"\n                    \"construct forecasts.\"\n                )\n        elif self._x is None:\n            raise TypeError(\n                \"x is not None but the model does not contain any exogenous \"\n                \"variables.\"\n            )\n        assert self._x is not None\n        nx = self._x.shape[1]\n        if isinstance(x, Mapping):\n            if len(x) != nx:\n                raise ValueError(\n                    \"x must have the same number of entries as the number of x \"\n                    f\"variables included in the model ({nx})\"\n                )\n            collected: List[NDArray] = []\n            for key in self._x_names:\n                if key not in x:\n                    keys = \", \".join([str(k) for k in x.keys()])\n                    raise KeyError(\n                        \"The keys of x must exactly match the variable names of \"\n                        f\"the included exogenous regressors. {key} not found in: \"\n                        f\"{keys}\"\n                    )\n                temp = np.asarray(x[key])\n                if temp.ndim == 1:\n                    temp = temp.reshape((1, -1))\n                collected.append(temp)\n            base_shape = collected[0].shape\n            shapes = [v.shape == base_shape for v in collected]\n            if not all(shapes):\n                raise ValueError(\n                    \"The shapes of the arrays contained in the dictionary differ. \"\n                    \"These must all be the same and satisfy the requirement for \"\n                    \"expected x values.\"\n                )\n            if len(base_shape) != 2:\n                raise ValueError(\n                    \"The arrays contained in the dictionary must be 1 or 2-dimensional.\"\n                )\n            arr: NDArray = np.array(collected)\n        else:\n            arr = np.asarray(x)\n\n            if arr.ndim == 1:\n                arr = arr.reshape((1, -1))\n            if arr.ndim == 2:\n                if nx != 1:\n                    raise ValueError(\n                        \"1- and 2-dimensional x values can only be used when the \"\n                        f\"model has a single exogenous regressor.  The model has {nx} \"\n                        \"exogenous regressors, and so you must use either a \"\n                        \"dictionary or a 3-dimensional NumPy array.\"\n                    )\n                arr = arr.reshape((1,) + arr.shape)\n            if arr.shape[0] != self._x.shape[1]:\n                raise ValueError(\n                    \"The leading dimension of x must match the number of x variables \"\n                    f\"included in the model ({nx})\"\n                )\n        assert isinstance(arr, np.ndarray)\n        if arr.shape[2] != horizon:\n            raise ValueError(\n                f\"The number of values passed {arr.shape[2]} does not match the \"\n                f\"horizon of the forecasts ({horizon}).\"\n            )\n        possible_nobs = (self._y.shape[0], self._y.shape[0] - start)\n        if arr.shape[1] not in possible_nobs:\n            raise ValueError(\n                \"The shape of x does not satisfy the requirements for expected \"\n                \"exogenous regressors.  The number of values must either match \"\n                f\"the original sample size ({self._y.shape[0]}) or the number of \"\n                f\"forecasts ({self._y.shape[0] - start}).\"\n            )\n        if arr.shape[1] > (self._y.shape[0] - start):\n            arr = arr[:, start:]\n        return arr\n\n    def forecast(\n        self,\n        params: ArrayLike1D,\n        horizon: int = 1,\n        start: Optional[Union[int, DateLike]] = None,\n        align: str = \"origin\",\n        method: str = \"analytic\",\n        simulations: int = 1000,\n        rng: Optional[Callable[[Union[int, Tuple[int, ...]]], NDArray]] = None,\n        random_state: Optional[np.random.RandomState] = None,\n        *,\n        reindex: Optional[bool] = None,\n        x: Union[None, Dict[Label, ArrayLike], ArrayLike] = None,\n    ) -> ARCHModelForecast:\n        reindex = check_reindex(reindex)\n        if not isinstance(horizon, (int, np.integer)) or horizon < 1:\n            raise ValueError(\"horizon must be an integer >= 1.\")\n        # Check start\n        earliest, default_start = self._fit_indices\n        default_start = max(0, default_start - 1)\n        start_index = cutoff_to_index(start, self._y_series.index, default_start)\n        if start_index < (earliest - 1):\n            raise ValueError(\n                \"Due to backcasting and\/or data availability start cannot be less \"\n                \"than the index of the largest value in the right-hand-side \"\n                \"variables used to fit the first observation.  In this model, \"\n                \"this value is {0}.\".format(max(0, earliest - 1))\n            )\n        # Parse params\n        params = np.asarray(params)\n        mp, vp, dp = self._parse_parameters(params)\n\n        #####################################\n        # Compute residual variance forecasts\n        #####################################\n        # Back cast should use only the sample used in fitting\n        resids = self.resids(mp)\n        backcast = self._volatility.backcast(resids)\n        full_resids = self.resids(mp, self._y[earliest:], self.regressors[earliest:])\n        vb = self._volatility.variance_bounds(full_resids, 2.0)\n        if rng is None:\n            rng = self._distribution.simulate(dp)\n        variance_start = max(0, start_index - earliest)\n        vfcast = self._volatility.forecast(\n            vp,\n            full_resids,\n            backcast,\n            vb,\n            start=variance_start,\n            horizon=horizon,\n            method=method,\n            simulations=simulations,\n            rng=rng,\n            random_state=random_state,\n        )\n        var_fcasts = vfcast.forecasts\n        assert var_fcasts is not None\n        if start_index < earliest:\n            # Pad if asking for variance forecast before earliest available\n            var_fcasts = _forecast_pad(earliest - start_index, var_fcasts)\n\n        arp = self._har_to_ar(mp)\n        nexog = 0 if self._x is None else self._x.shape[1]\n        exog_p = np.empty([]) if self._x is None else mp[-nexog:]\n        constant = arp[0] if self.constant else 0.0\n        dynp = arp[int(self.constant) :]\n        expected_x = self._reformat_forecast_x(x, horizon, start_index)\n        mean_fcast = _ar_forecast(\n            self._y, horizon, start_index, constant, dynp, expected_x, exog_p\n        )\n        # Compute total variance forecasts, which depend on model\n        impulse = _ar_to_impulse(horizon, dynp)\n        longrun_var_fcasts = var_fcasts.copy()\n        for i in range(horizon):\n            lrf = var_fcasts[:, : (i + 1)].dot(impulse[i::-1] ** 2)\n            longrun_var_fcasts[:, i] = lrf\n        variance_paths: Optional[NDArray] = None\n        mean_paths: Optional[NDArray] = None\n        shocks: Optional[NDArray] = None\n        long_run_variance_paths: Optional[NDArray] = None\n        if method.lower() in (\"simulation\", \"bootstrap\"):\n            # TODO: This is not tested, but probably right\n            assert isinstance(vfcast.forecast_paths, np.ndarray)\n            variance_paths = vfcast.forecast_paths\n            assert isinstance(vfcast.shocks, np.ndarray)\n            shocks = vfcast.shocks\n            if start_index < earliest:\n                # Pad if asking for variance forecast before earliest available\n                variance_paths = _forecast_pad(earliest - start_index, variance_paths)\n                shocks = _forecast_pad(earliest - start_index, shocks)\n\n            long_run_variance_paths = variance_paths.copy()\n            for i in range(horizon):\n                _impulses = impulse[i::-1][:, None]\n                lrvp = variance_paths[:, :, : (i + 1)].dot(_impulses ** 2)\n                long_run_variance_paths[:, :, i] = np.squeeze(lrvp)\n            t, m = self._y.shape[0], self._max_lags\n            mean_paths = np.empty(shocks.shape[:2] + (m + horizon,))\n            dynp_rev = dynp[::-1]\n            for i in range(start_index, t):\n                path_loc = i - start_index\n                mean_paths[path_loc, :, :m] = self._y[i - m + 1 : i + 1]\n\n                for j in range(horizon):\n                    mean_paths[path_loc, :, m + j] = (\n                        constant\n                        + mean_paths[path_loc, :, j : m + j].dot(dynp_rev)\n                        + shocks[path_loc, :, j]\n                    )\n                    if expected_x.shape[0] > 0:\n                        mean_paths[path_loc, :, m + j] += expected_x[:, :, j].T @ exog_p\n\n            mean_paths = mean_paths[:, :, m:]\n\n        index = self._y_series.index\n        reindex = True if reindex is None else reindex\n        return ARCHModelForecast(\n            index,\n            start_index,\n            mean_fcast,\n            longrun_var_fcasts,\n            var_fcasts,\n            align=align,\n            simulated_paths=mean_paths,\n            simulated_residuals=shocks,\n            simulated_variances=long_run_variance_paths,\n            simulated_residual_variances=variance_paths,\n            reindex=reindex,\n        )\n\n\nclass ConstantMean(HARX):\n    r\"\"\"\n    Constant mean model estimation and simulation.\n\n    Parameters\n    ----------\n    y : {ndarray, Series}\n        nobs element vector containing the dependent variable\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    volatility : VolatilityProcess, optional\n        Volatility process to use in the model\n    distribution : Distribution, optional\n        Error distribution to use in the model\n    rescale : bool, optional\n        Flag indicating whether to automatically rescale data if the scale of the\n        data is likely to produce convergence issues when estimating model parameters.\n        If False, the model is estimated on the data without transformation.  If True,\n        than y is rescaled and the new scale is reported in the estimation results.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from arch.univariate import ConstantMean\n    >>> y = np.random.randn(100)\n    >>> cm = ConstantMean(y)\n    >>> res = cm.fit()\n\n    Notes\n    -----\n    The constant mean model is described by\n\n    .. math::\n\n        y_t = \\mu + \\epsilon_t\n    \"\"\"\n\n    def __init__(\n        self,\n        y: Optional[ArrayLike] = None,\n        hold_back: Optional[int] = None,\n        volatility: Optional[VolatilityProcess] = None,\n        distribution: Optional[Distribution] = None,\n        rescale: Optional[bool] = None,\n    ) -> None:\n        super().__init__(\n            y,\n            hold_back=hold_back,\n            volatility=volatility,\n            distribution=distribution,\n            rescale=rescale,\n        )\n        self._name = \"Constant Mean\"\n\n    def parameter_names(self) -> List[str]:\n        return [\"mu\"]\n\n    @cached_property\n    def num_params(self) -> int:\n        return 1\n\n    def _model_description(self, include_lags: bool = False) -> Dict[str, str]:\n        return super()._model_description(include_lags)\n\n    def simulate(\n        self,\n        params: ArrayLike,\n        nobs: int,\n        burn: int = 500,\n        initial_value: Optional[Union[float, NDArray]] = None,\n        x: Optional[ArrayLike] = None,\n        initial_value_vol: Optional[Union[float, NDArray]] = None,\n    ) -> DataFrame:\n        \"\"\"\n        Simulated data from a constant mean model\n\n        Parameters\n        ----------\n        params : ndarray\n            Parameters to use when simulating the model.  Parameter order is\n            [mean volatility distribution]. There is one parameter in the mean\n            model, mu.\n        nobs : int\n            Length of series to simulate\n        burn : int, optional\n            Number of values to simulate to initialize the model and remove\n            dependence on initial values.\n        initial_value : None\n            This value is not used.\n        x : None\n            This value is not used.\n        initial_value_vol : {ndarray, float}, optional\n            An array or scalar to use when initializing the volatility process.\n\n        Returns\n        -------\n        simulated_data : DataFrame\n            DataFrame with columns data containing the simulated values,\n            volatility, containing the conditional volatility and errors\n            containing the errors used in the simulation\n\n        Examples\n        --------\n        Basic data simulation with a constant mean and volatility\n\n        >>> import numpy as np\n        >>> from arch.univariate import ConstantMean, GARCH\n        >>> cm = ConstantMean()\n        >>> cm.volatility = GARCH()\n        >>> cm_params = np.array([1])\n        >>> garch_params = np.array([0.01, 0.07, 0.92])\n        >>> params = np.concatenate((cm_params, garch_params))\n        >>> sim_data = cm.simulate(params, 1000)\n        \"\"\"\n        if initial_value is not None or x is not None:\n            raise ValueError(\n                \"Both initial value and x must be none when \"\n                \"simulating a constant mean process.\"\n            )\n\n        mp, vp, dp = self._parse_parameters(params)\n\n        sim_values = self.volatility.simulate(\n            vp, nobs + burn, self.distribution.simulate(dp), burn, initial_value_vol\n        )\n        errors = sim_values[0]\n        y = errors + mp\n        vol = np.sqrt(sim_values[1])\n        assert isinstance(vol, np.ndarray)\n        df = dict(data=y[burn:], volatility=vol[burn:], errors=errors[burn:])\n        df = DataFrame(df)\n        return df\n\n    def resids(\n        self,\n        params: NDArray,\n        y: Optional[ArrayLike] = None,\n        regressors: Optional[ArrayLike] = None,\n    ) -> ArrayLike:\n        y = self._fit_y if y is None else y\n        return y - params\n\n\nclass ZeroMean(HARX):\n    r\"\"\"\n    Model with zero conditional mean estimation and simulation\n\n    Parameters\n    ----------\n    y : {ndarray, Series}\n        nobs element vector containing the dependent variable\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    volatility : VolatilityProcess, optional\n        Volatility process to use in the model\n    distribution : Distribution, optional\n        Error distribution to use in the model\n    rescale : bool, optional\n        Flag indicating whether to automatically rescale data if the scale of the\n        data is likely to produce convergence issues when estimating model parameters.\n        If False, the model is estimated on the data without transformation.  If True,\n        than y is rescaled and the new scale is reported in the estimation results.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from arch.univariate import ZeroMean\n    >>> y = np.random.randn(100)\n    >>> zm = ZeroMean(y)\n    >>> res = zm.fit()\n\n    Notes\n    -----\n    The zero mean model is described by\n\n    .. math::\n\n        y_t = \\epsilon_t\n\n    \"\"\"\n\n    def __init__(\n        self,\n        y: Optional[ArrayLike] = None,\n        hold_back: Optional[int] = None,\n        volatility: Optional[VolatilityProcess] = None,\n        distribution: Optional[Distribution] = None,\n        rescale: Optional[bool] = None,\n    ) -> None:\n        super().__init__(\n            y,\n            x=None,\n            constant=False,\n            hold_back=hold_back,\n            volatility=volatility,\n            distribution=distribution,\n            rescale=rescale,\n        )\n        self._name = \"Zero Mean\"\n\n    def parameter_names(self) -> List[str]:\n        return []\n\n    @cached_property\n    def num_params(self) -> int:\n        return 0\n\n    def _model_description(self, include_lags: bool = False) -> Dict[str, str]:\n        return super()._model_description(include_lags)\n\n    def simulate(\n        self,\n        params: Union[Sequence[float], ArrayLike1D],\n        nobs: int,\n        burn: int = 500,\n        initial_value: Optional[Union[float, NDArray]] = None,\n        x: Optional[ArrayLike] = None,\n        initial_value_vol: Optional[Union[float, NDArray]] = None,\n    ) -> DataFrame:\n        \"\"\"\n        Simulated data from a zero mean model\n\n        Parameters\n        ----------\n        params : {ndarray, DataFrame}\n            Parameters to use when simulating the model.  Parameter order is\n            [volatility distribution]. There are no mean parameters.\n        nobs : int\n            Length of series to simulate\n        burn : int, optional\n            Number of values to simulate to initialize the model and remove\n            dependence on initial values.\n        initial_value : None\n            This value is not used.\n        x : None\n            This value is not used.\n        initial_value_vol : {ndarray, float}, optional\n            An array or scalar to use when initializing the volatility process.\n\n        Returns\n        -------\n        simulated_data : DataFrame\n            DataFrame with columns data containing the simulated values,\n            volatility, containing the conditional volatility and errors\n            containing the errors used in the simulation\n\n        Examples\n        --------\n        Basic data simulation with no mean and constant volatility\n\n        >>> from arch.univariate import ZeroMean\n        >>> import numpy as np\n        >>> zm = ZeroMean()\n        >>> params = np.array([1.0])\n        >>> sim_data = zm.simulate(params, 1000)\n\n        Simulating data with a non-trivial volatility process\n\n        >>> from arch.univariate import GARCH\n        >>> zm.volatility = GARCH(p=1, o=1, q=1)\n        >>> sim_data = zm.simulate([0.05, 0.1, 0.1, 0.8], 300)\n        \"\"\"\n        params = ensure1d(params, \"params\", False)\n        if initial_value is not None or x is not None:\n            raise ValueError(\n                \"Both initial value and x must be none when \"\n                \"simulating a constant mean process.\"\n            )\n\n        _, vp, dp = self._parse_parameters(params)\n\n        sim_values = self.volatility.simulate(\n            vp, nobs + burn, self.distribution.simulate(dp), burn, initial_value_vol\n        )\n        errors = sim_values[0]\n        y = errors\n        vol = np.sqrt(sim_values[1])\n        assert isinstance(vol, np.ndarray)\n        df = dict(data=y[burn:], volatility=vol[burn:], errors=errors[burn:])\n        df = DataFrame(df)\n\n        return df\n\n    def resids(\n        self,\n        params: NDArray,\n        y: Optional[ArrayLike] = None,\n        regressors: Optional[ArrayLike] = None,\n    ) -> ArrayLike:\n        if y is not None:\n            return y\n        assert self._fit_y is not None\n        return self._fit_y\n\n\nclass ARX(HARX):\n    r\"\"\"\n    Autoregressive model with optional exogenous regressors estimation and\n    simulation\n\n    Parameters\n    ----------\n    y : {ndarray, Series}\n        nobs element vector containing the dependent variable\n    x : {ndarray, DataFrame}, optional\n        nobs by k element array containing exogenous regressors\n    lags : scalar, 1-d array, optional\n        Description of lag structure of the HAR.  Scalar included all lags\n        between 1 and the value.  A 1-d array includes the AR lags lags[0],\n        lags[1], ...\n    constant : bool, optional\n        Flag whether the model should include a constant\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    rescale : bool, optional\n        Flag indicating whether to automatically rescale data if the scale of the\n        data is likely to produce convergence issues when estimating model parameters.\n        If False, the model is estimated on the data without transformation.  If True,\n        than y is rescaled and the new scale is reported in the estimation results.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from arch.univariate import ARX\n    >>> y = np.random.randn(100)\n    >>> arx = ARX(y, lags=[1, 5, 22])\n    >>> res = arx.fit()\n\n    Estimating an AR with GARCH(1,1) errors\n\n    >>> from arch.univariate import GARCH\n    >>> arx.volatility = GARCH()\n    >>> res = arx.fit(update_freq=0, disp='off')\n\n    Notes\n    -----\n    The AR-X model is described by\n\n    .. math::\n\n        y_t = \\mu + \\sum_{i=1}^p \\phi_{L_{i}} y_{t-L_{i}} + \\gamma' x_t\n        + \\epsilon_t\n\n    \"\"\"\n\n    def __init__(\n        self,\n        y: Optional[ArrayLike] = None,\n        x: Optional[ArrayLike] = None,\n        lags: Optional[Union[int, List[int], NDArray]] = None,\n        constant: bool = True,\n        hold_back: Optional[int] = None,\n        volatility: Optional[VolatilityProcess] = None,\n        distribution: Optional[Distribution] = None,\n        rescale: Optional[bool] = None,\n    ) -> None:\n        # Convert lags to 2-d format\n\n        if lags is not None:\n            lags_arr = np.asarray(lags)\n            assert lags_arr is not None\n            if lags_arr.ndim == 0:\n                if lags_arr < 0:\n                    raise ValueError(\"lags must be a positive integer.\")\n                elif lags_arr == 0:\n                    lags = None\n                else:\n                    lags_arr = np.arange(1, int(lags_arr) + 1)\n            if lags is not None:\n                if lags_arr.ndim != 1:\n                    raise ValueError(\"lags does not follow a supported format\")\n                else:\n                    lags_arr = np.vstack((lags_arr, lags_arr))\n                    assert lags_arr is not None\n\n        super().__init__(\n            y,\n            x,\n            None if lags is None else lags_arr,\n            constant,\n            False,\n            hold_back,\n            volatility=volatility,\n            distribution=distribution,\n            rescale=rescale,\n        )\n        self._name = \"AR\"\n        if self._x is not None:\n            self._name += \"-X\"\n\n    def _model_description(self, include_lags: bool = True) -> Dict[str, str]:\n        \"\"\"Generates the model description for use by __str__ and related\n        functions\"\"\"\n        lagstr = \"none\"\n        if include_lags and self.lags is not None:\n            assert self._lags is not None\n            lagstr_comp = [str(lag[1]) for lag in self._lags.T]\n            lagstr = \", \".join(lagstr_comp)\n\n        xstr = str(self._x.shape[1]) if self._x is not None else \"0\"\n        conststr = \"yes\" if self.constant else \"no\"\n        od = {\"constant\": conststr}\n        if include_lags:\n            od[\"lags\"] = lagstr\n        od[\"no. of exog\"] = xstr\n        od[\"volatility\"] = self.volatility.__str__()\n        od[\"distribution\"] = self.distribution.__str__()\n        return od\n\n    def _generate_lag_names(self) -> List[str]:\n        lags = self._lags\n        names = []\n        var_name = self._y_series.name\n        if len(var_name) > 10:\n            var_name = var_name[:4] + \"...\" + var_name[-3:]\n        for i in range(lags.shape[1]):\n            names.append(var_name + \"[\" + str(lags[1, i]) + \"]\")\n        return names\n\n\nclass LS(HARX):\n    r\"\"\"\n    Least squares model estimation and simulation\n\n    Parameters\n    ----------\n    y : {ndarray, Series}\n        nobs element vector containing the dependent variable\n    y : {ndarray, DataFrame}, optional\n        nobs by k element array containing exogenous regressors\n    constant : bool, optional\n        Flag whether the model should include a constant\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    volatility : VolatilityProcess, optional\n        Volatility process to use in the model\n    distribution : Distribution, optional\n        Error distribution to use in the model\n    rescale : bool, optional\n        Flag indicating whether to automatically rescale data if the scale of the\n        data is likely to produce convergence issues when estimating model parameters.\n        If False, the model is estimated on the data without transformation.  If True,\n        than y is rescaled and the new scale is reported in the estimation results.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> from arch.univariate import LS\n    >>> y = np.random.randn(100)\n    >>> x = np.random.randn(100,2)\n    >>> ls = LS(y, x)\n    >>> res = ls.fit()\n\n    Notes\n    -----\n    The LS model is described by\n\n    .. math::\n\n        y_t = \\mu + \\gamma' x_t + \\epsilon_t\n\n    \"\"\"\n    # TODO??\n    def __init__(\n        self,\n        y: Optional[ArrayLike] = None,\n        x: Optional[ArrayLike] = None,\n        constant: bool = True,\n        hold_back: Optional[int] = None,\n        volatility: Optional[VolatilityProcess] = None,\n        distribution: Optional[Distribution] = None,\n        rescale: Optional[bool] = None,\n    ) -> None:\n        # Convert lags to 2-d format\n        super().__init__(\n            y,\n            x,\n            None,\n            constant,\n            False,\n            hold_back=hold_back,\n            volatility=volatility,\n            distribution=distribution,\n            rescale=rescale,\n        )\n        self._name = \"Least Squares\"\n\n    def _model_description(self, include_lags: bool = False) -> Dict[str, str]:\n        return super()._model_description(include_lags)\n\n\ndef arch_model(\n    y: Optional[ArrayLike],\n    x: Optional[ArrayLike] = None,\n    mean: str = \"Constant\",\n    lags: Optional[Union[int, List[int], NDArray]] = 0,\n    vol: str = \"Garch\",\n    p: Union[int, List[int]] = 1,\n    o: int = 0,\n    q: int = 1,\n    power: float = 2.0,\n    dist: str = \"Normal\",\n    hold_back: Optional[int] = None,\n    rescale: Optional[bool] = None,\n) -> HARX:\n    \"\"\"\n    Initialization of common ARCH model specifications\n\n    Parameters\n    ----------\n    y : {ndarray, Series, None}\n        The dependent variable\n    x : {np.array, DataFrame}, optional\n        Exogenous regressors.  Ignored if model does not permit exogenous\n        regressors.\n    mean : str, optional\n        Name of the mean model.  Currently supported options are: 'Constant',\n        'Zero', 'LS', 'AR', 'ARX', 'HAR' and  'HARX'\n    lags : int or list (int), optional\n        Either a scalar integer value indicating lag length or a list of\n        integers specifying lag locations.\n    vol : str, optional\n        Name of the volatility model.  Currently supported options are:\n        'GARCH' (default), 'ARCH', 'EGARCH', 'FIARCH' and 'HARCH'\n    p : int, optional\n        Lag order of the symmetric innovation\n    o : int, optional\n        Lag order of the asymmetric innovation\n    q : int, optional\n        Lag order of lagged volatility or equivalent\n    power : float, optional\n        Power to use with GARCH and related models\n    dist : int, optional\n        Name of the error distribution.  Currently supported options are:\n\n            * Normal: 'normal', 'gaussian' (default)\n            * Students's t: 't', 'studentst'\n            * Skewed Student's t: 'skewstudent', 'skewt'\n            * Generalized Error Distribution: 'ged', 'generalized error\"\n\n    hold_back : int\n        Number of observations at the start of the sample to exclude when\n        estimating model parameters.  Used when comparing models with different\n        lag lengths to estimate on the common sample.\n    rescale : bool\n        Flag indicating whether to automatically rescale data if the scale\n        of the data is likely to produce convergence issues when estimating\n        model parameters. If False, the model is estimated on the data without\n        transformation.  If True, than y is rescaled and the new scale is\n        reported in the estimation results.\n\n    Returns\n    -------\n    model : ARCHModel\n        Configured ARCH model\n\n    Examples\n    --------\n    >>> import datetime as dt\n    >>> import pandas_datareader.data as web\n    >>> djia = web.get_data_fred('DJIA')\n    >>> returns = 100 * djia['DJIA'].pct_change().dropna()\n\n    A basic GARCH(1,1) with a constant mean can be constructed using only\n    the return data\n\n    >>> from arch.univariate import arch_model\n    >>> am = arch_model(returns)\n\n    Alternative mean and volatility processes can be directly specified\n\n    >>> am = arch_model(returns, mean='AR', lags=2, vol='harch', p=[1, 5, 22])\n\n    This example demonstrates the construction of a zero mean process\n    with a TARCH volatility process and Student t error distribution\n\n    >>> am = arch_model(returns, mean='zero', p=1, o=1, q=1,\n    ...                 power=1.0, dist='StudentsT')\n\n    Notes\n    -----\n    Input that are not relevant for a particular specification, such as `lags`\n    when `mean='zero'`, are silently ignored.\n    \"\"\"\n    known_mean = (\"zero\", \"constant\", \"harx\", \"har\", \"ar\", \"arx\", \"ls\")\n    known_vol = (\"arch\", \"figarch\", \"garch\", \"harch\", \"constant\", \"egarch\")\n    known_dist = (\n        \"normal\",\n        \"gaussian\",\n        \"studentst\",\n        \"t\",\n        \"skewstudent\",\n        \"skewt\",\n        \"ged\",\n        \"generalized error\",\n    )\n    mean = mean.lower()\n    vol = vol.lower()\n    dist = dist.lower()\n    if mean not in known_mean:\n        raise ValueError(\"Unknown model type in mean\")\n    if vol.lower() not in known_vol:\n        raise ValueError(\"Unknown model type in vol\")\n    if dist.lower() not in known_dist:\n        raise ValueError(\"Unknown model type in dist\")\n\n    if mean == \"harx\":\n        am = HARX(y, x, lags, hold_back=hold_back, rescale=rescale)\n    elif mean == \"har\":\n        am = HARX(y, None, lags, hold_back=hold_back, rescale=rescale)\n    elif mean == \"arx\":\n        am = ARX(y, x, lags, hold_back=hold_back, rescale=rescale)\n    elif mean == \"ar\":\n        am = ARX(y, None, lags, hold_back=hold_back, rescale=rescale)\n    elif mean == \"ls\":\n        am = LS(y, x, hold_back=hold_back, rescale=rescale)\n    elif mean == \"constant\":\n        am = ConstantMean(y, hold_back=hold_back, rescale=rescale)\n    else:  # mean == \"zero\"\n        am = ZeroMean(y, hold_back=hold_back, rescale=rescale)\n\n    if vol in (\"arch\", \"garch\", \"figarch\", \"egarch\") and not isinstance(p, int):\n        raise TypeError(\n            \"p must be a scalar int for all volatility processes except HARCH.\"\n        )\n\n    if vol == \"constant\":\n        v: VolatilityProcess = ConstantVariance()\n    elif vol == \"arch\":\n        assert isinstance(p, int)\n        v = ARCH(p=p)\n    elif vol == \"figarch\":\n        assert isinstance(p, int)\n        v = FIGARCH(p=p, q=q)\n    elif vol == \"garch\":\n        assert isinstance(p, int)\n        v = GARCH(p=p, o=o, q=q, power=power)\n    elif vol == \"egarch\":\n        assert isinstance(p, int)\n        v = EGARCH(p=p, o=o, q=q)\n    else:  # vol == 'harch'\n        v = HARCH(lags=p)\n\n    if dist in (\"skewstudent\", \"skewt\"):\n        d: Distribution = SkewStudent()\n    elif dist in (\"studentst\", \"t\"):\n        d = StudentsT()\n    elif dist in (\"ged\", \"generalized error\"):\n        d = GeneralizedError()\n    else:  # ('gaussian', 'normal')\n        d = Normal()\n\n    am.volatility = v\n    am.distribution = d\n\n    return am\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_433","text":"import os\nimport torch\nimport torchvision.transforms as transforms\nimport numpy as np\nimport cv2\nimport dlib\nimport scipy.io as sio\nimport argparse\nimport math\n\nfrom modules import mobilenet_v1\nfrom utils import ToTensorGjz, NormalizeGjz, crop_img\nfrom modules.morphable.morphable_model import MorphableModel\nfrom modules import mesh\n\nclass Demo():\n    def __init__(self, opt):\n        self.opt = opt\n        self.out_dir = opt.out_dir\n        if not os.path.exists(self.out_dir):\n            os.makedirs(self.out_dir)\n        self.load_model()\n\n    def load_model(self):\n        # 1. load trained model\n        arch = 'mobilenet_1'\n        state_dict = torch.load(self.opt.checkpoint_fp, map_location=lambda storage, loc: storage)['state_dict']\n        new_state_dict = {k.replace('module.', ''): state_dict[k] for k in state_dict}\n        self.model = getattr(mobilenet_v1, arch)(num_classes=self.opt.num_classes)\n        model_dict = self.model.load_state_dict(new_state_dict)\n        self.model.cuda()\n        self.model.eval()\n\n        # 2. load dlib model for face detection and landmark used for face_cropping\n        self.face_regressor = dlib.shape_predictor(self.opt.dlib_landmark_model)\n        self.face_detector = dlib.get_frontal_face_detector()\n\n        # 3. transform\n        self.transform = transforms.Compose([ToTensorGjz(), NormalizeGjz(mean=127.5, std=128)])\n\n        # 4. load morphable_model\n        self.morphable_model = MorphableModel(self.opt.morphable_model, self.opt.model_auxiliary)\n        self.morphable_model.model_auxiliary['std_size'] = self.opt.std_size\n\n        #for item in self.morphable_model.model['kpt_ind']:\n        #    print(item)\n        #for i in range(53215):\n        #    if i not in self.morphable_model.model['kpt_ind']:\n        #        print(i)\n        #exit()\n\n    def predict(self, img_path):\n        img_name = img_path.split('\/')[-1].split('.')[0]\n        img_origin = cv2.imread(img_path)\n        rects = self.face_detector(img_origin, 1)\n\n        pts_res = []\n        Ps = []  # Camera matrix collection\n        poses = []  # pose collection\n        vertices_list = []  # store multiple face vertices\n        params_list = []\n        roi_box_list = []\n        colors_list = []\n\n        for ind, rect in enumerate(rects):\n            if self.opt.dlib_landmark:\n                # - use landmark for roi box cropping\n                pts = self.face_regressor(img_origin, rect).parts()\n                pts = np.array([[pt.x, pt.y] for pt in pts]).T\n                roi_box = self._parse_roi_box_from_landmark(pts)\n            else:\n                # - use detected face bbox\n                bbox = [rect.left(), rect.top(), rect.right(), rect.bottom()]\n                roi_box = self._parse_roi_box_from_landmark(bbox)\n            roi_box_list.append(roi_box)\n\n            # step one\n            img = crop_img(img_origin, roi_box)\n            img = cv2.resize(img, dsize=(self.opt.std_size, self.opt.std_size), interpolation=cv2.INTER_LINEAR)\n            img = self.transform(img).unsqueeze(0)\n            with torch.no_grad():\n                img = img.cuda()\n                params = self.model(img)\n                params = params.squeeze().cpu().numpy().flatten().astype(np.float32)\n\n            pts68 = self.morphable_model.predict_68pts(params, roi_box)\n\n            # two-step for more acccurate bbox to crop face\n            if self.opt.bbox_init == 'two':\n                roi_box = self._parse_roi_box_from_landmark(pts68)\n                img_step2 = crop_img(img_origin, roi_box)\n                img_step2 = cv2.resize(img_step2, dsize=(self.opt.std_size, self.opt.std_size), interpolation=cv2.INTER_LINEAR)\n                _img_step2 = img_step2.copy()\n                img_step2 = self.transform(img_step2).unsqueeze(0)\n                with torch.no_grad():\n                    img_step2 = img_step2.cuda()\n                    params = self.model(img_step2)\n                    params = params.squeeze().cpu().numpy().flatten().astype(np.float32)\n                    pts68 = self.morphable_model.predict_68pts(params, roi_box)\n\n            params_list.append(params)\n\n            vertices = self.morphable_model.predict_dense(params, roi_box)\n            if self.opt.dump_obj:\n                path = os.path.join(self.out_dir, '{}_{}.obj'.format(img_name, ind))\n                colors = mesh.transform.get_colors_from_image(img_origin, vertices) \/ 255.\n                colors_list.append(colors)\n                #tp = self.morphable_model.get_tex_params(_type='random')\n                #colors = self.morphable_model.generate_colors(tp)\n                #colors = np.minimum(np.maximum(colors, 0), 1)\n                mesh.interact.write_obj_with_colors(path, vertices.T, self.morphable_model.model['tri'], colors)\n                print(self.morphable_model.model['tri'])\n\n                h = img_origin.shape[0]\n                w = img_origin.shape[1]\n                image_vertices = vertices.copy().T\n                #image_vertices[:, 1] = h - image_vertices[:, 1] - 1\n                fitted_image = mesh.render.render_colors(image_vertices, self.morphable_model.triangles, colors, h, w) * 255.\n                print(fitted_image.shape, image_vertices.shape, self.morphable_model.triangles.shape, colors.shape)\n                cv2.imwrite(path.replace('obj', 'jpg'), fitted_image.astype('uint8'))\n\n        #self.swap(*params_list, *colors_list, *roi_box_list, h, w)\n\n    def swap(self, params1, params2, colors1, colors2, roi_box1, roi_box2, h, w):\n        params1_2 = params1.copy()\n        params1_2[12: 52] = params2[12: 52]\n        params2_1 = params2.copy()\n        params2_1[12: 52] = params1[12: 52]\n\n        vertices1_2 = self.morphable_model.predict_dense(params1_2, roi_box1).T\n        vertices2_1 = self.morphable_model.predict_dense(params2_1, roi_box2).T\n        image1_2 = mesh.render.render_colors(vertices1_2, self.morphable_model.triangles, colors2, h, w) * 255.\n        image2_1 = mesh.render.render_colors(vertices2_1, self.morphable_model.triangles, colors1, h, w) * 255.\n\n        cv2.imwrite('results\/1_2.jpg', image1_2.astype('uint8'))\n        cv2.imwrite('results\/2_1.jpg', image2_1.astype('uint8'))\n\n                \n    def _parse_roi_box_from_landmark(self, pts):\n        \"\"\"\n        Args:\n            pts: (2, n). n is the number of keypoints\n        Returns:\n            roi_box: list. (4, ). 4->(x1, y1, x2, y2)\n        \"\"\"\n        bbox = [min(pts[0, :]), min(pts[1, :]), max(pts[0, :]), max(pts[1, :])]\n        center = [(bbox[0] + bbox[2]) \/ 2, (bbox[1] + bbox[3]) \/ 2]\n        radius = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) \/ 2\n        bbox = [center[0] - radius, center[1] - radius, center[0] + radius, center[1] + radius]  # (x1, y1, x2, y2)\n\n        llength = math.sqrt((bbox[2] - bbox[0]) ** 2 + (bbox[3] - bbox[1]) ** 2)\n        center_x, center_y = center[0], center[1]\n\n        roi_box = [0] * 4\n        roi_box[0] = center_x - llength \/ 2\n        roi_box[1] = center_y - llength \/ 2\n        roi_box[2] = center_x + llength \/ 2\n        roi_box[3] = center_y + llength \/ 2\n\n        return roi_box\n\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser(description='3DDFA inference pipeline')\n    parser.add_argument('--file', default='.\/3DDFA\/samples\/1.jpg', type=str)\n    #parser.add_argument('--file', default='results\/test2.jpg', type=str)\n    parser.add_argument('--std_size', default=120, type=int)\n    parser.add_argument('--bbox_init', default='two', type=str)\n    parser.add_argument('--num_classes', default=62, type=int)\n    parser.add_argument('--checkpoint_fp', default='.\/3DDFA\/models\/phase1_wpdc_vdc.pth.tar', type=str)\n    parser.add_argument('--dlib_landmark_model', default='.\/3DDFA\/models\/shape_predictor_68_face_landmarks.dat', type=str)\n    parser.add_argument('--morphable_model', default='.\/Face3d\/Data\/BFM\/Out\/BFM.mat', type=str)\n    parser.add_argument('--model_auxiliary', default='.\/3DDFA\/utils\/model_auxiliary.mat')\n    parser.add_argument('--out_dir', default='results', type=str)\n    parser.add_argument('--dump_obj', default=1, type=bool)\n    parser.add_argument('--dlib_landmark', default=1, type=bool)\n\n    opt = parser.parse_args()\n    \n    demo = Demo(opt)\n    demo.predict(opt.file)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_434","text":"import tensorflow as tf\r\nimport VNet as vn\r\nimport numpy as np\r\n\r\nfrom scipy.misc.pilutil import imread\r\nfrom os import  walk\r\nfrom os.path import join\r\n\r\nDATA_DIR='D:\\\\program\\\\python\\\\job-logging.git\\\\trunk\\\\VNet-Tensorflow-master\\\\清洗过 - 副本\\\\原图像'\r\nLABLE_DIR='D:\\\\program\\\\python\\\\job-logging.git\\\\trunk\\\\VNet-Tensorflow-master\\\\清洗过 - 副本\\\\label'\r\n# DATA_DIR = 'D:\\\\zhengshunjie\\\\workspace\\\\deeplab\\\\组织切片2018.3.29\\\\清洗过 - 副本\\\\原图像'\r\n# LABLE_DIR= 'D:\\\\zhengshunjie\\\\workspace\\\\deeplab\\\\组织切片2018.3.29\\\\清洗过 - 副本\\\\lable'\r\nBATCH_SIZE = 8\r\nNUM_CLASSES = 2\r\nIMG_HEIGHT = 616\r\nIMG_WIDTH = 539\r\n\r\ndef read_images(data_path,lable_path):\r\n    data_filenames = next(walk(data_path))[2]\r\n    lable_filenames=next(walk(lable_path))[2]\r\n    data_num_files = len(data_filenames)\r\n    lable_num_files=len(lable_filenames)\r\n    data_images = np.zeros((data_num_files,IMG_HEIGHT,IMG_WIDTH,3),dtype=np.float32)\r\n    lable_images=np.zeros((lable_num_files,IMG_HEIGHT,IMG_WIDTH),dtype=np.float32)\r\n    valuequeue=None\r\n    valuelabel=None\r\n    for i in range(len(data_filenames)):\r\n        data_img=imread(join(data_path,data_filenames[i]))\r\n        lable_img=imread(join(lable_path,lable_filenames[i]),mode='L')\r\n        data_img = tf.cast(data_img,tf.float32)\r\n        lable_img=tf.cast(lable_img,tf.float32)\r\n        # data_images[i]=data_img\r\n        # lable_images[i]=lable_img\r\n        valuequeue=tf.train.input_producer(data_img,shuffle=False)\r\n        valuelabel=tf.train.input_producer(lable_img,shuffle=False)\r\n    return valuequeue,valuelabel\r\n\r\nimages,lables = read_images(DATA_DIR,LABLE_DIR)\r\n\r\ntf_input = tf.placeholder(dtype=tf.float32, shape=(1, IMG_WIDTH, IMG_HEIGHT, 0, 3))\r\ntf_output= tf.placeholder(dtype=tf.float32, shape=(IMG_HEIGHT, IMG_HEIGHT, 1))\r\n\r\nlogits = vn.v_net(tf_input,1.0,3)\r\nloss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=tf_output,logits=logits))\r\ntrain_step = tf.train.ProximalGradientDescentOptimizer(0.1).minimize(loss)\r\n\r\ninit=tf.global_variables_initializer()\r\n\r\nsaver=tf.train.Saver()\r\nfile_name='saved_model\/model.ckpt'\r\ndef main():\r\n    with tf.Session() as sess:\r\n        sess.run(init)\r\n        for epoch in range(500):\r\n            for batch in range(BATCH_SIZE):\r\n                num=np.random.uniform(0,700)\r\n                batch_xs=images.dequeue()\r\n                batch_ys=lables.dequeue()\r\n\r\n                sess.run(train_step,feed_dict={tf_input:batch_xs,tf_output:batch_ys})\r\n\r\n            print(\"loss:\",loss)\r\n        saver.saver(sess,file_name)\r\n\r\n\r\nif __name__=='__main__':\r\n    main()\r\n\r\n# import tensorflow as tf\r\n# import VNet as vn\r\n#\r\n# import numpy as np\r\n# from os.path import join\r\n# import matplotlib.pyplot as plt\r\n# import convert_to_tfrecords\r\n# BATCH_SIZE = 8\r\n#\r\n# TRAIN_FILE = 'train.tfrecords'\r\n# VALIDATION_FILE = 'validation.tfrecords'\r\n#\r\n#\r\n# NUM_CLASSES = 2\r\n# IMG_HEIGHT = convert_to_tfrecords.IMG_HEIGHT\r\n# IMG_WIDTH = convert_to_tfrecords.IMG_WIDTH\r\n# IMG_CHANNELS = convert_to_tfrecords.IMG_CHANNELS\r\n# IMG_PIXELS = IMG_HEIGHT * IMG_WIDTH * IMG_CHANNELS\r\n#\r\n# NUM_TRAIN = convert_to_tfrecords.NUM_TRAIN\r\n# NUM_VALIDARION = convert_to_tfrecords.NUM_VALIDARION\r\n#\r\n# def read_and_decode(filename_queue):\r\n#\r\n#     reader = tf.TFRecordReader()\r\n#\r\n#     _,serialized_example = reader.read(filename_queue)\r\n#\r\n#     features = tf.parse_single_example(serialized_example,features={\r\n#         'label_raw':tf.FixedLenFeature([],tf.string),\r\n#         'image_raw':tf.FixedLenFeature([],tf.string)\r\n#         })\r\n#\r\n#     image = tf.decode_raw(features['image_raw'],tf.uint8)\r\n#     label = tf.decode_raw(features['label_raw'],tf.uint8)\r\n#\r\n# #    image.set_shape([IMG_PIXELS])\r\n#     image = tf.reshape(image,[IMG_HEIGHT,IMG_WIDTH,IMG_CHANNELS])\r\n# #    image = tf.cast(image, tf.float32) * (1. \/ 255) - 0.5\r\n#\r\n# #    label.set_shape([IMG_HEIGHT * IMG_WIDTH * 1])\r\n#     label = tf.reshape(label,[IMG_HEIGHT,IMG_WIDTH,1])\r\n# #    label = tf.cast(label,tf.float32) * (1. \/ 255) - 0.5\r\n#     return image,label\r\n#\r\n#\r\n# def inputs(data_set,batch_size,num_epochs):\r\n#     if not num_epochs:\r\n#         num_epochs = None\r\n#     if data_set == 'train':\r\n#         file = TRAIN_FILE\r\n#     else:\r\n#         file = VALIDATION_FILE\r\n#\r\n#     with tf.name_scope('input') as scope:\r\n#         filename_queue = tf.train.string_input_producer([file])\r\n#     image,label = read_and_decode(filename_queue)\r\n#\r\n#     return image,label\r\n# def loss_funtion(logits_mat,target_mat):\r\n#     print()\r\n#\r\n#\r\n# #loss\r\n#\r\n# def main():\r\n#     with tf.Session() as sess:\r\n#         images, labels = inputs('train', BATCH_SIZE, 1)\r\n#         plt.imshow(images.eval())\r\n#         plt.show()\r\n# if __name__=='__main__':\r\n#     main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_435","text":"import gleipnir.sampled_parameter as sampled_parameter\nfrom gleipnir.sampled_parameter import SampledParameter\nfrom scipy.stats import norm\nimport numpy as np\n\ndef test_initialization():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    return\n\ndef test_attributes():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    name = sp.name\n    assert sp.name == 'sample'\n    prior = sp.prior_dist\n    n = norm(0.0,1.0)\n    assert isinstance(sp.prior_dist, type(n))\n\ndef test_func_rvs():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    rvs = sp.rvs(10)\n    assert len(rvs) == 10\n\ndef test_func_logprior():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    logprior = sp.logprior(0.5)\n    assert np.isclose(logprior, -1.0439385332046727)\n\ndef test_func_prior():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    prior = sp.prior(0.5)\n    assert np.isclose(prior, 0.3520653267642995)\n\ndef test_func_invcdf():\n    sp = SampledParameter('sample', norm(0.0,1.0))\n    invcdf = sp.invcdf(0.5)\n    assert np.isclose(invcdf, 0.0)\n\n\n\nif __name__ == '__main__':\n    test_initialization()\n    test_attributes()\n    test_func_rvs()\n    test_func_prior()\n    test_func_logprior()\n    test_func_invcdf()            \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_436","text":"\"\"\"\nmodule for describing data process.\n\nAll data structure is describing as nested combination of `dict` or `list` for `ndarray`.\nData process is a translation from data structure to another data structure or typical `ndarray`.\nData cache can be implemented based on the dynamic features of `list` and `dict`.\n\nThe full data structure is\n\n.. code::\n\n    {\n    \"particle\":{\n        \"A\":{\"p\":...,\"m\":...}\n        ...\n    },\n    \"decay\":[\n        {\n        \"A->R1+B\": {\n            \"R1\": {\n            \"ang\":  {\n                \"alpha\":[...],\n                \"beta\": [...],\n                \"gamma\": [...]\n            },\n            \"z\": [[x1,y1,z1],...],\n            \"x\": [[x2,y2,z2],...]\n            },\n            \"B\" : {...}\n        },\n        \"R->C+D\": {\n            \"C\": {\n            ...,\n            \"aligned_angle\":{\n                \"alpha\":[...],\n                \"beta\":[...],\n                \"gamma\":[...]\n            }\n            },\n            \"D\": {...}\n        },\n        },\n        {\n        \"A->R2+C\": {...},\n        \"R2->B+D\": {...}\n        },\n        ...\n    ],\n    \"weight\": [...]\n    }\n\n\"\"\"\n\nimport random\nfrom pprint import pprint\n\nimport numpy as np\n\nfrom .config import get_config\nfrom .tensorflow_wrapper import tf\n\n# import tensorflow as tf\n# from pysnooper import  snoop\n\n\ntry:\n    from collections.abc import Iterable\nexcept ImportError:  # python version < 3.7\n    from collections import Iterable\n\n\ndef set_random_seed(seed):\n    \"\"\"\n    set random seed for random, numpy and tensorflow\n    \"\"\"\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    random.seed(seed)\n\n\ndef load_dat_file(\n    fnames, particles, dtype=None, split=None, order=None, _force_list=False\n):\n    \"\"\"\n    Load ``*.dat`` file(s) of 4-momenta of the final particles.\n\n    :param fnames: String or list of strings. File names.\n    :param particles: List of Particle. Final particles.\n    :param dtype: Data type.\n    :param split: sizes of each splited dat files\n    :param order: transpose order\n\n    :return: Dictionary of data indexed by Particle.\n    \"\"\"\n    n = len(particles)\n    if dtype is None:\n        dtype = get_config(\"dtype\")\n\n    if isinstance(fnames, str):\n        fnames = [fnames]\n    elif isinstance(fnames, Iterable):\n        fnames = list(fnames)\n    else:\n        raise TypeError(\"fnames must be string or list of strings\")\n\n    datas = []\n    sizes = []\n    for fname in fnames:\n        if fname.endswith(\".npz\"):\n            data = np.load(fname)[\"arr_0\"]\n        elif fname.endswith(\".npy\"):\n            data = np.load(fname)\n        else:\n            data = np.loadtxt(fname, dtype=dtype)\n        data = np.reshape(data, (-1, 4))\n        sizes.append(data.shape[0])\n        datas.append(data)\n\n    if split is None:\n        n_total = sum(sizes)\n        if n_total % n != 0:\n            raise ValueError(\"number of data find {}\/{}\".format(n_total, n))\n        n_data = n_total \/\/ n\n        split = [size \/\/ n_data for size in sizes]\n\n    if order is None:\n        order = (1, 0, 2)\n\n    ret = {}\n    idx = 0\n    for size, data in zip(split, datas):\n        data_1 = data.reshape((-1, size, 4))\n        data_2 = data_1.transpose(order)\n        for i in data_2:\n            part = particles[idx]\n            ret[part] = i\n            idx += 1\n\n    return ret\n\n\ndef save_data(file_name, obj, **kwargs):\n    \"\"\"Save structured data to files. The arguments will be passed to ``numpy.save()``.\"\"\"\n    return np.save(file_name, obj, **kwargs)\n\n\ndef save_dataz(file_name, obj, **kwargs):\n    \"\"\"Save compressed structured data to files. The arguments will be passed to ``numpy.save()``.\"\"\"\n    return np.savez(file_name, obj, **kwargs)\n\n\ndef load_data(file_name, **kwargs):\n    \"\"\"Load data file from save_data. The arguments will be passed to ``numpy.load()``.\"\"\"\n    if \"allow_pickle\" not in kwargs:\n        kwargs[\"allow_pickle\"] = True\n    data = np.load(file_name, **kwargs)\n    try:\n        return data[\"arr_0\"].item()\n    except IndexError:\n        try:\n            return data.item()\n        except ValueError:\n            return data\n\n\ndef _data_split(dat, batch_size, axis=0):\n    data_size = dat.shape[axis]\n    if axis == 0:\n        for i in range(0, data_size, batch_size):\n            yield dat[i : min(i + batch_size, data_size)]\n    elif axis == -1:\n        for i in range(0, data_size, batch_size):\n            yield dat[..., i : min(i + batch_size, data_size)]\n    else:\n        raise Exception(\"unsupported axis: {}\".format(axis))\n\n\ndef data_generator(data, fun=_data_split, args=(), kwargs=None, MAX_ITER=1000):\n    \"\"\"Data generator: call ``fun`` to each ``data`` as a generator. The extra arguments will be passed to ``fun``.\"\"\"\n    kwargs = kwargs if kwargs is not None else {}\n\n    def _gen(dat):\n        if isinstance(dat, dict):\n            if not dat:\n                for i in range(MAX_ITER):\n                    yield {}\n            ks, vs = [], []\n            for k, v in dat.items():\n                ks.append(k)\n                vs.append(_gen(v))\n            for s_data in zip(*vs):\n                yield type(dat)(zip(ks, s_data))\n        elif isinstance(dat, list):\n            if not dat:\n                for i in range(MAX_ITER):\n                    yield []\n            vs = []\n            for v in dat:\n                vs.append(_gen(v))\n            for s_data in zip(*vs):\n                yield list(s_data)\n        elif isinstance(dat, tuple):\n            vs = []\n            for v in dat:\n                vs.append(_gen(v))\n            for s_data in zip(*vs):\n                yield s_data\n        else:\n            for i in fun(dat, *args, **kwargs):\n                yield i\n\n    return _gen(data)\n\n\ndef data_split(data, batch_size, axis=0):\n    \"\"\"\n    Split ``data`` for ``batch_size`` each in ``axis``.\n\n    :param data: structured data\n    :param batch_size: Integer, data size for each split data\n    :param axis: Integer, axis for split, [option]\n    :return: a generator for split data\n\n    >>> data = {\"a\": [np.array([1.0, 2.0]), np.array([3.0, 4.0])], \"b\": {\"c\": np.array([5.0, 6.0])}, \"d\": [], \"e\": {}}\n    >>> for i, data_i in enumerate(data_split(data, 1)):\n    ...     print(i, data_to_numpy(data_i))\n    ...\n    0 {'a': [array([1.]), array([3.])], 'b': {'c': array([5.])}, 'd': [], 'e': {}}\n    1 {'a': [array([2.]), array([4.])], 'b': {'c': array([6.])}, 'd': [], 'e': {}}\n\n    \"\"\"\n    return data_generator(\n        data, fun=_data_split, args=(batch_size,), kwargs={\"axis\": axis}\n    )\n\n\nsplit_generator = data_split\n\n\ndef data_map(data, fun, args=(), kwargs=None):\n    \"\"\"Apply fun for each data. It returns the same structure.\"\"\"\n    kwargs = kwargs if kwargs is not None else {}\n    if isinstance(data, dict):\n        return type(data)(\n            {k: data_map(v, fun, args, kwargs) for k, v in data.items()}\n        )\n    if isinstance(data, list):\n        return [data_map(data_i, fun, args, kwargs) for data_i in data]\n    if isinstance(data, tuple):\n        return tuple([data_map(data_i, fun, args, kwargs) for data_i in data])\n    return fun(data, *args, **kwargs)\n\n\ndef data_struct(data):\n    \"\"\"get the structure of data, keys and shape\"\"\"\n    if isinstance(data, dict):\n        return type(data)({k: data_struct(v) for k, v in data.items()})\n    if isinstance(data, list):\n        return [data_struct(data_i) for data_i in data]\n    if isinstance(data, tuple):\n        return tuple([data_struct(data_i) for data_i in data])\n    if hasattr(data, \"shape\"):\n        return tuple(data.shape)\n    return data\n\n\ndef data_mask(data, select):\n    \"\"\"\n    This function using boolean mask to select data.\n\n    :param data: data to select\n    :param select: 1-d boolean array for selection\n    :return: data after selection\n    \"\"\"\n    ret = data_map(data, tf.boolean_mask, args=(select,))\n    return ret\n\n\ndef data_cut(data, expr, var_map=None):\n    \"\"\"cut data with boolean expression\n\n    :param data: data need to cut\n    :param expr: cut expression\n    :param var_map: variable map between parameters in expr and data, [option]\n\n    :return: data after being cut,\n    \"\"\"\n    var_map = var_map if isinstance(var_map, dict) else {}\n    import sympy as sym\n\n    expr_s = sym.sympify(expr)\n    params = tuple(expr_s.free_symbols)\n    args = [data_index(data, var_map.get(i.name, i.name)) for i in params]\n    expr_f = sym.lambdify(params, expr, \"tensorflow\")\n    mask = expr_f(*args)\n    return data_mask(data, mask)\n\n\ndef data_merge(*data, axis=0):\n    \"\"\"This function merges data with the same structure.\"\"\"\n    assert len(data) > 0\n    if isinstance(data[0], dict):\n        assert all([isinstance(i, dict) for i in data]), \"not all type same\"\n        all_idx = [set(list(i)) for i in data]\n        idx = set.intersection(*all_idx)\n        return type(data[0])(\n            {i: data_merge(*[data_i[i] for data_i in data]) for i in idx}\n        )\n    if isinstance(data[0], list):\n        assert all([isinstance(i, list) for i in data]), \"not all type same\"\n        return [data_merge(*data_i) for data_i in zip(*data)]\n    if isinstance(data[0], tuple):\n        assert all([isinstance(i, tuple) for i in data]), \"not all type same\"\n        return tuple([data_merge(*data_i) for data_i in zip(*data)])\n    m_data = tf.concat(data, axis=axis)\n    return m_data\n\n\ndef data_shape(data, axis=0, all_list=False):\n    \"\"\"\n    Get data size.\n\n    :param data: Data array\n    :param axis: Integer. ???\n    :param all_list: Boolean. ???\n    :return:\n    \"\"\"\n\n    def flatten(dat):\n        ret = []\n\n        def data_list(dat1):\n            if hasattr(dat1, \"shape\"):\n                ret.append(dat1.shape)\n            else:\n                ret.append(())\n\n        data_map(dat, data_list)\n        return ret\n\n    shapes = flatten(data)\n    if all_list:\n        return shapes\n    return shapes[0][axis]\n\n\ndef data_to_numpy(dat):\n    \"\"\"Convert Tensor data to ``numpy.ndarray``.\"\"\"\n\n    def to_numpy(data):\n        if hasattr(data, \"numpy\"):\n            return data.numpy()\n        return data\n\n    dat = data_map(dat, to_numpy)\n    return dat\n\n\ndef data_to_tensor(dat):\n    \"\"\"convert data to ``tensorflow.Tensor``.\"\"\"\n\n    def to_tensor(data):\n        return tf.convert_to_tensor(data)\n\n    dat = data_map(dat, to_tensor)\n    return dat\n\n\ndef flatten_dict_data(data, fun=\"{}\/{}\".format):\n    \"\"\"Flatten data as dict with structure named as ``fun``.\"\"\"\n\n    def dict_gen(dat):\n        return dat.items()\n\n    def list_gen(dat):\n        return enumerate(dat)\n\n    if isinstance(data, (dict, list, tuple)):\n        ret = {}\n        gen_1 = dict_gen if isinstance(data, dict) else list_gen\n        for i, data_i in gen_1(data):\n            tmp = flatten_dict_data(data_i)\n            if isinstance(tmp, (dict, list, tuple)):\n                gen_2 = dict_gen if isinstance(tmp, dict) else list_gen\n                for j, tmp_j in gen_2(tmp):\n                    ret[fun(i, j)] = tmp_j\n            else:\n                ret[i] = tmp\n        return ret\n    return data\n\n\ndef data_index(data, key):\n    \"\"\"Indexing data for key or a list of keys.\"\"\"\n\n    def idx(data, i):\n        if isinstance(i, int):\n            return data[i]\n        assert isinstance(data, dict)\n        if i in data:\n            return data[i]\n        for k, v in data.items():\n            if str(k) == str(i):\n                return v\n        raise ValueError(\"{} is not found\".format(i))\n\n    if isinstance(key, (list, tuple)):\n        keys = list(key)\n        if len(keys) > 1:\n            return data_index(idx(data, keys[0]), keys[1:])\n        return idx(data, keys[0])\n    return idx(data, key)\n\n\ndef data_strip(data, keys):\n    if isinstance(keys, str):\n        keys = [keys]\n    if isinstance(data, dict):\n        ret = {}\n        for k, v in data.items():\n            if k not in keys:\n                ret[k] = data_strip(v, keys)\n        return ret\n    if isinstance(data, list):\n        return [data_strip(data_i, keys) for data_i in data]\n    if isinstance(data, tuple):\n        return tuple([data_strip(data_i, keys) for data_i in data])\n    return data\n\n\ndef check_nan(data, no_raise=False):\n    \"\"\"check if there is nan in data\"\"\"\n    head_keys = []\n\n    def _check_nan(dat, head):\n        if isinstance(dat, dict):\n            return {k: _check_nan(v, head + [k]) for k, v in dat.items()}\n        if isinstance(dat, list):\n            return [\n                _check_nan(data_i, head + [i]) for i, data_i in enumerate(dat)\n            ]\n        if isinstance(dat, tuple):\n            return tuple(\n                [\n                    data_struct(data_i, head + [i])\n                    for i, data_i in enumerate(dat)\n                ]\n            )\n        if np.any(tf.math.is_nan(dat)):\n            if no_raise:\n                return False\n            raise ValueError(\"nan in data[{}]\".format(head))\n        return True\n\n    return _check_nan(data, head_keys)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_439","text":"<gh_stars>0\nimport re\nfrom fractions import Fraction\n\nfrom . import PenalizerInterface, InvalidPenalizerConfigError\nfrom ..utils import ConfigDictMixin\n\n\"\"\"Penalize a late submission.\"\"\"\n\n\nclass LatePenalty(ConfigDictMixin):\n    UNITS_REGEX = re.compile(r'^(?P<mag>[0-9\/]+)\\s*(?P<unit>[a-z]*)$')\n\n    def __init__(self, after, penalty):\n        self.after = self.time_to_seconds(after)\n        self.penalty, penalty_unit = self.split_units(penalty)\n\n        if penalty_unit in ('pt', 'pts'):\n            self.penalty \/= 100\n            self.penalty_points = True\n        elif penalty_unit is None:\n            self.penalty_points = False\n        else:\n            raise InvalidPenalizerConfigError(\"unknown penalty unit `{}'. try \"\n                                              \"a fraction optionally followed \"\n                                              \"by `pt'.\"\n                                              .format(penalty_unit))\n\n    @classmethod\n    def split_units(cls, amount_str):\n        if isinstance(amount_str, (int, float)):\n            return Fraction(amount_str), None\n\n        match = cls.UNITS_REGEX.match(amount_str.lower())\n\n        if match is None:\n            raise InvalidPenalizerConfigError(\"unknown units format `{}'\"\n                                              .format())\n\n        return Fraction(match.group('mag')), match.group('unit') or None\n\n    @classmethod\n    def time_to_seconds(cls, time_str):\n        mag, unit = cls.split_units(time_str)\n\n        unit = unit or 's'\n        units = {'s': 1, 'm': 60, 'h': 60*60, 'd': 24*60*60}\n\n        if unit not in units:\n            raise InvalidPenalizerConfigError(\"unknown time unit `{}'. try \"\n                                              \"one of {}\"\n                                              .format(unit, ', '.join(units)))\n        return mag * units[unit]\n\n    def is_late(self, submission):\n        return submission.seconds_late is not None \\\n               and submission.seconds_late > self.after\n\n    def adjust_grade(self, grade):\n        if self.penalty_points:\n            return max(0, grade - self.penalty)\n        else:\n            return grade * (1 - self.penalty)\n\n\nclass LatePenalizer(PenalizerInterface):\n    \"\"\"\n    Penalize students for late submissions.\n\n    Configure it like this in the assignment config file. In this\n    example, after 8 hours late you get 75 points off your grade (a 85\n    would go to a 10).\n\n    penalties:\n    - name: LATE\n      backend: LatePenalizer\n      backend-options:\n        penalties:\n        - after: 1h\n          penalty: 25pts\n        - after: 8h\n          penalty: 50pts\n\n    That is, penalties are applied in order, and they do not stop when\n    there is a match. They don't necessarily have to be in increasing\n    order of `after' values.\n    \"\"\"\n\n    def __init__(self, penalties):\n        self.penalties = [LatePenalty.from_config_dict(p) for p in penalties]\n\n    def adjust_grade(self, submission, grade):\n        for penalty in self.penalties:\n            if penalty.is_late(submission):\n                grade = penalty.adjust_grade(grade)\n\n        return grade\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_440","text":"<filename>src\/modeling\/_gcnn.py\nfrom __future__ import division\nimport torch\nimport torch.nn.functional as F\nimport numpy as np\nimport scipy.sparse\nimport math\n\nclass SparseMM(torch.autograd.Function):\n    \"\"\"Redefine sparse @ dense matrix multiplication to enable backpropagation.\n    The builtin matrix multiplication operation does not support backpropagation in some cases.\n    \"\"\"\n    @staticmethod\n    def forward(ctx, sparse, dense):\n        ctx.req_grad = dense.requires_grad\n        ctx.save_for_backward(sparse)\n        return torch.matmul(sparse, dense)\n\n    @staticmethod\n    def backward(ctx, grad_output):\n        grad_input = None\n        sparse, = ctx.saved_tensors\n        if ctx.req_grad:\n            grad_input = torch.matmul(sparse.t(), grad_output)\n        return None, grad_input\n\ndef spmm(sparse, dense):\n    return SparseMM.apply(sparse, dense)\n\n\ndef gelu(x):\n    \"\"\"Implementation of the gelu activation function.\n        For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):\n        0.5 * x * (1 + torch.tanh(math.sqrt(2 \/ math.pi) * (x + 0.044715 * torch.pow(x, 3))))\n        Also see https:\/\/arxiv.org\/abs\/1606.08415\n    \"\"\"\n    return x * 0.5 * (1.0 + torch.erf(x \/ math.sqrt(2.0)))\n\nclass BertLayerNorm(torch.nn.Module):\n    def __init__(self, hidden_size, eps=1e-12):\n        \"\"\"Construct a layernorm module in the TF style (epsilon inside the square root).\n        \"\"\"\n        super(BertLayerNorm, self).__init__()\n        self.weight = torch.nn.Parameter(torch.ones(hidden_size))\n        self.bias = torch.nn.Parameter(torch.zeros(hidden_size))\n        self.variance_epsilon = eps\n\n    def forward(self, x):\n        u = x.mean(-1, keepdim=True)\n        s = (x - u).pow(2).mean(-1, keepdim=True)\n        x = (x - u) \/ torch.sqrt(s + self.variance_epsilon)\n        return self.weight * x + self.bias\n\n\nclass GraphResBlock(torch.nn.Module):\n    \"\"\"\n    Graph Residual Block similar to the Bottleneck Residual Block in ResNet\n    \"\"\"\n    def __init__(self, in_channels, out_channels, mesh_type='body'):\n        super(GraphResBlock, self).__init__()\n        self.in_channels = in_channels\n        self.out_channels = out_channels\n        self.lin1 = GraphLinear(in_channels, out_channels \/\/ 2)\n        self.conv = GraphConvolution(out_channels \/\/ 2, out_channels \/\/ 2, mesh_type)\n        self.lin2 = GraphLinear(out_channels \/\/ 2, out_channels)\n        self.skip_conv = GraphLinear(in_channels, out_channels)\n        # print('Use BertLayerNorm in GraphResBlock')\n        self.pre_norm = BertLayerNorm(in_channels)\n        self.norm1 = BertLayerNorm(out_channels \/\/ 2)\n        self.norm2 = BertLayerNorm(out_channels \/\/ 2)\n\n    def forward(self, x):\n        trans_y = F.relu(self.pre_norm(x)).transpose(1,2)\n        y = self.lin1(trans_y).transpose(1,2)\n\n        y = F.relu(self.norm1(y))\n        y = self.conv(y)\n\n        trans_y = F.relu(self.norm2(y)).transpose(1,2)\n        y = self.lin2(trans_y).transpose(1,2)\n\n        z = x+y\n\n        return z\n\n# class GraphResBlock(torch.nn.Module):\n#     \"\"\"\n#     Graph Residual Block similar to the Bottleneck Residual Block in ResNet\n#     \"\"\"\n#     def __init__(self, in_channels, out_channels, mesh_type='body'):\n#         super(GraphResBlock, self).__init__()\n#         self.in_channels = in_channels\n#         self.out_channels = out_channels\n#         self.conv = GraphConvolution(self.in_channels, self.out_channels, mesh_type)\n#         print('Use BertLayerNorm and GeLU in GraphResBlock')\n#         self.norm = BertLayerNorm(self.out_channels)\n#     def forward(self, x):\n#         y = self.conv(x)\n#         y = self.norm(y)\n#         y = gelu(y)\n#         z = x+y\n#         return z\n\nclass GraphLinear(torch.nn.Module):\n    \"\"\"\n    Generalization of 1x1 convolutions on Graphs\n    \"\"\"\n    def __init__(self, in_channels, out_channels):\n        super(GraphLinear, self).__init__()\n        self.in_channels = in_channels\n        self.out_channels = out_channels\n        self.W = torch.nn.Parameter(torch.FloatTensor(out_channels, in_channels))\n        self.b = torch.nn.Parameter(torch.FloatTensor(out_channels))\n        self.reset_parameters()\n\n    def reset_parameters(self):\n        w_stdv = 1 \/ (self.in_channels * self.out_channels)\n        self.W.data.uniform_(-w_stdv, w_stdv)\n        self.b.data.uniform_(-w_stdv, w_stdv)\n\n    def forward(self, x):\n        return torch.matmul(self.W[None, :], x) + self.b[None, :, None]\n\nclass GraphConvolution(torch.nn.Module):\n    \"\"\"Simple GCN layer, similar to https:\/\/arxiv.org\/abs\/1609.02907.\"\"\"\n    def __init__(self, in_features, out_features, mesh='body', bias=True):\n        super(GraphConvolution, self).__init__()\n        device=torch.device('cuda')\n        self.in_features = in_features\n        self.out_features = out_features\n\n        if mesh=='body':\n            adj_indices = torch.load('.\/src\/modeling\/data\/smpl_431_adjmat_indices.pt')\n            adj_mat_value = torch.load('.\/src\/modeling\/data\/smpl_431_adjmat_values.pt')\n            adj_mat_size = torch.load('.\/src\/modeling\/data\/smpl_431_adjmat_size.pt')\n        elif mesh=='hand':\n            adj_indices = torch.load('.\/src\/modeling\/data\/mano_195_adjmat_indices.pt')\n            adj_mat_value = torch.load('.\/src\/modeling\/data\/mano_195_adjmat_values.pt')\n            adj_mat_size = torch.load('.\/src\/modeling\/data\/mano_195_adjmat_size.pt')\n\n        self.adjmat = torch.sparse_coo_tensor(adj_indices, adj_mat_value, size=adj_mat_size).to(device)\n\n        self.weight = torch.nn.Parameter(torch.FloatTensor(in_features, out_features))\n        if bias:\n            self.bias = torch.nn.Parameter(torch.FloatTensor(out_features))\n        else:\n            self.register_parameter('bias', None)\n        self.reset_parameters()\n\n    def reset_parameters(self):\n        # stdv = 1. \/ math.sqrt(self.weight.size(1))\n        stdv = 6. \/ math.sqrt(self.weight.size(0) + self.weight.size(1))\n        self.weight.data.uniform_(-stdv, stdv)\n        if self.bias is not None:\n            self.bias.data.uniform_(-stdv, stdv)\n\n    def forward(self, x):\n        if x.ndimension() == 2:\n            support = torch.matmul(x, self.weight)\n            output = torch.matmul(self.adjmat, support)\n            if self.bias is not None:\n                output = output + self.bias\n            return output\n        else:\n            output = []\n            for i in range(x.shape[0]):\n                support = torch.matmul(x[i], self.weight)\n                # output.append(torch.matmul(self.adjmat, support))\n                output.append(spmm(self.adjmat, support))\n            output = torch.stack(output, dim=0)\n            if self.bias is not None:\n                output = output + self.bias\n            return output\n\n    def __repr__(self):\n        return self.__class__.__name__ + ' (' \\\n               + str(self.in_features) + ' -> ' \\\n               + str(self.out_features) + ')'"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_441","text":"import sounddevice as sd\nimport numpy as np\nimport time\nimport eda, model, predict\nfrom scipy.io import wavfile\nfrom tqdm import tqdm\n\nDURATION = 10\nNUMBER_OF_SAMPLES = 5\nSAMPLE_RATE = 16000\n\ndef main():\n  print('Ola! Quantos locutores voce deseja cadastrar?')\n  print('Cada locutor ira gravar {} amostras de {} segundos cada.'.format(NUMBER_OF_SAMPLES, DURATION))\n  qtd_locutores = int(input())\n  with open('dados.csv', 'w') as f:\n    f.write('fname,label\\n')\n    for i in range(qtd_locutores):\n      print('Qual o nome do ' + str(i + 1) + 'o locutor?')\n      nome = input()\n      for j in range(NUMBER_OF_SAMPLES):\n        print('Amostra ' + str(j + 1) + ', locutor = ' + nome + '. Pressione ENTER para iniciar a gravacao.')  \n        enter = input()\n\n        my_recording = sd.rec(DURATION * SAMPLE_RATE, samplerate=SAMPLE_RATE, channels=1)\n        for t in tqdm(range(DURATION)):\n          time.sleep(1)\n        # scaled_data = np.int16(my_recording \/ np.max(np.abs(my_recording)) * 32767)\n        print('Deseja confirmar essa gravacao? Y\/N')\n        option = input()\n        if (option == 'Y' or option == 'y'):\n          wav_dir = 'wavfiles\/' + nome + str(j + 1) + '.wav' ## exemplo -> user_samples\/locutor1.wav\n          wavfile.write(wav_dir, SAMPLE_RATE, my_recording)\n          f.write(nome + str(j + 1) + '.wav' + ',' + nome + '\\n')\n        else:\n          j = j - 1\n  # eda.main()\n  # model.main()\n  # predict.main()\n  \nif __name__ == '__main__':\n  main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_442","text":"from math import sqrt\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as sct\nimport seaborn as sns\nimport statsmodels.api as sm\nimport statsmodels.stats as st\nfrom sklearn.decomposition import PCA\nfrom loguru import logger\nfrom IPython.core.pylabtools import figsize\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.feature_selection import RFE\n\n#Analise inicial\nfifa = pd.read_csv(\"fifa.csv\")\ncolumns_to_drop = [\"Unnamed: 0\", \"ID\", \"Name\", \"Photo\", \"Nationality\", \"Flag\",\n                   \"Club\", \"Club Logo\", \"Value\", \"Wage\", \"Special\", \"Preferred Foot\",\n                   \"International Reputation\", \"Weak Foot\", \"Skill Moves\", \"Work Rate\",\n                   \"Body Type\", \"Real Face\", \"Position\", \"Jersey Number\", \"Joined\",\n                   \"Loaned From\", \"Contract Valid Until\", \"Height\", \"Weight\", \"LS\",\n                   \"ST\", \"RS\", \"LW\", \"LF\", \"CF\", \"RF\", \"RW\", \"LAM\", \"CAM\", \"RAM\", \"LM\",\n                   \"LCM\", \"CM\", \"RCM\", \"RM\", \"LWB\", \"LDM\", \"CDM\", \"RDM\", \"RWB\", \"LB\", \"LCB\",\n                   \"CB\", \"RCB\", \"RB\", \"Release Clause\"\n]\n\ntry:\n    fifa.drop(columns_to_drop, axis=1, inplace=True)\nexcept KeyError:\n    logger.warning(f\"Columns already dropped\")\n\nfifa.dropna(inplace= True)\n\n\"\"\"\n    Qual fração da variância consegue ser explicada pelo primeiro componente principal de fifa? \n    Responda como um único float (entre 0 e 1) arredondado para três casas decimais.\n\"\"\"\n\ndef q1():\n\n    pca = PCA(n_components = 1)\n    project = pca.fit(fifa)\n    varianciaExplicada = project.explained_variance_ratio_[0]\n    return varianciaExplicada.round(3)\n\nq1()\n\n\"\"\"\n    Quantos componentes principais precisamos para explicar 95% da variância total?\n    Responda como un único escalar inteiro.\n\"\"\"\n\ndef q2():\n\n    pca095 = PCA(n_components= 0.95)\n    project = pca095.fit_transform(fifa)\n    numeroComponentesPrincipais = project.shape[1]\n    return numeroComponentesPrincipais\n\nq2()\n\n\"\"\"\n    Qual são as coordenadas (primeiro e segundo componentes principais) do ponto x abaixo? \n    O vetor abaixo já está centralizado. Cuidado para não centralizar o vetor novamente\n    (por exemplo, invocando PCA.transform() nele).\n    Responda como uma tupla de float arredondados para três casas decimais.\n\"\"\"\n\nx = [0.87747123,  -1.24990363,  -1.3191255, -36.7341814,\n     -35.55091139, -37.29814417, -28.68671182, -30.90902583,\n     -42.37100061, -32.17082438, -28.86315326, -22.71193348,\n     -38.36945867, -20.61407566, -22.72696734, -25.50360703,\n     2.16339005, -27.96657305, -33.46004736,  -5.08943224,\n     -30.21994603,   3.68803348, -36.10997302, -30.86899058,\n     -22.69827634, -37.95847789, -22.40090313, -30.54859849,\n     -26.64827358, -19.28162344, -34.69783578, -34.6614351,\n     48.38377664,  47.60840355,  45.76793876,  44.61110193,\n     49.28911284\n]\n\ndef q3():\n\n    pca = PCA().fit(fifa)\n    c1,c2 = pca.components_.dot(x)[0:2].round(3)\n    return c1,c2\n\nq3()\n\n\n\"\"\"\n    Realiza RFE com estimador de regressão linear para selecionar cinco variáveis, eliminando uma a uma.\n    Quais são as variáveis selecionadas? Responda como uma lista de nomes de variáveis.\n\"\"\"\n\ndef q4():\n\n    x = fifa.drop(columns=\"Overall\")\n    y = fifa[\"Overall\"]\n\n    rfe = RFE(estimator= LinearRegression(), n_features_to_select= 5)\n    rfe.fit(x,y)\n\n    indexFeatureSelect = rfe.get_support(indices=True)\n\n    featureSelect = list(x.columns[indexFeatureSelect])\n\n    return featureSelect\n\nq4()\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_444","text":"<gh_stars>0\nimport sys\nimport csv\nfrom scipy import spatial\nimport db_wrapper\n\n\n# Get list of all classes at MIT\nclasses = db_wrapper.get_all_classes()\nnum_classes = len(classes)\n\n# Create hash table with keys = classes and values = index in list\nclass_table = {k:v for k, v in zip(classes, xrange(num_classes))}\n\n# Create nxn matrix with n = total number of classes\nmatrix = [[0 for x in xrange(num_classes)] for y in xrange(num_classes)]\n\n# Create nxn similarity table\nsimilarity_table = [[0 for x in xrange(num_classes)] for y in xrange(num_classes)]\n\n\n# Implementation of item-to-item CF\nprint \"Executing CF...\"\nfor cls in classes:\n    cls_pos = class_table[cls]\n    students = db_wrapper.get_students_of_class(cls)\n\n    for student in students:\n        subjects = db_wrapper.get_student_classes_all(student)\n        \n        for subject in subjects:    # subjects are the classes that student has taken\n            matrix[cls_pos][class_table[subject]] += 1     # goes down column, then across the row\n\n    count = 0\n    for c in classes:\n        if count > cls_pos:\n            break\n\n        # compute similarity between cls and c\n        cls_list = matrix[cls_pos]\n        c_list = matrix[class_table[c]]\n        similarity = 1 - spatial.distance.cosine(cls_list, c_list)  # CONSIDER PEARSON INSTEAD!\n        similarity_table[cls_pos][class_table[c]] = similarity\n        count += 1\n\n\n# output matrix to CSV\nwith open(\"output_matrix.csv\", \"wb\") as f:\n    writer = csv.writer(f)\n    writer.writerows(matrix)\n\n# output data to CSV\nwith open(\"output_similarities.csv\", \"wb\") as f:\n    writer = csv.writer(f)\n    writer.writerow(classes)\n    writer.writerows(similarity_table)\nsys.exit()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_445","text":"r\"\"\"Main module that computes the optimal policy.\n\n\"\"\"\nimport numpy as np\n\nfrom adapt_hypo_test.two_states import util\nfrom adapt_hypo_test.two_states.util import (nx_to_log_odds, m_to_r, pq_to_m, x_grid, lp_grid, log_p_log_q_to_m)\nfrom scipy.special import logsumexp\n\n\ndef nop_reward(log_cond_reward, m, lp):\n    r\"\"\"Computes\n    :math:`\\mathbb{P}(\\hat{S}_{k-1} = S_{k-1}|y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=e)`\n\n    .. math::\n\n        \\mathbb{P}(\\hat{S}_{k-1} = S_{k-1}|y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=e) = \\sum_{s_{k-1}}\\mathbb{P}(\\hat{S}_{k-1}=s_{k-1}|s_{k-1},y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=e)\\mathbb{P}(s_{k-1}|y^{k-2}\\sigma_{k-2})\n\n    :param log_cond_reward: :math:`\\log(\\mathbb{P}(\\hat{S}_k=s_k|s_k,y^{k-1},\\sigma^{k-1}))`\n        This is an array of shape ``(2, 2k-1, 2k-1)``, where the last two\n        indices correspond to the grid of posterior log odds. That is, if the\n        posterior log odds\n\n        .. math::\n\n            x(y^{k-1}) = \\log(\\mathbb{P}(s_k=1|y^{k-1},\\sigma^{k-1})\/\\mathbb{P}(s_k=0|y^{k-1},\\sigma^{k-1}))\n\n        is such that :math:`x(y^{k-1}) = n_0 r_0 + n_1 r_1`, then::\n\n            log_cond_reward[s_k, n_0+i-1, n_1+i-1]\n\n        is the corresponding :math:`\\log(\\mathbb{P}(\\hat{S}_k=s_k|s_k,y^{k-1},\\sigma^{k-1}))`\n    :param m: :math:`\\log(\\mathbb{P}(y|s))`\n        Should be of the form::\n\n            m = np.log(np.array([[1-p, p],[q,1-q]]))\n    :param lp: Shape\n        ``(2, 2(k-2)+1, 2(k-2)+1)``. Given a log odds :math:`x = r_0 n_0 + r_1 n_1`,\n        we should have ``lp[s_{k-1}, n_0+(k-2), n_1-(k-2)]`` be the corresponding\n        log probability :math:`\\log(\\mathbb{P}(s_{k-1}|y^{k-2}, \\sigma^{k-2}))`.\n    :return: :math:`\\mathbb{P}(\\hat{S}_{k-1} = S_{k-1}|y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=e)`,\n        with shape ``(2(k-2)+1, 2(k-2)+1)``.\n    \"\"\"\n    # Get :math:`\\mathbb{P}(\\hat{S}_{k-1}=s_{k-1}|s_{k-1},y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=e)`\n    nop = nop_cond_reward(log_cond_reward, m)\n    nop = logsumexp(lp + nop, axis=0)\n    return nop\n\n\ndef p_reward(log_cond_reward, m, lp):\n    r\"\"\"\n    Computes\n\n    .. math::\n        \\mathbb{P}(\\hat{S}_{k-1} = S_{k-1}|y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=\\nu) = \\sum_{s_{k-1}}\\mathbb{P}(\\hat{S}_{k-1}=s_{k-1}|s_{k-1},y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=\\nu)\\mathbb{P}(s_{k-1}|y^{k-2}\\sigma_{k-2})\n\n    See :py:func:`~adapt_hypo_test.two_states.no_transitions.nop_reward` for\n    details on arguments.\n\n    :return: :math:`\\mathbb{P}(\\hat{S}_{k-1} = S_{k-1}|y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=\\nu)`,\n        with shape ``(2(k-2)+1, 2(k-2)+1)``. The indices correspond to the grid\n        of log odds at step :math:`k-2`.\n    \"\"\"\n    # Get :math:`\\mathbb{P}(\\hat{S}_{k-1}=s_{k-1}|s_{k-1},y^{k-2},\\sigma^{k-2},\\sigma_{k-1}=\\nu)`\n    p = p_cond_reward(log_cond_reward, m)\n    p = logsumexp(lp + p, axis=0)\n    return p\n\n\ndef get_actions(log_cond_reward, m):\n    r\"\"\"\n    Makes a grid of optimal actions, given a grid of conditional rewards\n    :math:`\\log(\\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1}))`.\n\n    We make this determination by performing a Bellman backup. That is, we\n    compare the expected reward in the case of performing a permutation to the\n    case where we do not. We return the nontrivial permutation if and only if\n    the expected reward is larger if we were to.\n\n    In equations, we return the truth value of\n\n        .. math::\n\n            \\mathbb{P}\\left( \\hat{S}_0=S_0| y^{n-2},\\sigma^{n-2}, \\sigma_{n-1} = \\nu \\right)\n            > \\mathbb{P}\\left( \\hat{S}_0=S_0| y^{n-2},\\sigma^{n-2}, \\sigma_{n-1} = e \\right)\n\n    for all possible :math:`y^{n-2}`. As usual in this module, we instead look\n    for all possible posterior log odds in place of all possible sets of data,\n    to make the problem computationally tractable.\n\n    See :py:func:`~adapt_hypo_test.two_states.no_transitions.nop_reward` for\n    details on arguments.\n\n    :return: The optimal actions at the given step, encoded as an array of shape\n        ``(2*i+1, 2*i+1)``. If the returned value is ``sigma``, and the current\n        posterior log odds is :math:`x = n_0 r_0 + n_1 r_1`, the optimal policy\n        is to perform a permutation if and only if ``sigma[n_0+i, n_1+i]`` is\n        ``True``.\n    \"\"\"\n    r = m_to_r(m)\n    k = log_cond_reward.shape[-1]\n    k = k\/\/2\n    lp = lp_grid(k - 1, r)\n\n    nop = nop_reward(log_cond_reward, m, lp)\n    p = p_reward(log_cond_reward, m, lp)\n    sigma = np.logical_and(p > nop, np.logical_not(np.isclose(p, nop)))\n    return sigma\n\n\ndef nop_cond_reward(log_cond_reward, m):\n    r\"\"\"\n    Given :math:`\\log(\\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1}))`,\n    computes\n    :math:`\\log(\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}, \\sigma_{k-1}=e))`\n    according to\n\n        .. math::\n\n            \\sum_{y_k} \\mathbb{P}(\\hat{S}_{k}=s_{k}|s_{k}=\\sigma_{k-1}(s_{k-1}),y^{k-1},\\sigma^{k-1}) \\mathbb{P}(y_{k-1}|s_{k-1}, \\sigma_{k-1}=e)\n\n    Defining :math:`\\chi_k^{s_k}(x_k) = \\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1})`,\n    we compute :math:`\\chi_{k-1}^{s_{k-1}}(x_{k-1})` from\n    :math:`\\sum_{y_{k-1}}\\mathbb{P}(y_{k-1}|\\sigma_{k-1}(s_{k-1}))\\chi_k^{s_k=\\sigma_{k-1}(s_{k-1})}((-1)^{\\sigma_{k-1}}x_{k-1}+(-1)^{y_{k-1}+1}r_{y_{k-1}})`\n    where for this function, :math:`\\sigma_{k-1} = e` is the identity permutation,\n    and :math:`(-1)^e = 1`\n\n    See :py:func:`~adapt_hypo_test.two_states.no_transitions.nop_reward` for\n    details on arguments.\n\n    :return: If the returned value is ``nop``, and the current posterior log\n        odds is :math:`x = n_0 r_0 + n_1 r_1`, ``nop[s_k, n_0+k-1, n_1+k-1]`` is the\n        value of :math:`\\log(\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}, \\sigma_{k-1}=e))`.\n    \"\"\"\n    nop = np.clip(np.logaddexp(\n        # For :math:`y_{k-1} = 0`, we have\n        # :math:`x_k = x_{k-1} - r_0`. Therefore shift down in the 1 direction.\n        # The 2 direction doesn't change, but the possible values are from\n        # :math:`n_1 = -(k-1)` to :math:`n_1 = (k-1)`, so slice into the 2 axis.\n        m[:, 0][:, None, None] + log_cond_reward[:, :-2, 1:-1],\n        # Similarly for :math:`y_{k-1} = 1`.\n        m[:, 1][:, None, None] + log_cond_reward[:, 1:-1, 2:]\n    ), None, 0.)\n    return nop\n\n\ndef p_cond_reward(log_cond_reward, m):\n    r\"\"\"\n    Given :math:`\\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1})`,\n    computes\n    :math:`\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}, \\sigma_{k-1}=\\nu)`\n    according to\n    :math:`\\sum_{y_k} \\mathbb{P}(\\hat{S}_{k}=s_{k}|s_{k}=\\sigma_{k-1}(s_{k-1}),y^{k-1},\\sigma^{k-1}) \\mathbb{P}(y_{k-1}|s_{k-1}, \\sigma_{k-1}=\\nu)`.\n\n    Defining :math:`\\chi_k^{s_k}(x_k) = \\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1})`,\n    we compute :math:`\\chi_{k-1}^{s_{k-1}}(x_{k-1})` from\n    :math:`\\sum_{y_{k-1}}\\mathbb{P}(y_{k-1}|\\sigma_{k-1}(s_{k-1}))\\chi_k^{s_k=\\sigma_{k-1}(s_{k-1})}((-1)^{\\sigma_{k-1}}x_{k-1}+(-1)^{y_{k-1}+1}r_{y_{k-1}})`\n    where for this function, :math:`\\sigma_{k-1} = \\nu` is the nontrivial permutation.\n    and :math:`(-1)^\\nu = -1`\n\n    See :py:func:`~adapt_hypo_test.two_states.no_transitions.nop_reward` for\n    details on arguments.\n\n    :return: If the returned value is ``p``, and the current posterior log\n        odds is :math:`x = n_0 r_0 + n_1 r_1`, ``p[s_k, n_0+k-1, n_1+k-1]`` is the\n        value of :math:`\\log(\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}, \\sigma_{k-1}=\\nu))`.\n    \"\"\"\n    # :math:`s_{k} = \\sigma_{k-1}(s_{k-1})`, so flip the 0 axis.\n    # :math:`x_{k} = (-1)x_{k-1} - (-1)^{y_{k-1}}r_{y_{k-1}}, so flip the 1 and 2 axes,\n    # then apply offsets below.\n    flip_reward = np.flip(log_cond_reward, axis=(0, 1, 2))\n    # :math:`s_{k} = \\sigma_{k-1}(s_{k-1})`, so flip the 0 axis.\n    flip_m = np.flip(m, axis=0)\n    p = np.clip(np.logaddexp(\n        # If :math:`y_{k-1} = 0`, :math:`x_k = (-1)x_{k-1} - r_0`, so that\n        # :math:`x_{k-1} + r_0 = -x_k`. Therefore shift up in the 1 axis.\n        # The 2 direction doesn't change, but the possible values are from\n        # :math:`n_1 = -(k-1)` to :math:`n_1 = (k-1)`, so slice into the 2 axis.\n        flip_m[:, 0][:, None, None] + flip_reward[:, 2:, 1:-1],\n        # Similarly for :math:`y_{k-1} = 1`.\n        flip_m[:, 1][:, None, None] + flip_reward[:, 1:-1, :-2]\n    ), None, 0.)\n    return p\n\n\ndef backup_cond_reward(log_cond_reward, sigma, m):\n    r\"\"\"From :math:`\\log(\\mathbb{P}(\\hat{S}_k = s_k|s_k, y^{k-1}, \\sigma^{k-1}))` and\n    the optimal permutations :math:`\\sigma_{k-1}`, computes\n    :math:`\\log(\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}))`.\n\n    See :py:func:`~adapt_hypo_test.two_states.no_transitions.nop_reward` for\n    details on other arguments.\n\n    :param sigma: A ``(2*k-1, 2*k-1)`` array with the optimal permutations at\n        step :math:`k-1` corresponding to the grid of log odds.\n    :return: An array of shape ``(2*(k-2)+1, 2*(k-2)+1)`` corresponding to\n        :math:`\\log(\\mathbb{P}(\\hat{S}_{k-1} = s_{k-1}|s_{k-1}, y^{k-2}, \\sigma^{k-2}))`,\n        with indices corresponding to the grid of log odds.\n    \"\"\"\n    nop = nop_cond_reward(log_cond_reward, m)\n    b_reward = nop\n    p = p_cond_reward(log_cond_reward, m)\n    b_reward[:, sigma] = p[:, sigma]\n    return b_reward\n\n\ndef chi_base(n, r):\n    r\"\"\"The start of the computation. This initializes an array of probability\n    of correct inference after all the data has been seen, conditional on the\n    true final state. We work backwards from here to obtain the optimal policy.\n\n    :param n: Number of steps to compute for.\n    :param r: The parameters\n        :math:`r_0 = \\log((1-p)\/q)` and :math:`r_1 = \\log((1-q)\/p)`,\n        as a numpy array of shape (2,).\n    :return:\n        :math:`\\log(\\mathbb{P}(\\hat{S}_{n+1} = s_{n+1}|s_{n+1}, y^n, \\sigma^n))`\n        The dimensions of the returned array are\n        0: :math:`s_{n+1}`, 1: :math:`n_0`, 2: :math:`n_1`\n    \"\"\"\n    nx = x_grid(n)\n    lo = nx_to_log_odds(nx, r)\n    ret = np.zeros((2, 2 * n + 1, 2 * n + 1))\n    ret[0][lo > 0] = -float('inf')\n    ret[1][lo < 0] = -float('inf')\n    ret[0][lo == 0] = np.log(.5)\n    ret[1][lo == 0] = np.log(.5)\n    return ret\n\n\ndef solve(p, q, n, log=False):\n    r\"\"\"Solves for the optimal permutations.\n\n    For the system with two states and two outputs and a trivial transition\n    matrix, this solves for the optimal permutations to apply. See\n    :py:mod:`adapt_hypo_test` for details.\n\n    :param p: :math:`\\mathbb{P}(y = 1|s = 0)` unless ``log`` is specified,\n        in which case this should be :math:`\\log(\\mathbb{P}(y = 1|s = 0))`.\n    :param q: :math:`\\mathbb{P}(y = 0|s = 1)` unless ``log`` is specified,\n        in which case this should be :math:`\\log(\\mathbb{P}(y = 0|s = 1))`.\n    :param n: Number of steps of the hypothesis testing scenario.\n    :param log: Defaults to ``False``. If ``True``, the input ``p`` and ``q``\n        will be interpreted as being in log space.\n    :return: A 2-tuple, containing\n\n        The optimal permutations ``sigma``, encoded as a list of 2D arrays.\n        The arrays are indexed by $n_0, n_1$, so that if the posterior log odds\n        after ``i`` steps is ``r_0 n_0 + r_1 n_1``, the optimal permutation to\n        apply is ``sigma[i][n_0+i, n_1+i]``. The entries of the arrays are 0 or 1,\n        with 0 indicating the trivial permutation, and 1 indicating the\n        nontrivial permutation.\n\n        The conditional value function as an array of shape (2, 1, 1). This is\n\n            .. math::\n\n                \\log(\\chi_i^{s_0}) = \\log(\\mathbb{P}(\\hat{S}_{0} = s_{0}|s_{0}))\n\n        with the 0 index being :math:`s_0`. To obtain the probability of correct\n        inference of initial state, compute\n\n            >>> from scipy.special import logsumexp\n            >>> logsumexp(chi.ravel() + log_prior)\n\n        where chi is the second value returned from this function, and\n        ``log_prior`` is the prior probability of the intial states.\n    \"\"\"\n    if log:\n        m = log_p_log_q_to_m(p, q)\n    else:\n        m = pq_to_m(p, q)\n    r = m_to_r(m)\n    chi = chi_base(n, r)\n    sigmas = []\n    for i in range(n):\n        sigma = get_actions(chi, m)\n        sigmas.append(sigma)\n        chi = backup_cond_reward(chi, sigma, m)\n    sigmas = list(reversed(sigmas))\n    return sigmas, chi\n\n\ndef evaluate_sigma(sigma, x):\n    p = util.index_with_nx(sigma, x)\n    xx = np.copy(x)\n    xx[p] = -xx[p]\n    return xx, p\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_446","text":"\"\"\"The WaveBlocks Project\n\nScript to spawn new wavepackets aposteriori to an already completed simulation.\nThis can be used to evaluate spawning errors and test criteria for finding the\nbest spawning time.\n\n@author: <NAME>\n@copyright: Copyright (C) 2010, 2011 <NAME>\n@license: Modified BSD License\n\"\"\"\n\nimport sys\n\nimport numpy as np\nfrom scipy import linalg as spla\n\nfrom WaveBlocks import ParameterLoader\nfrom WaveBlocks import ParameterProvider\nfrom WaveBlocks import IOManager\nfrom WaveBlocks import PotentialFactory\nfrom WaveBlocks import HagedornWavepacket\nfrom WaveBlocks import AdiabaticSpawner\n\n\ndef aposteriori_spawning(fin, fout, pin, pout, bid1, bid2):\n    \"\"\"\n    :param f: An ``IOManager`` instance providing the simulation data.\n    :param datablock: The data block where the results are.\n    \"\"\"\n    # Number of time steps we saved\n    timesteps = fin.load_wavepacket_timegrid()\n    nrtimesteps = timesteps.shape[0]\n\n    params = fin.load_wavepacket_parameters()\n    coeffs = fin.load_wavepacket_coefficients()\n\n    # A data transformation needed by API specification\n    coeffs = [ [ coeffs[i,j,:] for j in xrange(pin[\"ncomponents\"]) ] for i in xrange(nrtimesteps) ]\n\n    # Initialize a mother Hagedorn wavepacket with the data from another simulation\n    HAWP = HagedornWavepacket(pin)\n    HAWP.set_quadrature(None)\n\n    # Initialize an empty wavepacket for spawning\n    SWP = HagedornWavepacket(pout)\n    SWP.set_quadrature(None)\n\n    # Initialize a Spawner\n    AS = AdiabaticSpawner(pout)\n\n    # Iterate over all timesteps and spawn\n    for i, step in enumerate(timesteps):\n        print(\" Try spawning at timestep \"+str(step))\n\n        # Configure the wave packet and project to the eigenbasis.\n        HAWP.set_parameters(params[i])\n        HAWP.set_coefficients(coeffs[i])\n        #HAWP.project_to_eigen(Potential)\n\n        # Try spawning a new packet\n        ps = AS.estimate_parameters(HAWP, 0)\n\n        if ps is not None:\n            SWP.set_parameters(ps)\n            AS.project_coefficients(HAWP, SWP)\n\n            # Save the spawned packet\n            fout.save_wavepacket_parameters(HAWP.get_parameters(), timestep=step, blockid=bid1)\n            fout.save_wavepacket_coefficients(HAWP.get_coefficients(), timestep=step, blockid=bid1)\n\n            fout.save_wavepacket_parameters(SWP.get_parameters(), timestep=step, blockid=bid2)\n            fout.save_wavepacket_coefficients(SWP.get_coefficients(), timestep=step, blockid=bid2)\n\n\n\n\nif __name__ == \"__main__\":\n    # Input data manager\n    iomin = IOManager()\n\n    # Read file with simulation data\n    try:\n        iomin.open_file(filename=sys.argv[1])\n    except IndexError:\n        iomin.open_file()\n\n    # Read a configuration file with the spawn parameters\n    try:\n        parametersspawn = ParameterLoader().load_from_file(sys.argv[2])\n    except IndexError:\n        raise IOError(\"No spawn configuration given!\")\n\n    parametersin = iomin.load_parameters()\n\n    # Check if we can start a spawning simulation\n    if parametersin[\"algorithm\"] != \"hagedorn\":\n        iomin.finalize()\n        raise ValueError(\"Unknown propagator algorithm.\")\n\n    # Parameters for spawning simulation\n    parametersout = ParameterProvider()\n\n    # Transfer the simulation parameters\n    parametersout.set_parameters(parametersin)\n\n    # And add spawning related configurations variables\n    parametersout.update_parameters(parametersspawn)\n\n    # How much time slots do we need\n    tm = parametersout.get_timemanager()\n    slots = tm.compute_number_saves()\n\n    # Second IOM for output data of the spawning simulation\n    iomout = IOManager()\n    iomout.create_file(parametersout, filename=\"simulation_results_spawn.hdf5\")\n\n    # Some data in the global data block\n    iomout.add_grid(parametersout, blockid=\"global\")\n    iomout.save_grid(iomin.load_grid(blockid=\"global\"), blockid=\"global\")\n\n    # Allocate all the data blocks\n    gid = iomout.create_group()\n    bid1 = iomout.create_block(groupid=gid)\n    bid2 = iomout.create_block(groupid=gid)\n    # Block for remainder \/ mother after spawning\n    iomout.add_wavepacket(parametersin, blockid=bid1)\n    # Block for spawned packet\n    iomout.add_wavepacket(parametersout, blockid=bid2)\n\n    # Really do the aposteriori spawning simulation\n    aposteriori_spawning(iomin, iomout, parametersin, parametersout, bid1, bid2)\n\n    # Close the inpout\/output files\n    iomin.finalize()\n    iomout.finalize()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_447","text":"#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Jun  2 11:17:40 2021\n\n@author: alex\n\"\"\"\n\n\nimport numpy as np\nimport scipy.signal as signal\nimport matplotlib\nimport matplotlib.pyplot as plt\n\nfrom pyro.dynamic import ContinuousDynamicSystem\nfrom pyro.dynamic import linearize\n\n# Embed font type in PDF\nmatplotlib.rcParams['pdf.fonttype'] = 42\nmatplotlib.rcParams['ps.fonttype']  = 42\n\n###############################################################################\nclass TransferFunction( ContinuousDynamicSystem ):\n    \"\"\"Time-invariant transfer function representation of a dynamic system\n\n    Y(s) \/ U(s) =   [ num ] \/ [den]\n\n    \"\"\"\n    ############################################\n    def __init__(self, num, den):\n        \n        self.num = num\n        self.den = den\n\n        n = den.shape[0] - 1\n        \n        ContinuousDynamicSystem.__init__( self, n, 1, 1)\n        \n        self.compute_ss()\n        self.compute_poleszeros()\n        \n        # Plot params\n        self.figsize = (5,3)\n        self.dpi = 300\n        self.fontsize = 5\n        \n    #############################################\n    def compute_ss(self):\n\n        A, B, C, D = signal.tf2ss(self.num, self.den)\n\n        self.A = A\n        self.B = B\n        self.C = C\n        self.D = D\n        \n    #############################################\n    def compute_poleszeros(self):\n        \n        tf = signal.TransferFunction(self.num, self.den)\n        \n        self.poles = tf.poles\n        self.zeros = tf.zeros\n        \n    #############################################\n    def f(self, x, u, t):\n\n        dx = np.dot(self.A, x) + np.dot(self.B, u)\n\n        return dx\n    \n    #############################################\n    def h(self, x, u, t):\n        \n        y = np.dot(self.C, x) + np.dot(self.D, u)\n        \n        return y\n    \n    ############################################\n    def bode_plot(self):\n        \"\"\" Plot frequency response \"\"\"\n        \n        tf = signal.TransferFunction(self.num, self.den)\n        \n        w, mag, phase = tf.bode()\n        \n        fig , plots = plt.subplots(2, sharex=True, figsize=self.figsize, \n                                  dpi=self.dpi, frameon=True)\n        \n        plots[0].semilogx(w, mag)\n        plots[1].semilogx(w, phase)\n        \n        plots[0].set_ylabel(self.output_label[0] + ' ' + self.output_units[0] +'\\n-------------------\\n'+ self.input_label[0] + ' ' + self.input_units[0]\n                 , fontsize= self.fontsize )\n        plots[1].set_ylabel( 'Phase [rad]', fontsize= self.fontsize )\n        plots[1].set_xlabel( 'Freq [rad\/sec]', fontsize= self.fontsize )\n        \n        for i in [0,1]:\n            plots[i].grid(True)\n            plots[i].tick_params( labelsize = self.fontsize )\n        \n        fig.canvas.manager.set_window_title('Bode plot of ' + self.name)\n        \n        plt.show()\n        \n    ############################################\n    def pz_map(self):\n        \"\"\" Plot poles and zeros \"\"\"\n        \n        self.compute_poleszeros()\n        \n        fig , plot = plt.subplots(1, sharex=True, figsize=self.figsize, \n                                  dpi=self.dpi, frameon=True)\n        \n        plot.plot( self.poles.real, self.poles.imag, 'x')\n        plot.plot( self.zeros.real, self.zeros.imag, 'o')\n        plot.grid(True)\n        plot.tick_params( labelsize = self.fontsize )\n        \n        fig.canvas.manager.set_window_title('Poles and zeros of ' + self.name)\n        \n        plt.show()\n        \n\n\n\n\n#################################################################\ndef ss2tf( ss, u_index , y_index):\n    \"\"\"\n    Compute the transfer function of a given input and output of a state-space\n    \"\"\"\n    nums, den = signal.ss2tf(ss.A, ss.B, ss.C, ss.D, u_index)\n    \n    num = nums[y_index]\n    \n    tf = TransferFunction(num, den)\n    \n    tf.name = (ss.output_label[y_index] + '\/' + ss.input_label[u_index] + \n               ' transfer function of ' + ss.name )\n\n    tf.output_label[0] = ss.output_label[y_index]\n    tf.output_units[0] = ss.output_units[y_index]\n    tf.input_label[0]  = ss.input_label[u_index]\n    tf.input_units[0]  = ss.input_units[u_index]\n    \n    return tf\n        \n\n'''\n#################################################################\n##################          Main                         ########\n#################################################################\n'''\n\n\nif __name__ == \"__main__\":     \n    \"\"\" MAIN TEST \"\"\"\n    \n    num = np.array([1])\n    den = np.array([1,0,1])\n    \n    #TF = signal.TransferFunction( num, den)\n    \n    sys = TransferFunction( num , den)\n    \n    #sys.bode_plot()\n    \n    from pyro.dynamic import pendulum\n    \n    non_linear_sys = pendulum.SinglePendulum()\n    \n    non_linear_sys.lc1     = 1\n    non_linear_sys.m1      = 2\n    non_linear_sys.I1      = 2\n    non_linear_sys.d1      = 2\n    non_linear_sys.gravity = 9.81\n    \n    linearized_sys = linearize( non_linear_sys )\n    siso_sys       = ss2tf( linearized_sys, 0, 0)\n    \n    print('Poles',siso_sys.poles)\n    print('num',siso_sys.num)\n    print('den',siso_sys.den)\n    \n    siso_sys.bode_plot()\n    \n    \n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_437","text":"<gh_stars>0\nfrom PIL import Image\nimport numpy as np\nimport cv2\nfrom scipy.misc import imread\nimport torch\nfrom matplotlib import pyplot as plt\ndef prep_im_for_blob(im, target_size):\n    \"\"\"Mean subtract and scale an image for use in a blob.\"\"\"\n\n    im = im.astype(np.float32, copy=False)\n    # changed to use pytorch models\n    im \/= 255.  # Convert range to [0,1]\n    # normalization for pytroch pretrained models.\n    # https:\/\/pytorch.org\/docs\/stable\/torchvision\/models.html\n    pixel_means = [0.485, 0.456, 0.406]\n    pixel_stdens = [0.229, 0.224, 0.225]\n\n    # normalize manual\n    im -= pixel_means  # Minus mean\n    im \/= pixel_stdens  # divide by stddev\n\n    # im = im[:, :, ::-1]\n    im_shape = im.shape\n    im_size_min = np.min(im_shape[0:2])\n    im_size_max = np.max(im_shape[0:2])\n    im_scale = float(target_size) \/ float(im_size_min)\n    # Prevent the biggest axis from being more than MAX_SIZE\n    # if np.round(im_scale * im_size_max) > max_size:\n    #     im_scale = float(max_size) \/ float(im_size_max)\n    # im = imresize(im, im_scale)\n    im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,\n                    interpolation=cv2.INTER_LINEAR)\n\n    return im, im_scale\n\ndef crop(image, purpose, size):\n\n\n    cut_image = image[int(purpose[1]):int(purpose[3]),int(purpose[0]):int(purpose[2]),:]\n\n\n    height, width = cut_image.shape[0:2]\n\n    max_hw   = max(height, width)\n    cty, ctx = [height \/\/ 2, width \/\/ 2]\n\n    cropped_image  = np.zeros((max_hw, max_hw, 3), dtype=cut_image.dtype)\n\n    x0, x1 = max(0, ctx - max_hw \/\/ 2), min(ctx + max_hw \/\/ 2, width)\n    y0, y1 = max(0, cty - max_hw \/\/ 2), min(cty + max_hw \/\/ 2, height)\n\n    left, right = ctx - x0, x1 - ctx\n    top, bottom = cty - y0, y1 - cty\n\n    cropped_cty, cropped_ctx = max_hw \/\/ 2, max_hw \/\/ 2\n    y_slice = slice(cropped_cty - top, cropped_cty + bottom)\n    x_slice = slice(cropped_ctx - left, cropped_ctx + right)\n    cropped_image[y_slice, x_slice, :] = cut_image[y0:y1, x0:x1, :]\n\n\n    return cv2.resize(cropped_image, (size,size), interpolation=cv2.INTER_LINEAR)\n\nif __name__ == '__main__':\n    version = 'custom'\n    if version == 'coco':\n        im = imread('\/home\/yjyoo\/PycharmProjects\/data\/coco\/images\/val2017\/000000397133.jpg')\n        query_im = imread('\/home\/yjyoo\/PycharmProjects\/data\/coco\/images\/val2017\/000000007816.jpg')\n\n    else:\n        im = imread('.\/scene.jpeg')\n        _im = cv2.resize(im, dsize=(640, 480), interpolation=cv2.INTER_AREA)\n        plt.imshow(_im)\n        plt.show()\n        print(np.array(im).shape)           # (480, 640, 3)\n        query_im = imread('.\/query.jpeg')\n        query_im = cv2.resize(query_im, dsize=(640, 480), interpolation=cv2.INTER_AREA)\n        print(np.array(query_im).shape)     # (480, 640, 3)\n\n    im, im_scale = prep_im_for_blob(im, target_size=600)\n    im = torch.tensor(im)\n    im = torch.unsqueeze(im, 0)\n    im = im.transpose(1, 3)\n    im = im.transpose(2, 3)\n\n\n\n    # query_im = crop(query_im, [505.54, 53.01, 543.08, 164.09], size=128)\n    query_im, query_im_scale = prep_im_for_blob(query_im, target_size=128)\n    query_im = torch.tensor(query_im)\n    query_im = torch.unsqueeze(query_im, 0)\n    query_im = query_im.transpose(1, 3)\n    query_im = query_im.transpose(2, 3)\n\n    print(im.shape)         # torch.Size([1, 3, 600, 899])\n    print(im_scale)         # 1.405152224824356\n    print(query_im.shape)   # torch.Size([1, 3, 128, 128])\n    print(query_im_scale)   # 1.0\n\n\n\n\n\n# 640, 425\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_438","text":"# -*- coding: utf-8 -*-\n\"\"\"Some matrix specialization.\"\"\"\n\nimport time\nfrom pygimli.core import _pygimli_ as pg\nfrom pygimli.utils.geostatistics import covarianceMatrix\nimport numpy as np\n\nfrom . import _pygimli_ as pgcore\nfrom . import (CMatrix, CSparseMapMatrix, CSparseMatrix, ElementMatrix,\n               IVector, MatrixBase, R3Vector, RVector)\n\nfrom .logger import critical, warn\n\n# make core matrices (now in pgcor, later pg.core) available here for brevity\nBlockMatrix = pgcore.RBlockMatrix\nIdentityMatrix = pgcore.IdentityMatrix\n\nBlockMatrix = pgcore.RBlockMatrix\nSparseMapMatrix = pgcore.RSparseMapMatrix\nSparseMatrix = pgcore.RSparseMatrix\nMatrix = pgcore.RMatrix\n\n\nclass MultMatrix(pgcore.MatrixBase):\n    \"\"\"Base Matrix class for all matrix types holding a matrix.\"\"\"\n    def __init__(self, A, verbose=False):\n        self._A = A\n        self.ndim = self._A.ndim\n        super(MultMatrix, self).__init__(verbose)\n\n    @property\n    def A(self):\n        return self._A\n\n    @A.setter\n    def A(self, A):\n        self._A = A\n\n    def rows(self):\n        \"\"\"Return number of rows (using underlying matrix).\"\"\"\n        return self.A.rows()  # this should be _A\n\n    def cols(self):\n        \"\"\"Return number of columns (using underlying matrix).\"\"\"\n        return self.A.cols()  # this should be _A\n\n    def save(self, filename):\n        \"\"\"So it can be used in inversion with dosave flag\"\"\"\n        pass\n\n\nclass MultLeftMatrix(MultMatrix):\n    \"\"\"Matrix consisting of actual RMatrix and lef-side vector.\"\"\"\n\n    def __init__(self, A, left, verbose=False):\n        \"\"\"Constructor saving matrix and vector.\"\"\"\n        if A.rows() != len(left):\n            raise Exception(\"Matrix columns do not fit vector length!\")\n        super(MultLeftMatrix, self).__init__(A, verbose)\n\n        self._l = left\n\n    @property\n    def l(self):  # better use left and right instead (pylint E743)?\n        return self._l\n\n    @l.setter\n    def r(self, l):\n        self._l = l\n\n    def mult(self, x):\n        \"\"\"Multiplication from right-hand-side (dot product A*x).\"\"\"\n        return self.A.mult(x) * self.l\n\n    def transMult(self, x):\n        \"\"\"Multiplication from right-hand-side (dot product A.T * x)\"\"\"\n        return self.A.transMult(x * self.l)\n\n\nLMultRMatrix = MultLeftMatrix  # alias for backward compatibility\n\n\nclass MultRightMatrix(MultMatrix):\n    \"\"\"Some Matrix, multiplied with a right hand side vector r.\"\"\"\n\n    def __init__(self, A, r=None, verbose=False):\n        super(MultRightMatrix, self).__init__(A, verbose)\n\n        if r is None:\n            self._r = pgcore.RVector(self.cols(), 1.0)\n        else:\n            self._r = r\n\n    @property\n    def r(self):\n        return self._r\n\n    @r.setter\n    def r(self, r):\n        self._r = r\n\n    def mult(self, x):\n        \"\"\"Return M*x = A*(r*x)\"\"\"\n        if hasattr(x, '__len__') and hasattr(self.r, '__len__'):\n            if len(x) != len(self.r):\n                # assuming A was complex\n                # warn('need to double x')\n                # print('mult:', self.A.rows(), \" x \" , self.A.cols(),\n                #        'x:', len(x), 'r:', len(self.r))\n                # print(self.perm)\n                return self.A.mult(x[self.perm] * self.r)\n                # return self.A.mult(pgcore.cat(x, x) * self.r)\n        return self.A.mult(x * self.r)\n\n    def transMult(self, x):\n        \"\"\"Return M.T*x=(A.T*x)*r\"\"\"\n        # print('transmult', self.A.rows(), \" x \" , self.A.cols(), x, self.r, )\n        return self.A.transMult(x) * self.r\n\n\nRMultRMatrix = MultRightMatrix  # alias for backward compatibility\n\n\nclass MultLeftRightMatrix(MultMatrix):\n    \"\"\"Matrix consisting of actual RMatrix and left-hand-side vector.\"\"\"\n\n    def __init__(self, A, left, right, verbose=False):\n        \"\"\"Constructor saving matrix and vector.\"\"\"\n        if A.cols() != len(right):\n            raise Exception(\"Matrix columns do not fit right vector length!\")\n        if A.rows() != len(left):\n            raise Exception(\"Matrix rows do not fit left vector length!\")\n\n        super(MultLeftRightMatrix, self).__init__(A, verbose)\n        self._r = right\n        self._l = left\n\n    @property\n    def l(self):\n        return self._l\n\n    @l.setter\n    def l(self, l):\n        self._l = l\n\n    @property\n    def r(self):\n        return self._r\n\n    @r.setter\n    def r(self, r):\n        self._r = r\n\n    def mult(self, x):\n        \"\"\"Multiplication from right-hand-side (dot product A*x).\"\"\"\n        return self.A.mult(x * self._r) * self._l\n\n    def transMult(self, x):\n        \"\"\"Multiplication from right-hand-side (dot product A.T*x).\"\"\"\n        return self.A.transMult(x * self._l) * self._r\n\n\nLRMultRMatrix = MultLeftRightMatrix  # alias for backward compatibility\n\n__BlockMatrix_addMatrix__ = pgcore.RBlockMatrix.addMatrix\n\n\ndef __BlockMatrix_addMatrix_happy_GC__(self, M, row=None, col=None,\n                                       scale=1.0, transpose=False):\n    \"\"\"Add an existing matrix to this block matrix and return a unique index.\n\n    As long row and col are None, the Matrix will not be used until a matrix\n    entry is has been added.\n\n    Monkeypatched version to increase the reference counter of M to keep the\n    garbage collector happy.\n\n    TODO\n    ----\n        * Add numpy matrices or convertable\n        * Transpose is only for 1d arrays. Needed for matrices?\n\n    Parameters\n    ----------\n    M: pg.core Matrix | pg.Vector | 1d iterable\n        Matrix to add to the block.\n    row: long\n        Starting row index.\n    col: long\n        Starting column index.\n    scale: float[1.0]\n        Scale all matrix entries.\n    transpose: bool [False]\n        Transpose the matrix.\n    \"\"\"\n    if M.ndim == 1:\n        if transpose is False:\n            _M = SparseMapMatrix(list(range(len(M))), [0]*len(M), M)\n        else:\n            _M = SparseMapMatrix([0]*len(M), list(range(len(M))), M)\n        M = _M\n    else:\n        if transpose is True:\n            if isinstance(M, pgcore.RSparseMapMatrix):\n                warn('Move me to core')\n                v = pg.RVector()\n                i = pg.IndexArray([0])\n                j = pg.IndexArray([0])\n                M.fillArrays(v, i, j)\n                M = SparseMapMatrix(j, i, v)\n            else:\n                critical(\"don't know yet how to add transpose matrix of type\",\n                         type(M))\n\n    if not hasattr(self, '__mats__'):\n        self.__mats__ = []\n    self.__mats__.append(M)\n\n    matrixID = __BlockMatrix_addMatrix__(self, M)\n\n    if row is not None and col is not None:\n        self.addMatrixEntry(matrixID, row, col, scale)\n\n    return matrixID\n\npgcore.RBlockMatrix.addMatrix = __BlockMatrix_addMatrix_happy_GC__\npgcore.RBlockMatrix.add = __BlockMatrix_addMatrix_happy_GC__\n# pgcore.CBlockMatrix.addMatrix = __BlockMatrix_addMatrix_happy_GC__\n# pgcore.CBlockMatrix.add = __BlockMatrix_addMatrix_happy_GC__\n\n\nclass Add2Matrix(pgcore.MatrixBase):\n    \"\"\"Matrix by adding two matrices.\"\"\"\n\n    def __init__(self, A, B):\n        super().__init__()\n        self.A = A\n        self.B = B\n        assert A.rows() == B.rows()\n        assert A.cols() == B.cols()\n\n    def mult(self, x):\n        \"\"\"Return M*x = A*(r*x)\"\"\"\n        return self.A.mult(x) + self.B.mult(x)\n\n    def transMult(self, x):\n        \"\"\"Return M.T*x=(A.T*x)*r\"\"\"\n        return self.A.transMult(x) + self.B.transMult(x)\n\n    def cols(self):\n        \"\"\"Number of columns.\"\"\"\n        return self.A.cols()\n\n    def rows(self):\n        \"\"\"Number of rows.\"\"\"\n        return self.A.rows()\n\n\nclass Mult2Matrix(pgcore.MatrixBase):\n    \"\"\"Matrix  by multiplying two matrices.\"\"\"\n\n    def __init__(self, A, B):\n        super().__init__()\n        self.A = A\n        self.B = B\n        assert A.cols() == B.rows()\n\n    def mult(self, x):\n        \"\"\"Return M*x = A*(r*x)\"\"\"\n        return self.A.mult(self.B.mult(x))\n\n    def transMult(self, x):\n        \"\"\"Return M.T*x=(A.T*x)*r\"\"\"\n        return self.B.transMult(self.A.transMult(x))\n\n    def cols(self):\n        \"\"\"Number of columns.\"\"\"\n        return self.B.cols()\n\n    def rows(self):\n        \"\"\"Number of rows.\"\"\"\n        return self.A.rows()\n\n\nclass DiagonalMatrix(pgcore.MatrixBase):\n    \"\"\"Square matrix with a vector on the main diagonal.\"\"\"\n\n    def __init__(self, d):\n        super().__init__()\n        self.d = d\n\n    def mult(self, x):\n        \"\"\"Return M*x = r*x (element-wise)\"\"\"\n        return x * self.d\n\n    def transMult(self, x):\n        \"\"\"Return M.T*x=(A.T*x)*r\"\"\"\n        return x * self.d\n\n    def cols(self):\n        \"\"\"Number of columns (length of diagonal).\"\"\"\n        return len(self.d)\n\n    def rows(self):\n        \"\"\"Number of rows (length of diagonal).\"\"\"\n        return len(self.d)\n\n\nclass Cm05Matrix(pgcore.MatrixBase):\n    \"\"\"Matrix implicitly representing the inverse square-root.\"\"\"\n\n    def __init__(self, A, verbose=False):\n        \"\"\"Constructor saving matrix and vector.\n\n        Parameters\n        ----------\n        A : ndarray\n            numpy type (full) matrix\n        \"\"\"\n        from scipy.linalg import eigh  # , get_blas_funcs\n\n        if A.shape[0] != A.shape[1]:  # rows\/cols for pgcore matrix\n            raise Exception(\"Matrix must by square (and symmetric)!\")\n\n        self.size = A.shape[0]\n        t = time.time()\n        self.ew, self.EV = eigh(A)\n        self.mul = np.sqrt(1.\/self.ew)\n        if verbose:\n            pgcore.info('(C) Time for eigenvalue decomposition:{:.1f}s'.format(\n                time.time() - t))\n\n        self.A = A\n        super().__init__(verbose)  # only in Python 3\n\n    def rows(self):\n        \"\"\"Return number of rows (using underlying matrix).\"\"\"\n        return self.size\n\n    def cols(self):\n        \"\"\"Return number of columns (using underlying matrix).\"\"\"\n        return self.size\n\n    def mult(self, x):\n        \"\"\"Multiplication from right-hand side (dot product).\"\"\"\n        part1 = (np.dot(np.transpose(x), self.EV).T*self.mul).reshape(-1, 1)\n        return self.EV.dot(part1).reshape(-1,)\n#        return self.EV.dot((x.T.dot(self.EV)*self.mul).T)\n\n    def transMult(self, x):\n        \"\"\"Multiplication from right-hand side (dot product).\"\"\"\n        return self.mult(x)  # matrix is symmetric by definition\n\n\nclass NDMatrix(BlockMatrix):\n    \"\"\"Diagonal block (block-Jacobi) matrix derived from pg.matrix.BlockMatrix.\n\n    (to be moved to a better place at a later stage)\n    \"\"\"\n\n    def __init__(self, num, nrows, ncols):\n        super(NDMatrix, self).__init__()  # call inherited init function\n        self.Ji = []  # list of individual block matrices\n        for i in range(num):\n            self.Ji.append(pg.Matrix())\n            self.Ji[-1].resize(nrows, ncols)\n            n = self.addMatrix(self.Ji[-1])\n            self.addMatrixEntry(n, nrows * i, ncols * i)\n\n        self.recalcMatrixSize()\n        print(self.rows(), self.cols())\n\n\nclass GeostatisticConstraintsMatrix(pg.MatrixBase):\n    \"\"\"Geostatistic constraints matrix\n\n    Uses geostatistical operators described by Jordi et al. (2018),\n    however corrects for the remaining non-smooth (damping) part by\n    correcting for the spur of the inverse root matrix.\n\n    <NAME>., <NAME>., <NAME>., <NAME>. & <NAME>.\n    (2018): Geostatistical regularisation operators for geophysical inverse\n    problems on irregular meshes. Geoph. J. Int. 213, 1374-1386,\n    doi:10.1093\/gji\/ggy055.\n    \"\"\"\n    def __init__(self, CM=None, mesh=None, **kwargs):\n        \"\"\"Initialize by computing the covariance matrix & its inverse root.\n\n        Parameters\n        ----------\n        CM : pg.Matrix or pg.SparseMapMatrix\n            covariance matrix, if not given, use mesh and I\n        mesh : pg.Mesh\n            mesh of which the cell midpoints are used for covariance\n        I : float | iterable of floats\n            axis correlation length (isotropic) or lengths (anisotropic)\n        dip : float [0]\n            angle of main axis corresponding to I[0] (2D) or I[0]&I[1] (3D)\n        strike : float [0]\n            angle of main axis corresponding to I[0] versus I[1] (3D)\n        withRef : bool [False]\n            neglect spur (reference model effect) that is otherwise corrected\n        \"\"\"\n        super().__init__()\n        if isinstance(CM, pg.Mesh):\n            CM = covarianceMatrix(CM, **kwargs)\n        if CM is None:\n            CM = covarianceMatrix(mesh, **kwargs)\n\n        self.nModel = CM.shape[0]\n        self.CM05 = Cm05Matrix(CM)\n        self.spur = self.CM05 * pg.RVector(self.nModel, 1.0)\n        if kwargs.pop('withRef', False):\n            self.spur *= 0.0\n\n    def mult(self, x):\n        return self.CM05.mult(x) - self.spur * x\n\n    def transMult(self, x):\n        return self.CM05.transMult(x) - self.spur * x\n\n    def cols(self):\n        return self.nModel\n\n    def rows(self):\n        return self.nModel\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_443","text":"<filename>AMnet\/preprocessing.py\nimport numpy\nimport scipy.spatial\nimport pkg_resources\nimport os\nimport scipy.io\nimport AMnet.utilities\nimport random\n\n\ndef extract_data(size):\n\n    path_to_data = pkg_resources.resource_filename(\"AMnet\", \"data\/Voxelized_GE_Files_\"+size+\"\/\")\n\n    file_list = [f for f in os.listdir(path_to_data) if os.path.isfile(os.path.join(path_to_data, f))]\n    geometry = []\n    flattened_geometry = []\n    mass = []\n    support_material = []\n    print_time =[]\n    sumsum = []\n    for file in file_list:\n        data = scipy.io.loadmat(os.path.join(path_to_data, file))\n        # print(sum(data['c'].flatten()))\n        v = sum(data['c'].flatten()\/pow(len(data['c']), 3))\n        if v > 0:\n            geometry.append(data['c'])\n            flattened_geometry.append(data['c'].flatten())\n            mass.append(data['mass'])\n            print_time.append(data['print_time'])\n            support_material.append(data['support_material'])\n\n    N = len(geometry)\n    print(N)\n    G = len(geometry[0])\n\n    numpy.savez(pkg_resources.resource_filename('AMnet', 'data\/data_geometry.npz'),\n                geometry=geometry,\n                flattened_geometry=flattened_geometry,\n                mass=mass,\n                support_material=support_material,\n                print_time=print_time)\n    numpy.savez(pkg_resources.resource_filename('AMnet', 'data\/constants.npz'), N=N, G=G)\n\n    return True\n\n\ndef augment_data():\n    # Load the data\n    geometry, mass, support_material, print_time, _, N, G = AMnet.utilities.load_data()\n\n    # Define some variables\n    augmented_geometry = []\n    augmented_flattened_geometry = []\n    augmented_mass = []\n    augmented_print_time = []\n    augmented_support_material = []\n\n    # Make some rotation options\n    faces = []\n    faces.append([1, (1, 2)])\n    faces.append([2, (1, 2)])\n    faces.append([3, (1, 2)])\n    faces.append([4, (1, 2)])\n    faces.append([1, (0, 2)])\n    faces.append([3, (0, 2)])\n\n    for i, part in enumerate(geometry):\n        for face in faces:\n            m = mass[i]\n            sm = support_material[i]\n            pt = print_time[i]\n            temp = part\n            temp = numpy.rot90(temp, face[0], face[1])\n            for quadrant in range(4):\n                temp_rotated = numpy.rot90(temp, quadrant+1, (0, 1))\n                augmented_geometry.append(temp_rotated)\n                augmented_flattened_geometry.append(temp_rotated.flatten())\n                augmented_mass.append(m)\n                augmented_print_time.append(pt)\n                augmented_support_material.append(sm)\n\n    # Shuffle the data\n    x = list(range(len(augmented_mass)))\n    random.shuffle(x)\n\n    numpy.savez(pkg_resources.resource_filename('AMnet', 'data\/data_geometry.npz'),\n                geometry=[augmented_geometry[idx] for idx in x],\n                flattened_geometry=[augmented_flattened_geometry[idx] for idx in x],\n                mass=[augmented_mass[idx] for idx in x],\n                support_material=[augmented_support_material[idx] for idx in x],\n                print_time=[augmented_print_time[idx] for idx in x])\n    numpy.savez(pkg_resources.resource_filename('AMnet', 'data\/constants.npz'), N=len(augmented_mass), G=G)\n\n    print(len(augmented_mass))\n\n    return True\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_448","text":"<reponame>gtpash\/rom-operator-inference-Python3\n# pre\/test_reprojection.py\n\"\"\"Tests for rom_operator_inference.pre._reprojection.\"\"\"\n\nimport pytest\nimport numpy as np\nfrom scipy import linalg as la\n\nimport rom_operator_inference as opinf\n\n\n# Reprojection schemes ========================================================\ndef test_reproject_discrete(n=50, m=5, r=3):\n    \"\"\"Test pre._reprojection.reproject_discrete().\"\"\"\n    # Construct dummy operators.\n    k = 1 + r + r*(r+1)\/\/2\n    D = np.diag(1 - np.logspace(-1, -2, n))\n    W = la.qr(np.random.normal(size=(n,n)))[0]\n    A = W.T @ D @ W\n    Ht = np.random.random((n,n,n))\n    H = (Ht + Ht.T) \/ 20\n    H = H.reshape((n, n**2))\n    B = np.random.random((n,m))\n    U = np.random.random((m,k))\n    B1d = np.random.random(n)\n    U1d = np.random.random(k)\n    basis = np.eye(n)[:,:r]\n    x0 = np.zeros(n)\n    x0[0] = 1\n\n    # Try with bad initial condition shape.\n    with pytest.raises(ValueError) as exc:\n        opinf.pre.reproject_discrete(lambda x: x, basis, x0[:-1], k)\n    assert exc.value.args[0] == \"basis and initial condition not aligned\"\n\n    # Linear case, no inputs.\n    def f(x):\n        return A @ x\n    X_ = opinf.pre.reproject_discrete(f, basis, x0, k)\n    assert X_.shape == (r,k)\n    rom = opinf.DiscreteOpInfROM(\"A\").fit(basis, X_)\n    assert np.allclose(basis @ X_, rom.predict(X_[:,0], k))\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n\n    # Linear case, 1D inputs.\n    def f(x, u):\n        return A @ x + B1d * u\n    X_ = opinf.pre.reproject_discrete(f, basis, x0, k, U1d)\n    assert X_.shape == (r,k)\n    rom = opinf.DiscreteOpInfROM(\"AB\").fit(basis, X_, inputs=U1d)\n    assert np.allclose(X_, basis.T @ rom.predict(X_[:,0], k, U1d))\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n    assert np.allclose(rom.B_.entries.flatten(), basis.T @ B1d)\n\n    # Linear case, 2D inputs.\n    def f(x, u):\n        return A @ x + B @ u\n    X_ = opinf.pre.reproject_discrete(f, basis, x0, k, U)\n    assert X_.shape == (r,k)\n    rom = opinf.DiscreteOpInfROM(\"AB\").fit(basis, X_, inputs=U)\n    assert np.allclose(X_, basis.T @ rom.predict(X_[:,0], k, U))\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n    assert np.allclose(rom.B_.entries, basis.T @ B)\n\n    # Quadratic case, no inputs.\n    def f(x):\n        return A @ x + H @ np.kron(x,x)\n    X_ = opinf.pre.reproject_discrete(f, basis, x0, k)\n    assert X_.shape == (r,k)\n    rom = opinf.DiscreteOpInfROM(\"AH\").fit(basis, X_)\n    assert np.allclose(X_, basis.T @ rom.predict(X_[:,0], k))\n    assert np.allclose(rom.A_.entries,\n                       basis.T @ A @ basis, atol=1e-6, rtol=1e-6)\n    H_ = basis.T @ H @ np.kron(basis, basis)\n    for _ in range(10):\n        x_ = np.random.random(r)\n        x2_ = np.kron(x_, x_)\n        assert np.allclose(rom.H_(x_), H_ @ x2_)\n\n\ndef test_reproject_continuous(n=100, m=20, r=10):\n    \"\"\"Test pre._reprojection.reproject_continuous().\"\"\"\n    # Construct dummy operators.\n    k = 1 + r + r*(r+1)\/\/2\n    D = np.diag(1 - np.logspace(-1, -2, n))\n    W = la.qr(np.random.normal(size=(n,n)))[0]\n    A = W.T @ D @ W\n    Ht = np.random.random((n,n,n))\n    H = (Ht + Ht.T) \/ 20\n    H = H.reshape((n, n**2))\n    B = np.random.random((n,m))\n    U = np.random.random((m,k))\n    B1d = np.random.random(n)\n    U1d = np.random.random(k)\n    basis = np.eye(n)[:,:r]\n    X = np.random.random((n,k))\n\n    # Try with bad initial condition shape.\n    with pytest.raises(ValueError) as exc:\n        opinf.pre.reproject_continuous(lambda x:x, basis, X[:-1,:])\n    assert exc.value.args[0] == \\\n        f\"states and basis not aligned, first dimension {n-1} != {n}\"\n\n    # Linear case, no inputs.\n    def f(x):\n        return A @ x\n    X_, Xdot_ = opinf.pre.reproject_continuous(f, basis, X)\n    assert X_.shape == (r,k)\n    assert Xdot_.shape == (r,k)\n    rom = opinf.ContinuousOpInfROM(\"A\").fit(basis, X_, Xdot_)\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n\n    # Linear case, 1D inputs.\n    def f(x, u):\n        return A @ x + B1d * u\n    X_, Xdot_ = opinf.pre.reproject_continuous(f, basis, X, U1d)\n    assert X_.shape == (r,k)\n    assert Xdot_.shape == (r,k)\n    rom = opinf.ContinuousOpInfROM(\"AB\").fit(basis, X_, Xdot_, U1d)\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n    assert np.allclose(rom.B_.entries.flatten(), basis.T @ B1d)\n\n    # Linear case, 2D inputs.\n    def f(x, u):\n        return A @ x + B @ u\n    X_, Xdot_ = opinf.pre.reproject_continuous(f, basis, X, U)\n    assert X_.shape == (r,k)\n    assert Xdot_.shape == (r,k)\n    rom = opinf.ContinuousOpInfROM(\"AB\").fit(basis, X_, Xdot_, U)\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n    assert np.allclose(rom.B_.entries, basis.T @ B)\n\n    # Quadratic case, no inputs.\n    def f(x):\n        return A @ x + H @ np.kron(x,x)\n    X_, Xdot_ = opinf.pre.reproject_continuous(f, basis, X)\n    assert X_.shape == (r,k)\n    assert Xdot_.shape == (r,k)\n    rom = opinf.ContinuousOpInfROM(\"AH\").fit(basis, X_, Xdot_)\n    assert np.allclose(rom.A_.entries, basis.T @ A @ basis)\n    H_ = basis.T @ H @ np.kron(basis, basis)\n    for _ in range(10):\n        x_ = np.random.random(r)\n        x2_ = np.kron(x_, x_)\n        assert np.allclose(rom.H_(x_), H_ @ x2_)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_449","text":"<filename>students_final_projects\/group-f\/utilities\/basic\/coordinate.py\n'''\nUtility functions for positions and velocities.\n\n@author: <NAME> <<EMAIL>>\n'''\n\n# system ----\nfrom __future__ import absolute_import, division, print_function  # python 2 compatability\nimport numpy as np\nfrom scipy import spatial\n# local ----\nfrom . import constant\n\n\n#===================================================================================================\n# coordinate transformation\n#===================================================================================================\ndef get_positions_in_coordinate_system(\n    position_vectors, system_from='cartesian', system_to='cylindrical'):\n    '''\n    Convert input 3-D position vectors from (cartesian, cylindrical, spherical) to\n    (cartesian, cylindrical, spherical):\n        cartesian : x, y, z\n        cylindrical : R (along major axes, absolute\/unsigned), Z (along minor axis, signed),\n            angle phi [0, 2 * pi)\n        spherical : r (absolute\/unsigned), angle theta [0, pi), angle phi [0, 2 * pi)\n\n    Parameters\n    ----------\n    position_vectors : array (object number x 3) : position[s]\/distance[s] wrt a center\n\n    Returns\n    -------\n    positions_new : array (object number x 3) : position[s]\/distance[s] in new coordiante system\n    '''\n    assert system_from in ('cartesian', 'cylindrical', 'spherical')\n    assert system_to in ('cartesian', 'cylindrical', 'spherical')\n\n    if system_from == system_to:\n        return position_vectors\n\n    position_vectors = np.asarray(position_vectors)\n    if np.ndim(position_vectors) == 1:\n        position_vectors = np.asarray([position_vectors])\n\n    assert np.shape(position_vectors)[1] == 3\n\n    positions_new = np.zeros(position_vectors.shape, dtype=position_vectors.dtype)\n\n    if system_from == 'cartesian':\n        if system_to == 'cylindrical':\n            # R = sqrt(x^2 + y^2)\n            positions_new[:, 0] = np.sqrt(np.sum(position_vectors[:, [0, 1]] ** 2, 1))\n            # Z = z\n            positions_new[:, 1] = position_vectors[:, 2]\n            # phi = arctan(y \/ x)\n            positions_new[:, 2] = np.arctan2(position_vectors[:, 1], position_vectors[:, 0])\n            positions_new[:, 2][positions_new[:, 2] < 0] += 2 * np.pi  # convert to [0, 2 * pi)\n        elif system_to == 'spherical':\n            # r = sqrt(x^2 + y^2 + z^2)\n            positions_new[:, 0] = np.sqrt(np.sum(position_vectors ** 2, 1))\n            # theta = arccos(z \/ r)\n            positions_new[:, 1] = np.arccos(position_vectors[:, 2] \/ positions_new[:, 0])\n            # phi = arctan(y \/ x)\n            positions_new[:, 2] = np.arctan2(position_vectors[:, 1], position_vectors[:, 0])\n            positions_new[:, 2][positions_new[:, 2] < 0] += 2 * np.pi  # convert to [0, 2 * pi)\n\n    elif system_from == 'cylindrical':\n        if system_to == 'cartesian':\n            # x = R * cos(phi)\n            positions_new[:, 0] = position_vectors[:, 0] * np.cos(position_vectors[:, 2])\n            # y = R * sin(phi)\n            positions_new[:, 1] = position_vectors[:, 0] * np.sin(position_vectors[:, 2])\n            # z = Z\n            positions_new[:, 2] = position_vectors[:, 1]\n        elif system_to == 'spherical':\n            # r = sqrt(R^2 + Z^2)\n            positions_new[:, 0] = np.sqrt(position_vectors[:, 0] ** 2 + position_vectors[:, 1] ** 2)\n            # theta = arctan(R \/ Z)\n            positions_new[:, 1] = np.arctan2(position_vectors[:, 0], position_vectors[:, 1])\n            # phi = phi\n            positions_new[:, 2] = position_vectors[:, 2]\n\n    elif system_from == 'spherical':\n        if system_to == 'cartesian':\n            # x = r * sin(theta) * cos(phi)\n            positions_new[:, 0] = (position_vectors[:, 0] * np.sin(position_vectors[:, 1]) *\n                                   np.cos(position_vectors[:, 2]))\n            # y = r * sin(theta) * sin(phi)\n            positions_new[:, 1] = (position_vectors[:, 0] * np.sin(position_vectors[:, 1]) *\n                                   np.sin(position_vectors[:, 2]))\n            # z = r * cos(theta)\n            positions_new[:, 2] = position_vectors[:, 0] * np.cos(position_vectors[:, 1])\n        elif system_to == 'cylindrical':\n            # R = r * sin(theta)\n            positions_new[:, 0] = position_vectors[:, 0] * np.sin(position_vectors[:, 1])\n            # Z = r * cos(theta)\n            positions_new[:, 1] = position_vectors[:, 0] * np.cos(position_vectors[:, 1])\n            # phi = phi\n            positions_new[:, 2] = position_vectors[:, 2]\n\n    # if only one position vector, return as 1-D array\n    if len(positions_new) == 1:\n        positions_new = positions_new[0]\n\n    return positions_new\n\n\ndef get_velocities_in_coordinate_system(\n    velocity_vectors, position_vectors, system_from='cartesian', system_to='cylindrical'):\n    '''\n    Convert input 3-D velocity vectors from (cartesian, cylindrical, spherical) to\n    (cartesian, cylindrical, spherical).\n        cartesian : velocity along x, y, z\n        cylindrical : velocity along R (major axes), Z (minor axis), angle phi\n        spherical : velocity along r, angle theta, angle phi\n\n    Parameters\n    ----------\n    velocity_vectors : array (object number x 3) : velocity[s] wrt a center\n    position_vectors : array (object number x 3) : position[s]\/distance[s] wrt a center\n\n    Returns\n    -------\n    velocity_vectors_new : array (object number x 3) : velocity[s] in new coordiante system\n    '''\n    assert system_from in ('cartesian', 'cylindrical', 'spherical')\n    assert system_to in ('cartesian', 'cylindrical', 'spherical')\n\n    if system_from == system_to:\n        return velocity_vectors\n\n    velocity_vectors = np.asarray(velocity_vectors)\n    if np.ndim(velocity_vectors) == 1:\n        velocity_vectors = np.asarray([velocity_vectors])\n\n    position_vectors = np.asarray(position_vectors)\n    if np.ndim(position_vectors) == 1:\n        position_vectors = np.asarray([position_vectors])\n\n    assert np.shape(velocity_vectors)[1] == 3 and np.shape(position_vectors)[1] == 3\n\n    velocities_new = np.zeros(velocity_vectors.shape, dtype=velocity_vectors.dtype)\n\n    if system_from == 'cartesian':\n        # convert position vectors\n        # R = {x,y}\n        R = position_vectors[:, [0, 1]]\n        R_norm = np.zeros(R.shape, position_vectors.dtype)\n        # R_total = sqrt(x^2 + y^2)\n        R_total = np.sqrt(np.sum(R ** 2, 1))\n        masks = np.where(R_total > 0)[0]\n        # need to do this way\n        R_norm[masks] = np.transpose(R[masks].transpose() \/ R_total[masks])\n\n        if system_to == 'cylindrical':\n            # v_R = dot(v_{x,y}, R_norm)\n            velocities_new[:, 0] = np.sum(velocity_vectors[:, [0, 1]] * R_norm, 1)\n            # v_Z = v_z\n            velocities_new[:, 1] = velocity_vectors[:, 2]\n            # v_phi = cross(R_norm, v_{x,y})\n            velocities_new[:, 2] = np.cross(R_norm, velocity_vectors[:, [0, 1]])\n        elif system_to == 'spherical':\n            # convert position vectors\n            position_vectors_norm = np.zeros(position_vectors.shape, position_vectors.dtype)\n            position_vectors_total = np.sqrt(np.sum(position_vectors ** 2, 1))\n            masks = np.where(position_vectors_total > 0)[0]\n            # need to do this way\n            position_vectors_norm[masks] = np.transpose(\n                position_vectors[masks].transpose() \/ position_vectors_total[masks])\n\n            # v_r = dot(v, r)\n            velocities_new[:, 0] = np.sum(velocity_vectors * position_vectors_norm, 1)\n            # v_theta\n            a = np.transpose([R_norm[:, 0] * position_vectors_norm[:, 2],\n                              R_norm[:, 1] * position_vectors_norm[:, 2],\n                              -R_total \/ position_vectors_total])\n            velocities_new[:, 1] = np.sum(velocity_vectors * a, 1)\n            # v_phi = cross(R_norm, v_{x,y})\n            velocities_new[:, 2] = np.cross(R_norm, velocity_vectors[:, [0, 1]])\n\n    elif system_from == 'cylindrical':\n        raise ValueError('not yet support conversion from {} to {}'.format(system_from, system_to))\n\n    elif system_from == 'spherical':\n        raise ValueError('not yet support conversion from {} to {}'.format(system_from, system_to))\n\n    # if only one velocity vector, return as 1-D array\n    if len(velocities_new) == 1:\n        velocities_new = velocities_new[0]\n\n    return velocities_new\n\n\n#===================================================================================================\n# rotation of position or velocity\n#===================================================================================================\ndef get_coordinates_rotated(coordinate_vectors, rotation_tensor=None, rotation_angles=None):\n    '''\n    Get 3-D coordinate[s] (distance or velocity vector[s]) that are rotated by input rotation\n    vectors or input rotation angles.\n    If rotation_tensor, need to input vectors that are orthogonal.\n    If rotation_angles, rotate by rotation_angles[0] about x-axis, then by rotation_angles[1] about\n    y-axis, then by rotation_angles[2] about z-axis.\n\n    Parameters\n    ----------\n    coordinate_vectors : array : coordinate[s] (distance[s] or velocity[s]) wrt a center of rotation\n        (object number x dimension number)\n    rotation_tensor : array : *orthogonal* rotation vectors (such as max, med, min eigen-vectors)\n    rotation_angles : array : rotation angles about x-axis, y-axis, z-axis [radians]\n\n    Returns\n    -------\n    coordinate[s] (distance[s] or velocity[s]) in rotated basis :\n        array (object number x dimension number)\n    '''\n    if rotation_tensor is not None:\n        # sanity check - ensure input rotation vectors are orthogonal\n        tolerance = 1e-6\n        if (np.abs(np.dot(rotation_tensor[0], rotation_tensor[1])) > tolerance or\n                np.abs(np.dot(rotation_tensor[0], rotation_tensor[2])) > tolerance or\n                np.abs(np.dot(rotation_tensor[1], rotation_tensor[2])) > tolerance):\n            raise ValueError('input rotation_tensor is not orthogonal')\n\n    elif rotation_angles is not None:\n        m11 = np.cos(rotation_angles[1]) * np.cos(rotation_angles[2])\n        m12 = (np.cos(rotation_angles[0]) * np.sin(rotation_angles[2]) +\n               np.sin(rotation_angles[0]) * np.sin(rotation_angles[1]) * np.cos(rotation_angles[2]))\n        m13 = (np.sin(rotation_angles[0]) * np.sin(rotation_angles[2]) -\n               np.cos(rotation_angles[0]) * np.sin(rotation_angles[1]) * np.cos(rotation_angles[2]))\n        m21 = -np.cos(rotation_angles[1]) * np.sin(rotation_angles[2])\n        m22 = (np.cos(rotation_angles[0]) * np.cos(rotation_angles[2]) -\n               np.sin(rotation_angles[0]) * np.sin(rotation_angles[1]) * np.sin(rotation_angles[2]))\n        m23 = (np.sin(rotation_angles[0]) * np.cos(rotation_angles[2]) +\n               np.cos(rotation_angles[0]) * np.sin(rotation_angles[1]) * np.sin(rotation_angles[2]))\n        m31 = np.sin(rotation_angles[1])\n        m32 = -np.sin(rotation_angles[0]) * np.cos(rotation_angles[1])\n        m33 = np.cos(rotation_angles[0]) * np.cos(rotation_angles[1])\n\n        rotation_tensor = np.array([\n            [m11, m12, m13],\n            [m21, m22, m23],\n            [m31, m32, m33]],\n            dtype=coordinate_vectors.dtype\n        )\n\n    else:\n        raise ValueError('need to input either rotation angles or rotation vectors')\n\n    # have to do this way\n    coordinate_vectors_rotated = np.asarray(\n        np.dot(coordinate_vectors, rotation_tensor.transpose()), dtype=coordinate_vectors.dtype)\n\n    return coordinate_vectors_rotated\n\n\ndef get_principal_axes(position_vectors, weights=None, print_results=True):\n    '''\n    Compute principal axes of input position_vectors (which should be wrt a center),\n    defined via the moment of inertia tensor.\n    Get reverse-sorted eigen-vectors, eigen-values, and axis ratios of these principal axes.\n\n    Parameters\n    ----------\n    position_vectors : array (object number x dimension number) :\n        position[s]\/distance[s] wrt a center\n    weights : array : weight for each position (usually mass) - if None, assume all have same weight\n    print_results : bool : whether to print axis ratios\n\n    Returns\n    -------\n    eigen_vectors : array : max, med, min eigen-vectors\n    eigen_values : array : max, med, min eigen-values\n    axis_ratios : array : ratios of principal axes\n    '''\n    if weights is None or not len(weights):\n        weights = 1\n    else:\n        weights = weights \/ np.median(weights)\n\n    if position_vectors.shape[1] == 3:\n        # 3-D\n        xx = np.sum(weights * position_vectors[:, 0] ** 2)\n        yy = np.sum(weights * position_vectors[:, 1] ** 2)\n        zz = np.sum(weights * position_vectors[:, 2] ** 2)\n        xy = yx = np.sum(weights * position_vectors[:, 0] * position_vectors[:, 1])\n        xz = zx = np.sum(weights * position_vectors[:, 0] * position_vectors[:, 2])\n        yz = zy = np.sum(weights * position_vectors[:, 1] * position_vectors[:, 2])\n\n        moi_tensor = [[xx, xy, xz],\n                      [yx, yy, yz],\n                      [zx, zy, zz]]\n\n    elif position_vectors.shape[1] == 2:\n        # 2-D\n        xx = np.sum(weights * position_vectors[:, 0] ** 2)\n        yy = np.sum(weights * position_vectors[:, 1] ** 2)\n        xy = yx = np.sum(weights * position_vectors[:, 0] * position_vectors[:, 1])\n\n        moi_tensor = [[xx, xy],\n                      [yx, yy]]\n\n    eigen_values, eigen_vectors = np.linalg.eig(moi_tensor)\n\n    # order eigen-vectors by eigen-values, from largest to smallest\n    eigen_indices_sorted = np.argsort(eigen_values)[::-1]\n    eigen_values = eigen_values[eigen_indices_sorted]\n    eigen_values \/= eigen_values.max()  # renormalize to 1\n    # make eigen_vectors[0] corresponds to vector of eigen_values[0]\n    eigen_vectors = eigen_vectors.transpose()[eigen_indices_sorted]\n\n    if position_vectors.shape[1] == 3:\n        axis_ratios = np.sqrt(\n            [eigen_values[2] \/ eigen_values[0],\n             eigen_values[2] \/ eigen_values[1],\n             eigen_values[1] \/ eigen_values[0]]\n        )\n\n        if print_results:\n            print('* principal axes:  min\/maj = {:.3f}, min\/med = {:.3f}, med\/maj = {:.3f}'.format(\n                  axis_ratios[0], axis_ratios[1], axis_ratios[2]))\n\n    elif position_vectors.shape[1] == 2:\n        axis_ratios = eigen_values[1] \/ eigen_values[0]\n\n        if print_results:\n            print('* principal axes:  min\/maj = {:.3f}'.format(axis_ratios))\n\n    return eigen_vectors, eigen_values, axis_ratios\n\n\n#===================================================================================================\n# position distances\n#===================================================================================================\ndef get_positions_periodic(positions, periodic_length=None):\n    '''\n    Get position in range [0, periodic_length).\n\n    Parameters\n    ----------\n    positions : float or array\n    periodic_length : float : periodicity length (if none, return array as is)\n    '''\n    if periodic_length is None:\n        return positions\n\n    if np.isscalar(positions):\n        if positions >= periodic_length:\n            positions -= periodic_length\n        elif positions < 0:\n            positions += periodic_length\n    else:\n        positions[positions >= periodic_length] -= periodic_length\n        positions[positions < 0] += periodic_length\n\n    return positions\n\n\ndef get_position_differences(position_difs, periodic_length=None):\n    '''\n    Get distance \/ separation vector, in range [-periodic_length\/2, periodic_length\/2).\n\n    Parameters\n    ----------\n    position_difs : array : position difference[s]\n    periodic_length : float : periodicity length (if none, return array as is)\n    '''\n    if not periodic_length:\n        return position_difs\n    else:\n        if np.isscalar(periodic_length) and periodic_length <= 1:\n            print('! got unusual periodic_length = {}'.format(periodic_length))\n\n    if np.isscalar(position_difs):\n        if position_difs >= 0.5 * periodic_length:\n            position_difs -= periodic_length\n        elif position_difs < -0.5 * periodic_length:\n            position_difs += periodic_length\n    else:\n        position_difs[position_difs >= 0.5 * periodic_length] -= periodic_length\n        position_difs[position_difs < -0.5 * periodic_length] += periodic_length\n\n    return position_difs\n\n\ndef get_distances(\n    positions_1=None, positions_2=None, periodic_length=None, scalefactor=None,\n    total_distance=False):\n    '''\n    Get vector or total\/scalar distance[s] between input position vectors.\n    If input scale-factors, will convert distance from comoving to physical.\n\n    Parameters\n    ----------\n    positions_1 : array : position[s]\n    positions_2 : array : position[s]\n    periodic_length : float : periodic length (if none, not use periodic)\n    scalefactor : float or array : expansion scale-factor (to convert comoving to physical)\n    total : bool : whether to compute total\/scalar (instead of vector) distance\n\n    Returns\n    -------\n    distances : array (object number x dimension number, or object number) :\n        vector or total\/scalar distance[s]\n    '''\n    if not isinstance(positions_1, np.ndarray):\n        positions_1 = np.array(positions_1)\n    if not isinstance(positions_2, np.ndarray):\n        positions_2 = np.array(positions_2)\n\n    if len(positions_1.shape) == 1 and len(positions_2.shape) == 1:\n        shape_pos = 0\n    else:\n        shape_pos = 1\n\n    distances = get_position_differences(positions_1 - positions_2, periodic_length)\n\n    if total_distance:\n        distances = np.sqrt(np.sum(distances ** 2, shape_pos))\n\n    if scalefactor is not None:\n        if scalefactor > 1 or scalefactor <= 0:\n            print('! got unusual scalefactor = {}'.format(scalefactor))\n        distances *= scalefactor\n\n    return distances\n\n\ndef get_distances_angular(positions_1=None, positions_2=None, sphere_angle=360):\n    '''\n    Get angular separation[s] between input positions, valid for small separations.\n\n    Parameters\n    ----------\n    positions_1, positions_2 : arrays : positions in [RA, dec]\n    sphere_angle : float : angular size of sphere 360 [degrees], 2 * pi [radians]\n\n    Returns\n    -------\n    angular distances : array (object number x angular dimension number)\n    '''\n    if sphere_angle == 360:\n        angle_scale = constant.radian_per_degree\n    elif sphere_angle == 2 * np.pi:\n        angle_scale = 1\n    else:\n        raise ValueError('angle of sphere = {} does not make sense'.format(sphere_angle))\n\n    if np.ndim(positions_1) == 1 and positions_1.size == 2:\n        ras_1, decs_1 = positions_1[0], positions_1[1]\n    else:\n        ras_1, decs_1 = positions_1[:, 0], positions_1[:, 1]\n\n    if np.ndim(positions_2) == 1 and positions_2.size == 2:\n        ras_2, decs_2 = positions_2[0], positions_2[1]\n    else:\n        ras_2, decs_2 = positions_2[:, 0], positions_2[:, 1]\n\n    return np.sqrt((get_position_differences(ras_1 - ras_2, sphere_angle) *\n                    np.cos(angle_scale * 0.5 * (decs_1 + decs_2))) ** 2 + (decs_1 - decs_2) ** 2)\n\n\n#===================================================================================================\n# velocity conversion\n#===================================================================================================\ndef get_velocity_differences(\n    velocity_vectors_1=None, velocity_vectors_2=None,\n    position_vectors_1=None, position_vectors_2=None, periodic_length=None,\n    scalefactor=None, hubble_time=None,\n    total_velocity=False):\n    '''\n    Get relative velocity[s] [km \/ s] between input velocity vectors.\n    If input positions as well, add Hubble flow to velocities.\n\n    Parameters\n    ----------\n    velocity_vectors_1 : array : velocity[s] (object number x dimension number) [km \/ s]\n    velocity_vectors_2 : array : velocity[s] (object number x dimension number) [km \/ s]\n    position_vectors_1 : array : position[s] associated with velocity_vector_1\n        (object number x dimension number) [kpc comoving]\n    position_vectors_2 : array : position[s] associated with velocity_vector_2\n        (object number x dimension number) [kpc comoving]\n    periodic_length : float : periodicity length [kpc comoving]\n    scalefactor : float : expansion scale-factor\n    hubble_time : float : 1 \/ H(z) [Gyr]\n    total_velocity : bool : whether to compute total\/scalar (instead of vector) velocity\n\n    Returns\n    -------\n    velocity_difs  : array (object number x dimension number, or object number) :\n        velocity differences [km \/ s]\n    '''\n    if np.ndim(velocity_vectors_1) == 1 and np.ndim(velocity_vectors_1) == 1:\n        dimension_shape = 0\n    else:\n        dimension_shape = 1\n\n    velocity_difs = velocity_vectors_1 - velocity_vectors_2  # [km \/ s]\n\n    if position_vectors_1 is not None and position_vectors_2 is not None:\n        # add hubble flow: dr\/dt = a * dx\/dt + da\/dt * x = a(t) * dx\/dt + r * H(t)\n        # [kpc \/ Gyr]\n        vels_hubble = (scalefactor \/ hubble_time *\n                       get_distances(position_vectors_1, position_vectors_2, periodic_length))\n        vels_hubble *= constant.km_per_kpc \/ constant.sec_per_Gyr  # [km \/ s]\n        velocity_difs += vels_hubble\n\n    if total_velocity:\n        velocity_difs = np.sqrt(np.sum(velocity_difs ** 2, dimension_shape))\n\n    return velocity_difs\n\n\n#===================================================================================================\n# center of mass: position and velocity\n#===================================================================================================\ndef get_center_position_zoom(\n    positions, weights=None, periodic_length=None, position_number_min=32, center_position=None,\n    distance_max=np.Inf):\n    '''\n    Get position of center of mass, using iterative zoom-in.\n\n    Parameters\n    ----------\n    positions : array (particle number x dimension number) : position[s]\n    weights : array : weight for each position (usually mass) - if None, assume all have same weight\n    periodic_length : float : periodic box length\n    position_number_min : int : minimum number of positions within distance to keep zooming in\n    center_position : array : initial center position to use\n    distance_max : float : maximum distance to consider initially\n\n    Returns\n    -------\n    center_position : array : position vector of center of mass\n    '''\n    distance_bins = np.array([\n        np.Inf, 1000, 700, 500, 300, 200, 150, 100,\n        70, 50, 30, 20, 15, 10,\n        7, 5, 3, 2, 1.5, 1,\n        0.7, 0.5, 0.3, 0.2, 0.15, 0.1,\n        0.07, 0.05, 0.03, 0.02, 0.015, 0.01,\n        0.007, 0.005, 0.003, 0.002, 0.0015, 0.001,\n    ])\n    distance_bins = distance_bins[distance_bins <= distance_max]\n\n    if weights is not None:\n        assert positions.shape[0] == weights.size\n        # normalizing weights by median seems to improve numerical stability\n        weights = np.asarray(weights) \/ np.median(weights)\n\n    if center_position is None or not len(center_position):\n        center_position = np.zeros(positions.shape[1], positions.dtype)\n    else:\n        center_position = np.array(center_position, positions.dtype)\n\n    if positions.shape[0] > 2147483647:\n        idtype = np.int64\n    else:\n        idtype = np.int32\n    part_indices = np.arange(positions.shape[0], dtype=idtype)\n\n    for dist_i, dist_max in enumerate(distance_bins):\n        ## direct method ----------\n        distance2s = get_position_differences(\n            positions[part_indices] - center_position, periodic_length) ** 2\n        distance2s = np.sum(distance2s, 1)\n\n        # get particles within distance max\n        masks = (distance2s < dist_max ** 2)\n        part_indices_dist = part_indices[masks]\n\n        # store particles slightly beyond distance max for next interation\n        masks = (distance2s < (1.5 * dist_max) ** 2)\n        part_indices = part_indices[masks]\n\n        \"\"\"\n        ## kd-tree method ----------\n        if dist_i == 0:\n            # does not handle periodic boundaries, but should be ok for zoom-in\n            KDTree = spatial.cKDTree(positions)\n            particle_number_max = positions.shape[0]\n\n        distances, indices = KDTree.query(\n            center_position, particle_number_max, distance_upper_bound=dist_max)\n\n        masks = (distances < dist_max)\n        part_indices_dist = indices[masks]\n        particle_number_max = part_indices_dist.size\n        \"\"\"\n\n        # check whether reached minimum total number of particles within distance\n        # but force at least one loop over distance bins to get *a* center\n        if part_indices_dist.size <= position_number_min and dist_i > 0:\n            return center_position\n\n        if weights is None:\n            weights_use = weights\n        else:\n            weights_use = weights[part_indices_dist]\n\n        # ensure that np.average uses 64-bit internally for accuracy, but returns as input dtype\n        center_position = np.average(\n            positions[part_indices_dist].astype(np.float64), 0, weights_use).astype(positions.dtype)\n\n    return center_position\n\n\ndef get_center_velocity(\n    velocities, weights=None, positions=None, center_position=None, distance_max=20,\n    periodic_length=None):\n    '''\n    Get velocity of center of mass.\n    If no input masses, assume all masses are the same.\n\n    Parameters\n    ----------\n    velocities : array (particle number x 3) : velocity[s]\n    weights : array : weight for each position (usually mass) - if None, assume all have same weight\n    positions : array : positions (particle number x dimension number), if want to select by this\n    center_position : array : center position, if want to select by this\n    distance_max : float : maximum position difference from center to use particles\n    periodic_length : float : periodic box length\n\n    Returns\n    -------\n    center_velocity : array : velocity vector of center of mass\n    '''\n    masks = np.full(velocities.shape[0], True, dtype=bool)\n\n    # ensure that use only finite values\n    for dimen_i in range(velocities.shape[1]):\n        masks *= np.isfinite(velocities[:, dimen_i])\n\n    if positions is not None and center_position is not None and len(center_position):\n        assert velocities.shape == positions.shape\n        distance2s = np.sum(\n            get_position_differences(positions - center_position, periodic_length) ** 2, 1)\n        masks *= (distance2s < distance_max ** 2)\n\n    if weights is not None:\n        assert velocities.shape[0] == weights.size\n        # normalizing weights by median seems to improve numerical stability\n        weights = weights[masks] \/ np.median(weights[masks])\n\n    if not masks.any():\n        print('! could not compute center velocity')\n        print('  no particles within distance_max = {} kpc (nearest = {} kpc)'.format(\n            distance_max, np.sqrt(distance2s.min())))\n        return np.r_[np.nan, np.nan, np.nan]\n\n    # ensure that np.average uses 64-bit internally for accuracy, but returns as input dtype\n    return np.average(velocities[masks].astype(np.float64), 0, weights).astype(velocities.dtype)\n\n\n#===================================================================================================\n# volume of region\n#===================================================================================================\ndef get_volume_of_convex_hull(positions):\n    '''\n    Compute volume of convex hull that encloses input positions.\n\n    Parameters\n    ----------\n    positions : array : positions (object number x dimension number)\n\n    Returns\n    -------\n    volume within convex hull around positions : float\n    '''\n\n    def get_tetrahedron_volume(a, b, c, d):\n        return np.abs(np.einsum('ij,ij->i', a - d, np.cross(b - d, c - d))) \/ 6\n\n    ConvexHull = spatial.ConvexHull(positions)\n    DelaunayTes = spatial.Delaunay(positions[ConvexHull.vertices])\n    tets = DelaunayTes.points[DelaunayTes.simplices]\n\n    return np.sum(get_tetrahedron_volume(tets[:, 0], tets[:, 1], tets[:, 2], tets[:, 3]))\n\n\n#===================================================================================================\n# coordinates in redshift space\n#===================================================================================================\ndef convert_velocity_redshift(value_kind, values, solve_exact=True):\n    '''\n    Get velocity\/redshift along the line of sight from redshift\/velocity [km \/ s].\n    Independent of cosmology.\n\n    Parameters\n    ----------\n    value_kind: str : 'redshift', 'velocity'\n    values : float or array : redshift\/velocity value[s]\n    solve_exact : bool : whether to use exact solution or faster approximation\n\n    Returns\n    -------\n    velocities [km \/ s] or redshifts : array (object number)\n    '''\n    if value_kind == 'redshift':\n        # input redshift, get velocity\n        if solve_exact:\n            return (((1 + values) ** 2 - 1) \/ ((1 + values) ** 2 + 1) * constant.speed_light *\n                    constant.kilo_per_centi)\n        else:\n            return constant.speed_light * values * constant.kilo_per_centi\n\n    elif value_kind == 'velocity':\n        # input velocity, get redshift\n        if solve_exact:\n            return ((1 + values * constant.centi_per_kilo \/ constant.speed_light) \/\n                    (1 - values * constant.centi_per_kilo \/ constant.speed_light)) ** 0.5 - 1\n        else:\n            return values * constant.centi_per_kilo \/ constant.speed_light\n\n\ndef get_position_difs_from_redshift_difs(redshift_difs, hubble_times):\n    '''\n    Get position difference [kpc comoving] from redshift difference (redshift-space distortion).\n    *** distance is *approximate*, valid in non-relativistic limit.\n\n    Parameters\n    ----------\n    redshift_difs : float or array : redshift difference[s]\n    hubble_times : float or array : hubble time[s] = 1 \/ H [Gyr]\n\n    Returns\n    -------\n    position differences [kpc comoving] : array (object number)\n    '''\n    return convert_velocity_redshift('redshift', redshift_difs, solve_exact=False) * hubble_times\n\n\ndef get_position_difs_from_velocity_difs(velocity_difs, hubble_times, redshifts):\n    '''\n    Get position difference [kpc comoving] from velocity difference (redshifts-space distortion).\n\n    Parameters\n    ----------\n    velocity_difs : floar or array : peculiar velocity[s] [km \/ s]\n    hubble_time : float or array : hubble time[s] = 1 \/ H [Gyr]\n    redshifts : float or array\n\n    Returns\n    -------\n    position differences [kpc comoving]: array (object number)\n    '''\n    return ((velocity_difs \/ (1 + redshifts) * constant.kpc_per_km \/ constant.Gyr_per_sec) *\n            hubble_times)\n\n\ndef get_positions_in_redshift_space(\n    positions, velocities, hubble_times, redshifts, periodic_length=None):\n    '''\n    Get position[s] [kpc comoving] in redshifts space, convolving real position[s] with\n    redshifts-space distortion.\n\n    Parameters\n    ----------\n    positions : float or array : actual position[s] [kpc comoving]\n    velocities : float or array : peculiar velocity[s] [km \/ s]\n    hubble_times : float or array : hubble time[s] = 1 \/ H [Gyr]\n    periodic_length : float : periodicity length\n\n    Returns\n    -------\n    positions [kpc comoving] : array (object number)\n    '''\n    return positions(\n        positions + get_position_difs_from_velocity_difs(velocities, hubble_times, redshifts),\n        periodic_length)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_450","text":"<reponame>snumrl\/skate\nimport numpy as np\nimport math\nfrom scipy.optimize import minimize\n\nclass IKsolver(object):\n    def __init__(self, skel1, skel2, left_foot_traj, right_foot_traj, t, pend):\n        self.left_foot_traj = left_foot_traj\n        self.right_foot_traj = right_foot_traj\n        self.skel1 = skel1\n        self.skel2 = skel2\n        self.gtime = t\n        self.pendulum = pend\n\n    def update_target(self, ):\n        # print(\"self.gtime:\", self.gtime)\n        # self.target_foot = np.array([skel1.q[\"j_cart_x\"], -0.92, skel1.q[\"j_cart_z\"]])\n\n        # ground_height = -1.1\n        ground_height = -0.92\n        self.target_left_foot = np.array(\n            [self.skel1.q[\"j_cart_x\"], ground_height, self.left_foot_traj[1][self.gtime] - 0.05 - 0.3])\n        self.target_right_foot = np.array(\n            [self.skel1.q[\"j_cart_x\"], ground_height, self.right_foot_traj[1][self.gtime] + 0.05 + 0.3])\n        # l = self.skeletons[1].body('h_pole').local_com()[1]\n        l = self.pendulum.length\n        # self.target_pelvis = np.array([0, 0, 0])\n        self.target_pelvis = np.array(\n            [self.skel1.q[\"j_cart_x\"] - l * math.sin(self.pendulum.theta), -0.92 + l * math.cos(self.pendulum.theta), 0])\n\n    def set_params(self, x):\n        q = self.skel2.q\n        q = x\n        # q[6:] = x\n        self.skel2.set_positions(q)\n\n    def f(self, x):\n\n        def rotationMatrixToAxisAngles(R):\n            temp_r = np.array([R[2,1]-R[1,2], R[0,2]-R[2,0], R[1,0]-R[0,1]])\n            angle = math.acos((R[0, 0]+R[1, 1]+R[2, 2] - 1)\/2.)\n            temp_r_norm = np.linalg.norm(temp_r)\n            if temp_r_norm < 0.000001:\n                return np.zeros(3)\n\n            return temp_r\/temp_r_norm * angle\n\n        def rotationMatrixToEulerAngles(R):\n\n            # assert (isRotationMatrix(R))\n\n            sy = math.sqrt(R[0, 0] * R[0, 0] + R[1, 0] * R[1, 0])\n\n            singular = sy < 1e-6\n\n            if not singular:\n                x = math.atan2(R[2, 1], R[2, 2])\n                y = math.atan2(-R[2, 0], sy)\n                z = math.atan2(R[1, 0], R[0, 0])\n            else:\n                x = math.atan2(-R[1, 2], R[1, 1])\n                y = math.atan2(-R[2, 0], sy)\n                z = 0\n\n            return np.array([x, y, z])\n\n        self.set_params(x)\n        pelvis_state = self.skel2.body(\"h_pelvis\").to_world([0.0, 0.0, 0.0])\n        # pelvis_state = self.skel2.body(\"h_abdomen\").to_world([0.0, 0.0, 0.0])\n        left_foot_state = self.skel2.body(\"h_blade_left\").to_world([0.0, 0.0, 0.0])\n        left_foot_ori = self.skel2.body(\"h_blade_left\").world_transform()\n        right_foot_state = self.skel2.body(\"h_blade_right\").to_world([0.0, 0.0, 0.0])\n        right_foot_ori = self.skel2.body(\"h_blade_right\").world_transform()\n\n        abdomen_ori = self.skel2.body(\"h_abdomen\").world_transform()\n\n\n        # print(\"foot_ori: \", left_foot_ori[:3, :3], type(left_foot_ori[:3, :3]))\n\n        # todo : calculate the x_axis according to the spline\n\n        # x_axis = np.array([0., 0., self.left_der[0][self.gtime]])\n        x_axis = np.array([1.0, 0., 1.0])\n        x_axis = x_axis \/ np.linalg.norm(x_axis)  # normalize\n        y_axis = np.array([0., 1., 0.])\n        z_axis = np.cross(x_axis, y_axis)\n        z_axis = z_axis \/ np.linalg.norm(z_axis)  # normalize\n        R_des = np.stack((x_axis, y_axis, z_axis), axis=-1)\n        # print(\"x_axis: \\n\")\n        # print(x_axis)\n        # print(\"y_axis: \\n\")\n        # print(y_axis)\n        # print(\"z_axis: \\n\")\n        # print(z_axis)\n        # print(\"R: \\n\")\n        # print(R_des)\n\n        # left_axis_angle =rotationMatrixToAxisAngles(left_foot_ori[:3, :3])\n        # right_axis_angle = rotationMatrixToAxisAngles(right_foot_ori[:3, :3])\n\n        left_res_rot = np.transpose(R_des).dot(left_foot_ori[:3, :3])\n        right_res_rot = np.transpose(R_des).dot(right_foot_ori[:3, :3])\n        # print(\"vec res: \", left_res_rot)\n        left_axis_angle = rotationMatrixToAxisAngles(left_res_rot)\n        right_axis_angle = rotationMatrixToAxisAngles(right_res_rot)\n\n        abdomen_axis_angle = rotationMatrixToAxisAngles(abdomen_ori[:3, :3])\n\n        # print(\"axis_angle\", axis_angle)\n\n        # return 0.5 *  np.linalg.norm(left_foot_state - self.target_foot) ** 2\n        return 0.5 * (np.linalg.norm(pelvis_state - self.target_pelvis) ** 2 + np.linalg.norm(\n            left_foot_state - self.target_left_foot) ** 2 + np.linalg.norm(\n            right_foot_state - self.target_right_foot) ** 2 + np.linalg.norm(\n            left_axis_angle - np.array([0., 0., 0.])) ** 2 + np.linalg.norm(\n            right_axis_angle - np.array([0., 0., 0.])) ** 2 + np.linalg.norm(\n            abdomen_axis_angle - np.array([0., 0., 0.])) ** 2)\n\n    def g(self, x):\n        self.set_params(x)\n\n        pelvis_state = self.skel2.body(\"h_pelvis\").to_world([0.0, 0.0, 0.0])\n        # pelvis_state = self.skel2.body(\"h_abdomen\").to_world([0.0, 0.0, 0.0])\n        left_foot_state = self.skel2.body(\"h_blade_left\").to_world([0.0, 0.0, 0.0])\n        right_foot_state = self.skel2.body(\"h_blade_right\").to_world([0.0, 0.0, 0.0])\n\n        J_pelvis = self.skel2.body(\"h_pelvis\").linear_jacobian()\n        J_left_foot = self.skel2.body(\"h_blade_left\").linear_jacobian()\n        J_right_foot = self.skel2.body(\"h_blade_right\").linear_jacobian()\n\n        J_temp = np.vstack((J_pelvis, J_left_foot))\n        J = np.vstack((J_temp, J_right_foot))\n        AA = np.append(pelvis_state - self.target_pelvis, left_foot_state - self.target_left_foot)\n        AAA = np.append(AA, right_foot_state - self.target_right_foot)\n\n        # print(\"pelvis\", pelvis_state - self.target_pelvis)\n        # print(\"J\", J_pelvis)\n        #\n        # print(\"AA\", AA)\n        # print(\"J\", J)\n\n        # g = AA.dot(J)\n        g = AAA.dot(J)\n        # g = AA.dot(J)[6:]\n\n        return g\n\n    def solve(self, ):\n        q_backup = self.skel2.q\n        res = minimize(self.f, x0= self.skel2.q, jac=self.g, method=\"SLSQP\")\n        # res = minimize(self.f, x0=self.skeletons[2].q[6:], jac=self.g, method=\"SLSQP\")\n        # print(res)\n        self.skel2.set_positions(q_backup)\n\n        return res['x']"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_451","text":"<reponame>RobbinBouwmeester\/oxPTMScanner_cmd<filename>oxPTM_scanner.py\n\"\"\"\nCopyright 2017 <NAME>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\n\n\"\"\"\nThis software can be used to flag MS2 spectra based on belonging to one \nof two classes of spectra. The two classes this code has been tested on \noxPTM VS native spectra. The code can be used to train a new model that \ndiscriminates between two classes. After a model has been trained\nthe code can be used to make predictions for unseen spectra.\n\nLibrary versions:\n\nPython 2.7.13\nxgboost.__version__ = '0.6'\nsklearn.__version__ = '0.19.0'\nscipy.__version__ = '0.19.1'\nnumpy.__version__ = '1.13.3'\npandas.__version__ = '0.20.3'\n\nThis project was made possible by MASSTRPLAN. MASSTRPLAN received funding \nfrom the Marie Sklodowska-Curie EU Framework for Research and Innovation \nHorizon 2020, under Grant Agreement No. 675132.\n\"\"\"\n\n# TODO make webversion\n\n__author__ = \"<NAME>\"\n__copyright__ = \"Copyright 2017\"\n__credits__ = [\"<NAME>\",\"<NAME>\",\"Prof. <NAME>\"]\n__license__ = \"Apache License, Version 2.0\"\n__version__ = \"1.0\"\n__maintainer__ = \"<NAME>\"\n__email__ = \"<EMAIL>\"\n__status__ = \"Beta version; ready for in-field application\"\n\n#Native library\nimport argparse\nimport pickle\nimport copy\nfrom operator import itemgetter\nfrom itertools import combinations\nimport os\n\n#Pandas\nimport pandas as pd\n\n#Numpy\nimport numpy as np\nfrom numpy.random import ranf\nimport numpy as np\nimport numpy.random as np_random\n\n#Matplotlib\nimport matplotlib.pyplot as plt\n\n#SciPy\nimport scipy.stats as st\nimport scipy\n\n#ML\nfrom sklearn.model_selection import RandomizedSearchCV\nfrom sklearn.metrics import roc_curve\nfrom sklearn.model_selection import cross_val_predict\nfrom sklearn.metrics import auc\nfrom sklearn.model_selection import StratifiedKFold\nimport xgboost as xgb\n\ngui_object = None\n\nclass Dummy(): pass\n\ndef parse_msp(msp_entry,tic_normalization=True,min_perc=False,windowed_mode=False,top=10,window_size=100):\n    \"\"\"\n    Parse an MSP entry and return the identifier, peaks and intensity. Normalization \n    can be enabled and filtering on the intensity of peaks.\n\n    Parameters\n    ----------\n    msp_entry : list\n        list with the lines of the MSP entry\n    tic_normalization : bool\n        Return tic normalized intensities\n    min_perc : bool\n        Flag to use a minimal percentage intensity to filter peaks\n    windowed_mode : bool\n        Flag to use windowed mode to return the top intensity peaks\n    top : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    window_size : int\n        The size of the window in windowed mode\n        \n    Returns\n    -------\n    str\n        identifier of the msp entry\n    list\n        the m\/z values in the msp entry\n    list\n        the intensity values in the msp entry    \n    \"\"\"\n    \n    identifier = \"\"\n    mz_list = []\n    intensity_list = []\n    if tic_normalization: tot_tic = 0.0\n    \n    #Iterate over the lines in the MSP entry and record the identifiers, m\/z and intensities\n    for line in msp_entry:\n        line = line.rstrip()\n        if line == \"\": continue\n        if line.startswith(\"Name: \"):\n            identifier = line.lstrip(\"Name: \")\n            continue\n        if \":\" in line: continue\n        \n        splitline = line.split(\"\\t\")\n\n        mz_list.append(float(splitline[0]))\n        intensity_list.append(float(splitline[1]))\n        if tic_normalization: tot_tic += intensity_list[-1]\n    \n    #In the case of tic normalization iterate over the values and divide by total intensity\n    if tic_normalization:\n        for index,intens in enumerate(intensity_list):\n            intensity_list[index] = intens\/tot_tic\n    \n    #Filter based on the top intensities\n    gr_mz_list,gr_intensity_list = get_top_spec(mz_list,\n                                                intensity_list,\n                                                min_perc=min_perc,\n                                                windowed_mode=windowed_mode,\n                                                top=top,\n                                                window_size=window_size)\n    \n    return(identifier,gr_mz_list,gr_intensity_list)\n    \ndef parse_mgf(mgf_entry,tic_normalization=True,min_perc=False,top=10,window_size=100,windowed_mode=False):\n    \"\"\"\n    Parse an MGF entry and return the identifier, peaks and intensity. Normalization \n    can be enabled and filtering on the intensity of peaks.\n\n    Parameters\n    ----------\n    mgf_entry : list\n        list with the lines of the MGF entry\n    tic_normalization : bool\n        Return tic normalized intensities\n    min_perc : bool\n        Flag to use a minimal percentage intensity to filter peaks\n    windowed_mode : bool\n        Flag to use windowed mode to return the top intensity peaks\n    top : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    window_size : int\n        The size of the window in windowed mode\n        \n    Returns\n    -------\n    str\n        identifier of the MGF entry\n    list\n        the m\/z values in the MGF entry\n    list\n        the intensity values in the MGF entry    \n    \"\"\"\n    \n    identifier = \"\"\n    mz_list = [0.0]\n    intensity_list = [1.0]\n    if tic_normalization: tot_tic = 0.0\n    \n    #Iterate over the lines in the MGF entry\n    for line in mgf_entry:\n        line = line.rstrip()\n        if line == \"\": continue\n        if line.startswith(\"TITLE=\"):\n            identifier = line.lstrip(\"TITLE=\")\n            continue\n        if \"=\" in line: continue\n        \n        if \"\\t\" in line: splitline = line.split(\"\\t\")\n        else: splitline = line.split(\" \")\n        \n        mz_list.append(float(splitline[0]))\n        intensity_list.append(float(splitline[1]))\n        if tic_normalization: tot_tic += intensity_list[-1]\n    \n    #In the case of tic normalization iterate over the values and divide by total intensity\n    if tic_normalization:\n        for index,intens in enumerate(intensity_list):\n            intensity_list[index] = intens\/tot_tic\n    \n    #Filter based on the top intensities\n    gr_mz_list,gr_intensity_list = get_top_spec(mz_list,\n                                                intensity_list,\n                                                min_perc=min_perc,\n                                                windowed_mode=windowed_mode,\n                                                top=top,\n                                                window_size=window_size)\n    \n    return(identifier,gr_mz_list,gr_intensity_list)\n\ndef get_top_spec(mz_list,intensity_list,min_perc=False,windowed_mode=False,top=10,window_size=100,add_dummy_peak=True):\n    \"\"\"\n    Filter in multiple ways on the intensity of peaks.\n\n    Parameters\n    ----------\n    mz_list : list\n        The m\/z values of a spectrum in a list; equal length to the intensity list\n    intensity_list : list\n        The intensity values of a spectrum in a list; equal length to the m\/z list\n    min_perc : bool\n        Flag to use a minimal percentage intensity to filter peaks\n    windowed_mode : bool\n        Flag to use windowed mode to return the top intensity peaks\n    top : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    window_size : int\n        The size of the window in windowed mode\n    add_dummy_peak : bool\n        Flag to add a dummy peak at 0.0 m\/z\n    \n    Returns\n    -------\n    list\n        the filtered m\/z values from the spectrum\n    list\n        the filtered intensity values from the spectrum  \n    \"\"\"\n    gr_intensity_list = []\n    gr_mz_list = []\n    \n    #In the case of minimal percentage... calculate perc intensity and filter\n    if min_perc:\n        for i,mz in zip(intensity_list,mz_list):\n            if i > min_perc:\n                gr_intensity_list.append(i)\n                gr_mz_list.append(mz)\n    \n    #In the case of windowed mode... iterate over the possible windows and intensity values; take the top per window\n    if windowed_mode:\n        start_index = 0\n        for w in range(window_size,int(max(mz_list)),window_size):\n            temp_mz = []\n            temp_intens = []\n            temp_start_index = 0\n            \n            #Iterate over all m\/z values and see if they fall within the window\n            for mz,intens in zip(mz_list[start_index:],intensity_list[start_index:]):\n                if mz > w and mz <= w+window_size:\n                    temp_start_index += 1\n                    temp_mz.append(mz)\n                    temp_intens.append(intens)\n                if mz > w+window_size:\n                    break\n            #Next window ignore all these lower values\n            start_index = copy.deepcopy(temp_start_index)\n            \n            #Use all if there are less peaks than the top number of peaks it should select\n            if len(temp_mz) <= top:\n                gr_mz_list.extend(temp_mz)\n                gr_intensity_list.extend(temp_intens)\n                continue\n            \n            #Get the indexes of the top peaks\n            idxs = np.sort(np.argpartition(np.array(temp_intens), -top)[-top:])\n            gr_mz_list.extend([temp_mz[idx] for idx in idxs])\n            gr_intensity_list.extend([temp_intens[idx] for idx in idxs])\n    \n    #If not windowed or min perc use a simple top peaks\n    if not windowed_mode and not min_perc:\n        if len(intensity_list) > top:\n            #Get the indexes of the top peaks\n            idxs = np.sort(np.argpartition(np.array(intensity_list), -top)[-top:])\n            gr_mz_list = [mz_list[idx] for idx in idxs]\n            gr_intensity_list = [intensity_list[idx] for idx in idxs]\n        else:\n            #If there are less peaks than top peaks; return all\n            gr_mz_list = mz_list\n            gr_intensity_list = intensity_list\n    \n    #If needed add a dummy peak; this is important later since I want to take into account immonium ions and small fragments\n    if add_dummy_peak:\n        gr_mz_list.insert(0,0.0)\n        gr_intensity_list.insert(0,1.0)\n    \n    return(gr_mz_list,gr_intensity_list)\n    \ndef get_feats(mz_list,intensity_list,feat_matrix,instance_index,feats,max_dist=275,allowed_c=[],pseudocount=0.000000001):\n    \"\"\"\n    Retrieve features and write them to a matrix.\n\n    Parameters\n    ----------\n    mz_list : list\n        The m\/z values of a spectrum in a list; equal length to the intensity list\n    intensity_list : list\n        The intensity values of a spectrum in a list; equal length to the m\/z list\n    feat_matrix : lil or csr matrix\n        Sparse matrix that should be used to fill in the features from the m\/z and intensity lists\n    instance_index : int\n        Row number in the matrix where the features should be filled in (indexing starts at 0)\n    feats : list\n        The bins used for features; should be sorted!; features are assigned if value is in between values of this list\n    max_dist : int\n        Maximum distance between peaks\n    allowed_c : list\n        Allowed bins (selected features); not used any more\n    \n    Returns\n    -------\n    matrix\n        A sparse matrix (lil or csr) is returned with filled in features\n    \"\"\"\n    # UNCOMMENT var below if standard library combinations is used\n    #allowed_c = set(allowed_c)\n    \n    spectrum = zip(mz_list,intensity_list)\n    dists_mz = []\n    dists_mz_intens = []\n    prev_analyzed = set()\n    \n    #Make deepcopy since we are going to change the spectra!\n    spec_one = list(copy.deepcopy(spectrum))\n    spec_two = list(copy.deepcopy(spectrum))\n    \n    #Iterate over the peaks and measure the distance in m\/z between all combinations\n    for peak_one in spec_one:\n        if len(spec_two) == 1: continue\n        spec_two = spec_two[1:]\n        for peak_two in spec_two:\n            dist_mz = abs(peak_one[0]-peak_two[0])\n            if dist_mz > max_dist: break\n            dists_mz.append(dist_mz)\n            dists_mz_intens.append(peak_one[1]+peak_two[1])\n    \n    # UNCOMMENT code below if standard library combinations is used\n    #for c in combinations(spectrum,2):\n    #   dist_mz = abs(c[0][0]-c[1][0])\n    #   if c[0][0] in prev_analyzed: continue\n    #   if dist_mz > max_dist: \n    #       prev_analyzed.add(c[0][0])\n    #       continue\n    #   if len(allowed_c) != 0:\n    #       if dist_mz not in allowed_c: continue\n    #   dists_mz.append(dist_mz)\n    #   dists_mz_intens.append(c[0][1]+c[1][1])\n    \n    #Digitize the delta m\/z; assign bins for all delta m\/z s\n    index_bins = np.digitize(dists_mz,feats)\n    \n    #Iterate over assigned bins and sum the intensity for possible existing values\n    for index,intens in zip(index_bins,dists_mz_intens):\n        feat_matrix[instance_index,index-1] += intens\n\n    feat_matrix[instance_index,feat_matrix.shape[1]-1] += pseudocount\n    return(feat_matrix)\n    \ndef read_msp(infile_name,feat_lim_file=\"\",\n             sum_feats=False,selected_features=[],\n             max_dist=275,step_size=0.005,feat_bins=[],\n             top_peaks=50,windowed_mode=False):\n    \"\"\"\n    Read an MSP file and put the features into a matrix.\n\n    Parameters\n    ----------\n    infile_name : list\n        The infile MSP file.\n    feat_lim_file : list\n        Old variable with the name of a file that contains the features.\n    sum_feats : bool\n        Old variable used to sum features of the two classes.\n    selected_features : list\n        Old variable for selected features; use feat_bins.\n    max_dist : int\n        Maximum distance between peaks\n    step_size : float\n        Size between the m\/z values for bins.\n    feat_bins : list\n        Bins to use for features.\n    top_peaks : int\n        Number of peaks to select based on the intensity\n    windowed_mode : bool\n        Flag to used windowed mode for selecting the highest intensity peaks\n        \n    Returns\n    -------\n    matrix\n        A sparse matrix (csr) is returned with filled in features\n    list\n        Used features for binning\n    list\n        Identifiers of all entries in the MSP file\n    int\n        Number of analyzed MSP entries\n    \"\"\"\n    print(\" Reading the MSP file ... \")\n\n    infile = open(infile_name)\n\n    if len(feat_lim_file) > 0:\n        selected_features = [float(f.strip()) for f in open(feat_lim_file).readlines()]\n        \n    counter = 0\n    temp_entry = []\n    instance_names = []\n    num_instances = num_instances_msp(infile_name)\n\n    if len(feat_bins) == 0: feat_bins = np.arange(0,max_dist+step_size,step_size)\n    \n    #Initialize the feature matrix, must be lil since scr is slow when mutating values!\n    feat_matrix = scipy.sparse.lil_matrix((num_instances, len(feat_bins)),dtype=np.float32)\n    \n    #Iterate over the file and filter out single entries\n    for line in infile:\n        if line.startswith(\"Name: \"):\n            if len(temp_entry) == 0:\n                temp_entry.append(line.strip())\n                continue\n            #For this entry get identifier,m\/z,intensities\n            identifier,mz_list,intensity_list = parse_msp(temp_entry,top=top_peaks,windowed_mode=windowed_mode)\n            instance_names.append(identifier)\n            #Fill in the feature matrix\n            feat_matrix = get_feats(mz_list,intensity_list,feat_matrix,counter,feat_bins,allowed_c=selected_features,max_dist=max_dist)\n            \n            #Make sure the current line is still used for the next entry\n            temp_entry = [line]\n            perc = round((float(counter)\/num_instances)*1000,1)\n            if perc.is_integer():\n                try:\n                    gui_object.progress_bar.setProperty(\"value\", perc\/10.0)\n                except:\n                    pass\n\n            counter += 1\n            \n        temp_entry.append(line.strip())\n    \n    #If everything is empty; return\n    if len(temp_entry) == 0:\n        temp_entry.append(line.strip())\n        return(feat_matrix.asformat(\"csr\"),feat_bins,instance_names,counter)\n\n    #Analyse the last record; since we do not know when the spectra ends\n    identifier,mz_list,intensity_list = parse_msp(temp_entry,top=top_peaks,windowed_mode=windowed_mode)\n    instance_names.append(identifier)\n    feat_matrix = get_feats(mz_list,intensity_list,feat_matrix,counter,feat_bins,allowed_c=selected_features)\n    \n    print(\" Total number of entries read: %s \"  % (counter))\n    counter += 1\n    \n    return(feat_matrix.asformat(\"csr\"),feat_bins,instance_names,counter)\n    \ndef num_instances_msp(infile_name):\n    \"\"\"\n    Count the number of entries in the MSP file.\n\n    Parameters\n    ----------\n    infile_name : list\n        The infile MSP file.\n\n    Returns\n    -------\n    int\n        Number of analyzed MSP entries\n    \"\"\"\n    infile = open(infile_name)\n    num_instances = 0\n    for line in infile:\n        if line.startswith(\"Name: \"):\n            num_instances += 1\n    return(num_instances)\n\ndef read_mgf(infile_name,feat_lim_file=\"\",\n             sum_feats=False,selected_features=[],\n             max_dist=275,step_size=0.005,feat_bins=[],\n             top_peaks=50,windowed_mode=False):\n    \"\"\"\n    Read an MGF file and put the features into a matrix.\n\n    Parameters\n    ----------\n    infile_name : list\n        The infile MGF file.\n    feat_lim_file : list\n        Old variable with the name of a file that contains the features.\n    sum_feats : bool\n        Old variable used to sum features of the two classes.\n    selected_features : list\n        Old variable for selected features; use feat_bins.\n    max_dist : int\n        Maximum distance between peaks\n    step_size : float\n        Size between the m\/z values for bins.\n    feat_bins : list\n        Bins to use for features.\n    top_peaks : int\n        Number of peaks to select based on the intensity\n    windowed_mode : bool\n        Flag to used windowed mode for selecting the highest intensity peaks\n        \n    Returns\n    -------\n    matrix\n        A sparse matrix (csr) is returned with filled in features\n    list\n        Used features for binning\n    list\n        Identifiers of all entries in the MGF file\n    int\n        Number of analyzed MGF entries\n    \"\"\"      \n    \n    infile = open(infile_name)\n    \n    if len(feat_lim_file) > 0:\n        selected_features = [float(f.strip()) for f in open(\"selected_features.txt\").readlines()]\n        \n    counter = 0\n    temp_entry = []\n    instance_names = []\n    num_instances = num_instances_mgf(infile_name)\n    #print(num_instances)\n\n    if len(feat_bins) == 0: feat_bins = np.arange(0,max_dist+step_size,step_size)\n    \n    #Initialize the feature matrix, must be lil since scr is slow when mutating values!\n    feat_matrix = scipy.sparse.lil_matrix((num_instances, len(feat_bins)),dtype=np.float32)\n    \n    #Iterate over the file and filter out single entries\n    for line in infile:\n        if line.startswith(\"END IONS\"):\n            #For this entry get identifier,m\/z,intensities\n            identifier,mz_list,intensity_list = parse_mgf(temp_entry,top=top_peaks,windowed_mode=windowed_mode)\n            instance_names.append(identifier)\n            #Fill in the feature matrix\n            feat_matrix = get_feats(mz_list,intensity_list,feat_matrix,counter,feat_bins,allowed_c=selected_features,max_dist=max_dist)\n            counter += 1\n            temp_entry = []\n            continue\n        if line.startswith(\"BEGIN IONS\"):\n            continue\n        temp_entry.append(line)\n\n    return(feat_matrix.asformat(\"csr\"),feat_bins,instance_names,counter)\n\ndef num_instances_mgf(infile_name):\n    \"\"\"\n    Count the number of entries in the MGF file.\n\n    Parameters\n    ----------\n    infile_name : list\n        The infile MGF file.\n\n    Returns\n    -------\n    int\n        Number of analyzed MGF entries\n    \"\"\"\n    infile = open(infile_name)\n    num_instances = 0\n    for line in infile:\n        if line.startswith(\"BEGIN IONS\"):\n            num_instances += 1\n    return(num_instances)   \n\ndef train_xgb(X,y,n_jobs=32,n_iter_search=20):\n    \"\"\"\n    Train an XGBoost model with hyper parameter optimization.\n\n    Parameters\n    ----------\n    X : matrix\n        Matrix with all the features, every instance should be coupled to the y-value\n    y : vector\n        Vector with the class, every value should be coupled to an x-vector with features\n        \n    Returns\n    -------\n    object\n        Trained XGBoost model\n    object\n        Cross-validation results\n    \"\"\"\n    \n    xgb_handle = xgb.XGBClassifier()\n\n    one_to_left = st.beta(10, 1)  \n    from_zero_positive = st.expon(0, 50)\n    \n    #Define distributions to sample from for hyper parameter optimization\n    param_dist = {  \n        \"n_estimators\": st.randint(3, 80),\n        \"max_depth\": st.randint(3, 40),\n        \"learning_rate\": st.uniform(0.05, 0.4),\n        \"colsample_bytree\": one_to_left,\n        \"subsample\": one_to_left,\n        \"gamma\": st.uniform(0, 10),\n        \"reg_alpha\": from_zero_positive,\n        \"min_child_weight\": from_zero_positive\n    }\n\n    n_iter_search = n_iter_search\n    random_search = RandomizedSearchCV(xgb_handle, param_distributions=param_dist,\n                                       n_iter=n_iter_search,verbose=10,scoring=\"roc_auc\",\n                                       n_jobs=n_jobs,cv=StratifiedKFold(n_splits=10, shuffle=True,random_state=42))\n\n    #print(X)\n    #print(X.shape)\n    #print(y)\n    random_search_res_xgb = random_search.fit(X, y)\n    \n    #Get the best model that was retrained on all data\n    xgb_model = random_search_res_xgb.best_estimator_\n\n    return(xgb_model,random_search_res_xgb)\n    \ndef train_xgb_lim(X,y,params_dist,out_dir=\"res\/\"):\n    \"\"\"\n    Train an XGBoost model with set hyper parameters.\n\n    Parameters\n    ----------\n    X : matrix\n        Matrix with all the features, every instance should be coupled to the y-value\n    y : vector\n        Vector with the class, every value should be coupled to an x-vector with features\n    params_dist : dict\n        The hyperparameters to use\n    out_dir : str\n        String value that points to a directory used for output\n        \n    Returns\n    -------\n    list\n        The cross-validated predictions.\n    \"\"\"\n    #There is a need to unpack the hyperparameter dictionary with \"**\"\n    xgb_handle = xgb.XGBClassifier(**params_dist)\n    #Using predict_proba since ROC-curve\n    test_preds = cross_val_predict(xgb_handle,X,y,method=\"predict_proba\")\n    plot_roc(X,y,test_preds[:,1],fname=out_dir+\"roc.png\")\n    return(test_preds)\n\ndef plot_feat_imp(feats_index,feat_names,X,y,top_imp=10,out_dir=\"res\/\"):\n    \"\"\"\n    Plot the most important features in a boxplot and seperate on class (y)\n\n    Parameters\n    ----------\n    feats_index : list\n        Indexes of the features coupled to the X matrix\n    feat_names : list\n        Names of the features coupled to specific indices\n    X : matrix\n        Matrix with all the features, every instance should be coupled to the y-value\n    y : vector\n        Vector with the class, every value should be coupled to an x-vector with features\n    top_imp : int\n        Plot this number of top features in a boxplot\n    out_dir : str\n        String value that points to a directory used for output\n        \n    Returns\n    -------\n    \n    \"\"\"\n    for fi in feats_index[0:top_imp]:\n        #Need for a dense matrix when plotting\n        #print(fi)\n        #print(X.todense()[y==1,:][:,fi])\n        #print(X.todense()[y==0,:][:,fi])\n        plt.boxplot([list(X.todense()[y==1,:][:,fi]),list(X.todense()[y==0,:][:,fi])])\n        plt.title(feat_names[fi])\n        plt.savefig(out_dir+\"%s_feat_groups.png\" % (feat_names[fi]), bbox_inches='tight')\n        plt.close()\n\ndef plot_train_distr(xgb_model,X,y,out_dir=\"res\/\"):\n    \"\"\"\n    Plot probability distributions for the input matrix.\n\n    Parameters\n    ----------\n    xgb_model : object\n        Trained XGBoost model\n    X : matrix\n        Matrix with all the features, every instance should be coupled to the y-value\n    y : vector\n        Vector with the class, every value should be coupled to an x-vector with features\n    out_dir : str\n        String value that points to a directory used for output\n        \n    Returns\n    -------\n\n    \"\"\"\n    \n    #Get the predicted probabilities for both classes (store them seperately)\n    probs_oxid = xgb_model.predict_proba(X[y==1])[:,1]\n    probs_native = xgb_model.predict_proba(X[y==0])[:,1]\n    \n    #Plot density distribution for probailities\n    pd.Series(probs_oxid).plot(kind=\"density\")\n    pd.Series(probs_native).plot(kind=\"density\")\n    axes = plt.gca()\n    axes.set_xlim([0.0,1.0])\n    plt.savefig(out_dir+\"density_groups.png\", bbox_inches='tight')\n    plt.close()\n    \n    #Plot density distribution for probailities; zoom in more so the y-axis is readable\n    pd.Series(probs_oxid).plot(kind=\"density\")\n    pd.Series(probs_native).plot(kind=\"density\")\n    axes = plt.gca()\n    axes.set_xlim([0.0,1.0])\n    axes.set_ylim([0.0,1.0])\n    plt.savefig(out_dir+'density_groups_zoomed.png', bbox_inches='tight')\n    plt.close()\n\n    #Plot probability distributions in histogram\n    plt.hist(probs_native,bins=100)\n    plt.hist(probs_oxid,bins=100)\n    plt.savefig(out_dir+'hist_groups.png', bbox_inches='tight')\n    plt.close()\n    \n    #Plot probability distributions in histogram; zoom in more so the y-axis is readable\n    plt.hist(probs_native,bins=100)\n    plt.hist(probs_oxid,bins=100)\n    axes = plt.gca()\n    axes.set_ylim([0.0,1000.0])\n    plt.savefig(out_dir+'hist_groups_zoomed.png', bbox_inches='tight')\n    plt.close()\n\ndef xgboost_to_wb(xgboost,params=None,outfile=\"model.pickle\"):\n    \"\"\"\n    Pickle a trained XGBoost model.\n\n    Parameters\n    ----------\n    xgboost : object\n        Trained XGBoost model\n    outfile : str\n        Location of the pickle\n        \n    Returns\n    -------\n\n    \"\"\"\n    if params != None: xgboost.params_train = params\n    pickle.dump(xgboost, open(outfile,\"wb\"))\n\ndef plot_roc(X,y,test_preds,fname=\"res\/roc.png\"):\n    \"\"\"\n    Plot an ROC-curve and write to a file\n\n    Parameters\n    ----------\n    X : matrix\n        Matrix with all the features, every instance should be coupled to the y-value\n    y : vector\n        Vector with the class, every value should be coupled to an x-vector with features\n    test_preds : vector\n        Predicted probabilities for classes\n\n    Returns\n    -------\n\n    \"\"\"\n    #Retrieve multiple fpr and tpr values for different thresholds\n    fpr, tpr, thresholds = roc_curve(y,test_preds)\n    plt.plot(fpr, tpr)\n    plt.title(auc(fpr, tpr))\n    plt.savefig(fname, bbox_inches='tight')\n    plt.close()\n\ndef get_min_diff(zero_f=\"NIST\/human_hcd_synthetic_oxidized.msp\",\n                 one_f=\"NIST\/human_hcd_synthetic_native.msp\",\n                 outfile=\"res_small\/selected_features_diff.txt\",\n                 top_mean = 1000,\n                 top_peaks = 50,\n                 max_distance = 275,\n                 distance_bins = 0.005,\n                 windowed_mode=False):\n    \"\"\"\n    Function that is used to get the most important bins in terms of mean intensity between the two classes.\n\n    Parameters\n    ----------\n    zero_f : str\n        Filename (and dir) that contains the spectra for class 0\n    one_f : str\n        Filename (and dir) that contains the spectra for class 1\n    top_mean : int\n        Return this amount of features (bins)\n    top_peaks : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    max_distance : int\n        Maximum distance in m\/z to use for features\n    windowed_mode : bool\n        Flag to use windowed mode to return the top intensity peaks\n    distance_bins : float\n        Distance in m\/z between the bins\n\n    Returns\n    -------\n    list\n        The most important bins that are on average different between the classes\n    \"\"\"\n    \n    #Check the file extension and parse to get features for class zero\n    if zero_f.endswith(\".mgf\"): feats_zero_sum,feat_bins,instance_names,count_zero = read_mgf(zero_f,\n                                                                                              sum_feats=True,\n                                                                                              max_dist=max_distance,\n                                                                                              step_size=distance_bins,\n                                                                                              top_peaks=top_peaks)\n    elif zero_f.endswith(\".msp\"): feats_zero_sum,feat_bins,instance_names,count_zero = read_msp(zero_f,\n                                                                                                sum_feats=True,\n                                                                                                max_dist=max_distance,\n                                                                                                step_size=distance_bins,\n                                                                                                top_peaks=top_peaks)\n    else: return(False)\n    \n    #Check the file extension and parse to get features for class one\n    if one_f.endswith(\".mgf\"): feats_one_sum,feat_bins,instance_names,count_one = read_mgf(one_f,\n                                                                                           sum_feats=True,\n                                                                                           max_dist=max_distance,\n                                                                                           step_size=distance_bins,\n                                                                                           top_peaks=top_peaks)\n    elif one_f.endswith(\".msp\"): feats_one_sum,feat_bins,instance_names,count_one = read_msp(one_f,\n                                                                                             sum_feats=True,\n                                                                                             max_dist=max_distance,\n                                                                                             step_size=distance_bins,\n                                                                                             top_peaks=top_peaks)\n    else: return(False)\n    \n    #Get average difference between the bins of both groups\n    diffs = [abs(m1-m2) for m1,m2 in zip(feats_zero_sum.mean(axis=0).tolist()[0],feats_one_sum.mean(axis=0).tolist()[0])]\n    \n    #Get the indexes of the biggest differences in bins\n    indexes_diff = sorted(list(enumerate(diffs)),key=itemgetter(1),reverse=True)\n    selected_features_diff = [feat_bins[ind] for ind,val in indexes_diff[0:top_mean]]\n    selected_features_diff.sort()\n    \n    #For the important bins we need the next number to create a closed bin; calculated vals; extend to bins\n    diff_bins = [sfd+distance_bins for sfd in selected_features_diff]\n    diff_bins.extend(selected_features_diff)\n    diff_bins.sort()\n    \n    #Remove duplicate values\n    diff_bins = list(set(diff_bins))\n    diff_bins.sort()\n    \n    #Write feats to a file\n    outfile_feats = open(outfile,\"w\")\n    outfile_feats.write(\"\\n\".join(map(str,diff_bins)))\n    outfile_feats.close()\n\n    return(diff_bins)\n    \ndef train_initial_classifier(zero_f=\"NIST\/human_hcd_synthetic_oxidized.msp\",\n                             one_f=\"NIST\/human_hcd_synthetic_native.msp\",\n                             selected_features_diff=[],\n                             top_mean = 1000,\n                             top_peaks = 100,\n                             max_distance = 275,\n                             distance_bins = 0.005,\n                             windowed_mode = False,\n                             out_dir=\"res\/\",\n                             out_pickle=\"model.pickle\",\n                             n_jobs=32,\n                             n_iter_search=20):\n    \"\"\"\n    Function that is used to train an XGBoost model to discrimate between the MS2 spectra from two files.\n\n    Parameters\n    ----------\n    zero_f : str\n        Filename (and dir) that contains the spectra for class 0\n    one_f : str\n        Filename (and dir) that contains the spectra for class 1\n    selected_features_diff : list\n        List with m\/z bin values that should be used as features\n    top_mean : int\n        Return this amount of features (bins)\n    top_peaks : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    max_distance : int\n        Maximum distance in m\/z to use for features\n    windowed_mode : bool\n        Flag to use windowed mode to return the top intensity peaks\n    distance_bins : float\n        Distance in m\/z between the bins\n    out_dir : str\n        Directory to write the results to\n        \n    Returns\n    -------\n    dict\n        Used parameters in the XGBoost model\n    list\n        Most important features according to the F-score in the XGBoost model\n    \"\"\"\n    #Check the file extension and parse to get features for class zero\n    if zero_f.endswith(\".mgf\"): feats_zero,feat_bins,instance_names,count_zero = read_mgf(zero_f,sum_feats=False,\n                                                                                          feat_bins=selected_features_diff,\n                                                                                          max_dist=max_distance,\n                                                                                          step_size=distance_bins,\n                                                                                          top_peaks=top_peaks)\n    elif zero_f.endswith(\".msp\"): feats_zero,feat_bins,instance_names,count_zero = read_msp(zero_f,\n                                                                                            sum_feats=False,\n                                                                                            feat_bins=selected_features_diff,\n                                                                                            max_dist=max_distance,\n                                                                                            step_size=distance_bins,\n                                                                                            top_peaks=top_peaks)\n    else: return(False) # TODO display error!\n    \n    #Check the file extension and parse to get features for class one\n    if one_f.endswith(\".mgf\"): feats_one,feat_bins,instance_names,count_one = read_mgf(one_f,\n                                                                                       sum_feats=False,\n                                                                                       feat_bins=selected_features_diff,\n                                                                                       max_dist=max_distance,\n                                                                                       step_size=distance_bins,\n                                                                                       top_peaks=top_peaks)\n    elif one_f.endswith(\".msp\"): feats_one,feat_bins,instance_names,count_one = read_msp(one_f,\n                                                                                         sum_feats=False,\n                                                                                         feat_bins=selected_features_diff,\n                                                                                         max_dist=max_distance,\n                                                                                         step_size=distance_bins,\n                                                                                         top_peaks=top_peaks)\n    else: return(False) # TODO display error!\n\n    #Prepare labels equal to length class zero and one\n    y = [0]*(count_zero)\n    y.extend([1]*(count_one))\n\n    y = np.array(y)\n    \n    #Stack the feature matrices of both classes\n    X = scipy.sparse.vstack((feats_zero,feats_one))\n    \n    #Train optimizing the hyperparameters\n    xgb_model,random_search_res_xgb = train_xgb(X,y,n_jobs=n_jobs,n_iter_search=n_iter_search)\n    print(random_search_res_xgb.best_params_)\n    print(random_search_res_xgb.best_score_)\n    \n    #Train use selected hyperparameters\n    train_xgb_lim(X,y,random_search_res_xgb.best_params_,out_dir=out_dir)\n    plot_train_distr(xgb_model,X,y,out_dir=out_dir)\n\n    #Make a dummy object that contains the params used for training\n    dummy = Dummy()\n    dummy.selected_features_diff = selected_features_diff\n    dummy.top_mean = top_mean\n    dummy.top_peaks = top_peaks\n    dummy.max_distance = max_distance\n    dummy.distance_bins = distance_bins\n    dummy.windowed_mode = windowed_mode\n\n    #Flush to pickle\n    xgboost_to_wb(random_search_res_xgb,params=dummy,outfile=os.path.join(out_dir,out_pickle))\n    \n    random_search_res_xgb = pickle.load(open(os.path.join(out_dir,out_pickle),\"rb\"))\n    \n    #Plot some of the feature importances and probs\n    fscores = xgb_model.booster().get_fscore()\n    fscores_list = sorted(list(fscores.items()),key=itemgetter(1),reverse=True)\n    selected_features_indexes = list(map(int,[f.replace(\"f\",\"\") for f,n in fscores_list]))\n    selected_features_xgboost  = [selected_features_diff[sfp] for sfp in selected_features_indexes]\n    plot_feat_imp(selected_features_indexes,selected_features_diff,X,y,out_dir=out_dir)\n    \n    return(random_search_res_xgb.best_params_,selected_features_xgboost)\n    \ndef apply_model(infile_pred,\n                infile_model,\n                infile_features,\n                threshold_prob=0.5,\n                windowed_peak_picking=False,\n                out_dir=\"res\/\",\n                top_peaks=50,\n                max_distance=275,\n                distance_bins=0.005):\n    \"\"\"\n    Make predictions to discriminate between classes of spectra using pretrained models.\n\n    Parameters\n    ----------\n    infile_pred : str\n        Filename (and dir) that contain the spectra we need to make predictions for\n    infile_model : str\n        Filename (and dir) that points to the trained XGBoost model\n    infile_features : str\n        Filename (and dir) that contains the m\/z bins (features)\n    top_peaks : int\n        The top intensity peaks to filter (in windowed mode it will return the top peaks within the window)\n    max_distance : int\n        Maximum distance in m\/z to use for features\n    windowed_peak_picking : bool\n        Flag to use windowed mode to return the top intensity peaks\n    distance_bins : float\n        Distance in m\/z between the bins\n    threshold_prob : float\n        Threshold to determine an instance belongs to class zero or one\n    out_dir : str\n        Directory to write the results to\n        \n    Returns\n    -------\n\n    \"\"\"\n    print(\" Making predictions... \")\n\n    if isinstance(infile_features, str):\n        #Read the to be used m\/z bins (features)\n        features = [f.strip() for f in open(infile_features).readlines()]\n    else:\n        features = infile_features\n\n    #Check the file extension and parse to get features\n    if infile_pred.endswith(\".mgf\"): \n        feats,feat_bins,instance_names,count_inst = read_mgf(infile_pred,\n                                                             sum_feats=False,\n                                                             feat_bins=features,\n                                                             max_dist=max_distance,\n                                                             step_size=distance_bins,\n                                                             top_peaks=top_peaks)\n    elif infile_pred.endswith(\".msp\"):\n        feats,feat_bins,instance_names,count_inst = read_msp(infile_pred,\n                                                             sum_feats=False,\n                                                             feat_bins=features,\n                                                             max_dist=max_distance,\n                                                             step_size=distance_bins,\n                                                             top_peaks=top_peaks)\n    else: return(False)\n    \n    #Load the XGBoost model\n    random_search_res_xgb = pickle.load(open(infile_model,\"rb\"))\n    \n    print(\" Formatting predictions ... \")\n    #Format the preds\n    preds = pd.DataFrame(random_search_res_xgb.predict_proba(feats),index=instance_names,columns=[\"Prob_class_0\",\"Prob_class_1\"])\n    \n    print(\" Plotting predictions ... \")\n    #Plot the probabilities\n    pd.Series(preds[\"Prob_class_1\"]).plot(kind=\"density\")\n    axes = plt.gca()\n    axes.set_xlim([0.0,1.0])\n    axes.set_ylim([0.0,1.0])\n    plt.savefig(os.path.join(out_dir,\"density_groups_zoomed.png\"), bbox_inches=\"tight\")\n    plt.close()\n    \n    #Threshold probabilities\n    #print(list(preds.index[preds[\"Prob_class_1\"] > threshold_prob]))\n    \n    print(\" Writing predictions ... \")\n    preds.to_csv(os.path.join(out_dir,\"predictions.csv\"))\n\ndef parse_argument():\n    \"\"\"\n    Read arguments from the command line\n\n    Parameters\n    ----------\n        \n    Returns\n    -------\n\n    \"\"\"\n    parser = argparse.ArgumentParser()\n    \n    parser.add_argument(\"--top_peaks\", type=int, dest=\"top_peaks\", default=100,\n                        help=\"Number of peaks to extract and consider for combinations in a spectrum\")\n    \n    parser.add_argument(\"--top_mean\", type=int, dest=\"top_mean\", default=2000,\n                        help=\"The top bins in different mean between group A and B to learn on\")\n                        \n    parser.add_argument(\"--max_distance\", type=int, dest=\"max_distance\", default=300,\n                        help=\"The maximum difference between peaks (maximum bin value)\")\n    \n    parser.add_argument(\"--n_jobs\", type=int, dest=\"n_jobs\", default=32,\n                        help=\"The maximum number of threads to spawn\")\n\n    parser.add_argument(\"--n_iter_search\", type=int, dest=\"n_iter_search\", default=20,\n                        help=\"Number of random samplings from the hyperparameter sets\")\n                            \n    parser.add_argument(\"--distance_bins\", type=float, dest=\"distance_bins\", default=0.1,\n                        help=\"Distance in m\/z of the bins\")\n    \n    parser.add_argument(\"--file_a\", type=str, dest=\"file_a\",default=\"data\/human_hcd_synthetic_native_sample.msp\", #\"NIST\/human_hcd_synthetic_native.msp\"\n                        help=\"The mgf or msp of group A\")\n    \n    parser.add_argument(\"--file_b\", type=str, dest=\"file_b\", default=\"data\/human_hcd_synthetic_oxidized_sample.msp\", #\"NIST\/human_hcd_synthetic_oxidized.msp\"\n                        help=\"The mgf or msp of group B\")\n    \n    parser.add_argument(\"--file_pred\", type=str, dest=\"file_pred\", default=\"NIST\/human_hcd_synthetic_native.msp\",\n                        help=\"The mgf or msp to make predictions for\")\n                        \n    parser.add_argument(\"--out_dir\", type=str, dest=\"out_dir\", default=\"res\/\",\n                        help=\"Directory where the results are written. WILL OVERWITE EXISTING FILES!\")\n\n    parser.add_argument(\"--out_pickle\", type=str, dest=\"out_pickle\", default=\"model.pickle\",\n                        help=\"File where the model is pickled.\")\n\n    parser.add_argument(\"--make_pred\", action=\"store_true\",\n                        help=\"Flag that can be included to indicate predictions are desired instead of training a model\")\n                        \n    parser.add_argument(\"--windowed_peak_picking\", action=\"store_true\",\n                        help=\"Flag that can be included to use windowed peak picking per 100 m\/z\")\n\n    parser.add_argument(\"--model\", type=str, dest=\"model\", default=\"res\/model.pickle\",\n                        help=\"File that refers to a model that is used for predictions\")\n    \n    parser.add_argument(\"--feats\", type=str, dest=\"feats\", default=\"res\/selected_features_diff.txt\",\n                        help=\"File that refers to the features that are used in the model\")\n\n    parser.add_argument(\"--version\", action=\"version\", version=\"%(prog)s 1.0\")\n\n    results = parser.parse_args()\n\n    return(results)\n\ndef main(arguments=None,gui_object_local=None):\n    global gui_object\n    gui_object = gui_object_local\n\n    if arguments == None:\n        #Get command line arguments\n        argu = parse_argument()\n    else:\n        argu = arguments\n\n    #Train a new model\n    if not argu.make_pred:\n        #print(os.getcwd())\n        #print(os.path.join(os.getcwd(),\"selected_features.txt\"))\n        selected_features_diff = get_min_diff(zero_f=argu.file_a,\n                                              one_f=argu.file_b,\n                                              outfile=os.path.join(os.getcwd(),\"selected_features.txt\"),\n                                              top_peaks=argu.top_peaks,\n                                              top_mean=argu.top_mean,\n                                              max_distance=argu.max_distance,\n                                              distance_bins=argu.distance_bins,\n                                              windowed_mode=argu.windowed_peak_picking)\n        # UNCOMMENT line below and comment above call to bypass initial feature selection\n        #selected_features_diff = [float(f.strip()) for f in open(\"res\/selected_features.txt\").readlines()]\n\n        random_search_params,selected_features_xgb = train_initial_classifier(zero_f=argu.file_a,\n                                                                              one_f=argu.file_b,\n                                                                              selected_features_diff=selected_features_diff,\n                                                                              top_peaks=argu.top_peaks,\n                                                                              top_mean=argu.top_mean,\n                                                                              max_distance=argu.max_distance,\n                                                                              distance_bins=argu.distance_bins,\n                                                                              windowed_mode=argu.windowed_peak_picking,\n                                                                              out_pickle=argu.out_pickle,\n                                                                              n_jobs=argu.n_jobs,\n                                                                              n_iter_search=argu.n_iter_search)\n    #Make predictions using existing trained model\n    if argu.make_pred:\n        print(\" ===================== \")\n        print(\" Starting to make predictions ... \")\n        \n        model = pickle.load(open(os.path.join(argu.model),\"rb\"))\n        try:\n            model.params_train\n            argu.selected_features_diff = model.params_train.selected_features_diff\n            argu.top_mean = model.params_train.top_mean\n            argu.top_peaks = model.params_train.top_peaks\n            argu.max_distance = model.params_train.max_distance\n            argu.distance_bins = model.params_train.distance_bins\n            argu.windowed_peak_picking = model.params_train.windowed_mode\n            print(\" ---------------------- \")\n            print(\" Loaded model settings: \")\n            print(\" Number of features selected  %s \" % (len(argu.selected_features_diff)))\n            print(\" Maximum distance  %s \" % (argu.max_distance))\n            print(\" Distance bins  %s \" % (argu.distance_bins))\n            print(\" Used windows  %s \" % (argu.windowed_peak_picking))\n            print(\" Top peak per MS2 %s\" % (argu.top_peaks))\n            print(\" ---------------------- \")\n        except:\n            # Model parameters were not saved with trained model\n            pass\n\n\n\n        apply_model(argu.file_pred,argu.model,argu.selected_features_diff,out_dir=argu.out_dir,\n                    windowed_peak_picking=argu.windowed_peak_picking,\n                    top_peaks=argu.top_peaks,\n                    max_distance=argu.max_distance,\n                    distance_bins=argu.distance_bins)\n        \n        print(\" ===================== \")\n\nif __name__ == \"__main__\":\n    main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_453","text":"# Just a test\nimport audiovisualizer\nimport numpy\nimport numpy.fft as nfft\nimport pylab\nimport scipy\nimport scipy.io as sio\n\n# The sample rate of the input matrix (Hz)\nSAMPLE_RATE=44100\n# Frequency range to display (audible is 16-16384Hz)\nDISPLAY_FREQ=(16, 2000)\n# FPS of output (Hz)\nOUT_FPS = 30\n# Size of the moving average (s)\nMV_AVG_SIZE=0.5\n\ndef bin_approx_search(lst, tg):\n    \"\"\"\n    Find the index of the element in lst which is closest to the number tg\n    \"\"\"\n    top = len(lst) - 1\n    bottom = 0\n    while top > bottom:\n        curri = (top - bottom)\/\/2 + bottom\n        if lst[curri] < tg:\n            bottom = curri\n        else:\n            top = curri\n        if top - bottom == 1:\n            if abs(lst[top] - tg) < abs(lst[bottom] - tg):\n                return top\n            else:\n                return bottom\n    return top\n\ndef plotSpectrum(y,samplerate):\n    \"\"\"\n    Plots a Single-Sided Amplitude Spectrum of y(t)\n    \"\"\"\n    n = len(y) # length of the signal\n    k = scipy.arange(n)\n    T = n\/samplerate\n    frq = audiovisualizer.movingfft.get_x_axis(samplerate, n)\n\n    Y = nfft.fft(y)\/n # fft computing and normalization\n    Y = Y[range(n\/\/2)]\n    print(Y.shape)\n\n    bottomindex = bin_approx_search(frq, DISPLAY_FREQ[0])\n    topindex = bin_approx_search(frq, DISPLAY_FREQ[1])\n\n    frq = frq[bottomindex:topindex]\n    Y = Y[bottomindex:topindex]\n    print(Y.shape)\n\n    # We want to plot frequencies in the audible range\n    \n    pylab.clf()\n    pylab.plot(frq,abs(Y),'r') # plotting the spectrum\n    pylab.xlabel('Freq (Hz)')\n    pylab.ylabel('|Y(freq)|')\n    pylab.ylim((0, 0.018))\n\naudio = sio.loadmat(\"song1.mat\")['x']\n\nframe_increment = SAMPLE_RATE \/\/ OUT_FPS\navg_len = int(MV_AVG_SIZE * SAMPLE_RATE)\nframe = 0\nfor start in range(0, audio.shape[0] - avg_len, frame_increment):\n    print(start, start+avg_len)\n    plotSpectrum(audio[start:start + avg_len, 0], SAMPLE_RATE)\n    pylab.show()\n    break\n    pylab.savefig('frame_'+str(frame).zfill(4)+'.png', bbox_inches='tight')\n    frame += 1\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_454","text":"<reponame>msmbuilder\/mdentropy\nfrom ..utils import unique_row_count\n\nfrom numpy import (array, atleast_1d, digitize, empty, floor, linspace, log2,\n                   histogramdd, hstack, ndarray, sqrt, vstack)\nfrom scipy.stats import skew\n\n__all__ = ['hist', 'symbolic', 'doanes_rule']\n\n\ndef doanes_rule(x):\n    \"\"\"Convenience function for choosing an optimal number of bins using Doane's Rule.\n\n    Parameters\n    ----------\n    x : numpy.ndarray or list of floats\n        Data to be binned.\n\n    Returns\n    -------\n    n_bins : int\n    \"\"\"\n    if not isinstance(x, ndarray):\n        x = array(x)\n\n    n = x.shape[0]\n    g1 = atleast_1d(skew(x))\n    sg1 = sqrt(6 * (n - 2) \/ ((n + 1) * (n + 3)))\n\n    return min(floor(1 + log2(n) + log2(1 + abs(g1)\/sg1)))\n\n\ndef hist(n_bins, rng, *args):\n    \"\"\"Convenience function for histogramming N-dimentional data\n\n    Parameters\n    ----------\n    n_bins : int\n        Number of bins.\n    rng : list of lists\n        List of min\/max values to bin data over.\n    args : array_like, shape = (n_samples, )\n        Data of which to histogram.\n\n    Returns\n    -------\n    bins : array_like, shape = (n_bins, )\n    \"\"\"\n    data = vstack((args)).T\n\n    if n_bins is None:\n        n_bins = doanes_rule(data)\n\n    return histogramdd(data, bins=n_bins, range=rng)[0].flatten()\n\n\ndef symbolic(n_bins, rng, *args):\n    \"\"\"Symbolic binning of data\n\n    Parameters\n    ----------\n    rng : list of lists\n        List of min\/max values for each dimention.\n    n_bins : int\n        Number of bins to use.\n    args : array_like, shape = (n_samples, )\n        Data of which to calculate entropy. Each array must have the same\n        number of samples.\n\n    Returns\n    -------\n    counts : float\n    \"\"\"\n    labels = empty(0).reshape(args[0].shape[0], 0)\n    if n_bins is None:\n        n_bins = min(map(doanes_rule, args))\n\n    for i, arg in enumerate(args):\n\n        partitions = linspace(rng[i][0], rng[i][1], n_bins + 1)\n        label = digitize(arg, partitions).reshape(-1, 1)\n\n        labels = hstack((labels, label))\n\n    return unique_row_count(labels)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_456","text":"<filename>training\/buyer_utils.py\n'''\nFunctions to evaluate buyer's fixed strategies\n'''\n\nimport math\nimport numpy as np\nimport time\nfrom scipy.optimize import minimize\n\ndef getBuyerExperience(sellers, buyer_info):\n    # get the buyer experience with sellers based on previous purchases\n    num_sellers = len(sellers)\n    num_buyers = buyer_info.count\n    cumulativeBuyerExperience = np.zeros((num_buyers, num_sellers))\n    for i in range(0, num_buyers):\n        for j in range(0, num_sellers):\n            cumulativeBuyerExperience[i][j] = sellers[j].getBuyerExperience(i)\n    return cumulativeBuyerExperience\n\ndef get_buyer_rewards(X, ys, probAll, cumulativeBuyerExperience, buyer_info):\n    # get buyer utilities\n    buyer_utilities = buyerUtilitiesCalculator(X, ys, buyer_info.V, buyer_info.a_val, probAll,\n                                                  buyer_info.count,\n                                                  cumulativeBuyerExperience, buyer_info.unfinished_task_penalty)\n\n    # get buyer penalties\n    buyer_penalties = buyerPenaltiesCalculator(X, ys, buyer_info.V, buyer_info.a_val, buyer_info.count,\n                                                  cumulativeBuyerExperience, buyer_info.unfinished_task_penalty)\n\n    return buyer_utilities, buyer_penalties\n\n\ndef getPurchases(buyer_info, cumulativeBuyerExperience, ys, probAll):\n    # get the amount of resources purchased by each device based on y\n    X = []\n    for i in range(0, buyer_info.count):\n        X_i = buyerPurchaseCalculator(cumulativeBuyerExperience[i, :], ys, buyer_info.V[i], buyer_info.a_val[i]\n                                      , probAll, buyer_info.unfinished_task_penalty)\n        X.append(X_i)\n    X = np.array(X).T\n    return X\n\n\n\n# Callback to stop optimization after a set time limit\nclass TookTooLong(Warning):\n    pass\n\n# class MinimizeStopper(object):\n#     def __init__(self, max_sec=60):\n#         self.max_sec = max_sec\n#         self.start = time.time()\n#     def __call__(self, xk=None):\n#         elapsed = time.time() - self.start\n#         if elapsed > self.max_sec:\n#             warnings.warn(\"Terminating optimization: time limit reached\",\n#                           TookTooLong)\n        # else:\n        #     # you might want to report other stuff here\n        #     print(\"Elapsed: %.3f sec\" % elapsed)\n\n# Buyer Purchase Calculator\ndef buyerPurchaseCalculator(cumulativeBuyerExperience, yAll, V_i, a_i, y_prob, consumer_penalty_coeff):\n    # get singleBuyer utility function to maximize\n    N = len(y_prob)\n\n    def singleBuyerUtilityFunction(x_i):\n        buyerUtility = 0.\n        for j in range(0, N):\n            buyerUtility += (V_i * math.log(x_i[j] - a_i + np.e) \\\n                             - x_i[j] \/ yAll[j]) * y_prob[j] \\\n                            - consumer_penalty_coeff * (cumulativeBuyerExperience[j] - x_i[j]) ** 2\n        #     buyerUtility += (V_i * math.log(x_i[j] - a_i + np.e) - (x_i[j] \/ yAll[j])) * y_prob[j]\n        # buyerUtility -= consumer_penalty_coeff*(np.sum(cumulativeBuyerExperience) - np.sum(x_i))**2\n        return -1 * buyerUtility\n\n    # solve optimization function for each buyer try for two seconds\n    x_init = cumulativeBuyerExperience\n    # x_init = np.full_like(cumulativeBuyerExperience, 100)\n    if np.random.uniform()>0.5:\n        xi_opt_sol = minimize(singleBuyerUtilityFunction, x_init, bounds=[(0, 100)] * N,options={'maxiter':1000})\n        # xi_opt_sol = minimize(singleBuyerUtilityFunction, x_init, options={'maxiter': 1000})\n        x_opt = xi_opt_sol.x\n    else:\n        x_opt = x_init*np.random.uniform(low=1,high=1.2)\n    # x_opt[x_opt < 0] = 0\n    return x_opt\n\n\n# Buyer Utilities Calculator\ndef buyerUtilitiesCalculator(X, yAll, V, a, y_prob, M, cumulativeBuyerExperience, consumer_penalty_coeff):\n    N = len(y_prob)\n    buyerUtilities = []\n    for i in range(0, M):\n        buyerUtility = 0\n        for j in range(0, N):\n            buyerUtility += (V[i] * math.log(X[j][i] - a[i] + np.e) \\\n                             - X[j][i] \/ yAll[j]) * y_prob[j]\n            # todo: Add the regularizer based on Z values\n        buyerUtilities.append(buyerUtility)\n    buyerUtilities = np.array(buyerUtilities)\n    return buyerUtilities\n\n\n# Buyer Penalties Calculator\ndef buyerPenaltiesCalculator(X, yAll, V, a, M, cumulativeBuyerExperience, consumer_penalty_coeff):\n    N = len(yAll)\n    buyerPenalties = []\n    for i in range(0, M):\n        buyerPenalty = 0\n        for j in range(0, N):\n            buyerPenalty += consumer_penalty_coeff * (cumulativeBuyerExperience[i][j] - X[j][i]) ** 2\n            # todo: Add the regularizer based on Z values\n        buyerPenalties.append(buyerPenalty)\n    buyerPenalties = np.array(buyerPenalties)\n    return buyerPenalties"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_457","text":"<filename>fitting.py\n\nimport numpy as np\nfrom scipy.linalg import sqrtm\nfrom scipy.interpolate import interp1d\nimport copy, time\nimport emcee\n\ndef ln_prior(pvals, models):\n    \"\"\"\n    Logarithm of the prior (mostly just uniform prior bounds for now).\n    \"\"\"\n    # Define priors\n    priors = {\n        'prob1mbb_Q':   (1., 100.),\n        'prob1mbb_U':   (1., 100.),\n        'dust_T':       (16., 24.),\n        'dust_beta':    (1.4, 1.8),\n        'sync_beta':    (-1.6, -0.8),\n        'ame_nupeak':   (15., 35.),\n        'gdust_beta':   (1.1, 1.8),\n        'gdust_dbeta':  (-1.8, 1.8),\n        'gdust_Td1':    (5., 30.),\n        'gdust_Td2':    (5., 30.),\n        'gdust_fI':     (0., 1.),\n        'gdust_fQ':     (-2., 2.),\n        'gdust_fU':     (-2., 2.),\n        'sigma_beta':   (1e-2, 1.),\n        'sigma_temp':   (.1, 10.),\n    }\n\n    # Make ordered list of parameter names\n    param_names = []\n    for mod in models:\n        param_names += mod.param_names\n\n    # Get a list of amplitude names\n    amp_names = []\n    for mod in models:\n        amp_names += [\"%s_%s\" % (mod.model, pol) for pol in \"IQU\"]\n\n    pnames = amp_names + param_names\n\n    # Go through priors and apply them\n    ln_prior = 0. # Set default prior value\n    for pn in priors.keys():\n    #    print 'pnames: ' + str(pnames)\n    #    print 'pn: ' + str(pn)\n        if pn not in pnames: continue\n        pmin, pmax = priors[pn] # Prior bounds\n    #    print 'pmin: ' + str(pmin) + ', pmax: ' + str(pmax)\n    #    print 'pvals: ' + str(pvals)\n        val = pvals[pnames.index(pn)] # Current value of parameter\n    #    print 'val: ' + str(val)\n        if val < pmin or val > pmax:\n            ln_prior = -np.inf\n    return ln_prior\n\ndef lnprob(pvals, data_spec, models_fit, param_spec, Ninv_sqrt):\n    \"\"\"\n    log-probability (likelihood times prior) for a set of parameter values.\n    \"\"\"\n    # Retrieve instrument\/data model and parameter info\n    nu, D_vec, Ninv, beam_mat = data_spec\n\n    # pnames should be amps_names + param_names\n    # initial_vals should be amps_vals + param_vals\n    pnames, initial_vals, parent_model = param_spec\n\n    # Apply prior\n    logpr = ln_prior(pvals, models_fit)\n    if not np.isfinite(logpr):\n        return -np.inf\n\n    F_fg, F_cmb, F = F_matrix(pvals, nu, models_fit, param_spec)\n    H = F_fg.T * Ninv * F_fg\n\n    # GLS solution for component amplitudes\n    x_mat = np.linalg.inv(F.T * beam_mat.T * Ninv * beam_mat * F) \\\n          * F.T * beam_mat.T * Ninv * D_vec # Equation A3\n\n    chi_square = (D_vec - beam_mat * F * x_mat).T * Ninv \\\n               * (D_vec - beam_mat * F * x_mat) # Equation A4\n\n    # Equation A14\n    U, Lambda, VT = np.linalg.svd(Ninv_sqrt*F_fg, full_matrices=False)\n\n    # Equation A16\n    N_eff_inv_cmb = F_cmb.T * Ninv_sqrt \\\n                  * (np.matrix(np.identity(U.shape[0])) - U*U.T) \\\n                  * Ninv_sqrt * F_cmb\n\n    # Total log posterior\n    lnprob = logpr - chi_square - 0.5*np.log(np.linalg.det(H)) \\\n                              - 0.5*np.log(np.linalg.det(N_eff_inv_cmb))\n\n    # Return log-posterior and GLS amplitudes\n    return lnprob, np.array(x_mat.T)[0]\n\n\ndef lnprob_joint(params, data_spec, models_fit, param_spec):\n    \"\"\"\n    log-probability (likelihood times prior) for a set of parameter values.\n    \"\"\"\n    # Retrieve instrument\/data model and parameter info\n    nu, D_vec, Ninv, beam_mat = data_spec\n    pnames, initial_vals, parent_model = param_spec\n    Nmod = len(models_fit)\n    Npol = 3\n\n    # Separate amplitude and spectral model parameters\n    amps = params[:Nmod*Npol]\n    pvals = params[Nmod*Npol:]\n\n    # Apply prior\n    logpr = ln_prior(params, models_fit)\n    if not np.isfinite(logpr):\n        return -np.inf\n\n    # Create new copies of model objects to work with\n    #models = [copy.deepcopy(m) for m in models_fit]\n    models = models_fit\n\n    # Set new parameter values for the copied model objects, and then get\n    # scalings as a function of freq.\/polarisation\n    pstart = 0\n    mdata = np.zeros(nu.size * Npol)\n    for i in range(len(models)):\n        m = models[i]\n\n        # Set new parameter values in the models\n        n = m.params().size\n        #m.set_params( pvals[pstart:pstart+n] )\n        mparams = pvals[pstart:pstart+n]\n        pstart += n # Increment for next model\n\n        # Calculate scaling with freq. given new parameter values\n        amp = np.outer( amps[3*i:3*(i+1)], np.ones(nu.size) ) # Npol*Nfreq array\n\n        # Apply positivity prior on I amplitudes of all components\n        #if m.model == 'ame':\n        if np.any(amp[0] < 0.):\n            return -np.inf\n\n        # Add to model prediction of data vector\n        mdata += (amp * m.scaling(nu, params=mparams)).flatten()\n\n    # Calculate chi-squared with data (assumed beam = 1)\n    mdata = np.matrix(mdata).T\n    chi_square = (D_vec - mdata).T * Ninv * (D_vec - mdata)\n\n    # Return log-posterior\n    #return logpr - 0.5 * chi_square\n    return -0.5 * chi_square\n\n\ndef F_matrix(pvals, nu, models_fit, param_spec):\n    \"\"\"\n    Foreground spectral dependence operator.\n    \"\"\"\n    pnames, initial_vals, parent_model = param_spec\n\n    # Check that the CMB component is the first component in the model list\n    if models_fit[0].model != 'cmb':\n        raise ValueError(\"The first model in the models_fit list should be a \"\n                         \"CMB() object.\")\n\n    Nband = len(nu) # No. of frequency bands\n    Npol = 3 # No. of data components (I, Q, U)\n    Ncomp = len(models_fit) # No. of sky components\n\n    F_fg = np.zeros((Npol * Nband, Npol * (Ncomp - 1)))\n    F_cmb = np.zeros((Npol * Nband, Npol))\n    F = np.zeros((Npol * Nband, Npol * Ncomp))\n\n    # Create new copies of model objects to work with\n    #models = [copy.deepcopy(m) for m in models_fit]\n    models = models_fit\n\n    # Set new parameter values for the copied model objects, and then get\n    # scalings as a function of freq.\/polarisation\n    pstart = 0; k = -1\n    for i in range(len(models)):\n        m = models[i]\n\n        # Set new parameter values in the models\n        n = m.params().size\n        #m.set_params( pvals[pstart:pstart+n] )\n        mparams = pvals[pstart:pstart+n]\n        pstart += n # Increment for next model\n        if m.model != 'cmb': k += 1 # Increment for next non-CMB model\n\n        # Calculate scaling with freq. given new parameter values\n        scal = m.scaling(nu, params=mparams)\n\n        for j in range(Npol):\n            # Fill FG or CMB -matrix with scalings, as appropriate\n            if m.model != 'cmb':\n                F_fg[j*Nband:(j+1)*Nband, k*Npol + j] = scal[j,:]\n            else:\n                F_cmb[j*Nband:(j+1)*Nband, j] = scal[j,:]\n\n    # Stack CMB and FG F-matrices together\n    F = np.hstack((F_cmb, F_fg))\n    return np.matrix(F_fg), np.matrix(F_cmb), np.matrix(F)\n\n\ndef mcmc(data_spec, models_fit, param_spec, nwalkers=50,\n         burn=500, steps=1000, sample_file=None):\n    \"\"\"\n    Run MCMC to fit model to some simulated data.\n    \"\"\"\n    # Retrieve instrument\/data model and parameter info\n    nu, D_vec, Ninv, beam_mat = data_spec\n    pnames, initial_vals, parent_model = param_spec\n\n    # Invert noise covariance matrix\n    Ninv_sqrt = np.matrix(sqrtm(Ninv))\n\n    # Get a list of model parameter names (FIXME: Ignores input pnames for now)\n    param_names = []\n    for mod in models_fit:\n        param_names += mod.param_names\n\n    # Get a list of amplitude names\n    fg_amp_names = []; cmb_amp_names = []\n    for mod in models_fit:\n        if mod.model == 'cmb':\n            cmb_amp_names += [\"%s_%s\" % (mod.model, pol) for pol in \"IQU\"]\n        else:\n            fg_amp_names += [\"%s_%s\" % (mod.model, pol) for pol in \"IQU\"]\n    pnames = cmb_amp_names + fg_amp_names + param_names\n\n    # Define starting points\n    ndim = len(initial_vals)\n    pos = [initial_vals*(1.+1e-3*np.random.randn(ndim)) for i in range(nwalkers)]\n\n    # Run emcee sampler\n    sampler = emcee.EnsembleSampler( nwalkers, ndim, lnprob,\n                           args=(data_spec, models_fit, param_spec, Ninv_sqrt) )\n    sampler.run_mcmc(pos, burn + steps)\n\n    # Recover samples of spectral parameters and amplitudes\n    param_samples = sampler.chain[:, burn:, :].reshape((-1, ndim))\n    amp_samples = np.swapaxes(np.array(sampler.blobs), 0, 1)\n    amp_samples = amp_samples[:, burn:, :].reshape((-1, amp_samples.shape[2]))\n    samples = np.concatenate((amp_samples.T, param_samples.T))\n\n    # Save chains to file\n    if sample_file is not None:\n        np.savetxt(sample_file, samples, fmt=\"%.6e\", header=\" \".join(pnames))\n\n    # Summary statistics for fitted parameters\n    params_out = np.median(param_samples, axis=0)\n\n    # Return summary statistics and samples\n    return params_out, pnames, samples\n\n\ndef joint_mcmc(data_spec, models_fit, param_spec, nwalkers=100,\n               burn=500, steps=1000, nthreads=2, sample_file=None):\n    \"\"\"\n    Run MCMC to fit model to some simulated data. Fits to all parameters, both\n    amplitudes and spectral parameters.\n    \"\"\"\n    # Retrieve instrument\/data model and parameter info\n    nu, D_vec, Ninv, beam_mat = data_spec\n    pnames, initial_vals, parent_model = param_spec\n\n    # Get a list of model parameter names (FIXME: Ignores input pnames for now)\n    param_names = []\n    for mod in models_fit:\n        param_names += mod.param_names\n\n    # Get a list of amplitude names\n    amp_names = []\n    for mod in models_fit:\n        amp_names += [\"%s_%s\" % (mod.model, pol) for pol in \"IQU\"]\n    pnames = amp_names + param_names\n\n    # Define starting points\n    ndim = len(initial_vals)\n    pos = [initial_vals*(1.+1e-3*np.random.randn(ndim)) for i in range(nwalkers)]\n\n    #print param_spec\n    # Run emcee sampler\n    sampler = emcee.EnsembleSampler( nwalkers, ndim, lnprob_joint,\n                                     args=(data_spec, models_fit, param_spec),\n                                     threads=nthreads )\n    sampler.run_mcmc(pos, burn + steps)\n\n    # Recover samples of spectral parameters and amplitudes\n    samples = sampler.chain[:, burn:, :].reshape((-1, ndim))\n\n    # Recover log(posterior)\n    logp = sampler.lnprobability[:,burn:].reshape((-1,))\n\n    # Save chains to file\n    if sample_file is not None:\n        np.savetxt(sample_file, samples, fmt=\"%.6e\", header=\" \".join(pnames))\n\n    # Return summary statistics and samples\n    return pnames, samples.T, logp\n\n\ndef noise_model_old(fname=\"data\/CMBpol_extended_noise.dat\", scale=1.):\n    \"\"\"\n    Load noise model from file and create interpolation function as a fn of\n    frequency. This is the noise per pixel, for some arbitrary pixel size.\n    \"\"\"\n    # Load from file\n    nu, sigma = np.genfromtxt(fname).T\n\n    # Extrapolate at the ends of the frequency range\n    if nu[0] > 1.:\n        sigma0 = sigma[0] \\\n               + (sigma[1] - sigma[0]) \/ (nu[1] - nu[0]) * (1. - nu[0])\n        sigman = sigma[-1] \\\n               + (sigma[-1] - sigma[-2]) \/ (nu[-1] - nu[-2]) * (1e3 - nu[-1])\n        if sigma0 < 0.: sigma0 = sigma[0]\n        if sigman < 0.: sigman = sigma[-1]\n\n        # Add to end of range\n        nu = np.concatenate(([1.,], nu, [1e3,]))\n        sigma = np.concatenate(([sigma0,], sigma, [sigman,]))\n\n    # Rescale by constant overall factor\n    sigma *= scale\n\n    # Construct interpolation function\n    return interp1d(nu, sigma, kind='linear', bounds_error=False)\n\n\ndef noise_model(fname=\"data\/noise_coreplus_extended.dat\", scale=1.):\n    \"\"\"\n    Load noise model from file and create interpolation function as a fn of\n    frequency. This is the noise per pixel, for some arbitrary pixel size.\n    \"\"\"\n    # Load from file\n    dat = np.genfromtxt(fname).T\n    if dat.shape[0] == 3:\n        nu, fwhm, sigma = dat\n    elif dat.shape[0] == 2:\n        nu, sigma = dat\n    else:\n        raise ValueError(\"Unexpected number of columns in noise file.\")\n\n    # Rescale by constant overall factor\n    sigma *= scale\n\n    # Work in log-space\n    sigma = np.log(sigma)\n\n    # Extrapolate at the ends of the frequency range\n    if nu[0] > 1.:\n        sigma0 = sigma[0] \\\n               + (sigma[1] - sigma[0]) \/ (nu[1] - nu[0]) * (1. - nu[0])\n        sigman = sigma[-1] \\\n               + (sigma[-1] - sigma[-2]) \/ (nu[-1] - nu[-2]) * (1e3 - nu[-1])\n        if sigma0 < 0.: sigma0 = sigma[0]\n        if sigman < 0.: sigman = sigma[-1]\n\n        # Add to end of range\n        nu = np.concatenate(([1.,], nu, [1e3,]))\n        sigma = np.concatenate(([sigma0,], sigma, [sigman,]))\n\n    # Construct interpolation function\n    _interp = interp1d(nu, sigma, kind='linear', bounds_error=False)\n    return lambda freq: np.exp(_interp(freq))\n\n\ndef generate_data(nu, fsigma_T, fsigma_P, components,\n                  noise_file=\"data\/core_plus_extended_noise.dat\",\n                  idx_px = 0):\n    \"\"\"\n    Create a mock data vector from a given set of models, including adding a\n    noise realization.\n    \"\"\"\n    # Loop over components that were included in the data model and calculate\n    # the signal at a given frequency (should be in uK_CMB)\n    signal = 0\n    cmb_signal = 0\n    # Disabled for the case of the allsky\n    if idx_px == 0:\n        pass #print( \"(FITTING.PY) Parameters in the input model:\" )\n    for comp in components:\n        if idx_px == 0:\n            pass #print comp.param_names\n\n        # Add this component to total signal\n        signal += np.atleast_2d(comp.amps()).T * comp.scaling(nu)\n\n        # Store CMB signal separately\n        if comp.model == 'cmb':\n            cmb_signal = np.atleast_2d(comp.amps()).T * comp.scaling(nu)\n\n    # Construct data vector\n    D_vec = np.matrix(signal.flatten()).T\n\n    # Noise rms as a function of frequency\n    sigma_interp = noise_model(fname=noise_file, scale=1.)\n    sigma_nu = sigma_interp(nu \/ 1e9)\n    fsigma = np.zeros(3*len(nu))\n    fsigma[0:len(nu)] = fsigma_T * sigma_nu # Stokes I\n    fsigma[len(nu):2*len(nu)] = fsigma_P * sigma_nu # Stokes Q\n    fsigma[2*len(nu):] = fsigma_P * sigma_nu # Stokes U\n\n    #noise_mat = np.matrix( np.diagflat(cmb_signal.flatten() * fsigma) )\n    #noise_mat = np.matrix( np.diagflat(fsigma) )\n    #Ninv = np.linalg.inv(noise_mat)\n\n    # Inverse noise covariance\n    noise_mat = np.identity(fsigma.size) * fsigma\n    Ninv = np.identity(fsigma.size) \/ fsigma**2.\n    n_vec = (np.matrix(np.random.randn(D_vec.size)) * noise_mat).T\n\n    # Add noise to generated data\n    D_vec += n_vec\n    return D_vec, Ninv\n\n\ndef model_test(nu, D_vec, Ninv, models_fit, initial_vals=None, burn=500,\n               steps=1000, cmb_amp_in=None, sample_file=None):\n    \"\"\"\n    Generate simulated data given an input model, and perform MCMC fit using\n    another model.\n    \"\"\"\n    # Collect together data and noise\/instrument model\n    Ninv_sqrt = np.matrix(sqrtm(Ninv)) # Invert noise covariance matrix\n    beam_mat = np.identity(3*len(nu)) # Beam model\n    data_spec = (nu, D_vec, Ninv, beam_mat)\n\n    # Loop over specified component models and set up MCMC parameters for them\n    pnames = []; pvals = []; parent_model = []\n    for mod in models_fit:\n        # Get parameter names, initial parameter values, and component ID\n        pn = mod.param_names\n        pv = mod.params()\n\n        # Loop through parameters from this component\n        for i in range(len(pn)):\n            pnames.append( \"%s.%s\" % (mod.name, pn[i]) )\n            pvals.append( pv[i] )\n            parent_model.append( mod )\n\n    # Use 'guess' as the initial point for the MCMC if specified\n    if initial_vals is None: initial_vals = pvals\n\n    # Collect names, initial values, and parent components for the parameters\n    param_spec = (pnames, initial_vals, parent_model)\n\n    # Run MCMC sampler on this model\n    t0 = time.time()\n    params_out, pnames, samples = mcmc(data_spec, models_fit, param_spec,\n                                       burn=burn, steps=steps,\n                                       sample_file=sample_file)\n    print \"MCMC run in %d sec.\" % (time.time() - t0)\n\n    # Estimate error on recovered CMB amplitudes\n    # FIXME: Why estimate error using F_matrix on median!?\n    F_fg, F_cmb, F = F_matrix(params_out, nu, models_fit, param_spec)\n\n    H = F_fg.T * Ninv * F_fg\n\n    # Equation A3\n    x_mat = np.linalg.inv(F.T * beam_mat.T * Ninv * beam_mat * F) \\\n          * F.T * beam_mat.T * Ninv * D_vec\n\n    # Equation A14\n    U, Lambda, VT = np.linalg.svd(Ninv_sqrt*F_fg, full_matrices=False)\n\n    # Equation A16\n    N_eff_inv_cmb = F_cmb.T * Ninv_sqrt \\\n                  * (np.matrix(np.identity(U.shape[0])) - U*U.T) \\\n                  * Ninv_sqrt * F_cmb\n\n    N_eff_cmb = np.linalg.inv(N_eff_inv_cmb)\n    cmb_noise = np.array([N_eff_cmb[0,0], N_eff_cmb[1,1], N_eff_cmb[2,2]])\n\n    gls_cmb = x_mat[0:3,0]\n    cmb_chisq = (np.matrix(cmb_amp_in).T - gls_cmb).T * N_eff_inv_cmb \\\n              * (np.matrix(cmb_amp_in).T - gls_cmb)\n\n    return gls_cmb, cmb_chisq, cmb_noise\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_458","text":"<reponame>kmckiern\/scripts\n#!\/bin\/env python\n\n\"\"\"\nexample usage:\n        python pore_occupancy.py --trj whereever\/cnv.xtc --top 4xdk.pdb --out sf_h2o_p9761_17_14.dat\n\nnote: use python version >= 3.4\n\"\"\"\n\nimport argparse\nimport mdtraj\nimport numpy as np\nimport pandas as pd\nfrom scipy.stats import multivariate_normal\nimport IPython\n\nparser = argparse.ArgumentParser(description='get water and ion occupancy of trek sf')\nparser.add_argument('--tf', type=str, help='trajectory file')\nparser.add_argument('--gaussian', action='store_true', help='gaussian counting', default=False)\nparser.add_argument('--histogram', action='store_true', help='histogram counting', default=False)\nparser.add_argument('--start', type=int, help='start bin for sum window')\nparser.add_argument('--end', type=int, help='end bin for sum window')\nargs = parser.parse_args()\n\n# parameters obtained from visual inspection in vmd ... could be better\n# help to define the boundary of the selectivity filter\ncyl_radius = .55\nz_slice = 0.2\ncyl_length = 1.0\nnum_bins = round(cyl_length\/z_slice)\nfull_l = 2.0*cyl_length\nnb = 2 * num_bins\n\nres_indxs = [101, 210, 362, 471]\n\n# via: \n# http:\/\/stackoverflow.com\/questions\/25720600\/generating-3d-gaussian-distribution-in-python\ndef numerical_gaussian(xmin, xmax, ymin, ymax, mu, sigma):\n    # generate numerical grid\n    x, y = np.mgrid[xmin:xmax, ymin:ymax]\n    xy = np.column_stack([x.flat, y.flat])\n    # get gaussian values over grid\n    covariance = np.diag(sigma**2)\n    gz = multivariate_normal.pdf(xy, mean=mu, cov=covariance)\n    gz = g.reshape(x.shape)\n    return gz\n    \ndef relevant_indices(trj):\n    # CA of each GLY located centerally to each selectivity filter strand\n    # +2 is top, -2 is bottom of strand\n    for i in [-3, -2, -1, 1, 2, 3]:\n        for j in range(4):\n            res_indxs.append(res_indxs[j]+i)\n    atom_indxs = []\n    for ref in res_indxs:\n        atom_indxs += [atom.index for atom in trj.top.atoms if ((atom.residue.resSeq == ref) and (atom.name == 'CA'))]\n    ri = np.array(atom_indxs)\n    wi = [atom.index for atom in trj.topology.atoms if (atom.residue.is_water and (atom.element.symbol == 'O'))]\n    ki = np.array([i.index for i in trj.top.atoms_by_name('K+')])\n    return ri, wi, ki\n\ndef sf_bc(traj, ri):\n    # filter by z\n    ri_qz = traj.xyz[:, ri, -1]\n    z_cent = np.average(ri_qz, axis=1)\n    z_min = z_cent - cyl_length\n    z_max = z_cent + cyl_length\n    # filter by xy\n    ri_qxy = traj.xyz[:, ri, :2]\n    xy_cent = np.average(ri_qxy, axis=1)\n    return z_min, z_max, xy_cent\n\ndef discrete_bins(traj, wi, ki, z_min, z_max, xy_cent):\n    nf = len(traj)\n    # time series of bin by frame, n_h2o, n_k\n    time_series = np.zeros([nb, nf, 2])\n\n    z_lbls = []\n    for ndx, atom_var in enumerate([wi, ki]):\n        # label above (1), within (0), or below (-1) sf wrt z\n        zs = traj.xyz[:, atom_var, -1]\n        z_scale = (zs.T - z_min).T\n        z_scale[(z_scale >= 0.0) & (z_scale <= full_l)] = 0\n        z_scale[z_scale < 0.0] = -1\n        z_scale[z_scale > full_l] = 1\n        z_lbls.append(z_scale)\n    \n        # label if within radius of sf (0), or outside (1)\n        xys = traj.xyz[:,atom_var,:2]\n        sx_scale = (xys[:,:,0].T - xy_cent[:,0]).T\n        sy_scale = (xys[:,:,1].T - xy_cent[:,1]).T\n        moduli = sx_scale**2 + sy_scale**2\n        moduli[moduli <= cyl_radius] = 0\n        moduli[moduli > cyl_radius] = 1\n    \n        for frame in range(nf):\n            z_good = np.where(z_scale[frame]==0)[0]\n            xy_good = np.where(moduli[frame]==0)[0]\n            in_sf = np.array(list(set(z_good).intersection(xy_good)))\n    \n            final_z = [traj.xyz[frame, atom_var[i], -1] for i in in_sf]\n\n            # histogram the results\n            tval, tbin = np.histogram(final_z, bins=nb, range=(z_min[frame], z_max[frame]))\n            time_series[:, frame, ndx] = tval\n\n    return time_series, z_lbls\n\n# if state = end = None, full matrix will be summed\ndef sum_bins(start, end, timeseries):\n     totaled = np.sum(timeseries[start:end], axis=0)\n     return totaled\n\n# tsave\ndef write_bins(of, time_series, out_pref):\n    if len(time_series.shape) == 3:\n        for ndx, bin_vals in enumerate(time_series):\n            np.save(out_pref + str(ndx) + '\/' + of, bin_vals)\n    else:\n        np.save(out_pref + '_' + of, time_series)\n    \ndef main():\n    trj_data = open(args.tf).readlines() \n    for t_ndx, trjd in enumerate(trj_data):\n        # read, load, align\n        t, top = trjd.split()\n        label = t.strip().split('\/')[-1].split('.')[0]\n        traj = mdtraj.load(t, top=top)\n        pi = traj.top.select('protein')\n        traj = traj.superpose(traj, atom_indices=pi)\n        x = traj[0]\n\n        ri, wi, ki = relevant_indices(x)\n        # get ions and water in the selectivity filter\n        if args.gaussian:\n            # fit 10 gaussians to SF \n            gaussians = fit_gaussians()\n            # bin gaussian counts\n            bin_timeseries, zs = gaussian_bins(*gaussians)\n\n        if args.histogram:\n            # get trj info\n            z_min, z_max, xy_cent = sf_bc(traj, ri)\n            # histogram data\n            bin_timeseries, zs = discrete_bins(traj, wi, ki, z_min, z_max, xy_cent)\n\n        # record bin data\n        for ndx, i in enumerate(bin_timeseries):\n            if ndx == 0:\n                write_bins(label, zs[0], 'atom_resolved_bins\/water_')\n            if ndx == 1:\n                write_bins(label, zs[1], 'atom_resolved_bins\/k_')\n        write_bins(label, bin_timeseries, 'bins\/b')\n        # sum over bins for feature vector of SF occupancy\n        first = args.start\n        last = args.end\n        bin_window = sum_bins(first, last, bin_timeseries)\n        write_bins(label, bin_window, 'bins\/summed\/w_' + str(first) + '_' + str(last))\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_459","text":"<filename>modules\/spectrograph_optics.py\n#!\/usr\/bin\/env python\n# vim: set fileencoding=utf-8 ts=4 sts=4 sw=4 et tw=80 :\n#\n# Routines related to spectrograph optical properties and calculations.\n#\n# <NAME>\n# Created:       2018-12-29\n# Last modified: 2019-03-30\n#--------------------------------------------------------------------------\n#**************************************************************************\n#--------------------------------------------------------------------------\n\n## Current version:\n__version__ = \"0.2.0\"\n\n## Python version-agnostic module reloading:\n#try:\n#    reload                              # Python 2.7\n#except NameError:\n#    try:\n#        from importlib import reload    # Python 3.4+\n#    except ImportError:\n#        from imp import reload          # Python 3.0 - 3.3\n\n## Modules:\nimport os\nimport sys\nimport time\nimport numpy as np\n#from numpy.lib.recfunctions import append_fields\n#import datetime as dt\n#from dateutil import parser as dtp\n#import scipy.linalg as sla\n#import scipy.signal as ssig\n#import scipy.ndimage as ndi\nimport scipy.optimize as opti\n#import scipy.interpolate as stp\n#import scipy.spatial.distance as ssd\nfrom functools import partial\n#from collections import OrderedDict\n#import multiprocessing as mp\n#np.set_printoptions(suppress=True, linewidth=160)\n#import pandas as pd\n#import statsmodels.api as sm\n#import statsmodels.formula.api as smf\n#from statsmodels.regression.quantile_regression import QuantReg\n#import theil_sen as ts\n#import window_filter as wf\n#import itertools as itt\n\n## Glass indexes of refraction:\nfrom glass import Glass\n#import glass\n#reload(glass)\n\n###--------------------------------------------------------------------------##\n### Calculating index of refraction for several glass types:\n#class Glass(object):\n#\n#    def __init__(self, glasstype):\n#        self._bcoeffs = {\n#            'SiO2':np.array([0.67071081e0, 0.433322857e0, 0.877379057e0]),\n#            'LLF1':np.array([1.21640125e0, 1.33664540e-1, 8.83399468e-1]),\n#            'PBM2':np.array([1.39446503e0, 1.59230985e-1, 2.45470216e-1]),\n#             'LF5':np.array([1.28035628e0, 1.6350597e-1,  8.93930112e-1]), }\n#        self._ccoeffs = {\n#            'SiO2':np.array([0.00449192312e0, 0.0132812976e0, 95.8899878e0]),\n#            'LLF1':np.array([8.57807248e-3,   4.20143003e-2,   1.07593060e+2]),\n#            'PBM2':np.array([1.10571872e-2,   5.07194882e-2,   3.14440142e1]),\n#             'LF5':np.array([9.29854416e-3,   4.49135769e-2,   1.10493685e2]), }\n#        if self._unknown_glass(glasstype):\n#            raise\n#        self._gtype = glasstype\n#        self._coeffs = zip(self._bcoeffs[self._gtype],\n#                           self._ccoeffs[self._gtype])\n#        return\n#\n#    def _unknown_glass(self, glasstype):\n#        if not glasstype in self._bcoeffs.keys():\n#            sys.stderr.write(\"Unknown glass type: %s\\n\" % glasstype)\n#            return True\n#        else:\n#            return False\n#\n#    # Squared index of refraction for specified wavelengths:\n#    def refraction_index_squared(self, wlen_um):\n#        lam_um_sq = wlen_um**2\n#        n_squared = np.ones_like(wlen_um, dtype='float')\n#        for bb,cc in self._coeffs:\n#            n_squared += (lam_um_sq * bb) \/ (lam_um_sq - cc)\n#        return n_squared\n#\n#    def refraction_index(self, wlen_um):\n#        return np.sqrt(self.refraction_index_squared(wlen_um))\n#    \n#    def glass_dn_dlambda_easy(self, wlen_um, glasstype, epsfrac=1e-5):\n#        #if self._unknown_glass(glasstype):\n#        #    raise\n#\n#        wlen_lower = wlen_um * (1.0 - epsfrac)\n#        wlen_upper = wlen_um * (1.0 + epsfrac)\n#\n#        nn_lower = self.refraction_index(wlen_lower) #, glasstype)\n#        nn_upper = self.refraction_index(wlen_upper) #, glasstype)\n#\n#        return (nn_upper - nn_lower) \/ (wlen_upper - wlen_lower)\n\n##--------------------------------------------------------------------------##\n##--------------------------------------------------------------------------##\n## Prism deflection:\n#def prism_deflection_n(incid_r, apex_r, n):\n#    ptemp = np.sqrt(n**2 - np.sin(incid_r)**2) * np.sin(apex_r) \\\n#                - np.cos(apex_r) * np.sin(incid_r)\n#    return incid_r - apex_r + np.arcsin(ptemp)\n\n#def prism_deflection_glass_wl(incid_r, apex_r, gtype, wlen):\n\n#def wiki_prism_deflection_n(i, A, n):\n#    return i - A + np.arcsin(n * np.sin(A - np.arcsin(np.sin(i) \/ n)))\n\n##--------------------------------------------------------------------------##\n## Prism object to calculate deflections for the specified material and shape:\nclass Prism(object):\n\n    def __init__(self, glasstype, apex_deg, n_air=1.0):\n        #self._apex_deg = apex_deg\n        #self._apex_rad = np.radians(apex_deg)\n        self._material = Glass(glasstype)\n        self.set_apex_deg(apex_deg)\n        self.set_n_air(n_air)    # index of refraction of air in spectrograph\n        return\n\n    # -------------------------------------\n    # Getters and setters:\n    def get_apex_rad(self):\n        return self._apex_rad\n\n    def get_apex_deg(self):\n        return self._apex_deg\n\n    def set_apex_deg(self, apex_deg):\n        self._apex_deg = apex_deg\n        self._apex_rad = np.radians(apex_deg)\n        return\n\n    def set_n_air(self, index_refr):\n        self._n_air = index_refr\n        return\n\n    # -------------------------------------\n\n    @staticmethod\n    def _wiki_deflection_rad_nr(i, A, nr):\n        \"\"\"Deflection angle using formula from Wikipedia (which seems\n        to be identical to others used here. Inputs are:\n        i  -- incidence angle (RADIANS)\n        A  -- prism apex angle (RADIANS)\n        nr -- index of refraction RATIO at desired wavelength(s): \n                    n_glass \/ n_air\n        \"\"\"\n        return i - A + np.arcsin(nr * np.sin(A - np.arcsin(np.sin(i) \/ nr)))\n\n    def deflection_rad_nr(self, incidence_r, nr):\n        \"\"\"Deflection angle as a function of incidence angle and \n        index of refraction RATIO (n_glass \/ n_air).\"\"\"\n        return self._wiki_deflection_rad_nr(incidence_r, self._apex_rad, nr)\n\n    def deflection_rad_nr2(self, incidence_r, nr2):\n        \"\"\"Calculate deflection angle from incidence and SQUARED index of\n        refraction RATIO (glass \/ air). Units of RADIANS used throughout.\"\"\"\n        ptemp = np.sqrt(nr2 - np.sin(incidence_r)**2) * np.sin(self._apex_rad) \\\n                - np.cos(self._apex_rad) * np.sin(incidence_r)\n        return incidence_r - self._apex_rad + np.arcsin(ptemp)\n\n    def deflection_rad_wl(self, incidence_r, wavelength_um):\n        \"\"\"Calculate deflection angle given incidence angle and wavelength\n        in microns. Units of RADIANS used throughout.\"\"\"\n        n2_glass = self._material.refraction_index_squared(wavelength_um)\n        n2_air   = self._n_air**2\n        return self.deflection_rad_nr2(incidence_r, n2_glass\/n2_air)\n        #ptemp = np.sqrt(n2 - np.sin(incidence_r)**2) * np.sin(self._apex_rad) \\\n        #        - np.cos(self._apex_rad) * np.sin(incidence_r)\n        #return incidence_r - self._apex_rad + np.arcsin(ptemp)\n\n    def deflection_deg_wl(self, incidence_d, wavelength_um):\n        \"\"\"Calculate deflection angle given incidence angle and wavelength\n        in microns. Units of RADIANS used throughout.\"\"\"\n        incidence_r = np.radians(incidence_deg)\n        return np.degrees(self.deflection_rad_wl(incidence_r, wavelength_um))\n\n\n##--------------------------------------------------------------------------##\n## Notes on notation, relations, identities, etc.:\n\n# theta_B  --> blaze angle\n# lambda_B --> blaze wavelength\n# theta    --> facet illumination angle\n# alpha    --> angle of incidence\n# beta     --> angle of diffraction\n# gamma    --> angle of incidence relative to facet normal SPECIFICALLY\n#                   in the plane that is parallel to grooves\n\n# Related by:\n# alpha = theta_B + theta\n# beta  = theta_B - theta\n\n# Note that:\n# * theta is SMALL in Littrow configuration, alpha ~= beta\n\n## Grating methods implemented:\nclass GratingTools(object):\n\n    #groove_spacing_units = {'mm':1.0, 'um':1e3, 'nm':1e6}\n\n    def __init__(self, gratio=None, lines_per_mm=None):\n        # Placeholders:\n        self._blaze_angle_rad = 0.0\n        self._g_spacing_units = {'mm':1.0, 'um':1e3, 'nm':1e6}\n        self._groove_spacing = {x:0.0 for x in self._g_spacing_units.keys()}\n\n        # Handle useful inputs:\n        if gratio:\n            self._blaze_angle_rad = self._calc_blaze_angle(gratio)\n        if lines_per_mm:\n            for kk,mult in self._g_spacing_units.items():\n                self._groove_spacing[kk] = mult \/ lines_per_mm\n\n        return\n\n    # --------------------------------------\n    # Blaze angle and wavelength:\n\n    @staticmethod\n    def _calc_blaze_angle(ratio):\n        \"\"\"For R4 grating, use ratio = 4.  Blaze angle returns in RADIANS.\"\"\"\n        return np.arctan(ratio)\n\n    @staticmethod\n    def _calc_blaze_wavelength(spec_orders, groove_spacing,\n            theta_B_rad, facet_rad, gamma_rad):\n        \"\"\"\n        Compute blaze wavelength for an array of order numbers.\n        NOTE: wavelength computed in same units as groove spacing.\n        \"\"\"\n        ord_vec = np.atleast_1d(spec_orders)\n        if not np.all(ord_vec == np.int_(ord_vec)):\n            sys.stderr.write(\"Error: non-integer spec_orders provided!\\n\")\n            return np.nan * spec_orders\n\n        ang_tmp = np.sin(theta_B_rad) * np.cos(facet_rad) * np.cos(gamma_rad)\n        return 2.0 * groove_spacing * ang_tmp \/ np.float_(spec_orders)\n\n    def get_blaze_wavelengths(self, spec_orders, facet_rad=0.0, gamma_rad=0.0,\n            units='nm'):\n        return self._calc_blaze_wavelength(spec_orders,\n                self._groove_spacing[units], self._blaze_angle_rad, \n                facet_rad=facet_rad, gamma_rad=gamma_rad)\n\n    @staticmethod\n    def _calc_line_tilt_ctr(blaze_rad, gamma_rad):\n        \"\"\"Calculate line tilt at order center (at blaze wavelength).\n        Formulae from Barnes (2004) thesis, page 11:\n        tan(φ) = (sin(α) + sin(β)) \/ cos(β) * (sin(γ) \/ cos(γ))\n               = λ * dβ\/dλ * tan(γ)\n        tan(φ) = 2 * tan(θ_B) * tan(γ)      # at blaze wavelength λ_B\n        \"\"\"\n        return np.arctan(2.0 * np.tan(blaze_rad) * np.tan(gamma_rad))\n\n    @staticmethod\n    def _calc_line_tilt_any(alpha_rad, beta_rad, gamma_rad):\n        \"\"\"Calculate line tilt at order center (at blaze wavelength).\n        Formulae from Barnes (2004) thesis, page 11:\n        tan(φ) = (sin(α) + sin(β)) \/ cos(β) * (sin(γ) \/ cos(γ))\n               = λ * dβ\/dλ * tan(γ)\n        tan(φ) = 2 * tan(θ_B) * tan(γ)      # at blaze wavelength λ_B\n        \"\"\"\n        numer = (np.sin(alpha_rad) + np.sin(beta_rad)) * np.sin(gamma_rad)\n        denom = np.cos(beta_rad) * np.cos(gamma_rad)\n        return np.arctan(numer \/ denom)\n\n    @staticmethod\n    def _calc_order_FSR(wlen_cen, spec_orders):\n        return wlen_cen \/ spec_orders\n    \n    @staticmethod\n    def _calc_order_width(wlen_cen, groove_spacing, \n            theta_B_rad, facet_rad, gamma_rad):\n        \"\"\"\n        Compute angular span of the order (free spectral range) with central\n        wavelength wlen_cen. \n        \n        NOTES: \n        * groove_spacing and wlen_cen need same units for correct result!\n        * diff_angle_rad should correspond to central wavelength (wlen_cen)\n        * wlen_cen supports numpy arrays\n        \"\"\"\n        diff_angle_rad = theta_B_rad - facet_rad\n        cos_diff_gamma = np.cos(diff_angle_rad) * np.cos(gamma_rad)\n        return wlen_cen \/ (groove_spacing * cos_diff_gamma)\n\n    def get_order_params(self, spec_orders, facet_rad=0.0, gamma_rad=0.0,\n            units='nm'):\n        \"\"\"\n        Computes central (blaze) wavelength and angular extent of specified\n        orders using chosen geometry\/angles.\n\n        Outputs:\n        central_wlen -- corresponding central wavelengths in requested units\n        order_FSR    -- order free spectral ranges (units of central_wlen)\n        order_angwid -- order angular width (RADIANS)\n        \"\"\"\n        use_spacing = self._groove_spacing[units]\n        central_wlen = self._calc_blaze_wavelength(spec_orders, use_spacing,\n                self._blaze_angle_rad, facet_rad, gamma_rad)\n        order_FSR = self._calc_order_FSR(central_wlen, spec_orders)\n        order_angwid = self._calc_order_width(central_wlen, use_spacing,\n                self._blaze_angle_rad, facet_rad, gamma_rad)\n        return (central_wlen, order_FSR, order_angwid)\n\n\n##--------------------------------------------------------------------------##\n##--------------------------------------------------------------------------##\n## Grating class (to be overloaded for double pass:\n\n##--------------------------------------------------------------------------##\n##--------------------------------------------------------------------------##\n## More sophisticated grating+prism class (closer to real design):\nclass DoublePassPrismGratingPrism(object):\n\n    def __init__(self, config={}):\n        # PARAMETERS LIST:\n        # 0. coordinate system:\n        #       * x-axis points \"right\" towards input fiber (grating at -X).\n        #       * y-axis points \"ahead\" from camera to grating (optical axis)\n        #       * z-axis points \"up\" towards sky from bench surface\n        # 1. prism:\n        #       * glass type\n        #       * apex angle (degrees)\n        #\n        # 2. grating:\n        #       * blaze ratio (i.e., R4)\n        #       * groove spacing in lines\/mm\n        #\n        # 3. layout:\n        #       * angle of initial beam w.r.t. optical axis (assume 0?)\n        #       * rotation of prism apex w.r.t. optical axis. Let 0 degrees\n        #           represent apex perpendicular to optical axis.\n        #       * direction to grating w.r.t. optical axis. This is really\n        #           the prism deflection angle that \"points\" to the grating\n        #       * alpha or sine(alpha), tilt of grating w.r.t. optical bench.\n        #           --> could also be expressed as facet angle\n        #       * rotation of grating w.r.t. optical bench normal. This is\n        #           effectively the nominal gamma angle of the ray pointing\n        #           directly at the grating. EQUIVALENTLY can use orientation\n        #           of grating on optical bench (same units as prism base)\n\n        # For prism apex 'perpendicular' to optical axis, incidence ~ apex\/2\n        self.prism_glass    = config.get('prism_glass', \"PBM2\")\n        self.apex_angle_deg = config.get('apex_angle_deg', 55.0)\n\n        # How far prism is \"turned\" w.r.t. main optical axis (def from CAD):\n        self.prism_turn_deg = config.get('prism_turn_deg', 23.507)\n\n        # Turn of incident beam (from fiber\/collimator) \n        # w.r.t. main optical axis (positive angles towards grating):\n        # MAY VARY WITH WAVELENGTH???\n        self.input_turn_deg = config.get('input_turn_deg', 2.0)\n\n        # Allow non-unity index of refraction for air:\n        self.air_index_refr = config.get('air_index_refr', 1.0)\n\n        # Front and rear prism face orientations w.r.t. z-axis:\n        self.prism_face1_deg = self.prism_turn_deg + 0.5 * self.apex_angle_deg\n        self.prism_face2_deg = self.prism_turn_deg - 0.5 * self.apex_angle_deg\n\n        # Angle of incidence of input beam w.r.t. prism face1 normal:\n        self.prism_front_incid_deg = self.prism_face1_deg - self.input_turn_deg\n\n        # Create prism object with given settings:\n        self.pr_obj = Prism(self.prism_glass, self.apex_angle_deg)\n        self.pr_obj.set_n_air(self.air_index_refr)\n\n        # ---------------------------------------------------\n\n        # Grating ruling in lines \/ millimeter:\n        self.grating_ruling_lmm = config.get('grating_ruling_lmm', 41.59)\n        self.grating_spacing_um = 1e3 \/ self.grating_ruling_lmm\n\n        # Grating face angle w.r.t. optical axis (turn about bench normal):\n        self.grating_turn_deg = config.get('grating_turn_deg', 44.827)\n\n        # Grating face tilt w.r.t. optical bench:\n        self.grating_tilt_deg = config.get('grating_tilt_deg', 13.786)\n\n        # Derived quantities:\n        self.input_turn_rad   = np.radians(self.input_turn_deg)\n        self.grating_turn_rad = np.radians(self.grating_turn_deg)\n        self.grating_tilt_rad = np.radians(self.grating_tilt_deg)\n\n        self.alpha_angle_rad  = np.radians(90.0 - self.grating_tilt_deg)\n        self.blaze_angle_rad  = config.get('blaze_angle_rad', np.arctan(4.))\n        self.facet_angle_rad  = self.alpha_angle_rad - self.blaze_angle_rad\n\n        self.fixed_geometry   = 2.0 * self.grating_spacing_um \\\n                * np.cos(self.facet_angle_rad) * np.sin(self.blaze_angle_rad)\n\n        ## deal with angle changes between prism\/grating for second prism pass:\n        #pass1_out_heading = self.input_turn_deg + np.degrees(deflect_r)\n        #gamma_eff_grating = pass1_out_heading - self.grating_turn_rad\n        #pass1_out_incid_d = pass1_out_heading - self.prism_face2_deg    # emergent\n        #pass2_new_incid_d = pass1_out_incid_d - 2.0 * gamma_eff_grating\n\n        # Lastly include some distances:\n        self.coll_focallen_mm = config.get('coll_focallen_mm', 380.0)\n        #self.coll_focallen_mm = 375.0\n        #self.prism_grating_mm = 284.0       # approximately\n        #self.prism_grating_mm = 275.0       # approximately\n        #self.prism_grating_mm = 250.0       # approximately\n        self.prism_grating_mm = config.get('prism_grating_mm', 100.0)\n        self.lens_compression = config.get('lens_compression',   2.0)\n        return\n\n    # ---------------------------------------------------------\n    # Joint prism+grating central wavelength and deflection:\n    def _prism_pass1_deflection(self, wavelength_um):\n        \"\"\"\n        Calculate the deflection angle and new direction of travel for the\n        specified wavelength after first pass through prism (using configured\n        prism and layout). Assumes all rays incident on prism are parallel.\n        Output angles are in RADIANS.\n        \"\"\"\n        incid_1_r = np.radians(self.prism_front_incid_deg)\n        deflect_r = self.pr_obj.deflection_rad_wl(incid_1_r, wavelength_um)\n        return deflect_r\n\n    def _deflection_gamma(self, wavelength_um):\n        \"\"\"\n        Calculate the effective gamma angle at the grating for the specified\n        wavelength using configured prism and layout. Assumes all rays\n        incident on prism are parallel. Output angle in RADIANS.\n        \"\"\"\n        deflect_r = self._prism_pass1_deflection(wavelength_um)\n        #incid_1_r = np.radians(self.prism_front_incid_deg)\n        #deflect_r = self.pr_obj.deflection_rad_wl(incid_1_r, wavelength_um)\n        #heading_r = self.input_turn_deg + deflect_r     # outbound direction\n        return self.input_turn_rad + deflect_r - self.grating_turn_rad\n\n    def _lamcen_residual(self, wavelength_um, order=0):\n        ls = wavelength_um * order\n        rs = self.fixed_geometry * np.cos(self._deflection_gamma(wavelength_um))\n        return ls - rs\n\n    def _iter_calc_lamcen(self, order):\n        kw = {'order':order}\n        runme = partial(self._lamcen_residual, **kw)\n        return opti.bisect(runme, 0.0, 10.0)\n\n    def calc_central_wlen_um(self, spec_order_list):\n        return np.array([self._iter_calc_lamcen(x) for x in spec_order_list])\n\n    def gamma_from_wlen_um(self, wlen_list_um):\n        return np.array([self._deflection_gamma(x) for x in wlen_list_um])\n\n    def fancy_deflections(self, spec_order_list):\n        order_ctr_wlen_um = self.calc_central_wlen_um(spec_order_list)\n        order_ctr_gamma_r = self.gamma_from_wlen_um(order_ctr_wlen_um)\n        return order_ctr_wlen_um, order_ctr_gamma_r\n\n    def two_pass_deflection(self, wavelength_um):\n        \"\"\"\n        incid_1_r   --> angle of incidence of light onto prism (first pass)\n        deflect_1_r --> deflection angle produced by first pass\n        heading_1_r --> direction of deflected ray in benchtop units\n        gamma_eff_r --> effective gamma angle at grating for this wavelength\n        excid_1_r   --> angle of deflected ray to exit face normal\n\n        incid_2_r   --> angle of incidence on prism face 2 (second pass)\n        deflect_2_r --> deflection angle produced by second pass\n        \"\"\"\n        incid_1_r   = np.radians(self.prism_front_incid_deg)\n        deflect_1_r = self.pr_obj.deflection_rad_wl(incid_1_r, wavelength_um)\n        heading_1_r = self.input_turn_rad + deflect_1_r\n        gamma_eff_r = heading_1_r - self.grating_turn_rad\n        excid_1_r   = heading_1_r - np.radians(self.prism_face2_deg)\n\n        # Non-zero gamma causes change in incidence for second pass:\n        incid_2_r = excid_1_r - 2.0 * gamma_eff_r\n        refl_beam_r = heading_1_r + np.pi - 2 * gamma_eff_r\n        deflect_2_r = self.pr_obj.deflection_rad_wl(incid_2_r, wavelength_um)\n        heading_2_r = refl_beam_r - deflect_2_r\n\n        # Total Y-shift produced by a combination of prism<-->grating offset\n        # and deflection over the collimator focal length:\n        pg_yshift =  2.0 * self.prism_grating_mm * np.tan(gamma_eff_r)\n        pc_yshift = -1.0 * self.coll_focallen_mm * np.tan(heading_2_r - np.pi)\n        wlen_nm = 1e3 * wavelength_um\n        gamma_deg = np.degrees(gamma_eff_r)\n        sys.stderr.write(\"λ=%6.1f nm, γ= %6.3f: PG,PC shifts: %6.2f, %6.2f | i2=%5.2f\\n\"\n                % (wlen_nm, gamma_deg, pg_yshift, pc_yshift, np.degrees(incid_2_r)))\n        return heading_2_r, pg_yshift, pc_yshift\n        #return deflect_1_r, refl_beam_r, deflect_2_r, heading_2_r\n\n##--------------------------------------------------------------------------##\n\n\n\n\n######################################################################\n# CHANGELOG (spectrograph_optics.py):\n#---------------------------------------------------------------------\n#\n#  2018-12-29:\n#     -- Increased __version__ to 0.1.0.\n#     -- First created spectrograph_optics.py.\n#\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_460","text":"<filename>ex4\/ex4.py<gh_stars>10-100\nimport scipy.io as sio\r\nimport numpy as np\r\nfrom scipy.optimize import minimize\r\n\r\nfrom common_functions import add_zero_feature, sigmoid, matrix_args_array_only\r\n\r\ndef sigmoid_gradient(z):\r\n    return np.multiply(sigmoid(z), 1-sigmoid(z))\r\n\r\n@matrix_args_array_only\r\ndef cf_nn(nn_params, input_layer_size, hidden_layer_size, num_labels, X, Y, lambda_coef):\r\n\r\n    Theta1 = nn_params[0, :hidden_layer_size * (input_layer_size + 1)].reshape((hidden_layer_size, (input_layer_size + 1)))\r\n    Theta2 = nn_params[0, hidden_layer_size * (input_layer_size + 1):].reshape((num_labels, (hidden_layer_size + 1)))\r\n\r\n    m = Y.shape[1]\r\n    Y = Y.A\r\n\r\n    A_1 = X\r\n    Z_2 = Theta1*A_1.T\r\n    A_2 = sigmoid(Z_2)\r\n    A_2 = add_zero_feature(A_2, axis=0)\r\n    Z_3 = Theta2*A_2\r\n    A_3 = sigmoid(Z_3)\r\n    H = A_3.A\r\n\r\n    J = np.sum(-Y*np.log(H) - (1-Y)*np.log(1-H))\/m\r\n\r\n    reg_J = 0.0\r\n    reg_J += np.sum(np.power(Theta1, 2)[:, 1:])\r\n    reg_J += np.sum(np.power(Theta2, 2)[:, 1:])\r\n\r\n    J += reg_J*(float(lambda_coef)\/(2*m))\r\n\r\n    return J\r\n\r\n@matrix_args_array_only\r\ndef gf_nn(nn_params, input_layer_size, hidden_layer_size, num_labels, X, Y, lambda_coef):\r\n\r\n    Theta1 = nn_params[0, :hidden_layer_size * (input_layer_size + 1)].reshape((hidden_layer_size, (input_layer_size + 1)))\r\n    Theta2 = nn_params[0, hidden_layer_size * (input_layer_size + 1):].reshape((num_labels, (hidden_layer_size + 1)))\r\n\r\n    m = Y.shape[1]\r\n\r\n    A_1 = X\r\n    Z_2 = Theta1*A_1.T\r\n    A_2 = sigmoid(Z_2)\r\n    A_2 = add_zero_feature(A_2, axis=0)\r\n    Z_3 = Theta2*A_2\r\n    A_3 = sigmoid(Z_3)\r\n\r\n    DELTA_3 = A_3 - Y\r\n    DELTA_2 = np.multiply((Theta2.T*DELTA_3)[1:, :], sigmoid_gradient(Z_2))\r\n    Theta1_grad = (DELTA_2 * A_1)\/m\r\n    Theta2_grad = (DELTA_3 * A_2.T)\/m\r\n\r\n    lambda_coef = float(lambda_coef)\r\n    Theta1_grad[:, 1:] += (lambda_coef\/m)*Theta1[:, 1:]\r\n    Theta2_grad[:, 1:] += (lambda_coef\/m)*Theta2[:, 1:]\r\n\r\n    return np.concatenate((Theta1_grad.A1, Theta2_grad.A1))\r\n\r\ndef rand_initialize_weights(L_in, L_out):\r\n    epsilon_init = 0.12\r\n    return np.random.rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init\r\n\r\nif __name__ == '__main__':\r\n    data = sio.loadmat('ex4data1.mat')\r\n    y = data['y']\r\n    X = data['X']\r\n\r\n    X = add_zero_feature(X)\r\n\r\n    data = sio.loadmat('ex4weights.mat')\r\n    Theta1 = data['Theta1']\r\n    Theta2 = data['Theta2']\r\n\r\n    nn_params = np.concatenate((Theta1.ravel(), Theta2.ravel()))\r\n\r\n    input_layer_size  = 400\r\n    hidden_layer_size = 25\r\n    num_labels = 10\r\n    m = len(y)\r\n\r\n    Y = (np.arange(num_labels)[:, np.newaxis] == (y.T-1)).astype(float)\r\n\r\n    for lambda_coef in (0, 1):\r\n        print 'Cost function = {}, lambda = {}'.format(cf_nn(nn_params, input_layer_size, hidden_layer_size, num_labels, X, Y, lambda_coef), lambda_coef)\r\n\r\n    initial_Theta1 = rand_initialize_weights(input_layer_size, hidden_layer_size)\r\n    initial_Theta2 = rand_initialize_weights(hidden_layer_size, num_labels)\r\n\r\n    initial_nn_params = np.concatenate((initial_Theta1.ravel(), initial_Theta2.ravel()))\r\n\r\n    res = minimize(cf_nn, initial_nn_params, method='L-BFGS-B', jac=gf_nn, options={'disp': True, 'maxiter':100},\r\n                        args=(input_layer_size, hidden_layer_size, num_labels, X, Y, lambda_coef)).x\r\n\r\n    Theta1 = res[:hidden_layer_size * (input_layer_size + 1)].reshape((hidden_layer_size, (input_layer_size + 1)))\r\n    Theta2 = res[hidden_layer_size * (input_layer_size + 1):].reshape((num_labels, (hidden_layer_size + 1)))\r\n\r\n\r\n    h1 = sigmoid(np.dot(X, Theta1.T))\r\n    h2 = sigmoid(np.dot(add_zero_feature(h1), Theta2.T))\r\n    y_pred = np.argmax(h2, axis=1)+1\r\n\r\n    print 'Training Set Accuracy: {}'.format(np.mean(y_pred == y.ravel(), ) * 100)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_462","text":"<filename>audio\/audio_record.py\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu May 20 21:00:52 2021\n\n@author: omar\n\"\"\"\n\nimport sounddevice as sd\nfrom scipy.io.wavfile import write\nfrom audio.audio_converter import convert_audio\nfrom audio.audio_recognition import speech_rec\n\ndef record(audio_needed = False):\n\n    fs = 44100  # Sample rate\n    seconds = 6  # Duration of recording\n    \n    myrecording = sd.rec(int(seconds * fs), samplerate=fs, channels=2)\n    print(\"Recording...\")\n    sd.wait()  # Wait until recording is finished\n    print(\"End of Record Session.\")\n    \n    write(\"recorded.wav\", fs, myrecording)  # Save as WAV file\n    \n    convert_audio()\n    \n    result = speech_rec(audio_needed)\n    \n    return result\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_463","text":"\"\"\"\nCode to do fractal geometry analysis:\n    surface area of simple curves\n    volume of simple curves\n    find all line segment intersections\n\"\"\"\n\nimport numpy as np\nfrom scipy.spatial import ConvexHull\n#from shapely.geometry import LineString\n#from shapely.geometry.polygon import LinearRing\n\n\n\ndef poly_point_pairs(curve):\n    pairs = [(x_n, x_np1) for x_n, x_np1 in zip(curve[:-1], curve[1:])]\n    pairs.append((curve[-1], curve[0]))\n    return pairs\n\ndef pppair_2_det(pppair):\n    pt_1, pt_2 = pppair\n    x1, y1 = pt_1\n    x2, y2 = pt_2\n    return x1*y2 - x2*y1\n\ndef pppair_2_len(pppair):\n    pt_1, pt_2 = pppair\n    return np.linalg.norm(pt_2 - pt_1)\n\ndef simple_surface_area(curve):\n    pppairs = poly_point_pairs(curve)\n    lens = [pppair_2_len(pppair) for pppair in pppairs]\n    return np.sum(lens)\n\ndef simple_volume(curve):\n    pppairs = poly_point_pairs(curve)\n    dets = [pppair_2_det(pppair) for pppair in pppairs]\n    return 0.5 * np.sum(dets)\n\ndef curve_2_tuples(curve):\n    return [(x,y) for x,y in curve]\n\ndef is_simple(curve):\n    is_simple = False\n    tuples = curve_2_tuples(curve)\n    lr = LinearRing(tuples)\n    try:\n        test = lr.area\n        is_simple = True\n    finally:\n        return is_simple\n\ndef do_intersect_shp(p_n, p_np1, p_m, p_mp1):\n    ln = LineString([tuple(p_n), tuple(p_np1)])\n    lm = LineString([tuple(p_m), tuple(p_mp1)])\n    return ln.intersects(lm)\n\ndef get_intersect(p_n, p_np1, p_m, p_mp1):\n    xm1, ym1 = p_m\n    xm2, ym2 = p_mp1\n    xn1, yn1 = p_n\n    xn2, yn2 = p_np1\n    slope_n = (yn2 - yn1)\/(xn2 - xn1)\n    slope_m = (ym2 - ym1)\/(xm2 - xm1)\n    x_star = (ym1 - yn1 + slope_n * xn1 - slope_m * xm1)\/(slope_n - slope_m)\n    y_star = slope_n * (x_star - xn1) + yn1\n    return [x_star, y_star]\n\ndef does_intersect(p_n, p_np1, p_m, p_mp1):\n    xm1, ym1 = p_m\n    xm2, ym2 = p_mp1\n    xn1, yn1 = p_n\n    xn2, yn2 = p_np1\n    slope_n = (yn2 - yn1)\/(xn2 - xn1)\n    slope_m = (ym2 - ym1)\/(xm2 - xm1)\n    x_star = (ym1 - yn1 + slope_n * xn1 - slope_m * xm1)\/(slope_n - slope_m)\n    y_star = slope_n * (x_star - xn1) + yn1\n    cond_x = min(xn1,xn2) <= x_star <= max(xn1,xn2)\n    cond_y = min(yn1,yn2) <= y_star <= max(yn1,yn2)\n    return cond_x and cond_y\n\ndef cclockwise_order(p1,p2,p3):\n    slope_12 = (p3[1] - p1[1]) * (p2[0] - p1[0])\n    slope_13 = (p2[1] - p1[1]) * (p3[0] - p1[0])\n    # those are not errors, i think\n    return slope_12 > slope_13   \n\ndef do_intersect_ccw(p_n, p_np1, p_m, p_mp1):\n    cond_n = cclockwise_order(p_n,p_m,p_mp1) != cclockwise_order(p_np1,p_m,p_mp1)\n    cond_m = cclockwise_order(p_n,p_np1,p_m) != cclockwise_order(p_n,p_np1,p_mp1)\n    return cond_n and cond_m\n\ndef intersects(curve):\n    '''\n    returns list of intersections, if at=None then there was a div by 0 issue\n    '''\n    pppairs = poly_point_pairs(curve)\n    buffer = 2\n    intersect_list = []\n    for n, (p_n, p_np1) in enumerate(pppairs[:-buffer]):\n        pppairs_ahead = pppairs[n + buffer:]\n        for k, (p_m, p_mp1) in enumerate(pppairs_ahead):\n            m = n + k + buffer\n            if np.linalg.norm(p_n-p_m)<2.5 and k>5 and does_intersect(p_n, p_np1, p_m, p_mp1):\n                try:\n                    point = get_intersect(p_n, p_np1, p_m, p_mp1)\n                except:\n                    point = None    \n                desc = {'n':n, 'm':m, 'at':point}\n                intersect_list.append(desc)\n    return intersect_list\n\ndef complex_to_simples(curve, intersect_list):\n    '''\n    https:\/\/web.archive.org\/web\/20100805164131\/http:\/\/www.cis.southalabama.edu\/~hain\/general\/Theses\/Subramaniam_thesis.pdf\n\n    '''\n    simples = []\n    smallest = sorted(intersect_list, key=lambda d: d['m']-d['n'])\n    base = curve\n    for intersect in intersect_list:\n        pass\n\n    \n\n\n\n\n\ndef convex_hull(curve, len_line_seg=None):\n    # need to configure to keep maximum hull line segment length small\n    # enough to include non-overlapped points\n    \n    if len_line_seg is None:\n        deltas = curve[:-1] - curve[1:]\n        dists = np.linalg.norm(deltas, axis=1)\n        dmin, dmax, dmean = np.amin(dists), np.amax(dists), np.mean(dists)\n\n        double_deltas = curve[:-2] - curve[2:]\n        double_dists = np.linalg.norm(double_deltas, axis=1)\n        ddmin, ddmax, ddmean = np.amin(double_dists), np.amax(double_dists), np.mean(double_dists)\n\n        #expectations:\n\n        # dmean:\n        # dmean = dmin = dmax; give or take some rounding error\n\n        # ddmax:\n        # ddmax = 2*dmean (2 line segments, no change in heading)\n\n        # ddmin:\n        # ddmin = 2 line segments, one bend at angle alpha\n        # ddmin = len of 3rd leg of isoceles triangle where angle is alpha and leg len is dmean\n        # ddmin = dmean * sin(alpha) \/ sin((pi - alpha)\/2)\n        # ddmin = dmean * 2 sin(alpha \/ 2)\n\n        # ddmean:\n        # dmean * 2sin(alpha\/2) <= ddmean <= 2 dmean \n        # let the ratio of 1's to 0's be r_c\n        # ddmean = 2 dmean (r_c + (1-r_c) sin(alpha\/2))\n\n    hull = ConvexHull(curve)\n    return hull"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_452","text":"<reponame>metocean\/tcrm\n\"\"\"\n:mod:`interp3d` -- interpolate to a set of points in 3-dimensional space\n========================================================================\n\n.. module:: interp3d\n    :synopsis: Interpolate data to a set of points in 3-d space.\n\n.. moduleauthor:: <NAME> <<EMAIL>>\n\nUse :func:`scipy.ndimage.interpolation.map-coordinates` to interpolate\ndata in three dimensions.\n\n\"\"\"\n\nimport numpy as np\nfrom scipy.ndimage.interpolation import map_coordinates\n\ndef interp3d(input_array, coords,\n             scale=[360., 180., 365.],\n             offset=[0., -90., 0.],\n             prefilter=True):\n    \"\"\"\n    Wrapper to :func:`scipy.ndimage.interpolation.map_coordinates`, which\n    converts coordinates of points to indices that correspond to the\n    array.  We assume that one is working with lon, lat, day data\n    (i.e. initially designed to work with daily long term mean sea\n    level pressure)\n\n    :param input_array: A 3-d array of data at regular intervals,\n                        representing the data to be evaluated.\n    :param coords: A 3-by-n array of coordinates at which the data\n                   in ``input_array`` will be interpolated to.\n    :param list scale: A (list of) scale factor(s) that reduces the\n                       ``coords`` values to the range of indices in\n                       ``input_array``.\n    :param list offset: A (list of) offset factor(s) that is\n                        subtracted from the ``coords`` values before\n                        adjusting the ``scale`` (above).\n    :param boolean prefilter: If ``True`` (default), then apply a spline\n                              filter before interpolation (necessary for\n                              spline interpolation of order > 1).  If\n                              ``False``, it is assumed that the input is\n                              already filtered. Default is ``True``.\n\n    :returns: 1-d array of values corresponding to the interpolated\n              values at the points given in ``coords``.\n\n    Example::\n\n      >>> vals = interp3d(data, coords, scale=[360., 180., 365.],\n      ...                 offset=[0., -90., 0.])\n\n    \"\"\"\n\n    if input_array.ndim != 3:\n        raise ValueError('Input array has incorrect shape')\n    if coords.shape[0] != 3:\n        raise ValueError('Coordinates of points must be 3-d')\n\n    dims = input_array.shape\n    indices = [d*(c - o) \/ s for d, c, o, s in\n               zip(dims, coords, offset, scale)]\n\n    values = map_coordinates(input_array, indices, mode='wrap',\n                             prefilter=prefilter)\n    dtype = input_array.dtype\n    return np.array(values, dtype)\n\ndef _interp(data, coords, scale=[360., 180.], offset=[0., -90.]):\n    \"\"\"\n    Wrapper to scipy.ndimage.interpolation.map_coordinates, which converts\n    coordinates of points to indices that correspond to the array.\n    We assume that one is working with lon, latdata (i.e. initially\n    designed to work with daily long term mean sea level pressure)\n\n    Input:\n    input_array - a 2-d array of data at regular intervals, representing the\n                  data to be evaluated\n    coords - a 2xn array of coordinates at which the data in input_array\n             will be interpolated\n    scale - a scale factor that reduces the coords values to the range of\n            indices in input_array\n    offset - an offset factor that is subtracted from the coords values\n             before adjusting the scale (above)\n\n    Output:\n    1-d array of values corresponding to the interpolated values\n    at the points given in 'coords'\n\n    Example: vals = interp2d( data, coords, scale=[360., 180.],\n                              offset=[0.,-90.] )\n    \"\"\"\n\n    if data.ndim != np.asarray(coords).ndim:\n        raise ValueError('Input array and coordinates do not have matching dimensions')\n\n    dims = np.array(data.shape)\n\n    indices = [d*(c - o) \/ s for d, c, o, s in \n               zip(dims, coords, offset, scale)]\n\n    values = map_coordinates(data, indices, mode='wrap')\n\n    return values\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_455","text":"<gh_stars>0\nfrom scipy.stats import kurtosis, skew\nfrom torch.utils.data import Dataset\nfrom sklearn.datasets import make_spd_matrix\nfrom sklearn.covariance import empirical_covariance\nfrom sklearn.metrics import mean_squared_error\nfrom torch.utils.data import DataLoader\nimport numpy as np\nimport itertools\nimport torch.nn.functional as F\n#from .set_transformer.models import SmallSetTransformer, SmallDeepSamples\nimport torch.nn as nn\nimport torch\nimport copy\nimport matplotlib.pyplot as plt \nimport os\nfrom scipy.special import logsumexp\nimport math\nfrom sklearn.preprocessing import StandardScaler\nfrom statsmodels.distributions.empirical_distribution import ECDF\n\nfrom utils import str_to_bool_arg, QuantileScaler\n\nfrom deep_samples.model import DeepSamples\n\nfrom src.dataset import FullLargeDataset\n\n\n\nclass BasicDeepSet(nn.Module):\n    def __init__(self, n_inputs=2, n_outputs=1, n_enc_layers=4, n_hidden_units=64, n_dec_layers=1, \n                 multiplication=True,ln=False, bn=False, activation=nn.ReLU, instance_norm=False, sample_norm=False, n_samples=1000, **kwargs):\n        \"\"\" Note: sample_norm = True first tranposes the data so that the sample_dim is last to reuse existing norm implementations \"\"\"\n        super().__init__()\n        if sample_norm and any([bn, ln, instance_norm]):\n            raise ValueError(\"Cannot have sample_norm and other norms\")\n        enc_layers = []\n        for i in range(n_enc_layers):\n            if i == 0:\n                if sample_norm:\n                    enc_layers.append(nn.ConvTranspose1d(n_inputs, n_hidden_units, 1))\n                else:\n                    enc_layers.append(nn.Linear(in_features=n_inputs, out_features=n_hidden_units))\n            else:\n                if sample_norm:\n                    enc_layers.append(nn.ConvTranspose1d(n_hidden_units, n_hidden_units, 1))\n                else:\n                    enc_layers.append(nn.Linear(in_features=n_hidden_units, out_features=n_hidden_units))\n            if ln:\n                enc_layers.append(nn.LayerNorm(n_hidden_units))\n            if bn:\n                enc_layers.append(nn.BatchNorm1d(n_samples))\n            if instance_norm:\n                enc_layers.append(nn.InstanceNorm1d(n_samples))\n            if sample_norm:\n                if i == 0:\n                    enc_layers.append(nn.InstanceNorm1d(n_hidden_units, affine=True))\n            enc_layers.append(activation())\n        # remove last relu\n        enc_layers = enc_layers[:-1]\n        self.enc = nn.Sequential(*enc_layers)\n        dec_layers = []\n        # for i in range(n_dec_layers - 1):\n        #     dec_layers.append(nn.Linear(in_features=n_hidden_units, out_features=n_hidden_units))\n        #     dec_layers.append(activation())\n        # dec_layers.append(nn.Linear(in_features=n_hidden_units, out_features=n_outputs))\n        for i in range(n_dec_layers):\n            if i == n_dec_layers - 1:\n                dec_layers.append(nn.Linear(in_features=n_hidden_units, out_features=n_outputs))\n            else:\n                dec_layers.append(nn.Linear(in_features=n_hidden_units, out_features=n_hidden_units))\n                if ln:\n                    dec_layers.append(nn.LayerNorm(n_hidden_units))\n                dec_layers.append(activation())\n        self.dec = nn.Sequential(*dec_layers)\n        self.multiplication=multiplication\n        self.sample_norm = sample_norm\n\n    def forward(self, x):\n        if len(x.shape) == 4 and x.shape[1] > 1:\n            encoded = []\n            for j in range(x.shape[1]):\n                a = x[:, j, :, :].squeeze(1)\n                if self.sample_norm:\n                    encoded.append(torch.transpose(self.enc(torch.transpose(a, 1, 2)), 1, 2))\n                else:\n                    encoded.append(self.enc(a))\n            x = torch.cat(encoded, 1)\n        else:\n            x = x.squeeze(1)\n            if self.sample_norm:\n                out = torch.transpose(self.enc(torch.transpose(x, 1, 2)), 1, 2)\n            else:\n                out = self.enc(x)\n            #x = torch.mul(x, out)\n        return out\n    \nclass BasicDeepSetMean(BasicDeepSet):\n    def forward(self, x, length=None):\n        x = super().forward(x)\n        if self.sample_norm:\n            x = super().forward(torch.transpose(x, 1, 2))\n        else:\n            x = super().forward(x)\n        if self.multiplication:\n            x = torch.mul(x, x)\n        if self.sample_norm:\n            x = torch.transpose(x, 1, 2)\n        x = x.mean(dim=-2)\n        x = self.dec(x)\n        return x\n\nclass BasicDeepSetMeanRC(BasicDeepSet):\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n        dec_layers = []\n        for i in range(kwargs['n_dec_layers']):\n            if i == kwargs['n_dec_layers'] - 1:\n                dec_layers.append(nn.Linear(in_features=kwargs['n_hidden_units'] + kwargs['n_inputs'], out_features=kwargs['n_outputs']))\n            else:\n                dec_layers.append(nn.Linear(in_features=kwargs['n_hidden_units'] + kwargs['n_inputs'], out_features=kwargs['n_hidden_units'] + kwargs['n_inputs']))\n                if kwargs['ln']:\n                    dec_layers.append(nn.LayerNorm(kwargs['n_hidden_units'] + kwargs['n_inputs']))\n                dec_layers.append(kwargs['activation']())\n        self.dec = nn.Sequential(*dec_layers)\n\n    def forward(self, x, length=None):\n#         x = super().forward(x)\n        means = torch.mean(x, axis=1)\n        # print(means.shape)\n        x -= means.unsqueeze(1)\n        if self.sample_norm:\n            x = self.enc(torch.transpose(x, 1, 2))\n        else:\n            x = self.enc(x)\n        if self.multiplication:\n            x = torch.mul(x, x)\n        if self.sample_norm:\n            x = torch.transpose(x, 1, 2)\n        x = x.mean(dim=-2)\n        x = torch.cat([x, means], axis=1)  # [b, hidden + features_per_sample]\n        # print('x', x.shape)\n        x = self.dec(x)\n        return x\n\n    \nclass BasicDeepSetSum(BasicDeepSet):\n    def forward(self, x, length=None):\n#         x = super().forward(x)\n        if self.sample_norm:\n            x = self.enc(torch.transpose(x, 1, 2))\n        else:\n            x = self.enc(x)\n        if self.multiplication:\n            x = torch.mul(x, x)\n        if self.sample_norm:\n            x = torch.transpose(x, 1, 2)\n        x = x.sum(dim=-2)\n        x = self.dec(x)\n        return x\n\n    \n\n\n\ndef train_nn(model, name, optimizer, scheduler, train_generator, test_generator, classification=False, \n             n_epochs=10, outputs=[], use_wandb=False, plot_gradients=False, seed=0):\n    \n    np.random.seed(seed)\n    torch.manual_seed(seed)\n    if use_wandb:\n        import wandb\n    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n    print(device)\n    print(classification)\n    model = model.to(device)\n\n    if use_wandb and plot_gradients:\n        wandb.watch(model, log='all')\n    # by default, reduction = mean when multiple outputs\n    #criterion = nn.MSELoss() \n    if classification:\n        criterion = nn.BCELoss()\n    else:\n        criterion = nn.MSELoss(reduction=\"none\") \n    step = 0\n    best_loss_ts = None\n    best_loss_tr = None\n    losses_tr = []\n    losses_ts = []\n    dtype = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor\n    for epoch in range(n_epochs):\n        print(epoch)\n        train_aux = []\n        for x, y, lengths in train_generator:\n            # print(x.shape)\n            x, y, lengths = x.type(dtype).to(device), y.type(dtype).to(device), lengths.to(device)\n            preds = model(x, lengths)\n            preds = preds.reshape(x.shape[0], len(outputs))\n            assert preds.shape == y.shape, \"{} {}\".format(preds.shape, y.shape)\n            loss_elements = criterion(preds, y)\n            loss = loss_elements.mean()\n            if np.isnan(loss.detach().cpu().numpy()):\n                raise ValueError(\"Train loss is nan: \", loss)\n            train_aux.append(loss.detach().cpu().numpy())\n            # TODO: maybe we don't want to log at every step\n            if use_wandb:\n                wandb.log({f\"{name} train loss per step\": loss}, step=step)\n            if len(outputs) > 1:\n                outputs_loss = loss_elements.mean(dim=0)\n                # print(outputs)\n                # print(outputs_loss)\n                assert len(outputs) == len(outputs_loss)\n                per_output_loss = outputs_loss\n                if use_wandb:\n                    for i in range(len(outputs)):\n                        wandb.log({outputs[i]: per_output_loss[i]}, step=step)\n            optimizer.zero_grad()\n            loss.backward()\n            optimizer.step()\n            preds = model(x, lengths)\n            step += 1\n            if step % 20 == 0:\n                # losses_tr.append(per_output_loss.detach().cpu().numpy())\n                \n                aux = []\n                accuracy = []\n                for x, y, lengths in test_generator:\n                    x, y, lengths = x.type(dtype).to(device), y.type(dtype).to(device), lengths.to(device)\n                    loss_elements = criterion(model(x, lengths), y)\n                    loss = loss_elements.mean()\n                    if np.isnan(loss.detach().cpu().numpy()):\n                        raise ValueError(\"Test loss is nan: \", loss)\n                    if classification:\n                        accuracy.append(accuracy_score(model(x, lengths).detach().cpu().numpy(),\n                                                       y.detach().cpu().numpy().astype(np.int8)))\n                    aux.append(loss.detach().cpu().numpy())\n                test_loss = np.nanmean(aux)\n                if use_wandb:\n                    wandb.log({f\"{name} test loss per step\": test_loss}, step=step)\n                if len(outputs) > 1:\n                    outputs_loss = loss_elements.mean(dim=0)\n                    assert len(outputs) == len(outputs_loss)\n                    per_output_loss = outputs_loss\n                    if use_wandb:\n                        for i in range(len(outputs)):\n                            wandb.log({outputs[i]: per_output_loss[i]}, step=step)\n                train_loss = train_aux[-1]\n#                 train_loss = np.nanmean(train_aux)\n#                 print(train_aux)\n                train_aux = []\n                losses_tr.append(train_loss)\n#                 print(train_loss)\n                if not np.isnan(train_loss) and not best_loss_tr or (train_loss < best_loss_tr):\n                    if use_wandb:\n                        wandb.run.summary[\"best_tr_loss\"] = train_loss\n                    best_loss_tr = train_loss\n                scheduler.step()\n                if classification:\n                    print('Train loss: '+str(train_loss)+\", test loss: \"+str(test_loss)\n                        +'test accuracy: ' + np.nanmean(accuracy))\n                else:\n                    print('Train loss: '+str(train_loss)+\", test loss: \"+str(test_loss)) \n                # losses_ts.append(per_output_loss.detach().cpu().numpy())\n                losses_ts.append(test_loss)\n                if not np.isnan(train_loss) and not best_loss_ts or (test_loss < best_loss_ts):\n                    if use_wandb:\n                        wandb.run.summary[\"best_loss\"] = test_loss\n                    best_loss_ts = test_loss\n            #print(list(model.parameters())[4])\n    return model, best_loss_tr, best_loss_ts, losses_tr, losses_ts\n\nif __name__ == \"__main__\":\n    import argparse\n    import wandb\n\n    parser = argparse.ArgumentParser(description='Results summary')\n    parser.add_argument('-lr', '--learning_rate', default=.01, type=float)\n    parser.add_argument('-bs', '--batch_size', default=64, type=int)\n    parser.add_argument('-e', '--enc_layers', default=2, type=int)\n    parser.add_argument('-d', '--dec_layers', default=1, type=int)\n    parser.add_argument('-ol', '--output_layers', default=1, type=int)\n    parser.add_argument('-u', '--hidden_units', default=64, type=int)\n    parser.add_argument('-s', '--step_size', default=60, type=int)\n    parser.add_argument('-g', '--gamma', default=.9, type=float)\n    parser.add_argument('-f', '--features', default=2, type=int)\n    parser.add_argument('-n', '--sample_size', default=1000, type=int)\n    parser.add_argument('-eo', '--enc_layers_outer', default=2, type=int)\n    parser.add_argument('-do', '--dec_layers_outer', default=1, type=int)\n    parser.add_argument('-ei', '--enc_layers_inner', default=2, type=int)\n    parser.add_argument('-di', '--dec_layers_inner', default=1, type=int)\n    parser.add_argument('-uo', '--hidden_units_outer', default=64, type=int)\n    parser.add_argument('-ui', '--hidden_units_inner', default=64, type=int)\n    parser.add_argument('--normalization', default=\"true\", type=str)\n    parser.add_argument('--connect_decoder', default=\"true\", type=str)\n\n    parser.add_argument('--layer_norm', default='false', type=str)\n    parser.add_argument('--batch_norm', default='false', type=str)\n    parser.add_argument('--instance_norm', default='false', type=str)\n    parser.add_argument('--sample_norm', default='false', type=str)\n    parser.add_argument('--mean_center', default='false', type=str)\n    parser.add_argument('--quantile_scaling', default='false', type=str)\n    parser.add_argument('--seed_weights', default=0, type=int)\n    parser.add_argument('-a', '--activation', default='relu', help='relu|elu', type=str)\n    parser.add_argument('-m', '--model', default='deepsets', type=str, help='deepsets|settransformer|deepsamples')\n    parser.add_argument('--path', default='distribution_plots\/', type=str)\n    parser.add_argument('--wandb_test', action='store_true')\n    parser.add_argument('--cpu', action='store_true')\n    parser.add_argument('--epochs', default=100, type=int)\n    parser.add_argument('--train_size', default=10000, type=int)\n    args = parser.parse_args()\n\n    layer_norm = str_to_bool_arg(args.layer_norm, 'layer_norm')\n    batch_norm = str_to_bool_arg(args.batch_norm, 'batch_norm')\n    instance_norm = str_to_bool_arg(args.instance_norm, 'instance_norm')\n    sample_norm = str_to_bool_arg(args.sample_norm, 'sample_norm')\n    mean_center = str_to_bool_arg(args.mean_center, 'mean_center')\n    ensemble_network = str_to_bool_arg(args.ensemble_network, 'ensemble_network')\n    quantile_scaling = str_to_bool_arg(args.quantile_scaling, 'quantile_scaling')\n    args.output_name = args.output_name.split()\n    normalization = str_to_bool_arg(args.normalization, 'normalization')\n    connect_decoder = str_to_bool_arg(args.connect_decoder, 'connect_decoder')\n    \n    \n    wandb.init(project='hematocrit')\n    data_config = {\n        'inputs': [\"rbc\", \"retics\", \"plt\", \"basos\", \"perox\"],\n        'outputs': [\"Hematocrit\"],\n        'id_file': \"\/misc\/vlgscratch5\/RanganathGroup\/lily\/blood_dist\/data_large\/id_files\/Hematocrit_rbc,retics,plt,basos,perox_January-1-2021.txt\",\n        'num_samples': 1000,\n        'num_subsamples': 1000,\n        'permute_subsamples': False,\n        'normalizer': \"all\",\n        'imputation': \"zero\"\n    }\n    Dataset = FullLargeDataset\n    train = Dataset(test=False, **data_config)\n    test = Dataset(test=True, **data_config)\n    num_workers = 32\n    n_dists = 5\n    n_final_outputs = 1\n    output_names = ['hematocrit']\n    \n    train_generator = DataLoader(train,\n                                    batch_size=args.batch_size,\n                                    shuffle=True,\n                                    num_workers=num_workers,\n                                    pin_memory=False,\n                                    drop_last=True)\n    test_generator = DataLoader(test,\n                            batch_size=args.batch_size,\n                            shuffle=True,\n                            num_workers=num_workers,\n                            pin_memory=False,\n                            drop_last=True)\n\n    device = 'cpu' if args.cpu else torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n    \n    \n    if args.activation == 'relu':\n        activation = nn.ReLU\n    elif args.activation == 'elu':\n        activation = nn.ELU\n\n    n_outputs = 1\n    if args.model == 'deepsample':\n        model = DeepSamples(n_inputs=n_inputs, n_outputs=n_final_outputs, n_enc_layers_outer=args.enc_layers_outer, n_hidden_units_outer=args.hidden_units_outer,\n        n_enc_layers_inner=args.enc_layers_inner, n_hidden_units_inner=args.hidden_units_inner, n_dec_layers_inner=args.dec_layers_inner, n_dists=n_dists,\n        activation=activation, normalization=normalization, \n        connect_decoder=connect_decoder).to(device)\n        n_inputs = args.features\n    else:\n        if args.model == 'settransformer':\n            model_unit = SmallSetTransformer\n            n_inputs = args.features\n        elif args.model == 'deepsets-sum':\n            model_unit = BasicDeepSetSum\n            n_inputs = args.features\n        elif args.model == 'deepsets-rc':\n            model_unit = BasicDeepSetMeanRC\n            n_inputs = args.features\n        else:\n            model_unit = BasicDeepSetMean\n            n_inputs = args.features\n        model = model_unit(n_inputs=n_inputs, n_outputs=n_outputs, n_enc_layers=args.enc_layers, n_hidden_units=args.hidden_units, n_dec_layers=args.dec_layers, ln=layer_norm, bn=batch_norm, activation=activation, instance_norm=instance_norm, n_samples=args.sample_size, sample_norm=sample_norm).to(device)\n    \n    print(model)\n    optimizer = torch.optim.Adam(model.parameters(),lr=args.learning_rate)\n    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma, last_epoch=-1)\n\n    output_names = ['hematocrit']\n    print(output_names)\n    model, train_score, test_score, losses_tr, losses_ts = train_nn(model, 'tentative', optimizer, scheduler, \n                                            train_generator, test_generator, n_epochs=args.epochs,\n                                            outputs=output_names, use_wandb=True, plot_gradients=False, seed=args.seed_weights)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_461","text":"#!\/usr\/bin\/env python3\nfrom __future__ import print_function\nfrom __future__ import division\nimport rospy\nimport rosbag\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib; matplotlib.use('TkAgg')\nfrom waypoint_generation_library import WaypointGen\nfrom scipy import linalg\nfrom nav_msgs.msg import Odometry\nfrom geometry_msgs.msg import Quaternion\nfrom sensor_msgs.msg import Imu\nfrom tf.transformations import euler_from_quaternion, quaternion_from_euler\nfrom mpl_toolkits import mplot3d\n\nWaypointGeneration = WaypointGen()\nwaypoints, desVel, desAcc, timeVec = WaypointGeneration.waypoint_calculation()\ndesiredPos = WaypointGeneration.desiredPos\n\n# plot the waypoints    \nfigPos = plt.figure()\naxPos = plt.axes(projection = '3d')\naxPos.plot3D(desiredPos[:,0], desiredPos[:,1], desiredPos[:,2], 'ro')\n\npnt3d = axPos.scatter(waypoints[:,0], waypoints[:,1], waypoints[:,2], c = timeVec)\ncbar = plt.colorbar(pnt3d)\ncbar.set_label(\"Time [sec]\")\n# label the axes and give title\naxPos.set_xlabel('X-Axis [m]')\naxPos.set_ylabel('Y-Axis [m]')\naxPos.set_zlabel('Z-Axis [m]')\naxPos.set_title('Minimum Jerk Position Waypoints')\n\n# plot the desired kinematics\nfigOtherKinematics = plt.figure()\nfigOtherKinematics.suptitle('Desired Kinematics in Inertial Frame')\n# desired position waypoints\naxPos = plt.subplot(311)\naxPos.plot(timeVec, waypoints[:,0], '-r', label = '$x_b$')\naxPos.plot(timeVec, waypoints[:,1], '-k', label = '$y_b$')\naxPos.plot(timeVec, waypoints[:,2], '-b', label = '$z_b$')\n# add the yaw legend\naxPos.plot(np.nan, '-g', label = 'yaw')\naxPos.legend(loc = 0)\nplt.grid()\nplt.xlabel('Time [sec]')\nplt.ylabel('Position [m]')\n# plt.title('Desired Position in Inertial Frame')\n# desired yaw\naxYaw = axPos.twinx()\naxYaw.plot(timeVec, waypoints[:,3], '-g')\naxYaw.set_ylabel('Yaw [rad]')\n\n# desired velocity waypoints\naxVel = plt.subplot(312)\naxVel.plot(timeVec, desVel[:,0], '-r', label = '$v_{x,b}$')\naxVel.plot(timeVec, desVel[:,1], '-k', label = '$v_{y,b}$')\naxVel.plot(timeVec, desVel[:,2], '-b', label = '$v_{z,b}$')\n# add the yaw legend\naxVel.plot(np.nan, '-g', label = '$yaw_{rate}$')\naxVel.legend(loc = 0)\nplt.grid()\nplt.xlabel('Time [sec]')\nplt.ylabel('Velocity [m\/s]')\n# plt.title('Desired Velocity in Inertial Frame')\n# desired yaw\naxYawRate = axVel.twinx()\naxYawRate.plot(timeVec, desVel[:,3], '-g')\naxYawRate.set_ylabel('Yaw [rad\/s]')\n\n# desired acceleration waypoints\naxAcc = plt.subplot(313)\naxAcc.plot(timeVec, desAcc[:,0], '-r', label = '$a_{x,b}$')\naxAcc.plot(timeVec, desAcc[:,1], '-k', label = '$a_{y,b}$')\naxAcc.plot(timeVec, desAcc[:,2], '-b', label = '$a_{z,b}$')\n# add the yaw legend\naxAcc.plot(np.nan, '-g', label = '$yaw_{acc}$')\naxAcc.legend(loc = 0)\nplt.grid()\nplt.xlabel('Time [sec]')\nplt.ylabel('Acceleration [$m\/s^2$]')\n# plt.title('Desired Acceleration in Inertial Frame')\n# desired yaw\naxYawRate = axAcc.twinx()\naxYawRate.plot(timeVec, desAcc[:,3], '-g')\naxYawRate.set_ylabel('Yaw [$rad\/s^2$]')\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_321","text":"import pytest\nimport numpy as np\nimport pandas as pd\nimport numpy.testing as npt\nimport pandas.testing as pdt\nfrom scipy.stats import logistic\n\nimport zepid as ze\nfrom zepid import (RiskRatio, RiskDifference, OddsRatio, NNT, IncidenceRateRatio, IncidenceRateDifference,\n                   Sensitivity, Specificity, Diagnostics, interaction_contrast, interaction_contrast_ratio, spline,\n                   table1_generator)\nfrom zepid.calc import sensitivity, specificity\n\n\n@pytest.fixture\ndef data_set():\n    df = pd.DataFrame()\n    df['exp'] = [1]*50 + [0]*50\n    df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25\n    return df\n\n\n@pytest.fixture\ndef multi_exposures():\n    df = pd.DataFrame()\n    df['exp'] = [1]*50 + [0]*50 + [2]*50\n    df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25 + [1]*25 + [0]*25\n    return df\n\n\n@pytest.fixture\ndef time_data():\n    df = pd.DataFrame()\n    df['exp'] = [1]*50 + [0]*50\n    df['dis'] = [1]*6 + [0]*44 + [1]*14 + [0]*36\n    df['t'] = [2]*50 + [8]*50\n    return df\n\n\nclass TestRiskRatio:\n\n    def test_risk_ratio_reference_equal_to_1(self, data_set):\n        rr = RiskRatio()\n        rr.fit(data_set, exposure='exp', outcome='dis')\n        assert rr.risk_ratio[0] == 1\n\n    def test_risk_ratio_equal_to_1(self, data_set):\n        rr = RiskRatio()\n        rr.fit(data_set, exposure='exp', outcome='dis')\n        assert rr.risk_ratio[1] == 1\n\n    def test_multiple_exposures(self, multi_exposures):\n        rr = RiskRatio()\n        rr.fit(multi_exposures, exposure='exp', outcome='dis')\n        assert rr.results.shape[0] == 3\n        assert list(rr.results.index) == ['Ref:0', '1', '2']\n\n    def test_match_sas_ci(self, data_set):\n        sas_ci = 0.6757, 1.4799\n        rr = RiskRatio()\n        rr.fit(data_set, exposure='exp', outcome='dis')\n        df = rr.results\n        npt.assert_allclose(np.round(df.loc[df.index == '1'][['RR_LCL', 'RR_UCL']], 4), [sas_ci])\n\n    def test_match_sas_sampledata(self):\n        sas_rd = 0.742118331\n        sas_se = 0.312612740\n        sas_ci = 0.402139480, 1.369523870\n        df = ze.load_sample_data(False)\n        rr = RiskRatio()\n        rr.fit(df, exposure='art', outcome='dead')\n        npt.assert_allclose(rr.risk_ratio[1], sas_rd, rtol=1e-5)\n        rf = rr.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['RR_LCL', 'RR_UCL']], [sas_ci], rtol=1e-5)\n        npt.assert_allclose(rf.loc[rf.index == '1'][['SD(RR)']], sas_se, rtol=1e-5)\n\n\nclass TestRiskDifference:\n\n    def test_risk_difference_reference_equal_to_0(self, data_set):\n        rd = RiskDifference()\n        rd.fit(data_set, exposure='exp', outcome='dis')\n        assert rd.risk_difference[0] == 0\n\n    def test_risk_difference_equal_to_0(self, data_set):\n        rd = RiskDifference()\n        rd.fit(data_set, exposure='exp', outcome='dis')\n        assert rd.risk_difference[1] == 0\n\n    def test_multiple_exposures(self, multi_exposures):\n        rd = RiskDifference()\n        rd.fit(multi_exposures, exposure='exp', outcome='dis')\n        assert rd.results.shape[0] == 3\n        assert list(rd.results.index) == ['Ref:0', '1', '2']\n\n    def test_match_sas_ci(self, data_set):\n        sas_ci = -0.195996398, 0.195996398\n        rd = RiskDifference()\n        rd.fit(data_set, exposure='exp', outcome='dis')\n        df = rd.results\n        npt.assert_allclose(df.loc[df.index == '1'][['RD_LCL', 'RD_UCL']], [sas_ci])\n\n    def test_match_sas_se(self, data_set):\n        sas_se = 0.1\n        rd = RiskDifference()\n        rd.fit(data_set, exposure='exp', outcome='dis')\n        df = rd.results\n        npt.assert_allclose(df.loc[df.index == '1'][['SD(RD)']], sas_se)\n\n    def test_match_sas_sampledata(self):\n        sas_rr = -0.045129870\n        sas_se = 0.042375793\n        sas_ci = -0.128184899, 0.037925158\n        df = ze.load_sample_data(False)\n        rd = RiskDifference()\n        rd.fit(df, exposure='art', outcome='dead')\n        npt.assert_allclose(rd.risk_difference[1], sas_rr)\n        rf = rd.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['RD_LCL', 'RD_UCL']], [sas_ci])\n        npt.assert_allclose(rf.loc[rf.index == '1'][['SD(RD)']], sas_se)\n\n    def test_frechet_bounds(self):\n        df = ze.load_sample_data(False)\n        rd = RiskDifference()\n        rd.fit(df, exposure='art', outcome='dead')\n        npt.assert_allclose(rd.results['UpperBound'][1] - rd.results['LowerBound'][1], 1.0000)\n\n    def test_frechet_bounds2(self, multi_exposures):\n        rd = RiskDifference()\n        rd.fit(multi_exposures, exposure='exp', outcome='dis')\n        npt.assert_allclose(rd.results['UpperBound'][1:] - rd.results['LowerBound'][1:], [1.0000, 1.0000])\n\n\nclass TestOddsRatio:\n\n    def test_odds_ratio_reference_equal_to_1(self, data_set):\n        ord = OddsRatio()\n        ord.fit(data_set, exposure='exp', outcome='dis')\n        assert ord.odds_ratio[0] == 1\n\n    def test_odds_ratio_equal_to_1(self, data_set):\n        ord = OddsRatio()\n        ord.fit(data_set, exposure='exp', outcome='dis')\n        assert ord.odds_ratio[1] == 1\n\n    def test_multiple_exposures(self, multi_exposures):\n        ord = OddsRatio()\n        ord.fit(multi_exposures, exposure='exp', outcome='dis')\n        assert ord.results.shape[0] == 3\n        assert list(ord.results.index) == ['Ref:0', '1', '2']\n\n    def test_match_sas_ci(self, data_set):\n        sas_ci = 0.4566, 2.1902\n        ord = OddsRatio()\n        ord.fit(data_set, exposure='exp', outcome='dis')\n        df = ord.results\n        npt.assert_allclose(df.loc[df.index == '1'][['OR_LCL', 'OR_UCL']], [sas_ci], rtol=1e-4)\n\n    def test_match_sas_sampledata(self):\n        sas_or = 0.7036\n        sas_se = 0.361479191\n        sas_ci = 0.3465, 1.4290\n        df = ze.load_sample_data(False)\n        ord = OddsRatio()\n        ord.fit(df, exposure='art', outcome='dead')\n        npt.assert_allclose(ord.odds_ratio[1], sas_or, rtol=1e-4)\n        rf = ord.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['OR_LCL', 'OR_UCL']], [sas_ci], rtol=1e-3)\n        npt.assert_allclose(rf.loc[rf.index == '1'][['SD(OR)']], sas_se, rtol=1e-4)\n\n\nclass TestNNT:\n\n    def test_return_infinity(self, data_set):\n        nnt = NNT()\n        nnt.fit(data_set, exposure='exp', outcome='dis')\n        assert np.isinf(nnt.number_needed_to_treat[1])\n\n    def test_match_inverse_of_risk_difference(self):\n        df = ze.load_sample_data(False)\n\n        rd = RiskDifference()\n        rd.fit(df, exposure='art', outcome='dead')\n\n        nnt = NNT()\n        nnt.fit(df, exposure='art', outcome='dead')\n\n        npt.assert_allclose(nnt.number_needed_to_treat[1], 1\/rd.risk_difference[1])\n        rf = rd.results\n        nf = nnt.results\n        npt.assert_allclose(nf.loc[nf.index == '1'][['NNT_LCL', 'NNT_UCL']],\n                            1 \/ rf.loc[rf.index == '1'][['RD_LCL', 'RD_UCL']])\n        npt.assert_allclose(nf.loc[nf.index == '1'][['SD(RD)']], rf.loc[rf.index == '1'][['SD(RD)']])\n\n    def test_multiple_exposures(self, multi_exposures):\n        nnt = NNT()\n        nnt.fit(multi_exposures, exposure='exp', outcome='dis')\n        assert nnt.results.shape[0] == 3\n        assert list(nnt.results.index) == ['Ref:0', '1', '2']\n\n\nclass TestIncidenceRateRatio:\n\n    def test_incidence_rate_ratio_reference_equal_to_1(self, time_data):\n        irr = IncidenceRateRatio()\n        irr.fit(time_data, exposure='exp', outcome='dis', time='t')\n        assert irr.incidence_rate_ratio[0] == 1\n\n    def test_incidence_rate_ratio_equal_to_expected(self, time_data):\n        sas_irr = 1.714285714\n        sas_se = 0.487950036\n        sas_ci = 0.658778447, 4.460946657\n        irr = IncidenceRateRatio()\n        irr.fit(time_data, exposure='exp', outcome='dis', time='t')\n        npt.assert_allclose(irr.incidence_rate_ratio[1], sas_irr, rtol=1e-4)\n        rf = irr.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['IRR_LCL', 'IRR_UCL']], [sas_ci], rtol=1e-4)\n        npt.assert_allclose(rf.loc[rf.index == '1'][['SD(IRR)']], sas_se, rtol=1e-4)\n\n    def test_multiple_exposures(self):\n        df = pd.DataFrame()\n        df['exp'] = [1]*50 + [0]*50 + [2]*50\n        df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25 + [1]*25 + [0]*25\n        df['t'] = 2\n        irr = IncidenceRateRatio()\n        irr.fit(df, exposure='exp', outcome='dis', time='t')\n        assert irr.results.shape[0] == 3\n        assert list(irr.results.index) == ['Ref:0', '1', '2']\n\n    def test_match_sas_sampledata(self):\n        sas_irr = 0.753956\n        sas_se = 0.336135409\n        sas_ci = 0.390146, 1.457017\n        df = ze.load_sample_data(False)\n        irr = IncidenceRateRatio()\n        irr.fit(df, exposure='art', outcome='dead', time='t')\n        npt.assert_allclose(irr.incidence_rate_ratio[1], sas_irr, rtol=1e-5)\n        rf = irr.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['IRR_LCL', 'IRR_UCL']], [sas_ci], rtol=1e-5)\n        npt.assert_allclose(rf.loc[rf.index == '1'][['SD(IRR)']], sas_se, rtol=1e-5)\n\n\nclass TestIncidenceRateDifference:\n\n    def test_incidence_rate_difference_reference_equal_to_0(self, time_data):\n        ird = IncidenceRateDifference()\n        ird.fit(time_data, exposure='exp', outcome='dis', time='t')\n        assert ird.incidence_rate_difference[0] == 0\n\n    def test_multiple_exposures(self):\n        df = pd.DataFrame()\n        df['exp'] = [1]*50 + [0]*50 + [2]*50\n        df['dis'] = [1]*25 + [0]*25 + [1]*25 + [0]*25 + [1]*25 + [0]*25\n        df['t'] = 2\n        ird = IncidenceRateDifference()\n        ird.fit(df, exposure='exp', outcome='dis', time='t')\n        assert ird.results.shape[0] == 3\n        assert list(ird.results.index) == ['Ref:0', '1', '2']\n\n    def test_match_openepi_sampledata(self):\n        oe_irr = -0.001055\n        oe_ci = -0.003275, 0.001166\n        df = ze.load_sample_data(False)\n        ird = IncidenceRateDifference()\n        ird.fit(df, exposure='art', outcome='dead', time='t')\n        npt.assert_allclose(ird.incidence_rate_difference[1], oe_irr, atol=1e-5)\n        rf = ird.results\n        npt.assert_allclose(rf.loc[rf.index == '1'][['IRD_LCL', 'IRD_UCL']], [oe_ci], atol=1e-5)\n\n\nclass TestDiagnostics:\n\n    @pytest.fixture\n    def test_data(self):\n        df = pd.DataFrame()\n        df['test'] = [1]*50 + [0]*50\n        df['case'] = [1]*40 + [0]*10 + [1]*15 + [0]*35\n        return df\n\n    def test_sensitivity_same_as_calc(self, test_data):\n        se = Sensitivity()\n        se.fit(test_data, test='test', disease='case')\n        sens = sensitivity(40, 50)\n        npt.assert_allclose(se.sensitivity, sens[0])\n\n    def test_specificity_same_as_calc(self, test_data):\n        sp = Specificity()\n        sp.fit(test_data, test='test', disease='case')\n        spec = specificity(15, 50)\n        npt.assert_allclose(sp.specificity, spec[0])\n\n    def test_diagnostic_same_as_compositions(self, test_data):\n        se = Sensitivity()\n        se.fit(test_data, test='test', disease='case')\n\n        sp = Specificity()\n        sp.fit(test_data, test='test', disease='case')\n\n        diag = Diagnostics()\n        diag.fit(test_data, test='test', disease='case')\n\n        npt.assert_allclose(diag.sensitivity.sensitivity, se.sensitivity)\n        npt.assert_allclose(diag.specificity.specificity, sp.specificity)\n\n    def test_match_sas_sensitivity_ci(self, test_data):\n        sas_ci = [0.689127694, 0.910872306]\n        diag = Diagnostics()\n        diag.fit(test_data, test='test', disease='case')\n        npt.assert_allclose(diag.sensitivity.results[['Se_LCL', 'Se_UCL']], [sas_ci])\n\n    def test_match_sas_specificity_ci(self, test_data):\n        sas_ci = [0.572979816, 0.827020184]\n        diag = Diagnostics()\n        diag.fit(test_data, test='test', disease='case')\n        npt.assert_allclose(diag.specificity.results[['Sp_LCL', 'Sp_UCL']], [sas_ci])\n\n\nclass TestInteractionContrasts:\n\n    @pytest.fixture\n    def data_ic(self, n=10000):\n        df = pd.DataFrame()\n        np.random.seed(111)\n        df['exp'] = np.random.binomial(1, 0.5, size=n)\n        df['mod'] = np.random.binomial(1, 0.5, size=n)\n        df['y'] = np.random.binomial(1, size=n, p=logistic.cdf(0.1 + 0.2*df['exp'] + 0.3*df['mod'] -\n                                                               0.4*df['mod']*df['exp']))\n        # Note: IC will not be equal to ICR\n        return df\n\n    def test_interaction_contrast(self, data_ic):\n        ic = interaction_contrast(data_ic, exposure='exp', outcome='y', modifier='mod', print_results=False)\n        npt.assert_allclose(np.round(ic[0], 4), -0.1009)\n\n    def test_interaction_contrast_ci(self, data_ic):\n        ic = interaction_contrast(data_ic, exposure='exp', outcome='y', modifier='mod', print_results=False)\n        assert ic[1] < -0.1009 < ic[2]\n\n    def test_interaction_contrast_ratio(self, data_ic):\n        icr = interaction_contrast_ratio(data_ic, exposure='exp', outcome='y', modifier='mod', print_results=False)\n        npt.assert_allclose(np.round(icr[0], 4), -0.4908)\n\n    def test_interaction_contrast_ratio_delta_ci(self, data_ic):\n        icr = interaction_contrast_ratio(data_ic, exposure='exp', outcome='y', modifier='mod', print_results=False)\n        assert icr[1] < -0.4908 < icr[2]\n\n    def test_interaction_contrast_ratio_bootstrap_ci(self, data_ic):\n        icr = interaction_contrast_ratio(data_ic, exposure='exp', outcome='y', modifier='mod',\n                                         ci='bootstrap', print_results=False)\n        assert icr[1] < -0.4908 < icr[2]\n\n\nclass TestSplines:\n\n    @pytest.fixture\n    def spline_data(self):\n        df = pd.DataFrame()\n        df['v'] = [1, 5, 10, 15, 20]\n        return df\n\n    def test_error_for_bad_nknots(self, spline_data):\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=1.5)\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=0)\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=-1)\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=8)\n\n    def test_error_for_unequal_numbers(self, spline_data):\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=1, knots=[1, 3])\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=3, knots=[1, 3])\n\n    def test_error_for_bad_order(self, spline_data):\n        with pytest.raises(ValueError):\n            spline_data['sp'] = spline(spline_data, 'v', n_knots=3, knots=[3, 1, 2])\n\n    def test_auto_knots1(self, spline_data):\n        spline_data['sp'] = spline(spline_data, 'v', n_knots=1, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 5.0},\n                                                      {'sp': 10.0}])\n        pdt.assert_series_equal(spline_data['sp'], expected_splines['sp'])\n\n    def test_auto_knots2(self, spline_data):\n        spline_data[['sp1', 'sp2']] = spline(spline_data, 'v', n_knots=2, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 10 - 20\/3, 'sp2': 0.0},\n                                                      {'sp1': 15 - 20\/3, 'sp2': 15 - 40\/3},\n                                                      {'sp1': 20 - 20\/3, 'sp2': 20 - 40\/3}])\n        pdt.assert_frame_equal(spline_data[['sp1', 'sp2']], expected_splines[['sp1', 'sp2']])\n\n    def test_user_knots1(self, spline_data):\n        spline_data['sp'] = spline(spline_data, 'v', n_knots=1, knots=[16], restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 4.0}])\n        pdt.assert_series_equal(spline_data['sp'], expected_splines['sp'])\n\n    def test_user_knots2(self, spline_data):\n        spline_data[['sp1', 'sp2']] = spline(spline_data, 'v', n_knots=2, knots=[10, 16], restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 5.0, 'sp2': 0.0},\n                                                      {'sp1': 10.0, 'sp2': 4.0}])\n        pdt.assert_frame_equal(spline_data[['sp1', 'sp2']], expected_splines[['sp1', 'sp2']])\n\n    def test_quadratic_spline1(self, spline_data):\n        spline_data['sp'] = spline(spline_data, 'v', n_knots=1, knots=[16], term=2, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 4.0**2}])\n        pdt.assert_series_equal(spline_data['sp'], expected_splines['sp'])\n\n    def test_quadratic_spline2(self, spline_data):\n        spline_data[['sp1', 'sp2']] = spline(spline_data, 'v', n_knots=2, knots=[10, 16], term=2, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 5.0**2, 'sp2': 0.0},\n                                                      {'sp1': 10.0**2, 'sp2': 4.0**2}])\n        pdt.assert_frame_equal(spline_data[['sp1', 'sp2']], expected_splines[['sp1', 'sp2']])\n\n    def test_cubic_spline1(self, spline_data):\n        spline_data['sp'] = spline(spline_data, 'v', n_knots=1, knots=[16], term=3, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 0.0},\n                                                      {'sp': 4.0**3}])\n        pdt.assert_series_equal(spline_data['sp'], expected_splines['sp'])\n\n    def test_cubic_spline2(self, spline_data):\n        spline_data[['sp1', 'sp2']] = spline(spline_data, 'v', n_knots=2, knots=[10, 16], term=3, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 5.0**3, 'sp2': 0.0},\n                                                      {'sp1': 10.0**3, 'sp2': 4.0**3}])\n        pdt.assert_frame_equal(spline_data[['sp1', 'sp2']], expected_splines[['sp1', 'sp2']])\n\n    def test_higher_order_spline(self, spline_data):\n        spline_data[['sp1', 'sp2']] = spline(spline_data, 'v', n_knots=2, knots=[10, 16], term=3.7, restricted=False)\n        expected_splines = pd.DataFrame.from_records([{'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 0.0, 'sp2': 0.0},\n                                                      {'sp1': 5.0**3.7, 'sp2': 0.0},\n                                                      {'sp1': 10.0**3.7, 'sp2': 4.0**3.7}])\n        pdt.assert_frame_equal(spline_data[['sp1', 'sp2']], expected_splines[['sp1', 'sp2']])\n\n    def test_restricted_spline1(self, spline_data):\n        spline_data['rsp'] = spline(spline_data, 'v', n_knots=2, knots=[10, 16], restricted=True)\n        expected_splines = pd.DataFrame.from_records([{'rsp': 0.0},\n                                                      {'rsp': 0.0},\n                                                      {'rsp': 0.0},\n                                                      {'rsp': 5.0},\n                                                      {'rsp': 6.0}])\n        pdt.assert_series_equal(spline_data['rsp'], expected_splines['rsp'])\n\n    def test_restricted_spline2(self, spline_data):\n        spline_data['rsp'] = spline(spline_data, 'v', n_knots=2, knots=[5, 16], restricted=True)\n        expected_splines = pd.DataFrame.from_records([{'rsp': 0.0},\n                                                      {'rsp': 0.0},\n                                                      {'rsp': 10.0 - 5.0},\n                                                      {'rsp': 15.0 - 5.0},\n                                                      {'rsp': (20.0 - 5.0) - (20.0 - 16.0)}])\n        pdt.assert_series_equal(spline_data['rsp'], expected_splines['rsp'])\n\n    def test_restricted_spline3(self, spline_data):\n        spline_data['rsp'] = spline(spline_data, 'v', n_knots=2, knots=[5, 16], term=2, restricted=True)\n        expected_splines = pd.DataFrame.from_records([{'rsp': 0.0},\n                                                      {'rsp': 0.0},\n                                                      {'rsp': (10.0 - 5.0)**2 - 0},\n                                                      {'rsp': (15.0 - 5.0)**2 - 0},\n                                                      {'rsp': (20.0 - 5.0)**2 - (20.0 - 16.0)**2}])\n        pdt.assert_series_equal(spline_data['rsp'], expected_splines['rsp'])\n\n\nclass TestTable1:\n\n    @pytest.fixture\n    def data(self, n=1000):\n        df = pd.DataFrame()\n        np.random.seed(111)\n        df['exp'] = np.random.binomial(1, 0.5, size=n)\n        df['mod'] = np.random.binomial(1, 0.5, size=n)\n        df['y'] = np.random.binomial(1, size=n, p=logistic.cdf(0.1 + 0.2*df['exp'] + 0.3*df['mod'] -\n                                                               0.4*df['mod']*df['exp']))\n        df['continuous'] = np.random.normal(size=n)\n        return df\n\n    def test_unstratified_median(self, data):\n        t = table1_generator(data, cols=['exp', 'mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'category', 'continuous'])\n        assert isinstance(t, type(pd.DataFrame()))\n\n    def test_unstratified_mean(self, data):\n        t = table1_generator(data, cols=['exp', 'mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'category', 'continuous'],\n                             continuous_measure='mean')\n        assert isinstance(t, type(pd.DataFrame()))\n\n    def test_stratified_median(self, data):\n        t = table1_generator(data, cols=['mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'continuous'], strat_by='exp')\n        assert isinstance(t, type(pd.DataFrame()))\n\n    def test_stratified_mean(self, data):\n        t = table1_generator(data, cols=['mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'continuous'],\n                             continuous_measure='mean', strat_by='exp')\n        assert isinstance(t, type(pd.DataFrame()))\n\n    def test_catch_different_lengths(self, data):\n        with pytest.raises(ValueError):\n            table1_generator(data, cols=['exp', 'mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'continuous'],\n                             continuous_measure='A')\n\n    def test_wrong_continuous_measure_error(self, data):\n        with pytest.raises(ValueError):\n            table1_generator(data, cols=['exp', 'mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'category', 'continuous'],\n                             continuous_measure='A')\n        with pytest.raises(ValueError):\n            table1_generator(data, cols=['mod', 'y', 'continuous'],\n                             variable_type=['category', 'category', 'continuous'],\n                             continuous_measure='A', strat_by='exp')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_322","text":"\"\"\"\ntrkd_roi_analysis.py\n\nThis module run various anlyses on the tracked ROI USIs (Unexpected event\nSelectivity Indices).\n\nAuthors: <NAME>\n\nLast modified: 29 May 2021\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport scipy.stats as scist\nimport sys, copy, time\nimport itertools as it\n\nsys.path.extend(['..\/..'])\nfrom analysis import session\nfrom util import gen_util, math_util\n\n\n#############################################\n\ndef set_up_mouse_info(mouse_df_fnm):\n    \"\"\"\n    Returns mouse dataframe and mouse numbers.\n    \n    Parameters\n    ----------\n    mouse_df_fnm : string\n        File name for the dataframe that contains experiment information\n        \n    Returns\n    -------\n    mouse_df : Pandas DataFrame\n        Dataframe with mouse\/experiment information\n    mouse_ns_full : 1-D array of numbers\n        All mouse numbers\n    mouse_ns_sess_123 : 1-D array of numbers\n        Mouse numbers for mice with data from all of sessions 1-3\n    \"\"\"\n\n    # declarations\/initializations\n    mouse_df = pd.read_csv(mouse_df_fnm) \n    # Restrict to production mice that passed and have all files\n    mouse_df = mouse_df[(mouse_df.runtype=='prod') & (mouse_df.pass_fail=='P')\n                        & (mouse_df.all_files)]\n    # Obtain all mouse numbers\n    mouse_ns_full = mouse_df['mouse_n'].unique()\n    mouse_ns_sess_123 = []\n\n    print('All mice: ', mouse_ns_full)\n\n    for mouse_n in mouse_ns_full:\n        # Obtain session numbers for each mouse\n        sess_ns = mouse_df[(mouse_df.mouse_n==mouse_n)]['sess_n'].values\n        # Add mouse to mouse numbers with data from sess. 1-3\n        if np.sum(np.isin(sess_ns, np.asarray([1,2,3])))>=3:\n            mouse_ns_sess_123.append(mouse_n)\n        # Want mouse 8 as well for running.  will update pupil diameter later\n        elif mouse_n==8:\n            mouse_ns_sess_123.append(mouse_n)\n\n    mouse_ns_sess_123 = np.asarray(mouse_ns_sess_123)\n    print('Mice with all of sessions 1-3 :', mouse_ns_sess_123)\n    \n    return mouse_df, mouse_ns_full, mouse_ns_sess_123\n\n#############################################\n\ndef make_usi_df(stimtype, mouse_df, mouse_df_fnm, mouse_ns, datadir, \n                brk_dir = 'any', \n                op = 'd-prime', \n                only_matched_rois = True, \n                sess_ns = [1,2,3],\n                scale = True, \n                remnans = False):\n\n    \"\"\"\n    Returns a dataframe that contains, for each tracked ROI,\n    USI, mean and std of the df\/f for (un)expected events over each session.\n    \n    Parameters\n    ----------\n    stimtype : string\n        Either 'gabors' or 'bricks'.\n    mouse_df : Pandas DataFrame\n        Dataframe with mouse information\n    mouse_df_fnm : string\n        File name for 'mouse_df'\n    mouse_ns : 1-D arraylike of numbers\n        Contains all mouse numbers for which to obtain data\n    datadir : string\n        Data directory\n    brk_dir : string;  optional, default = 'any'\n        Options: 'right', 'left', 'temp', 'nasal' or 'any' (default).  Specify \n        brick direction if desired.\n    op : string; optional, default = 'd-prime'\n        Options: 'diff', 'discr', 'd-prime' (default).  Operation to use when \n        computing USIs.\n    only_matched_rois : boolean; optional, default = True\n        If 'True' (default), only USIs for ROIs that have been matched across \n        sessions (and contain no NaNs in any recorded session) are included.  \n        Else, USIs for all ROIs are included (excluding ROIs with NaN df\/f \n        values for any particular session if 'remnans' argument is set to True).\n    sess_ns : 1-D arraylike; optional, default = [1,2,3]\n        Which sessions to include for selected mice.\n    scale : boolean; optional, default = True\n        Option to scale each ROI by its statistics for each session.  Rescales \n        through an analog to a z-score, where the mean is replaced by the \n        median, and the standard deviation is replaced by the 5% to 95% \n        interval.  This allows ROIs to be treated more equally to others in a \n        given session, compensating for calcium signal issues, e.g.\n    remnans : boolean; optional, default = False\n        Option to discount ROIs that have NaN df\/f values.  Note, this is \n        redundant if 'only_matched_rois' is set to True.\n        \n    Returns\n    -------\n    usi_df (pd DataFrame) : Pandas dataframe \n        Contains, for each tracked ROI, USI, mean and std of the df\/f for \n        (un)expected events over each session\n        \n        Columns:\n            'mouse_n', 'layer', 'compartment' :\n                mouse number, layer, and compartment, respectively\n            'sess_<session>_usi' for <session> in [1,2,3] : \n                USI values for given sessions\n            'sess_<session>_expec_evnt_<statistic>' for <session> in [1,2,3], \n            <statistic> in ['mn', 'std'] : \n                mean and std of integrated df\/f for each ROI over all \n                expected events in sess. (D\/G frames or expected flow)\n            'sess_<session>_unexp_evnt_<statistic>' for <session> in [1,2,3], \n            <statistic> in ['mn', 'std'] : \n                mean and std of integrated df\/f for each ROI over all expected \n                events in sess. (U\/G frames or unexpected flow)\n    \"\"\"\n    \n    # declarations\/initializations\n    t = time.time()\n    layers_dict = {'L23-Cux2': 'L2\/3', 'L5-Rbp4': 'L5'}\n\n    tracked_roi_usi_df = \\\n        pd.DataFrame(columns=['mouse_n', 'layer', 'compartment',\n            'sess_1_usi', 'sess_2_usi', 'sess_3_usi',\n            'sess_1_expec_evnt_mn', 'sess_2_expec_evnt_mn', \n            'sess_3_expec_evnt_mn',\n            'sess_1_expec_evnt_std', 'sess_2_expec_evnt_std', \n            'sess_3_expec_evnt_std',\n            'sess_1_unexp_evnt_mn', 'sess_2_unexp_evnt_mn',\n            'sess_3_unexp_evnt_mn',\n            'sess_1_unexp_evnt_std', 'sess_2_unexp_evnt_std', \n            'sess_3_unexp_evnt_std'])\n\n    # Loop over all given mouse numbers\n    for idx, mouse_n in enumerate(mouse_ns):\n        # declarations\/initializations\n        unexp_mn = []\n        unexp_std = []\n        expec_mn = []\n        expec_std = []\n        usi = []\n        # Determine layer and compartment\n        layer = layers_dict[mouse_df[mouse_df['mouse_n']==mouse_n]['line'].\n            values[0]]\n        compartment = mouse_df[mouse_df['mouse_n']==mouse_n]['plane'].values[0]\n        for sess_n in sess_ns:\n            print('Mouse ', mouse_n, ', sess ', sess_n)\n            # Obtain session object\n            sessid = mouse_df[(mouse_df['mouse_n']==mouse_n) & \n                              (mouse_df['sess_n']==sess_n)]['sessid'].values[0]\n            sess = session.Session(datadir, sessid, \n                only_matched_rois=only_matched_rois)\n            sess.extract_sess_attribs(mouse_df=mouse_df_fnm)\n            sess.extract_info(fulldict=False, roi=True, run=False, pupil=False) \n            roi_data = []\n            # Get expected event data\n            expec_data = get_roi_data(sess, stimtype, surp=0, brk_dir=brk_dir,\n                scale=scale, remnans=remnans)\n            expec_data_mn = np.nanmean(expec_data, axis=1)\n            expec_data_std = np.nanstd(expec_data, axis=1)\n            expec_mn.append(expec_data_mn)\n            expec_std.append(expec_data_std)\n            roi_data.append(expec_data)\n            # Get unexpected event data\n            unexp_data = get_roi_data(sess, stimtype, surp=1, brk_dir=brk_dir,\n                scale=scale, remnans=remnans)\n            unexp_data_mn = np.nanmean(unexp_data, axis=1)\n            unexp_data_std = np.nanstd(unexp_data, axis=1)\n            unexp_mn.append(unexp_data_mn)\n            unexp_std.append(unexp_data_std)\n            roi_data.append(unexp_data)\n            print('unexp_data.shape = ', unexp_data.shape)\n            # Compute USI\n            # Direct computation\n            usi.append((unexp_data_mn - expec_data_mn) \/ \n                        np.sqrt(0.5*(unexp_data_std**2 + expec_data_std**2)))\n\n            # Below is equivalent to above directly computed line (no \n            # permutations needed here). Note: no need for distribution\n#             unexp_idxs, _, _ = surp_idx_by_sess(\n#                 roi_data, n_perms=0, datatype='roi', op=op, nanpol=None)\n#             usi.append(unexp_idxs)\n\n            print('{:.2f} sec'.format(time.time()-t))\n\n        tracked_roi_usi_df.loc[idx] = [mouse_n, layer, compartment,\n                                       usi[0], usi[1], usi[2],\n                                       expec_mn[0], expec_mn[1], expec_mn[2],\n                                       expec_std[0], expec_std[1], expec_std[2],\n                                       unexp_mn[0], unexp_mn[1], unexp_mn[2],\n                                       unexp_std[0], unexp_std[1], unexp_std[2]]\n\n    return tracked_roi_usi_df\n\n#############################################\n\ndef get_roi_data(sess, stimtype, surp, brk_dir, scale, remnans):\n    \"\"\"\n    Returns 2-D array of integrated df\/f for each ROI and segment.  Segments are \n    frames D-G or U-G (both comprise 0.6 sec each) for Gabors and the 2 sec \n    immediately pre- or proceeding the onset of unexpected flow.\n    \n    Parameters\n    ----------\n    sess : session object\n        Session object for particular mouse\/session\n    stimtype : string\n        Options: 'gabors', 'bricks'\n    brk_dir : string\n        Options: 'right', 'left', 'temp', 'nasal' or 'any' (default).  Specify \n        brick direction if desired\n    scale : boolean; optional, default = True\n        Option to scale each ROI by its statistics for each session.  Rescales \n        through an analog to a z-score, where the mean is replaced by the \n        median, and the standard deviation is replaced by the 5% to 95% \n        interval.  This allows ROIs to be treated more equally to others in a \n        given session, compensating for calcium signal issues, e.g.\n    remnans : boolean; optional, default = False\n        Option to discount ROIs that have NaN df\/f values.  Note, this is \n        redundant if 'only_matched_rois' is set to True.\n    \n    Returns\n    -------\n    roi_data : 2-D array of numbers\n        Integated df\/f for each ROI for each segment (frames D\/U-G or 2s \n        immediately before or after onset of unexpected flow). \n        Rows: ROIs.  Columns: Segments (\/sequences)\n    \"\"\"\n    \n    # Warameters:\n    # Width for brick stim-locked traces = 2*half_width\n    half_width = 2\n    # Pre \/ post times, organized by stimulus and surprise\n    pre_dict = {'gabors':[0,0], 'bricks':[half_width,0]}\n    post_dict = {'gabors':[0.6,0.6], 'bricks':[0,half_width]}\n    pre = pre_dict[stimtype][surp]\n    post = post_dict[stimtype][surp]\n    # Only get segements around counterflow onset\n    surp = 1 if stimtype=='bricks' else surp \n    \n    # Obtain ROI data\n    stim = sess.get_stim(stimtype)\n    seg_ns = \\\n        stim.get_segs_by_criteria(surp=surp, gabk=16, gabfr=3, \n                                  bri_size=128, bri_dir=brk_dir, by=\"seg\", \n                                  remconsec=(stimtype == \"bricks\"))\n    twop_fr_ns = \\\n        stim.get_twop_fr_by_seg(seg_ns, first=True, \n                                ch_fl=[pre, post])['first_twop_fr']\n    roi_data_df = \\\n        stim.get_roi_data(twop_fr_ns, pre=pre, post=post, integ=True, \n                          scale=scale, remnans=remnans)\n    # Roi x seq (time is already integrated out):\n    roi_data = gen_util.reshape_df_data(roi_data_df, squeeze_rows=False, \n        squeeze_cols=True)\n    \n    return roi_data\n\n#############################################\n\ndef surp_idx_by_sess(data, n_perms=1000, datatype='roi', op='diff', \n                     stats='mean', nanpol=None):\n    \"\"\"\n    surp_idx_by_sess(data)\n    \n    Returns session item (ROIs or 1 for running) indices for difference between \n    surprise and regular sequences, as well as their percentiles based on \n    random permutations for each item.\n\n    Required args:\n        - data (3D array): data array, structured as \n                               reg, surp [x ROIs] x sequences \n\n    Optional args:\n        - n_perms (int)         : number of permutations for CI estimation\n                                  default: 1000\n        - datatype (str)        : type of data (e.g., 'roi', 'run')\n                                  default: 'roi'\n        - op (str)              : operation to use in measuring surprise \n                                  indices ('diff', 'rel_diff', 'discr')\n                                  default: 'diff'\n        - stats (str)           : statistic used across sequences\n                                  default: 'mean'\n        - nanpol (str)          : NaN policy ('omit' or None)\n                                  default: None\n\n    Returns:\n        - item_idxs (1-D array) : item (ROIs or 1 for running) surprise indices \n                                 for the session\n        - item_percs (1-D array): item (ROIs or 1 for running) surprise index \n                                 percentiles for the session, based on \n                                 each item's random permutations\n        - all_rand (2-D array)  : item (ROIs or 1 for running) indices \n                                 calculated through randomized permutation, \n                                    structured as item x n_perms\n    \"\"\"\n    \n    # take statistic across sequences, unless the index id discr (D')\n    if op != 'discr' and op != 'd-prime':\n        seq_mes = np.stack([math_util.mean_med(\n            subdata, stats=stats, axis=-1, nanpol=nanpol) \n            for subdata in data])\n        axis = None\n    else:\n        seq_mes = data\n        axis = -1\n\n    # calculate index\n    item_idxs = math_util.calc_op(seq_mes, op=op, nanpol=nanpol)\n\n    # reshape to add an item\/channel dimension if datatype isn't ROIs\n    last_dim = np.sum([sub.shape[-1] for sub in data])\n    if datatype != 'roi':\n        item_idxs = np.asarray(item_idxs).reshape(-1)\n        targ = (1, last_dim)\n    else:\n        targ = (-1, last_dim)\n\n    # get CI\n    div = data[0].shape[-1] # length of reg\n    # perms (items x perms)\n    all_rand = math_util.permute_diff_ratio(\n        np.concatenate(data, axis=-1).reshape(targ), div=div, \n        n_perms=n_perms, stats=stats, nanpol=nanpol, op=op)\n\n    item_percs = np.empty(len(item_idxs))\n    for r, (item_idx, item_rand) in enumerate(zip(item_idxs, all_rand)):\n        item_percs[r] = scist.percentileofscore(\n            item_rand, item_idx, kind='mean')\n    \n    return item_idxs, item_percs, all_rand\n\n#############################################\n\ndef make_usi_abs_mean_df(gab_df, brk_df, stimtype_list, n_perm):\n    \"\"\"\n    Returns dataframe of the mean |USI| values over ROIs for each session, the \n    p-values for each session pair comparison, and the Bonferroni-corrected \n    significance level of each.\n    \n    Parameters\n    ----------\n    gab_df : Pandas DataFrame\n        Dataframe of USIs for Gabor stimulus\n    brk_df : Pandas DataFrame\n        Dataframe of USIs for visual flow (bricks) stimulus\n    stimtype_list : list of strings\n        Contains stimuli over which to compute values\n    n_perm : number\n        Number of permutations to use to compute p-values for intersession \n        comparisons\n    \n    Returns\n    -------\n    df : Pandas DataFrame\n        Dataframe with mean |USI| session values and comparisons\n        \n        Columns:\n            'layer', 'compartment', 'stimtype' :\n                layer, compartment, and stimulus type, respectively\n            'usi_abs_mn_<session n>' :  \n                <|USI|>, where the average is taken over ROIs\n            'usi_abs_mn_raw_p__<sess m>_<sess n>' :  \n                raw p-value of <|USI|> between sessions m and n\n            'usi_sig_for_abs_mn__<sess m>_<sess n>' :  \n                (Bonferroni-) corrected significance level for <|USI|> between \n                sessions m and n\n    \"\"\"\n    \n    # declarations\/initializations\n    sess_ns = [1,2,3]\n    bonf_n = 12\n    alpha_001 = 0.001\/bonf_n\n    alpha_01  = 0.01\/bonf_n\n    alpha_05  = 0.05\/bonf_n\n    df = pd.DataFrame(\n        columns = ['layer', 'compartment', 'stimtype',\n                   'usi_abs_mn_1', 'usi_abs_mn_2', 'usi_abs_mn_3',\n                   'usi_abs_mn_raw_p__1_2', 'usi_abs_mn_raw_p__2_3', \n                   'usi_abs_mn_raw_p__1_3',\n                   'usi_sig_for_abs_mn__1_2', 'usi_sig_for_abs_mn__2_3',\n                   'usi_sig_for_abs_mn__1_3'])\n    df_dict = {'gabors':gab_df, 'bricks':brk_df}\n    idx = -1\n\n    # Loop through stimulus types, compartments\/layers and sessions\n    for stimtype in stimtype_list:\n        for compartment in ['dend', 'soma']:\n            for layer in ['L2\/3', 'L5']:\n                # declarations\/initializations\n                usi_df = df_dict[stimtype]\n                idx+=1\n                print(layer, compartment)\n                # Set masks to desired layer\/compartment\n                mask0 = usi_df['layer']==layer\n                mask1 = usi_df['compartment']==compartment\n                usis = []\n                usi_abs_mn = []\n                usi_abs_mn_pval = []\n                usi_sig_abs_mn_pval = []\n                # Obtain USIs and calculate the mean over ROIs of their absolute \n                #  values for each session\n                for sess_n in sess_ns:\n                    usis.append(np.hstack(usi_df[(mask0 & mask1)]\n                                          ['sess_{}_usi'.format(sess_n)].\n                                          values))\n                    usi_abs_mn.append(np.nanmean(np.abs(usis[-1])))\n                # Compute the p-value for the mean of the absolute values by \n                #  shuffling all session pairs\n                usi_abs_mn_pval = compute_usi_abs_mn_pval(usis, usi_abs_mn, \n                    n_perm, metric='abs_mean')\n                # Determine the significance levels\n                for pval in usi_abs_mn_pval:\n                    if pval <= alpha_001:\n                        pval_str = '<= 0.001'\n                    elif pval <= alpha_01:\n                        pval_str = '<= 0.01'\n                    elif pval <= alpha_05:\n                        pval_str = '<= 0.05'\n                    else:\n                        pval_str = 'False'\n                    usi_sig_abs_mn_pval.append(pval_str)\n                df.loc[idx] = [layer, compartment, stimtype,\n                               usi_abs_mn[0], usi_abs_mn[1], usi_abs_mn[2],\n                               usi_abs_mn_pval[0], usi_abs_mn_pval[1], \n                               usi_abs_mn_pval[2],\n                               usi_sig_abs_mn_pval[0], usi_sig_abs_mn_pval[1], \n                               usi_sig_abs_mn_pval[2]]\n\n            \n    \n    return df\n\n#############################################\n\ndef compute_usi_abs_mn_pval(usis, usi_scalar, n_perm, metric='abs_mean'):\n    \"\"\"\n    Compute p-values of <|USI|> across sessions by shuffling pairs\n    \n    Parameters\n    ----------\n    usis : list of 1-D arrays of numbers\n        usis[i] = 1-D array of USIs for session i for all mice in a particular \n        layer\/compartment\/stimulus type\n    usi_scalar : list of numbers\n        Specifies the scalar metric for a given session.  Can be, e.g., \n        variance.  See options below in 'metric'.  E.g., usi_scalar[i] can be \n        mean of USIs for session i\n    n_perm : number \n        Number of permutations\n    metric : string; optional, default = 'abs_mean'\n        Options: 'var', 'mean', 'abs_mean'. Scalar metric of USIs used in \n        'usi_scalar', above. Used to determine what scalar metric to use with \n        shuffled USIs.\n    \n    Returns\n    -------\n    usi_scalar_pval : list of numbers\n        P-values for chosen scalar (var, mean, |mean|).  In order, compares \n        sessions 1&2, 2&3, and 1&3\n    \"\"\"\n    \n    # declarations\/initializations\n    diff_distro = []; \n    usi_scalar_pval = []; \n    # Compute differences:\n    usi_diff = [usi_scalar[0]-usi_scalar[1],\n                usi_scalar[1]-usi_scalar[2],\n                usi_scalar[0]-usi_scalar[2]]\n    for _ in range(int(n_perm)):\n        usi_perm = []\n        # Make into array, with each column corresponding to a different session\n        usi_arr = np.asarray(usis).transpose() \n        # Vector of which session (column) to take from usi_arr:\n        rand_sess = \\\n            np.random.choice(range(usi_arr.shape[1]), \n                             size=usi_arr.shape[0], replace=True)\n        roi_idx = range(usi_arr.shape[0])\n        # Use above to select 2 of the 3 random sessions from usi_arr\n        usi_perm.append(usi_arr[roi_idx, rand_sess])\n        direc = np.random.choice([-1,1], size=usi_arr.shape[0], replace=True)\n        usi_perm.append(usi_arr[roi_idx, np.mod(rand_sess + direc, 3)])\n        # Compute a differences of metrics from the distributions\n        if metric=='var':\n            diff_distro.append(np.nanvar(usi_perm[0]) - np.nanvar(usi_perm[1]))\n        elif metric=='mean':\n            diff_distro.append(np.nanmean(usi_perm[0]) - \n                               np.nanmean(usi_perm[1]))\n        elif metric=='abs_mean':\n            diff_distro.append(np.nanmean(np.abs(usi_perm[0])) - \n                               np.nanmean(np.abs(usi_perm[1])))\n    diff_distro = np.asarray(diff_distro)\n    \n    for i in range(len(usi_scalar)):\n        usi_scalar_pval.append(compute_2_tailed_pval(usi_diff[i], diff_distro))\n    \n    return usi_scalar_pval\n\n#############################################\n\ndef compute_2_tailed_pval(value, distro):\n    \"\"\"\n    Compute 2-tailed p-value \n    \n    Parameters\n    ----------\n    value : number\n        value for which to ascertain the p-value\n    distro : 1-D array of numbers\n        computed distribution against which to compare 'value' to ascertain the \n        p-value\n    \n    Returns\n    -------\n    pval : number\n        computed 2-tailed p-value\n    \"\"\"\n    distro = np.asarray(distro)\n    n_perm_idcs = distro.size\n    # Form array of indices where 'value' is no greater than the distribution \n    #  values\n    perm_idcs_larger = np.where(distro >= value)[0]\n    # The probability is then the raio of the length of this array to the \n    #  distribution size\n    pval = len(perm_idcs_larger) \/ n_perm_idcs\n    # 2-tailed correction\n    if pval > 0.5:\n        pval = 1-pval\n    pval *= 2\n    if np.isnan(value):\n        pval = np.nan\n    \n    return pval\n\n#############################################\n\ndef make_usi_abs_frac_chng_df(gab__tracked_roi_usi_df, brk__tracked_roi_usi_df, \n                              n_perm, n_bstrap):\n    \"\"\"\n    Returns dataframe containing fractional chng from session 1 to 3 of the \n    <|USIs|> over ROIs for Gabors and visual flow, along with their \n    uncertainties (bootstrapped stdev) and p-value of the difference between the \n    Gabor and visual flow chng for each layer\/compartment\n    \n    Parameters\n    ----------\n    gab__tracked_roi_usi_df : Pandas DataFrame\n        Dataframe containing tracked usi for each \n        mouse\/layer\/compartment\/session for the Gabor stimulus\n    brk__tracked_roi_usi_df : Pandas DataFrame\n        Dataframe containing tracked usi for each \n        mouse\/layer\/compartment\/session for the bricks stimulus\n    n_perm : number\n        Number of permutations to perform to compare Gabors against visual flow\n    n_bstrap : number\n        Number of resamplings with replacement to do\n    \n    Returns\n    -------\n    usi_chng_df : Pandas DataFrame\n        Dataframe with <|USIs|> (over ROIs) fractional chng from sess 1 to 3, \n        and comparisons across stimuli\n        \n        Columns:\n            'layer', compartment, 'sess_compare' : \n                layer, compartment, and sessions compared, respectively\n            'gab_mn_abs_frac_chng' : \n                Gabor fractional chng in <|USIs|> from sess 1 to 3\n            'brk_mn_abs_frac_chng' : \n                Bricks fractional chng in <|USIs|> from sess 1 to 3\n            'pval_raw' : \n                Raw p-value comparing Gabor and brick fractional changes\n            'gab_bstrap_std' : \n                Bootstrapped stdev for 'gab_mn_abs_frac_chng'\n            'brk_bstrap_std' : \n                Bootstrapped stdev for 'brk_mn_abs_frac_chng'\n    \"\"\"\n    \n    # declarations\/initializations\n    sess_compare = [1,3]\n    compartment_list = ['dend', 'soma', 'all']\n    layer_list = ['L2\/3', 'L5', 'all']\n    usi_chng_df = pd.DataFrame(columns=['layer', 'compartment', 'sess_compare', \n                                        'gab_mn_abs_frac_chng', \n                                        'brk_mn_abs_frac_chng',\n                                        'pval_raw', 'gab_bstrap_std', \n                                        'brk_bstrap_std'])\n    idx = -1\n    # Loop through compartments and layers to get data for each\n    for layer, compartment in it.product(layer_list, compartment_list):\n        if layer == 'all' and compartment != 'all':\n            continue\n        if layer != 'all' and compartment == 'all':\n            continue\n        print(layer, compartment)\n        idx+=1\n        # Obtain fractional changes and ROI pairs across sessions and \n        #  layers\/compartments if layer is 'all' for statistical testing\n        gab_frac_chng, brk_frac_chng, gab_usi_lay_comp, brk_usi_lay_comp = \\\n            get_usi_abs_frac_chng(gab__tracked_roi_usi_df, \n                                  brk__tracked_roi_usi_df, \n                                  layer, compartment, sess_compare)\n        # Compute p-value\n        pval = \\\n            compute_usi_abs_frac_chng_pval(gab_usi_lay_comp, brk_usi_lay_comp, \n                                           gab_frac_chng, brk_frac_chng, \n                                           n_perm=n_perm)\n        # Compute uncertainty\n        gab_std, brk_std = \\\n            compute_usi_abs_frac_chng_err(gab_usi_lay_comp, brk_usi_lay_comp, \n                                          n_bstrap=n_bstrap)        \n        # Add data to dataframe\n        usi_chng_df.loc[idx] = [layer, compartment, sess_compare,\n                                gab_frac_chng, brk_frac_chng, \n                                pval, gab_std, brk_std]    \n    \n    return usi_chng_df\n\n#############################################\n\ndef get_usi_abs_frac_chng(gab__tracked_roi_usi_df, brk__tracked_roi_usi_df,\n                          layer, compartment, sess_compare):\n    '''\n    Get absolute fractional changes of <|USIs|> (over ROIs) from sess \n    sess_compare[0] (usually sess 1) to sess_compare[1] (usually sess 3) for \n    Gabors and visual flow, along with the associated USI pairs for \n    Gabors\/bricks for each session in order to shuffle stimulus labels to later \n    obtain p-values when comparing Gabors and visual flow.\n\n    Parameters\n    ----------\n    gab__tracked_roi_usi_df : Pandas DataFrame\n        Dataframe containing tracked usi for each \n        mouse\/layer\/compartment\/session for the Gabor stimulus\n    brk__tracked_roi_usi_df : Pandas DataFrame\n        Dataframe containing tracked usi for each \n        mouse\/layer\/compartment\/session for the bricks stimulus\n    layer : string\n        Layer for which to obtain data\n    compartment : string\n        Compartment for which to obtain data\n    sess_compare : 1-D arraylike of numbers\n        Sessions for which to obtain data\n        \n    Returns\n    -------\n    gab_abs_usi_frac_chng : 1-D list of numbers\n        Absolute fractional change from sess_compare[0] to sess_compare[1] in \n        <|USIs|> over ROIs for Gabors. Note, only 1 number in list unless \n        looking at all layers\/compartments\n    brk_usi_abs_frac_chng : 1-D list of numbers\n        Absolute fractional change from sess_compare[0] to sess_compare[1] in \n        <|USIs|> over ROIs for visual flow. Note, only 1 number in list unless \n        looking at all layers\/compartments\n    gab_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all').  \n        Next: Sessions. Inner: USIs for tracked ROIs\n    brk_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all'). \n        Next: Sessions. Inner: USIs for tracked ROIs\n    '''\n\n    # declarations\/initializations\n    layer_list = ['L2\/3', 'L5']\n    compartment_list = ['dend', 'soma']\n    gab_abs_usi_frac_chng = []\n    brk_usi_abs_frac_chng = []\n    gab_usi_lay_comp = []\n    brk_usi_lay_comp = []\n\n    # Unless we're processing all of the layers\/compartments together, no reason \n    #  to loop\n    if layer != 'all':\n        layer_list = [layer]\n        compartment_list = [compartment]\n    # Loop over chosen layers\/compartments (trivial loops unless looking at all \n    #  layers\/compartments)    \n    for layer, compartment in it.product(layer_list, compartment_list):\n        # declarations\/initializations\n        gab_usi_pairs = []\n        brk_usi_pairs = []\n        # Obtain data for each session that we want to compare\n        for sess_n in sess_compare:\n            # Obtain sub-dataframes limited to chosen layer\/compartment\n            mask0 = gab__tracked_roi_usi_df['layer']==layer\n            mask1 = gab__tracked_roi_usi_df['compartment']==compartment\n            gab_df = gab__tracked_roi_usi_df[mask0 & mask1]\n            mask0 = brk__tracked_roi_usi_df['layer']==layer\n            mask1 = brk__tracked_roi_usi_df['compartment']==compartment\n            brk_df = brk__tracked_roi_usi_df[mask0 & mask1]\n            # Obtain the USI values for Gabor \/ bricks for each session\n            gab_usi_pairs.append(np.hstack(gab_df['sess_{}_usi'.format(sess_n)].\n                                           values))\n            brk_usi_pairs.append(np.hstack(brk_df['sess_{}_usi'.format(sess_n)].\n                                           values))\n        # Amalgamate USIs across layers\/compartments (for 'all')\n        gab_usi_lay_comp.append(gab_usi_pairs)\n        brk_usi_lay_comp.append(brk_usi_pairs)    \n        # compute absolute fractional change across sessions for <|USI|> over \n        #  ROIs for Gabors\n        mean0 = np.nanmean(np.abs(gab_usi_pairs[0]))\n        mean1 = np.nanmean(np.abs(gab_usi_pairs[1]))\n        gab_abs_usi_frac_chng.append(np.abs((mean1-mean0)\/mean0))\n        # compute absolute fractional change across sessions for <|USI|> over \n        #  ROIs for visual flow\n        mean0 = np.nanmean(np.abs(brk_usi_pairs[0]))\n        mean1 = np.nanmean(np.abs(brk_usi_pairs[1]))\n        brk_usi_abs_frac_chng.append(np.abs((mean1-mean0)\/mean0))\n\n    return gab_abs_usi_frac_chng, brk_usi_abs_frac_chng, gab_usi_lay_comp, \\\n           brk_usi_lay_comp\n\n#############################################\n\ndef compute_usi_abs_frac_chng_pval(gab_usi_lay_comp, brk_usi_lay_comp,\n                                   gab_frac_chng, brk_frac_chng, n_perm):\n    \"\"\"\n    Compute p-values for <|USI|> (over ROIs) |fractional changes| across \n    sessions by shuffling stimulus labels\n    \n    Parameters\n    ----------\n    gab_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all').  \n        Next: Sessions. Inner: USIs for tracked ROIs\n    brk_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all').  \n        Next: Sessions. Inner: USIs for tracked ROIs\n    gab_abs_usi_frac_chng : 1-D list of numbers\n        Absolute fractional change from sess_compare[0] to sess_compare[1] in \n        <|USIs|> over ROIs for Gabors. Note, only 1 number in list unless \n        looking at all layers\/compartments\n    brk_usi_abs_frac_chng : 1-D list of numbers\n        Absolute fractional change from sess_compare[0] to sess_compare[1] in \n        <|USIs|> over ROIs for visual flow. Note, only 1 number in list unless \n        looking at all layers\/compartments\n    n_perm : number\n        Number of shuffles to perform\n\n    Returns\n    -------\n    pval : number\n        P-value of difference between |fractional changes| across sessions of \n        <|USI|> over ROIs for Gabors vs. bricks\n    \"\"\"\n    \n    # declarations\/initializations\n    n_perm = int(n_perm)\n    gab_brk_distro = []\n    # Permutations loop\n    for _ in range(n_perm):\n        # declarations\/initializations\n        gab_perm_pair_mn = []\n        gab_frac_chng_perm = []\n        brk_perm_pair_mn = []\n        brk_frac_chng_perm = []\n        # Get USIs for each layer\/compartment (just one iteration if layer not \n        #  'all')\n        for i in range(len(gab_usi_lay_comp)):\n            gab_usi_pair = gab_usi_lay_comp[i]\n            brk_usi_pair = brk_usi_lay_comp[i]\n            # Shuffle stimulus labels for each session\n            for j in range(len(gab_usi_pair)):\n                # Arrange USIs as columns, one column per stimulus type\n                arr = np.vstack((gab_usi_pair[j],brk_usi_pair[j])).transpose()\n                # Index ROIs\n                roi_idx = range(arr.shape[0])\n                # Randomly pick 1st or 2nd column of array\n                col = np.random.choice(range(arr.shape[1]), size=len(roi_idx), \n                                       replace=True)\n                # Obtain <|USI|> (over ROIs) with shuffled stimulus labels\n                gab_perm_pair_mn.append(np.nanmean(np.abs(arr[roi_idx, col])))\n                brk_perm_pair_mn.append(np.nanmean(np.abs(arr[roi_idx, \n                                                          np.mod(col+1,2)])))\n            # Compute |fractional change| across session for shuffled <|USI|>\n            gab_frac_chng_perm.append(\n                np.abs((gab_perm_pair_mn[1]-gab_perm_pair_mn[0]) \/ \n                       gab_perm_pair_mn[0]))\n            brk_frac_chng_perm.append(\n                np.abs((brk_perm_pair_mn[1]-brk_perm_pair_mn[0]) \/ \n                       brk_perm_pair_mn[0]))\n        # Add difference of distributions (averaged over layers\/compartments if \n        #  layer is 'all') to shuffled distribution\n        gab_brk_distro.append(\n            np.mean(gab_frac_chng_perm) - np.mean(brk_frac_chng_perm))\n\n    gab_brk_distro = np.asarray(gab_brk_distro)\n    # Compute difference and p-value\n    diff = np.mean(gab_frac_chng) - np.mean(brk_frac_chng)\n    pval = compute_2_tailed_pval(diff, gab_brk_distro)\n\n    return pval\n\n#############################################\n\ndef compute_usi_abs_frac_chng_err(gab_usi_lay_comp, brk_usi_lay_comp, \n                              n_bstrap=1e3):\n\n    \"\"\"\n    Compute uncertainty for <|USI|> (over ROIs) |fractional change| \n    \n    Parameters\n    ----------\n    gab_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all'). \n        Next: Sessions. Inner: USIs for tracked ROIs\n    brk_usi_lay_comp : 3-D list of numbers\n        Outer: Layers\/compartments (just 1 entry if layer not 'all').  \n        Next: Sessions. Inner: USIs for tracked ROIs\n    n_bstrap : number; optional, default = 1e3\n        Number of resamplings with replacement to do\n    \n    Returns\n    -------\n    gab_bstrap_std : number\n        Standard deviation of distribution of <|USI|> (over ROIs) \n        |fractional change| obtained via resampling with replacement from each \n        session's USIs for Gabors.\n    brk_bstrap_std : \n        Standard deviation of distribution of <|USI|> (over ROIs) \n        |fractional change| obtained via resampling with replacement from each \n        session's USIs for Gabors.\n    \"\"\"\n    \n    # declarations\/initializations\n    n_bstrap = int(n_bstrap)\n    gab_brk_distro = []\n    gab_bstrap_pair_mn = []\n    brk_bstrap_pair_mn = []\n    # Loop over layers\/compartments (1 iteration if layer not 'all')\n    for i in range(len(gab_usi_lay_comp)):\n        # Obtain USI pairs (across sessions) for each stimulus for \n        #  layer\/compartment\n        gab_usi_pairs = gab_usi_lay_comp[i]\n        brk_usi_pairs = brk_usi_lay_comp[i]\n        # Loop over sessions\n        for j in range(len(gab_usi_pairs)):\n            # Sample with replacement\n            gab_bstrap = \\\n                np.random.choice(gab_usi_pairs[j], size=(len(gab_usi_pairs[j]), \n                                 n_bstrap), replace=True)\n            brk_bstrap = \\\n                np.random.choice(brk_usi_pairs[j], size=(len(brk_usi_pairs[j]), \n                                 n_bstrap), replace=True)\n            # Compute average over ROIs of |USIs|\n            gab_bstrap_pair_mn.append(np.mean(np.abs(gab_bstrap), axis=0))\n            brk_bstrap_pair_mn.append(np.mean(np.abs(brk_bstrap), axis=0))\n        # Compute |fractional change| of <|USI|>\n        gab_frac_chng = \\\n            np.abs((gab_bstrap_pair_mn[1]-gab_bstrap_pair_mn[0]) \/ \n                   gab_bstrap_pair_mn[0])\n        brk_frac_chng = \\\n            np.abs((brk_bstrap_pair_mn[1]-brk_bstrap_pair_mn[0]) \/ \n                   brk_bstrap_pair_mn[0])\n    # Uncertainty\n    gab_bstrap_std = np.std(gab_frac_chng)\n    brk_bstrap_std = np.std(brk_frac_chng)\n    \n    return gab_bstrap_std, brk_bstrap_std\n\n#############################################\n\ndef make_usi_corr_df(tracked_roi_usi_df, usi_corr_df, stimtype, usi_base_sess=1, \n                     n_perm=1e4, n_bstrap=1e4):\n    \"\"\"\n    Returns a dataframe that contains, for each compartment and layer, the raw \n    and residual USI correlations (i.e., correlations between usi_{day m} vs. \n    Delta(USI) = usi_{day m+1} - usi_{day m} for m = 1 or 2), the bounds of the \n    standard deviation for the residual correlations and 95% confidence interval \n    for the null distribution of the residual correlations, the raw p-value \n    (multiply by 8 = Bonferroni N for corrected p-value), and the corrected \n    significance level.  \n    \n    For inspection convenience, the variables used to determine the \n    correlations, the raw shuffled correlation distribution, and the raw \n    bootstrapped distribution are included as well.\n    \n    Parameters\n    ----------\n    tracked_roi_usi_df : Pandas DataFrame\n        Dataframe with tracked ROI USIs and statistics\n    usi_corr_df : Pandas DataFrame\n        Dataframe with correlation information of USIs across sessions.  See \n        below under 'Returns' \n    stimtype : string\n        Stimulus type ('gabors' or 'bricks')\n    usi_base_sess : number; optional, default = 1\n        Session to obtain USIs and against which to compare delta(USI) with \n        usi_base_sess+1\n    n_perm : number; optional, default = 1e4\n        Number of permutations to perform to compare Gabors against visual flow\n    n_bstrap : number; optional, default =1e4\n        Number of resamplings with replacement to do\n\n    Returns\n    -------\n    usi_corr_df (pd DataFrame) : dataframe that contains, for each \n        layer\/compartment, data on the correlations between the USI in 1 session \n        and change in USI by the next session\n        \n        Columns:\n            stimtype, layer, compartment : \n                stimulus type (gabor \/ bricks), layer, and compartment, \n                respectively\n            usi_base_sess : \n                session USI obtained from difference in USIs taken from this and \n                subsequent sessions\n            corr_raw : \n                raw correlation between USI and Delta(USI)\n            corr_resid : \n                normalized residual correlation\n            corr_resid_low_sd, corr_resid_high_sd : \n                interval of bootstrapped correlation std dev (\/err)\n            corr_resid_null_low_ci, corr_resid_null_high_ci : \n                interval of 95% CI of null resid corr\n            pval_raw : \n                raw p-value of correlation.  Corrected p-value = 8*pval_raw, \n                where 8 = the Bonferroni N\n            sig_correc : \n                (bonferroni-) corrected significance level\n            usi, delta_usi : \n                USI and Delta(USI).  Correlation of these variables = \n                'corr_raw'.  For inspection if desired\n            corr_raw_distro : \n                raw correlation distribution obtained by shuffling session \n                labels.  Used to obtain p-value. For inspection if desired\n            bstrap_raw_distro : \n                raw correlation bootstrapped distribution, used to obtain \n                standard error. For inspection if desired\n    \"\"\"\n\n    # declarations\/initializations\n    bonf_n = 8\n    alpha_001 = 0.001\/bonf_n\n    alpha_01  = 0.01\/bonf_n\n    alpha_05  = 0.05\/bonf_n\n    \n    idx = usi_corr_df.shape[0]\n    layers = {'L23-Cux2':'L2\/3', 'L5-Rbp4':'L5'}\n    lc = list(it.product(layers.values(), ['dend', 'soma']))\n\n    # Loop through layers and compartments\n    for i, (l,c) in enumerate(lc):\n        print(c, l)\n\n        # declarations\/initializations\n        usi                   = []\n        corr_raw_distro       = []\n        error_corr_raw_distro = []\n        mask0 = tracked_roi_usi_df['compartment']==c\n        mask1 = tracked_roi_usi_df['layer']==l\n        usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_1_usi']) )\n        usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_2_usi']) )\n        usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_3_usi']) )\n\n        # Find correlation between USI and delta(USI)\n        x = usi[usi_base_sess-1]\n        x2 = usi[usi_base_sess]\n        y = x2 - x\n        corr_raw = scist.pearsonr(x, y)[0]\n\n        # Permuation and bootstrap loop\n        roi_idx = range(x.size)\n        loop_length = int(max(n_perm, n_bstrap))\n        for i_perm in range(loop_length):\n            # Shuffle session labels for USIs\n            if i_perm < n_perm:\n                # ROIs x sessions\n                arr = np.asarray(usi).transpose()\n                # Row 1: roi indexes; row 2: randomly chosen session\n                sess_col = np.random.choice([0,1,2], x.size)\n                # USIs from randomly chosen session\n                usi1_perm = arr[roi_idx, sess_col]\n                # USIs from randomly chosen remaining session (periodic boundary \n                #  conditions)\n                direction  = np.random.choice([-1,1], x.size)\n                usi2_perm = arr[roi_idx,np.mod(sess_col+direction,3)]\n                # compute pearson from shuffled USIs and add to shuffled distro\n                x_perm = usi1_perm\n                y_perm = usi2_perm - usi1_perm\n                corr_raw_distro.append(scist.pearsonr(x_perm, y_perm)[0])\n            # Bootstrapped standard deviation (~ standard error of correlation)\n            if i_perm < n_bstrap:\n                # sample from ROI indices with replacement\n                samp_idxs = np.random.choice(roi_idx, x.size, replace=True)\n                x_bstrap = x[samp_idxs]\n                y_bstrap = y[samp_idxs]\n                error_corr_raw_distro.append(scist.pearsonr(x_bstrap, y_bstrap)\n                                             [0])            \n    \n        # Compute correlation p-value, normalized value, and standard deviation\n        corr_raw_distro = np.asarray(corr_raw_distro)\n        error_corr_raw_distro = np.asarray(error_corr_raw_distro)\n        pval_raw = compute_2_tailed_pval(corr_raw, corr_raw_distro)\n        if pval_raw <= alpha_001:\n            pval_correc_str = '<= 0.001'\n        elif pval_raw <= alpha_01:\n            pval_correc_str = '<= 0.01'\n        elif pval_raw <= alpha_05:\n            pval_correc_str = '<= 0.05'\n        else:\n            pval_correc_str = 'False'\n        corr_med = np.median(corr_raw_distro)\n        corr_resid = corr_raw - corr_med\n        sigma = np.nanstd(error_corr_raw_distro)\n        # Normalize to be in [-1, 1] by dividing difference by distance between \n        #  median and left (if corr_raw < corr_med) or right \n        #  (if corr_raw > corr_med) bound\n        if corr_resid < 0:\n            corr_resid \/= (corr_med+1)\n            sigma     \/= (corr_med+1)\n        elif corr_resid > 0:\n            corr_resid \/= (1-corr_med)\n            sigma     \/= (1-corr_med)\n        corr_resid_low_sd  = corr_resid - sigma\n        corr_resid_high_sd = corr_resid + sigma\n            \n        # Compute normalized correlation CI\n        corr_resid_low_arg = int(np.round(alpha_05*corr_raw_distro.size))\n        corr_resid_low_nom = np.sort(corr_raw_distro)[corr_resid_low_arg]\n        corr_resid_high_arg = int(np.round((1-alpha_05)*corr_raw_distro.size))\n        corr_resid_high_nom = np.sort(corr_raw_distro)[corr_resid_high_arg]\n        corr_resid_null_low_ci = (corr_resid_low_nom - corr_med) \/ (corr_med+1)\n        corr_resid_null_high_ci = (corr_resid_high_nom - corr_med) \/ \\\n                                  (1-corr_med)\n            \n        # Add row to dataframe\n        usi_corr_df.loc[idx] = \\\n            [stimtype, l, c, usi_base_sess, \n            corr_raw, corr_resid, corr_resid_low_sd, corr_resid_high_sd,\n            corr_resid_null_low_ci, corr_resid_null_high_ci, \n            pval_raw, pval_correc_str,\n            x, y, corr_raw_distro, error_corr_raw_distro]\n        idx+=1\n        \n\n    return usi_corr_df\n\n#############################################\n\ndef usi_corr_permutation(tracked_roi_usi_df, stimtype, l, c, usi_base_sess=1):\n    \"\"\"\n    Returns the median of the shuffled distribution of correlations between\n    USI and Delta(USI)\n    \n    Parameters\n    ----------\n    tracked_roi_usi_df : Pandas DataFrame\n        Dataframe with tracked ROI USIs and statistics\n    stimtype : string\n        Stimulus type ('gabors' or 'bricks')\n    l : string\n        Layer from which to get data\n    c : string\n        Compartment from which to get data\n    usi_base_sess : number; optional, default = 1\n        Session to obtain USIs and against which to compare delta(USI) with \n        usi_base_sess+1\n\n    Returns\n    -------\n    median_array : 2-D array of numbers\n        Array with data with a correlation closest to median of a shuffled\n        distro.  Size: ROIs x 2.  1st column: USIs; 2nd column: Delta(USI)\n    \"\"\"\n\n    print(l, c)\n\n    # declarations\/initializations\n    usi                   = []\n    corr_raw_distro       = []\n    mask0 = tracked_roi_usi_df['compartment']==c\n    mask1 = tracked_roi_usi_df['layer']==l\n    usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_1_usi']) )\n    usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_2_usi']) )\n    usi.append( np.hstack(tracked_roi_usi_df[mask0 & mask1]['sess_3_usi']) )\n\n    # Find correlation between USI and delta(USI)\n    x = usi[usi_base_sess-1]\n    x2 = usi[usi_base_sess]\n    y = x2 - x\n    corr_raw = scist.pearsonr(x, y)[0]\n\n    # Permuation loop\n    roi_idx = range(x.size)\n    for i_perm in range(int(1e4)):\n        # Shuffle session labels for USIs\n        # ROIs x sessions\n        arr = np.asarray(usi).transpose()\n        # Row 1: roi indexes; row 2: randomly chosen session\n        sess_col = np.random.choice([0,1,2], x.size)\n        # USIs from randomly chosen session\n        usi1_perm = arr[roi_idx, sess_col]\n        # USIs from randomly chosen remaining session (periodic boundary \n        #  conditions)\n        direction  = np.random.choice([-1,1], x.size)\n        usi2_perm = arr[roi_idx,np.mod(sess_col+direction,3)]\n        # compute pearson from shuffled USIs and add to shuffled distro\n        x_perm = usi1_perm\n        y_perm = usi2_perm - usi1_perm\n        corr_raw_distro.append(scist.pearsonr(x_perm, y_perm)[0])\n\n    corr_med = np.median(corr_raw_distro)\n    corr_resid = corr_raw - corr_med\n\n    print('Corr raw, median = ', corr_raw, corr_med)\n\n    ###############\n    \n    # Second run to grab the permutation data with correlation\n    #  closest to median from above\n\n    # declarations\/initializations\n    corr_raw_distro       = []\n    # Just make sure it's farther away from median corr than anything possible\n    prev_pearson = -2 \n\n    for i_perm in range(int(1e4)):\n        # Shuffle session labels for USIs\n        # ROIs x sessions\n        arr = np.asarray(usi).transpose()\n        # Row 1: roi indexes; row 2: randomly chosen session\n        sess_col = np.random.choice([0,1,2], x.size)\n        # USIs from randomly chosen session\n        usi1_perm = arr[roi_idx, sess_col]\n        # USIs from randomly chosen remaining session (periodic boundary \n        #  conditions)\n        direction  = np.random.choice([-1,1], x.size)\n        usi2_perm = arr[roi_idx,np.mod(sess_col+direction,3)]\n        # Compute pearson from shuffled USIs and add to shuffled distro\n        x_perm = usi1_perm\n        y_perm = usi2_perm - usi1_perm\n        corr_raw_distro.append(scist.pearsonr(x_perm, y_perm)[0])\n        # Find data for median of distro\n        if np.abs(corr_med - corr_raw_distro[-1]) < np.abs(corr_med - prev_pearson):\n            x_keep_perm = x_perm\n            y_keep_perm = y_perm\n            prev_pearson = corr_raw_distro[-1]\n\n    # Median data\n    median_array = np.stack((x_keep_perm, y_keep_perm), axis=1)\n\n    return median_array"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_323","text":"import numpy as np\nimport scipy.sparse as sp\nimport properties\n\nfrom .. import utils\nfrom .base import BaseSimilarityMeasure\n\n\nclass LinearCorrespondence(BaseSimilarityMeasure):\n    \"\"\"\n    The petrophysical linear constraint for joint inversions.\n\n    ..math::\n        \\\\phi_c({\\\\mathbf m}_{\\\\mathbf1},{\\\\mathbf m}_{\\\\mathbf2})=\\\\lambda\\\\sum_{i=1}^M\n        (k_1*m_1 + k_2*m_2 + k_3)\n\n    Assuming that we are working with two models only.\n\n    \"\"\"\n\n    coefficients = properties.Array(\n        \"coefficients for the linear relationship between parameters\",\n        shape=(3,),\n        default=np.array([1.0, -1.0, 0.0]),\n    )\n\n    def relation(self, model):\n        \"\"\"\n        Computes the values of petrophysical linear relationship between two different\n        geophysical models.\n\n        The linear relationship is defined as:\n\n        f(m1, m2)  = k1*m1 + k2*m2 + k3\n\n        :param numpy.ndarray model: stacked array of individual models\n                                    np.c_[model1, model2,...]\n\n        :rtype: float\n        :return: linearly related petrophysical values of two different models,\n                  dimension: M by 1, :M number of model parameters.\n\n        \"\"\"\n        m1, m2 = self.wire_map * model\n        k1, k2, k3 = self.coefficients\n\n        return k1 * m1 + k2 * m2 + k3\n\n    def __call__(self, model):\n        \"\"\"\n        Computes the sum of values of petrophysical linear relationship\n        between two different geophysical models.\n\n        :param numpy.ndarray model: stacked array of individual models\n                                    np.c_[model1, model2,...]\n\n        :rtype: float\n        :return: a scalar value.\n        \"\"\"\n\n        result = self.relation(model)\n        return 0.5 * result.T @ result\n\n    def deriv(self, model):\n        \"\"\"Computes the Jacobian of the coupling term.\n\n        :param list of numpy.ndarray ind_models: [model1, model2,...]\n\n        :rtype: numpy.ndarray\n        :return: result: gradient of the coupling term with respect to model1, model2,\n                 :dimension 2M by 1, :M number of model parameters.\n        \"\"\"\n        k1, k2, k3 = self.coefficients\n        r = self.relation(model)\n        dc_dm1 = k1 * r\n        dc_dm2 = k2 * r\n\n        result = np.r_[dc_dm1, dc_dm2]\n\n        return result\n\n    def deriv2(self, model, v=None):\n        \"\"\"Computes the Hessian of the linear coupling term.\n\n        :param list of numpy.ndarray ind_models: [model1, model2, ...]\n        :param numpy.ndarray v: vector to be multiplied by Hessian\n        :rtype: scipy.sparse.csr_matrix if v is None\n                numpy.ndarray if v is not None\n        :return Hessian matrix: | h11, h21 | :dimension 2M*2M.\n                                |          |\n                                | h12, h22 |\n        \"\"\"\n\n        k1, k2, k3 = self.coefficients\n        if v is not None:\n            v1, v2 = self.wire_map * v\n            p1 = k1**2 * v1 + k2 * k1 * v2\n            p2 = k2 * k1 * v1 + k2**2 * v2\n            return np.r_[p1, p2]\n        else:\n            n = self.regmesh.nC\n            A = utils.sdiag(np.ones(n) * (k1**2))\n            B = utils.sdiag(np.ones(n) * (k2**2))\n            C = utils.sdiag(np.ones(n) * (k1 * k2))\n            return sp.bmat([[A, C], [C, B]], format=\"csr\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_324","text":"from SimpleCV.base import *\nfrom SimpleCV.Features.Features import Feature, FeatureSet\nfrom SimpleCV.Color import Color\nfrom SimpleCV.ImageClass import Image\nfrom SimpleCV.Features.Detection import ShapeContextDescriptor\nimport math\nimport scipy.stats as sps\ntry:\n    from sklearn import neighbors\nexcept:\n    print \"Need scikits learn installed\"\n    #exit()\n\n\n\"\"\"\nClassify an object based on shape context\n\"\"\"\nclass ShapeContextClassifier():\n\n    def  __init__(self,images,labels):\n        \"\"\"\n        Create a shape context classifier.\n\n        * *images* - a list of input binary images where the things\n          to be detected are white.\n\n        * *labels* - the names of each class of objects.\n        \"\"\"\n        self.imgMap = {}\n        self.ptMap = {}\n        self.descMap = {}\n        self.knnMap = {}\n        self.blobCount = {}\n        self.labels = labels\n        self.images = images\n        import warnings\n        warnings.simplefilter(\"ignore\")\n        for i in range(0,len(images)):\n            print \"precomputing \" + images[i].filename\n            self.imgMap[labels[i]] = images[i]\n\n            pts,desc,count  = self._image2FeatureVector(images[i])\n            self.blobCount[labels[i]] = count\n            self.ptMap[labels[i]] = pts\n            self.descMap[labels[i]] = desc\n            knn = neighbors.KNeighborsClassifier()\n            knn.fit(desc,range(0,len(pts)))\n            self.knnMap[labels[i]] = knn\n\n    def _image2FeatureVector(self,img):\n        \"\"\"\n        generate a list of points, SC descriptors, and the count of points\n        \"\"\"\n        #IMAGES MUST BE WHITE ON BLACK!\n        fulllist = []\n        raw_descriptors = []\n        blobs = img.findBlobs(minsize=50)\n        count = 0\n        if( blobs is not None ):\n            count = len(blobs)\n            for b in blobs:\n                fulllist += b._filterSCPoints()\n                raw_descriptors = blobs[0]._generateSC(fulllist)\n        return fulllist,raw_descriptors,count\n\n\n    def _getMatch(self,model_scd,test_scd):\n        correspondence,distance = self._doMatching(model_scd,test_scd)\n        return self._matchQuality(distances)\n\n    def _doMatching(self,model_name,test_scd):\n        myPts = len(test_scd)\n        otPts = len(self.ptMap[model_name])\n        # some magic metric that keeps features\n        # with a lot of points from dominating\n        #metric = 1.0 + np.log10( np.max([myPts,otPts])\/np.min([myPts,otPts])) # <-- this could be moved to after the sum\n        otherIdx = []\n        distance = []\n        import warnings\n        warnings.simplefilter(\"ignore\")\n        results = []\n        for sample in test_scd:\n            best = self.knnMap[model_name].predict(sample)\n            idx = best[0] # this is where we can play with k\n            scd = self.descMap[model_name][idx]\n            temp = np.sqrt(np.sum(((sample-scd)**2)))\n            #temp = 0.5*np.sum((sample-scd)**2)\/np.sum((sample+scd))\n            if( math.isnan(temp) ):\n                temp = sys.maxint\n            distance.append(temp)\n        return [otherIdx,distance]\n\n    def _matchQuality(self,distances):\n        #distances = np.array(distances)\n        #sd = np.std(distances)\n        #x = np.mean(distances)\n        #min = np.min(distances)\n        # not sure trimmed mean is perfect\n        # realistically we should have some bimodal dist\n        # and we want to throw away stuff with awful matches\n        # so long as the number of points is not a huge\n        # chunk of our points.\n        #tmean = sps.tmean(distances,(min,x+sd))\n        tmean = np.mean(distances)\n        std = np.std(distances)\n        return tmean,std\n\n\n    def _buildMatchDict(self,image, countBlobs):\n        # we may want to base the count on the num best_matchesber of large blobs\n        points,descriptors,count = self._image2FeatureVector(image)\n        matchDict = {}\n        matchStd = {}\n        for key,value in self.descMap.items():\n            if( countBlobs and self.blobCount[key] == count ): # only do matching for similar number of blobs\n                #need to hold on to correspondences\n                correspondence, distances = self._doMatching(key,descriptors)\n                result,std = self._matchQuality(distances)\n                matchDict[key] = result\n                matchStd[key] = std\n            elif( not countBlobs ):\n                correspondence, distances = self._doMatching(key,descriptors)\n                result,std = self._matchQuality(distances)\n                matchDict[key] = result\n                matchStd[key] = std\n\n        return points,descriptors,count,matchDict, matchStd\n\n    def classify(self,image, blobFilter=True):\n        \"\"\"\n        Classify an input image.\n\n        * *image* - the input binary image.\n        * *blobFilter* - Do a first pass where you only match objects\n          that have the same number of blobs - speeds up computation\n          and match quality.\n        \"\"\"\n        points,descriptors,count,matchDict,matchStd = self._buildMatchDict(image, blobFilter)\n        best = sys.maxint\n        best_name = \"No Match\"\n        for k,v in matchDict.items():\n            if ( v < best ):\n                best = v\n                best_name = k\n\n        return best_name, best, matchDict, matchStd\n\n    def getTopNMatches(self,image,n=3, blobFilter = True):\n        \"\"\"\n        Classify an input image and return the top n results.\n\n        * *image* - the input binary image.\n        * *n* - the number of results to return.\n        * *blobFilter* - Do a first pass where you only match objects\n          that have the same number of blobs - speeds up computation\n          and match quality.\n        \"\"\"\n        n = np.clip(n,1,len(self.labels))\n        points,descriptors,count,matchDict,matchStd = self._buildMatchDict(image,blobFilter)\n        best_matches = list(sorted(matchDict, key=matchDict.__getitem__))\n        retList = []\n        for k in best_matches:\n            retList.append((k,matchDict[k]))\n        return retList[0:n], matchDict, matchStd\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_325","text":"<filename>quadpy\/sphere\/stroud.py\n# -*- coding: utf-8 -*-\n#\nimport numpy\nimport sympy\n\nfrom .helpers import cartesian_to_spherical\n\nfrom .albrecht_collatz import AlbrechtCollatz\nfrom .mclaren import McLaren\nfrom ..nsphere.stroud1969 import Stroud1969\n\n\nclass Stroud(object):\n    \"\"\"\n    <NAME>,\n    Approximate Calculation of Multiple Integrals,\n    Prentice Hall, 1971.\n    \"\"\"\n\n    def __init__(self, index, symbolic=False):\n        self.name = \"Stroud_U3({})\".format(index)\n\n        if index == \"U3 3-1\":\n            self.set_data(McLaren(1, symbolic=symbolic))\n        elif index == \"U3 5-1\":\n            self.set_data(AlbrechtCollatz(1, symbolic=symbolic))\n        elif index == \"U3 5-2\":\n            self.set_data(AlbrechtCollatz(2, symbolic=symbolic))\n        elif index == \"U3 5-3\":\n            self.set_data(AlbrechtCollatz(3, symbolic=symbolic))\n        elif index == \"U3 5-4\":\n            self.set_data(AlbrechtCollatz(4, symbolic=symbolic))\n        elif index == \"U3 5-5\":\n            self.set_data(McLaren(2, symbolic=symbolic))\n        elif index == \"U3 7-1\":\n            self.set_data(McLaren(3, symbolic=symbolic))\n        elif index == \"U3 7-2\":\n            self.set_data(AlbrechtCollatz(5, symbolic=symbolic))\n        elif index == \"U3 8-1\":\n            self.set_data(McLaren(4, symbolic=symbolic))\n        elif index == \"U3 9-1\":\n            self.set_data(McLaren(5, symbolic=symbolic))\n        elif index == \"U3 9-2\":\n            self.set_data(McLaren(6, symbolic=symbolic))\n        elif index == \"U3 9-3\":\n            self.set_data(McLaren(7, symbolic=symbolic))\n        elif index == \"U3 11-1\":\n            self.set_data(McLaren(8, symbolic=symbolic))\n        elif index == \"U3 11-2\":\n            scheme = Stroud1969(3, symbolic=symbolic)\n            self.degree = scheme.degree\n            self.weights = scheme.weights\n            pi = sympy.pi if symbolic else numpy.pi\n            self.weights \/= 4 * pi\n            self.points = scheme.points\n            self.azimuthal_polar = cartesian_to_spherical(self.points)\n        elif index == \"U3 11-3\":\n            self.set_data(McLaren(9, symbolic=symbolic))\n        else:\n            assert index == \"U3 14-1\", \"Illegal index {}.\".format(index)\n            self.set_data(McLaren(10, symbolic=symbolic))\n        return\n\n    def set_data(self, scheme):\n        self.degree = scheme.degree\n        self.weights = scheme.weights\n        self.points = scheme.points\n        self.azimuthal_polar = scheme.azimuthal_polar\n        return\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_328","text":"<filename>emotionclassification.py<gh_stars>1-10\n#!\/usr\/bin\/env python3\n# -*- coding = utf-8 -*-\nimport os\nimport sys\nimport json\nimport argparse\nfrom statistics import mode\n\nimport cv2\nimport numpy as np\nfrom keras.models import load_model\n\nfrom data.load_data import get_fer2013_data\nfrom models.model_factory import load_keras_model\nfrom util.constant import fer2013_classes\nfrom util.classifyimgops import apply_offsets\nfrom util.classifyimgops import preprocess_input\nfrom util.info import load_info\n\nap = argparse.ArgumentParser()\nap.add_argument(\"-d\", \"--detector\", default = \"DNN\",\n                help = \"The detector used to detect faces: [mtcnn, dnn, cascade]\")\nap.add_argument(\"-i\", \"--image\", default = None,\n                help = \"The images that you want to detect faces from.\")\nargs = vars(ap.parse_args())\n\n# Get Cascade Classifier and DNN Model.\nface_detector, net = load_info()\n\n# Choose Cascade vs DNN.\ndnn = True\ncascade = False\n\n# Bounding.\nimage_window = 10\nif dnn:\n   emotion_offsets = (45, 40)\nelif cascade:\n   emotion_offsets = (30, 40)\nelse:\n   raise ValueError(\"You must choose either dnn or cascade.\")\n\n# Load Emotion Detection Model.\nemotion_labels = fer2013_classes\nemotion_classifier = load_keras_model('Model-27-0.6631', compile = False)\nemotion_target_size = emotion_classifier.input_shape[1:3]\nemotion_window = []\n\n# If running from an IDE (not from command line), then enter images here.\nsavedir = \"modded\" # Directory to save changed images.\nuserimages = [\".\/test_imgs\/amoghneutralnew.jpg\"]\n\nfor image in userimages:\n   file, extension = os.path.splitext(image)\n   file = os.path.basename(file)\n   image = np.array(cv2.imread(image), dtype = 'uint8')\n   gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n   global faces\n   if dnn:\n      blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0, (300, 300), swapRB=False, crop=False)\n      net.setInput(blob)\n      faces = net.forward()\n   if cascade:\n      faces = face_detector.detectMultiScale(gray_image, 1.3, 5)\n\n   if cascade:\n      for face_coordinates in faces:\n         print(face_coordinates)\n         x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)\n         gray_face = gray_image[y1: y2, x1: x2]\n         try:\n            gray_face = cv2.resize(gray_face, (emotion_target_size))\n         except:\n            continue\n\n         gray_face = preprocess_input(gray_face, False)\n         gray_face = np.expand_dims(gray_face, 0)\n         gray_face = np.expand_dims(gray_face, -1)\n         emotion_prediction = emotion_classifier.predict(gray_face)\n         emotion_probability = np.max(emotion_prediction)\n         emotion_label_arg = np.argmax(emotion_prediction)\n         emotion_text = emotion_labels[emotion_label_arg]\n         emotion_window.append(emotion_text)\n\n         if len(emotion_window) > image_window: emotion_window.pop(0)\n         try:\n            emotion_mode = mode(emotion_window)\n         except:\n            continue\n\n         if emotion_text == 'happy':\n            color = emotion_probability * np.asarray((255, 255, 0))\n         elif emotion_text == 'angry':\n            color = emotion_probability * np.asarray((255, 0, 0))\n         elif emotion_text == 'sad':\n            color = emotion_probability * np.asarray((0, 0, 255))\n         elif emotion_text == 'surprise':\n            color = emotion_probability * np.asarray((0, 255, 255))\n         else:\n            color = emotion_probability * np.asarray((0, 255, 0))\n\n         color = color.astype(int)\n         color = color.tolist()\n\n         x, y, w, h = face_coordinates\n         # cv2.rectangle(image, (x, y), (xe, ye), color, 3)\n         cv2.rectangle(image, (x, y), (x + w, y + h), color, 3)\n         cv2.putText(image, emotion_mode, (x + 0, y - 45), cv2.FONT_HERSHEY_SIMPLEX,\n                     1, color, 3, cv2.LINE_AA)\n         # Print a background behind the text.\n         bg = np.full((image.shape), (0, 0, 0), dtype = np.uint8)\n         cv2.putText(bg, emotion_mode, (x + 0, y - 45), cv2.FONT_HERSHEY_SIMPLEX,\n                     1, color, 3, cv2.LINE_AA)\n         x1, y1, w1, h1 = cv2.boundingRect(bg[:,:,2])\n         image[y1: y1 + h1, x1: x1 + w1] = bg[y1: y1 + h1, x1: x1 + w1]\n\n   if dnn:\n      (h, w) = image.shape[:2]\n      for k in range(0, faces.shape[2]):\n         c = faces[0, 0, k, 2]\n         if c < 0.5: continue\n         box = faces[0, 0, k, 3:7] * np.array([w, h, w, h])\n         (x, y, xe, ye) = box.astype(\"int\")\n         face_coordinates = (x, y, xe, ye)\n\n         x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)\n         gray_face = gray_image[y1: y2, x1: x2]\n         try:\n            gray_face = cv2.resize(gray_face, (emotion_target_size))\n         except:\n            continue\n\n         gray_face = cv2.flip(gray_face, 1)\n         # gray_face = preprocess_input(gray_face, False)\n         gray_face = np.expand_dims(gray_face, 0)\n         gray_face = np.expand_dims(gray_face, -1)\n         emotion_prediction = emotion_classifier.predict(gray_face)\n         emotion_probability = np.max(emotion_prediction)\n         emotion_label_arg = np.argmax(emotion_prediction)\n         emotion_text = emotion_labels[emotion_label_arg]\n         emotion_window.append(emotion_text)\n\n         if len(emotion_window) > image_window: emotion_window.pop(0)\n         try:\n            emotion_mode = mode(emotion_window)\n         except:\n            continue\n\n         if emotion_text == 'happy':\n            color = emotion_probability * np.asarray((255, 255, 0))\n         elif emotion_text == 'angry':\n            color = emotion_probability * np.asarray((255, 0, 0))\n         elif emotion_text == 'sad':\n            color = emotion_probability * np.asarray((0, 0, 255))\n         elif emotion_text == 'surprise':\n            color = emotion_probability * np.asarray((0, 255, 255))\n         else:\n            color = emotion_probability * np.asarray((0, 255, 0))\n\n         color = color.astype(int)\n         color = color.tolist()\n\n         x, y, w, h = face_coordinates\n         cv2.rectangle(image, (x, y), (xe, ye), color, 3)\n         # cv2.rectangle(image, (x, y), (x + w, y + h), color, 3)\n         cv2.putText(image, emotion_mode, (x + 0, y - 80), cv2.FONT_HERSHEY_SIMPLEX,\n                     3, color, 3, cv2.LINE_AA)\n         # Print a background behind the text.\n         # bg = np.full((image.shape), (0, 0, 0), dtype = np.uint8)\n         # cv2.putText(bg, emotion_mode, (x + 0, y - 45), cv2.FONT_HERSHEY_SIMPLEX,\n         #             1, color, 3, cv2.LINE_AA)\n         # x1, y1, w1, h1 = cv2.boundingRect(bg[:,:,2])\n         # print(x1, y1, w1, h1)\n         # image[y1: y1 + h1, x1: x1 + w1] = bg[y1: y1 + h1, x1: x1 + w1]\n\n   cv2.imwrite(os.path.join(savedir or \"\", f\"{file}-detect{extension}\"), image)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_329","text":"<reponame>sina-moammar\/2020-Fall-Computational-Physics\nimport numpy as np\nfrom scipy.optimize import curve_fit\nfrom typing import Callable, List, Tuple, TypeVar\n\n\ndef auto_correlation(data: List[float], lag: int) -> float:\n    \"\"\"Calculates auto-correlation of `data` with `lag` time delay\n\n    Args:\n        data (List[float]): data\n        lag (int): lag of comparision\n\n    Returns:\n        float: auto-correlation of `data[lag:]` with `data[:-lag]\n    \"\"\"\n    \n    if lag == 0:\n        return 1\n    else:\n        correlation = np.corrcoef(data[:len(data) - lag], data[lag:])[0, 1]\n        return 0 if np.isnan(correlation) else correlation\n    \n    \ndef _exp_model(x: float, char_length: float) -> float:\n    \"\"\"Model of `f(x) = exp(- x \/ l)`\n\n    Args:\n        x (float): input\n        char_length (float): characteristic length (l)\n\n    Returns:\n        float: output of function\n    \"\"\"\n    \n    return np.exp(-x \/ char_length)\n\n\ndef exp_characteristic_length(x_s: List[float], y_s: List[float]) -> Tuple[float, float]:\n    \"\"\"Finds characteristic length of `exp(-x \/ l)` function.\n\n    Args:\n        x_s (List[float]): inputs\n        y_s (List[float]): outputs\n\n    Returns:\n        Tuple[float, float]: characteristic length and its error\n    \"\"\"\n    \n    try:\n        x_length = x_s[-1] - x_s[0]\n        x_length = 1 if x_length == 0 else x_length\n        # should normalized x\n        fit_para, fit_error = curve_fit(_exp_model, x_s \/ x_length, y_s, p0=(.5,))\n        # because of normalization\n        fit_para = fit_para[0] * x_length\n        fit_error = np.sqrt(fit_error[0]) * x_length\n    except:\n        fit_para, fit_error = 0, 0\n\n    return fit_para, fit_error\n\n\nX = TypeVar('X')\n\ndef bootstrap_error(data: List[X], function: Callable[[List[X]], float], size: int = 100) -> float:\n    \"\"\"Calculates bootstrap error of `data`.\n\n    Args:\n        data (List[X]): list of any data\n        function (Callable[[List[X]], float]): function gives the value that we want to calculate its error\n        size (int, optional): number of batches. Defaults to 100.\n\n    Returns:\n        float: bootstrap error\n    \"\"\"\n    \n    ensemble_values = np.zeros(size)\n\n    for i in range(size):\n        # select `len(data)` values from data randomly\n        random_numbers = np.random.randint(0, len(data), len(data))\n        # get function output of this batch\n        ensemble_values[i] = function(data[random_numbers])\n\n    # return standard deviation of function output of batches\n    return np.std(ensemble_values)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_331","text":"# -*- coding: utf-8 -*-\n\"\"\"\nSupport function for net handling\n\"\"\"\n\nimport time\n\nimport numpy as np\nimport scipy.sparse as sp \n\n\n\n############## return cor list (raw) with integer values ( = float * 1000)\n\ndef return_net_list(Z_cor_mat):\n\n    t2 = time.time()\n    \n    print(Z_cor_mat.shape) \n    \n    x_sig,y_sig = np.where(Z_cor_mat != 0.0)\n        \n    net_list = np.array(np.column_stack((x_sig + 1,y_sig + 1,Z_cor_mat[x_sig,y_sig]*1000)),dtype = int)\n    \n    print(net_list.shape)\n    \n    t3 = time.time()\n    \n    print(\"Sparse Weighted correlation thresholding computation took \" + str(t3-t2) + \"s\")\n    \n    return net_list\n    \ndef return_int_net_list(int_mat,min_int = 0):\n\n    t2 = time.time()\n    \n    x_sig,y_sig = np.where(int_mat > min_int)\n    \n    net_list = np.array(np.column_stack((x_sig + 1,y_sig + 1,int_mat[x_sig,y_sig])),dtype = 'int64')\n    \n    print(net_list.shape)\n    \n    t3 = time.time()\n    \n    print(\"Sparse Weighted correlation thresholding computation took \" + str(t3-t2) + \"s\")\n    \n    return net_list\n    \n##################################### Formatting data for external community detection algorithm (radatools) ##############################\n        \ndef export_List_net_from_list(Z_List_file,Z_list):\n    \n    \n    print(Z_list.shape)\n    \n    #print \"saving file \" + Z_List_file\n    \n    np.savetxt(Z_List_file,Z_list,fmt = '%d %d %d')\n       \n\n    \n#def read_List_net_file(Z_List_file):\n\n    #Z_list = np.loadtxt(Z_List_file,dtype = 'int64')\n    \n    #return Z_list\n    \n#def read_mod_file(mod_file):\n    \n    #community_vect = np.loadtxt(mod_file,dtype = 'int', delimiter = '\\t')\n    \n    #return community_vect[:,1]\n    \ndef read_lol_file(lol_file):\n\n    with open(lol_file,'r') as f :\n        \n        lines = f.readlines()[4:] \n        \n        line_nb_elements = lines[0]\n        \n        nb_elements = int(line_nb_elements.split(': ')[1])\n        \n        #print nb_elements\n        \n        community_vect = np.empty((nb_elements),dtype = int)\n        \n        lines = lines[3:]\n        \n        #print lines\n        \n        for i,line in enumerate(lines):\n            \n            try:\n                nb_nodes,index_nodes = line.split(': ')\n                print (nb_nodes,index_nodes)\n                \n                if int(nb_nodes) > 1:\n                    index_nodes = np.array(list(map(int,index_nodes.split(' '))),dtype = int) -1\n                \n                    #print i,index_nodes\n                    community_vect[index_nodes] = i\n                    \n                else :\n                    community_vect[int(index_nodes) -1] = i\n                \n            except ValueError:\n                print(\"Warning, reading lol file \")\n                \n        f.close()\n        \n    return community_vect\n    \ndef read_Pajek_corres_nodes(Pajek_net_file):\n\n    with open(Pajek_net_file,'r') as f :\n        \n        lines = f.readlines()\n        \n        line_nb_elements = lines[0]\n        \n        nb_elements = int(line_nb_elements.split(' ')[1])\n        \n        #print nb_elements\n        \n        node_corres = np.empty((nb_elements),dtype = 'int')\n        \n        lines = lines[1:(nb_elements+1)]\n        \n        #print lines\n        \n        for i,line in enumerate(lines):\n            #print line\n            \n            new_index,old_index = line.split(' ')\n            \n            #print i+1, new_index, old_index\n            \n            #node_corres[i] = old_index\n            \n            if (i+1) == int(new_index) :\n                node_corres[i] = int(old_index)-1\n            else:\n                print(\"Warning, incompatible indexes {} {}\".format(new_index,i+1))\n            \n        f.close()\n        \n    return node_corres\n    \n####### from modified Pajek file, read coords\n\n#def read_Pajek_rel_coords(Pajek_net_file):\n    \n    #with open(Pajek_net_file,'r') as f :\n        \n        #lines = f.readlines()\n        \n        #line_nb_elements = lines[0]\n        \n        #nb_elements = int(line_nb_elements.split(' ')[1])\n        \n        #print nb_elements\n        \n        #node_rel_coords = np.empty((nb_elements,3),dtype = 'float')\n        \n        #node_lines = lines[1:(nb_elements+1)]\n        \n        ##print lines\n        \n        #for i,line in enumerate(node_lines):\n            ##print line\n            \n            #node_line = line.split(' ')\n            \n            ##print node_line\n            \n            #node_rel_coords[i,0] = node_line[2]\n            #node_rel_coords[i,1] = node_line[3]\n            #node_rel_coords[i,2] = node_line[4]\n            \n            ##print node_rel_coords[i,:] \n            \n        #f.close()\n        \n    #return node_rel_coords\n   \n   \n    ###########\" return corres_nodes and sparse matrix from pajek file\n    \ndef read_Pajek_corres_nodes_and_sparse_matrix(Pajek_net_file):\n\n    with open(Pajek_net_file,'r') as f :\n        \n        lines = f.readlines()\n        \n        line_nb_elements = lines[0]\n        \n        nb_elements = int(line_nb_elements.split(' ')[1])\n        \n        print(nb_elements)\n        \n        node_corres = np.empty((nb_elements),dtype = 'int')\n        \n        node_lines = lines[1:(nb_elements+1)]\n        \n        #print lines\n        \n        for i,line in enumerate(node_lines):\n            #print line\n            \n            new_index,old_index = line.split(' ')\n            \n            #print i+1, new_index, old_index\n            \n            #node_corres[i] = old_index\n            \n            if (i+1) == int(new_index) :\n                node_corres[i] = int(old_index)-1\n            else:\n                print(\"Warning, incompatible indexes {} {}\".format(new_index,i+1))\n            \n            \n            \n        list_sparse_matrix = [line.strip().split(' ') for line in lines[(nb_elements+2):]]\n        \n        np_list_sparse_matrix = np.transpose(np.array(list_sparse_matrix,dtype = 'int64'))\n        \n        sparse_matrix = sp.coo_matrix((np_list_sparse_matrix[2,:],(np_list_sparse_matrix[0,:]-1,np_list_sparse_matrix[1,:]-1)), shape = (nb_elements,nb_elements))\n        \n        f.close()\n        \n    return node_corres,sparse_matrix\n   \n#####################\" compute modular Network\ndef compute_modular_network(sparse_matrix,community_vect):\n    \n    mod_mat = np.empty(sparse_matrix.todense().shape) \n    \n    mod_mat[:] = np.NAN\n    \n    for u,v,w in zip(sparse_matrix.row,sparse_matrix.col,sparse_matrix.data):\n        \n        if (community_vect[u] == community_vect[v]):\n            \n            mod_mat[u,v] = community_vect[u] \n        else:\n            \n            mod_mat[u,v] = -1\n            \n    return mod_mat\n          \n### read strength from Network_Properties node results \ndef get_strength_values_from_info_nodes_file(info_nodes_file):\n\n    from pandas.io.parsers import read_csv\n    \n    info_nodes = read_csv(info_nodes_file, sep = \"\\t\")\n    \n    #print info_nodes\n    \n    return info_nodes['Strength'].values\n    \ndef get_strength_pos_values_from_info_nodes_file(info_nodes_file):\n\n    from pandas.io.parsers import read_csv\n    \n    info_nodes = read_csv(info_nodes_file, sep = \"\\t\")\n    \n    print(info_nodes)\n    \n    return info_nodes['Strength_Pos']\n\ndef get_strength_neg_values_from_info_nodes_file(info_nodes_file):\n\n    from pandas.io.parsers import read_csv\n    \n    info_nodes = read_csv(info_nodes_file, sep = \"\\t\")\n    \n    print(info_nodes)\n    \n    return info_nodes['Strength_Neg']\n    \ndef get_degree_pos_values_from_info_nodes_file(info_nodes_file):\n\n    from pandas.io.parsers import read_csv\n    \n    info_nodes = read_csv(info_nodes_file, sep = \"\\t\")\n    \n    print(info_nodes)\n    \n    return info_nodes['Degree_Pos']\n\ndef get_degree_neg_values_from_info_nodes_file(info_nodes_file):\n\n    from pandas.io.parsers import read_csv\n    \n    info_nodes = read_csv(info_nodes_file, sep = \"\\t\")\n    \n    print(info_nodes)\n    \n    return info_nodes['Degree_Neg']\n    \n##################################### Formatting data for external community detection algorithm (Louvain_Traag) ##############################\n        \ndef export_Louvain_net_from_list(Z_Louvain_file,Z_list,coords):\n    \n    print(np.array(Z_list).shape)\n    \n    #print sig_x,sig_y\n    print(\"column_stack\")\n    tab_edges = np.column_stack((np.array(Z_list),np.repeat(1,repeats = len(Z_list))))\n    \n    print(tab_edges.shape)\n    \n    print(\"file\")\n    \n    with open(Z_Louvain_file,'w') as f:\n        \n        #### write node list\n        nb_nodes = coords.shape[0]\n        \n        print(\"Nb nodes: \" + str(nb_nodes))\n        \n        coords_list = coords.tolist()\n        \n        f.write('>\\n')\n        \n        for node in range(nb_nodes):\n            \n            ##print node + coord label\n            f.write(str(node+1) + ' ' + '_'.join(map(str,coords_list[node])) + '\\n')\n        \n        #### write slice list\n        f.write('>\\n')\n        f.write('1 1\\n')\n        \n        #### write edge list\n        f.write('>\\n')\n        \n        np.savetxt(f,tab_edges,fmt = '%d %d %d %d')\n        \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_332","text":"<reponame>angus-g\/sosfilt\nimport numpy as np\nfrom scipy.signal import signaltools\nfrom ._sosfilt import _sosfilt\n\n\ndef _validate_sos(sos):\n    sos = np.atleast_2d(sos)\n\n    if sos.ndim == 2:\n        return sos, -1, 1\n\n    n_filters, n_sections, m = sos.shape\n\n    if m != 6:\n        raise ValueError(\"last dim of sos array must be size 6\")\n    if not (sos[..., 3] == 1).all():\n        raise ValueError(\"sos[..., 3] should be all ones\")\n\n    return sos, n_sections, n_filters\n\n\ndef _validate_nfilters(x, axis, n_filters):\n    # with 1 filter, we'll broadcast it as usual\n    if n_filters == 1:\n        return\n\n    # otherwise, the number of filters must match the\n    # product of the non-filtered axes of x\n    x_shape = list(x.shape)\n    x_shape.pop(axis)\n    if n_filters != np.product(x_shape):\n        raise ValueError(\"n_filters must match product of non-filtered axes\")\n\n\ndef _validate_ntaps(ntaps):\n    first_tap = ntaps[0]\n    if not np.all(ntaps == first_tap):\n        raise ValueError(\"all filters must have the same number of taps\")\n\n    return first_tap\n\n\ndef sosfilt_zi(sos):\n    sos = np.asarray(sos)\n    if sos.ndim != 3 or sos.shape[2] != 6:\n        raise ValueError(\"sos must be shape (n_filters, n_sections, 6)\")\n\n    if sos.dtype.kind in \"bui\":\n        sos = sos.astype(np.float64)\n\n    n_filters, n_sections = sos.shape[:2]\n    zi = np.empty((n_filters, n_sections, 2), dtype=sos.dtype)\n    scale = np.ones(n_filters, dtype=sos.dtype)\n    for section in range(n_sections):\n        b = sos[:, section, :3]\n        a = sos[:, section, 3:]\n\n        # lfilter_zi solves zi = A*zi + B\n        # where A = scipy.linalg.companion(a).T\n        # and   B = b[1:] - a[1:]*b[0]\n        #\n        # because a[0] = 1 for a sos filter, we have\n        # A = [ 1 + a[1], -1;\n        #         a[2],    1]\n        # so zi[0] = (B[0] + B[1]) \/ (1 + a[1] + a[2])\n        # and zi[1] = B[1] - a[2] * zi[0]\n        #\n        # we can pretty easily write this in a vectorised\n        # way over all n_filters!\n\n        B = b[:, 1:] - a[:, 1:] * b[:, [0]]\n        zi[:, section, 0] = B.sum(axis=-1) \/ a.sum(axis=-1)\n        zi[:, section, 1] = B[:, 1] - a[:, 2] * zi[:, section, 0]\n        zi[:, section, :] *= scale[:, None]\n\n        scale *= b.sum(axis=-1) \/ a.sum(axis=-1)\n\n    return zi\n\n\ndef sosfilt(sos, x, axis=-1, zi=None):\n    x = signaltools._validate_x(x)\n\n    sos, n_sections, n_filters = _validate_sos(sos)\n\n    x_zi_shape = list(x.shape)\n    x_zi_shape[axis] = 2\n    x_zi_shape = tuple([n_sections] + x_zi_shape)\n    inputs = [sos, x]\n\n    if zi is not None:\n        inputs.append(np.asarray(zi))\n\n    dtype = np.result_type(*inputs)\n    if dtype.char not in \"fdgFDGO\":\n        raise NotImplementedError(f\"input type '{dtype}' not supported\")\n\n    if zi is not None:\n        zi = np.array(zi, dtype)\n        if zi.shape != x_zi_shape:\n            raise ValueError(\"invalid zi shape\")\n        return_zi = True\n    else:\n        zi = np.zeros(x_zi_shape, dtype=dtype)\n        return_zi = False\n\n    axis = axis % x.ndim\n    x = np.moveaxis(x, axis, -1)\n    zi = np.moveaxis(zi, [0, axis + 1], [-2, -1])\n    x_shape, zi_shape = x.shape, zi.shape\n    x = np.reshape(x, (-1, x.shape[-1]))\n    x = np.array(x, dtype, order=\"C\")  # make a modifiable copy\n    zi = np.ascontiguousarray(np.reshape(zi, (-1, n_sections, 2)))\n    sos = sos.astype(dtype, copy=False)\n\n    _sosfilt(sos, x, zi)\n\n    x.shape = x_shape\n    x = np.moveaxis(x, -1, axis)\n\n    if return_zi:\n        zi.shape = zi_shape\n        zi = np.moveaxis(zi, [-2, -1], [0, axis + 1])\n        out = (x, zi)\n    else:\n        out = x\n\n    return out\n\n\ndef sosfiltfilt(sos, x, axis=-1, padtype=\"odd\", padlen=None):\n    \"\"\"\n    A forward-backward digital filter using cascaded second-order sections.\n\n    Parameters\n    ----------\n    sos : array_like\n        An array of second-order filter coefficients. It must have either\n        the shape ``(n_filters, n_sections, 6)`` or ``(n_sections, 6)``.\n        In the latter case, the single filter will be broadcast over the\n        whole input array. In the former case, `n_filters` must match\n        the product of the non-filter axes of `x`. Additionally,\n        `n_sections` must be the same for all filters.\n    x : array_like\n        The array of data to be filtered.\n    axis : int, optional\n        The axis of `x` to which the filter is applied.\n        Default is -1.\n    padtype : str or None, optional\n        Must be 'odd', 'even', 'constant', or None. Determines the type\n        of extension to use for the padded signal to which the filter is\n        applied. If None, no padding is used. The default is 'odd'.\n    padlen : int or None, optional\n        The number of elements by which to extend `x` at both ends of\n        `axis` before applying the filter.\n    \"\"\"\n\n    # filter validation\n    sos, n_sections, n_filters = _validate_sos(sos)\n\n    if n_filters == 1:\n        # defer to scipy's implementation for the usual case of a single filter\n        return signaltools.sosfiltfilt(\n            sos, x, axis=axis, padtype=padtype, padlen=padlen\n        )\n\n    # input validation\n    x = signaltools._validate_x(x)\n    _validate_nfilters(x, axis, n_filters)\n\n    # padding validation\n    ntaps = np.ones(n_filters, dtype=int) * (2 * n_sections + 1)\n    ntaps -= np.minimum((sos[..., 2] == 0).sum(axis=1), (sos[..., 5] == 0).sum(axis=1))\n    ntaps = _validate_ntaps(ntaps)\n    edge, ext = signaltools._validate_pad(padtype, padlen, x, axis, ntaps=ntaps)\n\n    # filter initial conditions\n    zi = sosfilt_zi(sos)\n\n    # to handle multiple filters, we might want zi.shape = (n_sections, ..., 2, ...)\n    zi = np.swapaxes(zi, 0, 1)  # => (n_sections, n_filters, 2)\n    zi_shape = list(x.shape)\n    zi_shape[axis] = 2\n    # we need to swap axis to the end first, so it picks up the end of zi\n    zi_shape[axis], zi_shape[-1] = zi_shape[-1], zi_shape[axis]\n    zi_shape = [n_sections] + zi_shape\n    zi = zi.reshape(zi_shape)  # should look like (n_sections, ..., 2)\n    # now we need to swap axis back from the end to where it should be\n    zi = np.swapaxes(zi, -1, (axis % x.ndim) + 1)\n\n    # forward filter\n    x_0 = signaltools.axis_slice(ext, stop=1, axis=axis)\n    (y, zf) = sosfilt(sos, ext, axis=axis, zi=zi * x_0)\n\n    # backward filter\n    y_0 = signaltools.axis_slice(y, start=-1, axis=axis)\n    (y, zf) = sosfilt(\n        sos, signaltools.axis_reverse(y, axis=axis), axis=axis, zi=zi * y_0\n    )\n\n    # reshaping\n    y = signaltools.axis_reverse(y, axis=axis)\n    if edge > 0:\n        y = signaltools.axis_slice(y, start=edge, stop=-edge, axis=axis)\n\n    return y\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_333","text":"import numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.fftpack as fftp\nimport scipy.optimize as opt\nimport sys\nimport os\nimport string\nfrom scipy import signal\n\nfrom bcolors import *\nfrom funct import *\n\n\ndef periodogram(x,y,z,t,name):\n    vel=x*x+y*y\n    components=[vel,z*z]\n    F=[]\n    A=[]\n\n    for i in range(0,len(components)):\n        window=np.kaiser(components[i].shape[-1],5)\n        vel=components[i]#*window\n        f,a=DO_FFT(vel,20)\n        F.append(f)\n        A.append(a)\n\n    \n    plt.figure(1,figsize=(11,7))\n    plt.title(\"Spectral Gap - <NAME>\")\n    plt.subplot(121)\n    plt.title(\"FFT horizontal velocity\")\n    plt.xlabel(\"Frequency [Hz]\")\n    plt.ylabel(\"Power Spectrum [dB]\")\n    plt.loglog(F[0],A[0],'k', markersize=0.1)\n\n    plt.subplot(122)\n    plt.title(\"FFT vertical velocity\")\n    plt.xlabel(\"Frequency [Hz]\")\n    plt.ylabel(\"Power Spectrum [dB]\")\n    plt.loglog(F[1],A[1],'r',markersize=0.1)\n\n    try:\n        plt.savefig(\"graph\/\"+name+\"_FFT.png\", figuresize=(8,6), dpi=320, format=\"png\")\n        print_ok(\"Graph saved in: \"+\"graph\/\"+name+\"_FFT.png\")\n    except IOError as IoE:\n        print_fail(\"I\/O Error! Erro number = {0}; {1}\".format(IoE.errno,IoE.strerror))\n        exit(IoE.errno)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_334","text":"<filename>PAM_repeat1000times-regression.py<gh_stars>1-10\nimport pandas as pd\nimport numpy as np\nimport xgboost as xgb\nimport shap\nfrom scipy.stats import pearsonr\n\n  \nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn import metrics \nfrom sklearn.model_selection import KFold, GridSearchCV\n\nimport time\nimport random\n\nfrom utils import data_handler, plotter\n\n#handle warnings\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\nnp.random.seed(3)\n\n\n\ndef test(y_pred,y_true,end_ptr):\n    '''Evaluate the performance of PAM through 3 metrics; \n       And find the best predicted condition for the next PAM trial\n       \n       Inputs:\n           X_test      - for testing\n           y_true      - ground true for X_test\n           end_ptr     - range of [0,end_ptr] in y_pred and y_true are values observable to PAM\n           \n       Uses:(global variables)    \n           pred_result - of shape (total_samp,), storing all the results predicted by PAM\n           true_results- of shape (total_samp,), the same order as of pred_results, storing all the ground truth\n           \n       Outputs:\n            \n    \n    '''\n    #All sample metrics    \n    r2 = metrics.r2_score(y_true,y_pred)   \n    mse = metrics.mean_squared_error(y_true,y_pred)\n    [pear,p_value] = pearsonr(y_true,y_pred)\n    \n    #metrics based on observable samples\n    y_true_s = y_true[0:(end_ptr+1)]\n    y_pred_s = y_pred[0:(end_ptr+1)]\n    r2_s = metrics.r2_score(y_true_s,y_pred_s)   \n    mse_s = metrics.mean_squared_error(y_true_s,y_pred_s)\n    [pear_s,p_value_s] = pearsonr(y_true_s,y_pred_s)\n    return [r2,pear,p_value,mse,r2_s,pear_s,p_value_s,mse_s] #, best_pos_ind, best_prob \n\n\n\n# data handling\nX_df,Y_df = data_handler.load_XY(1)\nX = X_df.as_matrix()\nY = Y_df.as_matrix() \/ 100\n\n\n# setup and construct initial training dataset\n# cross validation settup\ninner_nsplits = 10\ninit_train_size = 20\ntotalSamp = X.shape[0]\n\n\nY_global_max = np.max(Y)\nall_ind = np.random.permutation(list(range(0,totalSamp)))\nall_ind_wo_max = list(range(0,totalSamp))\nall_ind_wo_max.remove(0)\n\n\n# PAM guided synthesis\ndef PAM_regression(save_csv= False, verbose=False, to_break=True, title='cqd_PAM_',batch=1):\n\n    ## start PAM guided synthesis...\n    init_time = time.time()\n    Nc = 0\n\n    #construct initial training set\n    results_mat = np.zeros(((totalSamp-init_train_size),12))\n\n    train_ind = random.sample(all_ind_wo_max, init_train_size)\n    test_ind = [x for x in all_ind if x not in train_ind]\n    if(verbose):\n        print('initial training set indexes',train_ind)  \n\n    # set up result storage to compute eval metrics, in the order of PAM\n    #  ignore the initial training set, as it is not determined by PAM\n    pred_results = np.zeros(totalSamp-init_train_size)\n    true_results = np.zeros(totalSamp-init_train_size)\n\n\n    # setup the hyperparameter range for tuning\n    tuned_parameters = dict(learning_rate=[0.01],\n                            n_estimators=[300,500,700], #100,,300,400,500\n                            colsample_bylevel = [0.5,0.7,0.9],\n                          gamma=[0,0.2], #0,0.1,0.2,0.3,0.4\n                          max_depth =[3,7,11], # [3,7,11]]\n                          reg_lambda = [0.1,1,10], #[0.1,1,10]\n                         # reg_alpha = [1],\n                           subsample=[0.4,0.7,1])\n\n    j=0\n    loop_count = 0\n    mean_y_only_init = np.mean(Y[train_ind])\n    std_y_only_init = np.std(Y[train_ind])\n    \n    \n    while(j<totalSamp-init_train_size):        \n        inner_cv = KFold(n_splits=inner_nsplits,shuffle=True, random_state=j) \n        X_train = X[train_ind]\n        Y_train = Y[train_ind]\n        X_test = X[test_ind]\n        Y_test = Y[test_ind]\n\n        last_max = np.max(Y_train)\n        \n        # GradientBoost\n        reg = xgb.XGBRegressor(objective=\"reg:linear\",min_child_weight=1,**{'tree_method':'exact'},\n                                 silent=True,n_jobs=4,random_state=3,seed=3);\n\n        gb_clf = GridSearchCV(reg,tuned_parameters, cv=inner_cv,scoring='r2',verbose=0,n_jobs=4)\n        gb_clf.fit(X_train, Y_train)\n        y_pred = gb_clf.predict(X_test)\n\n\n        # choose the batch of conditions with best predicted yield\n        best_pos_ind = np.argsort(-y_pred)[:batch]       \n        best_prob = y_pred[best_pos_ind]\n        next_ind = np.array(test_ind)[best_pos_ind]        \n        \n        # update results storage\n        train_size = len(Y_train)\n        temp = list(range(0,len(y_pred)))\n        ind_notbest = [x for x in temp if x not in best_pos_ind]\n        \n        start_ptr = j\n        end_ptr = np.min([start_ptr + batch, totalSamp-init_train_size]) \n        pred_results[start_ptr:end_ptr] = best_prob\n        pred_results[end_ptr:totalSamp-init_train_size]= y_pred[ind_notbest]\n        true_results[start_ptr:end_ptr] = Y_test[best_pos_ind]\n        true_results[end_ptr:totalSamp-init_train_size] = Y_test[ind_notbest]\n\n        pred_metrics = test(pred_results,true_results,end_ptr-1)    \n\n        # calculate results\n        next_best_true_ind = next_ind[np.argmax(Y_test[best_pos_ind])]\n        next_best_y_true = np.max(Y_test[best_pos_ind])\n        result_list = [train_size,next_best_true_ind,next_best_y_true,best_prob[0],] + pred_metrics   \n        results_mat[loop_count,:] = np.array(result_list)\n                     \n        loop_count = loop_count +1\n        j = j + batch\n                     \n        if(verbose):            \n            print(loop_count,'->',j,', best_next_ind=',next_best_true_ind, ' best_Y_true=',\"{0:.6f}\".format(next_best_y_true),' train_max=',\"{0:.6f}\".format(last_max),' r2=',pred_metrics[0])\n\n        train_ind = [*train_ind , *next_ind]   \n        test_ind = [x for x in test_ind if x not in next_ind]\n        \n        ## critical point\n        if(next_best_y_true==Y_global_max and Nc == 0):\n            Nc = j+init_train_size          \n            if(to_break):\n                break\n\n\n    saved_title = '-'\n    if(save_csv):\n        results = pd.DataFrame(data=results_mat[0:j,:],columns=['sample_size','pred_ind','best_pred_result','y_true','r2','pearson','p_value','mse','r2_s','pearson_s','p_value_s','mse_s'])\n        saved_title = data_handler.save_csv(results,title=title)\n        \n\n    # compute stats\n    mean_y_wo_init =  np.mean(true_results[0:j])\n    std_y_wo_init = np.std(true_results[0:j])\n    \n    mean_y_w_init = np.mean(Y[train_ind])\n    std_y_w_init = np.std(Y[train_ind])\n\n    run_time = (time.time() - init_time)\/60\n    \n    return [saved_title, Nc,mean_y_wo_init,std_y_wo_init,mean_y_w_init,std_y_w_init,mean_y_only_init,std_y_only_init, run_time]\n\n\nouter_loop = 10\ninner_loop = 100\n\nprint('start PAM for ',str(outer_loop*inner_loop),' times...')\n# save the results some repetitions for backup\nfor j in range(0,outer_loop):\n\n    #PAM_results = np.zeros((inner_loop,9))\n    init_time = time.time()\n    res_arr = []\n\n    for i in range(0,inner_loop): \n\n        loop_count = j*inner_loop + i        \n        result = PAM_regression(save_csv= False, verbose=False, to_break = True, title='cqd_PAM_'+str(loop_count)+'th_loop_')\n        res_arr.append(result)\n        print(str(loop_count),' -> ',str(result[0]),'  time=',result[len(result)-1])\n   \n\n    PAM_df = pd.DataFrame(data=res_arr, columns=['file-name','num_experiments','mean_y_wo_init','std_y_wo_init','mean_y_w_init','std_y_w_init','mean_y_only_init','std_y_only_init', 'run_time'])\n    saved_path = data_handler.save_csv(PAM_df,title='cqd_PAM_'+str(inner_loop)+'times_')\n    print('total = ',str((time.time()-init_time)\/3600),'  hrs  >>-------saved')\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_335","text":"<reponame>nids2001\/UncertainSCI\nfrom itertools import combinations\n\nimport numpy as np\nfrom scipy import special as sp\nfrom scipy.special import comb\n\nfrom UncertainSCI.utils.prob import discrete_sampling\n\n\ndef hyperbolic_cross_indices(d, k):\n    \"\"\"\n    Returns indices associated with a d-dimensional (isotropic)\n    hyperbolic cross index space up to degree k.\n    \"\"\"\n\n    assert k >= 0\n    assert d >= 1\n\n    if d == 1:\n        lambdas = range(k+1)\n        return lambdas\n\n    lambdas = np.zeros([1, d], dtype=int)\n\n    # First add all indices with sparsity 1\n    for q in range(d):\n        temp = np.zeros([k-1, d], dtype=int)\n        temp[:, q] = np.arange(1, k, dtype=int)\n        lambdas = np.vstack([lambdas, temp])\n\n    # Now determine the maximum 0-norm the entries can be. I.e., for\n    # which values of p is 2^p <= k+1?\n    pmax = int(np.floor(np.log(k+1)\/np.log(2)))\n\n    # For each sparsity p, populate with all possible indices of that\n    # sparsity\n    for p in range(2, pmax+1):\n        # Determine all possible locations where nonzero entries can occur\n        combs = combinations(range(d), p)\n        combs = np.array([row for row in combs], dtype=int)\n\n        # Now we have 2^p < k+1, i.e., an index with nonzero entries\n        # np.ones([p 1]) is ok.\n        # Keep incrementing these entries until product exceeds k+1\n        possible_indices = np.ones([1, p])\n        ind = 0\n\n        while ind < possible_indices.shape[0]:\n            # Add any possibilities that are children of\n            # possible_indices[ind,:]\n\n            lambd = possible_indices[ind, :]\n            for q in range(p):\n                temp = lambd.copy()\n                temp[q] += 1\n                if np.prod(temp+1) <= k+1:\n                    possible_indices = np.vstack([possible_indices, temp])\n\n            ind += 1\n\n        possible_indices = np.vstack({tuple(row) for row in possible_indices})\n        arow = lambdas.shape[0]\n        lambdas = np.vstack([lambdas,\n                             np.zeros([combs.shape[0]*possible_indices.shape[0],\n                                       d],\n                                      dtype=int)])\n\n    # Now for each combination, we put in possible_indices\n        for c in range(combs.shape[0]):\n            i1 = arow\n            i2 = arow + possible_indices.shape[0]\n\n            lambdas[i1:i2, combs[c, :]] = possible_indices\n\n            arow = i2\n\n    return lambdas\n\n\ndef total_degree_indices(d, k):\n    # Returns multi-indices associated with d-variate polynomials of\n    # degree less than or equal to k. Each row is a multi-index, ordered\n    # in total-degree-graded reverse lexicographic ordering.\n\n    assert d > 0\n    assert k >= 0\n\n    if d == 1:\n        return np.arange(k+1, dtype=int).reshape([k+1, 1])\n\n    # total degree indices up to degree k in d-1 dimensions:\n    lambdasd1 = total_degree_indices(d-1, k)\n    # lambdasd1 should already be sorted by total degree, which is\n    # assumed below\n\n    lambdas = np.zeros([np.round(int(comb(d+k, d))), d], dtype=int)\n\n    i0 = 0\n    for qk in range(0, k+1):\n\n        n = int(np.round(comb(d-1+(k-qk), d-1)))\n        i1 = i0 + n\n\n        lambdas[i0:i1, 0] = qk\n        lambdas[i0:i1, 1:] = lambdasd1[:n, :]\n        i0 = i1\n\n    # My version of numpy < 1.12, so I don't have np.flip :(\n    # degrees = np.cumsum(np.flip(lambdas,axis=1), axis=1)\n    degrees = np.cumsum(np.fliplr(lambdas), axis=1)\n\n    ind = np.lexsort(degrees.transpose())\n    lambdas = lambdas[ind, :]\n\n    return lambdas\n\n\ndef degree_encompassing_N(d, N):\n    # Returns the smallest degree k such that nchoosek(d+k,d) >= N\n\n    k = 0\n    while np.round(comb(d+k, d)) < N:\n        k += 1\n\n    return k\n\n\ndef total_degree_indices_N(d, N):\n    # Returns the first N ( > 0) d-dimensional multi-indices when ordered by\n    # total degree graded reverse lexicographic ordering.\n\n    assert N > 0\n\n    return total_degree_indices(d, degree_encompassing_N(d, N))[:N, :]\n\n\ndef tensor_product(d, k):\n    # Returns multi-indices associated with d-variate polynomials of\n    # degree less than or equal to k. Each row is a multi-index, ordered\n    # in p degree, where p = Inf\n\n    from itertools import product\n\n    Ival = np.empty(shape=[0, d], dtype=int)\n\n    for t in (_ for _ in product(range(k+1), repeat=d)):\n        Ival = np.vstack((Ival, np.asarray(t)))\n\n    return Ival\n\n\ndef multi_indices_degree(d, k, p):\n    # Returns multi-indices associated with d-variate polynomials of\n    # degree less than or equal to k. Each row is a multi-index, ordered\n    # in p degree, p could be any positive number including numpy.inf\n\n    if p < 1:\n        lambdas = total_degree_indices(d, k)\n        norm = (np.sum(lambdas**p, axis=1))**(1\/p)\n        norm = np.round(norm, decimals=8)\n        flags = (norm <= k)\n        lambdas = lambdas[flags]\n\n    elif p == np.inf:\n        lambdas = tensor_product(d, k)\n\n    elif p == 1:\n        lambdas = total_degree_indices(d, k)\n\n    else:\n        lambdas = tensor_product(d, k)\n        norm = (np.sum(lambdas**p, axis=1))**(1\/p)\n        norm = np.round(norm, decimals=8)\n        flags = (norm <= k)\n        lambdas = lambdas[flags]\n\n    return lambdas\n\n\ndef pdjk(d, k):\n    j = np.arange(k+1)\n    p = np.exp(np.log(d) + sp.gammaln(k+1) - sp.gammaln(j+1) +\n               sp.gammaln(j+d) - sp.gammaln(k+d+1))\n    assert np.abs(sum(p)-1) < 1e-8\n    return p\n\n\ndef sampling_total_degree_indices(N, d, k):\n\n    \"\"\"\n    Chooses N random multi-indices (with the uniform probability law) from the\n    set of d-variate multi-indices whose total degree is k and less\n\n    Parameters\n    ------\n    param1: N\n    Numebr of chosen random multi-indices\n    param2: d\n    dimension of variables\n    param3L k\n    total degree of variables\n\n    Returns\n    ------\n    The output lambdas is an N x d matrix, with each row containing one of\n    these multi-indices\n    \"\"\"\n    lambdas = np.zeros((N, d))\n\n    degrees = discrete_sampling(N, pdjk(d, k), np.arange(k+1)).T\n\n    for i in range(1, d):\n        for n in range(1, N+1):\n            lambdas[n-1, i-1] = \\\n                discrete_sampling(1, pdjk(d-i, degrees[n-1]),\n                                  np.arange(degrees[n-1], 0-1e-8, -1))\n\n        degrees = degrees - lambdas[:, i-1]\n\n    lambdas[:, d-1] = degrees\n\n    return lambdas\n\n\nclass MultiIndexSet():\n    def __init__(self, dim=None):\n        self.dim = dim\n        self.indices = np.zeros([0, self.dim])\n        self.adaptive = False\n\n    def get_indices(self):\n        return self.indices\n\n    def size(self):\n        return self.indices.shape[0]\n\n    def max_univariate_degree(self, dim=None):\n        \"\"\"\n        Returns the maximum index value along a given dimension. If no\n        dimension is specified, returns the maximum degree across all\n        dimensions.\n\n        Args:\n            dim: A dimension integer taking values between 0 and self.dim-1,\n              optional.\n        Returns:\n            deg: Maximum index value (integer).\n        \"\"\"\n\n        if dim is None:\n            return np.max(self.get_indices())\n        else:\n            return np.max(self.get_indices()[:, dim])\n\n    def zero_indices(self, dim_indices=None):\n        \"\"\"\n        Identifies indices in the index set whose entries in the dimensions\n        dim_indices are 0.\n\n        Args:\n            dim_list: list-like iterable containing dimension indices.\n        Returns:\n            flags: A boolean numpy vector indicating which indices in the index\n              set satisfy the conditions.\n        \"\"\"\n\n        assert all([0 <= dim <= self.dim-1 for dim in dim_indices])\n\n        if dim_indices is None:\n            return self.get_indices()\n\n        indices = self.get_indices()\n\n        return np.linalg.norm(indices[:, dim_indices], axis=1) == 0\n\n    def isamember(self, trial_indices):\n        \"\"\"\n        Determines if input indices are members of the current index set.\n\n        Args:\n            trial_indices: An :math:`K \\\\times d` numpy array, where each row\n              corresponds to an index.\n\n        Returns:\n            member: A numpy boolean array of size :math:`K` indicating if the\n              rows of trial_indices are part of the current index set.\n        \"\"\"\n\n        K, d = trial_indices.shape\n        assert self.dim == d, \\\n               \"Input index array should have {0:d} columns\".format(self.dim)\n\n        M = self.indices.shape[0]\n        member = np.zeros(K, dtype=bool)\n        for m in range(K):\n\n            index = trial_indices[m, :]\n\n            matches = np.ones(M, dtype=bool)\n            for q in range(d):\n                matches[matches] = index[q] == self.indices[matches, q]\n\n            if np.any(matches):\n                member[m] = True\n\n        return member\n\n    def get_margin(self):\n        \"\"\"\n        Computes the margin of the index set :math:`\\\\Lambda`. In :math:`d`\n        dimensions, this is defined as the set of indices :math:`\\\\lambda \\\\in\n        N_0^d \\\\backslash \\\\Lambda` such that\n\n        .. math::\n\n          \\\\lambda - e_j \\\\in \\\\Lambda\n\n        for some :math:`j = 1, \\\\ldots, d`.\n\n        Returns:\n            margin: A numpy array of size :math:`M \\\\times d` where each row\n              contains an index in the margin.\n        \"\"\"\n\n        # Do this in a brute-force manner:\n        # - search for leaves of the current index set as margin candidates\n        # - weed out leaves that are not in the margin\n\n        M, d = self.indices.shape\n        margin = np.zeros([0, d], dtype=self.indices.dtype)\n\n        for m in range(M):\n            candidates = np.tile(self.indices[m, :], [d, 1]) +\\\n                         np.eye(d, dtype=self.indices.dtype)\n            membership_flags = ~self.isamember(candidates)\n            margin = np.unique(\n                      np.append(margin, candidates[membership_flags, :], axis=0),\n                      axis=0)\n\n        return margin\n\n    def get_reduced_margin(self):\n        \"\"\"\n        Computes the reduced margin of the index set :math:`\\\\Lambda`. In\n        :math:`d` dimensions, this is defined as the set of indices\n        :math:`\\\\lambda \\\\in N_0^d \\\\backslash \\\\Lambda` such that\n\n        .. math::\n\n          \\\\lambda - e_j \\\\in \\\\Lambda\n\n        for every :math:`j = 1, \\\\ldots, d` satisfying :math:`\\\\lambda_j \\\\neq\n        0`.\n\n        Returns:\n            margin: A numpy array of size :math:`M \\\\times d` where each row\n              contains an index in the margin.\n        \"\"\"\n\n        # We'll sequentially test elements in the margin\n\n        margin = self.get_margin()\n        K, d = margin.shape\n        reduced_margin_inds = []\n\n        for k in range(K):\n            candidates = np.tile(margin[k, :], [d, 1]) - np.eye(d)\n            candidates = candidates[~np.any(candidates < 0, axis=1), :]\n\n            if np.all(self.isamember(candidates)):\n                reduced_margin_inds.append(k)\n\n        return margin[reduced_margin_inds, :]\n\n    def augment(self, indices):\n        \"\"\"\n        Augments the index set with the given indices.\n        \"\"\"\n\n        K, d = indices.shape\n        assert d == self.dim, \\\n               \"Input index array should have {0:d} columns\".format(self.dim)\n\n        membership_flags = self.isamember(indices)\n        if np.any(~membership_flags):\n            self.adaptive = True\n            self.indices = np.append(self.indices,\n                                     indices[~membership_flags, :], axis=0)\n\n\nclass LpSet(MultiIndexSet):\n    def __init__(self, dim=1, order=0, p=1):\n        assert dim > 0 and order >= 0 and p >= 0\n\n        super().__init__(dim=dim)\n        self.dim = dim\n        self.order = order\n        self.p = p\n        self.indices = self.get_indices()\n\n    def get_indices(self):\n        if self.p < 1:\n            lambdas = total_degree_indices(self.dim, self.order)\n            norm = (np.sum(lambdas**self.p, axis=1))**(1\/self.p)\n            norm = np.round(norm, decimals=8)\n            flags = (norm <= self.order)\n            lambdas = lambdas[flags]\n\n        elif self.p == np.inf:\n            lambdas = tensor_product(self.dim, self.order)\n\n        elif self.p == 1:\n            lambdas = total_degree_indices(self.dim, self.order)\n\n        else:\n            lambdas = tensor_product(self.dim, self.order)\n            norm = (np.sum(lambdas**self.p, axis=1))**(1\/self.p)\n            norm = np.round(norm, decimals=8)\n            flags = (norm <= self.order)\n            lambdas = lambdas[flags]\n\n        return lambdas\n\n\nclass TotalDegreeSet(MultiIndexSet):\n    def __init__(self, dim=1, order=0):\n        assert dim > 0 and order >= 0\n\n        super().__init__(dim=dim)\n\n        self.dim, self.order = dim, order\n        self.indices = self.get_indices()\n\n    def get_indices(self):\n        if self.adaptive:\n            return super().get_indices()\n        else:\n            return total_degree_indices(self.dim, self.order)\n\n\nclass HyperbolicCrossSet(MultiIndexSet):\n    def __init__(self, dim=1, order=0):\n        assert dim > 0 and order >= 0\n\n        super().__init__(dim=dim)\n\n        self.dim, self.order = dim, order\n        self.indices = self.get_indices()\n\n    def get_indices(self):\n        if self.adaptive:\n            return super().get_indices()\n        else:\n            return hyperbolic_cross_indices(self.dim, self.order)\n\n\nif __name__ == \"__main__\":\n\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_320","text":"\n# coding: utf-8\n\n# In[1]:\n\n\nimport matplotlib.pyplot as plt\nimport sgbm\nimport stdev\nimport simple_return as sr\nimport duration\nimport numpy as np\nimport pandas as pd\nimport statistics as sc\nfrom scipy.stats import kurtosis, skew\nimport pickle\nimport os\nimport multiprocessing\nfrom multiprocessing import Pool\n\n\n# In[2]:\n\n\nx=pd.ExcelFile('\/home\/anindya\/Parallel_code\/Squeeze\/Stat.xlsx')\npage=x.parse(0)\nN=page.N\nmu=page.tdrift\ntvola=page.tvola\np=0.15\n\n\n# In[3]:\n\n\nwith open('\/home\/anindya\/Parallel_code\/Squeeze\/vol.pkl','rb') as f:\n    vol = pickle.load(f)\n\n\n# In[4]:\n\n\nseed=range(0,201)\ndt=5.\/(250*360)\nsdt=np.sqrt(dt)\nname=\"\/home\/anindya\/Parallel_code\/Squeeze\/SMGBM\/Group1\/\"\n\n\n# In[5]:\n\n\ndef loop(k,theta,r,b):\n    GM_m=[]\n    GS_m=[]\n    GW_m=[]\n    GK_m=[]\n    l=[]\n    if(tvola[k]-((p*(np.percentile(vol[k],r))))>0):\n        si1=np.percentile(vol[k],r)\n    else:\n        si1=tvola[k]\/p\n    si2=((tvola[k]-(p*si1))\/(1-p))\n    for j in range(200):\n        sm=sgbm.sgbm(dt,N[k],p*100,mu[k],si1,si2,theta,b,seed[j])\n        ret_m=sr.s_ret(np.array(sm,dtype=float))\n        ret_m=np.array(ret_m)\n        L=len(ret_m)\n        n=20\n        new_ret_m=[np.array(ret_m[i:i+n]) for i in range(L-n)]\n        Ln=len(new_ret_m)\n        new_std_m=np.array([stdev.sd(new_ret_m[i]) for i in range(Ln)])\n        volatility_m= new_std_m\/sdt\n        dur_m=duration.duration(np.array(volatility_m))\n        dur_m=np.array(dur_m,dtype=float)\n        GM_m.append(np.mean(dur_m))\n        GS_m.append(stdev.sd(dur_m))\n        GW_m.append(skew(dur_m))\n        GK_m.append(kurtosis(dur_m,fisher=False))\n        l.append(len(dur_m))\n    return (GM_m,GS_m,GW_m,GK_m,l)\n#     return (GM_m,GS_m)\n\n\n# In[6]:\n\n\npool = Pool()\n\nfor k in range(0,6,1):\n    name1=name+\"I0\"+str(k+1)\n    if not os.path.exists(name1):\n        os.mkdir(name1)\n    for b in range(2,15,1):\n        name2=name1+\"\/shape\"+str(b)\n        if not os.path.exists(name2):\n            os.mkdir(name2)\n        for i in range(5,17,1):\n            t1=[]\n            t2=[]\n            t3=[]\n            t4=[]\n            L1=[]\n            theta=i\n            args=[]\n            for r in range(0,31,1):\n                args.append((k,theta,r,b))\n            for one,two,three,four,ll in pool.starmap(loop, args):\n                t1.append(one)\n                t2.append(two)\n                t3.append(three)\n                t4.append(four)\n                L1.append(ll)\n            strname=name2+\"\/theta\"+str(i)+\".xlsx\"\n            writer=pd.ExcelWriter(strname,engine='xlsxwriter')\n            for w in range(0,31,1):\n                df=pd.DataFrame({'T1':t1[w],'T2':t2[w],'T3':t3[w],'T4':t4[w],'Len':L1[w]},index=range(1,201))\n                vv=\"Vola\"+str((w))\n                df.to_excel(writer,sheet_name=vv)\n            writer.save()\n            \npool.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_326","text":"# Copyright (c) Facebook, Inc. and its affiliates.\n\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport os\nimport cv2\nimport torch\nimport numpy as np\nimport argparse\nimport torchvision\nfrom PIL import Image\nfrom tqdm import tqdm\nfrom pathlib import Path\nfrom datetime import datetime\nfrom retry.api import retry_call\nfrom torch.utils import data\nfrom torchvision import transforms\nfrom part_selector import Trainer as Trainer_selector\nfrom part_generator import Trainer as Trainer_cond_unet\nfrom scipy.ndimage.morphology import distance_transform_edt\n\nCOLORS = {'initial':1-torch.cuda.FloatTensor([45, 169, 145]).view(1, -1, 1, 1)\/255., 'eye':1-torch.cuda.FloatTensor([243, 156, 18]).view(1, -1, 1, 1)\/255., 'none':1-torch.cuda.FloatTensor([149, 165, 166]).view(1, -1, 1, 1)\/255., \n        'beak':1-torch.cuda.FloatTensor([211, 84, 0]).view(1, -1, 1, 1)\/255., 'body':1-torch.cuda.FloatTensor([41, 128, 185]).view(1, -1, 1, 1)\/255., 'details':1-torch.cuda.FloatTensor([171, 190, 191]).view(1, -1, 1, 1)\/255.,\n        'head':1-torch.cuda.FloatTensor([192, 57, 43]).view(1, -1, 1, 1)\/255., 'legs':1-torch.cuda.FloatTensor([142, 68, 173]).view(1, -1, 1, 1)\/255., 'mouth':1-torch.cuda.FloatTensor([39, 174, 96]).view(1, -1, 1, 1)\/255., \n        'tail':1-torch.cuda.FloatTensor([69, 85, 101]).view(1, -1, 1, 1)\/255., 'wings':1-torch.cuda.FloatTensor([127, 140, 141]).view(1, -1, 1, 1)\/255.}\n\nclass Initialstroke_Dataset(data.Dataset):\n    def __init__(self, folder, image_size):\n        super().__init__()\n        self.folder = folder\n        self.image_size = image_size\n        self.paths = [p for p in Path(f'{folder}').glob(f'**\/*.png')]\n        self.transform = transforms.Compose([\n            transforms.ToTensor(),\n        ])\n\n    def __len__(self):\n        return len(self.paths)\n\n    def __getitem__(self, index):\n        path = self.paths[index]\n        img = self.transform(Image.open(path))\n        return img\n\n    def sample(self, n):\n        sample_ids = [np.random.randint(self.__len__()) for _ in range(n)]\n        samples = [self.transform(Image.open(self.paths[sample_id])) for sample_id in sample_ids]\n        return torch.stack(samples).cuda()\n\ndef load_latest(model_dir, name):\n    model_dir = Path(model_dir)\n    file_paths = [p for p in Path(model_dir \/ name).glob('model_*.pt')]\n    saved_nums = sorted(map(lambda x: int(x.stem.split('_')[1]), file_paths))\n    if len(saved_nums) == 0:\n        return\n    name = saved_nums[-1]\n    print(f'continuing from previous epoch - {name}')\n    return name\n\n\ndef noise(n, latent_dim):\n    return torch.randn(n, latent_dim).cuda()\n\ndef noise_list(n, layers, latent_dim):\n    return [(noise(n, latent_dim), layers)]\n\ndef mixed_list(n, layers, latent_dim):\n    tt = int(torch.rand(()).numpy() * layers)\n    return noise_list(n, tt, latent_dim) + noise_list(n, layers - tt, latent_dim)\n\ndef image_noise(n, im_size):\n    return torch.FloatTensor(n, im_size, im_size, 1).uniform_(0., 1.).cuda()\n\ndef evaluate_in_chunks(max_batch_size, model, *args):\n    split_args = list(zip(*list(map(lambda x: x.split(max_batch_size, dim=0), args))))\n    chunked_outputs = [model(*i) for i in split_args]\n    if len(chunked_outputs) == 1:\n        return chunked_outputs[0]\n    return torch.cat(chunked_outputs, dim=0)\n\ndef evaluate_in_chunks_unet(max_batch_size, model, map_feats, *args):\n    split_args = list(zip(*list(map(lambda x: x.split(max_batch_size, dim=0), args))))\n    split_map_feats = list(zip(*list(map(lambda x: x.split(max_batch_size, dim=0), map_feats))))\n    chunked_outputs = [model(*i, j) for i, j in zip(split_args, split_map_feats)]\n    if len(chunked_outputs) == 1:\n        return chunked_outputs[0]\n    return torch.cat(chunked_outputs, dim=0)\n\ndef styles_def_to_tensor(styles_def):\n    return torch.cat([t[:, None, :].expand(-1, n, -1) for t, n in styles_def], dim=1)\n\ndef gs_to_rgb(image, color):\n    image_rgb = image.repeat(1, 3, 1, 1)\n    return 1-image_rgb*color\n\n@torch.no_grad()\ndef generate_truncated(S, G, style, noi, trunc_psi = 0.75, num_image_tiles = 8, bitmap_feats=None, batch_size=8):\n    latent_dim = G.latent_dim\n    z = noise(2000, latent_dim)\n    samples = evaluate_in_chunks(batch_size, S, z).cpu().numpy()\n    av = np.mean(samples, axis = 0)\n    av = np.expand_dims(av, axis = 0)\n        \n    w_space = []\n    for tensor, num_layers in style:\n        tmp = S(tensor)\n        av_torch = torch.from_numpy(av).cuda()\n        # import ipdb;ipdb.set_trace()\n        tmp = trunc_psi * (tmp - av_torch) + av_torch\n        w_space.append((tmp, num_layers))\n\n    w_styles = styles_def_to_tensor(w_space)\n    generated_images = evaluate_in_chunks_unet(batch_size, G, bitmap_feats, w_styles, noi)\n    return generated_images.clamp_(0., 1.)\n\n\n@torch.no_grad()\ndef generate_part(model, partial_image, partial_rgb, color=None, percentage=20, num=0, num_image_tiles=8, trunc_psi=1., save_img=False, results_dir='..\/results', evolvement=False):\n    model.eval()\n    ext = 'png'\n    num_rows = np.sqrt(num_image_tiles)\n    latent_dim = model.G.latent_dim\n    image_size = model.G.image_size\n    num_layers = model.G.num_layers\n    if percentage == 'eye':\n        n_eye = 10\n        generated_partial_images_candidates = []\n        scores = torch.zeros(n_eye)\n        for _ in range(n_eye):\n            latents_z = noise_list(num_image_tiles, num_layers, latent_dim)\n            n = image_noise(num_image_tiles, image_size)\n            image_partial_batch = partial_image[:, -1:, :, :]\n            bitmap_feats = model.Enc(partial_image)\n            generated_partial_images = generate_truncated(model.S, model.G, latents_z, n, trunc_psi = trunc_psi, bitmap_feats=bitmap_feats)\n            generated_partial_images_candidates.append(generated_partial_images)\n        generated_partial_images_candidates = torch.cat(generated_partial_images_candidates, 0)\n        # eye size rank\n        n_pixels = generated_partial_images_candidates.sum(-1).sum(-1).sum(-1) # B\n        for rank, i_eye in enumerate(torch.argsort(n_pixels, descending=True)):\n            scores[i_eye] += (rank+1)\/n_eye\n        # eye distance rank\n        initial_stroke = partial_image[:, :1].cpu().data.numpy()\n        initial_stroke_dt = torch.cuda.FloatTensor(distance_transform_edt(1-initial_stroke))\n        dt_pixels = (generated_partial_images_candidates*initial_stroke_dt).sum(-1).sum(-1).sum(-1) # B\n        for rank, i_eye in enumerate(torch.argsort(dt_pixels, descending=False)): # the smaller the better\n            if n_pixels[i_eye] > 3:\n                scores[i_eye] += (rank+1)\/n_eye\n        generated_partial_images = generated_partial_images_candidates[torch.argsort(scores, descending=True)[0]].unsqueeze(0)\n    else:\n        # latents and noise\n        latents_z = noise_list(num_image_tiles, num_layers, latent_dim)\n        n = image_noise(num_image_tiles, image_size)\n        image_partial_batch = partial_image[:, -1:, :, :]\n        bitmap_feats = model.Enc(partial_image)\n        generated_partial_images = generate_truncated(model.S, model.G, latents_z, n, trunc_psi = trunc_psi, bitmap_feats=bitmap_feats)\n    # regular\n    generated_partial_images = generate_truncated(model.S, model.G, latents_z, n, trunc_psi = trunc_psi, bitmap_feats=bitmap_feats)\n    generated_partial_rgb = gs_to_rgb(generated_partial_images, color)\n    generated_images = generated_partial_images + image_partial_batch\n    generated_rgb = 1 - ((1-generated_partial_rgb)+(1-partial_rgb))\n    if save_img:\n        torchvision.utils.save_image(generated_partial_rgb, os.path.join(results_dir, f'{str(num)}-{percentage}-comp.{ext}'), nrow=num_rows)\n        torchvision.utils.save_image(generated_rgb, os.path.join(results_dir, f'{str(num)}-{percentage}.{ext}'), nrow=num_rows)\n    return generated_partial_images.clamp_(0., 1.), generated_images.clamp_(0., 1.), generated_partial_rgb.clamp_(0., 1.), generated_rgb.clamp_(0., 1.)\n    \n\ndef train_from_folder(\n    data_path = '..\/..\/data',\n    results_dir = '..\/..\/results',\n    models_dir = '..\/..\/models',\n    n_part = 1,\n    image_size = 128,\n    network_capacity = 16,\n    batch_size = 3,\n    num_image_tiles = 8,\n    trunc_psi = 0.75,\n    generate_all=False,\n):\n    min_step = 299\n    name_eye='short_bird_creative_sequential_r6_partstack_aug_eye_unet2_largeaug'\n    load_from = load_latest(models_dir, name_eye)\n    load_from = min(min_step, load_from)\n    model_eye = Trainer_cond_unet(name_eye, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_eye.load_config()\n    model_eye.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_eye, load_from)))\n\n    name_head='short_bird_creative_sequential_r6_partstack_aug_head_unet2'\n    load_from = load_latest(models_dir, name_head)\n    load_from = min(min_step, load_from)\n    model_head = Trainer_cond_unet(name_head, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_head.load_config()\n    model_head.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_head, load_from)))\n    \n    name_body='short_bird_creative_sequential_r6_partstack_aug_body_unet2'\n    load_from = load_latest(models_dir, name_body)\n    load_from = min(min_step, load_from)\n    model_body = Trainer_cond_unet(name_body, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_body.load_config()\n    model_body.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_body, load_from)))\n    \n    name_beak='short_bird_creative_sequential_r6_partstack_aug_beak_unet2'\n    load_from = load_latest(models_dir, name_beak)\n    load_from = min(min_step, load_from)\n    model_beak = Trainer_cond_unet(name_beak, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_beak.load_config()\n    model_beak.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_beak, load_from)))\n    \n    name_legs='short_bird_creative_sequential_r6_partstack_aug_legs_unet2'\n    load_from = load_latest(models_dir, name_legs)\n    load_from = min(min_step, load_from)\n    model_legs = Trainer_cond_unet(name_legs, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_legs.load_config()\n    model_legs.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_legs, load_from)))\n    \n    name_wings='short_bird_creative_sequential_r6_partstack_aug_wings_unet2'\n    load_from = load_latest(models_dir, name_wings)\n    load_from = min(min_step, load_from)\n    model_wings = Trainer_cond_unet(name_wings, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_wings.load_config()\n    model_wings.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_wings, load_from)))\n    \n    name_mouth='short_bird_creative_sequential_r6_partstack_aug_mouth_unet2'\n    load_from = load_latest(models_dir, name_mouth)\n    load_from = min(min_step, load_from)\n    model_mouth = Trainer_cond_unet(name_mouth, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_mouth.load_config()\n    model_mouth.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_mouth, load_from)))\n    \n    name_tail='short_bird_creative_sequential_r6_partstack_aug_tail_unet2'\n    load_from = load_latest(models_dir, name_tail)\n    load_from = min(min_step, load_from)\n    model_tail = Trainer_cond_unet(name_tail, results_dir,  models_dir, n_part=n_part, batch_size=batch_size, image_size=image_size, network_capacity=network_capacity)\n    model_tail.load_config()\n    model_tail.GAN.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_tail, load_from)))\n    \n\n    name_selector='short_bird_creative_selector_aug'\n    load_from = load_latest(models_dir, name_selector)\n    part_selector = Trainer_selector(name_selector, results_dir, models_dir, n_part=n_part, batch_size = batch_size, image_size = image_size, network_capacity = network_capacity)\n    part_selector.load_config()\n    part_selector.clf.load_state_dict(torch.load('%s\/%s\/model_%d.pt'%(models_dir, name_selector, load_from)))\n\n    if not os.path.exists(results_dir):\n        os.mkdir(results_dir)\n    inital_dir = '%s\/bird_short_test_init_strokes_%d'%(data_path, image_size)\n    dataset = Initialstroke_Dataset(inital_dir, image_size=image_size)\n    dataloader = data.DataLoader(dataset, num_workers=5, batch_size=batch_size, drop_last=False, shuffle=False, pin_memory=True)\n    # import ipdb;ipdb.set_trace()\n\n    models = [model_eye, model_head, model_body, model_beak, model_legs, model_wings, model_mouth, model_tail]\n    target_parts = ['eye', 'head', 'body', 'beak', 'legs', 'wings', 'mouth', 'tail', 'none']\n    part_to_id = {'initial': 0, 'eye': 1, 'head': 4, 'body': 3, 'beak': 2, 'legs': 5, 'wings': 8, 'mouth': 6, 'tail': 7}\n    max_iter = 10\n    if generate_all:\n        generation_dir = os.path.join(results_dir, 'DoodlerGAN_all')\n        if not os.path.exists(generation_dir):\n            os.mkdir(generation_dir)\n            os.mkdir(os.path.join(generation_dir, 'bw'))\n            os.mkdir(os.path.join(generation_dir, 'color_initial'))\n            os.mkdir(os.path.join(generation_dir, 'color'))\n        for count, initial_strokes in enumerate(dataloader):\n            initial_strokes = initial_strokes.cuda()\n            start_point = len(os.listdir(os.path.join(generation_dir, 'bw')))\n            print('%d sketches generated'%start_point)\n            for i in range(batch_size):\n                samples_name = f'generated-{start_point+i}'\n                stack_parts = torch.zeros(1, 10, image_size, image_size).cuda()\n                initial_strokes_rgb = gs_to_rgb(initial_strokes[i], COLORS['initial'])\n                stack_parts[:, 0] = initial_strokes[i, 0]\n                stack_parts[:, -1] = initial_strokes[i, 0]\n                partial_rgbs = initial_strokes_rgb.clone()\n                prev_part = []\n                for iter_i in range(max_iter):\n                    outputs = part_selector.clf.D(stack_parts)\n                    part_rgbs = torch.ones(1, 3, image_size, image_size).cuda()\n                    select_part_order = 0\n                    select_part_ids = torch.topk(outputs, k=8, dim=0)[1]\n                    select_part_id = select_part_ids[select_part_order].item()\n                    select_part = target_parts[select_part_id]\n                    while (select_part == 'none' and iter_i < 6 or select_part in prev_part):\n                        select_part_order += 1\n                        if select_part_order > 7:\n                            import ipdb;ipdb.set_trace()\n                        select_part_id = select_part_ids[select_part_order].item()\n                        select_part = target_parts[select_part_id]\n                    if select_part == 'none':\n                        break\n                    prev_part.append(select_part)\n                    sketch_rgb = partial_rgbs\n                    stack_part = stack_parts.clone()\n                    select_model = models[select_part_id]\n                    part, partial, part_rgb, partial_rgb = generate_part(select_model.GAN, stack_part, sketch_rgb, COLORS[select_part], select_part, samples_name, 1, results_dir=results_dir, trunc_psi=0.1)\n                    stack_parts[0, part_to_id[select_part]] = part[0, 0]\n                    partial_rgbs[0] = partial_rgb[0]\n                    stack_parts[0, -1] = partial[0, 0]\n                    part_rgbs[0] = part_rgb[0]\n                initial_colored_full = np.tile(np.max(stack_parts.cpu().data.numpy()[:, 1:-1], 1), [3, 1, 1])\n                initial_colored_full = 1-np.max(np.stack([1-initial_strokes_rgb.cpu().data.numpy()[0], initial_colored_full]), 0)\n                cv2.imwrite(os.path.join(generation_dir, 'bw', f'{str(samples_name)}.png'), (1-stack_parts[0, -1].cpu().data.numpy())*255.)\n                cv2.imwrite(os.path.join(generation_dir, 'color_initial', f'{str(samples_name)}-color.png'), cv2.cvtColor(initial_colored_full.transpose(1, 2, 0)*255., cv2.COLOR_RGB2BGR))\n                cv2.imwrite(os.path.join(generation_dir, 'color', f'{str(samples_name)}-color.png'), cv2.cvtColor(partial_rgbs[0].cpu().data.numpy().transpose(1, 2, 0)*255., cv2.COLOR_RGB2BGR))\n    else:\n        now = datetime.now()\n        timestamp = now.strftime(\"%m-%d-%Y_%H-%M-%S\")\n        stack_parts = torch.zeros(num_image_tiles*num_image_tiles, 10, image_size, image_size).cuda()\n        initial_strokes = dataset.sample(num_image_tiles*num_image_tiles).cuda()\n        initial_strokes_rgb = gs_to_rgb(initial_strokes, COLORS['initial'])\n        stack_parts[:, 0] = initial_strokes[:, 0]\n        stack_parts[:, -1] = initial_strokes[:, 0]\n        partial_rgbs = initial_strokes_rgb.clone()\n        partial_rgbs_variation = initial_strokes_rgb.clone()\n        prev_parts = [[] for _ in range(num_image_tiles**2)]\n        samples_name = f'generated-{timestamp}-{min_step}'\n        for iter_i in range(max_iter):\n            outputs = part_selector.clf.D(stack_parts)\n            part_rgbs = torch.ones(num_image_tiles*num_image_tiles, 3, image_size, image_size).cuda()\n            for i in range(num_image_tiles**2):\n                prev_part = prev_parts[i]\n                select_part_order = 0\n                select_part_ids = torch.topk(outputs[i], k=9, dim=0)[1]\n                select_part_id = select_part_ids[select_part_order].item()\n                select_part = target_parts[select_part_id]\n                while (select_part == 'none' and iter_i < 6 or select_part in prev_part):\n                    select_part_order += 1\n                    select_part_id = select_part_ids[select_part_order].item()\n                    select_part = target_parts[select_part_id]\n                if select_part == 'none':\n                    break\n                prev_parts[i].append(select_part)\n                sketch_rgb = partial_rgbs[i].clone().unsqueeze(0)\n                stack_part = stack_parts[i].unsqueeze(0)\n                select_model = models[select_part_id]\n                part, partial, part_rgb, partial_rgb = generate_part(select_model.GAN, stack_part, sketch_rgb, COLORS[select_part], select_part, samples_name, 1, results_dir=results_dir, trunc_psi=0.1)\n                stack_parts[i, part_to_id[select_part]] = part[0, 0]\n                stack_parts[i, -1] = partial[0, 0]\n                partial_rgbs[i] = partial_rgb[0]\n                part_rgbs[i] = part_rgb[0]\n            torchvision.utils.save_image(partial_rgbs, os.path.join(results_dir, f'{str(samples_name)}-{str(min_step)}-round{iter_i}.png'), nrow=num_image_tiles)\n            torchvision.utils.save_image(part_rgbs, os.path.join(results_dir, f'{str(samples_name)}-{str(min_step)}-part-round{iter_i}.png'), nrow=num_image_tiles)\n        torchvision.utils.save_image(1-stack_parts[:, -1:], os.path.join(results_dir, f'{str(samples_name)}-{str(min_step)}-final_pred.png'), nrow=num_image_tiles)\n\nif __name__ == \"__main__\":\n    parser = argparse.ArgumentParser()\n    parser.add_argument(\"--data_dir\", type=str, default='..\/data')\n    parser.add_argument(\"--results_dir\", type=str, default='..\/results\/creative_bird_generation')\n    parser.add_argument(\"--models_dir\", type=str, default='..\/models')\n    parser.add_argument('--n_part', type=int, default=10)\n    parser.add_argument('--image_size', type=int, default=64)\n    parser.add_argument('--network_capacity', type=int, default=16)\n    parser.add_argument('--batch_size', type=int, default=100)\n    parser.add_argument('--num_image_tiles', type=int, default=8)\n    parser.add_argument('--trunc_psi', type=float, default=1.)\n    parser.add_argument('--generate_all', action='store_true')\n\n    args = parser.parse_args()\n    print(args)\n\n    train_from_folder(args.data_dir, args.results_dir, args.models_dir, args.n_part, args.image_size, args.network_capacity, \n        args.batch_size, args.num_image_tiles, args.trunc_psi, args.generate_all)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_327","text":"import numpy as np\nimport pandas as pd\nimport time, copy\nimport pickle as pickle \n\nimport sklearn\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import log_loss\nfrom scipy.special import expit\nimport matplotlib.pyplot as plt\n\n\nfrom sklearn.ensemble import AdaBoostClassifier \nimport statsmodels.api as sm\n\nimport tensorflow as tf\nfrom tensorflow.keras.models import Model, Sequential\nfrom tensorflow.keras.layers import Dense, Dropout, Input\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom tensorflow.python.eager.context import num_gpus\n\nfrom imblearn.over_sampling import SMOTE\nfrom imblearn.under_sampling import  RandomUnderSampler\n\nfrom sub_utils import exp_decay_scheduler, keras_count_nontrainable_params, resample_and_shuffle, create_tf_dataset, reshape_model_input\n\n\nclass Naive_Classifier:\n    \n    '''\n    Create naive baseline classifier, that assigns a constant surrender rate, regardsless of the feature configuration.\n    \n    Parameters\n    ----------\n        rate: Constant probability prediction\n    '''\n    \n    def __init__(self, rate, ):\n        self.rate = rate\n        \n    def predict_proba(self, X):\n        pred = np.zeros(shape=(len(X),2))\n        pred[:,0] = 1-self.rate\n        pred[:,1]= self.rate\n        return pred\n    \n    def predict(self, X):\n        return self.predict_proba(X)\n    \n    def predict_class(self, X, threshold=0.5):\n        return self.predict_proba(X)>threshold\n\n\ndef create_ann(widths: list, actv: list, dropout: float, n_input: int, lrate: float):\n    '''\n    Create individual ANNs for ANN_bagging.\n    '''\n    model = Sequential()\n    for j in range(len(widths)):\n        if j==0: # Specify input size for first layer\n            model.add(Dense(units = widths[j], activation = actv[j], input_dim = n_input))\n        else:\n            model.add(Dense(units = widths[j], activation = actv[j]))\n        if j<(len(widths)-1): # No dropout after output layer\n            model.add(Dropout(rate = dropout))\n\n    model.compile(loss = 'binary_crossentropy', metrics= ['acc'], optimizer=Adam(lr=lrate))\n    return model\n\n\ndef hpsearch_ann(**params):\n    '''\n    Use params obtained via a hpsearch to create an ann.\n    This function is a helper function, to simplify the varying notation.\n    '''\n\n    widths = [params['width_{}'.format(1+i)] for i in range(params['depth'])]+[1]\n    actv = params['depth']*[params['actv']]+['sigmoid']\n    dropout = params['dropout']\n    n_input = params['n_input']\n    lrate = params['lrate']\n    model = create_ann(widths=widths, actv=actv, dropout=dropout, n_input= n_input, lrate = lrate)\n    return model\n\n\ndef hpsearch_boost_ann(resampler ='None', tf_dist_strat = None, **params):\n    '''\n    Helper function to map params to ANN_boost object initialization.\n    '''\n\n    N_boosting = params['n_boosting']\n    n_input = params['n_input']\n    boost_width = params['width']\n    actv = params['actv']\n    lrate = params['lrate']\n\n    return ANN_boost(N_models = N_boosting, N_input = n_input, width=boost_width, act_fct=actv, lr = lrate, resampler = resampler, tf_dist_strat=tf_dist_strat)\n\n\n\nclass Logit_model:\n\n    '''\n    A bagged version of the sklearn LogisticRegression model.\n    '''\n\n    def __init__(self, params, poly_degrees, N_bag = 5, resampler = 'None'):\n        self.poly_degrees = poly_degrees\n        self.resampler = resampler\n        self.N_bag = N_bag\n        try:\n            del params['random_state']\n        except:\n            pass\n        \n        self.models = [LogisticRegression(**params) for _ in range(self.N_bag)]\n\n    def fit(self, X_train, y_train):\n        '''\n        Fit all individual models independently for data X, y.\n        '''\n        \n        for i in range(self.N_bag):\n            # optional resampling\n            if self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            else:\n                X,y = X_train, y_train\n                X,y = sklearn.utils.shuffle(X,y)\n\n            # polynomial feature engineering\n            X_logit, y_logit = reshape_model_input(X, degrees_lst = self.poly_degrees), y\n\n            # fit model\n            self.models[i].fit(X_logit, y_logit)\n\n        # [self.models[i].fit(*shuffle(X_logit, y_logit, random_state=i)) for i in range(self.N_bag)]\n\n        return self # allow for one-line notation of creating and fitting the model\n\n    def predict_proba(self, X):\n        '''\n        Predict probabilities using the full ensembles of self.N_bag individual models.\n        '''\n\n        X_logit = reshape_model_input(X, degrees_lst = self.poly_degrees)\n\n        return np.sum(np.array([self.models[i].predict_proba(X_logit) for i in range(self.N_bag)]), axis = 0)\/self.N_bag\n\n    def predict_proba_running_avg(self, X):\n        '''\n        Predict probabilities for all individual logit-models and report rolling average results, i.e. the benefit of adding more individual models to the ensemble.\n        '''\n\n        X_logit = reshape_model_input(X, degrees_lst = self.poly_degrees)\n        return np.cumsum(np.array([self.models[i].predict_proba(X_logit) for i in range(self.N_bag)]), axis = 0)\/np.arange(1, self.N_bag+1).reshape((-1,1,1))\n\n    def predict_proba_individual(self, X): \n        '''\n        Predict probabilities for all individual logit-models and report them as an array of shape (N_bag, len(X), 2).\n        '''\n\n        X_logit = reshape_model_input(X, degrees_lst = self.poly_degrees)\n        return np.array([self.models[i].predict_proba(X_logit) for i in range(self.N_bag)])    \n\n\nclass ANN_bagging:\n    \n    \"\"\"\n    Purpose: Build multiple ANN models, use the bagged predictor in combination with an optional resampling procedure to reduce the variance of a predictor.\n    New version - compatible with hpsklearn optimized parameter values as input\n\n    Initialize the architecture of all individual models in the bagging procedure.\n            \n            \n            Inputs:\n            -------\n                N_models: Number of models to be included in bagging procedure\n                N_input: Number of input nodes\n                width_lst: List containing the width for all layers, and hence implicitely also the depth of the network\n                act_fct_lst: List containing the activation function for all layers\n                dropout_rate: Dropout rate applied to all layers (except output layer)\n                                dropout_rate = 0 will effectively disable dropout\n                resampler: 'None': No resampling\n                            'SMOTE': SMOTE resampling\n                            'undersampling': RandomUndersampling\n                loss: loss function which the model will be compiled with. Standard option: 'binary_crossentropy'\n                optimizer: loss function which the model will be compiled with. Standard option: 'adam'\n            \n            Outputs:\n            --------\n                None. Creates self.model object with type(object) = dict\n    \"\"\"\n    \n    def __init__(self, N_models: int, hparams:dict, tf_dist_strat, resampler = 'None'):\n\n        self.resampler = resampler\n        self.model = {}\n        self.hparams = hparams\n        self.lr = hparams['lrate']\n        self.tf_dist_strat = tf_dist_strat\n        for i in range(N_models):\n            # create model i\n            try:\n                with self.tf_dist_strat.scope():\n                    self.model[i] = hpsearch_ann(**hparams)     \n            except:\n                self.model[i] = hpsearch_ann(**hparams) \n        # set ensemble model\n        try:\n            with self.tf_dist_strat.scope():\n                INPUT = Input(shape = (self.hparams['n_input'],))\n                self.ensemble = Model(inputs=INPUT, outputs = tf.keras.layers.Average()([self.model[i](INPUT) for i in range(len(self.model))]))\n                # reduce learning rate for final fine-tuning of collective bagged model                \n                self.ensemble.compile(optimizer = Adam(learning_rate=self.lr\/2), loss = 'binary_crossentropy', metrics = ['acc'])    \n        except:\n            INPUT = Input(shape = (self.hparams['n_input'],))\n            self.ensemble = Model(inputs=INPUT, outputs = tf.keras.layers.Average()([self.model[i](INPUT) for i in range(len(self.model))]))\n            # reduce learning rate for final fine-tuning of collective bagged model                \n            self.ensemble.compile(optimizer = Adam(learning_rate=self.lr\/2), loss = 'binary_crossentropy', metrics = ['acc'])   \n\n    def re_init_ensemble(self):\n        '''\n        Note: If we load old parametrizations by setting self.model[i] = value, the self.ensemble does not update automatically. \n        Hence, we need this value for consistently loading old values.\n        '''\n\n        # re-set ensemble model\n        try:\n            with self.tf_dist_strat.scope():\n                INPUT = Input(shape = (self.hparams['n_input'],))\n                self.ensemble = Model(inputs=INPUT, outputs = tf.keras.layers.Average()([self.model[i](INPUT) for i in range(len(self.model))]))\n                # reduce learning rate for final fine-tuning of collective bagged model                \n                self.ensemble.compile(optimizer = Adam(learning_rate=self.lr\/2), loss = 'binary_crossentropy', metrics = ['acc'])    \n        except:\n            INPUT = Input(shape = (self.hparams['n_input'],))\n            self.ensemble = Model(inputs=INPUT, outputs = tf.keras.layers.Average()([self.model[i](INPUT) for i in range(len(self.model))]))\n            # reduce learning rate for final fine-tuning of collective bagged model                \n            self.ensemble.compile(optimizer = Adam(learning_rate=self.lr\/2), loss = 'binary_crossentropy', metrics = ['acc']) \n\n\n    def fit(self, X_train, y_train, callbacks = [], val_share = 0.3, N_epochs = 200):\n        \n        \"\"\"\n        Purpose: Train all model instances in the bagging procedure.\n        \n        output:\n        \\t None. Updates parameters of all models in self.model\n        input\n        \\t X_train, y_train: \\t Training data\n        \\t resampling_option: \\t 'None': No resampling is performed\n        \\t                   \\t 'undersampling': random undersampling of the majority class\n        \\t                     \\t 'SMOTE': SMOTE methodology applied\n        \\t callbacks: \\t callbacks for training\n        \\t val_share, N_epochs, N_batch: \\t Additional arguments for training\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(X_train)==type(pd.DataFrame([1])):\n            X_train=X_train.values\n        if type(y_train) == type(pd.DataFrame([1])):\n            y_train=y_train.values\n\n        # check if GPUs are available\n        try:\n            N_GPUs = self.tf_dist_strat.num_replicas_in_sync()\n        except:\n            N_GPUs = 1\n        \n        for i in range(len(self.model)):\n            # utilze concept of resampling\n            X,y = resample_and_shuffle(X_train, y_train, self.resampler)\n\n            # transform into tf.data.Dataset\n            try:\n                train_data, val_data = create_tf_dataset(X, y, val_share, self.hparams['batch_size']*num_gpus())\n            except:\n                # go on with regular, numpy-data-type\n                print('tf.data.Dataset could not be constructed. Continuing with numpy-data.')\n                pass\n\n            \n            if len(self.model)==1:\n                try:\n                    self.model[i].fit(x=train_data, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                                    validation_data = val_data, verbose = 2, callbacks=callbacks)\n                except:\n                    print('using non-tf.data-format')\n                    self.model[i].fit(x=X, y = y, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                        validation_split= val_share, verbose = 2, callbacks=callbacks)\n            else:\n                if i==0:               \n                    # More compact view on models' training progress\n                    print('Data of shape {} '.format(X.shape) + 'and balance factor {}'.format(sum(y)\/len(y)))\n\n                # Start training of model  \n                print('Training Model {}'.format(i))\n                t_start = time.time()\n                try:\n                    self.model[i].fit(x=train_data, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                            validation_data= val_data, verbose = 2, callbacks=callbacks+[LearningRateScheduler(exp_decay_scheduler)])\n                except:\n                    print('using non-tf.data-format')\n                    self.model[i].fit(x=X, y = y, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                            validation_split= val_share, verbose = 2, callbacks=callbacks+[LearningRateScheduler(exp_decay_scheduler)])\n\n                n_epochs_trained = len(self.model[i].history.history['loss'])\n                print('\\t ...  {} epochs'.format(n_epochs_trained))\n\n                # plt.plot(self.model[i].history.history['loss'], label='loss')\n                # plt.plot(self.model[i].history.history['val_loss'], label='val_loss')\n                # plt.legend()\n                # plt.show()\n                \n                for _ in range(3):\n                    print('\\t ... Fine tuning')\n                    # reduce learning rate\n                    self.model[i].optimizer.learning_rate = self.model[i].optimizer.learning_rate\/2\n                    try:\n                        self.model[i].fit(x=train_data, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                                validation_data= val_data, verbose = 2, callbacks=callbacks+[LearningRateScheduler(exp_decay_scheduler)])#, initial_epoch= n_epochs_trained)\n                    except:\n                        print('using non-tf.data-format')\n                        self.model[i].fit(x=X, y = y, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, \n                                validation_split= val_share, verbose = 2, callbacks=callbacks+[LearningRateScheduler(exp_decay_scheduler)])#, initial_epoch= n_epochs_trained)\n                    # print(self.model[i].history.history)\n                    # n_epochs_trained += len(self.model[i].history.history['loss'])\n\n                print('\\t ... Overall time: {} sec.'.format(time.time()-t_start))\n                print('\\t ... Done!')\n\n                # plt.plot(self.model[i].history.history['loss'], label='loss')\n                # plt.plot(self.model[i].history.history['val_loss'], label='val_loss')\n                # plt.legend()\n                # plt.show()\n\n\n\n        print('Final fine tuning of whole bagged estimator:')\n        t_start = time.time() \n        try:\n            self.ensemble.fit(x=train_data, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, validation_data= val_data, verbose = 0, callbacks=callbacks)\n        except:\n            print('using non-tf.data-format')\n            self.ensemble.fit(x=X, y = y, batch_size= N_GPUs*self.hparams['batch_size'], epochs = N_epochs, validation_split= val_share, verbose = 0, callbacks=callbacks)\n        print('\\t ...  {} epochs'.format(len(self.ensemble.history.history['val_loss'])))\n        print('\\t ... {} sec.'.format(time.time()-t_start))\n        print('\\t ... Done!')\n        \n        # Return object to allow for shorter\/ single-line notation, i.e. ANN_bagging().fit()\n        return self\n        \n    def predict(self, X):  \n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        Inputs:\n        -------\n        \\t X: \\t Input data        \n        \n        Outputs:\n        --------\n        \\t Predictions for all input data\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(X)==type(pd.DataFrame([1])):\n            X=X.values\n        return self.ensemble.predict(X)\n    \n\n    def predict_proba(self, X):\n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        Replicate predict_proba method of Sequential() or Model() class to unify notation.\n        See documentation of self.predict() method.\n        \"\"\"\n        # handle pandas-datatype\n        if type(X)==type(pd.DataFrame([1])):\n            X=X.values\n        return self.predict(X)\n    \n\n    def predict_classes(self, X, threshold = 0.5):\n        \n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of Sequential() or Model() class to unify notation.\n        \"\"\"\n        # handle pandas-datatype\n        if type(X)==type(pd.DataFrame([1])):\n            X=X.values\n        return (self.predict(X)>= threshold)\n\n\nclass ANN_boost:\n    \n    '''\n    Create a boosting instance with neural networks as weak learner instances.\n    As we add a new weak learner it will train primarily on errors of previous models. Boost rate equal 1, i.e. weak learners added by summation.  \n    For the purpose of binary classification we impose a binary_crossentropy loss.\n    \n    '''\n    \n    def __init__(self, N_models, N_input, width: int, act_fct: str, lr = 0.001, tf_dist_strat = None, resampler = 'None'):\n        \n        \"\"\"\n        Initialize the architecture of all individual models in the bagging procedure.\n        Model style of weak learner: input->hidden_layer-> actv_fct-> single output (incl linear actv) -> sigmoid actv (to be carved off when combining multiple weak learners)\n        \n        \n        Inputs:\n        -------\n            N_models: Number of models to be included in bagging procedure\n            N_input: Number of input nodes\n            width_lst: List containing the width for all layers, and hence implicitely also the depth of the network\n            act_fct_lst: List containing the activation function for all layers. \n                            Last entry should be linear, as boosting models add a final sigmoid activation to the added weak learners to ensure a proper probability distribution.\n            dropout_rate: Dropout rate applied to all layers (except output layer)\n                            dropout_rate = 0 will effectively disable dropout\n            loss: loss function which the model will be compiled with. Standard option: 'binary_crossentropy'\n            optimizer: loss function which the model will be compiled with. Standard option: 'adam'\n        \n        Outputs:\n        --------\n            None. Creates self.model_base objects with type(object) = dict\n        \"\"\"        \n        \n        self.N_models = N_models\n        self.loss = 'binary_crossentropy'\n        self.N_input = N_input\n        self.width = width\n        self.act_fct = act_fct\n        self.tf_dist = tf_dist_strat\n        # self.dropout_rate = dropout_rate # canceled; not useful with only one hidden layer of which we tune its width\n        self.lr_init = lr\n        self.optimizer = Adam(learning_rate=self.lr_init)\n        self.resampler = resampler\n        self.history_val = []\n        self.history_train = []\n        self.training_steps = 0\n        \n            \n        # boosted models will be assigned during fitting procedure\n        #self.model_boost = [None]*self.N_models # depreciated version\n        self.model_boost = None # Save memory by reusing file-space, i.e. not saving each intermediate boosting step separately as they are recorded by self.model_base\n        # Create list of weak learner instances (compilation happens in creating functions)\n        # try:\n        #     with self.tf_dist.scope():\n        #         self.model_base = [self.create_model_prior()]+[self.create_model_learner() for _ in range(self.N_models-1)]\n        # except Exception as e:\n        #     print('Leaners not created within tf-distribution-strategy due to:')\n        #     print(e)\n        self.model_base = [self.create_model_prior()]+[self.create_model_learner() for _ in range(self.N_models-1)]\n                    \n            \n    def fit(self, x, y,  callbacks = [], val_share = 0.3, N_epochs = 200, N_batch = 64, correction_freq = 5):\n        \n        '''\n        Fitting procedure for the ANN_boost object.\n        \n        Inputs:\n        -------\n            x: Input Data\n            y: Targets\n            callbacks: list of tf.keras.callbacks objects, e.g. earlyStopping\n            val_share: share of (x,y) used for validation of the model during training and for potential callback options\n            N_epochs: number of epochs for training\n            N_batch: batch size for training\n            correction_freq: frequency in which a corrective step is performed, e.g. 0: never, 1: every epoch, 5: every 5 epochs, ...\n        '''\n\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost.fit: x values changed from pandas.DataFrame to numpy.array')\n        if type(y) == type(pd.DataFrame([1])):\n            y=y.values\n            #print('ANN_boost.fit: y values changed from pandas.DataFrame to numpy.array')\n\n\n        # optional resampling\n        x,y = resample_and_shuffle(x, y, self.resampler)\n\n        # transform into tf.data.Dataset (important: transformation after optional resampling)\n        try:\n            train_data, val_data = create_tf_dataset(x,y,val_share, N_batch*num_gpus())\n        except:\n            # go on with regular, numpy-data-type\n            print('tf.data.Dataset could not be constructed. Continuing with numpy-data.')\n            pass\n        \n\n        \n        if self.N_input != x.shape[1]:\n            raise ValueError('Error: Invalid input shape. Expected ({},) but given ({},)'.format(self.N_input, x.shape[1]))\n\n        \n        # iterate over number of weak learners included in boosting\n        INPUT = Input(shape= (self.N_input,)) # re-use this input layer to avoid more cache-intensiv multi-inputs models\n        for n in range(1,self.N_models+1):\n            \n            try:\n                with self.tf_dist.scope():\n                    if n == 1:\n                        # Note: Average Layer expects >= 2 inputs\n                        # Add final sigmoid Activation for classification\n                        self.model_boost = Model(inputs = INPUT, outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(self.model_base[0](INPUT)))\n                    else:\n                        self.model_boost = Model(inputs = INPUT,#[self.model_base[i].input for i in range(n)], \n                                                    # Note: Average() needs list as input; use .output, not .outputs (-> list of lists)\n                                                    outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(\n                                                        tf.keras.layers.Add()(\n                                                            [self.model_base[i](INPUT) for i in range(n)]# .output for i in range(n)]\n                                                        )\n                                                    )\n                                                )\n                    # set trainable = True for newly added weak learner (relevant if we retrain model)\n                    self.model_base[n-1].trainable = True\n                    # compile model\n                    self.model_boost.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n\n            except Exception as e:\n                print('Booster not created within distribution strategy due to:')\n                print(e)\n                if n == 1:\n                    # Note: Average Layer expects >= 2 inputs\n                    # Add final sigmoid Activation for classification\n                    self.model_boost = Model(inputs = INPUT, outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(self.model_base[0](INPUT)))#.output))\n                else:\n                    self.model_boost = Model(inputs = INPUT,#[self.model_base[i].input for i in range(n)], \n                                                # Note: Average() needs list as input; use .output, not .outputs (-> list of lists)\n                                                outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(\n                                                    tf.keras.layers.Add()(\n                                                        [self.model_base[i](INPUT) for i in range(n)]# .output for i in range(n)]\n                                                    )\n                                                )\n                                                )\n                # set trainable = True for newly added weak learner (relevant if we retrain model)\n                self.model_base[n-1].trainable = True\n                # compile model\n                self.model_boost.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])        \n\n\n            # train boosting model\n            print('Training Model {}'.format(n))\n            print('\\t trainable params: '+ str(keras_count_nontrainable_params(self.model_boost, trainable=True)))\n            print('\\t nontrainable params: '+ str(keras_count_nontrainable_params(self.model_boost, trainable=False)))\n\n            t_start = time.time()\n            if (n==1):\n                # set weights = 0 and bias = sigmoid^-1(baseline_hazard)\n                try:\n                    with self.tf_dist.scope():\n                        self.model_boost.layers[1].set_weights([np.array([0]*self.N_input).reshape((-1,1)), np.array([np.log(y.mean()\/(1-y.mean()))])])\n                except Exception as e:\n                    print('Setting weights of baseline-learner not performed within tf-distribution-strategy due to:')\n                    print(e)\n                    self.model_boost.layers[1].set_weights([np.array([0]*self.N_input).reshape((-1,1)), np.array([np.log(y.mean()\/(1-y.mean()))])])\n            else:\n                try:\n                # if data in tf.data.Dataset format available\n                    print('\\t .. training on tf.data.Dataset')\n                    self.model_boost.fit(x=train_data, validation_data = val_data, epochs = N_epochs, verbose = 2, callbacks=callbacks)\n                except Exception as e:\n                    print('Leaners not created within tf-distribution-strategy due to:')\n                    print(e)\n                    self.model_boost.fit(x=x, y = y, batch_size= N_batch, epochs = N_epochs, validation_split= val_share, verbose = 0, callbacks=callbacks)\n                self.history_val += self.model_boost.history.history['val_loss']\n                self.history_train += self.model_boost.history.history['loss']\n                \n                # evolutionary fitting of boosting model\n                #self.fit_evolutionary(x=x, y=y, batch_size=N_batch, epochs=N_epochs, epochs_per_it=25, validation_split=val_share, callbacks=callbacks)\n                \n                print('\\t ...  {} epochs'.format(len(self.history_val)-self.training_steps))              \n                self.training_steps = len(self.history_val)\n\n            print('\\t ... {} sec.'.format(time.time()-t_start))\n            #print('\\t ... eval.: ', self.model_boost.evaluate(x,y, verbose=0)) # optional: display to observe progress of training; however, slows down training.\n            print('\\t ... Done!')\n\n            # decaying influence of weak learners\n            #self.optimizer.lr = self.lr_init*0.9**n\n\n            \n            # corrective step: set all parameters as trainable and update them using SGD\n            if n>1:\n                if (correction_freq > 0) & (n%correction_freq ==0):\n                    self.corrective_step(model = self.model_boost, x=x, y=y, callbacks=callbacks, \n                                        val_share=val_share, N_epochs = N_epochs, N_batch= N_batch)\n            \n            \n            \n            # set trainable = False for weak learner that has been included in the boosting model \n            self.model_base[n-1].trainable = False\n\n\n    def fit_evolutionary(self, x, y, batch_size, epochs, epochs_per_it, validation_split, callbacks):\n        '''\n        Customized training scheme, using early stopping\/ callbacks and a iterative reduction of the initial learning rate.\n        ## DEPRECIATED as not very affective in the given scenario\n        '''\n        \n        self.model_boost.fit(x=x, y = y, batch_size= batch_size, epochs = epochs_per_it, validation_split=validation_split, verbose = 0, callbacks=callbacks)\n        self.history_train += self.model_boost.history.history['loss']\n        self.history_val += self.model_boost.history.history['val_loss']\n        #print(self.history_train)\n        #print(type(self.history_train))\n        val_loss = min(self.history_val)\n        #print('minimum val_loss: ', val_loss)\n\n\n        evol_patience = 0\n        for ep in range(epochs\/\/epochs_per_it):\n            self.optimizer.lr= self.lr_init*1.2**(1+ep%4)\n            # compile to effectively update lr\n            self.model_boost.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n            print(' \\t Fine tuning step ', ep, '...', ' (val_loss: ', np.round_(val_loss,4), ')')\n            self.model_boost.fit(x=x, y = y, batch_size=batch_size, epochs = epochs_per_it, validation_split=validation_split, verbose = 0, callbacks=callbacks)\n            # record training\/ validation history\n            self.history_train += self.model_boost.history.history['loss']\n            self.history_val += self.model_boost.history.history['val_loss']\n            \n            if min(self.history_val) < val_loss*0.99:\n                val_loss = min(self.history_val)\n            else:\n                evol_patience += 1\n                if evol_patience > 3:\n                    break            \n    \n    def corrective_step(self, model, x, y, callbacks = [], val_share = 0.3, N_epochs = 200, N_batch = 64):\n        '''\n        Perform a corrective step by updating all parameters of boosting model, i.e. all included weak learners.\n        '''\n        \n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost.fit: x values changed from pandas.DataFrame to numpy.array')\n        if type(y) == type(pd.DataFrame([1])):\n            y=y.values\n            #print('ANN_boost.fit: y values changed from pandas.DataFrame to numpy.array')\n\n\n        # transform into tf.data.Dataset\n        try:\n            train_data, val_data = create_tf_dataset(x,y,val_share, N_batch*num_gpus())\n        except:\n            # go on with regular, numpy-data-type\n            print('tf.data.Dataset could not be constructed. Continuing with numpy-data.')\n            pass\n\n        # allow updating of all parameters\n        try:\n            with self.tf_dist.scope():\n                model.trainable = True\n                model.compile(optimizer = Adam(lr=self.lr_init\/2), loss = self.loss, metrics = ['acc'])\n        except Exception as e:\n            print('Leaners not created within tf-distribution-strategy due to:')\n            print(e)\n            model.trainable = True\n            model.compile(optimizer = Adam(lr=self.lr_init\/2), loss = self.loss, metrics = ['acc'])\n        \n        print('Corrective Step ... ')\n        print('\\t trainable params: '+ str(keras_count_nontrainable_params(model, trainable=True)))\n        print('\\t nontrainable params: '+ str(keras_count_nontrainable_params(model, trainable=False)))\n\n        t_start = time.time()\n        \n        #self.fit_evolutionary(x=x, y=y, batch_size=N_batch, epochs=N_epochs, epochs_per_it=25, validation_split=val_share, callbacks=callbacks)\n        try:\n            # train with tf.data.dataset; explicitly indicate val_data; batch_size indicated in tf.data.dataset\n            model.fit(x=train_data, epochs = N_epochs,  validation_data= val_data, verbose = 2, callbacks=callbacks)\n        except Exception as e:\n            print('Model not created within tf-distribution-strategy due to:')\n            print(e)\n            model.fit(x=x, y = y, batch_size= N_batch, epochs = N_epochs,  validation_split= val_share, verbose = 2, callbacks=callbacks)\n\n\n\n        print('\\t ...  {} epochs'.format(len(model.history.history['val_loss'])))\n        run_time = time.time()-t_start\n        print('\\t ... {} sec.'.format(run_time))\n        print('\\t ... Correction performed!')\n              \n        # Lock updates\n        model.trainable = False      \n\n        return run_time\n        \n    def save_object(self, path):\n        '''\n        Function to save the ANN_boost object. \n        Required, as e.g. Sequential()-Object in self.model_base[i] cannot be pickled or dilled. \n        Hence, we save only the respective weights and provide a function load_object to restore the fully functional ANN_boost object.\n        Note: load_ANN_boost_object is no ANN_boost object function. However, the loaded ANN_boost object uses object.restore_learners() to restore learners and boosted models.\n        '''\n        # save weights of learners\n        #self.model_base = [self.model_base[i].get_weights() for i in range(self.N_models)]\n        # delete boosted models temporarily for pickling; can be restored with weights of (trained) learners\n        #cache = clone_model(self.model_boost)\n        #cache.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n        \n        model_backup = ANN_boost(N_models= self.N_models, N_input= self.N_input, width = self.width, act_fct = self.act_fct)\n        model_backup.model_base = [sub_model.get_weights() for sub_model in self.model_base] # save only weights -> to be restored in self.restore_learners()\n        # Note: Adam-object cannot be pickled in tf 2.4.\n        # workaround: switch to string-information and restore full optimizer (incl. learning_rate) in restore_learners\n        model_backup.optimizer = 'adam' \n\n        #self.model_boost = None#*self.N_models\n        with open( path, \"wb\" ) as file:\n            pickle.dump(model_backup, file)\n            print('ANN object dumped to ', path)\n\n        #self.model_boost = cache\n\n    def restore_learners(self):\n        '''\n        Restore the full Sequential() architecture of self.model_base[i] and self.model_boost[i] which were replaced by their weights to pickle dump the object.\n        '''\n        weights = copy.copy(self.model_base)\n        self.model_base = [self.create_model_prior()]+[self.create_model_learner() for _ in range(1,self.N_models)]\n        [self.model_base[i].set_weights(weights[i]) for i in range(self.N_models)]\n        #print(self.model_base)\n        # iterate over number of weak learners included in boosting\n        for n in range(1,self.N_models+1):\n            INPUT = Input(shape= (self.N_input,))\n            if n == 1:\n                # Note: Average Layer expects >= 2 inputs\n                # Add final sigmoid Activation for classification\n                #self.model_boost[n-1] = Model(inputs = self.model_base[0].input, \n                #                              outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(self.model_base[0].output))\n                self.model_boost = Model(inputs = INPUT,#self.model_base[0].input, \n                                        outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(self.model_base[0](INPUT)))#.output))\n            else:\n                #self.model_boost[n-1] \n                self.model_boost = Model(inputs = INPUT,#[self.model_base[i].input for i in range(n)], \n                                              # Note: Average() needs list as input; use .output, not .outputs (-> list of lists)\n                                              outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(\n                                                  tf.keras.layers.Add()(\n                                                      [self.model_base[i](INPUT) for i in range(n)]# .output for i in range(n)]\n                                                  )\n                                              )\n                                             )\n\n            # set trainable = True for newly added weak learner (relevant if we retrain model)\n            self.model_base[n-1].trainable = True\n            # compile model\n            self.model_boost.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n\n    def create_model_prior(self):\n        '''\n        Base model 0 in boosting structure; expresses a prior estimate (here constant rate) that will be improved by subsequent model created by create_model_learner.\n        '''\n        model = Sequential()\n        model.add(Dense(1, activation= 'linear', input_dim = self.N_input))\n        model.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n        return model\n\n    def create_model_learner(self):\n        '''\n        Create architecture for weak learners in boosting strategy.\n        '''\n        model = Sequential()\n        # Hidden layer\n        try:\n            model.add(Dense(units = self.width, activation = self.act_fct, input_dim = self.N_input))\n        except:\n            # old implementation\n            model.add(Dense(units = self.width_lst[0], activation = self.act_fct_lst[0], input_dim = self.N_input))\n            print('sub_surrender_models, create_model_learner(): atributes width_lst and act_fct_lst depreciated!')\n        # Output layer\n        model.add(Dense(units = 1, activation = 'linear'))\n        model.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n        return model\n\n    def prune_booster(self, n_learners:int):\n        '''\n        Take user input how many weak learners should be utilized. The rest will be discarded.\n        '''\n\n        assert n_learners<= self.N_models\n        assert n_learners > 1\n\n        INPUT = Input(shape= (self.N_input,)) # re-use this input layer to avoid more cache-intensiv multi-inputs models\n        self.model_boost = Model(inputs = INPUT,#[self.model_base[i].input for i in range(n)], \n                                                    # Note: Average() needs list as input; use .output, not .outputs (-> list of lists)\n                                                    outputs = tf.keras.layers.Activation(tf.keras.activations.sigmoid)(\n                                                        tf.keras.layers.Add()(\n                                                            [self.model_base[i](INPUT) for i in range(n_learners)]# .output for i in range(n)]\n                                                        )\n                                                    )\n                                                )\n        # compile model\n        self.model_boost.compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n        \n\n    def evaluate(self, x, y=None):\n        try:\n            # x is tf.data.Dataset\n            return self.model_boost.evaluate(x, verbose=0)\n        except:\n            return self.model_boost.evaluate(x,y, verbose=0)\n\n    def predict_proba(self, x):\n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost.fit: x values changed from pandas.DataFrame to numpy.array')\n\n        \n        # Use last iteration of boosting procedure\n        # Note: tf.keras.models.Model() does not posses .predict_proba(), but only .predict()\n        return self.model_boost.predict(x)\n    \n    \n    def predict(self, x):\n\n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost.fit: x values changed from pandas.DataFrame to numpy.array')\n\n        \n        # Use last iteration of boosting procedure\n        # Note: tf.keras.models.Model() does not posses .predict_proba(), but only .predict()\n        return self.model_boost.predict(x)\n    \n\n    def predict_classes(self, x, threshold = 0.5):\n        \n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of Sequential() or Model() class to unify notation.\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost.fit: x values changed from pandas.DataFrame to numpy.array')\n        return (self.predict(x)> threshold)\n    \n\ndef analyze_ensemble(model, x, y, profile: int, poly_degrees_max = None):\n    '''\n    Check for different model types, i.e. Logit-ensemble, ANN-ensemble and ANN-booster, by how much an additional learners improves the performance.\n    Goal: Determine a reasonable number of the depth of boosting\/ no. of weak lerners to work together, to limit computational effort\n\n    Inputs:\n    -------\n        model:  model(s) to evaluate; either list of models or single model\n        x:      input data, typically validation data\n        y:      target data, typically validation data\n\n    Outputs:\n    --------\n        None; a plot with performance over number of learners is produced.\n    '''\n\n    if type(model) == type([]):\n        pass\n    else:\n        model = [model]\n\n    for m in model:\n        if type(m) == ANN_bagging:\n            try: x_val = x.values\n            except: pass\n            # learners = model.model # dictionary of learners\n            pred = [l.predict(x_val) for l in m.model.values()]\n            # respect avering effect of bagging-ensemble\n            pred = np.cumsum(np.array(pred), axis = 0)\/np.arange(1, len(pred)+1).reshape((-1,1,1))\n            entropy = [log_loss(y_true = y, y_pred=p) for p in pred]\n            plt.plot(range(1, len(pred)+1), entropy, label = 'NN (bag)')\n        elif type(m) == ANN_boost:\n            try: x_val = x.values\n            except: pass\n            # learners = model.model_base # list of models\n            pred = [l.predict(x_val) for l in m.model_base]\n            # Note: do not forget final sigmoid function to form boosted-ensemble-prediction\n            pred = expit(np.cumsum(np.array(pred), axis = 0))\n            entropy = [log_loss(y_true = y, y_pred=pred[i]) for i in range(len(pred))]\n            plt.plot(range(1, len(pred)+1), entropy, label = 'NN (boost)')\n        elif type(m) == Logit_model:\n            assert type(poly_degrees_max) != type(None)\n            # learners = model.models # list of models\n            pred = [l.predict_proba(reshape_model_input(x, degrees_lst=[poly_degrees_max]*x.shape[1]))[:,-1] for l in m.models]\n            # respect avering effect of bagging-ensemble\n            pred = np.cumsum(np.array(pred), axis = 0)\/np.arange(1, len(pred)+1).reshape((-1,1))\n            entropy = [log_loss(y_true = y, y_pred=p) for p in pred]\n            plt.plot(range(1, len(pred)+1), entropy, label = 'Logist. Regr.')\n        else:\n            raise ValueError('Model type not compatible with method!')\n\n    plt.ylabel('entropy loss')\n    plt.xlabel('# of learners')\n    plt.yscale('log')\n    plt.legend()\n    plt.title(f'ensemble models of profile {profile}')\n    plt.show()\n\n\n\n########################################\n########### LEGACY CODE ################\n########################################\n\n# Note: These classes are either not used, e.g. since Logit_boosting showed poor performance, \n# or have been updated to a later version, e.g. Logit_model_old (with integrated feature preprocessing) -> Logit_model (a priori feature-preprocessing and K-Fold)\n\nclass Logit_model_old:\n    '''\n    Create a logistic model from either sklearn or statsmodels (significance analysis in summary included).\n    Further, we allow for adding higher degrees of the input variables without having to change the input data.\n    \n    Requirements: \n    \\t import statsmodels.api as sm\n    \\t from sklearn.models import LogisticRegression\n    '''\n    \n    def __init__(self, package='sklearn', polynomial_degrees = [1,1,1], resampler = 'None',\n                 X = None, y = None):\n        self.package = package\n        self.poly_degrees = polynomial_degrees\n        # Polynomial degrees of features selected after feed-forward fitting process\n        self.poly_selected = [1]*len(polynomial_degrees)\n        \n        self.resampler = resampler\n        if package == 'sklearn':\n            self.model = LogisticRegression(solver = 'liblinear', penalty = 'l2')\n        elif package == 'statsmodels':\n            \n            if self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X, y=y)\n            elif self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X, y=y)\n            elif self.resampler == 'None':\n                # Do nothing\n                pass\n            else:\n                print('Error: Resampler not recognized!')\n                \n            self.model = sm.Logit(endog = y, exog = reshape_model_input(sm.add_constant(X),\n                                                                          degrees_lst =self.poly_degrees))\n        else:\n            print('Error: Package not valid!')\n            \n            \n    def fit(self, X=None, y=None, val_share = 0.2):\n        \n        '''\n        Fit a Logistic Regression object. \n        Add higher-order polynomials of the input features in a feed-forward manner up to the max input-polynomial degree.\n        E.g. poly_degrees = [3,3,3] would result in checking [1,1,1], [2,1,1], .., [2,2,2], [3,2,2], ... [3,3,3]\n        Degree is only increased if validation error increases.\n        \n        Parameters\n        ----------\n            X: Features\n            y: Targets\n            var_share: Share of (X,y) used for validation during the forward-selection of features\n        '''\n        \n        if self.package == 'sklearn':\n            \n            if self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X, y=y)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X, y=y)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'None':\n                # Do nothing\n                pass\n            else:\n                print('Error: Resampler not recognized!')\n            \n            \n            \n            \n            # forward selection\n            n = len(self.poly_degrees)\n            bool_degree_increase = [True]*n\n            degrees_start = [1]*n\n            best_model = self.model.fit(X = reshape_model_input(X[0:int((1-val_share)*len(X))], \n                                                      degrees_lst =degrees_start), y = y[0:int((1-val_share)*len(y))])\n            \n            best_model_eval = sklearn.metrics.log_loss(y_true = y[int((1-val_share)*len(y)):],\n                               y_pred=best_model.predict_proba(X = reshape_model_input(X[int((1-val_share)*len(X)):], \n                                                                                          degrees_lst =degrees_start))[:,-1])\n            \n            # \n            for _ in range(1,max(self.poly_degrees)):\n                # increase all elements\/ orders in list stepwise each by magnitude of 1\n                for i in range(n):\n                    # check if degree permitted by self.poly_degrees\n                    if (degrees_start[i]+1 <= self.poly_degrees[i])& bool_degree_increase[i]:\n                        degrees_start[i]+=1\n                        \n                        #print(degrees_start)\n                        \n                        model_new = self.model.fit(X = reshape_model_input(X[0:int((1-val_share)*len(X))], \n                                                      degrees_lst =degrees_start), y = y[0:int((1-val_share)*len(y))])\n                        model_new_eval = sklearn.metrics.log_loss(y_true = y[int((1-val_share)*len(y)):],\n                               y_pred = model_new.predict_proba(X = reshape_model_input(X[int((1-val_share)*len(X)):], \n                                                                                          degrees_lst =degrees_start)))\n                        \n                        \n                        # compare validation error\n                        if model_new_eval< best_model_eval:\n                            # save new, best model reference\n                            best_model_eval = copy.copy(model_new_eval)\n                            best_model = copy.copy(model_new)\n                        else:\n                            # reverse increase of polynomial order and stop fwd-selection of feature i\n                            degrees_start[i]-=1\n                            #print('Validation error increased for feature {}.'.format(i))\n                            bool_degree_increase[i] = False   \n                            \n                    #print(str(model_new.coef_.shape)+ '(new) vs. (best) ' + str(best_model.coef_.shape))\n                    #print('\\n')       \n                \n            self.poly_selected = degrees_start\n            self.model = best_model\n            # fit cross-validated model on selected poly.-degrees for all data\n            #self.model = self.model.fit(X = reshape_model_input(X, degrees_lst =self.poly_selected), y = y)\n            \n            print('Logistic model built successfully; pruned to polynomial features with degrees {}'.format(self.poly_selected))\n            \n        if self.package == 'statsmodels':\n            self.model = self.model.fit(method='bfgs', maxiter=100)\n            print('Note: Fitting data for statsmodel provided at initialization.')\n            print('Note: Forward selection of model features not implemented for \"statsmodels-package\".')\n            \n        return self\n          \n        \n        \n    def predict(self, X):\n        \n        \"\"\"\n        Purpose: Predict class for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n        \n        if self.package == 'sklearn':\n            return self.model.predict(X = reshape_model_input(df_input = X, degrees_lst =self.poly_selected))\n        elif self.package == 'statsmodels':\n            return self.model.predict(exog=reshape_model_input(df_input = sm.add_constant(X),\n                                                                          degrees_lst =self.poly_selected))\n        else:\n            print('Error: Package unknown!') \n            \n            \n\n    def predict_proba(self, X):\n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        Replicate predict_proba method of other model-classes to unify notation.\n        See documentation of self.predict() method.\n        \"\"\"\n        if self.package == 'sklearn':\n            return self.model.predict_proba(X = reshape_model_input(df_input = X, degrees_lst =self.poly_selected))\n        elif self.package == 'statsmodels':\n            return self.model.predict(exog=reshape_model_input(df_input = sm.add_constant(X),\n                                                                          degrees_lst =self.poly_selected))\n        else:\n            print('Error: Package unknown!')\n            \n \n    \n    def predict_classes(self, X, threshold = 0.5):\n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of other model-classes to unify notation.\n        \"\"\"            \n        return self.predict_proba(X)>threshold\n    \n \n    \n    def summary(self, X=None):\n        \n        '''\n        Provide brief summary of coefficients, values and significance (for statsmodels only).\n        '''\n        if self.package == 'sklearn':\n            \n            df = pd.DataFrame(data = None,\n                               columns = ['const.']+list(reshape_model_input(df_input = X.loc[0:1,:], \n                                                                        degrees_lst =self.poly_selected).columns))\n            df.loc['',:] = [self.model.intercept_[0]]+self.model.coef_.flatten().tolist()\n            \n            print(df)\n            \n        elif self.package == 'statsmodels':\n            # Use summary() of statsmodels.api.Logit object\n            print(self.model.summary())\n\n# preliminary - class not functional yet\nclass ANN_boost_grad:\n    \n    '''\n    Create a gradient boosting instance with neural networks as weak learner instances.\n    As we add a new weak learner it will train primarily on errors of previous models. Boost rate initialized with 1, but eventually adapted in corrective step.  \n    For the purpose of binary classification we impose a binary_crossentropy loss.\n    \n    '''\n    \n    def __init__(self, N_models, N_input, width_lst = [], act_fct_lst = [], dropout_rate = 0,  optimizer = 'adam'):\n        \n        \"\"\"\n        Initialize the architecture of all individual models in the bagging procedure.\n        \n        \n        Inputs:\n        -------\n            N_models: Number of models to be included in bagging procedure\n            N_input: Number of input nodes\n            width_lst: List containing the width for all layers, and hence implicitely also the depth of the network\n            act_fct_lst: List containing the activation function for all layers. \n                            Last entry should be sigmoid, as gradient boosting models add probability outputs of weak learners.\n            dropout_rate: Dropout rate applied to all layers (except output layer)\n                            dropout_rate = 0 will effectively disable dropout\n            loss: loss function which the model will be compiled with. Standard option: 'binary_crossentropy'\n            optimizer: loss function which the model will be compiled with. Standard option: 'adam'\n        \n        Outputs:\n        --------\n            None. Creates self.model_base objects with type(object) = dict\n        \"\"\"        \n        \n        self.N_boost = N_models\n        self.optimizer = optimizer\n        self.loss = 'binary_crossentropy'\n        self.N_input = N_input\n        \n        if act_fct_lst[-1] != 'sigmoid':\n                raise Exception('Gradient boosting models adds probability outputs of weak learners. Final activation should be sigmoid!')\n            \n        # boosted models will be assigned during fitting procedure\n        self.model_boost = {}\n        # Create weak learner instances\n        self.model_base = {}\n        for i in range(N_models):\n            # Create first model to to capture baseline hazard\n            if i == 0:\n                self.model_base[i] = Sequential()\n                self.model_base[i].add(Dense(1, activation= 'sigmoid', input_dim = N_input))\n                \n            else:\n                self.model_base[i] = Sequential()\n                for j in range(len(width_lst)):\n                    if j==0: # Specify input size for first layer\n                        self.model_base[i].add(Dense(units = width_lst[j], activation = act_fct_lst[j], input_dim = N_input))\n                    else:\n                        self.model_base[i].add(Dense(units = width_lst[j], activation = act_fct_lst[j]))\n                    if j<(len(width_lst)-1): # No dropout after output layer\n                        self.model_base[i].add(Dropout(rate = dropout_rate))\n                    \n            # compile base models       \n            self.model_base[i].compile(optimizer = self.optimizer, loss = self.loss, metrics = ['acc'])\n            \n            \n            \n    def fit(self, x, y,  callbacks = [], val_share = 0.2, N_epochs = 200, N_batch = 64, correction_freq = 1):\n        \n        '''\n        Fitting procedure for the ANN_boost_grad object.\n        \n        Inputs:\n        -------\n            x: Input Data\n            y: Targets\n            callbacks: list of tf.keras.callbacks objects, e.g. earlyStopping\n            val_share: share of (x,y) used for validation of the model during training and for potential callback options\n            N_epochs: number of epochs for training\n            N_batch: batch size for training\n            correction_freq: frequency in which a corrective step is performed, e.g. 0: never, 1: every epoch, 5: every 5 epochs, ...\n        '''\n        \n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost_grad.fit: x values changed from pandas.DataFrame to numpy.array')\n        if type(y) == type(pd.DataFrame([1])):\n            y=y.values\n            #print('ANN_boost_grad.fit: y values changed from pandas.DataFrame to numpy.array')\n\n        if self.N_input== x.shape[1]:\n            pass\n        else:\n            print('Error: Invalid input shape. Expected ({},) but given ({},)'.format(self.N_input, x.shape[1]))\n            exit() \n            \n        if type(y) != type(np.array([1])):\n            # transform pd.series to np.array format -> required for tf.keras model and sample_weight\n            y = y.values.reshape((-1,1))\n            \n            \n        \n        # iterate over number of weak learners included in boosting\n        for n in range(1,self.N_boost+1):\n            \n            # train weak learners conditionally\n            print('Training weak learner {}'.format(n))\n            print('\\t trainable params: '+ str(keras_count_nontrainable_params(self.model_base[n-1], trainable=True)))\n            #print('\\t nontrainable params: '+ str(keras_count_nontrainable_params(self.model_boost[n-1], trainable=False)))\n\n            t_start = time.process_time()\n            if n==1:\n                # set weights = 0 and bias = sigmoid^-1(baseline_hazard)\n                self.model_base[n-1].layers[-1].set_weights([np.array([0]*self.N_input).reshape((-1,1)),\n                                                          np.array([-np.log((1-y.mean())\/y.mean())])])\n            else:                \n                \n                # compute new targets based of 2nd order taylor approx of binary-crossentropy loss\n                pred = self.model_boost[n-2].predict([x]*(n-1))\n                g = (pred-y)\/(pred*(1-pred)) # 1st order\n                h = (-2*pred**2+y*(1+pred))\/(pred*(1-pred))**2 # 2nd order\n                #print('type(g): ' +str(type(g)))\n                #print('type(h): ' +str(type(h)))\n                #print('type(g\/h): ' +str(type(g\/h)))\n                #print('\\n')\n                #print('g.shape: ' +str(g.shape))\n                #print('h.shape: ' +str(h.shape))\n                #print('g\/h.shape: ' +str((g\/h).shape))\n                #print('y.shape: ' +str(y.shape))\n\n                # train weak learner w.r.t. mse loss for new target; for faster convergence, normalize sample_weights\n                self.model_base[n-1].fit(x=x, y = -g\/h, sample_weight = h.flatten()\/h.sum(), batch_size= N_batch, epochs = N_epochs, \n                        validation_split= val_share, verbose = 0, callbacks=callbacks)\n                print('\\t ...  {} epochs'.format(len(self.model_base[n-1].history.history['val_loss'])))\n                \n            print('\\t ... {} sec.'.format(time.process_time()-t_start))\n            print('\\t ... Done!')\n            \n            # add newly trained weak learner to boosting model\n            if n == 1:\n                # Note: Add Layer expects >= 2 inputs\n                self.model_boost[n-1] = self.model_base[n-1]\n            else:\n                self.model_boost[n-1] = Model(inputs = [self.model_base[i].input for i in range(n)], \n                                              # Note: Add() needs list as input; use .output, not .outputs (-> list of lists)\n                                              outputs = tf.keras.layers.Add()(\n                                                      [self.model_base[i].output for i in range(n)]\n                                              )\n                                             )\n            self.model_boost[n-1].compile(loss = 'binary_crossentropy', optimizer = self.optimizer)\n                \n            # corrective step: set all parameters as trainable and update them using SGD\n            if n>1:\n                if (correction_freq > 0) & (n%correction_freq ==0):\n                    self.corrective_step(model = self.model_boost[n-1], x=x, y=y, callbacks=callbacks, \n                                        val_share=val_share, N_epochs = N_epochs, N_batch= N_batch)       \n\n               \n    \n    def corrective_step(self, model, x, y,  callbacks = [], val_share = 0.2, N_epochs = 200, N_batch = 64):\n        '''\n        Perform a corrective step by updating all parameters of boosting model, i.e. all included weak learners.\n        '''\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost_grad.corrective_step: x values changed from pandas.DataFrame to numpy.array')\n        if type(y) == type(pd.DataFrame([1])):\n            y=y.values\n            #print('ANN_boost_grad.corrective_step: y values changed from pandas.DataFrame to numpy.array')\n\n        # allow updating of all parameters\n        model.trainable = True\n        \n        print('Corrective Step ... ')\n        print('\\t trainable params: '+ str(keras_count_nontrainable_params(model, trainable=True)))\n        print('\\t nontrainable params: '+ str(keras_count_nontrainable_params(model, trainable=False)))\n\n        t_start = time.process_time()\n        model.fit(x=[x]*len(model.inputs), y = y, batch_size= N_batch, epochs = N_epochs, \n                    validation_split= val_share, verbose = 0, callbacks=callbacks)\n\n        print('\\t ...  {} epochs'.format(len(model.history.history['val_loss'])))\n        print('\\t ... {} sec.'.format(time.process_time()-t_start))\n        print('\\t ... Correction performed!')\n              \n        # Lock updates\n        model.trainable = False      \n        \n    \n    def predict_proba(self, x):\n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n    \n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost_grad.predict_proba: x values changed from pandas.DataFrame to numpy.array')\n\n\n        # Use last iteration of boosting procedure\n        # Note: tf.keras.models.Model() does not posses .predict_proba(), but only .predict()\n        return self.model_boost[self.N_boost-1].predict([x]*self.N_boost)\n    \n    def predict(self, x):\n\n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n        \n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost_grad.predict: x values changed from pandas.DataFrame to numpy.array')\n\n        # Use last iteration of boosting procedure\n        # Note: tf.keras.models.Model() does not posses .predict_proba(), but only .predict()\n        return self.model_boost[self.N_boost-1].predict([x]*self.N_boost)\n    \n    \n    def predict_classes(self, x, threshold = 0.5):\n        \n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of Sequential() or Model() class to unify notation.\n        \"\"\"\n\n        # handle pandas-datatype\n        if type(x)==type(pd.DataFrame([1])):\n            x=x.values\n            #print('ANN_boost_grad.predict_classes: x values changed from pandas.DataFrame to numpy.array')\n\n        return (self.predict([x]*self.N_boost)> threshold)\n    \n\nclass Logit_boosting:\n    \n    '''\n    Build a bagging procedure for Logistic models (from either the 'sklearn' or 'statsmodels' package) including an optional resampling procedure.\n    '''\n    \n    def __init__(self, N_models, polynomial_degrees = [1,1,1], bool_ada_boost =True, resampler = 'None',\n                 package='sklearn', X = None, y = None):\n        self.resampler = resampler\n        self.polynomial_degrees = polynomial_degrees\n        self.bool_ada_boost = bool_ada_boost\n        if self.bool_ada_boost:\n            self.model = AdaBoostClassifier(base_estimator=LogisticRegression(),n_estimators=N_models)\n        else:\n            raise ValueError('logitBoost not implemented')\n            # self.model = logitboost.LogitBoost(LogisticRegression(), n_estimators=N_models, random_state=0)\n            # print('Note: LogitBoost model only works for regressors as weak learners are fitted on residuals, i.e. crossentropy loss fails.')\n            # print('Abording action in Logit_boosting.__init__ in sub_surrender_models.py')\n            # exit()\n                \n    def fit(self, X_train, y_train, val_share = 0.2):\n        \n        \"\"\"\n        Purpose: Train all model instances in the boosting procedure.\n        \n\n        Inputs:\n        -------\n        \\t X_train, y_train: \\t Training data\n        \\t resampling_option: \\t 'None': No resampling is performed\n        \\t                   \\t 'undersampling': random undersampling of the majority class\n        \\t                     \\t 'SMOTE': SMOTE methodology applied\n        \\t callbacks: \\t callbacks for training\n        \\t val_share, N_epochs, N_batch: \\t Additional arguments for training\n\n        Outputs:\n        --------\n        \\t None. Updates parameters of all models in self.model\n        \"\"\"\n\n        # transform input X to higher degrees of features\n\n\n        if self.bool_ada_boost:\n            # utilze concept of resampling\n            if self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            else:\n                X,y = X_train, y_train\n                #X,y = sklearn.utils.shuffle(X,y)\n            \n            # include higher polynomial-degrees of input features\n            X = reshape_model_input(X, degrees_lst =self.polynomial_degrees)\n            # utilize AdaBoostClassifier object\n            self.model.fit(X,y)\n            return self\n        else:\n            # utilze concept of resampling\n            if self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            else:\n                X,y = X_train, y_train\n                #X,y = sklearn.utils.shuffle(X,y)\n\n            X = reshape_model_input(X, degrees_lst =self.polynomial_degrees)\n\n            self.model.fit(X = X, y = y)\n            \n            # Return model(s) to allow for shorter\/ single-line notation, i.e. Logit_bagging().fit()\n            return self\n\n        \n    def predict_proba(self, X):  \n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n        #pred = sum([self.model[i].predict_proba(X) for i in range(len(self.model))])\/len(self.model)\n\n        return self.model.predict_proba(X = reshape_model_input(X, degrees_lst =self.polynomial_degrees))\n    \n\n    def predict(self, X):\n        \n        \"\"\"\n        Purpose: Predict label for data\n        \n        Replicate predict_proba method of Sequential() or Model() class to unify notation.\n        See documentation of self.predict() method.\n        \"\"\"\n        return self.model.predict(X = reshape_model_input(X, degrees_lst =self.polynomial_degrees))\n    \n\n    def predict_classes(self, X, threshold = 0.5):\n        \n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of Sequential() or Model() class to unify notation.\n        \"\"\"\n        return self.model.predict(X = reshape_model_input(X, degrees_lst =self.polynomial_degrees))        \n\n\nclass Logit_bagging:\n    \n    '''\n    Build a bagging procedure for Logistic models (from either the 'sklearn' or 'statsmodels' package) including an optional resampling procedure.\n    '''\n    \n    def __init__(self, N_models, package='sklearn', polynomial_degrees = [1,1,1], resampler = 'None',\n                 X = None, y = None):\n        self.resampler = resampler\n        self.model = {}\n        for i in range(N_models):\n            # create model i\n            self.model[i] = Logit_model(package=package, polynomial_degrees = polynomial_degrees,\n                                        resampler = resampler, X = X, y = y)\n    \n    def fit(self, X_train, y_train, val_share = 0.2):\n        \n        \"\"\"\n        Purpose: Train all model instances in the bagging procedure.\n        \n\n        Inputs:\n        -------\n        \\t X_train, y_train: \\t Training data\n        \\t resampling_option: \\t 'None': No resampling is performed\n        \\t                   \\t 'undersampling': random undersampling of the majority class\n        \\t                     \\t 'SMOTE': SMOTE methodology applied\n        \\t callbacks: \\t callbacks for training\n        \\t val_share, N_epochs, N_batch: \\t Additional arguments for training\n\n        Outputs:\n        --------\n        \\t None. Updates parameters of all models in self.model\n        \"\"\"\n        \n        for i in range(len(self.model)):\n            # utilze concept of resampling\n            if self.resampler == 'undersampling':\n                X,y = RandomUnderSampler(sampling_strategy= 'majority').fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            elif self.resampler == 'SMOTE':\n                X,y = SMOTE().fit_resample(X=X_train, y=y_train)\n                # shuffle data, otherwise all oversampled data are appended\n                X,y = sklearn.utils.shuffle(X,y)\n            else:\n                X,y = X_train, y_train\n                X,y = sklearn.utils.shuffle(X,y)\n            \n            self.model[i].fit(X=X, y = y, val_share = val_share)\n        \n        # Return model(s) to allow for shorter\/ single-line notation, i.e. Logit_bagging().fit()\n        return self\n\n        \n    def predict_proba(self, X):  \n        \n        \"\"\"\n        Purpose: Predict event probability for data\n        \n        output:\n        \\t Predictions for all input data\n        input:\n        \\t X: \\t Input data\n        \"\"\"\n        pred = self.model[0].predict_proba(X)\n\n        for i in range(1,len(self.model)):\n            pred+=self.model[i].predict_proba(X)\n\n        return pred\/len(self.model)\n    \n\n    def predict(self, X):\n        \n        \"\"\"\n        Purpose: Predict label for data\n        \n        Replicate predict_proba method of Sequential() or Model() class to unify notation.\n        See documentation of self.predict() method.\n        \"\"\"\n        return self.predict_classes(X)\n    \n\n    def predict_classes(self, X, threshold = 0.5):\n        \n        \"\"\"\n        Purpose: Predict class memberships\/ labels for data\n        \n        Replicate predict_classes method of Sequential() or Model() class to unify notation.\n        \"\"\"\n        return (self.predict_proba(X)> threshold)        \n\n\nclass Tree_Classifier:\n    \n    '''\n    Build a tree based classifier. Fitting is based on pruning w.r.t. binary crossentropy, i.e. log_loss().\n    For the RandomForestClassifier option we prune our tree automatically at a max_depth=5\n    \n        criterion:   Method for binary splits of tree fitting procedure, {'gini, 'entropy'}\n        bool_forest: Boolean to decide whether a DecisionTreeClassifier (False) or a RandomForestClassifier (True) will be built.\n        resampling:  Indicates if a resampling strategy is used {'SMOTE', 'undersampling'}, or not {'None'}    \n    '''\n    \n    def __init__(self, criterion = 'gini', bool_cv = False, bool_forest = False, N_trees = 1, alpha = 0,\n                 resampling = 'None'):\n        \n        if bool_forest == False:\n            self.model = sklearn.tree.DecisionTreeClassifier(criterion= criterion, ccp_alpha = alpha)\n        else:\n            self.N_trees = N_trees\n            self.model = sklearn.ensemble.RandomForestClassifier(criterion = criterion, n_estimators=self.N_trees,\n                                                   max_depth= 5, ccp_alpha = alpha )\n        self.criterion = criterion\n        self.resampling = resampling\n        self.bool_forest = bool_forest\n        self.bool_cv = bool_cv\n        \n    def fit(self, X, y, val_share = 0.2, max_depth = 10):\n        \n        '''\n        Fit classifier, including a pruning procedure.\n        Pruning is performed w.r.t. binary_crossentropy evaluated on a validation set and up to a maximal depth.\n        \n        \n        Parameters:\n        -----------\n            val_share: Determines share of training data used for validation\n            max_depth: Maximum depth considered in pruning procedure\n        '''\n        \n        if self.resampling == 'SMOTE':\n            X,y = SMOTE().fit_resample(X,y)\n            # shuffle data, otherwise all oversampled data are appended\n            X,y = sklearn.utils.shuffle(X,y)\n        elif self.resampling == 'undersampling':\n            X,y = RandomUnderSampler().fit_resample(X,y)\n            # shuffle data, otherwise all oversampled data are appended\n            X,y = sklearn.utils.shuffle(X,y)\n        elif self.resampling == 'None':   \n            pass # do nothing\n        else:\n            print('Error: Resampling Option is not yet implemented!')\n        \n        \n        if self.bool_forest == False:\n            # Perform pruning for DecisionTreeClassifier\n            \n            if self.bool_cv:\n                model_cv = sklearn.model_selection.GridSearchCV(estimator=self.model, \n                                               param_grid= {'ccp_alpha':[0, 0.001, 0.0001, 0.00001, 0.000001],\n                                                           'criterion':['gini', 'entropy']})\n                model_cv.fit(X,y)\n                self.model =  model_cv.best_estimator_\n                \n            else:\n                # pruning purely wrt max_depth and validated entropy-loss\n                classifier = {}\n                classifier_eval = {}\n                for i in range(1,max_depth+1):\n                    # Build models up to max_depth\n                    classifier[i] = sklearn.tree.DecisionTreeClassifier(criterion=self.criterion, min_samples_leaf = 20,\n                                                        max_depth=i).fit(X=X[0:int((1-val_share)*len(X))], \n                                                                          y=y[0:int((1-val_share)*len(y))])\n                    # Evaluate log_loss of models\n                    classifier_eval[i] = sklearn.metrics.log_loss(y_true = y[int((1-val_share)*len(y)):],\n                                                   y_pred = classifier[i].predict_proba(X=X[int((1-val_share)*len(X)):])[:,-1])\n\n                best = 1+np.argmin(list(classifier_eval.values()))\n                #plt.plot([i for i in range(1,max_depth+1)], [classifier_eval[i] for i in range(1,max_depth+1)])\n\n                print('Note: Pruning of tree classifier sucessful with max_depth = {}'.format(best))\n\n                # Build model w.r.t. optimal depth\n                self.model = classifier[best]\n        else:\n            # Build RandomForestClassifier with a imposed max_depth=5\n            self.model.fit(X, y)\n            \n        # return object to allow for compact notation of e.g. Tree_classifier().fit()\n        return self\n        \n        \n    def predict_proba(self, X):\n        '''\n        Predict event probability of data X\n        '''\n        return self.model.predict_proba(X)\n        \n        \n    def predict(self, X):\n        '''\n        Predict class membership of data X\n        '''\n        return self.model.predict(X)\n        \n        \n    def predict_classes(self, X):\n        '''\n        Predict class membership of data X\n        '''\n        \n        pred = np.zeros(shape=(len(X),2))\n        pred_class = self.model.predict(X)\n        pred[:,1] = pred_class\n        pred[:,0] = 1- pred_class\n        \n        return pred"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_330","text":"import ctypes\nimport numbers\nimport warnings\nfrom io import BytesIO\nfrom typing import List, Optional, Sequence, Tuple\n\nimport cv2\nimport numpy as np\nimport ocrodeg\nimport scipy.ndimage as ndi\nimport torch\nimport torchvision.transforms.functional as F\nfrom matplotlib import pyplot as plt\nfrom PIL import Image as PILImage\nfrom scipy.ndimage import zoom as scizoom\nfrom scipy.ndimage.filters import gaussian_filter\nfrom scipy.ndimage.interpolation import map_coordinates\nfrom skimage.filters import gaussian\nfrom torchvision.transforms import RandomAffine\nfrom torchvision.transforms.transforms import _check_sequence_input, _setup_angle\n\n\nclass DeterministicAffine(RandomAffine):\n    def __init__(\n        self,\n        degrees,\n        translate=None,\n        scale=None,\n        shear=None,\n        interpolation=F.InterpolationMode.NEAREST,\n        fill=0,\n        fillcolor=None,\n        resample=None,\n    ):\n        torch.nn.Module.__init__(self)\n\n        if resample is not None:\n            warnings.warn(\n                \"Argument resample is deprecated and will be removed since v0.10.0. Please, use interpolation instead\"\n            )\n            interpolation = F._interpolation_modes_from_int(resample)\n\n        # Backward compatibility with integer value\n        if isinstance(interpolation, int):\n            warnings.warn(\n                \"Argument interpolation should be of type InterpolationMode instead of int. \"\n                \"Please, use InterpolationMode enum.\"\n            )\n            interpolation = F._interpolation_modes_from_int(interpolation)\n\n        if fillcolor is not None:\n            warnings.warn(\n                \"Argument fillcolor is deprecated and will be removed since v0.10.0. Please, use fill instead\"\n            )\n            fill = fillcolor\n\n        self.degrees = degrees\n\n        if translate is not None:\n            _check_sequence_input(translate, \"translate\", req_sizes=(2,))\n            for t in translate:\n                if not (0.0 <= t <= 1.0):\n                    raise ValueError(\"translation values should be between 0 and 1\")\n        self.translate = translate\n\n        if scale is not None:\n            if scale <= 0:\n                raise ValueError(\"scale values should be positive\")\n        self.scale = scale\n\n        if shear is not None:\n            self.shear = _setup_angle(shear, name=\"shear\", req_sizes=(2,))\n        else:\n            self.shear = shear\n\n        self.resample = self.interpolation = interpolation\n\n        if fill is None:\n            fill = 0\n        elif not isinstance(fill, (Sequence, numbers.Number)):\n            raise TypeError(\"Fill should be either a sequence or a number.\")\n\n        self.fillcolor = self.fill = fill\n\n    @staticmethod\n    def get_params(\n        degrees: List[float],\n        translate: Optional[List[float]],\n        scale: Optional[List[float]],\n        shears: Optional[List[float]],\n        img_size: List[int],\n    ) -> Tuple[float, Tuple[int, int], float, Tuple[float, float]]:\n        \"\"\"Get parameters for affine transformation\n\n        Returns:\n            params to be passed to the affine transformation\n        \"\"\"\n        angle = degrees\n        if translate is not None:\n            tx = float(translate[0] * img_size[0])\n            ty = float(translate[1] * img_size[1])\n            translations = (tx, ty)\n        else:\n            translations = (0, 0)\n\n        if scale is None:\n            scale = 1.0\n\n        shear_x = shear_y = 0.0\n        if shears is not None:\n            shear_x = shears[0]\n            shear_y = shears[1]\n\n        shear = (shear_x, shear_y)\n\n        return angle, translations, scale, shear\n\n\ndef disk(radius, alias_blur=0.1, dtype=np.float32):\n    if radius <= 8:\n        L = np.arange(-8, 8 + 1)\n        ksize = (3, 3)\n    else:\n        L = np.arange(-radius, radius + 1)\n        ksize = (5, 5)\n    X, Y = np.meshgrid(L, L)\n    aliased_disk = np.array((X ** 2 + Y ** 2) <= radius ** 2, dtype=dtype)\n    aliased_disk \/= np.sum(aliased_disk)\n\n    # supersample disk to antialias\n    return cv2.GaussianBlur(aliased_disk, ksize=ksize, sigmaX=alias_blur)\n\n\ndef brightness(image, beta):\n    return np.clip(image + beta, 0, 1)\n\n\ndef contrast(image, alpha):\n    channel_means = np.mean(image, axis=(0, 1))\n    return np.clip((image - channel_means) * alpha + channel_means, 0, 1)\n\n\ndef translation(image, magnitude):\n    return ocrodeg.transform_image(image, translation=magnitude)\n\n\ndef scale(image, scale, fill=1):\n    image = torch.tensor(image).unsqueeze(0)\n    scale = np.random.choice(scale)\n    scale = [scale - 0.025, scale + 0.025]\n    t = RandomAffine(degrees=0, scale=scale, fill=fill)\n    image = t(image).squeeze().numpy()\n    return image\n    # image = torch.tensor(image).unsqueeze(0)\n    # t = DeterministicAffine(\n    #     degrees=0, translate=(0, 0), shear=(0, 0), scale=scale, fill=fill)\n    # image = t(image).squeeze().numpy()\n    # return image\n\n\ndef rotation(image, magnitude):\n    return ndi.rotate(image, magnitude)\n\n\ndef affine(image, degrees, translate=[0, 0], shear=[0, 0], fill=1):\n    image = torch.tensor(image).unsqueeze(0)\n\n    translate = np.random.choice(translate)\n    translate = [translate - 0.01, translate + 0.01]\n\n    degrees = np.random.choice(degrees)\n    degrees = [degrees - 1, degrees + 1]\n\n    shear = np.random.choice(shear)\n    shear = [shear - 0.5, shear + 0.05]\n\n    t = RandomAffine(degrees=degrees, translate=translate, shear=shear, fill=fill)\n    image = t(image).squeeze().numpy()\n    return image\n\n\ndef binary_blur(image, sigma):\n    return ocrodeg.binary_blur(image, sigma=sigma)\n\n\ndef noisy_binary_blur(image, sigma, noise):\n    return ocrodeg.binary_blur(image, sigma=sigma, noise=noise)\n\n\ndef defocus_blur(image, radius, alias_blur):\n    kernel = disk(radius=radius, alias_blur=alias_blur)\n    return np.clip(cv2.filter2D(image, -1, kernel), 0, 1)\n\n\ndef motion_blur(image, size):\n    # generating the kernel\n    kernel_motion_blur = np.zeros((size, size))\n    kernel_motion_blur[int((size - 1) \/ 2), :] = np.ones(size, dtype=np.float32)\n    kernel_motion_blur = cv2.warpAffine(\n        kernel_motion_blur,\n        cv2.getRotationMatrix2D(\n            (size \/ 2 - 0.5, size \/ 2 - 0.5), np.random.uniform(-45, 45), 1.0\n        ),\n        (size, size),\n    )\n    kernel_motion_blur = kernel_motion_blur * (1.0 \/ np.sum(kernel_motion_blur))\n    return cv2.filter2D(image, -1, kernel_motion_blur)\n\n\ndef clipped_zoom(img, zoom_factor):\n    h = img.shape[0]\n    w = img.shape[1]\n    # ceil crop height(= crop width)\n    ch = int(np.ceil(h \/ float(zoom_factor)))\n    cw = int(np.ceil(w \/ float(zoom_factor)))\n    top = (h - ch) \/\/ 2\n    left = (w - cw) \/\/ 2\n    img = scizoom(\n        img[top : top + ch, left : left + cw], (zoom_factor, zoom_factor), order=1\n    )\n    # trim off any extra pixels\n    trim_top = (img.shape[0] - h) \/\/ 2\n    trim_left = (img.shape[1] - w) \/\/ 2\n\n    return img[trim_top : trim_top + h, trim_left : trim_left + w]\n\n\ndef zoom_blur(image, zoom_factor_start, zoom_factor_end, zoom_factor_step):\n    out = np.zeros_like(image)\n    zoom_factor_range = np.arange(zoom_factor_start, zoom_factor_end, zoom_factor_step)\n    for zoom_factor in zoom_factor_range:\n        out += clipped_zoom(image, zoom_factor)\n    return np.clip((image + out) \/ (len(zoom_factor_range) + 1), 0, 1)\n\n\ndef random_distortion(image, sigma, maxdelta):\n    noise = ocrodeg.bounded_gaussian_noise(image.shape, sigma, maxdelta)\n    return ocrodeg.distort_with_noise(image, noise)\n\n\ndef random_blotches(image, fgblobs, bgblobs, fgscale, bgscale):\n    return ocrodeg.random_blotches(\n        image, fgblobs=fgblobs, bgblobs=bgblobs, fgscale=fgscale, bgscale=bgscale\n    )\n\n\ndef surface_distortion(image, magnitude):\n    noise = ocrodeg.noise_distort1d(image.shape, magnitude=magnitude)\n    return ocrodeg.distort_with_noise(image, noise)\n\n\ndef threshold(image, magnitude):\n    blurred = ndi.gaussian_filter(image, magnitude)\n    return 1.0 * (blurred > 0.5)\n\n\ndef gaussian_noise(image, magnitude):\n    return ndi.gaussian_filter(image, magnitude)\n\n\ndef gaussian_noise_rgb(image, magnitude):\n    if len(image.shape) == 2:\n        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\n    return np.clip(image + np.random.normal(size=image.shape, scale=magnitude), 0, 1)\n\n\ndef shot_noise_rgb(image, magnitude):\n    if len(image.shape) == 2:\n        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\n\n    return np.clip(np.random.poisson(image * magnitude) \/ float(magnitude), 0, 1)\n\n\ndef fibrous_noise(image, blur, blotches):\n    return ocrodeg.printlike_fibrous(image, blur=blur, blotches=blotches)\n\n\ndef multiscale_noise(image, blur, blotches):\n    return ocrodeg.printlike_multiscale(image, blur=blur, blotches=blotches)\n\n\ndef pixelate(image, magnitude):\n    h, w = image.shape\n    image = cv2.resize(\n        image, (int(w * magnitude), int(h * magnitude)), interpolation=cv2.INTER_LINEAR\n    )\n    return cv2.resize(image, (w, h), interpolation=cv2.INTER_NEAREST)\n\n\ndef jpeg_compression(image, quality):\n    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]\n    result, encimg = cv2.imencode(\".jpg\", image * 255, encode_param)\n    decimg = cv2.imdecode(encimg, 0) \/ 255.0\n    return decimg\n\n\ndef elastic(image, alpha, sigma, alpha_affine, random_state=None):\n    assert len(image.shape) == 2\n    shape = image.shape\n    shape_size = shape[:2]\n\n    image = np.array(image, dtype=np.float32) \/ 255.0\n    shape = image.shape\n    shape_size = shape[:2]\n\n    # random affine\n    center_square = np.float32(shape_size) \/\/ 2\n    square_size = min(shape_size) \/\/ 3\n    pts1 = np.float32(\n        [\n            center_square + square_size,\n            [center_square[0] + square_size, center_square[1] - square_size],\n            center_square - square_size,\n        ]\n    )\n    pts2 = pts1 + np.random.uniform(\n        -alpha_affine, alpha_affine, size=pts1.shape\n    ).astype(np.float32)\n    M = cv2.getAffineTransform(pts1, pts2)\n    image = cv2.warpAffine(\n        image, M, shape_size[::-1], borderMode=cv2.BORDER_REFLECT_101\n    )\n\n    dx = (\n        gaussian(\n            np.random.uniform(-1, 1, size=shape[:2]), sigma, mode=\"reflect\", truncate=3\n        )\n        * alpha\n    ).astype(np.float32)\n    dy = (\n        gaussian(\n            np.random.uniform(-1, 1, size=shape[:2]), sigma, mode=\"reflect\", truncate=3\n        )\n        * alpha\n    ).astype(np.float32)\n\n    x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\n    indices = np.reshape(y + dy, (-1, 1)), np.reshape(x + dx, (-1, 1))\n    return (\n        np.clip(\n            map_coordinates(image, indices, order=1, mode=\"reflect\").reshape(shape),\n            0,\n            1,\n        )\n        * 255\n    )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_512","text":"<filename>pyvlova\/utils\/sympy2isl.py\n# Copyright 2020 <NAME>\n# SPDX-License-Identifier: Apache-2.0\nimport functools\nimport sympy\n\n\nclass ISLReprPrinter(sympy.StrPrinter):\n    def _print_And(self, expr):\n        return self.stringify(expr.args, ' and ', sympy.printing.str.PRECEDENCE['And'])\n\n    def _print_Or(self, expr):\n        return self.stringify(expr.args, ' or ', sympy.printing.str.PRECEDENCE['Or'])\n\n    def _print_Function(self, expr):\n        if expr.func is sympy.Mod:\n            r = self.stringify(expr.args, ' mod ', sympy.printing.str.PRECEDENCE['Mul'] + 1)\n            return f'{r}'\n        return super()._print_Function(expr)\n\n    def _print_Relational(self, expr):\n        if isinstance(expr, sympy.Eq):\n            return self.stringify(expr.args, ' = ', sympy.printing.str.PRECEDENCE['Relational'])\n        return super()._print_Relational(expr)\n\n\ndef parse_sympy_to_isl_repr(expr):\n    return ISLReprPrinter().doprint(expr)\n\n\ndef constraints_to_isl_repr(constraints):\n    return parse_sympy_to_isl_repr(functools.reduce(sympy.And, constraints))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_514","text":"\"\"\"\n===============\n=== Purpose ===\n===============\n\nGenerates CDC flu contest forecasts from Epicast [FLUV] user predictions.\n\n\n=================\n=== Changelog ===\n=================\n\n2016-12-08\n  + use secrets\n2016-10-27\n  * updated for 2016 flu contest and updated peakweek definition\n2015-12-14\n  * prefixed output with [EC]\n  + support presence of bin smoothing parameter\n2015-11-09\n  + temporary hack to set df based on number of users\n2015-11-04\n  * replaced normal with student's-t distribution (df=3)\n2015-10-28\n  + support backcasts for 2014-2015 season\n  + optional verbose output and specific user IDs\n  * fixed standard deviation when n=1\n  * fixed CDF when sigma=0\n2015-10-26\n  + first version, based partly on last year's fluv_submission.py\n\"\"\"\n\n# standard library\nfrom statistics import median_low\n\n# third party\nimport mysql.connector\nimport numpy as np\nimport scipy.stats\n\n# first party\nfrom ..forecasters.fc_abstract import Forecaster\nfrom delphi.epidata.client.delphi_epidata import Epidata\nimport delphi.operations.secrets as secrets\nimport delphi.utils.epiweek as flu\nfrom ..utils.forecast_type import ForecastType\n\n\nclass Epicast(Forecaster):\n\n  def __init__(self, test_season, locations, forecast_type, verbose=False, users=None):\n    super().__init__('epicast', test_season, locations, forecast_type, smooth_weeks_bw=0, smooth_wili_bw=0)\n    self.verbose = verbose\n    self.users = users\n\n  @staticmethod\n  def fit_distribution(values, num_bins, bin_size, first_value, unbounded, num_users):\n    values = [v for v in values if v is not None]\n    if len(values) == 0:\n      values = [0]\n    mu = np.median(values)\n    if len(values) == 1:\n      sigma = 0\n    else:\n      sigma = np.std(values, ddof=1)\n    sigma = max(sigma, 1e-3)\n    df = max(1, num_users - 1)\n    cdf = scipy.stats.t(df, mu, sigma).cdf\n    dist = []\n    for i in range(num_bins):\n      a = first_value + i * bin_size\n      if unbounded and i == num_bins - 1:\n        b = float('inf')\n      else:\n        b = a + bin_size\n      dist.append(cdf(b) - cdf(a))\n    dist = np.array(dist)\n    mass = sum(dist)\n    if mass > 0:\n      dist \/= mass\n    return dist\n\n  @staticmethod\n  def get_week_forecast(num_users):\n    def _forecast(first_epiweek, num_bins, indices, uniform_weight, smooth_bw, allow_none):\n      if smooth_bw > 0:\n        print(' [EC] warning: epicast doesnt smooth week bins, but smooth_bw = %.3f' % smooth_bw)\n      num_none = indices.count(None)\n      if num_none > 0 and not allow_none:\n        raise Exception('target does not allow None, but None given')\n      dist = Epicast.fit_distribution(indices, num_bins, 1, -0.5, False, num_users)\n      dist *= len(indices) - num_none\n      extra = [num_none] if allow_none else []\n      dist = Forecaster.Utils.normalize(list(dist) + extra)\n      dist = Forecaster.Utils.blend(dist, uniform_weight)\n      if allow_none:\n        dist, none = dist[:-1], dist[-1]\n      else:\n        none = None\n      possibilities = [i for i in indices if i is not None]\n      if len(possibilities) == 0:\n        possibilities = [0]\n      point = flu.add_epiweeks(first_epiweek, int(np.median(possibilities)))\n      return (dist, none, point)\n    return _forecast\n\n  @staticmethod\n  def get_wili_forecast(num_users):\n    def _forecast(bin_size, num_bins, wili, uniform_weight, smooth_bw):\n      if smooth_bw > 0:\n        print(' [EC] warning: epicast doesnt smooth wILI bins, but smooth_bw = %.3f' % smooth_bw)\n      dist = Epicast.fit_distribution(wili, num_bins, bin_size, 0, True, num_users)\n      dist = Forecaster.Utils.normalize(dist)\n      dist = Forecaster.Utils.blend(dist, uniform_weight)\n      point = np.median(wili)\n      return (dist, point)\n    return _forecast\n\n  def fetch_submissions(self, region, epiweek_now):\n    final_week = flu.join_epiweek(self.test_season + 1, 20)\n    self.cur = self.cnx.cursor()\n    self.cur.execute(\"\"\"\n    SELECT\n      u.`id` `user_id`, f.`epiweek`, f.`wili`\n    FROM (\n      SELECT\n        u.*\n      FROM\n        `ec_fluv_users_mturk_2019` u\n      JOIN\n        `ec_fluv_defaults` d\n      ON\n        TRUE\n      LEFT JOIN\n        `ec_fluv_user_preferences_mturk` p\n      ON\n        p.`user_id` = u.`id` AND p.`name` = d.`name`\n      WHERE\n        d.`name` = '_debug' AND coalesce(p.`value`, d.`value`) = '0'\n      ) u\n    JOIN\n      `ec_fluv_submissions_mturk` s\n    ON\n      s.`user_id` = u.`id`\n    JOIN\n      `ec_fluv_forecast_mturk` f\n    ON\n      f.`user_id` = u.`id` AND f.`region_id` = s.`region_id` AND f.`epiweek_now` = s.`epiweek_now`\n    JOIN\n      `ec_fluv_regions` r\n    ON\n      r.`id` = s.`region_id`\n    WHERE\n      r.`fluview_name` = %s AND s.`epiweek_now` = %s AND f.`epiweek` <= %s AND f.`wili` > 0\n    ORDER BY\n      u.`id` ASC, f.`epiweek` ASC\n    \"\"\", (region, epiweek_now, final_week))\n    submissions = {}\n    for (user, epiweek, wili) in self.cur:\n      if self.users is not None and user not in self.users:\n        continue\n      if user not in submissions:\n        submissions[user] = []\n      submissions[user].append(wili)\n    self.cur.close()\n    curves = []\n    expected_weeks = flu.delta_epiweeks(epiweek_now, final_week)\n    for user in submissions:\n      if len(submissions[user]) != expected_weeks:\n        print(' [EC] warning: missing data in user sumission [%d|%s|%d]' % (user, region, epiweek_now))\n      else:\n        curves.append(submissions[user])\n    return curves\n\n  def _init(self):\n    if self.test_season == 2014:\n      db = 'epicast'\n    elif self.test_season >= 2015:\n      db = 'epicast2'\n    else:\n      raise Exception('invalid epicast season [%d]' % self.test_season)\n    u, p = secrets.db.epi\n    self.cnx = mysql.connector.connect(user=u, password=p, database=db)\n\n  def _fini(self):\n    self.cnx.commit()\n    self.cnx.close()\n\n  def _train(self, region):\n    pass\n\n  def _forecast(self, region, epiweek):\n    # season setup and sanity check\n    ew1 = flu.join_epiweek(self.test_season, 40)\n    ew2 = flu.join_epiweek(self.test_season + 1, 20)\n    if not ew1 <= epiweek <= ew2:\n      raise Exception('`epiweek` outside of `test_season`')\n    # get past values (left half) from the Epidata API\n    epidata = Forecaster.Utils.decode(Epidata.fluview(region, Epidata.range(ew1, epiweek), issues=epiweek))\n    pinned = [row['wili'] for row in epidata]\n    if len(pinned) != flu.delta_epiweeks(ew1, epiweek) + 1:\n      raise Exception('missing ILINet data')\n    # get the user submissions (right half) from the database\n    submissions = self.fetch_submissions(region, epiweek)\n    self._num_users = len(submissions)\n    print(' [EC] %d users found for %s on %d' % (len(submissions), region, epiweek))\n    # concatenate observed data and user submissions\n    return [pinned + sub for sub in submissions]\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_516","text":"\"\"\"Various computers of job posting properties. Each class is generally a generic algorithm (such as skill extraction or occupation classification) paired with enough configuration to run on its own\"\"\"\nfrom . import JobPostingComputedProperty, ComputedPropertyColumn\n\nfrom skills_ml.algorithms.string_cleaners.nlp import title_phase_one\nfrom skills_ml.algorithms.jobtitle_cleaner.clean import JobTitleStringClean\nfrom skills_ml.algorithms.occupation_classifiers.classifiers import \\\n    SocClassifier\nfrom skills_ml.job_postings.corpora import SimpleCorpusCreator\nimport logging\nimport statistics\n\n\nNUMERIC_AGGREGATION_FUNCTION_PATHS = {\n    'numpy.mean': 'Arithemetic mean',\n    'numpy.median': 'Median (middle value)',\n    'numpy.std': 'Sample standard deviation',\n    'numpy.var': 'Sample variance',\n}\n\n\nclass TitleCleanPhaseOne(JobPostingComputedProperty):\n    \"\"\"Perform one phase of job title cleaning: lowercase\/remove punctuation\"\"\"\n    property_name = 'title_clean_phase_one'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='title_clean_phase_one',\n            description='Job title, cleaned by lowercasing and removing punctuation'\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        title_func = title_phase_one\n        return lambda job_posting: title_func(job_posting['title'])\n\n\nclass TitleCleanPhaseTwo(JobPostingComputedProperty):\n    \"\"\"Perform two phases of job title cleaning:\n\n    1. lowercase\/remove punctuation\n    2. Remove geography information\n    \"\"\"\n    property_name = 'title_clean_phase_two'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='title_clean_phase_two',\n            description='Job title, cleaned by lowercasing, removing punctuation, and removing geography information',\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        return lambda job_posting: JobTitleStringClean().clean_title(title_phase_one(job_posting['title']))\n\n\nclass Geography(JobPostingComputedProperty):\n    \"\"\"Produce a geography by querying a given JobGeographyQuerier\n\n    Args:\n        geo_querier\n    \"\"\"\n    def __init__(self, geo_querier, *args, **kwargs):\n        super().__init__(*args, **kwargs)\n        self.geo_querier = geo_querier\n\n    @property\n    def property_name(self):\n        return self.geo_querier.name\n\n    @property\n    def property_columns(self):\n        return [\n            ComputedPropertyColumn(name=name, description=description)\n            for name, description\n            in self.geo_querier.output_columns\n        ]\n\n    def _compute_func_on_one(self):\n        return lambda job_posting: self.geo_querier.query(job_posting)\n\n\nclass SOCClassifyProperty(JobPostingComputedProperty):\n    \"\"\"Classify the SOC code from a trained classifier\n\n    Args:\n        classifier_obj (object, optional) An object to use as a classifier.\n            If not sent one will be downloaded from s3\n    \"\"\"\n    def __init__(self, classifier_obj, *args, **kwargs):\n        super().__init__(*args, **kwargs)\n        self.classifier = SocClassifier(classifier_obj)\n\n    def _compute_func_on_one(self):\n\n        common_classifier = self.classifier\n        corpus_creator = SimpleCorpusCreator()\n\n        def func(job_posting):\n            return common_classifier.predict_soc(corpus_creator._transform(job_posting))\n\n        return func\n\n    @property\n    def property_name(self):\n        return self.classifier.name\n\n    @property\n    def property_description(self):\n        return self.classifier.description\n\n    @property\n    def property_columns(self):\n        property_columns = [\n            ComputedPropertyColumn(\n                name=self.property_name,\n                description=self.property_description,\n                compatible_aggregate_function_paths={\n                    'skills_ml.job_postings.aggregate.pandas.n_most_common': 'Most common'\n                }\n            )\n        ]\n        return property_columns\n\n\nclass GivenSOC(JobPostingComputedProperty):\n    \"\"\"Assign the SOC code given by the partner\"\"\"\n    property_name = 'soc_given'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='soc_given',\n            description='SOC code given by partner',\n            compatible_aggregate_function_paths={\n                'skills_ml.job_postings.aggregate.pandas.n_most_common': 'Most common'\n            }\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        def func(job_posting):\n            return job_posting.get('onet_soc_code', '99-9999.00')\n        return func\n\n\n\nclass PayMixin(object):\n    def salary_from_job_posting(self, job_posting):\n        minSalary = None\n        maxSalary = None\n        try:\n            minSalary = float(job_posting['baseSalary']['minValue'])\n        except ValueError:\n            logging.warning('Could not cast minValue string %s to float', job_posting['baseSalary']['minValue'])\n\n        try:\n            maxSalary = float(job_posting['baseSalary']['maxValue'])\n        except ValueError:\n            logging.warning('Could not cast maxValue string %s to float', job_posting['baseSalary']['maxValue'])\n\n        if not maxSalary and not minSalary:\n            logging.warning('Neither minSalary nor maxSalary could be converted to float, no extraction possible')\n            return None\n\n        if not maxSalary:\n            return minSalary\n\n        if not minSalary:\n            return maxSalary\n\n        return statistics.mean([minSalary, maxSalary])\n\n\nclass HourlyPay(JobPostingComputedProperty, PayMixin):\n    \"\"\"The pay given in the baseSalary field if salaryFrequency is hourly\"\"\"\n    property_name = 'hourly_pay'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='pay_hourly',\n            description='Pay given in baseSalary field if salaryFrequency is hourly',\n            compatible_aggregate_function_paths=NUMERIC_AGGREGATION_FUNCTION_PATHS,\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        def func(job_posting):\n            if job_posting.get('baseSalary', {}).get('salaryFrequency', None) != 'hourly':\n                return None\n            return self.salary_from_job_posting(job_posting)\n        return func\n\n\nclass YearlyPay(JobPostingComputedProperty, PayMixin):\n    \"\"\"The pay given in the baseSalary field if salaryFrequency is yearly\"\"\"\n    property_name = 'yearly_pay'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='pay_yearly',\n            description='Pay given in baseSalary field if salaryFrequency is yearly',\n            compatible_aggregate_function_paths=NUMERIC_AGGREGATION_FUNCTION_PATHS,\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        def func(job_posting):\n            if job_posting.get('baseSalary', {}).get('salaryFrequency', None) != 'yearly':\n                return None\n            return self.salary_from_job_posting(job_posting)\n        return func\n\n\nclass SkillCounts(JobPostingComputedProperty):\n    \"\"\"Adding top skill counts from a skill extractor\n\n    Args: (skills_ml.algorithms.skill_extractors.base.SkillExtractorBase) A skill extractor object\n    \"\"\"\n    def __init__(self, skill_extractor, *args, **kwargs):\n        self.skill_extractor = skill_extractor\n        super().__init__(*args, **kwargs)\n\n    @property\n    def property_name(self):\n        return f'skill_counts_{self.skill_extractor.name}'\n\n    @property\n    def property_columns(self):\n        return [ComputedPropertyColumn(\n            name=self.property_name,\n            description=self.skill_extractor.description,\n            compatible_aggregate_function_paths={\n                'skills_ml.job_postings.aggregate.pandas.listy_n_most_common': 'Most common'\n            }\n        )]\n\n    def _compute_func_on_one(self):\n        def func(job_posting):\n            count_dict = self.skill_extractor.document_skill_counts(job_posting)\n            count_lists = [[k] * v for k, v in count_dict.items()]\n            flattened = [count for countlist in count_lists for count in countlist]\n            return {self.property_name: flattened}\n        return func\n\n\nclass PostingIdPresent(JobPostingComputedProperty):\n    \"\"\"Records job posting ids. Used for counting job postings\"\"\"\n    property_name = 'posting_id_present'\n    property_columns = [\n        ComputedPropertyColumn(\n            name='posting_id_present',\n            description='Job postings',\n            compatible_aggregate_function_paths={'numpy.sum': 'Count of'}\n        )\n    ]\n\n    def _compute_func_on_one(self):\n        return lambda job_posting: 1\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_517","text":"<filename>tacoma\/drawing.py\n# -*- coding: utf-8 -*-\n\"\"\"\nThis module contains functions for drawing temporal networks\nin different ways. It depends on three packages not being installed\nduring installation with ``pip``, which are\n\n- matplotlib\n- networkx\n- python-louvain\n\nIf you want to use this module, please install the dependencies\nlisted above.\n\"\"\"\nfrom __future__ import print_function\n\ntry:\n    import matplotlib.pyplot as pl\n    from matplotlib.collections import LineCollection\nexcept ImportError as e:\n    print(\"\\033[1m tacoma does not install `matplotlib` as a dependency. Please install it manually. \\033[0m\")\n    raise e\n\ntry:\n    import networkx as nx\nexcept ImportError as e:\n    print(\"\\033[1m tacoma does not install `networkx` as a dependency. Please install it manually. \\033[0m\")\n    raise e\n\ntry:\n    import community\nexcept ImportError as e:\n    print(\"\\033[1m tacoma does not install `python-louvain`, neccessary for `community`,  as a dependency. Please install it manually. \\033[0m\")\n    raise e\n\nimport numpy as np\n\nfrom scipy.optimize import curve_fit\n\nimport tacoma as tc\n\n_layout_function = 'graphviz'\n\n\ndef _draw_edge_lists(L):\n    \"\"\"This draws a force-directed layout for each snapshot of a temporal network given in :mod:`_tacoma.edge_lists` format and hence should be used with caution.\"\"\"\n    from rocsNWL.drawing import draw\n    from rocsNWL.drawing import get_pos\n\n    G = nx.Graph()\n    G.add_nodes_from(range(L.N))\n    G.add_edges_from(L.edges[0])\n\n    pos, _ = get_pos(G, layout_function=_layout_function)\n\n    fig, ax = pl.subplots(1, len(L.edges), figsize=(len(L.edges)*3, 4))\n    ax = ax.flatten()\n\n    draw(G, pos=pos, ax=ax[0], layout_function=_layout_function)\n\n    for i in range(1, L.N):\n        G = nx.Graph()\n        G.add_nodes_from(range(L.N))\n        G.add_edges_from(L.edges[i])\n\n        draw(G, pos=pos, ax=ax[i], layout_function=_layout_function)\n\n\ndef fit_function(x, alpha, scale, fac, intervals_to_discard_for_fit):\n    r\"\"\"\n    A fit function for the number of uniquely observed edges over\n    time, following the assumption that edge activity rates follow a gamma\n    distribution.\n\n    .. math::\n        f(x) = \\frac{\\lambda^\\alpha}{\\Gamma(\\lambda)} x^{\\alpha-1}\\\\exp(-\\lambda x)\n\n    The fit function is\n\n    .. math::\n        y(x) = \\phi\\times \\left[ 1 - \\left(\\frac{\\lambda}{\\lambda+x}\\right)^\\alpha\\right]\n\n    Parameters\n    ----------\n    x : numpy.ndarray\n        Data on the x-axis, typically time\n    alpha : float\n        exponent in gamma distribution, has to be alpha > 0\n    scale : float\n        scale :math:`\\\\lambda` in gamma distribution, has to be scale > 0\n    fac : float\n        prefactor, typically :math:`\\\\phi=N(N-1)\/2`.\n    intervals_to_discard_for_fit : list of tuple of float\n        a list of time intervals which have to be discarded for the fit\n\n    Returns\n    -------\n\n    y : numpy.ndarray\n        value of the function\n    \"\"\"\n\n    x_ = x.copy()\n\n    offset = 0.0\n\n    for interval in intervals_to_discard_for_fit:\n        t0, t1 = interval\n        x_[np.logical_and(x >= t0, x < t1)] = t0 - offset\n\n        x_[x >= t1] -= t1 - t0\n        offset += t1 - t0\n\n    return fac * (1.0 - (scale\/(scale+x_))**(alpha))\n\n\ndef draw_edges(traj,\n               time_normalization_factor=1.,\n               time_unit=None,\n               ax=None,\n               fit=False,\n               edge_order=None,\n               color=None,\n               alpha=0.5,\n               linewidth=1.0,\n               intervals_to_discard_for_fit=[],\n               fit_color='k',\n               return_fit_params=False,\n               ):\n    \"\"\"\n    Draw edges according to an edge activity plot.\n\n    Parameters\n    ----------\n    traj : list of :class:`_tacoma.edge_trajectory_entry`\n        The result of :func:`tacoma.api.get_edge_trajectories`.\n    time_normalization_factor, float, default : 1.0\n        Rescale time by this factor.\n    time_unit : str, default : None\n        Unit of time to put on the axis.\n    ax : matplotlib.Axes, default : None\n        Axis to draw on, will create new one if none provided.\n    fit : bool, default : False\n        Fit a curve to the number of uniquely observed edges.\n    edge_order : list of int, default : None\n        Reorder the edges according to this list before drawing.\n    color : a matplotlib color, default : None\n        Color in which to draw the edges in\n    alpha : float, default : 0.5\n        Line opacity of edges\n    linewidth : float, default : 1.0\n        Line width of edges\n    intervals_to_discard_for_fit : list of tuple of float\n        a list of time intervals which have to be discarded for the fit\n    fit_color : a matplotlib color, default : 'k'\n        color in which to draw the fit in\n    return_fit_params : bool, default : False\n        Switch this on if you want to obtain the fit parameters.\n\n    Returns\n    -------\n    fig : matplotlib.Figure\n        If an axes was provided, this is `None`.\n    ax : matplotlib.Axes\n        The axes the plot was drawn on.\n    popt : tuple of float\n        Fit parameters, will only be returned if return_fit_params is `True`.\n    \"\"\"\n\n    if ax is None:\n        fig, ax = pl.subplots(1, 1)\n    else:\n        fig = None\n\n    if color is None:\n        color = 'k'\n\n    lines = []\n    max_i = len(traj)\n    all_t_max = []\n    all_t_min = []\n    max_node = []\n    for i, entry in enumerate(traj):\n        all_t_max.append(entry.time_pairs[-1][-1] * time_normalization_factor)\n        all_t_min.append(entry.time_pairs[0][0] * time_normalization_factor)\n        max_node.extend(entry.edge)\n        for t_ in entry.time_pairs:\n            t_ = np.array(t_) * time_normalization_factor\n\n            if edge_order is not None:\n                y = edge_order[i]\n            else:\n                y = i\n\n            lines.append([t_, [y, y]])\n\n    # if intervals_to_discard_for_fit is not None:\n    #    fit_x = []\n    #\n    #    for t_ in all_t_min:\n    #\n    # else:\n    fit_x = np.array(all_t_min)\n\n    fit_y = np.arange(len(traj), dtype=float)\n\n    lines = [list(zip(x, y)) for x, y in lines]\n    colors = [color for _ in range(len(lines))]\n\n    ax.add_collection(LineCollection(lines, colors=colors,\n                                     alpha=alpha, linewidth=linewidth))\n\n    t0 = min(all_t_min)\n    ax.set_ylim(-1, max_i)\n    ax.set_xlim(t0, max(all_t_max))\n\n    xlabel = 'time'\n    if time_unit is not None:\n        xlabel += ' ['+time_unit+']'\n\n    ylabel = 'edge id'\n    ax.set_xlabel(xlabel)\n    ax.set_ylabel(ylabel)\n\n    if fit:\n        N = max(max_node) + 1\n        fac = N*(N-1)\/2.\n\n        def fit_f(x, alpha, scale):\n            return fit_function(x, alpha, scale, fac, intervals_to_discard_for_fit)\n        #popt, pcov = curve_fit(fit, fit_x, fit_y,[1.\/fac,fac,10.0],maxfev=10000)\n        #popt, pcov = curve_fit(fit, fit_x, fit_y,[2,fac,10.0],maxfev=10000)\n        popt, pcov = curve_fit(fit_f, fit_x, fit_y, [0.5, 10.0], maxfev=10000)\n\n        #print (popt)\n\n        ax.plot(fit_x, fit(fit_x, *popt), 'r')\n\n        #log_y = np.log(fit_y) - 1.\n        #log_x = np.log(fit_x) - 1.\n\n    if not return_fit_params:\n        return fig, ax\n    else:\n        return fig, ax, popt\n\n\ndef edge_activity_plot(temporal_network,\n                       time_normalization_factor=1.,\n                       time_unit=None,\n                       ax=None,\n                       fit=False,\n                       edge_order=None,\n                       color=None,\n                       alpha=0.5,\n                       linewidth=1,\n                       intervals_to_discard_for_fit=[],\n                       fit_color=None,\n                       return_fit_params=False,\n                       ):\n    \"\"\"\n    Draw an edge activity plot for the given temporal network.\n    This is a wrapper for :func:`tacoma.drawing.draw_edges`.\n\n    Parameters\n    ----------\n    temporal_network : :class:`_tacoma.edge_lists` or :class:`_tacoma.edge_changes`.\n        A temporal network.\n    time_normalization_factor, float, default : 1.0\n        Rescale time by this factor.\n    time_unit : str, default : None\n        Unit of time to put on the axis.\n    ax : matplotlib.Axes, default : None\n        Axis to draw an, will create new one if none provided.\n    fit : bool, default : False\n        Fit a curve to the number of uniquely observed edges.\n    edge_order : list of int, default : None\n        Reorder the edges according to this list before drawing.\n    color : a matplotlib color, default : None\n        Color in which to draw the edges in\n    alpha : float, default : 0.5\n        Line opacity of edges\n    linewidth : float, default : 1.0\n        Line width of edges\n    intervals_to_discard_for_fit : list of tuple of float\n        a list of time intervals which have to be discarded for the fit\n    fit_color : a matplotlib color, default : 'k'\n        color in which to draw the fit in\n    return_fit_params : bool, default : False\n        Switch this on if you want to obtain the fit parameters.\n\n    Returns\n    -------\n    fig : matplotlib.Figure\n        If an axes was provided, this is `None`.\n    ax : matplotlib.Axes\n        The axes the plot was drawn on.\n    popt : tuple of float\n        Fit parameters, will only be returned if `return_fit_params` is `True`.\n    \"\"\"\n\n    traj = tc.get_edge_trajectories(temporal_network)\n    return draw_edges(\n        traj,\n        time_normalization_factor=time_normalization_factor,\n        time_unit=time_unit,\n        ax=ax,\n        fit=fit,\n        edge_order=edge_order,\n        color=color,\n        alpha=alpha,\n        linewidth=linewidth,\n        intervals_to_discard_for_fit=intervals_to_discard_for_fit,\n        fit_color=fit_color,\n        return_fit_params=return_fit_params,\n    )\n\n\ndef get_edge_order(edge_traj, edge_sim, threshold=0.):\n    \"\"\"\n    Create an edge order by performing a Louvain-clustering\n    on the thresholded edge similarity graph.\n\n    Parameters\n    ----------\n    edge_traj : list of :class:`_tacoma.edge_trajectory_entry`\n        Edge trajectories, first result of :func:`tacoma.api.get_edge_trajectories`,\n        or entry ``trajectories`` of :class`_tacoma.edge_trajectories`.\n    edge_sim : dict where key is a tuple of int and value is a float \n        Edge similarities, tuple of int denoting the pair of edges,\n        similarity is in dimension of time.\n        2nd result of :func:`tacoma.api.get_edge_trajectories`,\n        or entry ``edge_similarities`` of :class`_tacoma.edge_trajectories`.\n    threshold : float\n        Ignore similarities below this threshold (minimum time spent together,\n        where spent together refers to edges connected to the same node\n        at the same time).\n\n    Returns\n    -------\n    edge_order : list of int\n        Edge indices ordered in clusters.\n    \"\"\"\n\n    # get nx graph\n    G = get_edge_graph(edge_traj, edge_sim, threshold=0.)\n\n    # find best partition using Louvain clustering\n    partition = community.best_partition(G)\n    N_comm = max([v for v in partition.values()]) + 1\n\n    comm = [[] for i in range(N_comm)]\n\n    for k, v in partition.items():\n        comm[v].append(k)\n\n    order = []\n    for module in comm:\n        order.extend(module)\n\n    order = np.argsort(order)\n\n    return order\n\n\ndef get_edge_graph(edge_traj, edge_sim, threshold=0.):\n    \"\"\"\n    Construct a thresholded edge similarity graph.\n\n    Parameters\n    ----------\n    edge_traj : list of :class:`_tacoma.edge_trajectory_entry`\n        Edge trajectories, first result of :func:`tacoma.api.get_edge_trajectories`,\n        or entry ``trajectories`` of :class`_tacoma.edge_trajectories`.\n    edge_sim : dict where key is a tuple of int and value is a float \n        Edge similarities, tuple of int denoting the pair of edges,\n        similarity is in dimension of time.\n        2nd result of :func:`tacoma.api.get_edge_trajectories`,\n        or entry ``edge_similarities`` of :class`_tacoma.edge_trajectories`.\n    threshold : float\n        Ignore similarities below this threshold (minimum time spent together,\n        where spent together refers to edges connected to the same node\n        at the same time).\n\n    Returns\n    -------\n    G : nx.Graph\n        An undirected, unweighted graph where nodes are edges in the temporal network\n        and edges mean their similarity is above the threshold.\n    \"\"\"\n\n    N_edges = len(edge_traj)\n    G = nx.Graph()\n    G.add_nodes_from(range(N_edges))\n    G.add_edges_from([(u, v) for u, v, val in edge_sim if val > threshold])\n\n    return G\n\n\nif __name__ == \"__main__\":\n    import time\n    import _tacoma\n\n    L = tc.edge_lists()\n\n    L.N = 3\n    L.t = [0.0, 1.0, 2.0]\n    L.tmax = 3.0\n    L.edges = [\n        [\n            (0, 1)\n        ],\n        [\n            (1, 2), (0, 2)\n        ],\n        [\n            (0, 1)\n        ],\n    ]\n\n    L = _tacoma.dynamic_RGG(100, 100, mean_link_duration=10)\n    #F = tc.flockwork_P_varying_rates([],100,[0.5],100,[(0.0,1.0)],tmax=100)\n    F = L\n    FBIN = tc.bin(F, dt=1)\n    # draw_rows(FBIN)\n\n    start = time.time()\n    traj, similarities = tc.get_edge_trajectories(\n        FBIN, return_edge_similarities=True)\n    end = time.time()\n    print(similarities)\n\n    print(\"needed \", end-start, \"seconds\")\n    draw_edges(traj, fit=True)\n\n    start = time.time()\n    result = tc.get_edge_trajectories(F)\n    end = time.time()\n    print(\"needed \", end-start, \"seconds\")\n    draw_edges(traj)\n\n    # draw_edge_lists(L)\n\n    pl.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_518","text":"\"\"\"\n\nExperimental enrichment implemented over solr.\n\nCurrently the strategy implemented here does not scale due to the need for large OR clauses (alternatively: iterative queries)\n\nThe most efficient strategy may be to pre-load associations and compute in-memory\n\n\"\"\"\n\nfrom ontobio.golr.golr_associations import search_associations, GolrFields\nimport scipy.stats # TODO - move\nimport scipy as sp # TODO - move\n\nM=GolrFields()  \n\ndef get_counts(entities=[],\n               object_category=None,\n               min_count=1,\n               **kwargs):\n    \"\"\"\n    given a set of entities (genes, diseases, etc), finds the number of entities associated with each descriptor in a given category.\n\n    The result is a tuple (cmap, results), where cmap is a dict of TERM:COUNT\n\n    \"\"\"\n    results = search_associations(subjects=entities,\n                                  subject_direct=True,\n                                  rows=0,\n                                  facet_fields=[M.IS_DEFINED_BY, M.SUBJECT_TAXON, M.SUBJECT_CATEGORY],\n                                  object_category=object_category,\n                                  facet_mincount=3, # TODO\n                                  facet_limit=-1,\n                                  json_facet={\n                                      'categories':{\n                                          'limit':-1,\n                                          'type': 'terms',\n                                          'field' : M.OBJECT_CLOSURE,\n                                          'facet' : {\n                                              'uniq_subject': \"unique(subject)\"\n                                          }\n                                      }\n                                  },\n                                  **kwargs)\n    buckets = results['facets']['categories']['buckets']\n    cmap = {}\n    for bucket in buckets:\n        if bucket['uniq_subject'] >= min_count:\n            cmap[bucket['val']] = bucket['uniq_subject']\n    return (cmap, results)\n\ndef get_background(objects, taxon, object_category, **kwargs):\n    results = search_associations(objects=objects,\n                                  subject_taxon=taxon,\n                                  object_category=object_category,\n                                  rows=0,\n                                  facet_fields=[M.SUBJECT],\n                                  facet_mincount=3, # TODO\n                                  facet_limit=-1,\n                                  **kwargs)\n    return results['facet_counts'][M.SUBJECT].keys()\n\n# TODO: refactor this - fetch compact associations\ndef find_enriched(sample_entities=[],\n                  background_entities=None,\n                  object_category=None,\n                  **kwargs):\n\n    \"\"\"\n    Given a sample set of sample_entities (e.g. overexpressed genes) and a background set (e.g. all genes assayed), and a category of descriptor (e.g. phenotype, function),\n    return enriched descriptors\/classes\n    \"\"\"\n\n    (sample_counts, sample_results) = get_counts(entities=sample_entities,\n                                                 object_category=object_category,\n                                                 min_count=2,\n                                                 **kwargs)\n    print(str(sample_counts))\n\n    sample_fcs = sample_results['facet_counts']\n    taxon_count_dict = sample_fcs[M.SUBJECT_TAXON]\n\n    taxon=None\n    for (t,tc) in taxon_count_dict.items():\n        # TODO - throw error if multiple taxa\n        taxon = t\n\n    if background_entities is None:\n        objects = list(sample_counts.keys())\n        print(\"OBJECTS=\"+str(objects))\n        background_entities = get_background(objects, taxon, object_category)\n\n    # TODO: consider caching\n    (bg_counts,_) = get_counts(entities=background_entities,\n                               object_category=object_category,\n                               **kwargs)\n\n    sample_n = len(sample_entities) # TODO - annotated only?\n    pop_n = len(background_entities)\n    # adapted from goatools\n    for (sample_termid,sample_count) in sample_counts.items():\n        pop_count = bg_counts[sample_termid]\n\n        # https:\/\/en.wikipedia.org\/wiki\/Fisher's_exact_test\n        #              Cls  NotCls\n        # study\/sample [a,      b]\n        # rest of ref  [c,      d]\n        #              \n        a = sample_count\n        b = sample_n - sample_count\n        c = pop_count - sample_count\n        d = pop_n - pop_count - b\n        print(\"ABCD=\"+str((sample_termid,a,b,c,d,sample_n)))\n        _, p_uncorrected = sp.stats.fisher_exact( [[a, b], [c, d]])\n        print(\"P=\"+str(p_uncorrected))\n        # TODO: construct into object\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_520","text":"<filename>dl\/data\/generator\/synthtext.py<gh_stars>1-10\nimport os, logging, re, shutil, sys, csv\nfrom scipy import io as sio\nfrom lxml import etree\nimport cv2\nimport numpy as np\n\nclass _Skip(Exception):\n    pass\n\ndef VOCGenerator(basedir, imagedirname='SynthText', skip_missing=False, encoding='utf-8'):\n\n    def xmlgenerator(annodir, imagedir, cbb, wBB, imname, txts, **kwargs):\n        imgpath = os.path.join(imagedir, imname)\n\n        if not os.path.exists(imgpath):\n            if not skip_missing:\n                raise FileNotFoundError('{} was not found'.format(imgpath))\n            else:\n                logging.warning('Missing image: {}'.format(imgpath))\n                raise _Skip()\n\n        root = etree.Element('annotation')\n\n        # folder\n        folderET = etree.SubElement(root, 'folder')\n        folder = os.path.dirname(imname)\n        folderET.text = folder\n        # filename\n        filenameET = etree.SubElement(root, 'filename')\n        filename = os.path.basename(imname)\n        filenameET.text = filename\n\n        # read image to get height, width, channel\n        img = cv2.imread(imgpath)\n        h, w, c = img.shape\n\n        # size\n        sizeET = etree.SubElement(root, 'size')\n\n        # width\n        widthET = etree.SubElement(sizeET, 'width')\n        widthET.text = str(w)\n        # height\n        heightET = etree.SubElement(sizeET, 'height')\n        heightET.text = str(h)\n        # depth\n        depthET = etree.SubElement(sizeET, 'depth')\n        depthET.text = str(c)\n\n        # convert txts to list of str\n        # I don't know why texts is\n        # ['Lines:\\nI lost\\nKevin ', 'will                ', 'line\\nand            ',\n        # 'and\\nthe             ', '(and                ', 'the\\nout             ',\n        # 'you                 ', \"don't\\n pkg          \"]\n        # there is strange blank and the length of txts is different from the one of wBB\n        txts = ' '.join(txts.tolist()).split()\n        text_num = len(txts)\n\n        if wBB.ndim == 2:\n            # convert shape=(2, 4,) to (2, 4, 1)\n            wBB = np.expand_dims(wBB, 2)\n\n        assert text_num == wBB.shape[2], 'The length of text and wordBB must be same, but got {} and {}'.format(\n            text_num, wBB.shape[2])\n        for b in range(text_num):\n            # object\n            objectET = etree.SubElement(root, 'object')\n\n            # difficult\n            difficultET = etree.SubElement(objectET, 'difficult')\n            difficultET.text = '0'\n            # content\n            contentET = etree.SubElement(objectET, 'content')\n            contentET.text = '###'\n            # name\n            nameET = etree.SubElement(objectET, 'name')\n            nameET.text = txts[b]\n            # bndbox\n            bndboxET = etree.SubElement(objectET, 'bndbox')\n\n            # quad\n            for q in range(4):\n                xET = etree.SubElement(bndboxET, 'x{}'.format(q + 1))\n                xET.text = str(wBB[0, q, b])\n                yET = etree.SubElement(bndboxET, 'y{}'.format(q + 1))\n                yET.text = str(wBB[1, q, b])\n\n            # corner\n            xminET = etree.SubElement(bndboxET, 'xmin')\n            xminET.text = str(np.min(wBB[0, :, b]))\n            yminET = etree.SubElement(bndboxET, 'ymin')\n            yminET.text = str(np.min(wBB[1, :, b]))\n            xmaxET = etree.SubElement(bndboxET, 'xmax')\n            xmaxET.text = str(np.max(wBB[0, :, b]))\n            ymaxET = etree.SubElement(bndboxET, 'ymax')\n            ymaxET.text = str(np.max(wBB[1, :, b]))\n\n        xmlstr = etree.tostring(root, pretty_print=True, encoding=encoding)\n        dstpath = os.path.join(annodir, folder, os.path.splitext(filename)[0] + '.xml')\n\n        if not os.path.isdir(os.path.dirname(dstpath)):\n            os.mkdir(os.path.dirname(dstpath))\n\n        with open(dstpath, 'wb') as f:\n            f.write(xmlstr)\n\n    _gtmatRecognizer(xmlgenerator, basedir, imagedirname)\n\ndef TextRecogCSVGenerator(basedir, imagedirname='SynthText', skip_missing=False, encoding='utf-8'):\n\n    lines = [['folder', 'filename', 'text', 'xmin', 'ymin', 'xmax', 'ymax',\n             'x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']]\n\n    def csvgenerator(annodir, imagedir, cbb, wBB, imname, txts, **kwargs):\n        lines = kwargs.get('lines')\n\n        imgpath = os.path.join(imagedir, imname)\n\n        if not os.path.exists(imgpath):\n            if not skip_missing:\n                raise FileNotFoundError('{} was not found'.format(imgpath))\n            else:\n                logging.warning('Missing image: {}'.format(imgpath))\n                raise _Skip()\n\n        folder = os.path.dirname(imname)\n        filename = os.path.basename(imname)\n\n        # convert txts to list of str\n        # I don't know why txts is\n        # ['Lines:\\nI lost\\nKevin ', 'will                ', 'line\\nand            ',\n        # 'and\\nthe             ', '(and                ', 'the\\nout             ',\n        # 'you                 ', \"don't\\n pkg          \"]\n        # there is strange blank and the length of txts is different from the one of wBB\n        txts = ' '.join(txts.tolist()).split()\n        text_num = len(txts)\n\n        if wBB.ndim == 2:\n            # convert shape=(2, 4,) to (2, 4, 1)\n            wBB = np.expand_dims(wBB, 2)\n\n        assert text_num == wBB.shape[2], 'The length of text and wordBB must be same, but got {} and {}'.format(\n            text_num, wBB.shape[2])\n        for b in range(text_num):\n            text = txts[b]\n\n            # quad\n            quad = []\n            for q in range(4):\n                quad += [str(wBB[0, q, b]), str(wBB[1, q, b])]\n\n            # corner\n            corner = [str(np.min(wBB[0, :, b])), str(np.min(wBB[1, :, b])),\n                      str(np.max(wBB[0, :, b])), str(np.max(wBB[1, :, b]))]\n\n            lines += [[folder, filename, text, *corner, *quad]]\n\n    _gtmatRecognizer(csvgenerator, basedir, imagedirname, lines=lines)\n\n    annodir = os.path.join(basedir, 'Annotations')\n    with open(os.path.join(annodir, 'gt.csv'), 'w') as f:\n        writer = csv.writer(f)\n        writer.writerows(lines)\n\ndef TextRecogOnlyAlphabetNumberCSVGenerator(basedir, imagedirname='SynthText', skip_missing=False, encoding='utf-8'):\n\n    lines = [['folder', 'filename', 'text', 'xmin', 'ymin', 'xmax', 'ymax',\n             'x1', 'y1', 'x2', 'y2', 'x3', 'y3', 'x4', 'y4']]\n\n    def csvgenerator(annodir, imagedir, cbb, wBB, imname, txts, **kwargs):\n        lines = kwargs.get('lines')\n\n        imgpath = os.path.join(imagedir, imname)\n\n        img = cv2.imread(imgpath)\n        h, w, _ = img.shape\n        if not os.path.exists(imgpath):\n            if not skip_missing:\n                raise FileNotFoundError('{} was not found'.format(imgpath))\n            else:\n                logging.warning('Missing image: {}'.format(imgpath))\n                raise _Skip()\n\n        folder = os.path.dirname(imname)\n        filename = os.path.basename(imname)\n\n        # convert txts to list of str\n        # I don't know why txts is\n        # ['Lines:\\nI lost\\nKevin ', 'will                ', 'line\\nand            ',\n        # 'and\\nthe             ', '(and                ', 'the\\nout             ',\n        # 'you                 ', \"don't\\n pkg          \"]\n        # there is strange blank and the length of txts is different from the one of wBB\n        txts = ' '.join(txts.tolist()).split()\n        text_num = len(txts)\n\n        if wBB.ndim == 2:\n            # convert shape=(2, 4,) to (2, 4, 1)\n            wBB = np.expand_dims(wBB, 2)\n\n        assert text_num == wBB.shape[2], 'The length of text and wordBB must be same, but got {} and {}'.format(\n            text_num, wBB.shape[2])\n\n        charind = 0\n        # replace non-alphanumeric characters with *\n        alltexts_asterisk = ''.join([re.sub(r'[^A-Za-z0-9]', '*', text) for text in txts])\n        assert len(alltexts_asterisk) == cbb.shape[2], 'The length of characters and cbb must be same, but got {} and {}'.format(\n            len(alltexts_asterisk), cbb.shape[2])\n        for b in range(text_num):\n            text = txts[b]\n\n            alphanumerictext = re.findall(r'[A-Za-z0-9]+', text)\n\n            for ant in alphanumerictext:\n                charind = alltexts_asterisk.index(ant, charind)\n\n                # quad\n                quad = [cbb[0, 0, charind], cbb[1, 0, charind], # top-left\n                        cbb[0, 1, charind+len(ant)-1], cbb[1, 1, charind+len(ant)-1],\n                        cbb[0, 2, charind+len(ant)-1], cbb[1, 2, charind+len(ant)-1],\n                        cbb[0, 3, charind], cbb[1, 3, charind]]\n\n                # corner\n                xmin, ymin, xmax, ymax = max(np.min(quad[0::2]), 0), max(np.min(quad[1::2]), 0), min(np.max(quad[0::2]), w), min(np.max(quad[1::2]), h)\n                _h, _w, _ = img[int(ymin):int(ymax), int(xmin):int(xmax)].shape\n                if _h == 0 or _w == 0:\n                    charind += len(ant)\n                    continue\n                corner = [xmin, ymin, xmax, ymax]\n\n                quad = list(map(str, quad))\n                corner = list(map(str, corner))\n                lines += [[folder, filename, ant, *corner, *quad]]\n\n                charind += len(ant)\n\n    _gtmatRecognizer(csvgenerator, basedir, imagedirname, lines=lines)\n\n    annodir = os.path.join(basedir, 'Annotations')\n    with open(os.path.join(annodir, 'gt_alphanumeric.csv'), 'w') as f:\n        writer = csv.writer(f)\n        writer.writerows(lines)\n\ndef get_characters(basedir, imagedirname='SynthText', skip_missing=False):\n\n    class Symbols:\n        def __init__(self):\n            self.symbols = set()\n\n        def update(self, data):\n            self.symbols = self.symbols.union(data)\n\n        def __len__(self):\n            return len(self.symbols)\n\n        def __str__(self):\n            return ''.join(self.symbols)\n\n    symbols = Symbols()\n\n    def csvgenerator(annodir, imagedir, cbb, wBB, imname, txts, symbols, **kwargs):\n        image_num = kwargs.get('image_num')\n        i = kwargs.get('i')\n\n        imgpath = os.path.join(imagedir, imname)\n\n        img = cv2.imread(imgpath)\n        h, w, _ = img.shape\n        if not os.path.exists(imgpath):\n            if not skip_missing:\n                raise FileNotFoundError('{} was not found'.format(imgpath))\n            else:\n                logging.warning('Missing image: {}'.format(imgpath))\n                raise _Skip()\n\n\n        # convert txts to list of str\n        # I don't know why txts is\n        # ['Lines:\\nI lost\\nKevin ', 'will                ', 'line\\nand            ',\n        # 'and\\nthe             ', '(and                ', 'the\\nout             ',\n        # 'you                 ', \"don't\\n pkg          \"]\n        # there is strange blank and the length of txts is different from the one of wBB\n        txts = ' '.join(txts.tolist()).split()\n        text_num = len(txts)\n\n        if wBB.ndim == 2:\n            # convert shape=(2, 4,) to (2, 4, 1)\n            wBB = np.expand_dims(wBB, 2)\n\n        assert text_num == wBB.shape[2], 'The length of text and wordBB must be same, but got {} and {}'.format(\n            text_num, wBB.shape[2])\n\n        # replace non-alphanumeric characters with *\n        alltexts_asterisk = ''.join([re.sub(r'[^A-Za-z0-9]', '*', text) for text in txts])\n        assert len(alltexts_asterisk) == cbb.shape[\n            2], 'The length of characters and cbb must be same, but got {} and {}'.format(\n            len(alltexts_asterisk), cbb.shape[2])\n        for b in range(text_num):\n            text = txts[b]\n\n            symboltext = re.sub(r'[A-Za-z0-9]+', '', text)\n\n            symbols.update(symboltext)\n\n        sys.stdout.write('\\r{}, and number is {}...{:0.1f}% ({}\/{})'.format(symbols, len(symbols), 100 * (float(i + 1) \/ image_num), i + 1, image_num))\n        sys.stdout.flush()\n\n    _gtmatRecognizer(csvgenerator, basedir, imagedirname, customLog=True, symbols=symbols)\n\n    print()\n    print('symbols are {}, and number is {}'.format(symbols, len(symbols)))\n\n\ndef _gtmatRecognizer(generator, basedir, imagedirname='SynthText', customLog=False, **kwargs):\n    \"\"\"\n        convert gt.mat to https:\/\/github.com\/MhLiao\/TextBoxes_plusplus\/blob\/master\/data\/example.xml\n\n        <annotation>\n            <folder>train_images<\/folder>\n            <filename>img_10.jpg<\/filename>\n            <size>\n                <width>1280<\/width>\n                <height>720<\/height>\n                <depth>3<\/depth>\n            <\/size>\n            <object>\n                <difficult>1<\/difficult>\n                <content>###<\/content>\n                <name>text<\/name>\n                <bndbox>\n                    <x1>1011<\/x1>\n                    <y1>157<\/y1>\n                    <x2>1079<\/x2>\n                    <y2>160<\/y2>\n                    <x3>1076<\/x3>\n                    <y3>173<\/y3>\n                    <x4>1011<\/x4>\n                    <y4>170<\/y4>\n                    <xmin>1011<\/xmin>\n                    <ymin>157<\/ymin>\n                    <xmax>1079<\/xmax>\n                    <ymax>173<\/ymax>\n                <\/bndbox>\n            <\/object>\n            .\n            .\n            .\n\n        <\/annotation>\n\n        :param basedir: str, directory path under \\'SynthText\\'(, \\'licence.txt\\')\n        :param imagedirname: (Optional) str, image directory name including \\'gt.mat\\\n        :return:\n        \"\"\"\n    logging.basicConfig(level=logging.INFO)\n\n    imagedir = os.path.join(basedir, imagedirname)\n    gtpath = os.path.join(imagedir, 'gt.mat')\n\n    annodir = os.path.join(basedir, 'Annotations')\n\n    if not os.path.exists(gtpath):\n        raise FileNotFoundError('{} was not found'.format(gtpath))\n\n    if not os.path.exists(annodir):\n        # create Annotations directory\n        os.mkdir(annodir)\n\n    \"\"\"\n    ref: http:\/\/www.robots.ox.ac.uk\/~vgg\/data\/scenetext\/readme.txt\n    gts = dict;\n        __header__: bytes\n        __version__: str\n        __globals__: list\n        charBB: object ndarray, shape = (1, image num). \n                Character level bounding box. shape = (2=(x,y), 4=(top left,...: clockwise), BBox word num)\n        wordBB: object ndarray, shape = (1, image num). \n                Word level bounding box. shape = (2=(x,y), 4=(top left,...: clockwise), BBox char num)\n        imnames: object ndarray, shape = (1, image num, 1).\n        txt: object ndarray, shape = (i, image num).\n             Text. shape = (word num)\n    \"\"\"\n    logging.info('Loading {} now.\\nIt may take a while.'.format(gtpath))\n    gts = sio.loadmat(gtpath)\n    logging.info('Loaded\\n'.format(gtpath))\n\n    charBB = gts['charBB'][0]\n    wordBB = gts['wordBB'][0]\n    imnames = gts['imnames'][0]\n    texts = gts['txt'][0]\n\n    image_num = imnames.size\n\n    for i, (cbb, wBB, imname, txts) in enumerate(zip(charBB, wordBB, imnames, texts)):\n        imname = imname[0]\n\n        try:\n            generator(annodir, imagedir, cbb, wBB, imname, txts, i=i, image_num=image_num, **kwargs)\n        except _Skip:\n            pass\n\n        if not customLog:\n            sys.stdout.write('\\rGenerating... {:0.1f}% ({}\/{})'.format(100 * (float(i + 1) \/ image_num), i + 1, image_num))\n        sys.stdout.flush()\n\n\n    print()\n    logging.info('Finished!!!')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_522","text":"<filename>autoPyTorch\/datasets\/base_dataset.py<gh_stars>1-10\nimport os\nimport uuid\nfrom abc import ABCMeta\nfrom typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast\n\nimport numpy as np\n\nfrom scipy.sparse import issparse\n\nfrom sklearn.utils.multiclass import type_of_target\n\nfrom torch.utils.data import Dataset, Subset\n\nimport torchvision\n\nfrom autoPyTorch.constants import CLASSIFICATION_OUTPUTS, STRING_TO_OUTPUT_TYPES\nfrom autoPyTorch.datasets.resampling_strategy import (\n    CrossValFunc,\n    CrossValFuncs,\n    CrossValTypes,\n    DEFAULT_RESAMPLING_PARAMETERS,\n    HoldOutFunc,\n    HoldOutFuncs,\n    HoldoutValTypes\n)\nfrom autoPyTorch.utils.common import FitRequirement\n\nBaseDatasetInputType = Union[Tuple[np.ndarray, np.ndarray], Dataset]\nBaseDatasetPropertiesType = Union[int, float, str, List, bool]\n\n\ndef check_valid_data(data: Any) -> None:\n    if not all(hasattr(data, attr) for attr in ['__getitem__', '__len__']):\n        raise ValueError(\n            'The specified Data for Dataset must have both __getitem__ and __len__ attribute.')\n\n\ndef type_check(train_tensors: BaseDatasetInputType,\n               val_tensors: Optional[BaseDatasetInputType] = None) -> None:\n    \"\"\"To avoid unexpected behavior, we use loops over indices.\"\"\"\n    for i in range(len(train_tensors)):\n        check_valid_data(train_tensors[i])\n    if val_tensors is not None:\n        for i in range(len(val_tensors)):\n            check_valid_data(val_tensors[i])\n\n\nclass TransformSubset(Subset):\n    \"\"\"Wrapper of BaseDataset for splitted datasets\n\n    Since the BaseDataset contains all the data points (train\/val\/test),\n    we require different transformation for each data point.\n    This class helps to take the subset of the dataset\n    with either training or validation transformation.\n    The TransformSubset allows to add train flags\n    while indexing the main dataset towards this goal.\n\n    Attributes:\n        dataset (BaseDataset\/Dataset): Dataset to sample the subset\n        indices names (Sequence[int]): Indices to sample from the dataset\n        train (bool): If we apply train or validation transformation\n\n    \"\"\"\n\n    def __init__(self, dataset: Dataset, indices: Sequence[int], train: bool) -> None:\n        self.dataset = dataset\n        self.indices = indices\n        self.train = train\n\n    def __getitem__(self, idx: int) -> np.ndarray:\n        return self.dataset.__getitem__(self.indices[idx], self.train)\n\n\nclass BaseDataset(Dataset, metaclass=ABCMeta):\n    def __init__(\n        self,\n        train_tensors: BaseDatasetInputType,\n        dataset_name: Optional[str] = None,\n        val_tensors: Optional[BaseDatasetInputType] = None,\n        test_tensors: Optional[BaseDatasetInputType] = None,\n        resampling_strategy: Union[CrossValTypes, HoldoutValTypes] = HoldoutValTypes.holdout_validation,\n        resampling_strategy_args: Optional[Dict[str, Any]] = None,\n        shuffle: Optional[bool] = True,\n        seed: Optional[int] = 42,\n        train_transforms: Optional[torchvision.transforms.Compose] = None,\n        val_transforms: Optional[torchvision.transforms.Compose] = None,\n    ):\n        \"\"\"\n        Base class for datasets used in AutoPyTorch\n        Args:\n            train_tensors (A tuple of objects that have a __len__ and a __getitem__ attribute):\n                training data\n            dataset_name (str): name of the dataset, used as experiment name.\n            val_tensors (An optional tuple of objects that have a __len__ and a __getitem__ attribute):\n                validation data\n            test_tensors (An optional tuple of objects that have a __len__ and a __getitem__ attribute):\n                test data\n            resampling_strategy (Union[CrossValTypes, HoldoutValTypes]),\n                (default=HoldoutValTypes.holdout_validation):\n                strategy to split the training data.\n            resampling_strategy_args (Optional[Dict[str, Any]]): arguments\n                required for the chosen resampling strategy. If None, uses\n                the default values provided in DEFAULT_RESAMPLING_PARAMETERS\n                in ```datasets\/resampling_strategy.py```.\n            shuffle:  Whether to shuffle the data before performing splits\n            seed (int), (default=1): seed to be used for reproducibility.\n            train_transforms (Optional[torchvision.transforms.Compose]):\n                Additional Transforms to be applied to the training data\n            val_transforms (Optional[torchvision.transforms.Compose]):\n                Additional Transforms to be applied to the validation\/test data\n        \"\"\"\n        self.dataset_name = dataset_name\n\n        if self.dataset_name is None:\n            self.dataset_name = str(uuid.uuid1(clock_seq=os.getpid()))\n\n        if not hasattr(train_tensors[0], 'shape'):\n            type_check(train_tensors, val_tensors)\n        self.train_tensors, self.val_tensors, self.test_tensors = train_tensors, val_tensors, test_tensors\n        self.cross_validators: Dict[str, CrossValFunc] = {}\n        self.holdout_validators: Dict[str, HoldOutFunc] = {}\n        self.random_state = np.random.RandomState(seed=seed)\n        self.shuffle = shuffle\n        self.resampling_strategy = resampling_strategy\n        self.resampling_strategy_args = resampling_strategy_args\n        self.task_type: Optional[str] = None\n        self.issparse: bool = issparse(self.train_tensors[0])\n        self.input_shape: Tuple[int] = self.train_tensors[0].shape[1:]\n        if len(self.train_tensors) == 2 and self.train_tensors[1] is not None:\n            self.output_type: str = type_of_target(self.train_tensors[1])\n\n            if (\n                self.output_type in STRING_TO_OUTPUT_TYPES\n                and STRING_TO_OUTPUT_TYPES[self.output_type] in CLASSIFICATION_OUTPUTS\n            ):\n                self.output_shape = len(np.unique(self.train_tensors[1]))\n            else:\n                self.output_shape = self.train_tensors[1].shape[-1] if self.train_tensors[1].ndim > 1 else 1\n\n        # TODO: Look for a criteria to define small enough to preprocess\n        self.is_small_preprocess = True\n\n        # Make sure cross validation splits are created once\n        self.cross_validators = CrossValFuncs.get_cross_validators(*CrossValTypes)\n        self.holdout_validators = HoldOutFuncs.get_holdout_validators(*HoldoutValTypes)\n        self.splits = self.get_splits_from_resampling_strategy()\n\n        # We also need to be able to transform the data, be it for pre-processing\n        # or for augmentation\n        self.train_transform = train_transforms\n        self.val_transform = val_transforms\n\n    def update_transform(self, transform: Optional[torchvision.transforms.Compose],\n                         train: bool = True) -> 'BaseDataset':\n        \"\"\"\n        During the pipeline execution, the pipeline object might propose transformations\n        as a product of the current pipeline configuration being tested.\n\n        This utility allows to return self with the updated transformation, so that\n        a dataloader can yield this dataset with the desired transformations\n\n        Args:\n            transform (torchvision.transforms.Compose):\n                The transformations proposed by the current pipeline\n            train (bool):\n                Whether to update the train or validation transform\n\n        Returns:\n            self: A copy of the update pipeline\n        \"\"\"\n        if train:\n            self.train_transform = transform\n        else:\n            self.val_transform = transform\n        return self\n\n    def __getitem__(self, index: int, train: bool = True) -> Tuple[np.ndarray, ...]:\n        \"\"\"\n        The base dataset uses a Subset of the data. Nevertheless, the base dataset expects\n        both validation and test data to be present in the same dataset, which motivates\n        the need to dynamically give train\/test data with the __getitem__ command.\n\n        This method yields a datapoint of the whole data (after a Subset has selected a given\n        item, based on the resampling strategy) and applies a train\/testing transformation, if any.\n\n        Args:\n            index (int): what element to yield from all the train\/test tensors\n            train (bool): Whether to apply a train or test transformation, if any\n\n        Returns:\n            A transformed single point prediction\n        \"\"\"\n\n        X = self.train_tensors[0].iloc[[index]] if hasattr(self.train_tensors[0], 'loc') \\\n            else self.train_tensors[0][index]\n\n        if self.train_transform is not None and train:\n            X = self.train_transform(X)\n        elif self.val_transform is not None and not train:\n            X = self.val_transform(X)\n\n        # In case of prediction, the targets are not provided\n        Y = self.train_tensors[1][index] if self.train_tensors[1] is not None else None\n\n        return X, Y\n\n    def __len__(self) -> int:\n        return int(self.train_tensors[0].shape[0])\n\n    def _get_indices(self) -> np.ndarray:\n        return self.random_state.permutation(len(self)) if self.shuffle else np.arange(len(self))\n\n    def get_splits_from_resampling_strategy(self) -> List[Tuple[List[int], List[int]]]:\n        \"\"\"\n        Creates a set of splits based on a resampling strategy provided\n\n        Returns\n            (List[Tuple[List[int], List[int]]]): splits in the [train_indices, val_indices] format\n        \"\"\"\n        splits = []\n        if isinstance(self.resampling_strategy, HoldoutValTypes):\n            val_share = DEFAULT_RESAMPLING_PARAMETERS[self.resampling_strategy].get(\n                'val_share', None)\n            if self.resampling_strategy_args is not None:\n                val_share = self.resampling_strategy_args.get('val_share', val_share)\n            splits.append(\n                self.create_holdout_val_split(\n                    holdout_val_type=self.resampling_strategy,\n                    val_share=val_share,\n                )\n            )\n        elif isinstance(self.resampling_strategy, CrossValTypes):\n            num_splits = DEFAULT_RESAMPLING_PARAMETERS[self.resampling_strategy].get(\n                'num_splits', None)\n            if self.resampling_strategy_args is not None:\n                num_splits = self.resampling_strategy_args.get('num_splits', num_splits)\n            # Create the split if it was not created before\n            splits.extend(\n                self.create_cross_val_splits(\n                    cross_val_type=self.resampling_strategy,\n                    num_splits=cast(int, num_splits),\n                )\n            )\n        else:\n            raise ValueError(f\"Unsupported resampling strategy={self.resampling_strategy}\")\n        return splits\n\n    def create_cross_val_splits(\n        self,\n        cross_val_type: CrossValTypes,\n        num_splits: int\n    ) -> List[Tuple[Union[List[int], np.ndarray], Union[List[int], np.ndarray]]]:\n        \"\"\"\n        This function creates the cross validation split for the given task.\n\n        It is done once per dataset to have comparable results among pipelines\n        Args:\n            cross_val_type (CrossValTypes):\n            num_splits (int): number of splits to be created\n\n        Returns:\n            (List[Tuple[Union[List[int], np.ndarray], Union[List[int], np.ndarray]]]):\n                list containing 'num_splits' splits.\n        \"\"\"\n        # Create just the split once\n        # This is gonna be called multiple times, because the current dataset\n        # is being used for multiple pipelines. That is, to be efficient with memory\n        # we dump the dataset to memory and read it on a need basis. So this function\n        # should be robust against multiple calls, and it does so by remembering the splits\n        if not isinstance(cross_val_type, CrossValTypes):\n            raise NotImplementedError(f'The selected `cross_val_type` \"{cross_val_type}\" is not implemented.')\n        kwargs = {}\n        if cross_val_type.is_stratified():\n            # we need additional information about the data for stratification\n            kwargs[\"stratify\"] = self.train_tensors[-1]\n        splits = self.cross_validators[cross_val_type.name](\n            self.random_state, num_splits, self._get_indices(), **kwargs)\n        return splits\n\n    def create_holdout_val_split(\n        self,\n        holdout_val_type: HoldoutValTypes,\n        val_share: float,\n    ) -> Tuple[np.ndarray, np.ndarray]:\n        \"\"\"\n        This function creates the holdout split for the given task.\n\n        It is done once per dataset to have comparable results among pipelines\n        Args:\n            holdout_val_type (HoldoutValTypes):\n            val_share (float): share of the validation data\n\n        Returns:\n            (Tuple[np.ndarray, np.ndarray]): Tuple containing (train_indices, val_indices)\n        \"\"\"\n        if holdout_val_type is None:\n            raise ValueError(\n                '`val_share` specified, but `holdout_val_type` not specified.'\n            )\n        if self.val_tensors is not None:\n            raise ValueError(\n                '`val_share` specified, but the Dataset was a given a pre-defined split at initialization already.')\n        if val_share < 0 or val_share > 1:\n            raise ValueError(f\"`val_share` must be between 0 and 1, got {val_share}.\")\n        if not isinstance(holdout_val_type, HoldoutValTypes):\n            raise NotImplementedError(f'The specified `holdout_val_type` \"{holdout_val_type}\" is not supported.')\n        kwargs = {}\n        if holdout_val_type.is_stratified():\n            # we need additional information about the data for stratification\n            kwargs[\"stratify\"] = self.train_tensors[-1]\n        train, val = self.holdout_validators[holdout_val_type.name](\n            self.random_state, val_share, self._get_indices(), **kwargs)\n        return train, val\n\n    def get_dataset_for_training(self, split_id: int) -> Tuple[Dataset, Dataset]:\n        \"\"\"\n        The above split methods employ the Subset to internally subsample the whole dataset.\n\n        During training, we need access to one of those splits. This is a handy function\n        to provide training data to fit a pipeline\n\n        Args:\n            split (int): The desired subset of the dataset to split and use\n\n        Returns:\n            Dataset: the reduced dataset to be used for testing\n        \"\"\"\n        # Subset creates a dataset. Splits is a (train_indices, test_indices) tuple\n        return (TransformSubset(self, self.splits[split_id][0], train=True),\n                TransformSubset(self, self.splits[split_id][1], train=False))\n\n    def replace_data(self, X_train: BaseDatasetInputType,\n                     X_test: Optional[BaseDatasetInputType]) -> 'BaseDataset':\n        \"\"\"\n        To speed up the training of small dataset, early pre-processing of the data\n        can be made on the fly by the pipeline.\n\n        In this case, we replace the original train\/test tensors by this pre-processed version\n\n        Args:\n            X_train (np.ndarray): the pre-processed (imputation\/encoding\/...) train data\n            X_test (np.ndarray): the pre-processed (imputation\/encoding\/...) test data\n\n        Returns:\n            self\n        \"\"\"\n        self.train_tensors = (X_train, self.train_tensors[1])\n        if X_test is not None and self.test_tensors is not None:\n            self.test_tensors = (X_test, self.test_tensors[1])\n        return self\n\n    def get_dataset_properties(\n        self, dataset_requirements: List[FitRequirement]\n    ) -> Dict[str, BaseDatasetPropertiesType]:\n        \"\"\"\n        Gets the dataset properties required in the fit dictionary.\n        This depends on the components that are active in the\n        pipeline and returns the properties they need about the dataset.\n        Information of the required properties of each component\n        can be found in their documentation.\n        Args:\n            dataset_requirements (List[FitRequirement]): List of\n                fit requirements that the dataset properties must\n                contain. This is created using the `get_dataset_requirements\n                function in\n                <https:\/\/github.com\/automl\/Auto-PyTorch\/blob\/refactor_development\/autoPyTorch\/utils\/pipeline.py#L25>`\n\n        Returns:\n            dataset_properties (Dict[str, BaseDatasetPropertiesType]):\n                Dict of the dataset properties.\n        \"\"\"\n        dataset_properties = dict()\n        for dataset_requirement in dataset_requirements:\n            dataset_properties[dataset_requirement.name] = getattr(self, dataset_requirement.name)\n\n        # Add the required dataset info to dataset properties as\n        # they might not be a dataset requirement in the pipeline\n        dataset_properties.update(self.get_required_dataset_info())\n        return dataset_properties\n\n    def get_required_dataset_info(self) -> Dict[str, BaseDatasetPropertiesType]:\n        \"\"\"\n        Returns a dictionary containing required dataset\n        properties to instantiate a pipeline.\n        \"\"\"\n        info: Dict[str, BaseDatasetPropertiesType] = {'output_type': self.output_type,\n                                                      'issparse': self.issparse}\n        return info\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_523","text":"\"\"\"Core classes and functions for GuideMaker.\"\"\"\nimport os\nimport re\nimport yaml\nimport logging\nimport gzip\nimport hashlib\nimport statistics\nimport nmslib\nimport regex\nimport gc\nfrom typing import List, Dict, TypeVar, Generator\nfrom itertools import product\nfrom Bio import SeqIO\nfrom Bio.SeqUtils import GC\nfrom pybedtools import BedTool\nfrom Bio import Seq\nfrom copy import deepcopy\nimport pandas as pd\nimport numpy as np\nimport altair as alt\nfrom guidemaker import doench_predict\nfrom guidemaker import cfd_score_calculator\n\nlogger = logging.getLogger(__name__)\nPandasDataFrame = TypeVar('pandas.core.frame.DataFrame')\n\npd.options.mode.chained_assignment = None\n\ndef is_gzip(filename: str):\n    try:\n        with open(filename, \"rb\") as f:\n            logger.info(\"check if %s is gzipped\" % filename)\n            return f.read(2) == b'\\x1f\\x8b'\n    except IOError as e:\n        logger.error(\"Could not open the file %s to determine if it was gzipped\" % filename)\n        raise e\n\n\nclass PamTarget:\n\n    \"\"\"\n    A Class representing a Protospacer Adjacent Motif (PAM) and targets.\n\n    The classincludes all targets for given PAM as a dataframe,PAM and target attributes,\n    and methods to find target and control sequences.\n\n    \"\"\"\n\n    def __init__(self, pam: str, pam_orientation: str, dtype: str) -> None:\n        \"\"\"\n        Pam __init__\n\n        Args:\n            pam (str): A DNA string in ambiguous IUPAC format\n            pam_orientation (str): [5prime | 3prime ]\n                5prime means the order is 5'-[pam][target]-3'\n                3prime means the order is 5'-[target][pam]-3'\n            dtype (str): hamming or leven\n\n        Returns:\n            None\n        \"\"\"\n        for letter in pam.upper():\n            assert letter in ['A', 'C', 'G', 'T', 'M', 'R', 'W',\n                'S', 'Y', 'K', 'V', 'H', 'D', 'B', 'X', 'N']\n        assert pam_orientation in [\"3prime\", \"5prime\"]\n        self.pam: str = pam.upper()\n        self.pam_orientation: str = pam_orientation\n        self.dtype: str = dtype\n\n    def __str__(self) -> str:\n        \"\"\"\n        str __init__\n\n        Args:\n            self\n\n        Returns:\n            self(str)\n        \"\"\"\n        return \"A PAM object: {self.pam}\".format(self=self)\n\n    def find_targets(self, seq_record_iter: object, target_len: int) -> PandasDataFrame:\n        \"\"\"\n        Find all targets on a sequence that match for the PAM on both strand(s)\n\n        Args:\n            seq_record_iter (object): A Biopython SeqRecord iterator from SeqIO.parse\n            target_len (int): The length of the target sequence\n\n        Returns:\n            PandasDataFrame: A pandas dataframe with of matching targets\n        \"\"\"\n\n        def reverse_complement(seq: str) -> str:\n            \"\"\"\n            Reverse complement of the PAM sequence\n\n            Args:\n                seq (str): A DNA string\n\n            Returns:\n                str: A reverse complement of DNA string\n            \"\"\"\n            bpseq = Seq.Seq(seq)\n            return str(bpseq.reverse_complement())\n\n        def pam2re(pam: str) -> str:\n            \"\"\"\n            Convert an IUPAC ambiguous PAM to a Regex expression\n\n            Args:\n                pam (str): A DNA string\n\n            Returns:\n                str: A Regex expression\n            \"\"\"\n            dnaval = {'A': 'A', 'C': 'C', 'G': 'G', 'T': 'T',\n                      'M': '[A|C]', 'R': '[A|G]', 'W': '[A|T]', 'S': '[C|G]',\n                      'Y': '[C|T]', 'K': '[G|T]', 'V': '[A|C|G]', 'H': '[A|C|T]',\n                      'D': '[A|G|T]', 'B': '[C|G|T]', 'X': '[G|A|T|C]', 'N': '[G|A|T|C]'}\n            return \"\".join([dnaval[base] for base in pam])\n\n        #                5prime means the order is 5'-[pam][target]-3'\n        #                3prime means the order is 5'-[target][pam]-3'\n\n        def check_target(seq: str, target_len: int) -> bool:\n            \"\"\"\n            Check targets for guidelength and DNA bases\n\n            Args:\n                seq (str): A DNA string\n                target_len(int): Guide length\n\n            Returns:\n                bool: True or False\n            \"\"\"\n            if len(seq) == target_len and all(letters in ['A', 'T', 'C', 'G'] for letters in seq):  # if not ATCG in the target then ignore those targets\n                return True\n            return False\n\n        def run_for_5p(pam_pattern: str, dnaseq: str, target_len: int) -> Generator:\n            \"\"\"\n            Search for guides with 5prime pam orientation in the forward strand\n\n            Args:\n                pam_pattern (str): A DNA string representing PAM\n                dnaseq (str): A DNA string representing genome\n                target_len (int): Guide length\n\n            Returns:\n                (Generator): A generator with target_seq, exact_pam, start, stop, strand, and pam_orientation\n            \"\"\"\n            for match_obj in regex.finditer(pattern=pam_pattern, string=dnaseq, overlapped=True):\n                target_seq = dnaseq[match_obj.end(): match_obj.end() + target_len]\n                target_seq30 = dnaseq[match_obj.start()-3: match_obj.start()+27]\n                ## 5'-[guide of 25 nt][exact pam, 3nt][next two]-3'\n                if check_target(target_seq, target_len):\n                    exact_pam = match_obj.group(0)\n                    start = match_obj.end()\n                    stop = match_obj.end() + target_len\n                    # 5prime =True, 3prime = False\n                    pam_orientation = True\n                    # forward =True, reverse = False\n                    strand = True\n                    yield target_seq, exact_pam, start, stop, strand, pam_orientation, target_seq30\n\n\n\n        def run_for_3p(pam_pattern, dnaseq, target_len) -> Generator:\n            \"\"\"\n            Search for guides with 3prime pam orientation in the reverse strand\n\n            Args:\n                pam_pattern (str): A DNA string representing PAM\n                dnaseq (str): A DNA string representing genome\n                target_len (int): Guide length\n\n            Returns:\n                (Generator): A generator with target_seq, exact_pam, start, stop, strand, and pam_orientation\n            \"\"\"\n            for match_obj in regex.finditer(pattern=pam_pattern, string=dnaseq, overlapped=True):\n                target_seq = dnaseq[match_obj.start() - target_len: match_obj.start()]\n                target_seq30 = dnaseq[match_obj.end()-27 :match_obj.end()+3]\n                if check_target(target_seq, target_len):\n                    exact_pam = match_obj.group(0)\n                    start = match_obj.start() - target_len\n                    stop = match_obj.start()\n                    # 5prime =True, 3prime = False\n                    pam_orientation = False\n                    # forward =True, reverse = False\n                    strand = True\n                    yield target_seq, exact_pam, start, stop, strand, pam_orientation, target_seq30\n\n        def run_rev_5p(pam_pattern, dnaseq, target_len) -> Generator:\n            \"\"\"\n            Search for guides with 5prime pam orientation in the reverse strand\n\n            Args:\n                pam_pattern (str): A DNA string representing PAM\n                dnaseq (str): A DNA string representing genome\n                target_len (int): Guide length\n\n            Returns:\n                (Generator): A generator with target_seq, exact_pam, start, stop, strand, and pam_orientation\n            \"\"\"\n            for match_obj in regex.finditer(pattern=pam_pattern, string=dnaseq, overlapped=True):\n                target_seq = reverse_complement(\n                    dnaseq[match_obj.start() - target_len: match_obj.start()])\n                target_seq30 = reverse_complement(\n                    dnaseq[match_obj.end()-27:match_obj.end()+3])\n                if check_target(target_seq, target_len):\n                    exact_pam = reverse_complement(match_obj.group(0))\n                    start = match_obj.start() - target_len\n                    stop = match_obj.start()\n                    # 5prime =True, 3prime = False\n                    pam_orientation = True\n                    # forward =True, reverse = False\n                    strand = False\n                    yield target_seq, exact_pam, start, stop, strand, pam_orientation, target_seq30\n\n        def run_rev_3p(pam_pattern, dnaseq, target_len) -> Generator:\n            \"\"\"\n            Search for guides with 3prime pam orientation in the reverse strand\n\n            Args:\n                pam_pattern (str): A DNA string representing PAM\n                dnaseq (str): A DNA string representing genome\n                target_len (int): Guide length\n\n            Returns:\n                (Generator): A generator with target_seq, exact_pam, start, stop, strand, and pam_orientation\n            \"\"\"\n            for match_obj in regex.finditer(pattern=pam_pattern, string=dnaseq, overlapped=True):\n                target_seq = reverse_complement(\n                    dnaseq[match_obj.end(): match_obj.end() + target_len])\n                target_seq30 = reverse_complement(dnaseq[match_obj.start()-3:match_obj.start()+27])\n                if check_target(target_seq, target_len):\n                    exact_pam = reverse_complement(match_obj.group(0))\n                    start = match_obj.end()\n                    stop = match_obj.end() + target_len\n                    # 5prime =True, 3prime = False\n                    pam_orientation = False\n                    # forward =True, reverse = False\n                    strand = False\n                    yield target_seq, exact_pam, start, stop, strand, pam_orientation, target_seq30\n\n        target_list = []\n        for record in seq_record_iter:\n            record_id = record.id\n            seq = str(record.seq)\n            if self.pam_orientation == \"5prime\":\n                # forward\n                for5p = pd.DataFrame(run_for_5p(pam2re(self.pam), seq, target_len), columns=[\n                                     \"target\", \"exact_pam\", \"start\", \"stop\", \"strand\", \"pam_orientation\", \"target_seq30\"])\n                for5p[\"seqid\"] = record_id\n                # string to boolean conversion is not straight - as all string were set to Trues- so change the encoding in functions above.\n                # https:\/\/stackoverflow.com\/questions\/715417\/converting-from-a-string-to-boolean-in-python\/715455#715455\n                for5p = for5p.astype({\"target\": 'str', \"exact_pam\": 'category', \"start\": 'uint32',\n                                     \"stop\": 'uint32', \"strand\": 'bool', \"pam_orientation\": 'bool', \"seqid\": 'category'})\n                target_list.append(for5p)\n                # reverse\n                rev5p = pd.DataFrame(run_rev_5p(pam2re(reverse_complement(self.pam)), seq, target_len), columns=[\n                                     \"target\", \"exact_pam\", \"start\", \"stop\", \"strand\", \"pam_orientation\",\"target_seq30\"])\n                rev5p[\"seqid\"] = record_id\n                rev5p = rev5p.astype({\"target\": 'str', \"exact_pam\": 'category', \"start\": 'uint32',\n                                     \"stop\": 'uint32', \"strand\": 'bool', \"pam_orientation\": 'bool', \"seqid\": 'category'})\n                target_list.append(rev5p)\n                # Question? Append directly vs. concat then append? https:\/\/ravinpoudel.github.io\/AppendVsConcat\/\n            elif self.pam_orientation == \"3prime\":\n                # forward\n                for3p = pd.DataFrame(run_for_3p(pam2re(self.pam), seq, target_len), columns=[\n                                     \"target\", \"exact_pam\", \"start\", \"stop\", \"strand\", \"pam_orientation\",\"target_seq30\"])\n                for3p[\"seqid\"] = record_id\n                for3p = for3p.astype({\"target\": 'str', \"exact_pam\": 'category', \"start\": 'uint32',\n                                     \"stop\": 'uint32', \"strand\": 'bool', \"pam_orientation\": 'bool', \"seqid\": 'category'})\n                target_list.append(for3p)\n                # reverse\n                rev3p = pd.DataFrame(run_rev_3p(pam2re(reverse_complement(self.pam)), seq, target_len), columns=[\n                                     \"target\", \"exact_pam\", \"start\", \"stop\", \"strand\", \"pam_orientation\",\"target_seq30\"])\n                rev3p[\"seqid\"] = record_id\n                rev3p = rev3p.astype({\"target\": 'str', \"exact_pam\": 'category', \"start\": 'uint32',\n                                     \"stop\": 'uint32', \"strand\": 'bool', \"pam_orientation\": 'bool', \"seqid\": 'category'})\n                target_list.append(rev3p)\n            gc.collect()  # clear memory after each chromosome\n        df_targets = pd.concat(target_list, ignore_index=True)\n        df_targets = df_targets.assign(seedseq=np.nan, hasrestrictionsite=np.nan, isseedduplicated=np.nan)\n        df_targets = df_targets.astype({\"seedseq\": 'str', \"isseedduplicated\": 'bool'})\n        df_targets = df_targets.assign(dtype=self.dtype)\n        df_targets = df_targets.astype({\"dtype\": 'category'})\n        return df_targets\n\n\nclass TargetProcessor:\n\n    \"\"\"\n    A Class representing a set of guide RNA targets.\n\n    The class includes all targets in a dataframe, methods to process target and a dict with edit distances for sequences.\n\n    \"\"\"\n\n    def __init__(self, targets: PandasDataFrame, lsr: int, editdist: int = 2, knum: int = 2) -> None:\n        \"\"\"\n        TargetProcessor __init__\n\n        Args:\n            targets (PandasDataFrame): Dataframe with output from class PamTarget\n            lsr (int): Length of seed region\n            editdist (int): Edit distance\n            knum (int): Number of negative controls\n\n        Returns:\n            None\n        \"\"\"\n        self.targets = targets  # pandas dataframe\n        self.lsr: int = lsr  # length of seed region\n        self.editdist: int = editdist\n        self.knum: int = knum\n        self.nmslib_index: object = None\n        self.neighbors: dict = {}\n        self.closest_neighbor_df: PandasDataFrame = None\n        self.ncontrolsearched: int = None\n        self.gc_percent: float = None\n        self.genomesize: float = None\n        self.pam_orientation: bool = targets['pam_orientation'].iat[0]\n\n    def __str__(self) -> None:\n        \"\"\"\n        str __init__\n\n        Args:\n            self\n\n        Return:\n            None\n        \"\"\"\n        info = \"TargetList: contains a set of {} potential PAM targets\".format(len(self.targets))\n        return info\n\n    def __len__(self) -> int:\n        \"\"\"\n        len __init__ to display length of self.targets\n\n        Args:\n            self.targets\n\n        Return:\n            (int): Length of the self.targets\n        \"\"\"\n        return len(self.targets)\n\n    def check_restriction_enzymes(self, restriction_enzyme_list: list = []) -> None:\n        \"\"\"\n        Check for restriction enzymes and its reverse complement within gRNA sequence\n\n        Args:\n            restriction_enzyme_list (list): A list with sequence for restriction enzymes\n\n        Returns:\n            None\n        \"\"\"\n        element_to_exclude = []\n        for record in set(restriction_enzyme_list):\n            for letter in record.upper():\n                assert letter in ['A', 'C', 'G', 'T', 'M', 'R', 'W',\n                    'S', 'Y', 'K', 'V', 'H', 'D', 'B', 'X', 'N']\n            record_seq = Seq.Seq(record.upper())\n            element_to_exclude.append(extend_ambiguous_dna(str(record_seq)))\n            element_to_exclude.append(extend_ambiguous_dna(\n                str(record_seq.reverse_complement())))  # reverse complement\n        element_to_exclude = sum(element_to_exclude, [])  # flatout list of list to list with restriction enzyme sites\n        if len(element_to_exclude) > 0:\n            self.targets['hasrestrictionsite'] = self.targets['target'].str.contains('|'.join(element_to_exclude))\n        else:\n            self.targets['hasrestrictionsite'] = False\n    \n    def _one_hot_encode(self, seq_list: List[object]) -> List[str]:\n        \"\"\"One hot encode Target DNA as a binary string representation for NMSLIB.\"\"\"\n        charmap = {'A': '1 0 0 0', 'C': '0 1 0 0', 'G': '0 0 1 0', 'T': '0 0 0 1'}\n\n        def seq_to_bin(seq):\n            charlist = [charmap[letter] for letter in seq]\n            return \" \".join(charlist)\n        return list(map(seq_to_bin, seq_list))\n\n    def find_unique_near_pam(self) -> None:\n        \"\"\"\n        Identify unique sequences in the target list\n\n        The function filters a list of Target objects for targets that\n        are unique in the region closest to the PAM. The region length is defined\n        by the lsr (length of seed region that need to be unique).\n\n        Args:\n            lsr (int): Length of seed region that is close to PAM\n\n        Returns:\n            None\n        \"\"\"\n        def _get_prox(tseq):  # get target sequence as input\n            if self.pam_orientation == True:  # 5prime = True 3prime=False\n                if self.lsr == 0:\n                    return tseq\n                else:\n                    return tseq[0:self.lsr]\n            elif self.pam_orientation == False:  # 5prime = True 3prime=False\n                if self.lsr == 0:\n                    return tseq\n                else:\n                    return tseq[(len(tseq) - self.lsr):]\n        # https:\/\/stackoverflow.com\/questions\/12555323\/adding-new-column-to-existing-dataframe-in-python-pandas\n        self.targets = deepcopy(self.targets)\n        self.targets.loc[:, 'seedseq'] = self.targets.loc[:, 'target'].apply(_get_prox)\n        self.targets.loc[:, 'isseedduplicated'] = self.targets.loc[:, 'seedseq'].duplicated()\n\n    def create_index(self, configpath: str, num_threads=2):\n        \"\"\"\n        Create nmslib index\n\n        Converts self.targets to binary one hot encoding and returns NMSLIB index\n\n        Args:\n            num_threads (int): cpu threads\n            configpath (str): Path to config file which contains hyper parameters for NMSLIB\n\n                M (int): Controls the number of bi-directional links created for each element\n                during index construction. Higher values lead to better results at the expense\n                of memory consumption. Typical values are 2 -100, but for most datasets a\n                range of 12 -48 is suitable. Can’t be smaller than 2.\n\n                efC (int): Size of the dynamic list used during construction. A larger value means\n                   a better quality index, but increases build time. Should be an integer value\n                   between 1 and the size of the dataset.\n\n        Returns:\n            None (but writes NMSLIB index to self)\n        \"\"\"\n        with open(configpath) as cf:\n            config = yaml.safe_load(cf)\n\n        M, efC, post = config['NMSLIB']['M'], config['NMSLIB']['efc'], config['NMSLIB']['post']\n\n        # index everything but not duplicates\n        notduplicated_targets = list(set(self.targets['target'].tolist()))\n        #mod_logger.info(\"unique targets for index: %s\" % len(notduplicated_targets))\n        if self.targets['dtype'].iat[0] == \"hamming\":\n            bintargets = self._one_hot_encode(notduplicated_targets)\n            index_params = {'M': M, 'indexThreadQty': num_threads, 'efConstruction': efC, 'post': post}\n            index = nmslib.init(space='bit_hamming',\n                            dtype=nmslib.DistType.INT,\n                            data_type=nmslib.DataType.OBJECT_AS_STRING,\n                            method='hnsw')\n            index.addDataPointBatch(bintargets) # notduplicated_targets\n            index.createIndex(index_params, print_progress=True)\n            self.nmslib_index = index\n        else:\n            bintargets = notduplicated_targets\n            index_params = {'M': M, 'indexThreadQty': num_threads, 'efConstruction': efC, 'post': post}\n            index = nmslib.init(space='leven',\n                            dtype=nmslib.DistType.INT,\n                            data_type=nmslib.DataType.OBJECT_AS_STRING,\n                            method='hnsw')\n            index.addDataPointBatch(bintargets) # notduplicated_targets\n            index.createIndex(index_params, print_progress=True)\n            self.nmslib_index = index\n\n\n\n    def get_neighbors(self, configpath, num_threads=2) -> None:\n        \"\"\"\n        Get nearest neighbors for sequences removing sequences that\n        have neighbors less than the Hamming distance threshold.\n        For the list of all targets calculate the (knum) nearest neighbors.\n        filter out targets with close neighbors and\n        Writes a dictionary to self.neighbors:\n        self.neighbors[seq]{target: seq_obj, neighbors: {seqs:[s1, s1, ...], dist:[d1, d1,...]}}\n\n        Args:\n            configpath (str): Path to a parameter config file\n            num_threads (int): Number of threads\n\n        Returns:\n            None\n        \"\"\"\n        with open(configpath) as cf:\n            config = yaml.safe_load(cf)\n\n        ef = config['NMSLIB']['ef']\n\n        # unique_targets = self.targets.loc[self.targets['isseedduplicated']\n        #     == False]['target'].tolist()\n        # For indexing we need to use all targets -- for checking off-targets. For searching neighbours remove seed duplicated and one wiht restriction site.\n        unique_targets = self.targets.loc[(self.targets['isseedduplicated']==False) | (self.targets['hasrestrictionsite']==False)]['target'].tolist()\n        if self.targets['dtype'].iat[0] == \"hamming\":\n            unique_bintargets = self._one_hot_encode(unique_targets)  # search unique seed one\n        else:\n            unique_bintargets = unique_targets\n\n        self.nmslib_index.setQueryTimeParams({'efSearch': ef})\n        results_list = self.nmslib_index.knnQueryBatch(unique_bintargets,\n                                               k=self.knum, num_threads=num_threads)\n        neighbor_dict = {}\n        for i, entry in enumerate(results_list):\n            queryseq = unique_targets[i]\n            hitseqidx = entry[0].tolist()\n            editdist = entry[1].tolist()\n            if self.targets['dtype'].iat[0] == \"hamming\":\n                # check that the closest sequence meets the min. dist. requirment. We multiply by 2 b\/c each \n                # base is one hot encoded. e.g. 1000 vs 0100 = 2 differences\n                if editdist[1] >= 2 * self.editdist:\n                    neighbors = {\"seqs\": [self.targets['target'].values[x] for x in hitseqidx],  # reverse this?\n                                \"dist\": [int(x \/ 2) for x in editdist]} \n                    neighbor_dict[queryseq] = {\"target\": unique_targets[i],\n                                            \"neighbors\": neighbors}\n            else:\n               if editdist[1] >= self.editdist: \n                    neighbors = {\"seqs\": [self.targets['target'].values[x] for x in hitseqidx],  # reverse this?\n                                \"dist\": [int(x) for x in editdist]}\n                    neighbor_dict[queryseq] = {\"target\": unique_targets[i],\n                                            \"neighbors\": neighbors}\n        self.neighbors = neighbor_dict\n\n    def export_bed(self) -> object:\n        \"\"\"\n        Export the targets in self.neighbors to a bed format file\n\n        Args:\n            file (str): the name and location of file to export\n\n        Returns:\n            (obj): A Pandas Dataframe in Bed format\n        \"\"\"\n        # df = self.targets.copy()\n        # why deepcopy - https:\/\/stackoverflow.com\/questions\/55745948\/why-doesnt-deepcopy-of-a-pandas-dataframe-affect-memory-usage\n        # select only guides that are not duplecated in the seedseq\n        df = deepcopy(self.targets.loc[self.targets['isseedduplicated'] == False])\n        df = df[[\"seqid\", \"start\", \"stop\", \"target\", \"strand\"]]\n        df.loc[:, 'strand'] = df.loc[:, 'strand'].apply(lambda x: '+' if x == True else '-')\n        df.columns = [\"chrom\", \"chromstart\", \"chromend\", \"name\", \"strand\"]\n        df.sort_values(by=['chrom', 'chromstart'], inplace=True)\n        return df\n\n    def get_control_seqs(self, seq_record_iter: object, configpath, length: int = 20, n: int = 10,\n                         num_threads: int = 2) -> PandasDataFrame:\n        \"\"\"\n        Create random sequences with a specified GC probability and find seqs with the greatest\n        distance to any sequence flanking a PAM site\n\n        Args:\n            seq_record_iter (Bio.SeqIO): An iterator of fastas\n            length (int): Length of the sequence, must match the index\n            n (int): Number of sequences to  return\n            num_threads (int): Number of processor threads\n\n        Returns:\n            (PandasDataFrame): A pandas dataframe with control sequence\n        \"\"\"\n\n        with open(configpath) as cf:\n            config = yaml.safe_load(cf)\n\n        MINIMUM_HMDIST = config['CONTROL']['MINIMUM_HMDIST']\n\n        MAX_CONTROL_SEARCH_MULTIPLE = max(config['CONTROL']['CONTROL_SEARCH_MULTIPLE'])\n\n        #  search_mult (int): search this times n sequences\n        CONTROL_SEARCH_MULTIPLE = config['CONTROL']['CONTROL_SEARCH_MULTIPLE']\n\n        # get GC percent\n        totlen = 0\n        gccnt = 0\n        for record in seq_record_iter:\n            gccnt += GC(record.seq) * len(record)\n            totlen += len(record)\n        gc = gccnt \/ (totlen * 100)\n        self.gc_percent = gc * 100\n        self.genomesize = totlen \/ (1024 * 1024)\n\n        minimum_hmdist = 0\n        sm_count = 0\n        search_mult = 0\n\n        try:\n            while minimum_hmdist < MINIMUM_HMDIST or search_mult == MAX_CONTROL_SEARCH_MULTIPLE:\n                # generate random sequences\n                seqs = []\n                search_mult = CONTROL_SEARCH_MULTIPLE[sm_count]\n                for i in range(n * search_mult):\n                    seqs.append(\"\".join(np.random.choice(a=[\"G\", \"C\", \"A\", \"T\"], size=length,\n                                                         replace=True, p=[gc \/ 2, gc \/ 2, (1 - gc) \/ 2, (1 - gc) \/ 2])))\n                # one hot encode sequences\n                binseq = []\n                charmap = {'A': '1 0 0 0', 'C': '0 1 0 0', 'G': '0 0 1 0', 'T': '0 0 0 1'}\n                for seq in seqs:\n                    if self.targets['dtype'].iat[0] == \"hamming\":\n                        charlist = [charmap[letter] for letter in seq]\n                        binseq.append(\" \".join(charlist))\n                    else: # leven\n                        binseq.append(seq)\n\n                rand_seqs = self.nmslib_index.knnQueryBatch(binseq, k=2, num_threads=num_threads)\n                distlist = []\n                for i in rand_seqs:\n                    distlist.append(i[1][0])\n                zipped = list(zip(seqs, distlist))\n                dist_seqs = sorted(zipped, reverse=True, key=lambda x: x[1])\n                sort_seq = [item[0] for item in dist_seqs][0:n]\n\n                #sort_dist\n                if self.targets['dtype'].iat[0] == \"hamming\":\n                    sort_dist = [item[1] \/ 2 for item in dist_seqs][0:n]  ### ? does divide by 2 holds for leven???\n                else:\n                    sort_dist = [item[1] for item in dist_seqs][0:n]  ### ? does divide by 2 holds for leven???\n\n                minimum_hmdist = int(min(sort_dist))\n                sm_count += 1\n        except IndexError as e:\n            raise e\n\n        total_ncontrolsearched = search_mult * n\n        self.ncontrolsearched = total_ncontrolsearched\n        randomdf = pd.DataFrame(data={\"Sequences\": sort_seq, \"Hamming distance\": sort_dist})\n\n        def create_name(seq):\n            return \"Cont-\" + hashlib.md5(seq.encode()).hexdigest()\n        randomdf['name'] = randomdf[\"Sequences\"].apply(create_name)\n        randomdf = randomdf[[\"name\", \"Sequences\", \"Hamming distance\"]]\n        randomdf.head()\n        return (min(sort_dist),\n                statistics.median(sort_dist),\n                randomdf)\n\n\nclass Annotation:\n\n    \"\"\"\n    Annotation class for data and methods on targets and gene annotations.\n\n    \"\"\"\n\n    def __init__(self, annotation_list: List[str], annotation_type: str, target_bed_df: object) -> None:\n        \"\"\"\n        Annotation class for data and methods on targets and gene annotations\n\n        Args:\n            annotation_list (List[str]): A list of genbank files from a single genome\n            annotation_type (str): \"genbank\" | \"gff\"\n            target_bed_df (object): A pandas dataframe in Bed format with the\n                locations of targets in the genome\n\n        Returns:\n            None\n        \"\"\"\n        self.annotation_list: List[str] = annotation_list\n        self.annotation_type = annotation_type\n        self.target_bed_df: object = target_bed_df\n        self.genbank_bed_df: object = None\n        self.feature_dict: Dict = None\n        self.nearby: object = None\n        self.filtered_df: object = None\n        self.qualifiers: object = None\n\n    def check_annotation_type(self):\n        \"\"\"determine if the file provided by the GFF argument is a GFF or GTF file\n\n            Args: None\n\n            Returns (str): [\"gff\" | \"gtf\"]\n        \"\"\"\n        def search(f):\n            line1 = f.readline()\n            gffmatch = re.search(\"gff-version\", line1)\n            if gffmatch is not None:\n                return \"gff\"\n            gtfmatch = re.search(\"gtf-version\", line1)\n            if gtfmatch is not None:\n                return \"gtf\" \n        testfile = self.annotation_list[0]\n        if is_gzip(testfile):\n            with gzip.open(testfile, 'rt') as f:\n                return search(f)\n        else:\n            with open(testfile, 'r') as f:\n                return search(f)\n\n    def get_annotation_features(self, feature_types: List[str] = None) -> None:\n        \"\"\"\n        Parse annotation records into pandas DF\/Bed format and dict format saving to self\n\n        Args:\n            feature_types (List[str]): a list of Genbank feature types to use\n\n        Returns:\n            None\n        \"\"\"\n        if feature_types is None:\n            feature_types = [\"CDS\"]\n        feature_dict = {}\n        pddict = dict(chrom=[], chromStart=[], chromEnd=[], name=[], strand=[])\n        if self.annotation_type == \"genbank\":\n            for gbfile in self.annotation_list:\n                try:\n                    if is_gzip(gbfile):\n                        f = gzip.open(gbfile, mode='rt')\n                    else:\n                        f = open(gbfile, mode='r')\n                except IOError as e:\n                    logger.error(\"The genbank file %s could not be opened\" % gbfile)\n                    raise e\n                genbank_file = SeqIO.parse(f, \"genbank\")\n                for entry in genbank_file:\n                    for record in entry.features:\n                        if record.type in feature_types:\n                            if record.strand in [1, -1, \"+\", \"-\"]:\n                                pddict[\"strand\"].append(\"-\" if str(record.strand) in ['-1', '-' ] else \"+\")\n                            featid = hashlib.md5(str(record).encode()).hexdigest()\n                            pddict['chrom'].append(entry.id)\n                            pddict[\"chromStart\"].append(record.location.start.position)\n                            pddict[\"chromEnd\"].append(record.location.end.position)\n                            pddict[\"name\"].append(featid)\n                            for qualifier_key, qualifier_val in record.qualifiers.items():\n                                if not qualifier_key in feature_dict:\n                                    feature_dict[qualifier_key] = {}\n                                feature_dict[qualifier_key][featid] = qualifier_val\n            genbankbed = pd.DataFrame.from_dict(pddict)\n            self.genbank_bed_df = genbankbed\n            self.feature_dict = feature_dict\n            f.close()\n        elif self.annotation_type == \"gff\":\n            anno_format = self.check_annotation_type()\n            for gff in self.annotation_list:\n                bedfile = BedTool(gff)\n                for rec in bedfile:\n                    if rec[2] in feature_types:\n                        pddict[\"chrom\"].append(rec[0])\n                        pddict[\"chromStart\"].append(rec[3])\n                        pddict[\"chromEnd\"].append(rec[4])\n                        pddict[\"strand\"].append(rec[6])\n                        featid = hashlib.md5(str(rec).encode()).hexdigest()\n                        pddict[\"name\"].append(featid)\n                        featlist = rec[8].split(';')\n                        for feat in featlist:\n                            if feat.isspace():\n                                continue\n                            if anno_format == 'gtf':\n                                fl = re.search('^[^\"]*', feat)\n                                fv = re.search('\"([^\"]*)\"', feat)\n                                feat_key = fl.group(0).strip()\n                                feat_val = fv.group(0).strip('\"')\n                            elif anno_format =='gff':\n                                fl = feat.split('=')\n                                feat_key = fl[0]\n                                feat_val = fl[1]\n                            if not feat_key in feature_dict:\n                                feature_dict[feat_key] = {}\n                            feature_dict[feat_key][featid] = feat_val\n            genbankbed = pd.DataFrame.from_dict(pddict)\n            self.genbank_bed_df = genbankbed\n            self.feature_dict = feature_dict\n\n\n    def _get_qualifiers(self, configpath, excluded: List[str] = None) -> object:\n        \"\"\"\n        Create a dataframe with features and their qualifier values\n\n        Create a dataframe with features and their qualifier values for\n        all qualifiers over the minimum threshold (except 'translation'). Add\n        to self.qualifiers\n\n        Args:\n            min_prop (float): A float between 0-1 representing the fraction of\n            features the qualifier must be present in to be included in the dataframe\n            excluded (List(str)): A list of genbank qualifiers to exclude, Default [\"translation\"]\n\n        Returns:\n            None\n        \"\"\"\n        with open(configpath) as cf:\n            config = yaml.safe_load(cf)\n\n        min_prop = config['MINIMUM_PROPORTION']\n\n        if excluded is None:\n            excluded = [\"translation\"]\n        final_quals = []\n        qual_df = pd.DataFrame(data={\"Feature id\": []})\n        for featkey, quals in self.feature_dict.items():\n            if len(quals) \/ len(self.feature_dict[featkey]) > min_prop:\n                final_quals.append(featkey)\n        for qualifier in final_quals:\n            if qualifier not in excluded:\n                featlist = []\n                quallist = []\n                for feat, qual in self.feature_dict[qualifier].items():\n                    featlist.append(feat)\n                    if isinstance(qual, list):\n                        quallist.append(\";\".join([str(i) for i in qual]))\n                    else:\n                        quallist.append(qual)\n                tempdf = pd.DataFrame({'Feature id': featlist, qualifier: quallist})\n                qual_df = qual_df.merge(tempdf, how=\"outer\", on=\"Feature id\")\n        self.qualifiers = qual_df\n\n    def _get_nearby_features(self) -> None:\n        \"\"\"\n        Adds downstream information to the given target sequences and mapping information\n\n        Args:\n            None\n\n        Returns:\n            None\n\n        Note:\n            Writes a dataframe of nearby features to self.nearby\n        \"\"\"\n        # Import Features and sort by chromosome and then by start position in ascending order\n        featurebed = BedTool.from_dataframe(self.genbank_bed_df)\n        featurebed = featurebed.sort()\n        # import guide files and sort by chromosome and then by start position in ascending order\n        mapbed = BedTool.from_dataframe(self.target_bed_df)\n        mapbed = mapbed.sort()\n        # get feature downstream of target sequence\n        downstream = mapbed.closest(featurebed, d=True, fd=True, D=\"a\", t=\"first\")\n        # get feature upstream of target sequence\n        upstream = mapbed.closest(featurebed, d=True, id=True, D=\"a\", t=\"first\")\n        headers = {0: \"Accession\", 1: \"Guide start\", 2: \"Guide end\", 3: \"Guide sequence\",\n                   4: \"Guide strand\", 5: \"Feature Accession\", 6: \"Feature start\", 7: \"Feature end\", 8: \"Feature id\",\n                   9: \"Feature strand\", 10: \"Feature distance\"}\n        downstream: pd.DataFrame = downstream.to_dataframe(disable_auto_names=True, header=None)\n        downstream['direction'] = 'downstream'\n        upstream = upstream.to_dataframe(disable_auto_names=True, header=None)\n        upstream['direction'] = 'upstream'\n        upstream = upstream.append(downstream)\n        self.nearby = upstream.rename(columns=headers)\n\n\n    def _filter_features(self, before_feat: int = 100, after_feat: int = 200 ) -> None:\n        \"\"\"\n        Merge targets with Feature list and filter for guides close enough to interact.\n\n        Args:\n            before_feat (int): The maximum distance before the start of a feature measured from closest point to guide\n            after_feat (int): The maximum distance after the start codon (into the gene)\n\n        Returns:\n            None\n        \"\"\"\n        # for guides in the same orientation as the targets ( +\/+ or -\/-) select guides that are within\n        #  before_feat of the gene start\n        filtered_df = self.nearby.query(\n            '`Guide strand` == `Feature strand` and 0 < `Feature distance` < @before_feat')\n        # for guides in the +\/+ orientation select guides where the end is within [before_feat] of the gene start\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"+\" and `Feature strand` == \"+\" \\\n                                             and `Feature distance` == 0 and \\\n                                             `Guide end` - `Feature start` < @after_feat'))\n        # for guides in the -\/- orientation select guides where the end is within [before_feat] of the gene start\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"-\" and `Feature strand` == \"-\" \\\n                                                     and `Feature distance` == 0 \\\n                                                     and `Feature end` - `Guide start` < @after_feat'))\n        # Select guides where target is + and guide is - and the guide is infront of the gene\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"-\" and `Feature strand` == \"+\" and \\\n                                                     0 <`Feature start` - `Guide end` < @before_feat'))\n        # Select guides where target is - and guide is + and the guide is infront of the gene\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"+\" and `Feature strand` == \"-\" and \\\n                                                     0 <`Guide start` - `Feature end` < @before_feat'))\n        # Select guides where target is + and guide is - and the guide is is within [before_feat] of the gene start\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"-\" and `Feature strand` == \"+\" and \\\n                                                             0 <`Guide end` -`Feature start`  < @after_feat'))\n        # Select guides where target is - and guide is + and the guide is is within [before_feat] of the gene start\n        filtered_df = filtered_df.append(self.nearby.query('`Guide strand` == \"+\" and `Feature strand` == \"-\" and \\\n                                                             0 <`Feature end` - `Guide start` < @after_feat'))\n\n        self.filtered_df = filtered_df\n\n    def _format_guide_table(self, targetprocessor_object) -> PandasDataFrame:\n        \"\"\"\n        Create guide table for output\n\n        Args:\n            target- a dataframe with targets from targetclass\n\n        Returns:\n            (PandasDataFrame): A formated pandas dataframe\n        \"\"\"\n        def gc(seq):\n            cnt = 0\n            for letter in seq:\n                if letter in [\"G\", \"C\"]:\n                    cnt += 1\n            return cnt \/ len(seq)\n\n        def get_guide_hash(seq):\n            return hashlib.md5(seq.encode()).hexdigest()\n\n        def checklen30(seq):\n            if len(seq) == 30:\n                return True\n            return False\n\n        def get_off_target_score(seq):\n            dlist = targetprocessor_object.neighbors[seq][\"neighbors\"][\"dist\"]\n            s = [str(i) for i in dlist]\n            return \";\".join(s)\n\n        def get_off_target_seqs(seq):\n            slist = targetprocessor_object.neighbors[seq][\"neighbors\"][\"seqs\"]\n            return \";\".join(slist)\n        pretty_df = deepcopy(self.filtered_df)  # anno class object\n        # retrive only guides that are in neighbors keys.\n        pretty_df = pretty_df[pretty_df[\"Guide sequence\"].isin(\n            list(targetprocessor_object.neighbors.keys()))]\n        pretty_df['GC'] = pretty_df['Guide sequence'].apply(gc)\n        pretty_df['Guide name'] = pretty_df['Guide sequence'].apply(get_guide_hash)\n        pretty_df['Target strand'] = np.where(\n            pretty_df['Guide strand'] == pretty_df['Feature strand'], 'coding', 'non-coding')\n        pretty_df['Similar guide distances'] = pretty_df['Guide sequence'].apply(\n            get_off_target_score)\n        pretty_df['Similar guides'] = pretty_df['Guide sequence'].apply(get_off_target_seqs)\n        pretty_df = pd.merge(pretty_df, targetprocessor_object.targets, how=\"left\",\n         left_on=['Guide sequence', 'Guide start', 'Guide end', 'Accession'],\n            right_on=['target', 'start', 'stop', 'seqid'])\n        # rename exact_pam to PAM\n        pretty_df = pretty_df.rename(columns={\"exact_pam\": \"PAM\"})\n\n        pretty_df = pretty_df[['Guide name', 'Guide sequence', 'GC', 'dtype', 'Accession', 'Guide start', 'Guide end',\n                    'Guide strand', 'PAM', 'Feature id',\n                    'Feature start', 'Feature end', 'Feature strand',\n                    'Feature distance', 'Similar guides', 'Similar guide distances','target_seq30']]\n        pretty_df = pretty_df.merge(self.qualifiers, how=\"left\", on=\"Feature id\")\n        pretty_df = pretty_df.sort_values(by=['Accession', 'Feature start'])\n        # to match with the numbering with other tools- offset\n        pretty_df['Guide start'] = pretty_df['Guide start'] + 1\n        pretty_df['Feature start'] = pretty_df['Feature start'] + 1\n        pretty_df=pretty_df.loc[pretty_df['target_seq30'].apply(checklen30)==True]\n        self.pretty_df = pretty_df\n\n    def _filterlocus(self, filter_by_locus:list = []) -> PandasDataFrame:\n        \"\"\"\n        Create guide table for output for a selected locus_tag\n\n        Args:\n            target- a dataframe with targets from targetclass\n\n        Returns:\n            (PandasDataFrame): A formated pandas dataframe\n        \"\"\"\n\n        df = deepcopy(self.pretty_df)  # anno class object\n        if len (filter_by_locus) > 0:\n            df = df[df['locus_tag'].isin(filter_by_locus)]\n        return df\n\n    def locuslen(self) -> int:\n        \"\"\"\n        Count the number of locus tag in the genebank file\n\n        Args:\n            None\n\n        Returns:\n            (int): Number of locus tag\n        \"\"\"\n\n        locus_count = len(self.feature_dict['locus_tag' or 'locus'].keys())\n        return(locus_count)\n\n\n\nclass GuideMakerPlot:\n\n    \"\"\"\n    A class with functions to plot guides over genome cooridinates.\n\n    \"\"\"\n\n    def __init__(self, prettydf: PandasDataFrame, outdir: str) -> None:\n        \"\"\"\n        GuideMakerPlot class for visualizing distrubution of gRNA, features, and locus.\n\n        Args:\n            prettydf (PandasDataFrame): Final output from GuideMaker\n            outdir (str): Output Directory\n\n        Returns:\n            None\n        \"\"\"\n        self.prettydf = prettydf\n        self.accession = list(set(self.prettydf['Accession']))\n\n        def _singleplot(df):\n            \"\"\"\n            Returns guidemaker plot describing PAM targets\n\n            Args:\n                df(PandasDataFrame): Final output from GuideMaker for a single accession\n\n            Return:\n                None\n            \"\"\"\n            source = df\n            brush = alt.selection(type='interval', encodings=['x'])\n            binNum = int(round(source['Feature end'].max() \/ 200, 0))\n            display_info = source.columns.tolist()\n\n            # Feature density\n            densityF = alt.Chart(source).transform_density(\n            'Feature start',\n            as_=['Feature start', 'Feature Density'],\n            extent=[1, source['Feature end'].max()],\n            bandwidth=binNum,\n            ).mark_area(color='black', opacity=0.6).encode(\n            x=alt.X('Feature start', axis=alt.Axis(title='Genome Coordinates (bp)', tickCount=5)),\n            y='Feature Density:Q',\n            ).properties(height=50, width=500)\n\n            # Guide density\n            densityG = alt.Chart(source).transform_density(\n            'Guide start',\n            as_=['Guide start', 'Guide Density'],\n            extent=[1, source['Feature end'].max()],\n            bandwidth=binNum,\n            ).mark_area(color='pink', opacity=0.6).encode(\n            x=alt.X('Guide start', axis=alt.Axis(title='Genome Coordinates (bp)', tickCount=5)),\n            y='Guide Density:Q',\n            ).properties(height=50, width=500).add_selection(brush)\n\n            # locus bar\n            locus = alt.Chart(source).mark_bar(cornerRadiusTopLeft=3, cornerRadiusTopRight=3).encode(\n            x='count(locus_tag):Q',\n            y=alt.Y('locus_tag', axis=alt.Axis(title='Locus')),\n            color='PAM:N',\n            tooltip=display_info\n            ).transform_filter(\n            brush\n            ).interactive().properties(height=500, width=500)\n            guidemakerChart = (densityF & densityG & locus)\n            return(guidemakerChart)\n\n        for accession in self.accession:\n            df = self.prettydf[self.prettydf['Accession'] == accession]\n            accession_plot = _singleplot(df)\n            plot_file_name = f\"{outdir}\/{accession}.html\"\n            accession_plot.save(plot_file_name)\n\n\ndef get_fastas(filelist, input_format=\"genbank\", tempdir=None):\n    \"\"\"\n    Saves a Fasta and from 1 or more Genbank files (may be gzipped)\n\n    Args:\n        filelist (str): Genbank file to process\n\n    Returns:\n        None\n    \"\"\"\n    try:\n        fastpath = os.path.join(tempdir, \"forward.fasta\")\n        with open(fastpath, \"w\") as f1:\n            for file in filelist:\n                if is_gzip(file):\n                    with gzip.open(file, 'rt') as f:\n                        records = SeqIO.parse(f, input_format)\n                        SeqIO.write(records, f1, \"fasta\")\n                else:\n                    with open(file, 'r') as f:\n                        records = (SeqIO.parse(f, input_format))\n                        SeqIO.write(records, f1, \"fasta\")\n        return fastpath\n    except Exception as e:\n        logger.exception(\"An error occurred in the input file %s\" % file)\n        raise e\n\n\ndef extend_ambiguous_dna(seq: str) -> List[str]:\n    \"\"\"\n    Return list of all possible sequences given an ambiguous DNA input\n\n    Args:\n        seq(str): A DNA string\n\n    Return:\n        List[str]: A list of DNA string with expanded ambiguous DNA values\n    \"\"\"\n    ambiguous_dna_values = {\n    \"A\": \"A\",\n    \"C\": \"C\",\n    \"G\": \"G\",\n    \"T\": \"T\",\n    \"M\": \"AC\",\n    \"R\": \"AG\",\n    \"W\": \"AT\",\n    \"S\": \"CG\",\n    \"Y\": \"CT\",\n    \"K\": \"GT\",\n    \"V\": \"ACG\",\n    \"H\": \"ACT\",\n    \"D\": \"AGT\",\n    \"B\": \"CGT\",\n    \"X\": \"GATC\",\n    \"N\": \"GATC\",\n    }\n    extend_list = []\n    for i in product(*[ambiguous_dna_values[j] for j in seq]):\n        extend_list.append(\"\".join(i))\n    return extend_list\n\n\n# add CDF and Doench Azimuth scores\n\ndef cfd_score(df):\n    def cfd_calculator(knnstrlist, guide, mm_scores):\n            knnlist =  knnstrlist.split(';')\n            cfd_list=[]\n            for item in knnlist:\n                result=cfd_score_calculator.calc_cfd(guide, item, mm_scores=mm_scores)\n                cfd_list.append(result)\n            s = [str(i) for i in cfd_list]\n            return s\n\n    def get_max_cfd(cfdlist):\n        newlist = [float(x) for x in cfdlist]\n        newlist.sort()\n        maxcfd = newlist[-1]\n        return(maxcfd)\n    mm_scores, _ = cfd_score_calculator.get_mm_pam_scores()\n    df['CFD Similar Guides'] = df.apply(lambda x: cfd_calculator(x['Similar guides'], x['Guide sequence'], mm_scores=mm_scores), axis=1)\n    # Add a column with max CFD score\n    df['Max CFD'] = df['CFD Similar Guides'].apply(get_max_cfd)\n    return df\n\n\n\ndef get_doench_efficiency_score(df, pam_orientation, num_threads=1):\n    checkset={'AGG','CGG','TGG','GGG'}\n    if pam_orientation == \"3prime\" and set(df.PAM)==checkset:\n        doenchscore = doench_predict.predict(np.array(df.target_seq30), num_threads=num_threads)\n        df[\"Efficiency\"] = doenchscore\n    else:\n        logger.warning(\"NOTE: doench_efficiency_score based on Doench et al. 2016 - can only  be used for NGG PAM).Check PAM sequence and PAM orientation\")\n        df[\"Efficiency\"] = \"Not Available\"\n    return df.drop('target_seq30', axis=1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_524","text":"<reponame>yzhouas\/MIMIC-III_ICU_Readmission_Analysis\nfrom sklearn import metrics\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mimic3benchmark.util import *\nimport os\nfrom scipy import interp\n\nfrom sklearn.metrics import roc_curve, auc\n\n\ndef read_result(subject_path,file):\n    result = dataframe_from_csv(os.path.join(subject_path, file), index_col=None)\n    pred=result['prediction'].values.tolist()\n    label=result['y_true'].values.tolist()\n    data=(pred, label)\n    return data\n\n\nfig = plt.figure(figsize=(7,7))\n\no_path='\/Users\/jeffrey0925\/Desktop\/'\n\nfolders=['RF','LR','LSTM_no_embedding','LSTM _Demographic','LSTM_CNN_D_tune']\n\n\n\n\n'''\nfile1='rf.csv'\nfile2='svm.csv'\nfile3='noicd_3_k_lstm.n16.d0.3.dep2.bs8.ts1.0.epoch29.test0.597079065251462.state.csv'\nfile4='demo_4_k_lstm.n16.d0.3.dep2.bs8.ts1.0.epoch30.test0.5354190086797693.state.csv'\nfile5='best_4_k_lstm.n16.d0.3.dep2.bs8.ts1.0.epoch13.test0.5961579322814942.state.csv'\n\nfiles=[file1,file2,file3,file4,file5]\n\nfile_names={file1:'RF',\n    file2:'LR',\n    file3:'LSTM (L48-h CE)',\n    file4:'LSTM (L48-h CE + ICD9 +D)',\n    file5:'LSTM+CNN (L48-h CE + ICD9 + D)'}\n'''\nlinestyles = ['-', '--', '-.', ':','-']\nline=0\nfile_names=['RF','LR','LSTM (L48-h CE)','LSTM (L48-h CE + ICD9 +D)','LSTM+CNN (L48-h CE + ICD9 + D)']\ni = 0\nname=0\nfor folder in folders:\n    path=os.path.join(o_path, folder)\n    files = list(os.listdir(path))\n    print(folder, files)\n\n    mean_fpr = np.linspace(0, 1, 100)\n\n    tprs = []\n    aucs = []\n\n\n    for file in files:\n        result=read_result(path, file)\n        pred =result[0]\n        label =result[1]\n        #file_name=file_names[file]\n        fpr, tpr, thresh = metrics.roc_curve(label, pred)\n        tprs.append(interp(mean_fpr, fpr, tpr))\n        tprs[-1][0] = 0.0\n\n        roc_auc = auc(fpr, tpr)\n        aucs.append(roc_auc)\n        #plt.plot(fpr, tpr, lw=2, alpha=0.3,label='ROC fold %d (AUC = %0.3f)' % (i, roc_auc))\n\n        #auc = metrics.roc_auc_score(label, pred)\n        #plt.plot(fpr,tpr,linestyle=linestyles[i],lw=3,label=file_name+\"= %0.3f\" % auc)\n        #plt.plot(fpr,tpr,linestyle=linestyles[i],lw=3,label='fold '+str(i+1)+'= %0.3f' % auc)\n        i+=1\n\n\n\n    mean_tpr = np.mean(tprs, axis=0)\n    mean_tpr[-1] = 1.0\n    mean_auc = auc(mean_fpr, mean_tpr)\n    std_auc = np.std(aucs)\n    file_name=file_names[name]\n    name+=1\n    plt.plot(mean_fpr, mean_tpr,\n         label=file_name+' '+r'(AUC = %0.3f $\\pm$ %0.3f)' % (mean_auc, std_auc),linestyle=linestyles[line],\n         lw=3)\n    line+=1\n    std_tpr = np.std(tprs, axis=0)\n    tprs_upper = np.minimum(mean_tpr + std_tpr, 1)\n    tprs_lower = np.maximum(mean_tpr - std_tpr, 0)\n    plt.fill_between(mean_fpr, tprs_lower, tprs_upper,  alpha=.3)\n    #plt.fill_between(mean_fpr, tprs_lower, tprs_upper,  alpha=.3,label=r'$\\pm$ 1 std. dev.')\n\n\nplt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='k', alpha=.8)\n\nplt.xlim([0., 1.])\nplt.ylim([0., 1.])\nplt.xlabel('False Positive Rate')\nplt.ylabel('True Positive Rate')\nplt.legend(loc=\"lower right\")\nplt.show()\n\n\n#plt.plot([0, 1], [0, 1], linestyle='--',lw=2, color='k')\n\n\n\nfig.savefig('\/Users\/jeffrey0925\/Downloads\/mimic3-benchmarks-master\/mimic3models\/readmission3\/logistic\/error_bar222.png')\n\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_526","text":"import scipy.io \nimport matplotlib.pyplot as plt \nimport data \nimport pickle \nimport numpy as np \n\nbeta = scipy.io.loadmat('.\/beta_100.mat')['values'] ## K x T x V\nprint('beta: ', beta.shape)\n\nwith open('un\/min_df_100\/timestamps.pkl', 'rb') as f:\n    timelist = pickle.load(f)\nprint('timelist: ', timelist)\nT = len(timelist)\nticks = [str(x) for x in timelist]\nprint('ticks: ', ticks)\n\n## get vocab\ndata_file = 'un\/min_df_100'\nvocab, train, valid, test = data.get_data(data_file, temporal=True)\nvocab_size = len(vocab)\n\n## plot topics \nnum_words = 10\ntimes = [0, 10, 40]\nnum_topics = 50\nfor k in range(num_topics):\n    for t in times:\n        gamma = beta[k, t, :]\n        top_words = list(gamma.argsort()[-num_words+1:][::-1])\n        topic_words = [vocab[a] for a in top_words]\n        print('Topic {} .. Time: {} ===> {}'.format(k, t, topic_words)) \n\nprint('Topic Climate Change...')\nnum_words = 10\nfor t in range(46):\n    gamma = beta[46, t, :]\n    top_words = list(gamma.argsort()[-num_words+1:][::-1])\n    topic_words = [vocab[a] for a in top_words]\n    print('Time: {} ===> {}'.format(t, topic_words)) \n\nfig, axes = plt.subplots(nrows=2, ncols=4, figsize=(18, 9), dpi=80, facecolor='w', edgecolor='k')\nax1, ax2, ax3, ax4, ax5, ax6, ax7, ax8 = axes.flatten()\nticks = [str(x) for x in timelist]\n#plt.xticks(np.arange(T)[0::10], timelist[0::10])\n\nwords_1 = ['vietnam', 'war', 'pakistan', 'indonesia']\ntokens_1 = [vocab.index(w) for w in words_1]\nbetas_1 = [beta[1, :, x] for x in tokens_1]\nfor i, comp in enumerate(betas_1):\n    ax1.plot(range(T), comp, label=words_1[i], lw=2, linestyle='--', marker='o', markersize=4)\nax1.legend(frameon=False)\nprint('np.arange(T)[0::10]: ', np.arange(T)[0::10])\nax1.set_xticks(np.arange(T)[0::10])\nax1.set_xticklabels(timelist[0::10])\nax1.set_title('Topic \"Southeast Asia\"', fontsize=12)\n\n\nwords_5 = ['health', 'education', 'hunger', 'terrorism', 'water']\ntokens_5 = [vocab.index(w) for w in words_5]\nbetas_5 = [beta[5, :, x] for x in tokens_5]\nfor i, comp in enumerate(betas_5):\n    ax2.plot(comp, label=words_5[i], lw=2, linestyle='--', marker='o', markersize=4)\nax2.legend(frameon=False)\nax2.set_xticks(np.arange(T)[0::10])\nax2.set_xticklabels(timelist[0::10])\nax2.set_title('Topic \"Poverty & Development\"', fontsize=12)\n\n\nwords_11 = ['iran', 'iraq', 'imperialism']\ntokens_11 = [vocab.index(w) for w in words_11]\nbetas_11 = [beta[11, :, x] for x in tokens_11]\nfor i, comp in enumerate(betas_11):\n    ax3.plot(comp, label=words_11[i], lw=2, linestyle='--', marker='o', markersize=4)\nax3.legend(frameon=False)\nax3.set_xticks(np.arange(T)[0::10])\nax3.set_xticklabels(timelist[0::10])\nax3.set_title('Topic \"War\"', fontsize=12)\n\n\nwords_13 = ['iran', 'treaty', 'trade', 'race', 'nonproliferation']\ntokens_13 = [vocab.index(w) for w in words_13]\nbetas_13 = [beta[13, :, x] for x in tokens_13]\nfor i, comp in enumerate(betas_13):\n    ax4.plot(comp, label=words_13[i], lw=2, linestyle='--', marker='o', markersize=4)\nax4.legend(frameon=False)\nax4.set_xticks(np.arange(T)[0::10])\nax4.set_xticklabels(timelist[0::10])\nax4.set_title('Topic \"Nuclear Weapons\"', fontsize=12)\n\n\n#words_28 = ['men', 'equality', 'gender', 'female', 'education']\nwords_28 = ['education', 'gender', 'equality']\ntokens_28 = [vocab.index(w) for w in words_28]\nbetas_28 = [beta[28, :, x] for x in tokens_28]\nfor i, comp in enumerate(betas_28):\n    ax5.plot(comp, label=words_28[i], lw=2, linestyle='--', marker='o', markersize=4)\nax5.legend(frameon=False)\nax5.set_xticks(np.arange(T)[0::10])\nax5.set_xticklabels(timelist[0::10])\nax5.set_title('Topic \"Human Rights\"', fontsize=12)\n\n\nwords_30 = ['exploitation', 'legal', 'rules', 'negotiations']\ntokens_30 = [vocab.index(w) for w in words_30]\nbetas_30 = [beta[30, :, x] for x in tokens_30]\nfor i, comp in enumerate(betas_30):\n    ax6.plot(comp, label=words_30[i], lw=2, linestyle='--', marker='o', markersize=4)\nax6.legend(frameon=False)\nax6.set_xticks(np.arange(T)[0::10])\nax6.set_xticklabels(timelist[0::10])\nax6.set_title('Topic \"Ocean Exploitation\"', fontsize=12)\n\n\nwords_46 = ['ozone', 'warming', 'emissions', 'waste']\ntokens_46 = [vocab.index(w) for w in words_46]\nbetas_46 = [beta[46, :, x] for x in tokens_46]\nfor i, comp in enumerate(betas_46):\n    ax7.plot(comp, label=words_46[i], lw=2, linestyle='--', marker='o', markersize=4)\nax7.legend(frameon=False)\nax7.set_xticks(np.arange(T)[0::10])\nax7.set_xticklabels(timelist[0::10])\nax7.set_title('Topic \"Climate Change\"', fontsize=12)\n\n\nwords_49 = ['apartheid', 'independence', 'colonial', 'democratic']\ntokens_49 = [vocab.index(w) for w in words_49]\nbetas_49 = [beta[49, :, x] for x in tokens_49]\nfor i, comp in enumerate(betas_49):\n    ax8.plot(comp, label=words_49[i], lw=2, linestyle='--', marker='o', markersize=4)\nax8.legend(frameon=False)\nax8.set_title('Topic \"Africa\"', fontsize=12)\nax8.set_xticks(np.arange(T)[0::10])\nax8.set_xticklabels(timelist[0::10])\nplt.savefig('word_evolution.png')\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_527","text":"<reponame>simpeg\/aurora<gh_stars>1-10\n\"\"\"\nOne off method to help read in transfer function dumps provided by Gary from some of\nthe matlab tests.\n\n\"\"\"\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.io as sio\n\nfrom aurora.config.decimation_level_config import DecimationLevelConfig\nfrom aurora.general_helper_functions import BAND_SETUP_PATH\nfrom aurora.sandbox.io_helpers.zfile_murphy import read_z_file\nfrom aurora.time_series.frequency_band import FrequencyBands\nfrom aurora.transfer_function.emtf_z_file_helpers import clip_bands_from_z_file\nfrom aurora.transfer_function.emtf_z_file_helpers import get_default_orientation_block\nfrom aurora.transfer_function.plot.rho_phi_helpers import plot_phi\nfrom aurora.transfer_function.plot.rho_phi_helpers import plot_rho\nfrom aurora.transfer_function.transfer_function_header import TransferFunctionHeader\nfrom aurora.transfer_function.transfer_function_collection import (\n    TransferFunctionCollection,\n)\nfrom aurora.transfer_function.TTFZ import TTFZ\n\nCASE = \"IAK34ss\"  # synthetic\"\nbs_file = BAND_SETUP_PATH.joinpath(\"bs_256.cfg\")\nif CASE == \"synthetic\":\n    n_periods_clip = 3  # for synthetic case\n    z_mat = \"TS1zss20210831.mat\"\nelif CASE == \"IAK34ss\":\n    n_periods_clip = 3\n    z_mat = \"IAK34_struct_zss.mat\"\n\norientation_strs = get_default_orientation_block()\n\nfrequency_bands = FrequencyBands()\nsample_rate = 1.0\ntf_dict = {}\n\nfor i_dec in range(4):\n    frequency_bands = FrequencyBands()\n    frequency_bands.from_emtf_band_setup(\n        filepath=bs_file,\n        sample_rate=sample_rate,\n        decimation_level=i_dec + 1,\n        num_samples_window=256,\n    )\n    transfer_function_header = TransferFunctionHeader(\n        processing_scheme=\"RME\",\n        local_station_id=\"test1\",\n        reference_station_id=\"\",\n        input_channels=[\"hx\", \"hy\"],\n        output_channels=[\n            \"hz\",\n            \"ex\",\n            \"ey\",\n        ],\n        reference_channels=[],\n    )\n    tf_obj = TTFZ(transfer_function_header, frequency_bands)\n    config = DecimationLevelConfig()\n    config.sample_rate = sample_rate\n    config.num_samples_window = 256\n    tf_obj.processing_config = config\n    tf_dict[i_dec] = tf_obj\n\n    sample_rate \/= 4.0\n\ntmp = sio.loadmat(z_mat)\nif CASE == \"synthetic\":\n    stuff = tmp[\"temp\"][0][0].tolist()\nelif CASE == \"IAK34ss\":\n    stuff = tmp[\"TFstruct\"][0][0].tolist()\nTF = stuff[4]\nperiods = stuff[5]\ncov_ss = stuff[7]\ncov_nn = stuff[8]\nn_data = stuff[9]\nR2 = stuff[10]\nstderr = stuff[12]\nfreq = stuff[14]\n\nnan_cov_nn = []\nfor i in range(len(periods)):\n    if np.isnan(cov_nn[:, :, i]).any():\n        nan_cov_nn.append(i)\n        print(f\"NAN {i}\")\n\n\nif CASE == \"synthetic\":\n    cov_nn[:, :, 28] = cov_nn[:, :, 27]\nelif CASE == \"IAK34ss\":\n    for i in range(12):\n        cov_nn[:, :, i] = cov_nn[:, :, 12]\n\n# FIX NAN \/ INF\n\ntf_dict[0].tf.data = TF[:, :, :11]\ntf_dict[0].cov_nn.data = cov_nn[:, :, :11]\ntf_dict[0].cov_ss_inv.data = cov_ss[:, :, :11]\ntf_dict[0].num_segments.data = n_data[:, :11]\ntf_dict[0].R2.data = R2[:, :11]\n\ntf_dict[1].tf.data = TF[:, :, 11:17]\ntf_dict[1].cov_nn.data = cov_nn[:, :, 11:17]\ntf_dict[1].cov_ss_inv.data = cov_ss[:, :, 11:17]\ntf_dict[1].num_segments.data = n_data[:, 11:17]\ntf_dict[1].R2.data = R2[:, 11:17]\n\ntf_dict[2].tf.data = TF[:, :, 17:23]\ntf_dict[2].cov_nn.data = cov_nn[:, :, 17:23]\ntf_dict[2].cov_ss_inv.data = cov_ss[:, :, 17:23]\ntf_dict[2].num_segments.data = n_data[:, 17:23]\ntf_dict[2].R2.data = R2[:, 17:23]\n\ntf_dict[3].tf.data = TF[:, :, 23:]\ntf_dict[3].cov_nn.data = cov_nn[:, :, 23:]\ntf_dict[3].cov_ss_inv.data = cov_ss[:, :, 23:]\ntf_dict[3].num_segments.data = n_data[:, 23:]\ntf_dict[3].R2.data = R2[:, 23:]\n\n\nfor i_dec in range(4):\n    tf_dict[i_dec].tf.data = tf_dict[i_dec].tf.data\n\ntfc = TransferFunctionCollection(header=tf_obj.tf_header, tf_dict=tf_dict)\nz_file_path = \"from_matlab.zss\"\ntfc.write_emtf_z_file(z_file_path, orientation_strs=orientation_strs)\n\nif n_periods_clip:\n    clip_bands_from_z_file(z_file_path, n_periods_clip, n_sensors=5)\n\nzfile = read_z_file(z_file_path)\n\nzfile.apparent_resistivity(angle=0)\n\nscl = 1.0\nfig, axs = plt.subplots(nrows=2, figsize=(11, 8.5), dpi=300, sharex=True)\nmarkersize = 1\nplot_rho(\n    axs[0],\n    zfile.periods,\n    zfile.rxy * scl,\n    label=\"rxy\",\n    markersize=markersize,\n    color=\"red\",\n)\nplot_rho(\n    axs[0],\n    zfile.periods,\n    zfile.ryx * scl,\n    label=\"ryx\",\n    markersize=markersize,\n    color=\"blue\",\n)\naxs[0].legend()\nplot_phi(\n    axs[1], zfile.periods, zfile.pxy, label=\"pxy\", markersize=markersize, color=\"red\"\n)\nplot_phi(\n    axs[1], zfile.periods, zfile.pyx, label=\"pyx\", markersize=markersize, color=\"blue\"\n)\naxs[0].set_ylim(1, 1000)\naxs[0].set_xlim(1, 10000)\nplt.show()\nprint(\"success!\")\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_513","text":"<gh_stars>100-1000\nimport dash_core_components as dcc\nimport dash_bootstrap_components as dbc\nimport dash_html_components as html\nfrom dash.dependencies import Input, Output, State\nimport plotly.graph_objs as go\nimport plotly.express as px\nimport numpy as np\nimport pandas as pds\nimport scipy.stats as stats\n\nfrom app import app, template\nimport helper\n\n\n# Loading required resources\n\n\ndef get_proba(prob_ICU):\n    prob = prob_ICU[:, 1:] - prob_ICU[:, :-1]\n\n    prob = np.concatenate((prob_ICU[:, 0:1], prob), axis=1)\n    return prob\n\n\ndf_icu = pds.read_csv('assets\/icu_proba.csv', index_col=0)\ndf_death = pds.read_csv('assets\/death_proba.csv', index_col=0)\ndf_discharge = pds.read_csv('assets\/discharge_proba.csv', index_col=0)\n\ndf_enc = pds.read_csv('assets\/samp_prob.csv')\n\n\nprob_icu = get_proba(df_icu.values)\nprob_death = get_proba(df_death.values)\nprob_discharge = get_proba(df_discharge.values)\n\nage_param = (0.005168220626061383, -3024.5774292434444, 3091.093418522737)\n\n# Create forecast based on national average\n# --------------------------------------------------\n\nresource_form = dbc.Row(\n    [\n        dbc.Col(\n            dbc.FormGroup(\n                [\n                    dbc.Label(\"Surge Capacity New ICU Beds\", html_for=\"beds_input\"),\n                    dbc.Input(\n                        type=\"number\",\n                        id=\"beds_input\",\n                        min=5,\n                        max=5000,\n                        step=1,\n                        value=100,\n                    ),\n                ]\n            ),\n            width=3,\n        ),\n        dbc.Col(\n            dbc.FormGroup(\n                [\n                    dbc.Label(\"Number of Newly Hospitalized Patients (Day 1)\", html_for=\"patient_daily_input\"),\n                    dbc.Input(\n                        type=\"number\",\n                        id=\"patient_daily_input\",\n                        min=5,\n                        max=5000,\n                        step=1,\n                        value=50,\n                    ),\n                ]\n            ),\n\n            width=3,\n        ),\n        dbc.Col(\n            dbc.FormGroup(\n                [\n                    dbc.Label(\"Trend for Patient Arrival\", html_for=\"patient_schedule_input\"),\n                    dcc.Dropdown(\n                        id=\"patient_schedule_input\",\n                        options=[\n                            {\"label\": \"Constant\", \"value\": \"1\"},\n                            {\"label\": \"Exponential\", \"value\": \"2\"},\n                        ],\n                        value=\"1\",\n                    ),\n                ]\n            ),\n            width=3,\n        ),\n        dbc.Col(\n            dbc.Fade(\n\n                dbc.FormGroup(\n                    [\n                        dbc.Label(\"Exponential Rate\", html_for=\"patient_rate_input\"),\n                        dbc.Input(\n                            id=\"patient_rate_input\",\n                            type=\"number\",\n                            value=1.1,\n                            min=0.5,\n                            max=1.2,\n                            step=0.01\n                        ),\n                    ]\n                ),\n                id=\"fade\",\n                is_in=False,\n                appear=False,\n            ),\n            width=3,\n        ),\n    ],\n    form=True,\n)\n\npatient_form = dbc.Row(\n    [\n        dbc.Col(\n            dbc.FormGroup(\n                [\n                    dbc.Label(\"Median Age\", html_for=\"age_input\"),\n                    dbc.Input(\n                        type=\"number\",\n                        id=\"age_input\",\n                        min=45,\n                        max=85,\n                        step=1,\n                        value=68,\n                    ),\n                ]\n            ),\n            width=3,\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Percentage Male\",\n                id=\"sex_input\",\n                min=10,\n                max=90,\n                step=1,\n                value=63,\n            ),\n            width=3,\n        ),\n    ],\n    form=True,\n)\n\ncomor_form_row1 = dbc.Row(\n    [\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Hypertension %\",\n                id=\"hypertension_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=14\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Diabetes %\",\n                id=\"diabetes_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=11\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Asthma %\",\n                id=\"asthma_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=7\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Obesity %\",\n                id=\"obesity_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=4\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Immunosuppression %\",\n                id=\"immuno_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=2\n            ),\n        ),\n\n    ],\n    form=True,\n)\n\ncomor_form_row2 = dbc.Row(\n    [\n        dbc.Col(\n            helper.get_input_form(\n                label=\"C. Respiratory %\",\n                id=\"respiratory_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=6,\n                icon_url=app.get_asset_url(\"organs\/003-lungs.png\")\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"C. Heart %\",\n                id=\"heart_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=8,\n                icon_url=app.get_asset_url(\"organs\/023-heart.png\")\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"C. Renal %\",\n                id=\"renal_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=3,\n                icon_url=app.get_asset_url(\"organs\/008-kidneys-1.png\")\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"C. Liver %\",\n                id=\"liver_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=1,\n                icon_url=app.get_asset_url(\"organs\/028-liver.png\")\n            ),\n        ),\n        dbc.Col(\n            helper.get_input_form(\n                label=\"Pregnancy %\",\n                id=\"pregnancy_input\",\n                min=1,\n                max=90,\n                step=1,\n                value=1,\n                icon_url=app.get_asset_url(\"organs\/018-fetus.png\")\n            ),\n        ),\n    ],\n    form=True,\n)\n\nbutton = dbc.Row(\n    dbc.Col(dbc.Button(\"Run\", id=\"simulation_submit_button\", color=\"primary\", className=\"mr-2\", size=\"lg\"))\n)\n\n# sim_result = dbc.Row(\n#     [\n#         dbc.Col(html.Div([dcc.Graph(id=\"sim_line\")])),\n#     ],\n# )\n\nsim_result = html.Div([\n    dbc.Row(\n        [\n            dbc.Col(html.Div([dcc.Graph(id=\"sim_line\")])),\n        ],\n    ),\n    dbc.Row(\n        [\n            dbc.Col(html.Div([dcc.Graph(id=\"death_line\")])),\n        ],\n    ),\n    dbc.Row(\n        [\n            dbc.Col(html.Div([dcc.Graph(id=\"discharge_line\")])),\n        ],\n    ),\n])\n\nsimulation_input = html.Div(\n    [\n        html.Div(dbc.Row(dbc.Col(\n            html.Header(html.H2(\"In-Silico Demand Simulation (Advanced)\")),\n            style={'marginBottom': 25, 'marginTop': 25, 'text-align': 'center'})\n        )),\n        html.Div(dbc.Row(dbc.Col(\n            html.Header(html.H3(\"Resource & Demand Config\")),\n            style={'marginBottom': 5, 'marginTop': 0, 'text-align': 'left'})\n        )),\n        resource_form,\n        html.Div(dbc.Row(dbc.Col(\n            html.Header(html.H3(\"Patient Config\")),\n            style={'marginBottom': 5, 'marginTop': 5, 'text-align': 'left'})\n        )),\n        html.Div(dbc.Row(dbc.Col(\n            html.P(\"* Default values are national average.\"),\n            style={'marginBottom': 5, 'marginTop': 5, 'text-align': 'left', \"color\": 'Blue'})\n        )),\n        patient_form,\n        comor_form_row1,\n        comor_form_row2,\n        button,\n        sim_result\n    ]\n)\n\nlayout = html.Div([\n    simulation_input,\n])\n\n\n@app.callback(\n    Output(\"fade\", \"is_in\"),\n    [Input(\"patient_schedule_input\", \"value\")],\n)\ndef toggle_fade(v):\n    if v == \"2\":\n        # Button has never been clicked\n        return True\n    return False\n\n\ndef get_prob(data_enc,\n             age_param,\n             age_input,\n             sex_input,\n             hypertension_input,\n             diabetes_input,\n             asthma_input,\n             obesity_input,\n             immuno_input,\n             respiratory_input,\n             heart_input,\n             renal_input,\n             liver_input,\n             pregnancy_input):\n    prob_vec = np.array([sex_input, hypertension_input, diabetes_input,\n                         asthma_input, obesity_input, immuno_input,\n                         respiratory_input, heart_input, renal_input,\n                         liver_input, pregnancy_input]) * 1. \/ 100\n\n    fit_alpha, fit_loc, fit_beta = age_param\n    fit_loc += (age_input - 68)\n\n    age_log_prob = stats.lognorm.logpdf(data_enc['ageyear'].values, fit_alpha, fit_loc, fit_beta)\n    binary_data = data_enc.values[:, 2:-1]\n\n    binary_log_prob = binary_data * np.log(prob_vec) + (1 - binary_data) * np.log(1 - prob_vec)\n    binary_log_prob = np.sum(binary_log_prob, axis=1)\n    total_log_prob = age_log_prob + binary_log_prob\n\n    samp_prob = np.exp((total_log_prob - data_enc['samp_log_lik']).values)\n    samp_prob = samp_prob \/ np.sum(samp_prob)\n    return samp_prob\n\n\n# example output\n@app.callback([Output('sim_line', 'figure'),\n               Output('death_line', 'figure'),\n               Output('discharge_line', 'figure')],\n              [Input('simulation_submit_button', 'n_clicks')],\n              [\n                  State('beds_input', 'value'),\n                  State('patient_daily_input', 'value'),\n                  State('patient_schedule_input', 'value'),\n                  State('patient_rate_input', 'value'),\n                  State('age_input', 'value'),\n                  State('sex_input', 'value'),\n                  State('hypertension_input', 'value'),\n                  State('diabetes_input', 'value'),\n                  State('asthma_input', 'value'),\n                  State('obesity_input', 'value'),\n                  State('immuno_input', 'value'),\n                  State('respiratory_input', 'value'),\n                  State('heart_input', 'value'),\n                  State('renal_input', 'value'),\n                  State('liver_input', 'value'),\n                  State('pregnancy_input', 'value'),\n              ])\ndef update_output(\n        n_clicks,\n        beds_input,\n        patient_daily_input,\n        patient_schedule_input,\n        patient_rate_input,\n        age_input,\n        sex_input,\n        hypertension_input,\n        diabetes_input,\n        asthma_input,\n        obesity_input,\n        immuno_input,\n        respiratory_input,\n        heart_input,\n        renal_input,\n        liver_input,\n        pregnancy_input,\n):\n    if n_clicks is None:\n        return \"\"\n    else:\n        probs = get_prob(df_enc,\n                         age_param,\n                         age_input,\n                         sex_input,\n                         hypertension_input,\n                         diabetes_input,\n                         asthma_input,\n                         obesity_input,\n                         immuno_input,\n                         respiratory_input,\n                         heart_input,\n                         renal_input,\n                         liver_input,\n                         pregnancy_input)\n\n        n_arr = get_patients(patient_daily_input, patient_schedule_input, patient_rate_input)\n        n_itr = 100\n        icu_sum, death_sum, discharge_sum = one_sim(n_itr, n_arr, prob_icu, prob_death, prob_discharge, probs)\n\n        days = list(range(1, 16))\n\n        fig_icu = get_figure(days,\n                             *icu_sum,\n                             main_label='Occupancy (Mean)',\n                             title=\"Simulated ICU Occupancy\",\n                             yaxis=\"Number of Occupied ICU Beds\")\n        fig_icu.update_layout(\n            shapes=[{'line': {'color': 'grey', 'dash': 'dash', 'width': 1},\n                     'type': 'line',\n                     'x0': 0.,\n                     'x1': 1.,\n                     'xref': 'paper',\n                     'y0': beds_input,\n                     'y1': beds_input,\n                     'yref': 'y'}]\n        )\n        fig_death = get_figure(days,\n                               *death_sum,\n                               main_label='Total Death (Mean)',\n                               title=\"Simulated Death Toll\",\n                               yaxis=\"Number of Deaths\")\n        fig_discharge = get_figure(days,\n                                   *discharge_sum,\n                                   main_label='Total Discharge (Mean)',\n                                   title=\"Simulated Cumulative Discharge\",\n                                   yaxis=\"Number of Discharge\")\n\n    return fig_icu, fig_death, fig_discharge\n\n\ndef get_figure(days, m, upp, lor, main_label='Occupancy (Mean)', title=\"Simulated ICU Occupancy\",\n               yaxis=\"Number of Occupied ICU Beds\"):\n    fig = go.Figure()\n    fig.add_trace(go.Scatter(x=days,\n                             y=m,\n                             mode='lines+markers',\n                             name=main_label))\n\n    fig.add_trace(go.Scatter(x=days,\n                             y=upp,\n                             mode='lines',\n                             line=dict(dash='dot'),\n                             name='95% Quantile'))\n    fig.add_trace(go.Scatter(x=days,\n                             y=lor,\n                             mode='lines',\n                             line=dict(dash='dot'),\n                             name='5% Quantile'))\n    fig.update_layout(\n        title=title,\n        paper_bgcolor='White',\n        plot_bgcolor='White',\n        hovermode=\"x\",\n    )\n    fig.update_yaxes(title_text=yaxis)\n    fig.update_xaxes(title_text='Days')\n    fig.update_layout(template=template)\n    return fig\n\n\ndef samp_one_person(p_icu, p_death, p_discharge, probs):\n    inds = np.random.choice(p_icu.shape[0], p=probs, size=p_icu.shape[0], replace=True)\n    p_icu = p_icu[inds, :]\n    p_death = p_death[inds, :]\n    p_discharge = p_discharge[inds, :]\n\n    icu = np.random.binomial(1, p_icu)\n    death = np.random.binomial(1, p_death)\n    discharge = np.random.binomial(1, p_discharge)\n\n    icu = np.cumsum(icu, axis=1) > 0\n    death = np.cumsum(death, axis=1) > 0\n    discharge = np.cumsum(discharge, axis=1) > 0\n\n    icu_stay = icu.copy()\n    icu_stay[death] = False\n    icu_stay[discharge] = False\n\n    return icu_stay * 1., death * 1., discharge * 1.\n\n\ndef get_one_icu_line(n_person, one_icu, one_death, one_discharge):\n    n_person = n_person.astype(np.int)\n    n_day = len(n_person)\n    sums_icu = np.zeros(n_day)\n    sums_death = np.zeros(n_day)\n    sums_discharge = np.zeros(n_day)\n    s = 0\n    for i in range(n_day):\n        row_sum = np.sum(one_icu[s:(s + int(n_person[i])), :], axis=0)\n        sums_icu[i:] = sums_icu[i:] + row_sum[:(n_day - i)]\n\n        row_sum = np.sum(one_death[s:(s + int(n_person[i])), :], axis=0)\n        sums_death[i:] = sums_death[i:] + row_sum[:(n_day - i)]\n\n        row_sum = np.sum(one_discharge[s:(s + int(n_person[i])), :], axis=0)\n        sums_discharge[i:] = sums_discharge[i:] + row_sum[:(n_day - i)]\n\n        s += n_person[i]\n    return sums_icu, sums_death, sums_discharge\n\n\ndef create_summary(samps_icu):\n    m = np.mean(samps_icu, axis=0)\n    upp = np.quantile(samps_icu, 0.95, axis=0)\n    lor = np.quantile(samps_icu, 0.05, axis=0)\n    return m, upp, lor\n\n\ndef one_sim(n_itr, n_arr, prob_icu, prob_death, prob_discharge, probs):\n    samps_icu = np.zeros((n_itr, 15))\n    samps_death = np.zeros((n_itr, 15))\n    samps_discharge = np.zeros((n_itr, 15))\n\n    for i in range(n_itr):\n        one_icu, one_death, one_discharge = samp_one_person(prob_icu, prob_death, prob_discharge, probs)\n        icu, death, discharge = get_one_icu_line(n_arr, one_icu, one_death, one_discharge)\n\n        samps_icu[i, :] = icu\n        samps_death[i, :] = death\n        samps_discharge[i, :] = discharge\n\n    icu_sum = create_summary(samps_icu)\n    death_sum = create_summary(samps_death)\n    discharge_sum = create_summary(samps_discharge)\n    return icu_sum, death_sum, discharge_sum\n\n\ndef get_patients(patient_daily_input, patient_schedule_input, patient_rate_input):\n    arr = np.ones(15) * patient_daily_input\n    if patient_schedule_input == \"1\":\n        return arr\n\n    for i in range(1, 15):\n        arr[i] = arr[i - 1] * patient_rate_input\n    arr = arr.astype(np.int)\n    return arr\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_515","text":"<reponame>yuhao600\/project-euler\nfrom fractions import Fraction\n\nfraction = Fraction(3, 2)\ncount = 0\nfor i in range(1000):\n    if len(str(fraction.numerator)) > len(str(fraction.denominator)):\n        count += 1\n    fraction = 1 \/ (1 + fraction) + 1\n    \nprint(count)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_519","text":"import cPickle\n\nimport mnist_loader\nimport network\nimport numpy as np\nfrom scipy import misc, float32\nimport glob\ntraining_data1, validation_data, test_data = mnist_loader.load_data_wrapper()\n#print training_data[0][0]\ntraining_data = []\nfolders = glob.glob(\"C:\/Users\/ajha2\/Desktop\/PythonProjects\/MNIST_image\/mnist_png\/testing\/*\")\n\nfor folder in folders:\n    files = glob.glob( folder + \"\/*\")\n    for file in files:\n        img = misc.imread(file)\n        img_pixel_array = []\n        for i in range(0, len(img)):\n            for j in range(0, len(img[0])):\n                img_pixel_array.append([float32(img[i][j])\/256])\n        img_pixel_np_array = np.array(img_pixel_array, ndmin = 2)\n        #img_digit = np.array([[0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.0]], ndmin = 2)\n        #img_digit[int(folder[-1])][0] = 1.0\n        training_data.append((img_pixel_np_array, int(folder[-1])))\n\nf = open('C:\/Users\/ajha2\/Desktop\/PythonProjects\/MNIST_image\/testing_image_objects.save', 'wb')\n\ncPickle.dump(training_data, f, protocol=cPickle.HIGHEST_PROTOCOL)\nf.close()\nprint\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_521","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCalculates a Vector Ruggedness Measure\n\nFor more information on ArcGIS Python Raster Functions, See:\nhttps:\/\/github.com\/Esri\/raster-functions\/wiki\/PythonRasterFunction\n\nInput:\nslope raster (degrees; 0 = flat, 90 = vertical)\naspect raster (degrees, north = 0, clockwise increase)\nNeighborhood size (int describing a square that is size by size pixels)\n\nThis tool measures terrain ruggedness by calculating the vector ruggedness measure\ndescribed in <NAME>., <NAME>, and <NAME>. 2007. Quantifying\nLandscape Ruggedness for Animal Habitat Analysis: A case Study Using Bighorn Sheep in\nthe Mojave Desert. Journal of Wildlife Management. 71(5): 1419 -1426.\n\nref: http:\/\/www.bioone.org\/doi\/abs\/10.2193\/2005-723\n\nThis Raster Function was based on an arcpy tool originally written by <NAME>\nthat was last updated 12\/17\/2010\n\nFrom the abstract:\nTerrain ruggedness is often an important variable in wildlife habitat models.\nMost methods used to quantify ruggedness are indices derived from measures of\nslope and, as a result, are strongly correlated with slope. Using a Geographic\nInformation System, we developed a vector ruggedness measure (VRM) of terrain\nbased on a geomorphological method for measuring vector dispersion that is less\ncorrelated with slope...\n\"\"\"\n\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport numpy as np\nfrom scipy import ndimage\n\n\n# pylint: disable=invalid-name,unused-argument,no-self-use\n# required for the class contract required by the executing framework.\n\n\nclass VectorRuggednessMeasure:\n    \"\"\"A Python Raster Function to calculate a Vector Ruggedness Measure.\"\"\"\n\n    def __init__(self):\n        self.name = \"Vector Ruggedness Measure\"\n        self.description = (\n            \"Calculates the ruggedness of the terrain by measuring \"\n            \"the amount of dispersal of the normal vectors \"\n            \"of the terrain in the neighborhood of a location\"\n        )\n        self.neighborhood_size = 3\n\n    def getParameterInfo(self):\n        \"\"\"Describes all raster and scalar inputs to the raster function.\"\"\"\n\n        return [\n            {\n                \"name\": \"slope\",\n                \"dataType\": \"raster\",\n                \"value\": None,\n                \"required\": True,\n                \"displayName\": \"Slope raster\",\n                \"description\": (\n                    \"A raster of slope values for the terrain, in degrees \"\n                    \"with 0 = flat and 90 = vertical\"\n                ),\n            },\n            {\n                \"name\": \"aspect\",\n                \"dataType\": \"raster\",\n                \"value\": None,\n                \"required\": True,\n                \"displayName\": \"Aspect raster\",\n                \"description\": (\n                    \"A raster of aspect value for the terrain, in degrees \"\n                    \"with north = 0, increasing clockwise\"\n                ),\n            },\n            {\n                \"name\": \"size\",\n                \"dataType\": \"numeric\",\n                \"value\": 3,\n                \"required\": False,\n                \"displayName\": \"Neighborhood Size\",\n                \"description\": (\n                    \"A square of size x size  is considered to determine \"\n                    \"the ruggedness at the center of the square.\"\n                ),\n            },\n        ]\n\n    def getConfiguration(self, **scalars):\n        \"\"\"Define how input rasters are read and the output raster constructed.\"\"\"\n\n        return {\n            \"inheritProperties\": 2\n            | 4\n            | 8,  # inherit nodata, size, resample type, not pixel type.\n            \"invalidateProperties\": 1\n            | 2\n            | 4\n            | 8,  # reset everything on the parent dataset.\n            \"resampling\": True,  # process at request resolution\n        }\n\n    def updateRasterInfo(self, **kwargs):\n        \"\"\"Define the location and dimensions of the output raster.\"\"\"\n\n        self.neighborhood_size = kwargs.get(\"size\", 3)\n\n        kwargs[\"output_info\"][\"bandCount\"] = 1  # output is a single band raster\n        kwargs[\"output_info\"][\n            \"pixelType\"\n        ] = \"f4\"  # output is a 32bit floating point number\n        kwargs[\"output_info\"][\"statistics\"] = (\n            {\"minimum\": 0.0, \"maximum\": 1.0},\n        )  # we know something about the range of the outgoing raster.\n        kwargs[\"output_info\"][\"histogram\"] = ()\n        return kwargs\n\n    def updatePixels(self, tlc, shape, props, **pixelBlocks):\n        \"\"\"Creates processed pixels given all scalar and raster inputs.\"\"\"\n\n        # pylint: disable=too-many-locals\n\n        slope = np.array(pixelBlocks[\"slope_pixels\"], dtype=\"f4\", copy=False)[\n            0\n        ]  # limit to first (only) band\n        aspect = np.array(pixelBlocks[\"aspect_pixels\"], dtype=\"f4\", copy=False)[0]\n        dr = np.pi \/ 180.0  # degree to radian\n        slope_rad = slope * dr\n        aspect_rad = aspect * dr\n        xy = np.sin(slope_rad)\n        z = np.cos(slope_rad)\n        x = np.where(aspect == -1, 0.0, np.sin(aspect_rad) * xy)\n        y = np.where(aspect == -1, 0.0, np.cos(aspect_rad) * xy)\n        kernel = np.ones((self.neighborhood_size, self.neighborhood_size))\n        kernel_size = self.neighborhood_size * self.neighborhood_size\n        # focal statistics sum (used in the original tool) is the same as an image\n        #   convolution with an all ones in the kernel.  I.e. the sum all the cells\n        #   overlapping the kernel with a weight of 1 on each cell.\n        # TODO: how should we handle the boundary condition\n        #   cells outside the boundary will always have a zero value -- no contribution\n        # FIXME: need to handle nodata\n        #   original tool returned nodata if any cell in the neighborhood was nodata\n        x_sum = ndimage.convolve(x, kernel)  # , mode='constant', cval=0.0)\n        y_sum = ndimage.convolve(y, kernel)  # , mode='constant', cval=0.0)\n        z_sum = ndimage.convolve(z, kernel)  # , mode='constant', cval=0.0)\n        total = np.sqrt(x_sum * x_sum + y_sum * y_sum + z_sum * z_sum)\n        ruggedness = 1.0 - (total \/ kernel_size)\n        pixelBlocks[\"output_pixels\"] = ruggedness.astype(props[\"pixelType\"], copy=False)\n        return pixelBlocks\n\n    def updateKeyMetadata(self, names, bandIndex, **keyMetadata):\n        \"\"\"Define metadata attributes associated with the output raster dataset.\"\"\"\n\n        if bandIndex == -1:\n            keyMetadata[\"datatype\"] = \"Processed\"  # outgoing raster is now 'Processed'\n        elif bandIndex == 0:\n            keyMetadata[\n                \"wavelengthmin\"\n            ] = None  # reset inapplicable band-specific key metadata\n            keyMetadata[\"wavelengthmax\"] = None\n        return keyMetadata\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_525","text":"\"\"\"Functions to calculate three-point correlations and bispectrum.\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nfrom scipy.fftpack import fft, ifft2, fftshift\nfrom scipy.linalg import hankel\ntry:\n    from progress import getLogger\nexcept ImportError:\n    from logging import getLogger\n\nfrom .helpers import is_number_like, is_string_like, get_nfft\n\ndef fft2x(x, y, z, nfft=None):\n    \"\"\"Return Bi-cross-spectrum.\"\"\"\n    \n    # 1d-fourier-transforms\n    # ----------------------------------------------------------\n    x = np.ravel(x)\n    y = np.ravel(y)\n    z = np.ravel(z)\n    \n    assert len(x) == len(y) and len(x) == len(z), (\n        \"Arrays must have the same length\"\n    )\n    \n    if not nfft:\n        # let's hope it's not too much!\n        nfft = len(x)\n            \n    # transform\n    xfft = fft(x, n=nfft)\n    \n    if y is x:\n        yfft = xfft\n    else:\n        yfft = fft(y, n=nfft)\n\n    if z is x:\n        zfft = xfft\n    elif z is y:\n        zfft = yfft\n    else:\n        zfft = fft(z, n=nfft)\n    \n    # Fourier space product\n    # ----------------------------------------------------------\n    ## create indices aligned with fftpack's fft2 quadrants\n    lm = nfft \/ 2.\n    i0 = np.roll(\n        np.arange(int(np.ceil(lm-1)), int(-lm-1), -1, dtype=int), \n        int(np.floor(lm)) + 1\n    )\n    i = i0 * np.ones((nfft, nfft), dtype=int)\n    j0 = np.arange(0, -nfft, -1, dtype=int)\n    j = hankel(j0, np.roll(j0,1))\n    \n    # B\n    xfft = np.conjugate(xfft)\n    return xfft[j] * yfft[i] * zfft[i.T]\n\ndef padded_x3corr_norm(nfft, pad=0, segments=1, debias=True):\n    \"\"\"Return a matrix of weights necessary to normalise x3corr\n    (triple cross-correlation) calculated with zero-padded ffts.\n    For pad = zero, all weights are equal to N. See x3corr.\n    \n    Parameters:\n    ===========\n    \n    nfft: int\n        Size of fft segments (= (maximum lag + pad) \/ 2, see fft)\n    pad: int\n        Number of zeros added to the segment(s) before fft.\n    segments: int\n        Number of segments that were summed, is used as multiplyer.\n    debias: bool\n        Correct for bias from zero padding. Default: False - to be consistent\n        with two-point xcorr defaults.\n    \"\"\"\n    ndat = nfft - pad\n    nmid = min(ndat, nfft\/\/2) # symmetry axis\n    nemp = -min(0, ndat-pad) # completely empty\n    w3 = np.ones((nfft,nfft))\n    \n    if (nfft > ndat) and ndat <= pad and debias:\n        # correct zero-padding bias\n        for n in range(nfft-nemp):\n            for k in range(nfft-nemp):\n                if n < ndat and k < ndat:\n                    w3[n,k] = ndat - max(n,k)\n                elif n > ndat and k > ndat:\n                    w3[n+nemp,k+nemp] = w3[nfft-n-nemp,nfft-k-nemp]\n                elif abs(k - n) > ndat:\n                    w3[n+(n>k)*nemp,k+(k>n)*nemp] = max(\n                        abs(ndat - abs(k - n)), 1\n                    )\n    elif (nfft > ndat) and ndat > pad and debias:\n        w3 *= ndat - pad\n        for n in range(pad):\n            for k in range(pad):\n                if abs(k-n) < pad:\n                    w3[k,n] = w3[-k,n] = w3[k,-n] = w3[-k,-n] = ndat - max(n,k)\n    else:\n        w3 *= nfft  \n          \n    return w3 * segments\n\n\ndef x3corr(\n        x, y, z, \n        nfft=2**7, pad=0, subtract_mean=True, norm='corr', debias=True\n    ):\n    \"\"\"Return triple cross correlation matrix\n    \n                     < x(t) y(t-k) z(t-l) > \n        C_xyz(k,l) = ----------------------\n                      std(x) std(y) std(z)\n    \n    Parameters:\n    ===========\n    \n    x, y, z: array-like\n        Three time-series of the same length\n    nfft: int\n        Length of fft segments. Output contains nfft\/2 positive and\n        negative lags.\n    pad: int\n        Zero-padding of individual fft segments which are averaged.\n        default: 0. \n            Result will be nfft x nfft matrix with nfft \/ 2\n            positive and negative lags.\n        pad = nfft: \n            Perfect unmixing of positive and negative frequencies.\n            Warning: in contrast to the regular cross correlation, \n            parts of the second and third quadrant are be \"blind spots\"\n            where the the distance between the positve- and negative-lag\n            contributions exceeds nfft.\n    subtract_mean: bool\n        Subtract mean from time-series' first.\n    norm: str\n        default: 'corr' \n            Normalise to correlation\n        'cov':\n            Normalise to cross covariance\n    debias: bool\n        Correct for bias from zero padding. Default: True. In contrast to\n        the two-point function xcorr, we here debias by default because the\n        three-point correlation is always averaged over short segments so\n        the bias is significant for all likely applications.\n    \"\"\"\n    \n    if subtract_mean:\n        x = x - np.mean(x)\n        y = y - np.mean(y)\n        z = z - np.mean(z)\n    \n    # len of fft segments\n    ndat = nfft - pad\n    # number of overlapping fft segments (iterations below)\n    #nit = int(len(x) \/ ndat)\n    nit = int(np.ceil(len(x) \/ float(ndat)))\n    ti = np.unique(np.linspace(0, len(x)-ndat, nit, dtype=int))\n    \n    # mean cross-bispectrum\n    B = np.zeros((nfft, nfft), dtype=complex)\n    for i in range(nit):\n        B += fft2x(\n            x[ti[i]:ti[i]+ndat], \n            y[ti[i]:ti[i]+ndat], \n            z[ti[i]:ti[i]+ndat],\n            nfft = nfft # zero pad\n        )\n    \n    # normalisation\n    if norm == \"cov\":\n        n = padded_x3corr_norm(nfft, pad, nit, debias=debias)\n    elif is_number_like(norm):\n        n = float(norm)\n    elif (\n            hasattr(norm, '__len__') \n            and len(norm) == len(x) \n            and not is_string_like(norm)\n        ):\n        n = np.array(norm, dtype=float)\n    else:\n        n = padded_x3corr_norm(\n            nfft, pad, nit * np.std(x) * np.std(y) * np.std(z), debias=debias\n        )\n    \n    # backtransform to t-space & normalise \n    # to obtain the correlation\n    return np.real(ifft2(B)) \/ n\n    \ndef x3corr_grouped_df(\n        df, \n        cols,\n        by            = 'date', \n        nfft          = 'auto',\n        funcs         = (lambda x: x, lambda x: x, lambda x: x), \n        subtract_mean = 'total',\n        norm          = 'total corr',\n        debias        = True\n    ):\n    \"\"\"Group dataframe and calc triple cross correlation for each group \n    separately.\n    Returns: mean and std over groups for lags from -nfft\/2 to nfft\/2.\n    \n    Parameters:\n    ===========\n    \n    df: pandas.DataFrame\n        input time series, must include the columns \n        for which we calculate the xcorr and the one by which we group.\n    cols: list of str\n        colums with the time series of interest.\n    by: str\n        column by which to group. default: 'date'\n    nfft: str, int\n        Length of fft segments. Default: 'auto'.\n        'crop':      use the largest power of 2 < smallest group size\n        'pad':       use the smallest power of 2 > smallest group size\n        'pad > 100': same but ignoring groups with less than 100 events\n        'demix':     double-pad to perfectly separate anticausal frequencies.\n        Note: 2d-fft can be really inefficient if nfft is not a power of 2.\n        See also: get_nfft\n    funcs: list of functions\n        functions to apply to cols before calculating the xcorr. \n        default: identity (lambda x: x)\n    subtract_mean: str\n        what to subtract from the time series before calculating the \n        autocorr.\n        'total': subtract mean of the whole series from each group\n        'group': subtract group mean from each group\n        None:    subtract nothing\n        default: 'total'\n    norm: str\n        Normalisation. default: 'total' (normalise normalise days to cov, \n        the end result by total cov giving approx. a correlation.)\n        Other Values are passed to xcorr and used on each day separately.\n    \n    see also: x3corr, xcorr_grouped_df\n    \"\"\"    \n    # group, allocate, slice\n    g = df.groupby(by)\n    # we need three columns\n    cols = list(cols)\n    assert len(cols) == 3, \"Three column-names required.\"\n    df = df[cols]\n    g = g[cols]\n    # determine nfft\n    nfft, events_required = get_nfft(nfft, g)\n    \n    # what to subtract\n    x = None \n    y = None\n    z = None\n        \n    if subtract_mean in ('total', 'auto'):\n        # must match normalisation code below!\n        x = funcs[0](df[cols[0]])\n        y = funcs[1](df[cols[1]])\n        z = funcs[2](df[cols[1]])\n        \n        subtract = [\n            x.mean(),\n            y.mean(),\n            z.mean()\n        ]\n        sm       = False\n    elif subtract_mean in ('group', 'each', True, by):\n        subtract = [0,0,0]\n        sm       = True\n    else:\n        subtract = [0,0,0]\n        sm       = False\n    \n    # which norm for each day?\n    norm_flag = norm in (\"total\", \"total cov\", \"total corr\", \"auto\")\n    if norm_flag:\n        # calculate covariances for each day and later divide by global cov.\n        nd = 'cov'\n    else:\n        nd = norm\n    \n    # We can't average in frequency space because of the daily normalisation\n    ## ( daily variance changes, padding )\n    C  = np.zeros((nfft, nfft))\n    Ce = np.zeros((nfft, nfft))\n    \n    # Average over days\n    discarded_days = 0\n    for i, (gk, gs) in enumerate(g):\n        lgs = len(gs)\n        if lgs < events_required:\n            # this day is too short\n            discarded_days += 1\n            continue\n        else:\n            xi  = funcs[0](gs[cols[0]]).values - subtract[0]\n            yi  = funcs[1](gs[cols[1]]).values - subtract[1]\n            zi  = funcs[2](gs[cols[2]]).values - subtract[1]\n            pad = max(nfft - lgs, 0)\n            ci  = x3corr(\n                xi, yi, zi, \n                nfft=nfft, pad=pad, subtract_mean=sm, norm=nd, debias=debias\n            )\n            C  += ci\n            Ce += ci**2\n    \n    del ci, xi, yi, zi\n    \n    n = float(len(g) - discarded_days)\n    if discarded_days:\n        getLogger(__name__).info(\n            \"Discarded %i days < %i events\" % (\n                discarded_days, events_required\n            )\n        )\n        \n    if norm_flag:\n        if \"corr\" in norm:\n            if x is None:\n                # maybe we didn't calculate these yet\n                # must match subtract code above!\n                x = funcs[0](df[cols[0]])\n                y = funcs[1](df[cols[1]])\n                z = funcs[2](df[cols[2]])\n            # from cross covariance to cross correlation\n            n *= np.std(x) * np.std(y) * np.std(z)\n        \n    C \/= n\n    Ce = np.sqrt(np.abs(Ce - C**2) \/ n)\n    \n    # done\n    return C, Ce\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_240","text":"<filename>agent.py\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun Feb 28 11:15:15 2021\n\n@author: <NAME>\n\"\"\"\nfrom numpy import random\nfrom sympy import hyper\n\nfrom agent_control import AgentControl\nfrom replay_buffer import ReplayBuffer\nfrom collections import namedtuple\nimport time\nimport numpy as np\nimport math\nimport telegram_bot as tg\n\n\nclass Agent:\n\n    Transition = namedtuple('Transition',('state', 'action', 'next_state', 'reward', 'done'), rename = False) # 'rename' means not to overwrite invalid field\n\n    def __init__(self, env, hyperparameters, device, writer, max_games, tg_bot):\n        self.eps_start = hyperparameters['eps_start']\n        self.eps_end = hyperparameters['eps_end']\n        self.eps_decay = hyperparameters['eps_decay']\n        self.epsilon = hyperparameters['eps_start']\n        self.n_iter_update_nn = hyperparameters['n_iter_update_nn']\n        self.max_games = max_games\n        self.tg_bot = tg_bot\n        self.env = env\n\n        self.agent_control = AgentControl(env, device, hyperparameters['learning_rate'], hyperparameters['gamma'], hyperparameters['multi_step'], hyperparameters['double_dqn'], hyperparameters['dueling'])\n        self.replay_buffer = ReplayBuffer(hyperparameters['buffer_size'], hyperparameters['buffer_minimum'], hyperparameters['multi_step'], hyperparameters['gamma'])\n        self.summary_writer = writer\n\n        self.num_iterations = 0\n        self.total_reward = 0\n        self.num_games = 0\n        self.total_loss = []\n        self.ts_frame = 0\n        self.ts = time.time()\n        self.birth_time = time.time()\n        self.rewards = []\n\n        if self.tg_bot:\n            tg.welcome_msg(hyperparameters['multi_step'], hyperparameters['double_dqn'], hyperparameters['dueling'])\n\n    def select_greedy_action(self, obs):\n        # Give current state to the control who will pass it to NN which will\n        # return all actions and the control will take max and return it here\n        return self.agent_control.select_greedy_action(obs)\n\n    def select_eps_greedy_action(self, obs):\n        rand_num = random.rand()\n        if self.epsilon > rand_num:\n            # Select random action - explore\n            return self.env.action_space.sample()\n        else:\n            # Select best action\n            return self.select_greedy_action(obs)\n\n    def add_to_buffer(self, obs, action, new_obs, reward, done):\n        transition = self.Transition(state = obs, action = action, next_state = new_obs, reward = reward, done = done)\n        self.replay_buffer.append(transition)\n        self.num_iterations = self.num_iterations + 1\n        if self.epsilon > self.eps_end:\n            self.epsilon = self.eps_start - self.num_iterations \/ self.eps_decay\n        self.total_reward = self.total_reward + reward\n\n    def sample_and_improve(self, batch_size):\n        # If buffer is big enough\n        if len(self.replay_buffer.buffer) > self.replay_buffer.minimum:\n            # Sample batch_size number of transitions from buffer B\n            mini_batch = self.replay_buffer.sample(batch_size)\n            # Calculate loss and improve NN\n            loss = self.agent_control.improve(mini_batch)\n            # So we can calculate mean of all loss during one game\n            self.total_loss.append(loss)\n\n        if ( self.num_iterations % self.n_iter_update_nn) == 0:\n            self.agent_control.update_target_nn()\n\n    def reset_parameters(self):\n        self.rewards.append(self.total_reward)\n        self.total_reward = 0\n        self.num_games = self.num_games + 1\n        self.total_loss = []\n\n    def print_info(self):\n        # print(self.num_iterations, self.ts_frame, time.time(), self.ts)\n        fps = (self.num_iterations-self.ts_frame)\/(time.time()-self.ts)\n        print('%d %d rew:%d mean_rew:%.2f fps:%d, eps:%.2f, loss:%.4f' % (self.num_iterations, self.num_games, self.total_reward, np.mean(self.rewards[-40:]), fps, self.epsilon, np.mean(self.total_loss)))\n        self.ts_frame = self.num_iterations\n        self.ts = time.time()\n\n        if self.summary_writer != None:\n            self.summary_writer.add_scalar('reward', self.total_reward, self.num_games)\n            self.summary_writer.add_scalar('mean_reward', np.mean(self.rewards[-40:]), self.num_games)\n            self.summary_writer.add_scalar('10_mean_reward', np.mean(self.rewards[-10:]), self.num_games)\n            self.summary_writer.add_scalar('esilon', self.epsilon, self.num_games)\n            self.summary_writer.add_scalar('loss', np.mean(self.total_loss), self.num_games)\n\n        if self.tg_bot:\n            if (self.num_games % 10) == 0:\n                tg.info_msg(self.num_games+1, self.max_games, np.mean(self.rewards[-40:]), np.mean(self.total_loss))\n            if self.num_games == (self.max_games - 1):\n                tg.end_msg(time.time() - self.birth_time)\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_241","text":"import random\nfrom fractions import Fraction\n\nMAX_HASH = pow(2, 32)\nFILES_TO_SIMULATE = 100000\nMAX_SERVERS = 10\n\n\ndef generate_fraction(servs):\n    res = [[(0, Fraction(1, 1))]]  # server index, fraction\n    for i in range(1, servs):\n        rn = []\n        fraction_to_subtract = {}\n        for si in range(0, i):\n            fraction_to_subtract[si] = Fraction(1, i * (i + 1))\n        # print('to subtract per server:', fraction_to_subtract)\n        # take a part from each previous server.\n        for piece in res[i - 1]:\n\n            # print('starting:', piece, end='\\t')\n            si = piece[0]\n            fr = piece[1]\n\n            if (not fr > fraction_to_subtract[si]):\n                # print('giving it all to nfew server')\n                rn.append([i, fr])\n                fraction_to_subtract[si] -= fr\n            else:\n                if si % 2:  # makes similar parts sit together\n                    # rewriting old one but now its fraction decreases\n                    rn.append([si, fr - fraction_to_subtract[si]])\n                    # adding new one\n                    rn.append([i, fraction_to_subtract[si]])\n                else:\n                    rn.append([i, fraction_to_subtract[si]])\n                    rn.append([si, fr - fraction_to_subtract[si]])\n                fraction_to_subtract[si] = Fraction(0, 1)\n\n        # connect pieces siting next to each other\n        r = []\n        p = [-1, Fraction(1, 1)]\n        # print('rn:', rn)\n        for j in rn:\n            if j[0] != p[0]:\n                r.append(j)\n            else:\n                r[-1] = ([j[0], j[1] + p[1]])\n            p = j\n        # print(r)\n        res.append(r)\n    return res\n\n\nfractions = generate_fraction(MAX_SERVERS)\nranges = []\nfor s, f in enumerate(fractions):\n    ul = 0\n    rang = []\n    for i in f:\n        ul += i[1]\n        rang.append([i[0], ul])\n    print(rang)\n    ranges.append(rang)\n    print('servers:', s + 1, '\\tpieces:', len(f), '\\nfractions:', f, '\\nranges:', rang)\n\n\ndef algo1(fm, servers):\n    return fm % servers\n\n\ndef algo2(fm, servers):\n    fr = (MAX_HASH - 1) \/ servers\n    return int(fm \/ fr)\n\n\ndef algo3(fm, servers):\n    ff = Fraction(fm, MAX_HASH)\n    ul = 0\n    # print(ranges[servers])\n    for i in ranges[servers]:\n        if ff < i[1]:\n            # print(ff, i, float(ff))\n            return i[0]\n\n\nprint(\"=======================================\")\n\nmatches = [0] * (MAX_SERVERS - 1)\nfor files in range(FILES_TO_SIMULATE):\n    fm = random.randint(0, MAX_HASH)\n    endup = []\n    for servers in range(0, MAX_SERVERS):\n        s = algo3(fm, servers)\n        endup.append(s)\n    # print('-' * 30)\n    # print(fm, endup)\n\n    l = endup[0]\n    for i, e in enumerate(endup[1:]):\n        if e == l:\n            matches[i] += 1\n        l = e\nprint('=' * 30)\nprint('reused from total of', FILES_TO_SIMULATE, 'files')\nprint(matches)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_242","text":"<reponame>waitong94\/smarties\n#!\/usr\/bin\/env python3\n#\n#  smarties\n#  Copyright (c) 2018 CSE-Lab, ETH Zurich, Switzerland. All rights reserved.\n#  Distributed under the terms of the MIT license.\n#\n#  Created by <NAME> (<EMAIL>).\n#\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy import random\nfrom scipy.stats.stats import pearsonr\n\nXCOL = int(sys.argv[1])\nYCOL = int(sys.argv[2])\nNFILES = len(range(3, len(sys.argv)))\n\n\nfor j in range(3, len(sys.argv)):\n  DATA = np.fromfile(sys.argv[j], dtype=np.float32)\n  print (DATA.size \/\/ 4)\n  DATA = DATA.reshape([DATA.size \/\/ 4, 4])\n  start = 3000000\n  print(np.corrcoef(DATA[start:, XCOL], DATA[start:, YCOL]))\n  plt.semilogx(DATA[start:, XCOL], DATA[start:, YCOL], '.')\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_243","text":"<reponame>jonepatr\/lets_face_it<filename>code\/glow_pytorch\/glow\/modules.py\nimport numpy as np\nimport scipy.linalg\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom glow_pytorch.glow import thops\n\n\nclass ActNorm2d(nn.Module):\n    \"\"\"\n    Activation Normalization\n    Initialize the bias and scale with a given minibatch,\n    so that the output per-channel have zero mean and unit variance for that.\n\n    After initialization, `bias` and `logs` will be trained as parameters.\n    \"\"\"\n\n    def __init__(self, num_features, scale=1.0):\n        super().__init__()\n        # register mean and scale\n        size = [1, num_features]\n        self.register_parameter(\"bias\", nn.Parameter(torch.zeros(*size)))\n        self.register_parameter(\"logs\", nn.Parameter(torch.zeros(*size)))\n        self.num_features = num_features\n        self.scale = float(scale)\n        self.inited = False\n\n    def _check_input_dim(self, input):\n        return NotImplemented\n\n    def initialize_parameters(self, input):\n\n        if not self.training:\n            return\n        assert input.device == self.bias.device\n        with torch.no_grad():\n            bias = thops.mean(input.clone(), dim=0, keepdim=True) * -1.0\n            vars = thops.mean((input.clone() + bias) ** 2, dim=0, keepdim=True)\n            logs = torch.log(self.scale \/ (torch.sqrt(vars) + 1e-6))\n            self.bias.data.copy_(bias.data)\n            self.logs.data.copy_(logs.data)\n            self.inited = True\n\n    def _center(self, input, reverse=False):\n        if not reverse:\n            return input + self.bias\n        else:\n            return input - self.bias\n\n    def _scale(self, input, logdet=None, reverse=False):\n        logs = self.logs\n        if not reverse:\n            input = input * torch.exp(logs)\n        else:\n            input = input * torch.exp(-logs)\n        if logdet is not None:\n            \"\"\"\n            logs is log_std of `mean of channels`\n            so we need to multiply on the channel length\n            \"\"\"\n            dlogdet = thops.sum(logs) * input.size(1)\n            if reverse:\n                dlogdet *= -1\n            logdet = logdet + dlogdet\n        return input, logdet\n\n    def forward(self, input, logdet=None, reverse=False):\n        if not self.inited:\n            self.initialize_parameters(input)\n        # no need to permute dims as old version\n        if not reverse:\n            # center and scale\n            input = self._center(input, reverse)\n            input, logdet = self._scale(input, logdet, reverse)\n        else:\n            # scale and center\n            input, logdet = self._scale(input, logdet, reverse)\n            input = self._center(input, reverse)\n        return input, logdet\n\n\nclass LinearZeros(nn.Linear):\n    def __init__(self, in_channels, out_channels, logscale_factor=3):\n        super().__init__(in_channels, out_channels)\n        self.logscale_factor = logscale_factor\n        # set logs parameter\n        self.register_parameter(\"logs\", nn.Parameter(torch.zeros(out_channels)))\n        # init\n        self.weight.data.zero_()\n        self.bias.data.zero_()\n\n    def forward(self, input):\n        output = super().forward(input)\n        return output * torch.exp(self.logs * self.logscale_factor)\n\n\nclass Permute2d(nn.Module):\n    def __init__(self, num_channels, shuffle):\n        super().__init__()\n        self.num_channels = num_channels\n        self.indices = np.arange(self.num_channels - 1).astype(np.long)\n        self.indices_inverse = np.zeros((self.num_channels), dtype=np.long)\n        for i in range(self.num_channels):\n            self.indices_inverse[self.indices[i]] = i\n        if shuffle:\n            self.reset_indices()\n\n    def reset_indices(self):\n        np.random.shuffle(self.indices)\n        for i in range(self.num_channels):\n            self.indices_inverse[self.indices[i]] = i\n\n    def forward(self, input, reverse=False):\n        assert len(input.size()) == 4\n        if not reverse:\n            return input[:, self.indices]\n        else:\n            return input[:, self.indices_inverse]\n\n\nclass InvertibleConv1x1(nn.Module):\n    def __init__(self, num_channels, LU_decomposed=False):\n        super().__init__()\n        w_shape = [num_channels, num_channels]\n        w_init = np.linalg.qr(np.random.randn(*w_shape))[0].astype(np.float32)\n        if not LU_decomposed:\n            # Sample a random orthogonal matrix:\n            self.register_parameter(\"weight\", nn.Parameter(torch.Tensor(w_init)))\n        else:\n            np_p, np_l, np_u = scipy.linalg.lu(w_init)\n            np_s = np.diag(np_u)\n            np_sign_s = np.sign(np_s)\n            np_log_s = np.log(np.abs(np_s))\n            np_u = np.triu(np_u, k=1)\n            l_mask = np.tril(np.ones(w_shape, dtype=np.float32), -1)\n            eye = np.eye(*w_shape, dtype=np.float32)\n\n            self.register_buffer(\"p\", torch.Tensor(np_p.astype(np.float32)))\n            self.register_buffer(\"sign_s\", torch.Tensor(np_sign_s.astype(np.float32)))\n            self.l = nn.Parameter(torch.Tensor(np_l.astype(np.float32)))\n            self.log_s = nn.Parameter(torch.Tensor(np_log_s.astype(np.float32)))\n            self.u = nn.Parameter(torch.Tensor(np_u.astype(np.float32)))\n            self.l_mask = torch.Tensor(l_mask)\n            self.eye = torch.Tensor(eye)\n        self.w_shape = w_shape\n        self.LU = LU_decomposed\n\n    def get_weight(self, input, reverse):\n        w_shape = self.w_shape\n        if not self.LU:\n            dlogdet = torch.slogdet(self.weight)[1] * input.size(1)\n            if not reverse:\n                weight = self.weight.view(w_shape[0], w_shape[1])\n            else:\n                weight = (\n                    torch.inverse(self.weight.double())\n                    .float()\n                    .view(w_shape[0], w_shape[1])\n                )\n            return weight, dlogdet\n        else:\n            self.p = self.p.to(input.device)\n            self.sign_s = self.sign_s.to(input.device)\n            self.l_mask = self.l_mask.to(input.device)\n            self.eye = self.eye.to(input.device)\n            l = self.l * self.l_mask + self.eye\n            u = self.u * self.l_mask.transpose(0, 1).contiguous() + torch.diag(\n                self.sign_s * torch.exp(self.log_s)\n            )\n            dlogdet = thops.sum(self.log_s) * input.size(1)\n            if not reverse:\n                w = torch.matmul(self.p, torch.matmul(l, u))\n            else:\n                l = torch.inverse(l.double()).float()\n                u = torch.inverse(u.double()).float()\n                w = torch.matmul(u, torch.matmul(l, self.p.inverse()))\n            return w.view(w_shape[0], w_shape[1]), dlogdet\n\n    def forward(self, input, logdet=None, reverse=False):\n        \"\"\"\n        log-det = log|abs(|W|)| * pixels\n        \"\"\"\n        weight, dlogdet = self.get_weight(input, reverse)\n        if not reverse:\n            z = torch.matmul(input, weight)\n            if logdet is not None:\n                logdet = logdet + dlogdet\n            return z, logdet\n        else:\n            z = torch.matmul(input, weight)\n            if logdet is not None:\n                logdet = logdet - dlogdet\n            return z, logdet\n\n\nclass GaussianDiag:\n    Log2PI = float(np.log(2 * np.pi))\n\n    @staticmethod\n    def likelihood_simplified(x):\n        \"\"\"\n        lnL = -1\/2 * { ln|Var| + ((X - Mu)^T)(Var^-1)(X - Mu) + kln(2*PI) }\n              k = 1 (Independent)\n              Var = logs ** 2\n        \"\"\"\n        return -0.5 * ((x ** 2) + GaussianDiag.Log2PI)\n\n    @staticmethod\n    def logp_simplified(x):\n        likelihood = GaussianDiag.likelihood_simplified(x)\n        return torch.sum(likelihood, dim=1)\n\n    @staticmethod\n    def likelihood(mean, logs, x):\n        \"\"\"\n        lnL = -1\/2 * { ln|Var| + ((X - Mu)^T)(Var^-1)(X - Mu) + kln(2*PI) }\n              k = 1 (Independent)\n              Var = logs ** 2\n        \"\"\"\n        return -0.5 * (\n            logs * 2.0 + ((x - mean) ** 2) \/ torch.exp(logs * 2.0) + GaussianDiag.Log2PI\n        )\n\n    @staticmethod\n    def logp(mean, logs, x):\n        likelihood = GaussianDiag.likelihood(mean, logs, x)\n        return thops.sum(likelihood, dim=[1])\n\n    @staticmethod\n    def sample(output_shape, eps_std=1):\n        return torch.normal(\n            mean=torch.zeros_like(output_shape),\n            std=torch.ones_like(output_shape) * eps_std,\n        )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_244","text":"<reponame>whigg\/SeaIceVariability\n\"\"\"\nScript plots ranking on meshgrid plot for sea ice volume\n \nNotes\n-----\n    Source : http:\/\/psc.apl.washington.edu\/zhang\/IDAO\/data_piomas.html\n    Author : <NAME>\n    Date   : 23 September 2016\n\"\"\"\n\n### Import modules\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport datetime\nimport read_SeaIceThick_PIOMAS as CT\nimport read_SeaIceConc_PIOMAS as CC\nimport calc_PiomasArea as CA\nimport scipy.stats as sts\n\n### Define directories\ndirectorydata = '\/home\/zlabe\/Surtsey\/seaice_obs\/PIOMAS\/'  \ndirectoryfigure = '\/home\/zlabe\/Desktop\/'\n\n### Define time           \nnow = datetime.datetime.now()\ncurrentmn = str(now.month)\ncurrentdy = str(now.day)\ncurrentyr = str(now.year)\ncurrenttime = currentmn + '_' + currentdy + '_' + currentyr\ntitletime = currentmn + '\/' + currentdy + '\/' + currentyr\nprint '\\n' '----Calculate sea ice volume - %s----' % titletime \n\n### Alott time series\nyearmin = 1979\nyearmax = 2015\nyears = np.arange(yearmin,yearmax+1,1)\nmonths = [r'Jan',r'Feb',r'Mar',r'Apr',r'May',r'Jun',r'Jul',r'Aug',\n          r'Sep',r'Oct',r'Nov',r'Dec']\n\n### Call functions\n#lats,lons,sit = CT.readPiomas(directorydata,years,0.15)\n#lats,lons,sic = CC.readPiomas(directorydata,years,0.01)\n#area = CA.readPiomasArea(directorydata)\n\n### Calculate siv per year\ndef sivYear(sit,sic,area,conc):\n    \"\"\"\n    Function calculates time series of sea ice volume per YEAR\n\n    Parameters\n    ----------\n    sit : 4d array [year,month,lat,lon]\n        sea ice thickness (m)\n    sic : 4d array [year,month,lat,lon]\n        sea ice concentration (fraction, 0-1)\n    area : 2d array [lat,lon]\n        area of grid cell in PIOMAS (km^2) \n    conc : boolean\n        True or False ----> turning on\/off using sea ice concentration\n\n    Returns\n    -------\n    sivyr : 2d array [year,month]\n        sea ice volume\n\n    Usage\n    -----\n    siv_yr = sivYear(sit,sic,area,conc)\n    \"\"\"\n    \n    print '\\n>>> Using sivYear function!'\n    \n    print 'Calculating sea ice volume'\n    if conc == True:\n        siv = sit*sic*area\n    elif conc == False:\n        siv = sit*area\n    else:\n        RuntimeError('Did not use correct argument for function!')\n        \n    ### Take temporal average of year\n    siv = np.squeeze(np.apply_over_axes(np.nansum,\n                                        siv[:,:,:,:],(2,3)))\n                                        \n    ### Correct units \n    siv = siv\/10**6                                  \n      \n    print '*Completed: Calculated sea ice volume per year!'\n    return siv\n    \n###########################################################################\n###########################################################################\n###########################################################################   \n### Call function\nsivyr = sivYear(sit,sic,area,False)\nsivyr[np.where(sivyr==0.0)]=np.nan\n\nsivyr = sivyr.transpose()\n\n### Try ranking\nrank = np.empty(sivyr.shape)\nfor i in xrange(sivyr.shape[0]):\n    rank[i,:] = sts.rankdata(sivyr[i,:],method='min')\n    \nrank = np.flipud(rank)\n\n### Call parameters\nplt.rcParams['text.usetex']=True\nplt.rcParams['font.family'] = 'sans-serif'\nplt.rcParams['font.sans-serif'] = 'Avant Garde'\nplt.rcParams['xtick.direction'] = 'out'\nplt.rcParams['xtick.major.width'] = 1.3\nplt.rcParams['xtick.major.size'] = 4\n\n### Plot first meshgrid\nfig = plt.figure()\nax = plt.subplot(111)\n\nax.spines['top'].set_color('none')\nax.spines['right'].set_color('none')\nax.spines['bottom'].set_color('none')\nax.spines['left'].set_color('none')\nax.get_xaxis().set_tick_params(direction='out', width=1.5,length=5)\n\nplt.tick_params(\n    axis='x',          # changes apply to the x-axis\n    which='both',      # both major and minor ticks are affected\n    bottom='on',      # ticks along the bottom edge are off\n    top='off',         # ticks along the top edge are off\n    labelbottom='on')\nplt.tick_params(\n    axis='y',          # changes apply to the x-axis\n    which='both',      # both major and minor ticks are affected\n    left='off',      # ticks along the bottom edge are off\n    right='off',         # ticks along the top edge are off\n    labelleft='on')\n\ncs = plt.pcolormesh(rank,shading='faceted',edgecolor='w',\n                    linewidth=0.3,vmin=1,vmax=38)\n\ncs.set_cmap('viridis')\n\ncbar = plt.colorbar(cs,orientation='horizontal')\ncbar.set_ticks([])\ncbar.ax.invert_xaxis()\ncbar.set_label(r'\\textbf{Sea Ice Volume Rank by Year}')\n\nylabels = ['D','N','O','S','A','J','J','M','A','M','F','J']\nplt.yticks(np.arange(0.5,12.5,1),ylabels,ha='center')\nyax = ax.get_yaxis()\nyax.set_tick_params(pad=7)\nplt.xticks(np.arange(0.5,37.5,3),map(str,np.arange(1979,2016,3)))\nplt.xlim([0,37])\n\nplt.text(-3,-5.3,r'Highest rank')\nplt.text(34,-5.3,r'Lowest rank')\n\nfor i in xrange(rank.shape[0]):\n    for j in xrange(rank.shape[1]):\n        plt.text(j+0.5,i+0.5,'%s' % int(rank[i,j]),fontsize=6,\n                 color='w',va='center',ha='center')\n\n### Save figure\nplt.savefig(directoryfigure + 'siv_ranks.png',dpi=300)\n\n###########################################################################\n###########################################################################\n########################################################################### \n### Calculate climo\nclimyr = np.where((years>=1981) & (years<2010))[0]\nsivave = np.nanmean(sivyr[:,climyr],axis=1)\n\nanoms = sivyr.transpose() - sivave\n\n### Plot second meshgrid\nfig = plt.figure()\nax = plt.subplot(111)\n\nax.spines['top'].set_color('none')\nax.spines['right'].set_color('none')\nax.spines['bottom'].set_color('none')\nax.spines['left'].set_color('none')\nax.get_xaxis().set_tick_params(direction='out', width=1.3,length=5)\n\nplt.tick_params(\n    axis='x',          # changes apply to the x-axis\n    which='both',      # both major and minor ticks are affected\n    bottom='on',      # ticks along the bottom edge are off\n    top='off',         # ticks along the top edge are off\n    labelbottom='on')\nplt.tick_params(\n    axis='y',          # changes apply to the x-axis\n    which='both',      # both major and minor ticks are affected\n    left='off',      # ticks along the bottom edge are off\n    right='off',         # ticks along the top edge are off\n    labelleft='on')\n\ncs = plt.pcolormesh(np.flipud(anoms.transpose()),shading='faceted',\n                    edgecolor='w',linewidth=0.3,clim=np.arange(-10,11,0.2),\n                    vmin=-10,vmax=10)\n                   \nfor i in xrange(rank.shape[0]):\n    for j in xrange(rank.shape[1]):\n        plt.text(j+0.5,i+0.5,'%s' % int(rank[i,j]),fontsize=6,\n                 color='k',va='center',ha='center')                    \n\ncs.set_cmap('RdBu')\n\ncbar = plt.colorbar(cs,orientation='horizontal',shrink=0.7)\ncbar.set_ticks(np.arange(-10,11,2))\ncbar.set_ticklabels(map(str,np.arange(-10,11,2)))\ncbar.set_label(r'\\textbf{Sea Ice Volume Anomalies ($\\times$1000\\ km${^3}$)}',\n                         color='k')\n\n#cbar().tick_params(axis='y', direction='out')\n#cbarxtks = plt.getp(cbar.ax.axes, 'xticklines')\n#plt.setp(cbarxtks, direction='out')\n\nylabels = ['D','N','O','S','A','J','J','M','A','M','F','J']\nplt.yticks(np.arange(0.5,12.5,1),ylabels,ha='center')\nyax = ax.get_yaxis()\nyax.set_tick_params(pad=7)\nplt.xticks(np.arange(0.5,37.5,3),map(str,np.arange(1979,2016,3)))\nplt.xlim([0,37])\n\n### Save figure\nplt.savefig(directoryfigure + 'siv_anoms.png',dpi=300)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_245","text":"<gh_stars>0\n#==============================\n# Just started working on that\n#==============================\nfrom scipy import interpolate\nimport pickle\nfrom os import path\nimport pandas as pd\nimport numpy as np\n\n\nclass Interpolation():\n    def __init__(self):\n        self.model_path = path.join('models', 'interpolation.pk')\n\n    def train(self, coor, vals):\n        \"\"\"Training Interpolation model and saving it to pickle format.\n        \n        Parameters\n        ----------\n        coor : ndarray of floats\n            Data point coordinates\n        vals : ndarray of float\n            Data values.\n        \"\"\"\n        interp = interpolate.LinearNDInterpolator(coor, vals)\n        with open(self.model_path, 'wb') as f:\n            pickle.dump(interp, f)\n\n    def predict_grid(self, x_min, x_max, y_min, y_max, step=0.01):\n        \"\"\"Calculating interpolation for the grid created by given x_min_max\n           and y_min_max by given step.\n        \n        Parameters\n        ----------\n        x_min : float\n            Min grid value on x coordinate\n        x_max : float\n            Max grid value on x coordinate\n        y_min : float\n            Min grid value on y coordinate\n        y_max : float\n            Max grid value on y coordinate\n        step : float, optional\n            How dense should the grid be, by default 0.01\n        \n        Returns\n        -------\n        df\n            Returns pandas dataframe, with cols: x, y\n        \"\"\"\n        with open(self.model_path, 'rb') as f:\n            interp = pickle.load(f)\n        grid = self._generate_grid(x_min, x_max, y_min, y_max, step)\n        print('Starting Prediction')\n        grid.loc[:, \"val\"] = grid.apply(lambda x: interp(x[0], x[1]), axis=1)\n        return grid\n\n    def _generate_grid(self, x_min, x_max, y_min, y_max, step=0.01):\n        x = np.arange(x_min, x_max, step)\n        y = np.arange(y_min, y_max, step)\n        xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')\n        grid = np.transpose(\n            np.array([np.matrix.flatten(xv), np.matrix.flatten(yv)]))\n        grid = pd.DataFrame(grid, columns=['x', 'y'])\n        return grid\n\n\n# %% Tests\nTests = False\nif Tests is True:\n    from src.data.createDB import (Database, db_backend, db_name)\n    dbms = Database(db_backend, db_name)\n    query = \"\"\"WITH ranked AS(\n        SELECT m.*, ROW_NUMBER() OVER(PARTITION BY id ORDER BY time DESC) as rm\n        FROM `airly_raw_data` as m\n    ), locs as (SELECT id, lat, lng, city, street FROM 'airly_locs')\n    SELECT r.*, l.lat, l.lng\n    FROM ranked r LEFT JOIN locs as l on l.id = r.id where rm = 1\n    \"\"\"\n    data = dbms.pd_readSQL(sql=query)\n    inter = Interpolation()\n    inter.train(data.loc[:, ['lat', 'lng']].values, data.loc[:, 'pm10'])\n    data_pred = inter.predict_grid(49.8, 50.24, 19.6, 20.25, 0.001)\n    print(data_pred.head())\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_246","text":"<gh_stars>0\nfrom sympy import *\n\nu = Matrix([4, 3])\nv = Matrix([1, 1])\ns = u.dot(v)\nprint(s)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_247","text":"<filename>qmla\/exploration_strategies\/genetic_algorithms\/genetic_exploration_strategy.py\nimport numpy as np\nimport itertools\nimport sys\nimport os\nimport random\nimport copy\nimport scipy\nimport time\n\nimport pandas as pd\nimport sklearn as skl\n\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nimport seaborn as sns\n\ntry:\n    from lfig import LatexFigure\nexcept:\n    from qmla.shared_functionality.latex_figure import LatexFigure\nfrom qmla.exploration_strategies import exploration_strategy\nimport qmla.shared_functionality.probe_set_generation\nimport qmla.model_building_utilities\n\nimport qmla.shared_functionality.genetic_algorithm\n\n__all__ = [\n    \"Genetic\",\n    \"GeneticTest\",\n    \"GeneticAlgorithmQMLAFullyConnectedLikewisePauliTerms\",\n]\n\n\ndef hamming_distance(str1, str2):\n    return sum(c1 != c2 for c1, c2 in zip(str1, str2))\n\n\nclass Genetic(exploration_strategy.ExplorationStrategy):\n    r\"\"\"\n    Exploration Strategy where the model search is mediated through a genetic algorithm.\n    Genetic algorithm is implemented through :class:`qmla.GeneticAlgorithmQMLA`.\n    This forms the base class for genetic algorithm applications within QMLA.\n\n    :param str exploration_rules: name of exploration strategy used\n    :param list genes: terms which are permitted in the model search,\n        which become genes in the chromomsomes of the genetic algorithm\n    :param str true_model: name of the target model.\n\n    \"\"\"\n\n    def __init__(self, exploration_rules, genes, true_model, **kwargs):\n        super().__init__(exploration_rules=exploration_rules, **kwargs)\n\n        self.genes = genes\n        self.true_model = true_model\n        self.ratings_class = qmla.shared_functionality.rating_system.ModifiedEloRating(\n            initial_rating=1000, k_const=30\n        )  # for use when ranking\/rating models\n\n        self.branch_champion_selection_stratgey = \"fitness\"  # 'ratings'\n        self.fitness_method = \"elo_rating\"\n        self.prune_completed_initially = True\n        self.prune_complete = True\n        self.fitness_by_f_score = pd.DataFrame()\n        self.fitness_df = pd.DataFrame()\n        self.num_sites = qmla.model_building_utilities.get_num_qubits(self.true_model)\n        self.num_probes = 50\n        self.max_num_qubits = 7\n        self.hypothetical_final_generation = False\n\n        self.qhl_models = [\n            \"pauliSet_1J2_zJz_d3+pauliSet_1J3_yJy_d3+pauliSet_1J3_zJz_d3+pauliSet_2J3_xJx_d3+pauliSet_2J3_zJz_d3\",\n            \"pauliSet_1J3_yJy_d3+pauliSet_1J3_zJz_d3+pauliSet_2J3_xJx_d3+pauliSet_2J3_zJz_d3\",\n            \"pauliSet_1J2_zJz_d3+pauliSet_1J3_zJz_d3+pauliSet_2J3_xJx_d3+pauliSet_2J3_zJz_d3\",\n        ]\n        self.spawn_step = 0  # 1st generation's ID\n\n        self.mutation_probability = 0.1\n\n        if \"log_file\" not in kwargs:\n            kwargs[\"log_file\"] = self.log_file\n\n        self.genetic_algorithm = (\n            qmla.shared_functionality.genetic_algorithm.GeneticAlgorithmQMLA(\n                genes=genes,\n                num_sites=self.num_sites,\n                true_model=self.true_model,\n                mutation_probability=self.mutation_probability,\n                **kwargs,\n            )\n        )\n\n        self.true_chromosome = self.genetic_algorithm.true_chromosome\n        self.true_chromosome_string = self.genetic_algorithm.true_chromosome_string\n\n        self.num_possible_models = 2 ** len(self.true_chromosome)\n\n        self.max_num_probe_qubits = self.num_sites\n\n        # default test - 32 generations x 16 starters\n        self.max_spawn_depth = 24\n        self.initial_num_models = 16\n        self.initial_models = self.genetic_algorithm.random_initial_models(\n            num_models=self.initial_num_models\n        )\n        self.model_f_scores = {}\n        self.model_points_at_step = {}\n        self.generation_model_rankings = {}\n        self.models_ranked_by_fitness = {}\n        self.model_fitness_by_generation = {}\n        self.fitness_correlations = {}\n\n        self.tree_completed_initially = False\n        self.max_num_models_by_shape = {\n            self.num_sites: (self.initial_num_models * self.max_spawn_depth) \/ 10,\n            \"other\": 0,\n        }\n        self.num_processes_to_parallelise_over = self.initial_num_models\n\n        self.max_time_to_consider = 15\n        self.min_param = 0.35\n        self.max_param = 0.65\n\n        self.fitness_mechanism_names = {\n            \"f_score\": r\"$F_1$\",\n            \"hamming_distance\": r\"$H$\",\n            \"inverse_ll\": r\"$g^L$\",\n            \"inverse_ll_sq\": r\"$-\\frac{1}{L^2}$\",\n            \"akaike_info_criterion\": r\"$\\frac{1}{AIC}$\",\n            \"aic_sq\": r\"$\\frac{1}{AIC^2}$\",\n            \"aicc\": r\"$\\frac{1}{AICc}$\",\n            \"aicc_sq\": r\"$g^{A}$\",\n            \"bayesian_info_criterion\": r\"$\\frac{1}{BIC}$\",\n            \"bic_sq\": r\"$g^{B}$\",\n            \"akaike_weight\": r\"$w_{A}$\",\n            \"bayes_weight\": r\"$w_{B}$\",\n            \"mean_residuals\": r\"$r_{\\mu}$\",\n            \"mean_residuals_sq\": r\"$r_{\\mu}^2$\",\n            \"rs_mean\": r\"$1-\\overline{r}$\",\n            \"rs_median\": r\"$1-\\tilde{r}$\",\n            \"rs_mean_sq\": r\"$g^{r}$\",  # r\"$(1-\\overline{r})^2$\",\n            \"rs_median_sq\": r\"$(1-\\tilde{r})^2$\",\n            \"bf_points\": r\"$g^{p}$\",\n            \"bf_rank\": r\"$g^{R}$\",\n            \"elo_rating\": r\"$g^{E}$\",\n        }\n\n    def nominate_champions(self):\n        r\"\"\"Choose model with highest fitness on final generation\"\"\"\n\n        self.champion_model = self.models_ranked_by_fitness[self.spawn_step][0]\n        self.log_print(\n            [\n                \"Final generation:\",\n                self.spawn_step,\n                \"\\nModel rankings on final generation:\",\n                self.models_ranked_by_fitness[self.spawn_step],\n                \"\\nChampion:\",\n                self.champion_model,\n            ]\n        )\n\n        return [self.champion_model]\n\n    def analyse_generation(self, model_points, model_names_ids, **kwargs):\n        r\"\"\"\n        Following a complete generation of the genetic algorithm,\n        perform all necessary processing to enable construction of next set of models.\n\n        :param dict model_points: the number of Bayes factor comparisons for which each candidate\n            within the generation was deemed superior against a contemporary model\n        :param dict model_names_ids: mapping between models' names and their IDs from the QMLA environment;\n            this enables analaysing further data passed from QMLA within kwargs.\n        \"\"\"\n\n        self.spawn_step += 1\n\n        self.log_print([\"Analysing generation at spawn step \", self.spawn_step])\n        self.log_print([\"model names ids:\", model_names_ids])\n        self.model_points_at_step[self.spawn_step] = model_points\n\n        # model_names_ids = model_names_ids\n        sum_wins = sum(list(model_points.values()))\n        if sum_wins == 0:\n            sum_wins = 1  # TODO hack to get over some times passing empty dict from update_branch -- find a better way\n        model_ids = list(model_points.keys())\n\n        # model rankings  by number of wins\n        ranked_model_list = sorted(model_points, key=model_points.get, reverse=True)\n        ranked_models_by_name = [model_names_ids[m] for m in ranked_model_list]\n        self.log_print(\n            [\n                \"Ranked models:\",\n                ranked_model_list,\n                \"\\n Names:\",\n                ranked_models_by_name,\n                \"\\n with fitnesses:\",\n            ]\n        )\n\n        self.generation_model_rankings[self.spawn_step] = ranked_models_by_name\n        rankings = list(range(1, len(ranked_model_list) + 1))\n        rankings.reverse()\n        num_points = sum(rankings)  # number of points to distribute\n        ranking_points = list(\n            zip(ranked_models_by_name, [r \/ num_points for r in rankings])\n        )\n        ranking_points = dict(ranking_points)\n\n        # Model ratings  (Elo ratings)\n        precomputed_ratings = self.ratings_class.get_ratings(list(model_points.keys()))\n        original_ratings_by_name = {\n            model_names_ids[m]: precomputed_ratings[m] for m in model_ids\n        }\n        min_rating = min(original_ratings_by_name.values())\n        ratings_by_name = {\n            m: original_ratings_by_name[m] - min_rating\n            for m in original_ratings_by_name\n        }\n        self.log_print([\"Rating (as fraction of starting rating):\\n\", ratings_by_name])\n        sum_ratings = np.sum(list(ratings_by_name.values()))\n        model_elo_ratings = {\n            m: ratings_by_name[m] \/ sum_ratings for m in ratings_by_name\n        }\n\n        # New dictionaries which can be used as fitnesses:\n        model_f_scores = {\"fitness_type\": \"f_score\"}\n        model_hamming_distances = {\"fitness_type\": \"hamming_distance\"}\n        model_number_wins = {\"fitness_type\": \"number_wins\"}\n        model_win_ratio = {\"fitness_type\": \"win_ratio\"}\n        mean_residuals = {\"fitness_type\": \"mean_residuals\"}\n        log_likelihoods = {\"fitness_type\": \"log_likelihoods\"}\n\n        # Alter finished dicts also useable as fitness\n        # log_likelihoods['fitness_type'] = 'log_likelihoods'\n        model_elo_ratings[\"fitness_type\"] = \"elo_ratings\"\n        ranking_points[\"fitness_type\"] = \"ranking\"\n\n        model_instances = [self.tree.model_storage_instances[m] for m in model_ids]\n        aic_values = {\n            model.model_id: model.akaike_info_criterion for model in model_instances\n        }\n        aicc_values = {\n            model.model_id: model.akaike_info_criterion_c for model in model_instances\n        }\n        min_aicc = min(aicc_values.values())\n        self.log_print(\n            [\"At generation {}, AIC of models: {}\".format(self.spawn_step, aic_values)]\n        )\n\n        # store info on each model for analysis\n        for m in model_ids:\n            # Access the model storage instance and retrieve some attributes from there\n            model_storage_instance = self.tree.model_storage_instances[m]\n            self.log_print([\"Model storage instance:\", model_storage_instance])\n            mod = model_storage_instance.model_name\n            model_number_wins[mod] = model_points[m]\n            hamming_dist = self.hamming_distance_model_comparison(\n                test_model=mod\n            )  # for fitness use 1\/H\n            model_hamming_distances[mod] = (\n                self.genetic_algorithm.num_terms - hamming_dist\n            ) \/ self.genetic_algorithm.num_terms\n            model_f_scores[mod] = np.round(\n                self.f_score_model_comparison(test_model=mod), 2\n            )  # TODO get from model instance\n            self.model_f_scores[m] = model_f_scores[mod]\n            model_win_ratio[mod] = model_number_wins[mod] \/ sum_wins\n\n            # store scores for offline analysis\n            this_model_fitnesses = {\n                # When adding a new fitness fnc -- add a name in self.fitness_mechanism_names\n                \"model\": mod,\n                \"model_id\": m,\n                \"generation\": self.spawn_step,\n                # absolute metrics (not available in real experiments)\n                \"f_score\": model_f_scores[mod],\n                \"hamming_distance\": model_hamming_distances[mod],\n                # from storage instance\n                # 'eval_log_likelihood' : model_storage_instance.evaluation_log_likelihood,\n                \"inverse_ll\": -1 \/ model_storage_instance.evaluation_log_likelihood,\n                \"inverse_ll_sq\": (-1 \/ model_storage_instance.evaluation_log_likelihood)\n                ** 2,\n                \"akaike_info_criterion\": 1\n                \/ model_storage_instance.akaike_info_criterion,\n                \"aicc\": 1 \/ model_storage_instance.akaike_info_criterion_c,\n                \"aic_sq\": (1 \/ model_storage_instance.akaike_info_criterion) ** 2,\n                \"aicc_sq\": (1 \/ model_storage_instance.akaike_info_criterion_c) ** 2,\n                \"bayesian_info_criterion\": (\n                    1 \/ model_storage_instance.bayesian_info_criterion\n                ),\n                \"bic_sq\": (1 \/ model_storage_instance.bayesian_info_criterion) ** 2,\n                \"akaike_weight\": np.e\n                ** ((min_aicc - model_storage_instance.akaike_info_criterion_c) \/ 2),\n                \"bayes_weight\": np.e\n                ** (-1 * model_storage_instance.bayesian_info_criterion \/ 2),\n                \"mean_residuals\": 1 - model_storage_instance.evaluation_mean_pr0_diff,\n                \"mean_residuals_sq\": (\n                    1 - model_storage_instance.evaluation_mean_pr0_diff\n                )\n                ** 2,\n                \"rs_mean\": 1\n                - model_storage_instance.evaluation_residual_squares[\"mean\"],\n                \"rs_median\": 1\n                - model_storage_instance.evaluation_residual_squares[\"median\"],\n                \"rs_mean_sq\": (\n                    1 - model_storage_instance.evaluation_residual_squares[\"mean\"]\n                )\n                ** 2,\n                \"rs_median_sq\": (\n                    1 - model_storage_instance.evaluation_residual_squares[\"median\"]\n                )\n                ** 2,\n                # relative to other models in this branch\n                \"bf_points\": model_win_ratio[mod],\n                \"bf_rank\": ranking_points[mod],\n                \"elo_rating\": model_elo_ratings[mod],\n                # 'original_elo_rating' : original_ratings_by_name[mod],\n            }\n\n            self.fitness_by_f_score = self.fitness_by_f_score.append(\n                pd.Series(this_model_fitnesses), ignore_index=True\n            )\n\n            recorded_fitness_types = list(\n                this_model_fitnesses.keys()\n                - [\n                    \"model\",\n                    \"model_id\",\n                    \"generation\",\n                    \"hamming_distance\",\n                ]\n            )\n            for f in recorded_fitness_types:\n                try:\n                    new_entry = pd.Series(\n                        {\n                            \"generation\": this_model_fitnesses[\"generation\"],\n                            \"f_score\": this_model_fitnesses[\"f_score\"],\n                            \"fitness\": this_model_fitnesses[f],\n                            \"fitness_type\": f,\n                            \"fitness_type_name\": self.fitness_mechanism_names[f],\n                            \"active_fitness_method\": self.fitness_method == f,\n                        }\n                    )\n                    self.fitness_df = self.fitness_df.append(\n                        new_entry, ignore_index=True\n                    )\n                except:\n                    self.log_print(\n                        [\n                            \"fitness name keys:\",\n                            list(self.fitness_mechanism_names.keys())\n                            # \"f={}; type name = {}\".format(f, self.fitness_mechanism_names[f])\n                        ]\n                    )\n                    raise\n\n        # Extract fitness specified by user (exploration strategy's fitness_method attribute)\n        # to use for generating models within genetic algorithm\n        fitnesses = self.fitness_by_f_score[\n            self.fitness_by_f_score.generation == self.spawn_step\n        ][[\"model\", self.fitness_method]]\n\n        genetic_algorithm_fitnesses = dict(\n            zip(fitnesses[\"model\"], fitnesses[self.fitness_method])\n        )\n\n        self.log_print(\n            [\n                \"fitness method:{} => Fitnesses={}\".format(\n                    self.fitness_method, genetic_algorithm_fitnesses\n                )\n            ]\n        )\n        self.models_ranked_by_fitness[self.spawn_step] = sorted(\n            genetic_algorithm_fitnesses,\n            key=genetic_algorithm_fitnesses.get,\n            reverse=True,\n        )\n        self.model_fitness_by_generation[self.spawn_step] = genetic_algorithm_fitnesses\n\n        self.genetic_algorithm.consolidate_generation(\n            model_fitnesses=genetic_algorithm_fitnesses\n        )\n\n        # return genetic_algorithm_fitnesses\n        return self.models_ranked_by_fitness[self.spawn_step]\n\n    def generate_models(self, model_list, **kwargs):\n        r\"\"\"\n        Model generation using genetic algorithm.\n\n        Follows rules of :meth:`~qmla.exploration_strategies.ExplorationStrategy.generate_models`.\n        \"\"\"\n\n        # Analysis of the previous generation is called by the exploration strategy tree.\n        genetic_algorithm_fitnesses = self.model_fitness_by_generation[self.spawn_step]\n\n        self.log_print(\n            [\n                \"Spawn step:\",\n                self.spawn_step,\n            ]\n        )\n\n        # Spawn models from genetic algorithm\n        new_models = self.genetic_algorithm.genetic_algorithm_step(\n            model_fitnesses=genetic_algorithm_fitnesses,\n            num_pairs_to_sample=self.initial_num_models\n            \/ 2,  # for every pair, 2 chromosomes proposed\n        )\n\n        return new_models\n\n    def finalise_model_learning(self, **kwargs):\n        return\n\n    def hamming_distance_model_comparison(\n        self,\n        test_model,\n        target_model=None,\n    ):\n        r\"\"\"\n        Compare test_model with target_model by Hamming distance\n        \"\"\"\n\n        if target_model is None:\n            target_model = self.true_chromosome_string\n        else:\n            target_model = self.genetic_algorithm.chromosome_string(\n                self.genetic_algorithm.map_model_to_chromosome(target_model)\n            )\n        test_model = self.genetic_algorithm.chromosome_string(\n            self.genetic_algorithm.map_model_to_chromosome(test_model)\n        )\n\n        h = sum(c1 != c2 for c1, c2 in zip(test_model, target_model))\n        return h\n\n    def f_score_model_comparison(\n        self,\n        test_model,\n        target_model=None,\n        beta=1,\n    ):\n        r\"\"\"\n        Get F score of candidate model, measure of overlap between the terms of the candidate and target model\n\n        :param str test_model: name of candidate model\n        :param str target_model: name of target model, if None, assumed that target is self.true_model\n        :param float beta: relative importance of precision to sensitivity. in general this is F-beta score,\n            usually beta = 1\n        \"\"\"\n        if target_model is None:\n            target_model = self.true_model\n\n        true_set = set(\n            self.latex_name(mod)\n            for mod in qmla.model_building_utilities.get_constituent_names_from_name(\n                target_model\n            )\n        )\n        terms = [\n            self.latex_name(term)\n            for term in qmla.model_building_utilities.get_constituent_names_from_name(\n                test_model\n            )\n        ]\n        learned_set = set(sorted(terms))\n\n        total_positives = len(true_set)\n        true_positives = len(true_set.intersection(learned_set))\n        false_positives = len(learned_set - true_set)\n        false_negatives = len(true_set - learned_set)\n        precision = true_positives \/ (true_positives + false_positives)\n        sensitivity = true_positives \/ total_positives\n        try:\n            f_score = (1 + beta ** 2) * (\n                (precision * sensitivity) \/ (beta ** 2 * precision + sensitivity)\n            )\n        except BaseException:\n            # both precision and sensitivity=0 as true_positives=0\n            f_score = 0\n        return f_score\n\n    def f_score_from_chromosome_string(\n        self,\n        chromosome,\n    ):\n        r\"\"\"\n        F1 score between chromosome and true model\n        \"\"\"\n\n        mod = np.array([int(a) for a in list(chromosome)])\n\n        try:\n            f = skl.metrics.f1_score(mod, self.true_chromosome)\n            return f\n        except:\n            self.log_print(\n                [\n                    \"F score from chromosome {} with mod {} not working against true chrom {}\".format(\n                        mod, chromosome, self.true_chromosome\n                    )\n                ]\n            )\n            raise\n\n    def exploration_strategy_finalise(self):\n        r\"\"\"\n        Genetic algorithm specific version of :meth:`qmla.ExplorationStrategy.exploration_strategy_finalise`.\n        \"\"\"\n\n        # hypothetical generation_models\n        if self.hypothetical_final_generation:\n            # TODO this will cause a crash in QHL mode since.\n            # in general this should be turned off so not worth a large fix\n            self.log_print([\"Running hypothetical step to get some models\"])\n            hypothetical_models = self.genetic_algorithm.genetic_algorithm_step(\n                model_fitnesses=self.model_fitness_by_generation[self.spawn_step - 1],\n                num_pairs_to_sample=self.initial_num_models\n                \/ 2,  # for every pair, 2 chromosomes proposed\n            )\n            self.log_print([\"hypothetical generation models:\", hypothetical_models])\n\n        self.storage.fitness_correlations = self.fitness_correlations\n        self.storage.fitness_by_f_score = self.fitness_by_f_score\n        self.storage.fitness_df = self.fitness_df\n        self.storage.true_model_chromosome = self.true_chromosome_string\n        self.storage.ratings_df = self.ratings_class.ratings_df\n        gene_pool = self.genetic_algorithm.gene_pool\n        gene_pool[\"objective_function\"] = self.fitness_mechanism_names[\n            self.fitness_method\n        ]\n        self.storage.gene_pool = gene_pool\n        birth_register = self.genetic_algorithm.birth_register\n        birth_register[\"objective_function\"] = self.fitness_mechanism_names[\n            self.fitness_method\n        ]\n        birth_register[\"max_time_considered\"] = self.max_time_to_consider\n        self.storage.birth_register = birth_register\n        self.storage.ratings = self.ratings_class.all_ratings\n\n        chromosomes = sorted(\n            list(set(self.genetic_algorithm.previously_considered_chromosomes))\n        )\n        self.unique_chromosomes = pd.DataFrame(\n            columns=[\n                \"chromosome\",\n                \"numeric_chromosome\",\n                \"f_score\",\n                \"num_terms\",\n                \"hamming_distance\",\n            ]\n        )\n        for c in chromosomes:\n            hamming_dist = self.hamming_distance_model_comparison(\n                test_model=self.genetic_algorithm.map_chromosome_to_model(c)\n            )  # for fitness use 1\/H\n\n            chrom_data = pd.Series(\n                {\n                    \"chromosome\": str(c),\n                    \"numeric_chromosome\": int(c, 2),\n                    \"num_terms\": self.genetic_algorithm.num_terms,\n                    \"hamming_distance\": hamming_dist,\n                    \"f_score\": np.round(self.f_score_from_chromosome_string(c), 3),\n                }\n            )\n            self.unique_chromosomes.loc[len(self.unique_chromosomes)] = chrom_data\n        self.log_print([\"self.unique_chromosomes:\\n\", self.unique_chromosomes])\n        self.storage.unique_chromosomes = self.unique_chromosomes\n\n        dud_chromosome = str(\"1\" + \"0\" * self.genetic_algorithm.num_terms)\n        if dud_chromosome in chromosomes:\n            self.log_print(\n                [\n                    \"{} in previous chromosomes:\\n{}\".format(\n                        dud_chromosome,\n                        self.genetic_algorithm.previously_considered_chromosomes,\n                    )\n                ]\n            )\n        chromosome_numbers = sorted([int(c, 2) for c in chromosomes])\n        # self.exploration_strategy_specific_data_to_store['chromosomes_tested'] = chromosome_numbers\n        try:\n            f_scores = []\n            for c in chromosomes:\n                try:\n                    f_scores.append(np.round(self.f_score_from_chromosome_string(c), 3))\n                except:\n                    self.log_print(\n                        [\"Could not compute f score for chromosome: {}\".format(c)]\n                    )\n            # self.exploration_strategy_specific_data_to_store['f_score_tested_models' ] = f_scores\n        except:\n            self.log_print(\n                [\n                    \"Could not compute f score for chromosome list: {}\".format(\n                        chromosomes\n                    )\n                ]\n            )\n            pass\n\n        self.storage.chromosomes_tested = chromosome_numbers\n        self.storage.f_score_tested_models = f_scores\n\n    def check_tree_completed(self, spawn_step, **kwargs):\n        r\"\"\"\n        Genetic algorithm specific version of :meth:`qmla.ExplorationStrategy.check_tree_completed`.\n        \"\"\"\n\n        if self.spawn_step == self.max_spawn_depth:\n            self.log_print([\"Terminating at spawn depth \", self.spawn_step])\n            return True\n        elif self.genetic_algorithm.best_model_unchanged:\n            self.champion_determined = True\n            self.champion_model = (\n                self.genetic_algorithm.most_elite_models_by_generation[\n                    self.genetic_algorithm.genetic_generation - 1\n                ]\n            )\n\n            self.log_print(\n                [\n                    \"Terminating search early (after {} generations) b\/c elite model unchanged in {} generations.\".format(\n                        self.genetic_algorithm.genetic_generation,\n                        self.genetic_algorithm.unchanged_elite_num_generations_cutoff,\n                    ),\n                    \"\\nDeclaring champion:\",\n                    self.champion_model,\n                ]\n            )\n            # check if elite model hasn't changed in last N generations\n            return True\n        else:\n            self.log_print([\"Elite models changed recently; continuing search.\"])\n            return False\n\n    def check_tree_pruned(self, **kwargs):\n        r\"\"\"\n        Genetic algorithm specific version of :meth:`qmla.ExplorationStrategy.check_tree_pruned`.\n        \"\"\"\n        # no pruning for GA, winner is champion of final branch\n        return True\n\n    def set_specific_plots(self, **kwargs):\n        r\"\"\"\n        Genetic algorithm specific version of :meth:`qmla.ExplorationStrategy.set_specific_plots`.\n        \"\"\"\n\n        self.plot_methods_by_level = {\n            1: [],\n            2: [\n                self._plot_correlation_fitness_with_f_score,\n                self._plot_fitness_v_fscore_by_generation,\n                self.__plot_gene_pool_progression,\n            ],\n            3: [\n                self._plot_fitness_v_fscore,\n                self._plot_fitness_v_generation,\n            ],\n            4: [\n                self._plot_model_ratings,\n                self._plot_gene_pool,\n            ],\n            5: [self.plot_generational_metrics, self._plot_selection_probabilities],\n            6: [],\n        }\n\n        # Plots that need arguments so are called individually\n        if self.plot_level >= 2:\n            try:\n                self.ratings_class.plot_models_ratings_against_generation(\n                    f_scores=self.model_f_scores,\n                    save_directory=self.save_directory,\n                    f_score_cmap=self.f_score_cmap,\n                    figure_format=self.figure_format,\n                )\n            except Exception as e:\n                self.log_print(\n                    [\n                        \"plot failed plot_models_ratings_against_generation with error \",\n                        e,\n                    ]\n                )\n\n            try:\n                self.ratings_class.plot_rating_progress_single_model(\n                    target_model_id=champion_model_id,\n                    save_to_file=os.path.join(\n                        self.save_directory, \"ratings_progress_champion.png\"\n                    ),\n                )\n                if true_model_id != -1 and true_model_id != champion_model_id:\n                    self.ratings_class.plot_rating_progress_single_model(\n                        target_model_id=true_model_id,\n                        save_to_file=os.path.join(\n                            save_directory, \"ratings_progress_true_model.png\"\n                        ),\n                    )\n            except Exception as e:\n                self.log_print(\n                    [\"plot failed plot_rating_progress_single_model with error \", e]\n                )\n\n    def _plot_correlation_fitness_with_f_score(\n        self,\n        save_to_file=None,\n    ):\n        r\"\"\"\n        Show how the fitness of models at each generation progress in terms of F score.\n        \"\"\"\n\n        plt.clf()\n        correlations = pd.DataFrame(columns=[\"Generation\", \"Method\", \"Correlation\"])\n        fitness_types_to_ignore = [\"f_score\", \"hamming_distance\"]\n        for t in self.fitness_df.fitness_type.unique():\n            if t not in fitness_types_to_ignore:\n                this_fitness_type = self.fitness_df[\n                    self.fitness_df[\"fitness_type\"] == t\n                ]\n\n                for g in this_fitness_type.generation.unique():\n                    this_type_this_gen = this_fitness_type[\n                        this_fitness_type.generation == g\n                    ]\n\n                    corr = this_type_this_gen[\"f_score\"].corr(\n                        this_type_this_gen[\"fitness\"]\n                    )\n                    cov = this_type_this_gen[\"f_score\"].cov(\n                        this_type_this_gen[\"fitness\"]\n                    )\n\n                    corr = {\n                        \"Generation\": g,\n                        \"Method\": self.fitness_mechanism_names[t],\n                        # 'Method' : t,\n                        \"Correlation\": corr,\n                        \"Covariance\": cov,\n                    }\n                    correlations = correlations.append(\n                        pd.Series(corr), ignore_index=True\n                    )\n\n        self.fitness_correlations = correlations\n        self.log_print([\"fitness correlations:\\n\", self.fitness_correlations])\n        fig, ax = plt.subplots(figsize=(15, 10))\n\n        if len(correlations.Generation.unique()) == 1:\n            sns.scatterplot(\n                y=\"Correlation\",\n                x=\"Generation\",\n                # style= 'Method',\n                hue=\"Method\",\n                data=correlations,\n                ax=ax,\n                # markers = ['*', 'X', '<', '^'],\n            )\n        else:\n            sns.lineplot(\n                y=\"Correlation\",\n                x=\"Generation\",\n                # style= 'Method',\n                hue=\"Method\",\n                data=correlations,\n                ax=ax,\n                markers=[\"*\", \"X\", \"<\", \"^\"],\n            )\n        ax.axhline(0, ls=\"--\", c=\"k\")\n\n        if save_to_file is None:\n            save_to_file = os.path.join(\n                self.save_directory,\n                \"correlations_bw_fitness_and_f_score.png\".format(self.qmla_id),\n            )\n\n        plt.savefig(save_to_file)\n\n    def _plot_fitness_v_generation(self, save_to_file=None):\n        r\"\"\"\n        Plot progression of fitness against generations of the genetic algorithm.\n        \"\"\"\n        import matplotlib.pyplot as plt\n        import seaborn as sns\n\n        plt.clf()\n        fig, ax = plt.subplots()\n        sns.set(rc={\"figure.figsize\": (11.7, 8.27)})\n\n        cmap = sns.cubehelix_palette(dark=0.3, light=0.8, as_cmap=True)\n        sns.boxplot(\n            x=\"generation\",\n            y=\"fitness\",\n            data=self.fitness_df[\n                # self.fitness_df['fitness_type'] == 'model_hamming_distances'\n                self.fitness_df[\"active_fitness_method\"]\n                == True\n            ],\n            ax=ax,\n        )\n        ax.legend(loc=\"lower right\")\n        ax.set_xlabel(\"Generation\")\n        ax.set_ylabel(\"Fitness\")\n        ax.set_title(\"Fitness method: {}\".format(self.fitness_method))\n        # ax.set_xlim((0,1))\n        if save_to_file is None:\n            save_to_file = os.path.join(\n                self.save_directory,\n                \"fitness_v_generation.{}\".format(self.figure_format),\n            )\n\n        plt.savefig(save_to_file)\n\n    def _plot_fitness_v_fscore_by_generation(\n        self,\n    ):\n        r\"\"\"\n        Plot fitness vs f score throughout generations of the genetic algorithm.\n        \"\"\"\n\n        plt.clf()\n        sanity_check_df = self.fitness_df[\n            (self.fitness_df[\"fitness_type\"] == \"f_score\")\n            | (self.fitness_df[\"fitness_type\"] == \"model_hamming_distances\")\n        ]\n        candidate_fitnesses = self.fitness_df[\n            (self.fitness_df[\"fitness_type\"] == \"elo_rating\")\n            | (self.fitness_df[\"fitness_type\"] == \"ranking\")\n            | (self.fitness_df[\"fitness_type\"] == \"model_win_ratio\")\n        ]\n\n        g = sns.FacetGrid(\n            candidate_fitnesses,\n            row=\"generation\",\n            hue=\"fitness_type\",\n            hue_kws=dict(marker=[\"x\", \"+\", \"*\"]),\n            # col_wrap=5,\n            xlim=(-0.1, 1.1),\n            # ylim=(0,1),\n            size=4,\n            aspect=2,\n        )\n        g = g.map(plt.scatter, \"f_score\", \"fitness\").add_legend()\n\n        save_to_file = os.path.join(\n            self.save_directory, \"fitness_types.{}\".format(self.figure_format)\n        )\n        plt.savefig(save_to_file)\n\n    def _plot_model_ratings(\n        self,\n    ):\n        r\"\"\"\n        Plot ratings of models on all generations, as determined by the RatingSystem\n        \"\"\"\n\n        plt.clf()\n        ratings = self.ratings_class.all_ratings\n        generations = [int(g) for g in ratings.generation.unique()]\n        num_generations = len(generations)\n\n        lf = LatexFigure(use_gridspec=True, gridspec_layout=(num_generations, 1))\n\n        # TODO : unique linestyle and colour combo for each model ID and tracks across subplots\n        ratings[\"Model ID\"] = ratings[\"model_id\"]\n\n        for gen in generations:\n            ax = lf.new_axis()\n\n            this_gen_ratings = ratings[ratings.generation == gen]\n            colours = {\n                m: self.f_score_cmap(self.model_f_scores[m])\n                for m in this_gen_ratings[\"model_id\"]\n            }\n            sns.lineplot(\n                x=\"idx\",\n                y=\"rating\",\n                hue=r\"Model ID\",\n                hue_order=sorted(this_gen_ratings.model_id.unique()),\n                data=this_gen_ratings,\n                ax=ax,\n                legend=\"full\",\n                palette=colours,\n            )\n\n            ax.set_title(\"Generation {}\".format(gen), pad=-15)\n            ax.set_xlabel(\"\")\n            ax.set_ylabel(\"Elo rating\")\n            ax.legend(bbox_to_anchor=(1, 1))\n\n        save_to_file = os.path.join(self.save_directory, \"ratings\".format(self.qmla_id))\n\n        lf.save(save_to_file, file_format=self.figure_format)\n\n    def _plot_fitness_v_fscore(self):\n        r\"\"\"\n        Plot fitness against f score\n        \"\"\"\n\n        plt.clf()\n        fig, ax = plt.subplots()\n        sns.set(rc={\"figure.figsize\": (11.7, 8.27)})\n\n        cmap = sns.cubehelix_palette(dark=0.3, light=0.8, as_cmap=True)\n        sns.scatterplot(\n            x=\"f_score\",\n            y=\"elo_rating\",\n            # hue='generation',\n            # palette = cmap,\n            label=\"Rating\",\n            data=self.fitness_by_f_score,\n            ax=ax,\n        )\n\n        sns.scatterplot(\n            x=\"f_score\",\n            y=\"win_ratio\",\n            # hue='generation',\n            # palette = cmap,\n            label=\"Win ratio\",\n            data=self.fitness_by_f_score,\n            ax=ax,\n        )\n\n        ax.legend(loc=\"lower right\")\n        ax.set_xlabel(\"F score\")\n        ax.set_ylabel(\"Fitness (as probability)\")\n        # bplot.set_ylim((0,1))\n        ax.set_xlim((-0.05, 1.05))\n        save_to_file = os.path.join(\n            self.save_directory, \"fitness_v_fscore.png\".format(self.qmla_id)\n        )\n\n        ax.figure.savefig(save_to_file)\n\n    def _plot_gene_pool(self):\n        r\"\"\"\n        Show the F scores of all models in all generations\n        \"\"\"\n        ga = self.genetic_algorithm\n\n        plt.clf()\n        fig, axes = plt.subplots(\n            figsize=(10, 8),\n            constrained_layout=True,\n        )\n\n        gs = GridSpec(nrows=2, ncols=1, height_ratios=[7, 1])\n        label_fontsize = 10\n        # TODO get f score cmap from exploration strategy\n        # f_score_cmap = matplotlib.colors.ListedColormap([\"sienna\", \"red\", \"darkorange\", \"gold\", \"blue\"])\n        f_score_cmap = self.f_score_cmap\n\n        # Bar plots for probability of gene being selected, coloured by f score\n        ax = fig.add_subplot(gs[0, 0])\n\n        generations = list(sorted(ga.gene_pool.generation.unique()))\n        probability_grouped_by_f_by_generation = {\n            g: {\n                f: ga.gene_pool[\n                    (ga.gene_pool.f_score == f) & (ga.gene_pool.generation == g)\n                ].probability.sum()\n                for f in ga.gene_pool.f_score.unique()\n            }\n            for g in generations\n        }\n        probability_grouped_by_f_by_generation = pd.DataFrame(\n            probability_grouped_by_f_by_generation\n        ).T\n\n        sorted_f_scores = list(sorted(ga.gene_pool.f_score.unique()))\n        below = [0] * len(generations)\n        for f in sorted_f_scores[:]:\n            probs_this_f = list(probability_grouped_by_f_by_generation[f])\n            ax.bar(\n                generations,\n                probs_this_f,\n                color=f_score_cmap(f),\n                bottom=below,\n                edgecolor=[\"black\"] * len(generations),\n            )\n\n            below = [b + p for b, p in zip(below, probs_this_f)]\n        ax.set_xticks(generations)\n        ax.set_ylabel(\"Probability\", fontsize=label_fontsize)\n        ax.set_xlabel(\"Generation\", fontsize=label_fontsize)\n        ax.set_title(\"Gene pool\", fontsize=label_fontsize)\n\n        # Colour bar\n        ax = fig.add_subplot(gs[1, 0])\n        sm = plt.cm.ScalarMappable(\n            cmap=f_score_cmap, norm=plt.Normalize(vmin=0, vmax=1)\n        )\n        sm.set_array(np.linspace(0, 1, 100))\n        plt.colorbar(sm, cax=ax, orientation=\"horizontal\")\n        ax.set_xlabel(\"F-score\", fontsize=label_fontsize)\n\n        # Save figure\n        save_to_file = os.path.join(\n            self.save_directory, \"gene_pool.{}\".format(self.figure_format)\n        )\n\n        fig.savefig(save_to_file)\n\n    def _plot_selection_probabilities(self):\n        r\"\"\"\n        Plot pie charts of the selection probabilities of prospective parents at each generation.\n        Models are signified by their F score.\n        \"\"\"\n        generations = sorted(self.genetic_algorithm.gene_pool.generation.unique())\n        self.log_print([\"[_plot_selection_probabilities] generations:\", generations])\n        lf = LatexFigure(auto_gridspec=len(generations))\n\n        for g in generations:\n            ax = lf.new_axis()\n            this_gen_genes = self.genetic_algorithm.gene_pool[\n                self.genetic_algorithm.gene_pool.generation == g\n            ]\n            f_scores = this_gen_genes.f_score\n            colours = [self.f_score_cmap(f) for f in f_scores]\n            probabilities = this_gen_genes.probability\n\n            ax.pie(\n                probabilities,\n                colors=colours,\n                radius=2,\n            )\n\n        save_to_file = os.path.join(self.save_directory, \"selection_probabilities\")\n        lf.save(save_to_file, figure_format=self.figure_format)\n\n    def plot_generational_metrics(self):\n        r\"\"\"\n        Show various metrics across all generations\n        \"\"\"\n        fig, axes = plt.subplots(figsize=(15, 10), constrained_layout=True)\n        gs = GridSpec(\n            nrows=2,\n            ncols=1,\n        )\n\n        ax = fig.add_subplot(gs[0, 0])\n        sns.boxplot(y=\"f_score\", x=\"generation\", data=self.fitness_by_f_score, ax=ax)\n        ax.set_ylabel(\"F-score\")\n        ax.set_xlabel(\"Generation\")\n        ax.set_title(\"F score\")\n        ax.set_ylim(0, 1)\n        ax.legend()\n\n        ax = fig.add_subplot(gs[1, 0])\n        sns.boxplot(\n            y=\"log_likelihood\", x=\"generation\", data=self.fitness_by_f_score, ax=ax\n        )\n        ax.set_ylabel(\"log-likelihood\")\n        ax.set_xlabel(\"Generation\")\n        ax.set_title(\"Evaluation log likeihood\")\n        ax.legend()\n\n        # Save figure\n        save_to_file = os.path.join(self.save_directory, \"generation_progress.png\")\n\n        fig.savefig(save_to_file)\n\n    def __plot_gene_pool_progression(\n        self,\n    ):\n        r\"\"\"\n        Succinct representation of the progression of gene pool with respect to F score.\n        \"\"\"\n        lf = LatexFigure()\n        ax = lf.new_axis()\n        gene_pool = self.genetic_algorithm.gene_pool\n        gene_pool.sort_values(\"f_score\", inplace=True, ascending=False)\n\n        self.gene_pool_progression(\n            gene_pool=gene_pool,\n            ax=ax,\n            f_score_cmap=self.f_score_cmap,\n        )\n        lf.save(\n            save_to_file=os.path.join(self.save_directory, \"gene_pool_progression\"),\n            file_format=self.figure_format,\n        )\n\n    @staticmethod\n    def gene_pool_progression(\n        gene_pool, ax, f_score_cmap=None, draw_cbar=True, cbar_ax=None\n    ):\n        r\"\"\"\n        Method for plotting succinct summary of progression of gene pool with respect to F score.\n        \"\"\"\n        if f_score_cmap is None:\n            f_score_cmap = matplotlib.cm.RdBu\n        num_models_per_generation = len(gene_pool[gene_pool.generation == 1])\n        num_generations = gene_pool.generation.nunique()\n        f_scores_of_gene_pool = np.empty((num_models_per_generation, num_generations))\n        for g in gene_pool.generation.unique():\n\n            f_scores_by_gen = gene_pool[gene_pool.generation == g].f_score\n\n            f_scores_of_gene_pool[:, g - 1] = f_scores_by_gen\n\n        sns.heatmap(\n            f_scores_of_gene_pool,\n            cmap=f_score_cmap,\n            vmin=0,\n            vmax=1,\n            ax=ax,\n            cbar=draw_cbar,\n            cbar_kws=dict(\n                label=r\"$F_1$-score\",\n                aspect=25,\n                ticks=[0, 0.5, 1],\n            ),\n        )\n        ax.set_yticks([])\n        xtick_pos = range(5, num_generations + 1, 5)\n        ax.set_xticks([g - 0.5 for g in xtick_pos])\n        ax.set_xticklabels(xtick_pos)\n        ax.set_xlabel(\"Generation\")\n\n        if cbar_ax is not None:\n            cbar = ax.collections[0].colorbar\n            cbar.ax.set_ylabel(r\"$F_1$\", rotation=0, labelpad=10)  # if F horizontal\n            cbar.ax.yaxis.set_label_position(\n                \"right\",\n            )\n            cbar.ax.tick_params(labelleft=True, labelright=False)\n\n\nclass GeneticTest(Genetic):\n    r\"\"\"\n    Exactly as the genetic exploration strategy, but small depth to test quickly.\n\n    \"\"\"\n\n    def __init__(self, exploration_rules, **kwargs):\n        true_model = \"pauliSet_1J2_zJz_d4+pauliSet_1J3_zJz_d4+pauliSet_2J3_zJz_d4+pauliSet_2J4_zJz_d4+pauliSet_3J4_zJz_d4\"\n        self.true_model = qmla.model_building_utilities.alph(true_model)\n        num_sites = qmla.model_building_utilities.get_num_qubits(true_model)\n        terms = []\n        for i in range(1, 1 + num_sites):\n            for j in range(i + 1, 1 + num_sites):\n                for t in [\"x\", \"y\", \"z\"]:\n                    new_term = \"pauliSet_{i}J{j}_{o}J{o}_d{N}\".format(\n                        i=i,\n                        j=j,\n                        o=t,\n                        N=num_sites,\n                    )\n                    terms.append(new_term)\n\n        super().__init__(\n            exploration_rules=exploration_rules,\n            genes=terms,\n            true_model=self.true_model,\n            **kwargs,\n        )\n        self.max_spawn_depth = 2\n        self.max_num_probe_qubits = self.num_sites\n        self.initial_num_models = 6\n        self.initial_models = self.genetic_algorithm.random_initial_models(\n            num_models=self.initial_num_models\n        )\n        self.tree_completed_initially = False\n        self.max_num_models_by_shape = {\n            self.num_sites: (self.initial_num_models * self.max_spawn_depth) \/ 10,\n            \"other\": 0,\n        }\n        self.num_processes_to_parallelise_over = self.initial_num_models\n\n\nclass GeneticAlgorithmQMLAFullyConnectedLikewisePauliTerms(Genetic):\n    r\"\"\"\n    Exact structure of :class:`~qmla.Genetic`, where the avaiable terms\n    are assumed to follow conventional pauliSet format, and all sites are connected.\n    e.g. terms of the form:\n    pauliSet_1J2_xJx_d2, pauliSet_1J2_yJy_d2, pauliSet_1J2_zJz_d2,\n    \"\"\"\n\n    def __init__(\n        self,\n        exploration_rules,\n        true_model,\n        num_sites=None,\n        base_terms=[\"x\", \"y\", \"z\"],\n        **kwargs\n    ):\n        if num_sites is None:\n            num_sites = qmla.model_building_utilities.get_num_qubits(true_model)\n        terms = []\n        for i in range(1, 1 + num_sites):\n            for j in range(i + 1, 1 + num_sites):\n                for t in base_terms:\n                    new_term = \"pauliSet_{i}J{j}_{o}J{o}_d{N}\".format(\n                        i=i,\n                        j=j,\n                        o=t,\n                        N=num_sites,\n                    )\n                    terms.append(new_term)\n\n        super().__init__(\n            exploration_rules=exploration_rules,\n            genes=terms,\n            true_model=true_model,\n            **kwargs,\n        )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_248","text":"<filename>A6\/A6Part4.py<gh_stars>0\nimport os\nimport sys\nimport numpy as np\nimport math\nfrom scipy.signal import get_window\nimport matplotlib.pyplot as plt\n\nsys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..\/..\/software\/models\/'))\nimport utilFunctions as UF\nimport harmonicModel as HM\nimport dftModel as DFT\nimport stft\n\neps = np.finfo(float).eps\n\n\"\"\"\nA6Part4 - Improving the implementation of the two way mismatch f0 estimation algorithm\n\nImprove the performance of the current implementation of the two way mismatch algorithm in sms-tools \nused for fundamental frequency estimation. This is an optional open question and will not contribute \ntowards the final grade. There is no definite answer for this question. Its main purpose is to \nunderstand the limitations of the current implementations of the TWM algorithm and to come up with \nsome community driven solutions based on collective thinking. \n\nIn this question you will directly modify the core functions that implement the TWM algorithm in \nsms-tools. To assist you with this task, we have copied all the needed functions into this python \nfile. Hence, you just need to modify the functions in this file and not anywhere else.\n\nEstimating fundamental frequency from an audio signal is still a challenging and unsolved problem \nto a large extent. By this time you might have also realized that many times the performance of the \nTWM f0 estimation algorithm falls short of the expectations. There can be a systematic explanation \nfor the scenarios where TWM fails for specific categories or characteristics of the sounds. Some of \nthe known scenarios where the current implementation of the TWM algorithm fails to estimate a correct \nfundamental frequency are:\n\n1) Missing fundamental frequency: For many sounds the fundamental frequency component is very low and \ntherefore during the spectral peak picking step we do not obtain any peak corresponding to the f0. \nSince the TWM algorithm implemented in sms-tools considers only the detected spectral peaks as the \nf0 candidates, we do not get any candidate corresponding to the f0. This causes f0 estimation to fail. \nFor example, such a scenario is encountered in low pitched vocal sounds.\n\n2) Pseudo-harmonicity in the sound. Many instruments such as piano exhibit some deviation from perfect \nharmonicity wherein their harmonic partials are not perfectly located at integral multiples of the \nfundamental frequency. Since the TWM algorithm computes error function assuming that the harmonic \nlocations are at integral multiples, its performance is poorer when such deviations exist.\n\nIn this question we propose to work on these two scenarios. Go to freesound and download sound examples \nof low pitched vocal sounds and of piano. Run current implementation of TMW to identify the limitations \nand propose improvements to the code in order to obtain better f0 estimation for those two particular \nscenarios. \n\nThe core TWM algorithm is implemented in the function TWM_p(), which takes in an array of f0 candidates \nand detect the candidate that has the lowest error. TWM_p() is called by f0Twm(), which generates \nf0 candidates (f0c = np.argwhere((pfreq>minf0) & (pfreq<maxf0))[:,0]). This function also implements \na memory based prunning of the f0 candidates. If the f0 contour is found to be stable (no drastic \ntransitions across frames) then only the f0 candidates close to the stable f0 value are retained. \nf0Twm() is called for every audio frame by f0Detection().\n\nYou can use computeAndPlotF0(), which calls f0Detection() for estimating f0 for every audio frame. \nIn addition, it also plots the f0 contour on the top of the spectrogram. If you set plot=1, it shows \nthe plot, plot=2 saves the plot as can be seen in the code. \n\nOnce you implement your proposed enhancement, discuss and share your ideas on the discussion forum \nassigned for A6Part4 - https:\/\/class.coursera.org\/audio-001\/forum\/list?forum_id=10026. Along with the \ntext you should include 2 plots showing the f0 contour before and after your changes. Use the same \nvalues of the analysis parameters while showing the improvement in the performance. in the discussion, \nalso include a link to the sound in freesound. \n\nTIP: An identified limitation of the current implementation for the case of low vocal sounds is that \nit can only find f0 if there is a peak present in the magnitude spectrum. A possible improvement is \nto generate additional f0 candidates from the identified peaks. Another identified limitation for \nthe case of piano sounds is the assumption of perfect harmonicity. For these sounds you can think \nof modifying the generation of the ideal harmonic series that is computed in the code, incorporating \nthe typical deviation from harmonicity encountered in piano sounds.\n\nNOTE: Before you start making changes in the TWM implementation make sure you have reached the best \npossible performance that can be achieved by tuning the analysis parameters. If the analysis parameters \nare inappropriately set, it is not completely meaningful to just improve the TWM implementation.\n\nTo maintain the integrity if the sms-tools package for future assignments, please make changes only \nto the functions in this file and not the other files in sms-tools.\n\"\"\"\n\ndef computeAndPlotF0(inputFile = '..\/..\/sounds\/piano.wav'):\n    \"\"\"\n    Function to estimate fundamental frequency (f0) in an audio signal using TWM.\n    Input:\n        inputFile (string): wav file including the path    \n    \"\"\"\n    window='hamming'\n    M=2048\n    N=2048\n    H=256\n    f0et=5.0\n    t=-80\n    minf0=100\n    maxf0=300\n\n    fs, x = UF.wavread(inputFile)                               #reading inputFile\n    w  = get_window(window, M)                                  #obtaining analysis window    \n    f0 = f0Detection(x, fs, w, N, H, t, minf0, maxf0, f0et)  #estimating F0\n\n    ## Code for plotting the f0 contour on top of the spectrogram\n    # frequency range to plot\n    maxplotfreq = 500.0    \n    fontSize = 16\n    plot = 1\n\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n\n    mX, pX = stft.stftAnal(x, w, N, H)                      #using same params as used for analysis\n    mX = np.transpose(mX[:,:int(N*(maxplotfreq\/fs))+1])\n    \n    timeStamps = np.arange(mX.shape[1])*H\/float(fs)                             \n    binFreqs = np.arange(mX.shape[0])*fs\/float(N)\n    \n    plt.pcolormesh(timeStamps, binFreqs, mX)\n    plt.plot(timeStamps, f0, color = 'k', linewidth=1.5)\n    \n    plt.autoscale(tight=True)\n    plt.ylabel('Frequency (Hz)', fontsize = fontSize)\n    plt.xlabel('Time (s)', fontsize = fontSize)\n    plt.legend(('f0',))\n    \n    xLim = ax.get_xlim()\n    yLim = ax.get_ylim()\n    ax.set_aspect((xLim[1]-xLim[0])\/(2.0*(yLim[1]-yLim[0])))    \n\n    if plot == 1: \n        plt.autoscale(tight=True) \n        plt.show()\n    elif plot == 2:                   #you can save the plot too!\n        fig.tight_layout()\n        fig.savefig('f0_over_Spectrogram.png', dpi=150, bbox_inches='tight')\n\n\n\ndef f0Detection(x, fs, w, N, H, t, minf0, maxf0, f0et):\n    \"\"\"\n    Fundamental frequency detection of a sound using twm algorithm\n    x: input sound; fs: sampling rate; w: analysis window; \n    N: FFT size; t: threshold in negative dB, \n    minf0: minimum f0 frequency in Hz, maxf0: maximim f0 frequency in Hz, \n    f0et: error threshold in the f0 detection (ex: 5),\n    returns f0: fundamental frequency\n    \"\"\"\n    if (minf0 < 0):                                            # raise exception if minf0 is smaller than 0\n        raise ValueError(\"Minumum fundamental frequency (minf0) smaller than 0\")\n    \n    if (maxf0 >= 10000):                                       # raise exception if maxf0 is bigger than fs\/2\n        raise ValueError(\"Maximum fundamental frequency (maxf0) bigger than 10000Hz\")\n    \n    if (H <= 0):                                               # raise error if hop size 0 or negative\n        raise ValueError(\"Hop size (H) smaller or equal to 0\")\n        \n    hN = N\/2                                                   # size of positive spectrum\n    hM1 = int(math.floor((w.size+1)\/2))                        # half analysis window size by rounding\n    hM2 = int(math.floor(w.size\/2))                            # half analysis window size by floor\n    x = np.append(np.zeros(hM2),x)                             # add zeros at beginning to center first window at sample 0\n    x = np.append(x,np.zeros(hM1))                             # add zeros at the end to analyze last sample\n    pin = hM1                                                  # init sound pointer in middle of anal window          \n    pend = x.size - hM1                                        # last sample to start a frame\n    fftbuffer = np.zeros(N)                                    # initialize buffer for FFT\n    w = w \/ sum(w)                                             # normalize analysis window\n    f0 = []                                                    # initialize f0 output\n    f0t = 0                                                    # initialize f0 track\n    f0stable = 0                                               # initialize f0 stable\n    while pin<pend:             \n        x1 = x[pin-hM1:pin+hM2]                                  # select frame\n        mX, pX = DFT.dftAnal(x1, w, N)                           # compute dft           \n        ploc = UF.peakDetection(mX, t)                           # detect peak locations   \n        iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc)      # refine peak values\n        ipfreq = fs * iploc\/N                                    # convert locations to Hez\n        f0t = f0Twm(ipfreq, ipmag, f0et, minf0, maxf0, f0stable)  # find f0\n        if ((f0stable==0)&(f0t>0)) \\\n                or ((f0stable>0)&(np.abs(f0stable-f0t)<f0stable\/5.0)):\n            f0stable = f0t                                         # consider a stable f0 if it is close to the previous one\n        else:\n            f0stable = 0\n        f0 = np.append(f0, f0t)                                  # add f0 to output array\n        pin += H                                                 # advance sound pointer\n    return f0\n\ndef f0Twm(pfreq, pmag, ef0max, minf0, maxf0, f0t=0):\n    \"\"\"\n    Function that wraps the f0 detection function TWM, selecting the possible f0 candidates\n    and calling the function TWM with them\n    pfreq, pmag: peak frequencies and magnitudes, \n    ef0max: maximum error allowed, minf0, maxf0: minimum  and maximum f0\n    f0t: f0 of previous frame if stable\n    returns f0: fundamental frequency in Hz\n    \"\"\"\n    if (minf0 < 0):                                  # raise exception if minf0 is smaller than 0\n        raise ValueError(\"Minumum fundamental frequency (minf0) smaller than 0\")\n    \n    if (maxf0 >= 10000):                             # raise exception if maxf0 is bigger than 10000Hz\n        raise ValueError(\"Maximum fundamental frequency (maxf0) bigger than 10000Hz\")\n        \n    if (pfreq.size < 3) & (f0t == 0):                # return 0 if less than 3 peaks and not previous f0\n        return 0\n    \n    f0c = np.argwhere((pfreq>minf0) & (pfreq<maxf0))[:,0] # use only peaks within given range\n    if (f0c.size == 0):                              # return 0 if no peaks within range\n        return 0\n    f0cf = pfreq[f0c]                                # frequencies of peak candidates\n    f0cm = pmag[f0c]                                 # magnitude of peak candidates\n\n    if f0t>0:                                        # if stable f0 in previous frame \n        shortlist = np.argwhere(np.abs(f0cf-f0t)<f0t\/2.0)[:,0]   # use only peaks close to it\n        maxc = np.argmax(f0cm)\n        maxcfd = f0cf[maxc]%f0t\n        if maxcfd > f0t\/2:\n            maxcfd = f0t - maxcfd\n        if (maxc not in shortlist) and (maxcfd>(f0t\/4)): # or the maximum magnitude peak is not a harmonic\n            shortlist = np.append(maxc, shortlist)\n        f0cf = f0cf[shortlist]                         # frequencies of candidates                     \n\n    if (f0cf.size == 0):                             # return 0 if no peak candidates\n        return 0\n\n    f0, f0error = TWM_p(pfreq, pmag, f0cf)        # call the TWM function with peak candidates\n    \n    if (f0>0) and (f0error<ef0max):                  # accept and return f0 if below max error allowed\n        return f0\n    else:\n        return 0\n\n\ndef TWM_p(pfreq, pmag, f0c):\n    \"\"\"\n    Two-way mismatch algorithm for f0 detection (by Beauchamp&Maher)\n    [better to use the C version of this function: UF_C.twm]\n    pfreq, pmag: peak frequencies in Hz and magnitudes, \n    f0c: frequencies of f0 candidates\n    returns f0, f0Error: fundamental frequency detected and its error\n    \"\"\"\n\n    p = 0.5                                          # weighting by frequency value\n    q = 1.4                                          # weighting related to magnitude of peaks\n    r = 0.5                                          # scaling related to magnitude of peaks\n    rho = 0.33                                       # weighting of MP error\n    Amax = max(pmag)                                 # maximum peak magnitude\n    maxnpeaks = 10                                   # maximum number of peaks used\n    harmonic = np.matrix(f0c)\n    ErrorPM = np.zeros(harmonic.size)                # initialize PM errors\n    MaxNPM = min(maxnpeaks, pfreq.size)\n    for i in range(0, MaxNPM) :                      # predicted to measured mismatch error\n        difmatrixPM = harmonic.T * np.ones(pfreq.size)\n        difmatrixPM = abs(difmatrixPM - np.ones((harmonic.size, 1))*pfreq)\n        FreqDistance = np.amin(difmatrixPM, axis=1)    # minimum along rows\n        peakloc = np.argmin(difmatrixPM, axis=1)\n        Ponddif = np.array(FreqDistance) * (np.array(harmonic.T)**(-p))\n        PeakMag = pmag[peakloc]\n        MagFactor = 10**((PeakMag-Amax)\/20)\n        ErrorPM = ErrorPM + (Ponddif + MagFactor*(q*Ponddif-r)).T\n        harmonic = harmonic+f0c\n\n    ErrorMP = np.zeros(harmonic.size)                # initialize MP errors\n    MaxNMP = min(maxnpeaks, pfreq.size)\n    for i in range(0, f0c.size) :                    # measured to predicted mismatch error\n        nharm = np.round(pfreq[:MaxNMP]\/f0c[i])\n        nharm = (nharm>=1)*nharm + (nharm<1)\n        FreqDistance = abs(pfreq[:MaxNMP] - nharm*f0c[i])\n        Ponddif = FreqDistance * (pfreq[:MaxNMP]**(-p))\n        PeakMag = pmag[:MaxNMP]\n        MagFactor = 10**((PeakMag-Amax)\/20)\n        ErrorMP[i] = sum(MagFactor * (Ponddif + MagFactor*(q*Ponddif-r)))\n\n    Error = (ErrorPM[0]\/MaxNPM) + (rho*ErrorMP\/MaxNMP)  # total error\n    f0index = np.argmin(Error)                       # get the smallest error\n    f0 = f0c[f0index]                                # f0 with the smallest error\n\n    return f0, Error[f0index]        \n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_249","text":"from scipy.ndimage.fourier import fourier_gaussian\nimport numpy\nimport scipy\n\nprint('numpy version:', numpy.__version__)\nprint('scipy version:', scipy.__version__)\n\nprint('fourier_gaussian:', fourier_gaussian(numpy.ones([1, 1]), 1))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_250","text":"import sys\n\nfrom matplotlib import axes\nfrom matplotlib.figure import Figure\nfrom PyQt5 import QtCore, QtWidgets\nfrom scipy import constants as Cn\n\nfrom Solver import Projectile\nfrom ui import Ui\n\n# Constants\n\n#yapf: disable\nt           : float     = 0\ndt          : float     = 0.005\nA           : float     = 4e-5\nB           : float     = 0\n\ng           : float     = Cn.g\nv           : float     = 0\n\nProjectiles : dict      = {}\nlineList    : dict      = {}\n\nmax_xrange  : list      = [0, 1]\nmax_yrange  : list      = [0, 1]\nmax_time    : float     = 0\nbgCache                 = None\n\nfig         : Figure\nax          : axes\n#yapf: enable\n\n\ndef PrepareFigure():\n    global fig, ax\n\n    fig = MyUI.canvas.fig\n    ax = fig.gca()\n\n    ax.cla()\n    ax.yaxis.grid(color='gainsboro', linestyle='dotted', linewidth=1.5)\n    ax.xaxis.grid(color='gainsboro', linestyle='dotted', linewidth=0.8)\n    ax.axhline(0, linestyle='dotted', color='grey')\n    ax.axvline(0, linestyle='dotted', color='grey')\n\n    ax.set_title('Projectile Trajectory')\n    ax.set_xlabel(r'$x$', loc='center')\n    ax.set_ylabel(r'$y$', loc='center', rotation=0)\n\n    # fig.tight_layout(h_pad=2, w_pad=1)\n    fig.tight_layout()\n\n\ndef LoadData():\n    global dt, A, B, Projectiles\n\n    dt, A, B, Prjtls = MyUI.GetData().values()\n\n    Projectiles = {}\n\n    for id, Prjctl in Prjtls.items():\n        projectile = Projectile(dt, A, B, Prjctl['m'], Prjctl['x_i'], Prjctl['y_i'], Prjctl['v'], Prjctl['ang'], g)\n        Projectiles[id] = projectile\n\n\ndef ProcessData():\n    global Projectiles, max_xrange, max_yrange, max_time\n\n    max_xrange = [0, 1]\n    max_yrange = [0, 1]\n    max_time = 0.0\n\n    for Prjctl in Projectiles.values():\n        Prjctl: Projectile\n\n        Prjctl.Solve()\n\n        max_time = max(max_time, Prjctl.getMaxTime())\n\n        xr = Prjctl.getMaxXRange()\n\n        yr = Prjctl.getMaxYRange()\n\n        max_xrange[0] = min(xr[0], max_xrange[0])\n        max_xrange[1] = max(xr[1], max_xrange[1])\n\n        max_yrange[0] = min(yr[0], max_yrange[0])\n        max_yrange[1] = max(yr[1], max_yrange[1])\n\n    MyUI.SetMaxTime(max_t=max_time)\n    set_range()\n\n\ndef set_range():\n    global max_xrange, max_yrange\n\n    # set aspect\n\n    # padding\n    d = (max_xrange[0] - max_xrange[1]) * 0.08\n    max_xrange[0] = max_xrange[0] + d\n    max_xrange[1] = max_xrange[1] - d\n\n    d = (max_yrange[0] - max_yrange[1]) * 0.08\n    max_yrange[0] = max_yrange[0] + d\n    max_yrange[1] = max_yrange[1] - d\n\n\ndef plot_points(animated: bool = False):\n    global lineList, Projectiles\n\n    for id, Prjctl in Projectiles.items():\n        Prjctl: Projectile\n\n        x, y = Prjctl.getResults(slice(0, t))\n\n        lineList[id] = ax.plot(x,\n                               y,\n                               marker='o',\n                               markersize=4,\n                               markevery=[-1],\n                               label=str(Prjctl.angle),\n                               animated=animated)\n\n\ndef update_points(blit: bool = False):\n    global t\n\n    for id, Prjctl in Projectiles.items():\n        Prjctl: Projectile\n        x, y = Prjctl.getResults(slice(0, t))\n        lineList[id][0].set_xdata(x)\n        lineList[id][0].set_ydata(y)\n\n    if blit == True:\n        MyUI.canvas.restore_region(bgCache)\n        for id, Prjctl in Projectiles.items():\n            Prjctl: Projectile\n            ax.draw_artist(lineList[id][0])\n        MyUI.canvas.blit(ax.bbox)\n    else:\n        MyUI.canvas.draw()\n\n\ndef cache_bg():\n    global bgCache\n\n    bgCache = MyUI.canvas.copy_from_bbox(ax.bbox)\n\n\ndef RedrawPlots():\n    global lineList, ax, max_xrange, max_yrange, t, fig\n\n    t = 0\n\n    LoadData()\n    ProcessData()\n\n    RefreshPlots()\n\n    ax.set_xlim(tuple(max_xrange))\n    ax.set_ylim(tuple(max_yrange))\n\n    ax.legend()\n\n    MyUI.canvas.draw()\n\n    cache_bg()\n\n\ndef RefreshPlots(animated: bool = False):\n    global lineList\n\n    for id, line in lineList.items():\n        line[0].remove()\n\n    lineList = {}\n    ax.set_prop_cycle(None)\n\n    plot_points(animated=animated)\n\n    MyUI.canvas.draw()\n\n\ndef startAnimation():\n    RefreshPlots(animated=True)\n    cache_bg()\n\n\ndef stopAnimation():\n    RefreshPlots()\n\n\ndef animate(t_new: float):\n    global dt, t\n\n    t = t_new\n\n    update_points(blit=True)\n\n\ndef windowResize():\n    global fig\n\n    fig.tight_layout()\n\n\nif __name__ == '__main__':\n    app = QtWidgets.QApplication(sys.argv)\n\n    MyUI = Ui()\n\n    PrepareFigure()\n\n    MyUI.Redraw.connect(RedrawPlots)\n    MyUI.blit_start.connect(startAnimation)\n    MyUI.blit_stop.connect(stopAnimation)\n    MyUI.update_plot.connect(animate)\n    MyUI.resizeSignal.connect(windowResize)\n\n    # MyUI.showMaximized()\n    MyUI.show()\n\n    windowResize()\n    RedrawPlots()\n\n    app.exec_()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_251","text":"<reponame>gitter-badger\/mlmodels<filename>mlmodels\/model_tch\/vae\/util.py\n\nimport os, sys\nimport numpy as np\nimport scipy as sci\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport cv2\n\n\"\"\"\nfunctionality: sine wave npz generation and image gerneration\n\"\"\"\n\n# default image shape 64x64x3\n# default npz element size ([sample number], 64, 64) \ndata = {'resolution': 64, 'amplitude': 5, 'img_relative_folder':\"\/sinus_img\/verbose\", \\\n  'npz_relative_folder':\"\/sinus_npz\", 'npz_name': \"sinus.npz\", \\\n  'img_cv_folder':\"\/sinus_img_cv\/verbose\", 'npz_cv_folder':\"\/sinus_npz_cv\", 'npz_cv_name': \"sinus_cv.npz\"}\n\ndef set_resolution(resolution = 64):\n  data['resolution'] = resolution\n\ndef get_resolution():\n  return data['resolution']\n\n# sinus: y = a * sin(w * t)\ndef generate_random_sin(n_rand_starts = 100, amplitude = 1, n_pis = 4, omega = 1, step = 0.2):\n  r = np.random.randint(n_rand_starts)\n  x = np.arange(r, r + n_pis*np.pi, step)\n  y = amplitude * np.sin(omega * x)\n  return x,y\n\n# cosinus: y = a * cos (w * t + b) + c\ndef generate_random_cos(n_rand_starts = 1, a = 1, w= 1, b = 0, c = 0, x_upbound =1, x_downbound = -1, step = 0.2):\n  r = np.random.randint(n_rand_starts)\n  x = np.arange(x_downbound*2*np.pi+r, x_upbound*2*np.pi+r, step)\n  y = a * np.cos(w * x + b) + c\n\n  return x,y\n\n# opencv: create wave image as numpy array\ndef create_sin_2d_array_cv(x, y, resoltuion = data['resolution'],amp=data['amplitude']):\n  size = len(x), len(y), 3\n  linewidth = int(len(y)\/resoltuion + 0.5) \n  vis = np.zeros(size, dtype=np.uint8)\n  new_y = y.copy()\n  # amplitude set here for plot\n  y_max = amp\n  y_min = -1*amp\n  border = 16\n  ratio = float((len(y)-border) \/( y_max - y_min))\n  for i in range(len(y)):\n    new_y[i] = int(border\/2+(len(y)-border)-1-(y[i]-y_min)*ratio)\n\n  pointList = []\n  for i in range(int(len(x))):\n    pointList.append((i,int(new_y[i])))\n  pointList = np.array(pointList)\n\n  cv2.polylines(vis,  [pointList],  False,  (255,255,255),  linewidth)\n\n  vis = cv2.resize(vis, (resoltuion, resoltuion), interpolation=cv2.INTER_CUBIC)\n  # threshold as 50\n  result = np.where(vis[:,:,0] > 50, 1, 0)\n  return result\n\n# opencv: create wave image save as images to disk\ndef plot_save_disk_cv(x, y, filename, xmax=data['resolution'], ymax=data['resolution'],amp=data['amplitude']):\n  size = len(x), len(y), 3\n  linewidth = int(len(y)\/ymax + 0.5) \n  vis = np.ones(size, dtype=np.uint8)\n  vis = vis * 255\n  new_y = y.copy()\n  y_max = amp\n  y_min = -1*amp\n  border = 16\n  ratio = float((len(y)-border) \/( y_max - y_min))\n  for i in range(len(y)):\n    new_y[i] = int(border\/2+(len(y)-border)-1-(y[i]-y_min)*ratio)\n  pointList = []\n  for i in range(int(len(x))):\n    pointList.append((i,int(new_y[i])))\n  pointList = np.array(pointList)\n  cv2.polylines(vis,  [pointList],  False,  (0,0,0),  linewidth)\n  vis = cv2.resize(vis, (xmax, ymax), interpolation=cv2.INTER_CUBIC)\n  cv2.imwrite(filename, vis)\n\n\n# matplotlit: create wave image as numpy array\ndef create_sin_2d_array_plt(x, y, xmax=data['resolution'], ymax=data['resolution'],amp=data['amplitude']):\n  plt.rcParams['axes.facecolor']='white'\n  plt.rcParams['savefig.facecolor']='white'\n  fig = plt.figure(frameon=False, figsize=(xmax, ymax), dpi=1)\n  ax = plt.Axes(fig, [0., 0., 1., 1.])\n  # amplitude set here for plot\n  ax.set_ylim([-1*amp,1*amp])\n  ax.set_axis_off()\n  fig.add_axes(ax)\n\n  plt.plot(x,y, c=\"black\", linewidth=100)\n  fig.canvas.draw()\n  frame = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n  frame = frame.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n  plt.clf()\n  plt.close('all')\n  # frame is binary\n  result = np.where(frame[:,:,0] > 254, 0, 1)\n  return result\n\n# matplotlib: create wave image save as images to disk\ndef plot_save_disk(x, y, filename, xmax=data['resolution'], ymax=data['resolution'], amp=data['amplitude']):\n  fig = plt.figure(frameon=False, figsize=(xmax, ymax), dpi=1)\n\n  ax = plt.Axes(fig, [0., 0., 1., 1.])\n  ax.set_ylim([-1*amp,1*amp])\n  ax.set_axis_off()\n  fig.add_axes(ax)\n\n  plt.plot(x,y, c=\"black\", linewidth=100)\n  fig.savefig(filename)\n  plt.clf()\n  plt.close('all')\n\n# matplotlib: images saves to \/path\/sinus_img\/verbose\/*.png\ndef generate_train_img(folder, N_type=1, amax=5, wmin=5, wmax=10, bmin=-2, bmax=2, cmin=-2 ,cmax=2 , step = 0.1, wfreq=0.5 ) :\n    folder_w_subfolder = folder + data['img_relative_folder']\n    os.makedirs(folder, exist_ok=True)\n    \n    os.makedirs(folder_w_subfolder, exist_ok=True)\n    folder = os.path.abspath(folder_w_subfolder)\n\n    for type_i in range(N_type):\n      for amp_int in range(1, amax*2+1):\n        amp_i = amp_int*0.5\n        for omega_i in range(wmin, wmax, 1):\n          omega_ii = wfreq * omega_i\n          for b_i in range(bmin, bmax, 1):\n            for c_i in range(cmin, cmax, 1):\n              # use sinus gernerate: \n              # x,y = generate_random_sin(N_type, amp_i, 4, omega_ii, step)\n              # use cosinus gernerate: \n              x,y = generate_random_cos(n_rand_starts=N_type,a=amp_i, w=omega_ii, b = b_i, c = c_i, step = step)\n              filename = '{folder}\/sin_{amp_i}-{omega_ii}-{b_i}-{c_i}-{type_i}'.format(folder=folder, amp_i=amp_i, omega_ii=omega_ii, b_i=b_i, c_i=c_i,type_i=type_i).replace(\".\",\"_\")\n              filename = filename + \".png\"\n              plot_save_disk(x,y, filename, xmax = data['resolution'], ymax = data['resolution'], amp = data['amplitude'])\n\n# matplotlib: images saves to \/path\/sinus_npz\/verbose\/sinus.npz\ndef generate_train_npz(folder, N_type=1, amax=5, wmin=5, wmax=10, bmin=-2, bmax=2, cmin=-2 ,cmax=2 , step = 0.1, wfreq=0.5, resoltuion = data['resolution'] ) :\n    folder_w_subfolder = folder + data['npz_relative_folder']\n    # inital with empty numpy which is random\n    generate_npy = [np.empty([resoltuion, resoltuion], dtype=int)]\n    os.makedirs(folder, exist_ok=True)\n    os.makedirs(folder_w_subfolder, exist_ok=True)\n    folder = os.path.abspath(folder)\n    is_inital = False\n\n    for type_i in range(N_type):\n      for amp_int in range(1, amax*2+1):\n        amp_i = amp_int*0.5\n        for omega_i in range(wmin, wmax, 1):\n          omega_ii = wfreq * omega_i\n          for b_i in range(bmin, bmax, 1):\n            for c_i in range(cmin, cmax, 1): \n              # use sinus gernerate: \n              # x,y = generate_random_sin(N_type, amp_i, 4, omega_ii, step)\n              # use cosinus gernerate: \n              x,y = generate_random_cos(n_rand_starts=N_type,a=amp_i, w=omega_ii, b = b_i, c = c_i, step = step)\n              if len(generate_npy) == 1 and is_inital == False:\n                # replace the random array with first data, only do once\n                generate_npy = [create_sin_2d_array_plt(x,y)]\n                is_inital = True\n              else:\n                generate_npy=np.append(generate_npy, [create_sin_2d_array_plt(x,y)],axis=0)\n    np.savez(folder_w_subfolder+ \"\/\"+ data['npz_name'], sinus=generate_npy)\n    print(\"npz saved\")\n\n# opencv_version: images saves to \/path\/sinus_img_cv\/verbose\/*.png\ndef generate_train_npz_cv(folder, N_type=1, amax=5, wmin=5, wmax=10, bmin=-2, bmax=2, cmin=-2 ,cmax=2 , step = 0.1, wfreq=0.5, resoltuion = data['resolution'] ) :\n    folder_w_subfolder = folder + data['npz_cv_folder']\n    # inital with empty numpy which is random\n    generate_npy = [np.empty([resoltuion, resoltuion], dtype=int)]\n    os.makedirs(folder, exist_ok=True)\n    os.makedirs(folder_w_subfolder, exist_ok=True)\n    folder = os.path.abspath(folder)\n    is_inital = False\n\n    for type_i in range(N_type):\n      for amp_int in range(1, amax*2+1):\n        amp_i = amp_int*0.5\n        for omega_i in range(wmin, wmax, 1):\n          omega_ii = wfreq * omega_i\n          for b_i in range(bmin, bmax, 1):\n            for c_i in range(cmin, cmax, 1):\n              # use sinus gernerate:                \n              # x,y = generate_random_sin(N_type, amp_i, 4, omega_ii, step)\n              # use cosinus gernerate: \n              x,y = generate_random_cos(n_rand_starts=N_type,a=amp_i, w=omega_ii, b = b_i, c = c_i, step = step)\n\n              if len(generate_npy) == 1 and is_inital == False:\n                # replace the random array with first data, only do once\n                generate_npy = [create_sin_2d_array_cv(x,y)]\n                is_inital = True\n              else:\n                generate_npy=np.append(generate_npy, [create_sin_2d_array_cv(x,y)],axis=0)\n    np.savez(folder_w_subfolder+ \"\/\"+ data['npz_cv_name'], sinus=generate_npy)\n    print(\"npz saved\")\n\n# opencv_version: images saves to \/path\/sinus_npz\/verbose\/sinus.npz\ndef generate_train_img_cv(folder, N_type=1, amax=5, wmin=5, wmax=10, bmin=-2, bmax=2, cmin=-2 ,cmax=2 , step = 0.1, wfreq=0.5) :\n    folder_w_subfolder = folder + data['img_cv_folder']\n    os.makedirs(folder, exist_ok=True)\n    \n    os.makedirs(folder_w_subfolder, exist_ok=True)\n    folder = os.path.abspath(folder_w_subfolder)\n\n    for type_i in range(N_type):\n      for amp_int in range(1, amax*2+1):\n        amp_i = amp_int*0.5\n        for omega_i in range(wmin, wmax, 1):\n          omega_ii = wfreq * omega_i\n          for b_i in range(bmin, bmax, 1):\n            for c_i in range(cmin, cmax, 1):                \n              # use sinus gernerate:                \n              # x,y = generate_random_sin(N_type, amp_i, 4, omega_ii, step)\n              # use cosinus gernerate: \n              x,y = generate_random_cos(n_rand_starts=N_type,a=amp_i, w=omega_ii, b = b_i, c = c_i, step = step)\n\n              filename = '{folder}\/sin_{amp_i}-{omega_ii}-{b_i}-{c_i}-{type_i}'.format(folder=folder, amp_i=amp_i, omega_ii=omega_ii, b_i=b_i, c_i=c_i,type_i=type_i).replace(\".\",\"_\")\n              filename = filename + \".png\"\n              plot_save_disk_cv(x,y, filename, xmax = data['resolution'], ymax = data['resolution'])\n\nprint(\"loaded\")\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_252","text":"#!\/usr\/bin\/python\n\nimport argparse\nimport datetime\nimport numpy as np\nimport pickle\nimport os\nimport CLS_Clouds as CLS\nimport scipy.stats\n\nparser = argparse.ArgumentParser(description='Process some integers.')\nparser.add_argument('--date', type=str, help='date on which the algorithm should be run')\nparser.add_argument('--campaign', type=str, help='Cloudnet station on which the algorithm should be run')\nparser.add_argument('--type', metavar='type_str', type=str, help='Cloud type on which the algorithm should be run')\nargs = parser.parse_args()\n\ncampaign=args.campaign\ndate=datetime.datetime.strptime(args.date, \"%Y%m%d\").date()\ncloud_type=args.type\nprint(\"starting collector {} {} {}\".format(args.campaign, args.date, args.type))\n\ndef load_object(filename):\n    ifile=open(filename,\"rb\")\n    obj = pickle.load(ifile)\n    ifile.close()\n    return obj\n\ndef dict_to_str(source):\n    outstr=\"\"\n    keys=sorted(source.keys())\n    for key in keys:\n        outstr += str(source[key])+\";\"\n    return outstr\n\n\ndef keys_to_str(source):    \n    outstr=\"\"    \n    keys=sorted(source.keys())    \n    for key in keys:        \n        outstr += str(key)+\";\"    \n    return outstr\n\nif cloud_type==None:\n    cloud_type='all'\n\nrecognized_types=['pure_ice','pure_liquid','mixed-phase','liquid-based','tower','all']\nassert cloud_type in recognized_types, \"{} not in {}\".format(cloud_type, recognized_types)\n\ninfile='..\/cloud_properties\/cloud_properties_'+campaign+'\/'+date.strftime(\"%Y_%m_%d\")+'_clouds.dat'\noutfile='..\/cloud_collections\/'+'cloud_collection_'+campaign+'_'+cloud_type+'.csv'\n\nif not(os.path.exists(outfile)):\n    newfile=True\nelse:\n    if os.path.getsize(outfile)==0:\n        newfile=True\n    else:\n        newfile=False\n\nclouds = load_object(infile)\n\nice_only=[4]\nliquid=[1,3,5,7]\ndroplets_only=[1,5]\nsep=6\noutput={}\n\nfor i in range(len(clouds)):\n\n    #print clouds[i].cloud_type\n    #print clouds[i].top_variation(),clouds[i].time_length(),clouds[i].fill_factor()\n\n    if (clouds[i].cloud_type==cloud_type or cloud_type=='all') and clouds[i].n_profiles()>0:\n\n       if clouds[i].top_variation()<600.0 and clouds[i].time_length()>900 and clouds[i].fill_factor()>0.7:\n            \n            begin=datetime.datetime.utcfromtimestamp(clouds[i].begin_time)\n            end=datetime.datetime.utcfromtimestamp(clouds[i].end_time)\n            middle=begin+datetime.timedelta(seconds=(clouds[i].end_time-clouds[i].begin_time)\/2.)\n\n            clouds[i].validate_features()\n\n            output[\"A_Unique_Identifier\"]=begin.strftime(\"%Y%m%d%H%M%S\")+str(int(clouds[i].tops[0]))\n            output[\"Cloud_Run\"]=clouds[i].cloud_type\n            output[\"Cloud_Type\"]=clouds[i].most_common_type()\n            output[\"Date_Year\"]=middle.year\n            output[\"Date_Month\"]=middle.month\n            output[\"Date_Day\"]=middle.day\n            output[\"Date_Hour\"]=middle.hour\n            output[\"Begin_Date\"]=begin.strftime(\"%Y_%m_%d_%H_%M_%S\")\n            output[\"Begin_Date_Unix\"]=clouds[i].begin_time\n            output[\"End_Date\"]=end.strftime(\"%Y_%m_%d_%H_%M_%S\")\n            output[\"End_Date_Unix\"]=clouds[i].end_time\n\n            output[\"CTH\"]=np.max(clouds[i].tops)\n            output[\"CTH_AVG\"]=np.average(clouds[i].tops)\n            output[\"CTH_STD\"]=clouds[i].top_variation()\n            output[\"CTH_DIFFSUM\"]=clouds[i].top_diffsum()\n            output[\"LLH_STD\"]=clouds[i].liquid_layer_variation()\n            output[\"CBH\"]=np.min(clouds[i].bases)\n            output[\"CBT\"],output[\"CTT_MED\"],output[\"CTT\"]=clouds[i].temperature_range()\n            output[\"CBP\"],output[\"CTP\"]=clouds[i].pressure_range()\n\n            output[\"VEL\"],output[\"DIR\"]=clouds[i].vel_and_dir()\n\n            output[\"N_Profiles\"]=clouds[i].n_profiles()\n            output[\"N_Liquid\"]=clouds[i].n_profiles([\"pure liquid\",\"liquid-based layer\"])\n            output[\"N_MixedPhase\"]=clouds[i].n_profiles([\"mixed-phase layer\"])\n\n            output[\"LWC_AVG\"],output[\"LWC_MED\"],output[\"LWC_STD\"],output[\"LWC_N\"]=clouds[i].average(\"LWC\",CLS.droplets_only)\n            output[\"PATH_LWP_AVG\"],output[\"PATH_LWP_S_AVG\"],output[\"PATH_IWP_AVG\"],output[\"PATH_IWP_STD\"]=clouds[i].average_paths()\n            output[\"Cloud_Thickness_AVG\"],output[\"Cloud_Thickness_MED\"],output[\"Cloud_Thickness_STD\"], thickness_vals =clouds[i].cloud_top_thickness()\n\n            thickness_vals_s = sorted(thickness_vals, key=lambda k: k[0])\n            period_top, autocorr_top = CLS.time_analysis_from_vel(thickness_vals_s, 3)\n            #\n            # ey linkely wrong place\n            # here the CTH_autocorr is calculated\n            #\n            #print(autocorr_top)\n            if len(autocorr_top[1] > 0):\n                i_above_thres = np.where(autocorr_top[1] > 0.8)[0][-1]\n                output[\"CTH_autocorr_08_time\"] = autocorr_top[0][i_above_thres]\n            else:\n                output[\"CTH_autocorr_08_time\"] = -1\n            #wh = np.where(autocorr_top[1] > 0.0)[0]\n            #if len(wh) > 0:\n            #    output[\"CTH_autocorr_08_time\"] = autocorr_top[0][wh[-1]]\n            #else:\n            #    output[\"CTH_autocorr_08_time\"] = -99\n            # output[\"v_dl_period_f\"] = periodogram[0].tolist()\n            # output[\"v_dl_period_Pxx\"] = periodogram[1].tolist()\n            # output[\"v_dl_autocor_time\"] = autocorr[0].tolist()\n            # output[\"v_dl_autocor_coeff\"] = autocorr[1].tolist()\n\n\n            output[\"IWC_AVG\"],output[\"IWC_MED\"],output[\"IWC_STD\"],output[\"IWC_N\"]=clouds[i].average(\"IWC\",ice_only)\n            output[\"IWC_TOP_AVG\"],output[\"IWC_TOP_MED\"],output[\"IWC_TOP_STD\"],output[\"IWC_TOP_N\"]=clouds[i].separation_average(\"IWC\",sep)\n            output[\"ILCR_AVG\"],output[\"ILCR_MED\"],output[\"ILCR_N\"],output[\"ILCR_values\"]=clouds[i].ilr(sep)\n\n            clouds[i].correct_LDR(-20,-33)\n            output[\"LDR_AVG\"],output[\"LDR_MED\"],output[\"LDR_STD\"],output[\"LDR_N\"]=clouds[i].average(\"LDR\",ice_only)\n            output[\"LDR_values\"]=list(np.histogram(clouds[i].return_values(\"LDR\",ice_only),70,(-35.0,1))[0])\n            output[\"LDR_TOP_AVG\"],output[\"LDR_TOP_MED\"],output[\"LDR_TOP_STD\"],output[\"LDR_TOP_N\"]=clouds[i].separation_average(\"LDR\",sep)\n\n            output[\"N_Melting\"]=clouds[i].n_melting()\n            output[\"N_Drizzle\"]=clouds[i].n_drizzle()\n\n            output[\"v_AVG\"],output[\"v_MED\"],output[\"v_STD\"],output[\"v_N\"]=clouds[i].average(\"v\",ice_only)\n            output[\"v_TOP_AVG\"],output[\"v_TOP_MED\"],output[\"v_TOP_STD\"],output[\"v_TOP_N\"]=clouds[i].separation_average(\"v\",sep)\n            output[\"v_values\"]=list(np.histogram(clouds[i].return_values(\"v\",ice_only),60,(-1.5,0.0))[0])\n\n            #output[\"tfv_AVG\"],output[\"tfv_MED\"],output[\"tfv_STD\"],output[\"tfv_N\"]=clouds[i].average(\"tfv\",ice_only)\n            #output[\"tfv_TOP_AVG\"],output[\"tfv_TOP_MED\"],output[\"tfv_TOP_STD\"],output[\"tfv_TOP_N\"]=clouds[i].separation_average(\"tfv\",sep)\n            #output[\"vair_AVG\"],output[\"vair_MED\"],output[\"vair_STD\"],output[\"vair_N\"]=clouds[i].combined_average(\"vair\",\"v\",ice_only)\n\n            #output[\"v_comb_tfv_AVG\"],output[\"v_comb_tfv_MED\"],output[\"v_comb_tfv_STD\"],output[\"v_comb_tfv_N\"]=clouds[i].combined_average(\"v\",\"tfv\",ice_only)\n\n            output[\"Z_AVG\"],output[\"Z_MED\"],output[\"Z_STD\"],output[\"Z_N\"]=clouds[i].average(\"Z\",ice_only)\n            output[\"Z_AVG_drop\"],output[\"Z_MED_drop\"],output[\"Z_STD_drop\"],output[\"Z_N_drop\"]=clouds[i].average(\"Z\",droplets_only)\n            output[\"Z_TOP_AVG\"],output[\"Z_TOP_MED\"],output[\"Z_TOP_STD\"],output[\"Z_TOP_N\"]=clouds[i].separation_average(\"Z\",sep)\n            z_top_vals = clouds[i].return_values_separation(\"Z\",sep)\n            output[\"Z_TOP_values\"]=list(np.histogram(10*np.log10(z_top_vals),90,(-70.0,20))[0])\n            z_vals = clouds[i].return_values(\"Z\",ice_only)\n            #print(z_vals)\n            #print(10*np.log10(z_vals))\n            output[\"Z_values\"]=list(np.histogram(10*np.log10(z_vals),90,(-70.0,20))[0])\n\n            output[\"ZE_TOP_AVG\"],output[\"ZE_TOP_MED\"],output[\"ZE_TOP_STD\"],output[\"ZE_TOP_N\"]=clouds[i].separation_average(\"ratio_z_e\",sep)\n            print('ZE_TOP_stat ', output[\"ZE_TOP_AVG\"],output[\"ZE_TOP_MED\"],output[\"ZE_TOP_STD\"],output[\"ZE_TOP_N\"])\n            output[\"ZE_AVG\"],output[\"ZE_MED\"],output[\"ZE_STD\"],output[\"ZE_N\"]=clouds[i].average(\"ratio_z_e\",ice_only)\n            print('ZE_stat ', output[\"ZE_AVG\"],output[\"ZE_MED\"],output[\"ZE_STD\"],output[\"ZE_N\"])\n            \n            output[\"SNR_TOP_AVG\"],output[\"SNR_TOP_MED\"],output[\"SNR_TOP_STD\"],output[\"SNR_TOP_N\"]=clouds[i].separation_average(\"SNR\",sep)\n\n            output[\"width_AVG\"],output[\"width_MED\"],output[\"width_STD\"],output[\"width_N\"]=clouds[i].average(\"width\",ice_only)\n\n            #output[\"SNR_AVG\"],output[\"SNR_MED\"],output[\"SNR_STD\"],output[\"SNR_N\"]=clouds[i].average(\"SNR\",ice_only)\n            #output[\"SNR_10pp\"],output[\"SNR_90pp\"]=clouds[i].pp90(\"SNR\",ice_only)\n\n            output[\"alpha_Hogan_AVG\"],output[\"alpha_Hogan_MED\"],output[\"alpha_Hogan_STD\"],output[\"alpha_Hogan_N\"]=clouds[i].average(\"alpha_hogan\",ice_only)\n            output[\"alpha_Hogan_TOP_AVG\"],output[\"alpha_Hogan_TOP_MED\"],output[\"alpha_Hogan_TOP_STD\"],output[\"alpha_Hogan_TOP_N\"]=clouds[i].separation_average(\"alpha_hogan\",sep)\n            output[\"beta_AVG\"],output[\"beta_MED\"],output[\"beta_STD\"],output[\"beta_N\"]=clouds[i].average(\"beta\",ice_only)\n\n            # lidar variables from pollynet\n            output[\"qbscice_TOP_AVG\"],output[\"qbscice_TOP_MED\"],output[\"qbscice_TOP_STD\"],output[\"qbscice_TOP_N\"]=clouds[i].separation_average(\"qbsc\",sep)\n            output[\"qbsc_drop_AVG\"],output[\"qbsc_drop_MED\"],output[\"qbsc_drop_STD\"],output[\"qbsc_drop_N\"]=clouds[i].average(\"qbsc\",droplets_only)\n            # TODO add qiceext\n    \n            output[\"delta_AVG\"],output[\"delta_MED\"],output[\"delta_STD\"],output[\"delta_N\"]=clouds[i].average(\"voldepol\",ice_only)\n            output[\"voldepol_AVG\"],output[\"voldepol_MED\"],output[\"voldepol_STD\"],output[\"voldepol_N\"]=clouds[i].average(\"voldepol\",ice_only)\n            \n            #output[\"v_lidar_AVG\"],output[\"v_lidar_STD\"],output[\"v_lidar_N\"],output[\"v_lgt0_AVG\"],output[\"v_lgt0_STD\"],output[\"v_lgt0_N\"],vv_values=clouds[i].velocities()\n            #output[\"v_lidar_histo\"]=list(np.histogram(vv_values,60,(-3.0,3.0))[0])\n\n            # refactored vertical velocities in liquid layers\n            output['v_dl_mean'], output['v_dl_std'], output['v_dl_n'], v_base, vel_locations = clouds[i].velocities()\n            if len(v_base) > 0:\n                output['v_dl_perc'] = np.percentile(v_base, [10,25,50,75,90]).tolist()\n                output['v_dl_skew'] = scipy.stats.skew(v_base)\n            else:\n                output['v_dl_perc'] = [-99,-99,-99,-99,-99] \n                output['v_dl_skew'] = -99\n\n            output['v_cr_mean'], output['v_cr_std'], output['v_cr_n'], v_base, _ = clouds[i].velocities_liquid_radar('whole')\n            if len(v_base) > 0:\n                output['v_cr_perc'] = np.percentile(v_base, [10,25,50,75,90]).tolist()\n                output['v_cr_skew'] = scipy.stats.skew(v_base)\n            else:\n                output['v_cr_perc'] = [-99,-99,-99,-99,-99] \n                output['v_cr_skew'] = -99\n\n            # and the timeseries analysis\n            # (f, Pxx_den), (time_shifts[:500], v_autocorr[:500])\n            vel_locations_s = sorted(vel_locations, key=lambda k: k[0])\n            periodogram, autocorr = CLS.time_analysis_from_vel(vel_locations_s, 2)\n            output[\"v_dl_period_f\"] = periodogram[0].tolist()\n            output[\"v_dl_period_Pxx\"] = periodogram[1].tolist()\n            output[\"v_dl_autocor_time\"] = autocorr[0].tolist()\n            output[\"v_dl_autocor_coeff\"] = autocorr[1].tolist()\n\n            #\n            # now include the fixed height version\n            #\n            mids, mid_with_time = clouds[i].cloud_top_avg()\n            output['v_dl_fix_mean'], output['v_dl_fix_std'], output['v_dl_fix_n'], v_base, vel_locations = clouds[i].velocities_fixed_height(mids)\n            vel_locations_s = sorted(vel_locations, key=lambda k: k[0])\n            periodogram, autocorr = CLS.time_analysis_from_vel(vel_locations_s, 2)\n            output[\"v_dl_fix_period_f\"] = periodogram[0].tolist()\n            output[\"v_dl_fix_period_Pxx\"] = periodogram[1].tolist()\n            output[\"v_dl_fix_autocor_time\"] = autocorr[0].tolist()\n            output[\"v_dl_fix_autocor_coeff\"] = autocorr[1].tolist()\n\n            #output[\"pT_no_node_hist\"] = clouds[i].no_node_hist()\n            #output[\"pT_no_node_hist_cb\"] = clouds[i].no_node_hist_above_cb()\n            output[\"pT_no_node_hist_il\"] = clouds[i].no_node_hist_ice_liq()\n\n            #manually corrected LDR\n            output[\"LDRcorr_TOP_AVG\"], output[\"LDRcorr_TOP_MED\"], output[\"LDRcorr_TOP_STD\"], output[\"LDRcorr_TOP_N\"] = clouds[i].separation_average(\"LDRcorr\", sep)\n            output[\"LDRcorr_AVG\"], output[\"LDRcorr_MED\"], output[\"LDRcorr_STD\"], output[\"LDRcorr_N\"] = clouds[i].average(\"LDRcorr\", ice_only)\n\n            #interpolation\n            #il=16\n            #vv_int=[]\n            #if len(vv_values)>il+1:\n            #    for n in range(len(vv_values)\/il-il-1):\n            #        vv_int.append(np.average(vv_values[il*n:il*n+il]))\n            #vv_int=np.array(vv_int)\n            #vv_values=vv_int\n\n            #output[\"v_lidar_histo_INT\"]=list(np.histogram(vv_values,60,(-3.0,3.0))[0])\n\n            output[\"v_radar_AVG\"],output[\"v_radar_STD\"],output[\"v_radar_N\"],output[\"v_radar_lgt0_AVG\"],output[\"v_radar_lgt0_STD\"],output[\"v_radar_lgt0_N\"],output[\"v_radar_WIDTH\"],vv_radar_values,output[\"Z_top\"]=clouds[i].velocities_radar()\n            output[\"v_radar_histo\"]=list(np.histogram(vv_radar_values,60,(-3.0,3.0))[0])\n\n            output[\"file_hist_class\"] = clouds[i].get_class_file_history()\n\n            #print(clouds[i].cloud_type,output[\"Z_top\"])\n\n\n            #output[\"adv_wind_profiler\"],output[\"std_wind_profiler\"],output[\"max_wind_profiler\"],output[\"min_wind_profiler\"],output[\"dvdh_wind_profiler\"]=clouds[i].horizontal_wind(output[\"CTH\"],4)\n            #if len(clouds[i].features)>100:\n            #    clouds[i].FA()\n            #if output[\"Begin_Date\"]=='2018_12_30_21_05_14':\n            #    exit()\n\n            with open(outfile, \"a+\") as f:\n                if newfile:\n                    keys=keys_to_str(output)\n                    f.write(keys+\"\\n\")\n                    newfile=False\n\n                output_str=dict_to_str(output)\n                f.write(output_str+\"\\n\")\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_253","text":"import copy\nimport json\nimport logging\nimport os\nimport pickle\nimport random\nimport statistics\nimport sys\nimport time\n\nimport numpy as np\nimport torch\n\nimport yaml\nfrom inclearn.lib import factory\nfrom inclearn.lib import metrics, utils, results_utils\nfrom inclearn.lib.network import FeatureGenerator\nfrom inclearn.lib.data.samplers import NPairSampler, AuxSampler\n\nfrom inclearn.utils import LOGGER as logger\n\n\ndef train(args):\n    logger.LOGGER.setLevel(args[\"logging\"].upper())\n    autolabel = _set_up_options(args)\n    if args[\"autolabel\"]:\n        args[\"label\"] = autolabel\n\n    if args[\"label\"]:\n        logger.LOGGER.info(\"Label: {}\".format(args[\"label\"]))\n        try:\n            os.system(\"echo '\\ek{}\\e\\\\'\".format(args[\"label\"]))\n        except:\n            pass\n    if args[\"resume\"] and not os.path.exists(args[\"resume\"]):\n        raise IOError(f\"Saved model {args['resume']} doesn't exist.\")\n\n    if args[\"save_model\"] != \"never\" and args[\"label\"] is None:\n        raise ValueError(f\"Saving model every {args['save_model']} but no label was specified.\")\n\n    seed_list = copy.deepcopy(args[\"seed\"])\n    device = copy.deepcopy(args[\"device\"])\n\n    start_date = utils.get_date()\n    results_folder = results_utils.get_save_folder(args[\"model\"], start_date, args[\"label\"])\n    logger.add_file_headler(results_folder)\n\n    orders = copy.deepcopy(args[\"order\"])\n    del args[\"order\"]\n    if orders is not None:\n        assert isinstance(orders, list) and len(orders)\n        assert all(isinstance(o, list) for o in orders)\n        assert all([isinstance(c, int) for o in orders for c in o])\n    else:\n        orders = [None for _ in range(len(seed_list))]\n\n    avg_inc_accs, last_accs, forgettings = [], [], []\n    for i, seed in enumerate(seed_list):\n        logger.LOGGER.warning(\"Launching run {}\/{}\".format(i + 1, len(seed_list)))\n        args[\"seed\"] = seed\n        args[\"device\"] = device\n\n        start_time = time.time()\n\n        for avg_inc_acc, last_acc, forgetting in _train(args, start_date, orders[i], i):\n            yield avg_inc_acc, last_acc, forgetting, False\n\n        avg_inc_accs.append(avg_inc_acc)\n        last_accs.append(last_acc)\n        forgettings.append(forgetting)\n\n        logger.LOGGER.info(\"Training finished in {}s.\".format(int(time.time() - start_time)))\n        yield avg_inc_acc, last_acc, forgetting, True\n\n    logger.LOGGER.info(\"Label was: {}\".format(args[\"label\"]))\n\n    logger.LOGGER.info(\n        \"Results done on {} seeds: avg: {}, last: {}, forgetting: {}\".format(\n            len(seed_list), _aggregate_results(avg_inc_accs), _aggregate_results(last_accs),\n            _aggregate_results(forgettings)\n        )\n    )\n    logger.LOGGER.info(\"Individual results avg: {}\".format([round(100 * acc, 2) for acc in avg_inc_accs]))\n    logger.LOGGER.info(\"Individual results last: {}\".format([round(100 * acc, 2) for acc in last_accs]))\n    logger.LOGGER.info(\n        \"Individual results forget: {}\".format([round(100 * acc, 2) for acc in forgettings])\n    )\n\n    logger.LOGGER.info(f\"Command was {' '.join(sys.argv)}\")\n\n\ndef _train(args, start_date, class_order, run_id):\n    _set_global_parameters(args)\n    inc_dataset, model = _set_data_model(args, class_order)\n    results, results_folder = _set_results(args, start_date)\n\n    memory, memory_val, pseudo_memory = None, None, None\n    metric_logger = metrics.MetricLogger(\n        inc_dataset.n_tasks, inc_dataset.n_classes, inc_dataset.increments\n    )\n    use_unlabeled = args.get(\"use_unlabeled\", False)\n    print(f'use_unlabeled:{use_unlabeled}')\n    for task_id in range(inc_dataset.n_tasks):\n        pseudo_memory_n_samples = args.get(\"pseudo_memory_n_samples\", 2)\n        task_info, train_loader, val_loader, test_loader, aux_loader, pseudo_memory_loader, pure_new_data = \\\n            inc_dataset.new_task(memory, pseudo_memory, memory_val, pseudo_memory_n_samples=pseudo_memory_n_samples)\n        if task_info[\"task\"] == args[\"max_task\"]:\n            break\n        model.set_task_info(task_info)\n\n        # ---------------\n        # 1. Prepare Task\n        # ---------------\n        model.eval()\n        model.before_task(train_loader, val_loader if val_loader else test_loader)\n\n        # -------------\n        # 2. Train Task\n        # -------------\n        pseudo_memory = _train_task(args, model, train_loader, aux_loader, pseudo_memory, pseudo_memory_loader,\n                                    pure_new_data, inc_dataset, val_loader, test_loader, run_id, task_id, task_info,\n                                    results_folder)\n\n        # ----------------\n        # 3. Conclude Task\n        # ----------------\n        model.eval()\n        _after_task(args, model, inc_dataset, run_id, task_id, results_folder)\n\n        # ------------\n        # 4. Eval Task\n        # ------------\n        logger.LOGGER.info(\"Eval on {}->{}.\".format(0, task_info[\"max_class\"]))\n        ypreds, ytrue = model.eval_task(test_loader)\n        metric_logger.log_task(\n            ypreds, ytrue, task_size=task_info[\"increment\"], zeroshot=args.get(\"all_test_classes\")\n        )\n\n        if args[\"dump_predictions\"] and args[\"label\"]:\n            os.makedirs(\n                os.path.join(results_folder, \"predictions_{}\".format(run_id)), exist_ok=True\n            )\n            with open(\n                    os.path.join(\n                        results_folder, \"predictions_{}\".format(run_id),\n                        str(task_id).rjust(len(str(30)), \"0\") + \".pkl\"\n                    ), \"wb+\"\n            ) as f:\n                pickle.dump((ypreds, ytrue), f)\n\n        if args[\"label\"]:\n            logger.LOGGER.info(args[\"label\"])\n        logger.LOGGER.info(\"Avg inc acc: {}.\".format(metric_logger.last_results[\"incremental_accuracy\"]))\n        logger.LOGGER.info(\"Current acc: {}.\".format(metric_logger.last_results[\"accuracy\"]))\n        logger.LOGGER.info(\n            \"Avg inc acc top5: {}.\".format(metric_logger.last_results[\"incremental_accuracy_top5\"])\n        )\n        logger.LOGGER.info(\"Current acc top5: {}.\".format(metric_logger.last_results[\"accuracy_top5\"]))\n        logger.LOGGER.info(\"Forgetting: {}.\".format(metric_logger.last_results[\"forgetting\"]))\n        logger.LOGGER.info(\"Cord metric: {:.2f}.\".format(metric_logger.last_results[\"cord\"]))\n        if task_id > 0:\n            logger.LOGGER.info(\n                \"Old accuracy: {:.2f}, mean: {:.2f}.\".format(\n                    metric_logger.last_results[\"old_accuracy\"],\n                    metric_logger.last_results[\"avg_old_accuracy\"]\n                )\n            )\n            logger.LOGGER.info(\n                \"New accuracy: {:.2f}, mean: {:.2f}.\".format(\n                    metric_logger.last_results[\"new_accuracy\"],\n                    metric_logger.last_results[\"avg_new_accuracy\"]\n                )\n            )\n        if args.get(\"all_test_classes\"):\n            logger.LOGGER.info(\n                \"Seen classes: {:.2f}.\".format(metric_logger.last_results[\"seen_classes_accuracy\"])\n            )\n            logger.LOGGER.info(\n                \"unSeen classes: {:.2f}.\".format(\n                    metric_logger.last_results[\"unseen_classes_accuracy\"]\n                )\n            )\n\n        results[\"results\"].append(metric_logger.last_results)\n\n        avg_inc_acc = results[\"results\"][-1][\"incremental_accuracy\"]\n        last_acc = results[\"results\"][-1][\"accuracy\"][\"total\"]\n        forgetting = results[\"results\"][-1][\"forgetting\"]\n        yield avg_inc_acc, last_acc, forgetting\n\n        memory = model.get_memory()\n        memory_val = model.get_val_memory()\n    logger.LOGGER.info(\n        \"Average Incremental Accuracy: {}.\".format(results[\"results\"][-1][\"incremental_accuracy\"])\n    )\n    if args[\"label\"] is not None:\n        results_utils.save_results(\n            results, args[\"label\"], args[\"model\"], start_date, run_id, args[\"seed\"]\n        )\n\n    del model\n    del inc_dataset\n\n\ndef get_pseudo_memory(aux_loader, model, pseudo_memory, load_folder, save_folder, run_id, task_id, re_mine=False,\n                      n_classes_samples=100):\n    unlabeled_data_save_path = os.path.join(save_folder, f'pseudo_memory_{task_id}_task_{run_id}.pth')\n    unlabeled_data_load_path = None\n    if load_folder is not None:\n        unlabeled_data_load_path = os.path.join(load_folder, f'pseudo_memory_{task_id}_task_{run_id}.pth')\n    if unlabeled_data_load_path is not None and os.path.exists(unlabeled_data_load_path):\n        pseudo_memory = torch.load(unlabeled_data_load_path)\n        logger.LOGGER.info(f'Loaded existing pseudo data form {unlabeled_data_load_path}.')\n        new_data, new_label = pseudo_memory[0], pseudo_memory[1]\n    else:\n        if pseudo_memory is not None and not re_mine:\n            existing_pseudo_mem_cls = torch.unique(pseudo_memory[1])\n        else:\n            existing_pseudo_mem_cls = None\n\n        new_pseudo_memory = model.get_pseudo_memory(aux_loader, existing_cls=existing_pseudo_mem_cls,\n                                                    n_classes_samples=n_classes_samples)\n\n        if existing_pseudo_mem_cls is not None and not re_mine:\n            new_data = np.concatenate((pseudo_memory[0], new_pseudo_memory[0]), axis=0)\n            new_label = torch.cat((pseudo_memory[1], new_pseudo_memory[1]), dim=0).cpu()\n            pseudo_memory = (new_data, new_label)\n        else:\n            pseudo_memory = new_pseudo_memory\n            new_data = new_pseudo_memory[0]\n            new_label = new_pseudo_memory[1]\n\n        logger.LOGGER.info(f'Now unlabeled data: {len(pseudo_memory[0])}')\n    if (unlabeled_data_load_path is not None and not os.path.exists(unlabeled_data_load_path)) and \\\n            not os.path.exists(unlabeled_data_save_path):\n        # torch.save(pseudo_memory, unlabeled_data_save_path)\n        logger.LOGGER.info(f' Saved pseudo memory to {unlabeled_data_save_path}.')\n    return pseudo_memory, new_data, new_label\n\n\n# ------------------------\n# Lifelong Learning phases\n# ------------------------\n\n\ndef _train_task(config, model, train_loader, aux_loader, pseudo_memory, pseudo_memory_loader, pure_new_data,\n                inc_dataset, val_loader, test_loader, run_id, task_id, task_info, results_folder):\n    pseudo_memory_valid_map_idx = config.get('pseudo_memory_valid_map_idx', 0.5)\n    if config[\"resume\"] is not None and os.path.isdir(config[\"resume\"]) \\\n            and ((config[\"resume_first\"] and task_id == 0) or not config[\"resume_first\"]):\n        model.load_parameters(config[\"resume\"], run_id, device=config['device'][0])\n        logger.LOGGER.info(\n            \"Skipping training phase {} because reloading pretrained model.\".format(task_id)\n        )\n    elif config[\"resume\"] is not None and os.path.isfile(config[\"resume\"]) and \\\n            os.path.exists(config[\"resume\"]) and task_id == 0:\n        # In case we resume from a single model file, it's assumed to be from the first task.\n        # model.network = config[\"resume\"]\n        model.load_parameters(config[\"resume\"], run_id, device=config['device'][0])\n        logger.LOGGER.info(\n            \"Skipping initial training phase {} because reloading pretrained model.\".\n                format(task_id)\n        )\n    else:\n        logger.LOGGER.info(\"Train on {}->{}.\".format(task_info[\"min_class\"], task_info[\"max_class\"]))\n        model.train()\n        logger.LOGGER.info(f'Pseudo memory feature map selection is {pseudo_memory_valid_map_idx}.')\n        model.train_task(train_loader, pseudo_memory_loader, val_loader if val_loader else test_loader,\n                         freeze_layers=task_id != 0)\n\n    finetuning_config = config.get(\"finetuning_config\")\n\n    use_unlabeled = config.get('use_unlabeled', False)\n    generator_config = config.get(\"generator_config\", {})\n    train_generator_config = generator_config.get(\"train_config\", {})\n    batch_size = config.get(\"labeled_batch_size\", 128)\n    re_mined = config.get(\"pseudo_re_mined\", False)\n    n_classes_samples = config.get(\"pseudo_mem_n_classes_samples\", 100)\n    if task_id < task_info[\"max_task\"] - 1 and use_unlabeled:\n        p = get_pseudo_memory(aux_loader, model, pseudo_memory, config[\"resume\"], results_folder, run_id, task_id,\n                              re_mine=re_mined, n_classes_samples=n_classes_samples)\n        pseudo_memory = p[0]\n        new_pseudo_memory = (p[1], p[2])\n\n        pseudo_memory_n_samples = train_generator_config.get('train_generator_unlabel_n_samples', 2)\n        current_pseudo_class = torch.unique(new_pseudo_memory[1])\n        tmp_pseudo_memory_loader = inc_dataset.get_pseudo_memory_loader(pseudo_memory, pseudo_memory_n_samples,\n                                                                        batch_size=pseudo_memory_n_samples * len(\n                                                                            current_pseudo_class))\n        # train the generator network\n        if generator_config:\n            n_class_mem = train_generator_config.get(\"train_generator_memory_n_samples\", 12)\n            n_class_new = train_generator_config.get(\"train_generator_new_n_samples\", 12)\n            model.after_task_intensive(inc_dataset, train_generator=True)\n            current_memory = model.get_memory()\n            mem_sampler = AuxSampler(current_memory[1], batch_size=n_class_mem * int(task_info['increment']),\n                                     n_sample=n_class_mem)\n            memory_loader_PK = inc_dataset.get_loader(*current_memory, memory_flags=np.zeros(current_memory[0].shape),\n                                                      mode=\"train\", sampler=mem_sampler, sampler_init=False)\n            nb_class = min(len(np.unique(pure_new_data[1])), int(batch_size \/ n_class_new))\n            train_sampler = NPairSampler(y=pure_new_data[1], n_classes=nb_class, n_samples=n_class_new)\n            train_loader_PK = inc_dataset.get_loader(*pure_new_data, memory_flags=np.zeros(len(pure_new_data[1])),\n                                                     mode=\"train\", sampler=train_sampler, sampler_init=False)\n            train_generator_data = {\n                'labeled_loader': train_loader_PK,\n                'memory_loader': memory_loader_PK,\n            }\n            input_dim = generator_config.get(\"input_dim\", 64)\n            latent_dim = generator_config.get(\"latent_dim\", 64)\n            num_blocks = generator_config.get(\"n_blocks\", 2)\n\n            for cls in range(int(task_info['min_class']), int(task_info['max_class'])):\n                cls_encoder = FeatureGenerator(input_dim, latent_dim=latent_dim, num_blocks=num_blocks).to(model.device)\n                lr = train_generator_config.get(\"lr\", 0.1)\n                model.create_generator_optimizer(cls_encoder.parameters(), lr=lr)\n                model.class_encoders[cls] = cls_encoder\n            res = False\n            if task_id == 0 and config[\"resume\"] is not None:\n                generator_path = os.path.join(config[\"resume\"], 'generators')\n                if os.path.exists(generator_path):\n                    res = load_generator_params(model, config, generator_path, run_id, task_info['min_class'],\n                                                task_info['max_class'])\n            use_generators = not config.get('softmax_ce_not_unlabeled', False)\n            if not res and task_id < task_info[\"max_task\"] - 1 and use_generators:\n                model.train_task(train_loader, tmp_pseudo_memory_loader, val_loader if val_loader else test_loader,\n                                 train_generator_config=train_generator_config,\n                                 train_generator_data=train_generator_data)\n                if task_id >= 0:\n                    save_generator_path = os.path.join(results_folder, 'generator')\n                    if not os.path.isdir(save_generator_path):\n                        os.makedirs(save_generator_path)\n                    save_generator_params(model, save_generator_path, run_id, task_info['min_class'], task_info['max_class'])\n\n    # fine-tune\n    if finetuning_config:\n        model.fine_tune(pseudo_memory_loader, pseudo_memory_valid_map_idx, val_loader)\n    return pseudo_memory\n\n\ndef save_generator_params(model, results_folder, run_id, min_class, max_class):\n    for cls in range(min_class, max_class):\n        e_save_path = os.path.join(results_folder, f'generators_run{run_id}_class{cls}.pth')\n        torch.save({'state_dict': model.class_encoders[cls].state_dict()}, e_save_path)\n        logger.LOGGER.info(f'Saved generator encoder for class {cls} to file {e_save_path}.')\n\n\ndef load_generator_params(model, config, results_folder, run_id, min_class, max_class):\n    for cls in range(min_class, max_class):\n        e_save_path = os.path.join(results_folder, f'generator_encoders_run{run_id}_class{cls}.pth')\n        try:\n            state_dict_saved = torch.load(e_save_path, map_location=config['device'][0])\n        except Exception as e:\n            logger.LOGGER.warning(f'Loading file `{e_save_path}` failed. Try to train it again.')\n            return False\n        model.class_encoders[cls].load_state_dict(state_dict_saved['state_dict'])\n        logger.LOGGER.info(f'Loaded generator encoder for class {cls} from file {e_save_path}.')\n\n    d_save_path = os.path.join(results_folder, f'generators_run{run_id}.pth')\n    try:\n        state_dict_saved = torch.load(d_save_path, map_location=config['device'][0])\n    except:\n        logger.LOGGER.warning(f'Loading file `{d_save_path}` failed. Try to train it again.')\n        return False\n    return True\n\n\ndef _after_task(config, model, inc_dataset, run_id, task_id, results_folder):\n    if config[\"resume\"] and os.path.isdir(config[\"resume\"]) and not config[\"recompute_meta\"] \\\n            and ((config[\"resume_first\"] and task_id == 0) or not config[\"resume_first\"]):\n        model.load_metadata(config[\"resume\"], run_id)\n    else:\n        model.after_task_intensive(inc_dataset)\n\n    model.after_task(inc_dataset)\n\n    if config[\"label\"] and (\n            config[\"save_model\"] == \"task\" or\n            (config[\"save_model\"] == \"last\" and task_id == inc_dataset.n_tasks - 1) or\n            (config[\"save_model\"] == \"first\" and task_id == 0)\n    ):\n        model.save_parameters(results_folder, run_id)\n        model.save_metadata(results_folder, run_id)\n\n\n# ----------\n# Parameters\n# ----------\n\n\ndef _set_results(config, start_date):\n    if config[\"label\"]:\n        results_folder = results_utils.get_save_folder(config[\"model\"], start_date, config[\"label\"])\n    else:\n        results_folder = None\n\n    if config[\"save_model\"]:\n        logger.LOGGER.info(\"Model will be save at this rythm: {}.\".format(config[\"save_model\"]))\n\n    results = results_utils.get_template_results(config)\n\n    return results, results_folder\n\n\ndef _set_data_model(config, class_order):\n    inc_dataset = factory.get_data(config, class_order)\n    config[\"classes_order\"] = inc_dataset.class_order\n\n    model = factory.get_model(config)\n    model.inc_dataset = inc_dataset\n\n    return inc_dataset, model\n\n\ndef _set_global_parameters(config):\n    _set_seed(config[\"seed\"], config[\"threads\"], config[\"no_benchmark\"], config[\"detect_anomaly\"])\n    factory.set_device(config)\n\n\ndef _set_seed(seed, nb_threads, no_benchmark, detect_anomaly):\n    logger.LOGGER.info(\"Set seed {}\".format(seed))\n    random.seed(seed)\n    np.random.seed(seed)\n    torch.manual_seed(seed)\n    torch.cuda.manual_seed_all(seed)\n    if no_benchmark:\n        logger.LOGGER.warning(\"CUDA algos are not determinists but faster!\")\n    else:\n        logger.LOGGER.warning(\"CUDA algos are determinists but very slow!\")\n    torch.backends.cudnn.deterministic = not no_benchmark  # This will slow down training.\n    torch.set_num_threads(nb_threads)\n    if detect_anomaly:\n        logger.LOGGER.info(\"Will detect autograd anomaly.\")\n        torch.autograd.set_detect_anomaly(detect_anomaly)\n\n\ndef _set_up_options(args):\n    options_paths = args[\"options\"] or []\n\n    autolabel = []\n    for option_path in options_paths:\n        if not os.path.exists(option_path):\n            raise IOError(\"Not found options file {}.\".format(option_path))\n\n        args.update(_parse_options(option_path))\n\n        autolabel.append(os.path.splitext(os.path.basename(option_path))[0])\n\n    return \"_\".join(autolabel)\n\n\ndef _parse_options(path):\n    with open(path) as f:\n        if path.endswith(\".yaml\") or path.endswith(\".yml\"):\n            return yaml.load(f, Loader=yaml.FullLoader)\n        elif path.endswith(\".json\"):\n            return json.load(f)[\"config\"]\n        else:\n            raise Exception(\"Unknown file type {}.\".format(path))\n\n\n# ----\n# Misc\n# ----\n\n\ndef _aggregate_results(list_results):\n    res = str(round(statistics.mean(list_results) * 100, 2))\n    if len(list_results) > 1:\n        res = res + \" +\/- \" + str(round(statistics.stdev(list_results) * 100, 2))\n    return res\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_255","text":"'''\nviewprobe creates visualizations for a certain eval.\n'''\n\nimport glob\nimport os\nimport numpy\nimport re\nimport upsample\nimport time\nimport loadseg\nfrom scipy.misc import imread, imresize, imsave\nfrom loadseg import normalize_label\nimport expdir\n\nclass NetworkProbe:\n    def __init__(self, directory, blobs=None):\n        self.ed = expdir.ExperimentDirectory(directory)\n        # Load probe metadata\n        info = self.ed.load_info()\n        self.ih, self.iw = info.input_dim\n        self.layers = info.blobs if blobs is None else blobs\n        self.ds = loadseg.SegmentationData(info.dataset)\n        self.layer = {}\n        for blob in self.layers:\n            self.layer[blob] = LayerProbe(self.ed, blob, self.ds)\n\n    def score_tally_stats(self, layer, verbose=False):\n        # First, score every unit\n        if verbose:\n            print 'Adding tallys of unit\/label alignments.'\n            sys.stdout.flush()\n        ta, tg, ti = self.summarize_tally(layer)\n        labelcat = onehot(primary_categories_per_index(self.ds))\n        tc = np.count_act_with_labelcat(layer)\n        # If we were doing per-category activations p, then:\n        # c = numpy.dot(p, labelcat.transpose())\n        epsilon = 1e-20 # avoid division-by-zero\n        # If we were counting activations on non-category examples then:\n        # iou = i \/ (a[:,numpy.newaxis] + g[numpy.newaxis,:] - i + epsilon)\n        iou = ti \/ (tc + tg[numpy.newaxis,:] - ti + epsilon)\n        # Let's tally by primary-category.\n        pc = primary_categories_per_index(self.ds)\n        categories = self.ds.category_names()\n        ar = numpy.arange(iou.shape[1])\n        # actually - let's get the top iou for every category\n        pciou = numpy.array([iou * (pc[ar] == ci)[numpy.newaxis,:]\n                for ci in range(len(categories))])\n        # label_iou = iou.argmax(axis=1)\n        label_pciou = pciou.argmax(axis=2)\n        # name_iou = [self.ds.name(None, i) for i in label_iou]\n        name_pciou = [\n                [self.ds.name(None, j) for j in label_pciou[ci]]\n                for ci in range(len(label_pciou))]\n        # score_iou = iou[numpy.arange(iou.shape[0]), label_iou]\n        score_pciou = pciou[\n                numpy.arange(pciou.shape[0])[:,numpy.newaxis],\n                numpy.arange(pciou.shape[1])[numpy.newaxis,:],\n                label_pciou]\n        bestcat_pciou = score_pciou.argsort(axis=0)[::-1]\n        # Assign category for each label\n        # cat_per_label = primary_categories_per_index(self.ds)\n        # cat_iou = [categories[cat_per_label[i]] for i in label_iou]\n        # Now sort units by score and visulize each one\n        return bestcat_pciou, name_pciou, score_pciou, label_pciou, tc, tg, ti\n\n    def generate_html_summary(self, layer,\n            imsize=64, imcount=16, imscale=None, tally_stats=None,\n            gridwidth=None, verbose=False):\n        print 'Generating html summary', (\n            self.ed.filename(['html', '%s.html' % expdir.fn_safe(layer)]))\n        # Grab tally stats\n        bestcat_pciou, name_pciou, score_pciou, _, _, _, _ = (tally_stats)\n        if verbose:\n            print 'Sorting units by score.'\n            sys.stdout.flush()\n        if imscale is None:\n            imscale = imsize\n        categories = self.ds.category_names()\n        ordering = score_pciou.max(axis=0).argsort()[::-1]\n        top = self.max_act_indexes(layer, count=imcount)\n        self.ed.ensure_dir('html', 'image')\n        css = ('https:\/\/maxcdn.bootstrapcdn.com\/bootstrap\/latest' +\n               '\/css\/bootstrap.min.css')\n        html = ['<!doctype html>', '<html>', '<head>',\n                '<link rel=\"stylesheet\" href=\"%s\">' % css,\n                '<\/head>', '<body>', '<div class=\"container-fluid\">']\n        if gridwidth is None:\n            gridname = ''\n            gridwidth = imcount\n            gridheight = 1\n        else:\n            gridname = '-%d' % gridwidth\n            gridheight = (imcount + gridwidth - 1) \/\/ gridwidth\n        for unit in ordering:\n            if verbose:\n                print 'Visualizing %s unit %d' % (layer, unit)\n                sys.stdout.flush()\n            tiled = numpy.full(\n                ((imsize + 1) * gridheight - 1,\n                 (imsize + 1) * gridwidth - 1, 3), 255, dtype='uint8')\n            for x, index in enumerate(top[unit]):\n                row = x \/\/ gridwidth\n                col = x % gridwidth\n                vis = self.activation_visualization(layer, unit, index)\n                if vis.shape[:2] != (imsize, imsize):\n                    vis = imresize(vis, (imsize, imsize))\n                tiled[row*(imsize+1):row*(imsize+1)+imsize,\n                      col*(imsize+1):col*(imsize+1)+imsize,:] = vis\n            imfn = 'image\/%s%s-%04d.jpg' % (\n                    expdir.fn_safe(layer), gridname, unit)\n            imsave(self.ed.filename(os.path.join('html', imfn)), tiled)\n            labels = '; '.join(['%s (%s, %f)' %\n                    (name_pciou[c][unit], categories[c], score_pciou[c, unit])\n                    for c in bestcat_pciou[:,unit]])\n            html.extend([\n                '<h6>%s unit %d: %s<\/h6>' % (layer, unit + 1, labels),\n                '<img src=\"%s\" height=\"%d\">' % (os.path.join('html', imfn), imscale)\n                ])\n        html.extend([\n            '<\/div>', '<\/body>', '<\/html>', ''])\n        with open(self.ed.filename([\n                'html', '%s.html' % expdir.fn_safe(layer)]), 'w') as f:\n            f.write('\\n'.join(html))\n\n    def generate_csv_summary(\n            self, layer, csvfile, tally_stats, order=None, verbose=False):\n        if verbose:\n            print 'Generating csv summary', csvfile\n            sys.stdout.flush()\n        bestcat_pciou, name_pciou, score_pciou, label_pciou, tc, tg, ti = (\n                tally_stats)\n\n        # For each unit in a layer, outputs the following information:\n        # - label: best interpretation\n        # - object-label: top ranked interpretation for scene\/object\/color\/etc\n        # - object-truth: ground truth pixels\n        # - object-activation: activating pixels\n        # - object-intersect: intersecting pixels\n        # - object-iou: iou score\n        # - etc, for each category.\n        categories = self.ds.category_names()\n        csv_fields = sum([[\n            '%s-label' % cat,\n            '%s-truth' % cat,\n            '%s-activation' % cat,\n            '%s-intersect' % cat,\n            '%s-iou' % cat] for cat in categories],\n            ['unit', 'category', 'label', 'score'])\n\n        if order is not None:\n            csv_fields = order\n\n        if verbose:\n            print 'Sorting units by score.'\n            sys.stdout.flush()\n        ordering = score_pciou.max(axis=0).argsort()[::-1]\n        # top = self.max_act_indexes(layer, count=imcount)\n\n        import csv\n        with open(csvfile, 'w') as f:\n            writer = csv.DictWriter(open(csvfile, 'w'), csv_fields)\n            writer.writeheader()\n\n            for unit in ordering:\n                # Top images are top[unit]\n                bestcat = bestcat_pciou[0, unit]\n                data = {\n                   'unit': (unit + 1),\n                   'category': categories[bestcat],\n                   'label': name_pciou[bestcat][unit],\n                   'score': score_pciou[bestcat][unit]\n                }\n                for ci, cat in enumerate(categories):\n                    label = label_pciou[ci][unit]\n                    data.update({\n                        '%s-label' % cat: name_pciou[ci][unit],\n                        '%s-truth' % cat: tg[label],\n                        '%s-activation' % cat: tc[unit, label],\n                        '%s-intersect' % cat: ti[unit, label],\n                        '%s-iou' % cat: score_pciou[ci][unit]\n                    })\n                writer.writerow(data)\n\n    def generate_quantmat(self, layer, verbose=False):\n        if verbose:\n            print 'Generating quantmat'\n            sys.stdout.flush()\n        from scipy.io import savemat\n        lp = self.layer[layer]\n        filename = self.ed.filename(\n                'quant-%d.mat' % lp.quantdata.shape[1], blob=layer)\n        savemat(filename, { 'quantile': lp.quantdata })\n\n    def generate_imgmax(self, layer, verbose=False):\n        from scipy.io import savemat\n        imgmax = self.ed.open_mmap(blob=layer, part='imgmax', mode='w+',\n                shape = self.layer[layer].blobdata.shape[:2])\n        imgmax[...] = self.layer[layer].blobdata.max(axis=(2, 3))\n        self.ed.finish_mmap(imgmax)\n        # Also copy out to mat file\n        filename = self.ed.filename('imgmax.mat', blob=layer)\n        savemat(filename, { 'imgmax': imgmax })\n        # And cache\n        self.layer[layer].imgmax = imgmax\n\n    def instance_data(self, i, normalize=True):\n        record, shape = self.ds.resolve_segmentation(\n                self.ds.metadata(i), categories=None)\n        if normalize:\n            default_shape = (1, ) + shape\n            record = dict((cat, normalize_label(dat, default_shape))\n                    for cat, dat in record.items())\n        return record, shape\n\n    def top_image_indexes(self, layer, unit, count=10):\n        t = self.layer[layer].count_a[:,unit].argsort()[::-1]\n        return t[:count]\n\n    # Generates a mask at the \"lp.level\" quantile.\n    def activation_mask(self, layer, unit, index, shape=None):\n        if shape is None:\n             record, shape = self.instance_data(index)\n        sw, sh = shape\n        # reduction = int(round(self.iw \/ float(sw)))\n        lp = self.layer[layer]\n        blobdata = lp.blobdata\n        fieldmap = lp.fieldmap\n        quantdata = lp.quantdata\n        threshold = quantdata[unit, int(round(quantdata.shape[1] * lp.level))]\n        up = upsample.upsampleL(\n                fieldmap, blobdata[index:index+1, unit],\n                shape=(self.ih, self.iw), scaleshape=(sh, sw))[0]\n        mask = up > threshold\n        return mask\n\n    # Makes an iamge using the mask\n    def activation_visualization(self, layer, unit, index, alpha=0.2):\n        image = imread(self.ds.filename(index))\n        mask = self.activation_mask(layer, unit, index, shape=image.shape[:2])\n        return (mask[:, :, numpy.newaxis] * (1 - alpha) + alpha) * image\n\n    def summarize_tally(self, layer):\n        cat_count = len(self.ds.category_names())\n        tally = self.layer[layer].tally\n        unit_size = self.layer[layer].shape[1]\n        label_size = self.ds.label_size()\n        count = numpy.zeros(\n                (unit_size + 1, label_size + 1 + cat_count), dtype='int64')\n        for i in range(len(tally)):\n            t = tally[i]\n            count[t[:,0]+1, t[:,1]+1+cat_count] += t[:,2]\n        # count_a.shape = (unit size,)\n        count_a = count[1:,cat_count]\n        # this would summarize category intersections if we tallied them\n        # count_c.shape = (unit_size, cat_size)\n        # count_c = count[1:,0:cat_count]\n        # count_g.shape = (label_size,)\n        count_g = count[0,1+cat_count:]\n        # count_i.shape = (unit_size, label_size)\n        count_i = count[1:,1+cat_count:]\n        # return count_a, count_c, count_g, count_i\n        return count_a, count_g, count_i\n\n    def count_act_with_label(self, layer):\n        # Because our dataaset is sparse, instead of using count_a to count\n        # all activations, we can compute count_act_with_label to count\n        # activations only within those images which contain an instance\n        # of a given label.\n        tally = self.layer[layer].tally\n        unit_size = self.layer[layer].shape[1]\n        label_size = self.ds.label_size()\n        count = numpy.zeros((unit_size, label_size), dtype='int64')\n        for i in range(len(tally)):\n            c1 = numpy.zeros((unit_size + 1, label_size + 1), dtype='int64')\n            t = tally[i]\n            c1[t[:,0]+1, t[:,1]+1] = t[:,2]\n            count += c1[1:,0][:,numpy.newaxis] * (c1[0,1:][numpy.newaxis] > 0)\n        return count\n\n    def count_act_with_labelcat(self, layer):\n        # Because our dataaset is sparse, instead of using count_a to count\n        # all activations, we can compute count_act_with_labelcat to count\n        # activations only within those images which contain an instance\n        # of a given label category.\n        labelcat = onehot(primary_categories_per_index(self.ds))\n        # Be sure to zero out the background label - it belongs to no category.\n        labelcat[0,:] = 0\n        tally = self.layer[layer].tally\n        unit_size = self.layer[layer].shape[1]\n        label_size = self.ds.label_size()\n        count = numpy.zeros((unit_size, labelcat.shape[1]), dtype='int64')\n        for i in range(len(tally)):\n            c1 = numpy.zeros((unit_size + 1, label_size + 1), dtype='int64')\n            t = tally[i]\n            c1[t[:,0]+1, t[:,1]+1] = t[:,2]\n            count += c1[1:,0][:,numpy.newaxis] * (\n                    numpy.dot(c1[0,1:], labelcat) > 0)\n        # retval: (unit_size, label_size)\n        return numpy.dot(count, numpy.transpose(labelcat))\n\n    def max_act_indexes(self, layer, count=10):\n        max_per_image = self.layer[layer].imgmax\n        return max_per_image.argsort(axis=0)[:-1-count:-1,:].transpose()\n\n    def top_act_indexes(self, layer, count=10):\n        tally = self.layer[layer].tally\n        unit_size = self.layer[layer].shape[1]\n        label_size = self.ds.label_size()\n        all_acts = numpy.zeros((len(tally), unit_size), dtype='int64')\n        for i in range(len(tally)):\n            acts = numpy.zeros((unit_size + 1, 2), dtype='int32')\n            t = tally[i]\n            acts[t[:,0] + 1, (t[:,1] != -1).astype('int')] = t[:,2]\n            all_acts[i] = acts[1:,0]\n        return all_acts.argsort(axis=0)[:-1-count:-1,:].transpose()\n\nclass LayerProbe:\n    def __init__(self, ed, blob, ds):\n        info = ed.load_info(blob=blob)\n        self.shape = info.shape\n        self.fieldmap = info.fieldmap\n        # Load the raw activation data\n        if ed.has_mmap(blob=blob):\n            self.blobdata = ed.open_mmap(blob=blob, shape=self.shape, mode='r')\n        # Load the blob quantile data and grab thresholds\n        if ed.has_mmap(blob=blob, part='quant-*'):\n            self.quantdata = ed.open_mmap(blob=blob, part='quant-*',\n                                shape=(self.shape[1], -1), mode='r')\n        # Load tally too; tally_depth is inferred from file size.\n        self.tally = ed.open_mmap(blob=blob, part='tally-*', decimal=True,\n                shape=(ds.size(), -1, 3), dtype='int32', mode='r')\n        # And load imgmax\n        if ed.has_mmap(blob=blob, part='imgmax'):\n            self.imgmax = ed.open_mmap(blob=blob, part='imgmax',\n                    shape=(ds.size(), self.shape[1]), mode='r')\n        # Figure out tally level that was used.\n        self.level = ed.glob_number(\n                'tally-*.mmap', blob=blob, decimal=True)\n\ndef primary_categories_per_index(ds, categories=None):\n    '''\n    Returns an array of primary category numbers for each label, where the\n    first category listed in ds.category_names is given category number 0.\n    '''\n    if categories is None:\n        categories = ds.category_names()\n    catmap = {}\n    for cat in categories:\n        imap = ds.category_index_map(cat)\n        if len(imap) < ds.label_size(None):\n            imap = numpy.concatenate((imap, numpy.zeros(\n                ds.label_size(None) - len(imap), dtype=imap.dtype)))\n        catmap[cat] = imap\n    result = []\n    for i in range(ds.label_size(None)):\n        maxcov, maxcat = max(\n                (ds.coverage(cat, catmap[cat][i]) if catmap[cat][i] else 0, ic)\n                for ic, cat in enumerate(categories))\n        result.append(maxcat)\n    return numpy.array(result)\n\ndef onehot(arr, minlength=None):\n    '''\n    Expands an array of integers in one-hot encoding by adding a new last\n    dimension, leaving zeros everywhere except for the nth dimension, where\n    the original array contained the integer n.  The minlength parameter is\n    used to indcate the minimum size of the new dimension.\n    '''\n    length = numpy.amax(arr) + 1\n    if minlength is not None:\n        length = max(minlength, length)\n    result = numpy.zeros(arr.shape + (length,))\n    result[list(numpy.indices(arr.shape)) + [arr]] = 1\n    return result\n\nif __name__ == '__main__':\n    import argparse\n    import sys\n    import traceback\n\n    try:\n        parser = argparse.ArgumentParser(\n            description='Generate visualization for probed activation data.')\n        parser.add_argument(\n                '--directory',\n                default='.',\n                help='output directory for the net probe')\n        parser.add_argument(\n                '--format',\n                default='html',\n                help='html or csv or both')\n        parser.add_argument(\n                '--csvorder',\n                help='csv header order')\n        parser.add_argument(\n                '--blobs',\n                nargs='*',\n                help='network blob names to visualize')\n        parser.add_argument(\n                '--gridwidth',\n                type=int, default=None,\n                help='width of visualization grid')\n        parser.add_argument(\n                '--imsize',\n                type=int, default=72,\n                help='thumbnail dimensions')\n        parser.add_argument(\n                '--imscale',\n                type=int, default=None,\n                help='thumbnail dimensions')\n        parser.add_argument(\n                '--imcount',\n                type=int, default=16,\n                help='number of thumbnails to include')\n        args = parser.parse_args()\n        np = NetworkProbe(args.directory, blobs=args.blobs)\n        for blob in args.blobs:\n            formats = args.format.split(',')\n            if 'imgmax' in formats:\n                np.generate_imgmax(blob)\n            if 'html' in formats or 'csv' in formats:\n                tally_stats = np.score_tally_stats(blob, verbose=True)\n            if 'html' in formats:\n                np.generate_html_summary(blob,\n                        imsize=args.imsize, imscale=args.imscale,\n                        imcount=args.imcount, tally_stats=tally_stats,\n                        gridwidth=args.gridwidth,\n                        verbose=True)\n            if 'csv' in formats:\n                filename = os.path.join(args.directory,\n                        '%s-result.csv' % expdir.fn_safe(blob))\n                np.generate_csv_summary(blob, filename, tally_stats,\n                        order=(args.csvorder.split(',')\n                            if args.csvorder else None), verbose=True)\n            if 'quantmat' in formats:\n                np.generate_quantmat(blob, verbose=True)\n    except:\n        traceback.print_exc(file=sys.stdout)\n        sys.exit(1)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_254","text":"#============================================================================\r\n# Copyright (c) 2018 <NAME>. All rights reserved.\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#============================================================================\r\n# Author: <NAME>\r\n# E-mail: <EMAIL>\r\n# Description: Improvements of stripe artifact removal methods:\r\n# [1] <NAME>, <NAME>, and <NAME>, \"Superior techniques\r\n#     for eliminating ring artifacts in X-ray micro-tomography,\" Optics\r\n#     Express 26, 28396-28412 (2018). https:\/\/doi.org\/10.1364\/OE.26.028396.\r\n# [2] <NAME>, <NAME>, and <NAME>,\"Preprocessing techniques\r\n#     for removing artifacts in synchrotron-based tomographic images,\"\r\n#     Proc. SPIE 11113, Developments in X-Ray Tomography XII.\r\n#     https:\/\/doi.org\/10.1117\/12.2530324.\r\n# Publication date: 09th October 2019\r\n#============================================================================\r\n\r\n\"\"\"\r\nModule for stripe removal methods proposed in:\r\nhttps:\/\/doi.org\/10.1117\/12.2530324\r\n\"\"\"\r\n\r\nimport numpy as np\r\nfrom scipy import interpolate\r\nfrom scipy.signal.windows import gaussian\r\nfrom scipy.ndimage import median_filter\r\nfrom scipy.ndimage import binary_dilation\r\n# import scipy.fftpack as fft\r\nimport pyfftw.interfaces.scipy_fftpack as fft\r\n\r\nfrom sarepy.prep.stripe_removal_original import remove_stripe_based_sorting\r\nfrom sarepy.prep.stripe_removal_original import remove_stripe_based_fitting\r\nfrom sarepy.prep.stripe_removal_original import apply_gaussian_filter\r\nfrom sarepy.prep.stripe_removal_original import detect_stripe\r\n\r\n\r\ndef remove_stripe_based_filtering_sorting(sinogram, sigma, size, dim=1):\r\n    \"\"\"\r\n    Removing stripes using the filtering and sorting technique, combination of\r\n    algorithm 2 and algorithm 3 in Ref.[1]. Angular direction is along the axis 0.\r\n\r\n    Parameters\r\n    ----------\r\n    sinogram : array_like\r\n        2D array. Sinogram image.\r\n    sigma : int\r\n        Sigma of the Gaussian window used to separate the low-pass and\r\n        high-pass components of the intensity profile of each column.\r\n    size : int\r\n        Window size of the median filter.\r\n    dim : {1, 2}, optional\r\n        Dimension of the window.\r\n\r\n    Returns\r\n    -------\r\n    ndarray\r\n        2D array. Stripe-removed sinogram.\r\n\r\n    References\r\n    ----------\r\n    .. [1] https:\/\/doi.org\/10.1364\/OE.26.028396\r\n    \"\"\"\r\n    pad = min(150, int(0.1 * sinogram.shape[0]))\r\n    sinogram = np.transpose(sinogram)\r\n    sino_pad = np.pad(sinogram, ((0, 0), (pad, pad)), mode='reflect')\r\n    (_, ncol) = sino_pad.shape\r\n    window = gaussian(ncol, std=sigma)\r\n    list_sign = np.power(-1.0, np.arange(ncol))\r\n    sino_smooth = np.copy(sinogram)\r\n    for i, sino_1d in enumerate(sino_pad):\r\n        sino_smooth[i] = np.real(\r\n            fft.ifft(fft.fft(sino_1d * list_sign) * window) * list_sign)[pad:ncol - pad]\r\n    sino_sharp = sinogram - sino_smooth\r\n    sino_smooth_cor = np.transpose(\r\n        remove_stripe_based_sorting(np.transpose(sino_smooth), size, dim))\r\n    return np.transpose(sino_smooth_cor + sino_sharp)\r\n\r\n\r\ndef remove_stripe_based_sorting_fitting(sinogram, order, sigmax, sigmay):\r\n    \"\"\"\r\n    Remove stripes using the sorting and fitting technique, combination of\r\n    algorithm 2 and 1 in Ref. [1]. Angular direction is along the axis 0.\r\n\r\n    Parameters\r\n    ----------\r\n    sinogram : array_like\r\n        2D array. Sinogram image.\r\n    order : int\r\n        Polynomial fit order.\r\n    sigmax : int\r\n        Sigma of the Gaussian window in the x-direction.\r\n    sigmay : int\r\n        Sigma of the Gaussian window in the y-direction.\r\n\r\n    Returns\r\n    -------\r\n    ndarray\r\n        2D array. Stripe-removed sinogram.\r\n\r\n    References\r\n    ----------\r\n    .. [1] https:\/\/doi.org\/10.1364\/OE.26.028396\r\n    \"\"\"\r\n    sinogram = np.transpose(sinogram)\r\n    (nrow, ncol) = sinogram.shape\r\n    list_index = np.arange(0.0, ncol, 1.0)\r\n    mat_index = np.tile(list_index, (nrow, 1))\r\n    mat_comb = np.asarray(np.dstack((mat_index, sinogram)))\r\n    mat_sort = np.asarray(\r\n        [row[row[:, 1].argsort()] for row in mat_comb])\r\n    sino_sort = mat_sort[:, :, 1]\r\n    sino_cor = np.transpose(\r\n        remove_stripe_based_fitting(np.transpose(sino_sort), order, sigmax, sigmay))\r\n    mat_sort[:, :, 1] = sino_cor\r\n    mat_sort_back = np.asarray(\r\n        [row[row[:, 0].argsort()] for row in mat_sort])\r\n    return np.transpose(mat_sort_back[:, :, 1])\r\n\r\n\r\ndef remove_stripe_based_2d_filtering_sorting(sinogram, sigma, size, dim=1):\r\n    \"\"\"\r\n    Remove stripes using a 2D low-pass filter and the sorting-based technique,\r\n    algorithm in section 3.3.4 in Ref. [1]. Angular direction is along the axis 0.\r\n\r\n    Parameters\r\n    ---------\r\n    sinogram : array_like\r\n        2D array. Sinogram image.\r\n    sigma : int\r\n        Sigma of the Gaussian window.\r\n    size : int\r\n        Window size of the median filter.\r\n    dim : {1, 2}, optional\r\n        Dimension of the window.\r\n\r\n    Returns\r\n    -------\r\n    ndarray\r\n         2D array. Stripe-removed sinogram.\r\n\r\n    References\r\n    ----------\r\n    .. [1] https:\/\/doi.org\/10.1117\/12.2530324\r\n    \"\"\"\r\n    pad = min(150, int(0.1 * sinogram.shape[0]))\r\n    sino_smooth = apply_gaussian_filter(sinogram, sigma, sigma, pad)\r\n    sino_sharp = sinogram - sino_smooth\r\n    sino_cor = remove_stripe_based_sorting(sino_sharp, size, dim)\r\n    return sino_smooth + sino_cor\r\n\r\n\r\ndef remove_stripe_based_interpolation(sinogram, snr, size, drop_ratio=0.1, norm=True):\r\n    \"\"\"\r\n    Combination of algorithm 4, 5, and 6 in Ref. [1].\r\n    Remove stripes using a detection technique and an interpolation method.\r\n    Angular direction is along the axis 0.\r\n\r\n    Parameters\r\n    ----------\r\n    sinogram : array_like\r\n        2D array. Sinogram image\r\n    snr : float\r\n        Ratio used to segment between useful information and noise.\r\n    size : int\r\n        Window size of the median filter used to detect stripes.\r\n    drop_ratio : float, optional\r\n        Ratio of pixels to be dropped, which is used to to reduce\r\n        the possibility of the false detection of stripes.\r\n    norm : bool, optional\r\n        Apply normalization if True.\r\n\r\n    Returns\r\n    -------\r\n    ndarray\r\n        2D array. Stripe-removed sinogram.\r\n\r\n    References\r\n    ----------\r\n    .. [1] https:\/\/doi.org\/10.1364\/OE.26.028396\r\n    \"\"\"\r\n    drop_ratio = np.clip(drop_ratio, 0.0, 0.8)\r\n    sinogram = np.copy(sinogram)\r\n    (nrow, ncol) = sinogram.shape\r\n    ndrop = int(0.5 * drop_ratio * nrow)\r\n    sino_sort = np.sort(sinogram, axis=0)\r\n    sino_smooth = median_filter(sino_sort, (1, size))\r\n    list1 = np.mean(sino_sort[ndrop:nrow - ndrop], axis=0)\r\n    list2 = np.mean(sino_smooth[ndrop:nrow - ndrop], axis=0)\r\n    list_fact = np.divide(list1, list2,\r\n                          out=np.ones_like(list1), where=list2 != 0)\r\n    list_mask = detect_stripe(list_fact, snr)\r\n    list_mask = np.float32(binary_dilation(list_mask, iterations=1))\r\n    mat_fact = np.tile(list_fact, (nrow, 1))\r\n    if norm is True:\r\n        sinogram = sinogram \/ mat_fact\r\n    list_mask[0:2] = 0.0\r\n    list_mask[-2:] = 0.0\r\n    listx = np.where(list_mask < 1.0)[0]\r\n    listy = np.arange(nrow)\r\n    matz = sinogram[:, listx]\r\n    finter = interpolate.interp2d(listx, listy, matz, kind='linear')\r\n    listx_miss = np.where(list_mask > 0.0)[0]\r\n    if len(listx_miss) > 0:\r\n        sinogram[:, listx_miss] = finter(listx_miss, listy)\r\n    return sinogram\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_289","text":"<reponame>uluturki\/Mathematics-of-Epidemics-on-Networks<filename>docs\/examples\/fig1p2.py\nimport EoN\nimport networkx as nx\nfrom matplotlib import rc\nimport matplotlib.pylab as plt\n\n\nimport scipy\nimport random\n\n\n\ncolors = ['#5AB3E6','#FF2000','#009A80','#E69A00', '#CD9AB3', '#0073B3',\n        '#F0E442']\n\n#commands to make legend be in LaTeX font\n#rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})\nrc('text', usetex=True)\n\n\n\nrho = 0.025\ntarget_k = 6\n#Ns=[10000]#, 1000000]\nN=10000\ntau = 0.5\ngamma = 1.\nts = scipy.arange(0,40,0.05)\ncount = 50 #number of simulations to run for each\n\n\n\ndef generate_network(Pk, N, ntries = 100):\n    r'''Generates an N-node random network whose degree distribution is given by Pk'''\n    counter = 0\n    while counter< ntries:\n        counter += 1\n        ks = []\n        for ctr in range(N):\n            ks.append(Pk())\n        if sum(ks)%2 == 0:\n            break\n    if sum(ks)%2 ==1:\n        raise EoN.EoNError(\"cannot generate even degree sum\")\n    G = nx.configuration_model(ks)\n    return G\n \n\n\n#An erdos-renyi network has a Poisson degree distribution.\ndef PkPoisson():\n    return scipy.random.poisson(target_k)\ndef PsiPoisson(x):\n    return scipy.exp(-target_k*(1-x))\ndef DPsiPoisson(x):\n    return target_k*scipy.exp(-target_k*(1-x))\n    \n    \n    \n#a regular (homogeneous) network has a simple generating function.\n\ndef PkHomogeneous():\n    return target_k\ndef PsiHomogeneous(x):\n    return x**target_k\ndef DPsiHomogeneous(x):\n    return target_k*x**(target_k-1)\n\n\n\n\n#The following 30 - 40 lines or so are devoted to defining the degree distribution\n#and the generating function of the truncated power law network.\n\n#defining the power law degree distribution here:\nassert(target_k==6) #if you've changed target_k, then you'll\n                   #want to update the range 1..61 and\/or \n                   #the exponent 1.5.\n\nPlPk = {}\nexponent = 1.5\nkave = 0\nfor k in range(1,61):\n    PlPk[k]=k**(-exponent)\n    kave += k*PlPk[k]\n   \nnormfactor= sum(PlPk.values())\nfor k in PlPk:\n    PlPk[k] \/= normfactor\n\ndef PkPowLaw(): \n    r = random.random()\n    for k in PlPk:\n        r -= PlPk[k]\n        if r<0:\n            return k\n\ndef PsiPowLaw(x):\n    #print PlPk\n    rval = 0\n    for k in PlPk:\n        rval += PlPk[k]*x**k\n    return rval\n\ndef DPsiPowLaw(x):\n    rval = 0\n    for k in PlPk:\n        rval += k*PlPk[k]*x**(k-1)\n    return rval\n#End of power law network properties.   \n \n \n \n \n\ndef process_degree_distribution(N, Pk, color, Psi, DPsi, symbol, label, count):\n    report_times = scipy.linspace(0,30,3000)\n    sums = 0*report_times\n    for cnt in range(count):\n        G = generate_network(Pk, N)\n        t, S, I, R = EoN.fast_SIR(G, tau, gamma, rho=rho)\n        plt.plot(t, I*1.\/N, '-', color = color, \n                                alpha = 0.1, linewidth=1)\n        subsampled_I = EoN.subsample(report_times, t, I)\n        sums += subsampled_I*1.\/N\n    ave = sums\/count\n    plt.plot(report_times, ave, color = 'k')\n    \n    #Do EBCM    \n    N= G.order()#N is arbitrary, but included because our implementation of EBCM assumes N is given.\n    t, S, I, R = EoN.EBCM_uniform_introduction(N, Psi, DPsi, tau, gamma, rho, tmin=0, tmax=10, tcount = 41)\n    plt.plot(t, I\/N, symbol, color = color, markeredgecolor='k', label=label)\n\n    for cnt in range(3):  #do 3 highlighted simulations\n        G = generate_network(Pk, N)\n        t, S, I, R = EoN.fast_SIR(G, tau, gamma, rho=rho)\n        plt.plot(t, I*1.\/N, '-', color = 'k', linewidth=0.1)\n\n\n\n\nplt.figure(figsize=(8,4))\n    \n    \n\n#Powerlaw\nprocess_degree_distribution(N, PkPowLaw, colors[3], PsiPowLaw, DPsiPowLaw, 'd', r'Truncated Power Law', count)\n\n#Poisson\nprocess_degree_distribution(N, PkPoisson, colors[0], PsiPoisson, DPsiPoisson, '^', r'Erd\\H{o}s--R\\'{e}nyi', count)\n\n#Homogeneous\nprocess_degree_distribution(N, PkHomogeneous, colors[2], PsiHomogeneous, DPsiHomogeneous, 's', r'Homogeneous', count)\n\nplt.xlabel(r'$t$', fontsize=12)\nplt.ylabel(r'Proportion infected', fontsize=12)\nplt.legend(loc = 'upper right', numpoints = 1)\n\nplt.axis(xmax=10, xmin=0, ymin=0)\nplt.savefig('fig1p2.png')\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_290","text":"<gh_stars>0\nfrom sympy import Rational as frac\nfrom sympy import sqrt\n\nfrom ..helpers import article, untangle\nfrom ._helpers import HexahedronScheme, fs_r00, fs_rr0, fs_rrs\n\ncitation = article(\n    authors=[\"<NAME>\"],\n    title=\"A Formula for Approximate Computation of a Triple Integral\",\n    journal=\"The American Mathematical Monthly\",\n    volume=\"47\",\n    number=\"8\",\n    month=\"oct\",\n    year=\"1940\",\n    pages=\"539-543\",\n    url=\"https:\/\/doi.org\/10.2307\/2303834\",\n)\n\n\ndef sadowsky():\n    data = [\n        (frac(91, 450), fs_r00(1)),\n        (frac(-20, 225), fs_rr0(1)),\n        (frac(8, 225), fs_rrs(sqrt(frac(5, 8)), 1)),\n    ]\n    points, weights = untangle(data)\n    weights *= 8\n    return HexahedronScheme(\"Sadowsky\", weights, points, 5, citation)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_291","text":"<reponame>irxat\/geoist<filename>geoist\/inversion\/pfmodel_ts.py\nimport pathlib\nfrom datetime import datetime\nfrom functools import wraps\nimport numpy as np\nfrom scipy import linalg as splin\nfrom scipy import sparse as spsparse\nfrom scipy.optimize import minimize\nimport pandas as pd\n\nfrom geoist import gridder\nfrom geoist.pfm import prism,tesseroid\nfrom geoist.inversion.mesh import PrismMesh,TesseroidMesh\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import ImageGrid\n\nprint_level = -1 # control indentation of prints.\nlast_print_level = -2\n\n# A helper decorator print time consumption of f.\ndef timeit(f):\n    @wraps(f)\n    def wrap(*args,**kwargs):\n        global print_level\n        global last_print_level\n        print_level += 1\n        if print_level == last_print_level:\n            print('')\n        print(' '*4*print_level+'calling {}'.format(f.__name__))\n        st = datetime.now()\n        res = f(*args,**kwargs)\n        ed = datetime.now()\n        print(' '*4*print_level+'{} completed in {}'.format(f.__name__,ed-st))\n        last_print_level = print_level\n        print_level -= 1\n        return res\n    return wrap\n\nclass SmoothOperator:\n    def __init__(self):\n        self.axis = {'tzyx':{'x':-1,'y':-2,'z':-3,'t':-4},\n                     'txyz':{'t':-4,'x':-3,'y':-2,'z':-1}}\n\n    def derivation(self,v,component='dx',array_order='tzyx'):\n        for axis_i in component[1:]:\n            slices = [slice(None)]*v.ndim\n            slices[self.axis[array_order][axis_i]] = slice(-1,None,-1)\n            v = np.diff(v[tuple(slices)],axis=self.axis[array_order][axis_i])[tuple(slices)]\n        return v\n\n    def rderivation(self,v,component='dx',array_order='tzyx'):\n        for axis_i in component[-1:0:-1]:\n            slices = [slice(None)]*v.ndim\n            slices[self.axis[array_order][axis_i]] = 0\n            shape = list(v.shape)\n            shape[self.axis[array_order][axis_i]] = 1\n            prepend=np.zeros_like(v[tuple(slices)].reshape(tuple(shape)))\n            append=np.zeros_like(v[tuple(slices)].reshape(tuple(shape)))\n            v = np.diff(v,\n                       axis=self.axis[array_order][axis_i],\n                       prepend=prepend,\n                       append=append)\n        return v\n\nclass AbicLSQOperatorMS:\n    '''An operator doing matrix vector multiplication. The matrix is:\n        $\\alpha_g G^TG + \\sum \\alpha_i B_i^TB_i$. Where $\\alpha$'s are\n        weights, $G$ is kernel matrix, $B_i$'s are smooth matrix.\n    Args:\n        kernel_matrix (list of ndarray): kernel matrix of each survey\n        ns (int): number of surveys\n        nzyx (tuple of int): number of cells along z-axis, y-axis and x-axis\n        smmoth_components (list of str): which components should be smoothed, acceptable\n            string could be 'dx','dxx','dy','dyy','dxy','dt',...\n        weights (dict): name and values of weights.\n    '''\n    def __init__(self,\n                 kernel_matrices,\n                 ns,\n                 nzyx,\n                 smooth_components=set(),\n                 weights=None):\n        self.kernel_matrices = kernel_matrices\n        self.ns = ns\n        self.nz,self.ny,self.nx = nzyx\n        self.shape = (self.ns*self.ny*self.nx,self.ns*self.ny*self.nx)\n        self.weights = weights\n        self.smooth_components = smooth_components\n        self.smop = SmoothOperator()\n        if self.weights is None:\n            self.weights = {'bound':1,'obs':1,'dx':1,'dy':1,'dt':1, 'refer':1}\n\n    def matvec(self,v):\n        tmp = np.zeros_like(v)\n        v = v.reshape(self.ns,-1)\n        for i,k in enumerate(self.kernel_matrices):\n            tmp[i*self.ny*self.nx:(i+1)*self.ny*self.nx] = self.weights['obs'] * (k.T @ (k @ v[i]))\n        if 'refer' in self.weights.keys():\n            tmp += self.weights['refer']*v.ravel()\n        for key in self.smooth_components:\n            tmp2 = v.reshape(self.ns,self.nz,self.ny,self.nx)\n            tmp2 = self.smop.derivation(tmp2,component=key)\n            tmp2 = self.smop.rderivation(tmp2,component=key)\n            tmp += self.weights[key]*tmp2.ravel()\n        return tmp\n\nclass InvModelTS:\n    '''Multiple survey gravity inversion use Abic\n    Args:\n        nyx (tuple of int): number of cells along y-axis and x-axis\n        smooth_components (list of str): which components should be smoothed, acceptable\n            string could be 'dx','dxx','dy','dyy','dxy','dt',...\n        weights (dict): name and values of weights.\n        optimize_weights (list of str): specify which weight should be optimized by Abic.\n        source_volume (tuple of float): dimension of the underlying gravity source.\n        margin (tuple of float): margin size around the source volume.\n        cell_type (str): either 'prism' or 'Tesseroid'\n        data_dir (str): a folder where observation data resides\n    Attributes:\n        ns (int): number of surveys\n        nx,ny,nz (int): number of cells along x-axis, y-axis and z-axis\n        source_volume (tuple of float): dimension of the underlying gravity source\n        margin (tuple of float): margin size around the source volume.\n        cell_type (str): either 'prism' or 'Tesseroid'\n        smooth_components (list of str): which components should be smoothed\n        weights (dict): name and values of weights.\n        optimize_weights (list of str): specify which weight should be optimized by Abic.\n        data_dir (str): a folder where observation data resides\n        abic_val (float): abic value\n        log_total_det_val (float): log determinate value of the total matrix\n        log_obs_det_val (float): log determinate value of the observation matrix\n        min_u_val (float): minimum of U\n        min_density (float): minimum density\n        max_density (float): maximum density\n        kernel_matrices (list of ndarray): kernels of each survey.\n        rhs (ndarray): right hand side when solve min_u\n        solution (ndarray): model densityies solve min_u\n        abic_log (dict): save the weights and abic value during calculation\n        orig_data (DataFrame): original data loaded from files.\n        mesh (Mesh): mesh of the underlying density model.\n        R (float): radius of the Earth (m)\n    '''\n    def __init__(self,\n                 nyx=(20,20),\n                 smooth_components=None,\n                 weights=None,\n                 optimize_weights=None,\n                 source_volume=None,\n                 margin=(0,0,0,0),\n                 cell_type='prism',\n                 data_dir='.\/data'):\n        self.ny,self.nx = nyx\n        self.nz = 1\n        self.data_dir = pathlib.Path(data_dir)\n        self.source_volume = source_volume\n        self.margin= margin\n        self.kernel_op = None\n        self.smooth_components = smooth_components\n        self._weights = weights\n        self.optimize_weights = optimize_weights\n        self.cell_type = cell_type.lower()\n        self.smop = SmoothOperator()\n        self.kernel_matrices = []\n        self.abic_val = 0\n        self.log_total_det_val = 0\n        self.log_prior_det_val = 0\n        self.log_obs_det_val = 0\n        self.min_u_val = 0\n        self.min_density = -1.0e4\n        self.max_density = 1.0e4\n        self._btb_exist = False\n        self._gtg_exist = False\n        self.abic_log = {'weights':[],'abic_val':[]}\n        self._abic_iter = 0\n        self.R = 6371000\n        self._keymap = None\n        self.orig_data = None\n\n    def load_data(self,pattern='*.txt',names=['lon','lat','g'],**kwargs):\n        ''' load all data inside data dir, result saved in self.orig_data.\n        Args:\n            pattern (str): filename pattern.\n            names (list of str): name of the observation must be 'g', coordinates\n                must be 'lon','lat' or 'x','y'\n            kwargs : same as pd.read_csv\n        '''\n        data_files = sorted(self.data_dir.glob(pattern))\n        self.ns = len(data_files)\n        if not kwargs:\n            kwargs = dict()\n            kwargs['delim_whitespace'] = True\n        if self.cell_type == 'prism':\n            self._keymap = ['x','y']\n        elif self.cell_type == 'tesseroid':\n            self._keymap = ['lon','lat']\n        orig_data = []\n        for i,data_file in enumerate(data_files):\n            df = pd.read_csv(data_file,names=names,**kwargs)\n            i_survey = np.zeros(len(df),dtype=int) + i\n            df['i_survey'] = i_survey\n            orig_data.append(df)\n        self.orig_data = pd.concat(orig_data)\n        self.orig_data['z'] = 0.0\n\n    def set_refer(self,refer_density):\n        self.refer_density = refer_density\n\n    def deg2xy(self):\n        dlon = self.orig_data.groupby('i_survey')['lon'].apply(lambda x: x-x.mean())\n        dlat = self.orig_data.groupby('i_survey')['lat'].apply(lambda x: x-x.mean())\n        x = dlat*self.R*np.pi\/180.\n        y = dlon*self.R*np.cos(self.orig_data['lat']*np.pi\/180.)*np.pi\/180.\n        self.orig_data['x'] = x\n        self.orig_data['y'] = y\n\n    @property\n    def weights(self):\n        return self._weights\n    @weights.setter\n    def weights(self,values):\n        self._weights = values\n        if not self.kernel_op is None:\n            self.kernel_op.weights = self._weights\n    @property\n    def nx(self):\n        return self._nx\n    @nx.setter\n    def nx(self,value):\n        self._nx = value\n        self._btb_exist = False\n        self._gtg_exist = False\n\n    @property\n    def ny(self):\n        return self._ny\n    @ny.setter\n    def ny(self,value):\n        self._ny = value\n        self._btb_exist = False\n        self._gtg_exist = False\n\n    @property\n    def smooth_components(self):\n        return self._smooth_components\n    @smooth_components.setter\n    def smooth_components(self,values):\n        self._smooth_components = values\n        if not self.kernel_op is None:\n            self.kernel_op.smooth_components = self._smooth_components\n\n    def _gen_source_volume(self,source_volume=None,margin=None):\n        if source_volume is None:\n            source_volume = list(self.source_volume)\n        fun_list = [min,max,min,max]\n        key_ind = [self._keymap[0],self._keymap[0],self._keymap[1],self._keymap[1]]\n        for i in range(4):\n            if source_volume[i] is None:\n                source_volume[i] = fun_list[i](self.orig_data[key_ind[i]])\n                source_volume[i] += margin[i]*(-1)**(i+1)\n        self.source_volume = source_volume\n\n    def gen_mesh(self,source_volume=None,margin=None):\n        shape = (self.nz, self.ny, self.nx)\n        if margin is None:\n            margin = self.margin\n        self._gen_source_volume(source_volume,margin)\n        if self.cell_type =='prism':\n            self.mesh = PrismMesh(self.source_volume, shape)\n        elif self.cell_type =='tesseroid':\n            self.mesh = TesseroidMesh(self.source_volume, shape)\n        else:\n            raise ValueError('cell_type must be \\'prism\\' or \\'tesseroid\\'!!')\n        density = np.ones(shape)*1.0e3\n        self.mesh.addprop('density', density.ravel())\n\n    def gen_obs_grid(self,height=-1):\n        \"\"\" generate obs grid\n         \"\"\"\n        obs_area = (self.source_volume[0]+0.5*self.mesh.dims[0],\n                         self.source_volume[1]-0.5*self.mesh.dims[0],\n                         self.source_volume[2]+0.5*self.mesh.dims[1],\n                         self.source_volume[3]-0.5*self.mesh.dims[1])\n        obs_shape = (self.nx, self.ny)\n        return gridder.regular(obs_area, obs_shape, z=height)\n\n    def gen_kernel(self):\n        self.kernel_matrices = []\n        if self.cell_type == 'prism':\n            for i in range(self.ns):\n                xp = self.orig_data[self.orig_data['i_survey']==i]['x'].values\n                yp = self.orig_data[self.orig_data['i_survey']==i]['y'].values\n                zp = self.orig_data[self.orig_data['i_survey']==i]['z'].values\n                kernel0 = np.zeros((len(xp),self.ny*self.nx))\n                for j,cell in enumerate(self.mesh):\n                    kernel0[:,j] = prism.gz(xp,yp,zp,[cell])\n                self.kernel_matrices.append(np.array(kernel0))\n        elif self.cell_type == 'tesseroid':\n            for i in range(self.ns):\n                xp = self.orig_data[self.orig_data['i_survey']==i]['lon'].values\n                yp = self.orig_data[self.orig_data['i_survey']==i]['lat'].values\n                zp = self.orig_data[self.orig_data['i_survey']==i]['z'].values\n                kernel0 = np.zeros((len(xp),self.ny*self.nx))\n                for j,cell in enumerate(self.mesh):\n                    kernel0[:,j] = tesseroid.gz(xp,yp,zp,[cell])\n                self.kernel_matrices.append(np.array(kernel0))\n        else:\n            raise ValueError('cell_type must be \\'prism\\' or \\'tesseroid\\'!!')\n        self.kernel_op = AbicLSQOperatorMS(self.kernel_matrices,\n                                           ns=self.ns,\n                                           nzyx=(self.nz,self.ny,self.nx),\n                                         smooth_components=self._smooth_components,\n                                         weights=self._weights)\n        self._gtg_exist = False\n\n    def _diagvec(self,vec=None,diag=None):\n        if vec.ndim == 1:\n            return vec * diag\n        else:\n            return  vec * diag.reshape(1,-1)\n\n    @timeit\n    def forward(self,model_density=None):\n        obs_g = []\n        if model_density is None:\n            x = self.solution.reshape(self.ns,-1)\n        else:\n            x = model_density.reshape(self.ns,-1)\n        for i,k in enumerate(self.kernel_matrices):\n            obs_g.append((k @ x[i]).ravel())\n        return np.hstack(obs_g)\n\n    def _gen_rhs(self):\n        self.rhs = np.zeros(self.ns*self.ny*self.nx)\n        for i,k in enumerate(self.kernel_matrices):\n            s = i*self.ny*self.nx\n            e = (i+1)*self.ny*self.nx\n            g = self.orig_data[self.orig_data['i_survey']==i]['g'].values\n            self.rhs[s:e] = self._weights['obs'] * (k.T @ g)\n        if 'refer' in self._weights.keys():\n            self.rhs += (self._weights['refer']*self.refer_density.ravel())\n\n    def _gen_btb(self):\n        if self._btb_exist:\n            return\n        self._btb = dict()\n        for key in self.smooth_components:\n            if 't' in key:\n                tmp = np.eye(self.ns*self.nx*self.ny).reshape(-1,self.ns,self.nz,self.ny,self.nx)\n                nrow = self.ns*self.ny*self.nx\n            else:\n                tmp = np.eye(self.nx*self.ny).reshape(-1,self.ny,self.nx)\n                nrow = self.nx*self.ny\n            self._btb[key] = self.smop.rderivation(self.smop.derivation(tmp,component=key),\n                                                   component=key).reshape(nrow,-1)\n        self._btb_exist = True\n\n    def _gen_gtg(self):\n        if self._gtg_exist:\n            return\n        self._gtg = []\n        for k in self.kernel_matrices:\n            self._gtg.append(k.T @ k)\n        self._gtg_exist = True\n\n    @timeit\n    def do_linear_solve(self):\n        self.do_linear_solve_quiet()\n\n    def do_linear_solve_quiet(self):\n        self._gen_rhs()\n        self.solution = spsparse.linalg.cg(self.kernel_op,self.rhs,tol=1.0e-5)[0]\n\n    @timeit\n    def calc_u(self,solved=False,x=None):\n        return self.calc_u_quiet(solved,x)\n\n    @timeit\n    def calc_min_u(self,solved=False,x=None):\n        return self.calc_u_quiet(solved,x)\n\n    def calc_u_quiet(self,solved=False,x=None):\n        if x is None:\n            if not solved:\n                self.do_linear_solve_quiet()\n            x = self.solution\n        v = x.reshape(self.ns,-1)\n        self.min_u_val = 0.\n        for i,k in enumerate(self.kernel_matrices):\n            g = self.orig_data[self.orig_data['i_survey']==i]['g'].values\n            self.min_u_val += self._weights['obs']*np.linalg.norm(k @ v[i] - g)**2\n        for key in self._smooth_components:\n            tmp2 = self.smop.derivation(v.reshape(self.ns,self.nz,self.ny,self.nx),\n                                        component=key)\n            self.min_u_val += self._weights[key]*np.linalg.norm(tmp2.ravel())**2\n        if 'refer' in self._weights.keys():\n            v = x - self.refer_density.ravel()\n            self.min_u_val += self._weights['refer'] * np.linalg.norm(v)**2\n        return self.min_u_val\n\n    def calc_res(self):\n        self.residuals = dict()\n        self.stds = dict()\n        x = self.solution.reshape(self.ns,-1)\n        res = []\n        for i,k in enumerate(self.kernel_matrices):\n            g = self.orig_data[self.orig_data['i_survey']==i]['g'].values\n            res.append((k@x[i] - g).ravel())\n        res = np.hstack(res)\n        self.residuals['obs'] = np.linalg.norm(res)**2\n        self.stds['obs'] = np.std(res)\n        for key in self._smooth_components:\n            tmp2 = self.solution.reshape(self.ns,self.nz,self._ny,self._nx)\n            tmp2 = self.smop.derivation(tmp2,component=key)\n            self.residuals[key] = np.linalg.norm(tmp2.ravel())**2\n            self.stds[key] = np.std(tmp2.ravel())\n        if 'refer' in self._weights.keys():\n            self.residuals['refer'] = []\n            self.stds['refer'] = []\n            self.residuals['refer'].append(np.linalg.norm(self.solution.ravel()-self.refer_density.ravel())**2)\n            self.stds['refer'].append(np.std(self.solution.ravel()-self.refer_density.ravel()))\n\n    def calc_log_prior_total_det_quiet(self,precision=1.0e-6):\n        self._gen_gtg()\n        self._gen_btb()\n        self.log_prior_det_val = 0\n        self.log_total_det_val = 0\n        prior_eigs = np.zeros(self._nx*self._ny*self.nz)\n        total_eigs = np.zeros(self._nx*self._ny*self.nz)\n        tmp_mat = np.zeros((self.ns*self.nx*self.ny,self.ns*self.nx*self.ny))\n        for key in self.smooth_components:\n            if 't' in key:\n                tmp_mat += self.weights[key] * self._btb[key]\n            else:\n                for i in range(self.ns):\n                    tmp_mat[i*self.nx*self.ny:(i+1)*self.nx*self.ny,\n                            i*self.nx*self.ny:(i+1)*self.nx*self.ny] += self.weights[key] * self._btb[key]\n        prior_eigs = np.linalg.eigvalsh(tmp_mat)\n        self.log_prior_det_val = sum(np.log(prior_eigs[prior_eigs > precision]))\n        for i,k in enumerate(self.kernel_matrices):\n            tmp_mat[i*self.nx*self.ny:(i+1)*self.nx*self.ny,\n                    i*self.nx*self.ny:(i+1)*self.nx*self.ny] += self.weights['obs'] * self._gtg[i]\n        if 'refer' in self._weights.keys():\n            tmp_mat += self._weights['refer']*np.eye(self.nx*self.ny*self.ns)\n        total_eigs = np.linalg.eigvalsh(tmp_mat)\n        self.log_total_det_val = sum(np.log(total_eigs[total_eigs > precision]))\n        self.eigs = {'prior':prior_eigs,'total':total_eigs}\n\n    @timeit\n    def calc_log_prior_total_det(self,precision=1.0e-6):\n        return self.calc_log_prior_total_det_quiet(precision)\n\n    def calc_log_obs_det_quiet(self):\n        if 'refer' in self._weights.keys():\n            self.log_obs_det_val = (self.nx*self.ny*self.ns*np.log(self.weights['refer'])\n                                    +np.log(self._weights['obs'])*len(self.orig_data))\n        else:\n            self.log_obs_det_val = np.log(self._weights['obs'])*len(self.orig_data)\n        return self.log_obs_det_val\n\n    @timeit\n    def calc_log_obs_det(self):\n        return self.calc_log_obs_det_quiet()\n\n    @timeit\n    def calc_abic(self):\n        '''-log_prior_det_value+log_total_det-log_obs_det+min_u'''\n        self.calc_log_prior_total_det()\n        self.calc_u()\n        self.calc_log_obs_det()\n        self.abic_val = (self.log_total_det_val\n                         + self.min_u_val\n                         - self.log_prior_det_val\n                         - self.log_obs_det_val)\n        self.abic_log['weights'].append(self._weights.copy())\n        self.abic_log['abic_val'].append(self.abic_val)\n        return self.abic_val\n\n    def calc_abic_quiet(self,precision=1.0e-6):\n        '''-log_prior_det_value+log_total_det-log_obs_det+min_u'''\n        self.calc_log_prior_total_det_quiet(precision)\n        self.calc_u_quiet()\n        self.calc_log_obs_det_quiet()\n        self.abic_val = (self.log_total_det_val\n                         + self.min_u_val\n                         - self.log_prior_det_val\n                         - self.log_obs_det_val)\n        self.abic_log['weights'].append(self._weights.copy())\n        self.abic_log['abic_val'].append(self.abic_val)\n        if self._abic_iter % 10 == 0:\n            print('abic value is:{}'.format(self.abic_val))\n        self._abic_iter += 1\n        return self.abic_val\n\n    def _abic_optimize_exp(self,precision=1.0e-6):\n        def abic_target(x):\n            for i,key in enumerate(self.optimize_weights):\n                self._weights[key] = np.exp(x[i])\n            return self.calc_abic_quiet(precision=1.0e-6)\n        x0 = np.zeros(len(self.optimize_weights))\n        for i,key in enumerate(self.optimize_weights):\n            x0[i] = np.log(self._weights[key])\n        self.abic_optimize_summary = minimize(abic_target,\n                                              x0,\n                                              method='Nelder-Mead')\n\n    @timeit\n    def abic_optimize(self):\n        self._abic_iter = 0\n        self._abic_optimize_exp(precision=1.0e-6)\n\n    @timeit\n    def para_grad(self,x):\n        pass\n\n    def u_bound(self):\n        pass\n\n    def print_summary(self):\n        print('abic values:{}'.format(self.abic_val))\n        print('log total det:{}'.format(self.log_total_det_val))\n        print('log prior det:{}'.format(self.log_prior_det_val))\n        print('log obs det:{}'.format(self.log_obs_det_val))\n        print('min u:{}'.format(self.min_u_val))\n        print('std:',end=' ')\n        print(self.stds)\n        print('1\/var:',end=' ')\n        print({k:1.\/v**2 for k,v in self.stds.items()})\n        print('norms:',end=' ')\n        print(self.residuals)\n\n    def plot_density(self,density=None,surveys=None,fname=None):\n        if surveys is None:\n            surveys = range(self.ns)\n        fig = plt.figure(figsize=(10, 10))\n        nrows = int(np.ceil(np.sqrt(len(surveys))))\n        grid = ImageGrid(fig, 111,\n                        nrows_ncols=(nrows, nrows),\n                        axes_pad=0.05,\n                        cbar_mode='single',\n                        cbar_location='right',\n                        cbar_pad=0.1\n                        )\n        if density is None:\n            x = self.solution.reshape(self.ns,self.ny,self.nx)\n        else:\n            x = density.reshape(self.ns,self.ny,self.nx)\n        if self.cell_type == 'prism':\n            #rint(x.shape)\n            x = np.transpose(x,axes=[0,2,1]) #axis \/\/chenshi\n        for ind,i_survey in enumerate(surveys):\n            grid[ind].set_axis_off()\n            im = grid[ind].imshow(x[i_survey],origin='lower')\n        cbar = grid.cbar_axes[0].colorbar(im)\n        if fname is None:\n            plt.show()\n        else:\n            plt.savefig(fname,dpi=150)\n\n    def plot_field(self,field=None,surveys=None,fname=None,plot_station=True):\n        if surveys is None:\n            surveys = range(self.ns)\n        if field is None:\n            obs_g = self.orig_data['g']\n        else:\n            obs_g = pd.Series(field,index=self.orig_data.index)\n        fig = plt.figure(figsize=(10, 10))\n        if self.cell_type == 'prism':\n            axis_order = ['y','x']\n        elif self.cell_type == 'tesseroid':\n            axis_order = ['lon','lat']\n        nrows = int(np.ceil(np.sqrt(len(surveys))))\n        grid = ImageGrid(fig, 111,\n                        nrows_ncols=(nrows, nrows),\n                        axes_pad=0.05,\n                        cbar_mode='single',\n                        cbar_location='right',\n                        cbar_pad=0.1\n                        )\n        for ind,i_survey in enumerate(surveys):\n            grid[ind].set_axis_off()\n            tmp = self.orig_data[self.orig_data['i_survey']==ind]\n            x = tmp[axis_order[0]].values\n            y = tmp[axis_order[1]].values\n            g = obs_g[self.orig_data['i_survey']==ind].values\n            im = grid[ind].tricontourf(x, y, g, 20)\n            if plot_station:\n                im2 = grid[ind].scatter(x,y)\n        cbar = grid.cbar_axes[0].colorbar(im)\n        if fname is None:\n            plt.show()\n        else:\n            plt.savefig(fname,dpi=150)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_292","text":"import numpy as np\r\nimport scipy.sparse.csgraph\r\n\r\nimport dijkstra\r\n\r\ndef test_dijkstra_against_scipy():\r\n    W = np.random.random((100, 100))\r\n    W += W.transpose()\r\n    W[W<1.0] = np.inf\r\n    W = scipy.sparse.csr_matrix(W)\r\n\r\n    for seed in [0,1,2]:\r\n        result0 = dijkstra.dijkstra(W, seed)\r\n        result1 = scipy.sparse.csgraph.dijkstra(W, indices = [seed])[0]\r\n        assert all(result0 == result1)\r\n    \r\n\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_293","text":"from cmath import rect, phase\nfrom math import radians, degrees\nimport cv2\nimport numpy as np\n\nfrom dyslexia import preprocessing\n\n\ndef mean_angle(deg):\n    if len(deg) == 0:\n        return 0\n\n    return degrees(phase(sum(rect(1, radians(d)) for d in deg) \/ len(deg)))\n\n\ndef reject_outliers(values, m=2):\n    values = np.array(values)\n\n    return values[abs(values - mean_angle(values)) < m * np.std(values)]\n\n\ndef compute_rotation_angle(image):\n    \"\"\"Find best text angle direction\n\n    It's recommended that you use theses functions before using this one:\n\n    # ``remove_shadow(image)``\n    # ``image_to_gray(image, threshold=True)``\n    \"\"\"\n    gray = 255 - image\n\n    # Apply threshold to binarize image\n    thresh = cv2.threshold(gray, 0, 255,\n                           cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\n    thresh = 255 - thresh\n\n    # apply close to connect the white areas\n    # kernel = np.ones((5, 5), np.uint8)\n    # morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n    # kernel = np.ones((1, 9), np.uint8)\n    # morph = cv2.morphologyEx(morph, cv2.MORPH_CLOSE, kernel)\n    # kernel = np.ones((9, 1), np.uint8)\n    # morph = cv2.morphologyEx(morph, cv2.MORPH_CLOSE, kernel)\n\n    # Use HoughLines method to find lines\n    lines = cv2.HoughLinesP(thresh,\n                            rho=1,\n                            theta=1 * np.pi \/ 180,\n                            threshold=100,\n                            minLineLength=100,\n                            maxLineGap=50)\n                            \n    if lines is None:\n        return 0\n    if len(lines) == 0:\n        return 0\n\n    lines = np.reshape(lines, (lines.shape[0], 4))\n\n    angles = []\n    for x1, y1, x2, y2 in lines:  #[:1000]:\n        # get angle\n        angle = np.arctan2((y2 - y1), (x2 - x1))\n\n        # To degrees\n        angle = angle * 180 \/ np.pi\n\n        # Since we don't know where is the top of\n        # the picture then we just want the direction\n        if angle < 0:\n            angle = -angle\n\n        # Multiply angle by 2 so that mean on degrees work\n        # for line direction only\n        angles.append(angle * 2)\n\n    # Reject outliers (like paper border lines)\n    angles = reject_outliers(angles, m=1)\n\n    # Divides mean by 2 to retrieves direction\n    angle = mean_angle(angles) \/ 2\n\n    return angle\n\n\ndef find_best_rotation_angle(image: np.ndarray, threshold=1):\n    \"\"\"Find best text angle direction\n\n    It's recommended that you use theses functions before using this one:\n\n    # ``remove_shadow(image)``\n    # ``image_to_gray(image, threshold=True)``\n    \n    Apply this algorithm to find the best angle.\n    \n    #. use ``compute_rotation_angle()`` to get first angle detected\n    #. if angle is close to 180 or 0 then it's already good\n    #. else rotated image by angle\n    #. Use this image to use again ``compute_rotation_angle()``\n    #. if angle is close to 180 or 0 then use this angle\n    #. do the same for but with minus first angle found\n    #. If neither angles are close enough then use the closest from 180 or 0    \n    \n    Parameters\n    ----------\n    image : np.ndarray\n        Source image\n    threshold : int, default 1\n        Distance in degree from horizontal line (180 or 0 degrees)\n        to consider an angle to be good\n\n    Returns\n    -------\n    number:\n        Best rotation angle for this image\n    \"\"\"\n    angle = compute_rotation_angle(image)\n\n    if abs(angle - 90) > 90 - threshold:\n        return angle\n\n    img_rotated = preprocessing.rotate_img(image, angle)\n    new_angle1 = compute_rotation_angle(img_rotated)    \n\n    if abs(new_angle1 - 90) > 90 - threshold:\n        return angle\n\n    img_rotated = preprocessing.rotate_img(image, -angle)\n    new_angle2 = compute_rotation_angle(img_rotated)\n\n    if abs(new_angle2 - 90) > 90 - threshold:\n        return -angle\n\n    if abs(new_angle1 - 90) > abs(new_angle2 - 90):\n        return angle\n\n    return -angle\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_295","text":"<gh_stars>1-10\n# ---------------------------------------------------------\n# Copyright (c) Microsoft Corporation. All rights reserved.\n# ---------------------------------------------------------\n\n\"\"\"Utilities to train a surrogate model from teacher.\"\"\"\n\nimport numpy as np\nfrom scipy.sparse import issparse, isspmatrix_csr, vstack as sparse_vstack\n\n\ndef _soft_logit(values, clip_val=5):\n    \"\"\"Compute a soft logit on an iterable by bounding outputs to a min\/max value.\n\n    :param values: Iterable of numeric values to logit and clip.\n    :type values: iter\n    :param clip_val: Clipping threshold for logit output.\n    :type clip_val: Union[Int, Float]\n    \"\"\"\n    new_values = np.log(values \/ (1 - values))\n    return np.clip(new_values, -clip_val, clip_val)\n\n\ndef _model_distill(teacher_model_predict_fn, uninitialized_surrogate_model, data, original_training_data,\n                   explainable_model_args):\n    \"\"\"Teach a surrogate model to mimic a teacher model.\n\n    :param teacher_model_predict_fn: Blackbox model's prediction function.\n    :type teacher_model_predict_fn: function\n    :param uninitialized_surrogate_model: Uninitialized model used to distill blackbox.\n    :type uninitialized_surrogate_model: uninitialized model\n    :param data: Representative data (or training data) to train distilled model.\n    :type data: numpy.ndarray\n    :param original_training_data: Representative data (or training data) to get predictions from teacher model.\n    :type original_training_data: numpy.ndarray\n    :param explainable_model_args: An optional map of arguments to pass to the explainable model\n        for initialization.\n    :type explainable_model_args: dict\n    \"\"\"\n    # For regression, teacher_y is a real value whereas for classification it is a probability between 0 and 1\n    teacher_y = teacher_model_predict_fn(original_training_data)\n    multiclass = False\n    training_labels = None\n    is_classifier = len(teacher_y.shape) == 2\n    # If the predict_proba function returned one column but this is a classifier, modify to [1-p, p]\n    if is_classifier and teacher_y.shape[1] == 1:\n        teacher_y = np.column_stack((1 - teacher_y, teacher_y))\n    if is_classifier and teacher_y.shape[1] > 2:\n        # If more than two classes, use multiclass surrogate\n        multiclass = True\n        # For multiclass case, we need to train on the class label\n        training_labels = np.argmax(teacher_y, axis=1)\n        unique_labels = set(np.unique(training_labels))\n        if len(unique_labels) < teacher_y.shape[1]:\n            # Get the missing labels\n            missing_labels = set(range(teacher_y.shape[1])).difference(unique_labels)\n            # Append some rows with the missing labels\n            for missing_label in missing_labels:\n                # Find max prob for missing label\n                max_row_index = np.argmax(teacher_y[:, missing_label])\n                # Append the extra label to data and y value\n                training_labels = np.append(training_labels, missing_label)\n                if issparse(data) and not isspmatrix_csr(data):\n                    data = data.tocsr()\n                vstack = sparse_vstack if issparse(data) else np.vstack\n                data = vstack([data, data[max_row_index:max_row_index + 1, :]])\n        surrogate_model = uninitialized_surrogate_model(multiclass=multiclass,\n                                                        **explainable_model_args)\n    else:\n        surrogate_model = uninitialized_surrogate_model(**explainable_model_args)\n    if is_classifier and teacher_y.shape[1] == 2:\n        # Make sure output has only 1 dimension\n        teacher_y = teacher_y[:, 1]\n        # Transform to logit space and fit regression\n        surrogate_model.fit(data, _soft_logit(teacher_y))\n    else:\n        # Use hard labels for regression or multiclass case\n        if training_labels is None:\n            training_labels = teacher_y\n        surrogate_model.fit(data, training_labels)\n    return surrogate_model\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_296","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Apr 28 14:40:35 2021\n\n@author: utente\n\"\"\"\n#Functions that calculate the variance and the entropy, both phenotypic and genotypic\n\nfrom random import sample, uniform\nfrom scipy.spatial.distance import euclidean\nimport math\nimport numpy as np\n\ndef phen_variance(pop):\n            #Calculating the avg fitness of the population\n            avg_fitness = sum([i.fitness for i in pop.individuals])\/pop.size\n            #calculating the variance over the population\n            return sum([(i.fitness-avg_fitness)**2 for i in pop.individuals]) \/ (pop.size- 1)\n\n\ndef gen_variance(pop):\n            #selecting a random individual to be the origin\n            origin = sample(pop.individuals, 1)[0]\n            #calculating the distances of each point to the distance\n            distances = [ sum([ np.linalg.norm(ind[i] -  origin[i]) for i in range(len(ind)) ]) \/ len(ind) for ind in pop.individuals]\n            #calculating the average distance over the population\n            avg_distance = sum(distances) \/ pop.size\n            #calculating the variance over the population\n            return sum([(distance-avg_distance)**2 for distance in distances]) \/ (pop.size- 1)\n\ndef phen_entropy(pop):\n            #Calculating the fitnesses of the population\n            fitnesses = [i.fitness for i in pop.individuals]\n            #calculating the entropy over the population\n            return sum([ fitnesses.count(fitness) \/ len(fitnesses) * math.log(fitnesses.count(fitness) \/ len(fitnesses),  2) for fitness in fitnesses])\n\ndef gen_entropy(pop):\n            #selecting a random individual to be the origin\n            origin = sample(pop.individuals, 1)[0]\n            #calculating the distances of each point to the distance\n            distances = [ sum([ np.linalg.norm(ind[i] - origin[i]) for i in range(len(ind)) ]) \/ len(ind) for ind in pop.individuals]\n            #calculating the variance over the population\n            return sum([ distances.count(distance) \/ len(distances) * math.log(distances.count(distance) \/ len(distances), 2) for distance in distances])\n\ndef fs(pop):\n            #building the distance-half matrix\n            #starting by initializing the matrix with zeros\n            distance_matrix = np.zeros((len(pop), len(pop)))\n            #iterating over the individuals and calculating the euclidean distances\n            for i in range(pop.size):\n                for j in range(i, pop.size):\n                    distance_matrix[i,j] = sum([ np.linalg.norm(pop.individuals[i][index] - pop.individuals[j][index]) for index in range(4) ]) \/ 4\n            #normalizing distances in [0,1] and reverting them, so the result is big if the distance was small and viceversa\n            max_ = distance_matrix.max()\n            min_ = distance_matrix.min()\n            distance_matrix = 1 - (distance_matrix - min_)\/(max_ - min_)\n            #defining a sharing coeffient for each element in the population\n            sharing_coeff = []\n            for i in range(pop.size):\n                sharing_coeff.append( sum(distance_matrix[i] + distance_matrix.T[i]) )\n            #updating the individuals fitness\n            for i, individual in enumerate(pop.individuals):\n                \n                if pop.optim == 'max':\n                    \n                    individual.fitness = individual.fitness \/ sharing_coeff[i]\n                \n                else: \n                    \n                    individual.fitness = individual.fitness * int(sharing_coeff[i]) \n                    \n\n                \ndef mo_selection(pop):\n    '''\n    Multiobjective optimization selection process, can be used only if the fitness function is a tuple.    \n\n    '''\n    #copying all individuals in a list s \n    s = [(pop.individuals.index(i), i.fitness) for i in pop.individuals]\n    #Initializing the flag dictionary, the flag and the individuals\n    flag = {}\n    i = 1 \n    fit = s[0]\n    fit2 = s[1]    \n    \n    if pop.optim == 'max':\n    \n        #keep iterating while the set is not empty\n        while len(s) > 0:\n            #checking if the individual is dominated\n            if fit[1][0] < fit2[1][0] and fit[1][1] < fit2[1][1]:\n                #checking if we already compare all individuals\n                if s.index(fit) == len(s) - 1:\n                    #reinitializing the loop and increasing the flag\n                    fit = s[0]\n                    fit2 = s[1]\n                    i += 1\n                #if it is checking for another individual\n                fit = s[s.index(fit) + 1 ]\n            \n            #otherwise\n            else:\n                #checking if  we already check for all individuals\n                if fit2 == s[-1]:\n                    #then the individual is not-dominated, saving it in the flag dict with the right flag\n                    flag[str(fit[0])] = i\n                    #removing it from the list \n                    s.remove(fit)\n                    #checking how many individual are left\n                    if len(s) == 1:\n                        flag[str(s[0][0])] = i + 1\n                        break\n                    elif len(s) == 0:\n                        break\n                    else:\n                        #reinitializing the individuals\n                        fit = s[0]\n                        fit2 = s[1]\n                #otherwise\n                else:\n                    #changing the individual to check for \n                    fit2 = s[s.index(fit2) + 1]\n                    \n    else:\n        \n        #keep iterating while the set is not empty\n        while len(s) > 0:\n            #checking if the individual is dominated\n            if fit[1][0] > fit2[1][0] and fit[1][1] > fit2[1][1]:\n                #checking if we already compare all individuals\n                if s.index(fit) == len(s) - 1:\n                    #reinitializing the loop and increasing the flag\n                    fit = s[0]\n                    fit2 = s[1]\n                    i += 1\n                #if it is checking for another individual\n                fit = s[s.index(fit) + 1 ]\n            \n            #otherwise\n            else:\n                #checking if  we already check for all individuals\n                if fit2 == s[-1]:\n                    #then the individual is not-dominated, saving it in the flag dict with the right flag\n                    flag[str(fit[0])] = i\n                    #removing it from the list \n                    s.remove(fit)\n                    #checking how many individual are left\n                    if len(s) == 1:\n                        flag[str(s[0][0])] = i + 1\n                        break\n                    elif len(s) == 0:\n                        break\n                    else:\n                        #reinitializing the individuals\n                        fit = s[0]\n                        fit2 = s[1]\n                #otherwise\n                else:\n                    #changing the individual to check for \n                    fit2 = s[s.index(fit2) + 1]\n        \n    #assinging to each ind the probability of being picked of 1 - ind.flag \/ sum(flag)\n    tot_flag = sum(flag.values())\n    prob = {}\n    for ind in list(flag.keys()):\n        prob[ind] = 1 - flag[ind]\/tot_flag\n    \n    #sorting the probabilities dictionary\n    sorted_prob = {}\n    sorted_keys = sorted(prob, key=prob.get) \n    for w in sorted_keys:\n        sorted_prob[w] = prob[w]\n    #selecting the two parents\n    spin = uniform(0, sum(sorted_prob.values()))\n    position = 0\n    for individual in sorted_prob.keys():\n        position += sorted_prob[individual]\n        if position > spin:\n            index1 = individual\n            break\n        \n    spin = uniform(0, sum(sorted_prob.values()))\n    position = 0\n    # Find individual in the position of the spin\n    for individual in sorted_prob.keys():\n        position += sorted_prob[individual]\n        if position > spin:\n            index2 = individual\n            break\n    \n    return pop.individuals[int(index1)], pop.individuals[int(index2)]\n\n                    \n            \n    \n    \n    \n            \n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_297","text":"<gh_stars>0\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n# Author: <NAME>\n# License: MIT\n\n\"\"\"\nMie theory functions\n\"\"\"\n\n\nimport numpy as np\nimport scipy.special as sp\n\n\ndef sj(n, q):\n    return sp.spherical_jn(n, q)\n\n\ndef dsj(n, q):\n    return sp.spherical_jn(n, q, derivative=True)\n\n\ndef sy(n, q):\n    return sp.spherical_yn(n, q)\n\n\ndef dsy(n, q):\n    return sp.spherical_yn(n, q, derivative=True)\n\n\ndef sh1(n, q):\n    return sj(n, q) + 1j * sy(n, q)\n\n\ndef dsh1(n, q):\n    return dsj(n, q) + 1j * dsy(n, q)\n\n\ndef fdot(n, q, f, df):\n    return 1 \/ q * (f(n, q) + q * df(n, q))\n\n\ndef sjdot(n, q):\n    return fdot(n, q, sj, dsj)\n\n\ndef sh1dot(n, q):\n    return fdot(n, q, sh1, dsh1)\n\n\ndef get_cross_sections_analytical(k0, a, eps_sphere=4, eps_bg=1, Nmax=25):\n    k1 = k0 * (eps_bg.conjugate()) ** 0.5\n    k2 = k0 * (eps_sphere.conjugate()) ** 0.5\n    chi = k2 \/ k1\n\n    def coeffs(n):\n        q1 = sjdot(n, k1 * a) * sj(n, k2 * a) - chi * sj(n, k1 * a) * sjdot(n, k2 * a)\n        q2 = sh1dot(n, k1 * a) * sj(n, k2 * a) - chi * sh1(n, k1 * a) * sjdot(n, k2 * a)\n\n        c_over_a = -q1 \/ q2\n\n        q1 = sj(n, k1 * a) * sjdot(n, k2 * a) - chi * sjdot(n, k1 * a) * sj(n, k2 * a)\n        q2 = sh1(n, k1 * a) * sjdot(n, k2 * a) - chi * sh1dot(n, k1 * a) * sj(n, k2 * a)\n\n        d_over_b = -q1 \/ q2\n        return c_over_a, d_over_b\n\n    Cs, Ce = 0, 0\n\n    for n in range(1, Nmax):\n        A, B = coeffs(n)\n        # print(np.mean((np.abs(A)**2 + np.abs(B)**2)))\n        Cs += (2 * n + 1) * (np.abs(A) ** 2 + np.abs(B) ** 2)\n        Ce += -(2 * n + 1) * ((A) + (B)).real\n\n    Cs *= 2 * np.pi \/ k1 ** 2\n    Ce *= 2 * np.pi \/ k1 ** 2\n    Ca = Ce - Cs\n    return Cs, Ce, Ca\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_298","text":"<filename>interpolate\/pozo_0.5m_to_5m_interpolation_canopy.py\nimport numpy as np\nfrom scipy.interpolate import griddata\nfrom matplotlib import pyplot as pl\n\nmethod = 'linear'\n#method = 'cubic'\n\nz2 = np.load('pozo_0.5m_dem_mean_cl2.npy')\nz5 = np.load('pozo_0.5m_dem_mean_cl5.npy')\nz5[np.isnan(z5)] = z2[np.isnan(z5)]\n\n# input coords\nw = 0.5\nxb = np.arange(0, 500+w, w)\nyb = np.arange(0, 500+w, w)\nxc = xb[:-1] + w\/2.\nyc = yb[:-1] + w\/2.\nx, y = np.meshgrid(xc, yc)\nx2, y2, z2 = x[~np.isnan(z2)], y[~np.isnan(z2)], z2[~np.isnan(z2)]\nx5, y5, z5 = x[~np.isnan(z5)], y[~np.isnan(z5)], z5[~np.isnan(z5)]\n\n# output coords\nd = 5\nXb = np.arange(0, 500+d, d)\nYb = np.arange(0, 500+d, d)\nXc = Xb[:-1] + d\/2.\nYc = Yb[:-1] + d\/2.\nX, Y = np.meshgrid(Xc, Yc)\nZ2 = griddata((x2, y2), z2, (X, Y), method = method)\nZ5 = griddata((x5, y5), z5, (X, Y), method = method)\n\npl.title('Canopy height [m]')\npl.pcolormesh(Xb, Xb, np.ma.masked_invalid(Z5-Z2),\n        cmap = pl.cm.seismic,\n        vmin = -15, vmax = 15,\n        )\npl.axes().set_aspect('equal')\npl.colorbar()\npl.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_299","text":"import matplotlib.pyplot as plt\nimport altair as alt\nalt.data_transformers.disable_max_rows()\nimport pandas as pd \nimport numpy as np\nimport os\nfrom scipy.ndimage import gaussian_filter\n\n\ndef smooth_chrom(xs=[], ys=[], smooth_factor=1, source=None, filename=None, save_as=None):\n    '''\n    Function to smooth chromatogram from MS data.\n    Values can either be read from \n    \n    :param xs: (array-like) x values from chromatogram\n    :param ys: (array-like) y values from chromatogram\n    :param source: (string) dictates from where the function should read data.\n        None --> implies data is passed as an argument\n        'clip' --> implies pandas should read data from clipboard\n        'excel' --> implies pandas should read data from excel file \n    '''\n    if source is None:\n        asrt_text = 'If no source is provided, data arrays must be passed as arguments'\n        assert xs != [] and ys != [], asrt_text\n    elif source=='clip':\n        df = pd.read_clipboard()\n    elif source=='excel':\n        df = pd.read_excel(filename)\n    else:\n        assert xs is not None, 'Found no valid X values'\n        assert ys is not None, 'Found no valid Y values'\n    xs = df.iloc[3:, 0].astype(float)\n    ys = df.iloc[3:, 1].astype(float)\n    ys = gaussian_filter(ys, smooth_factor)\n    plt.plot(xs, ys)\n    plt.fill_between(xs, ys, alpha=0.3)\n    if save_as:\n        plt.savefig(save_as)\n\ndef get_files(directory='.', exts=['.']):\n    '''\n    Function that searches the defined directory and reutrns list\n    of all files with the specified extension or ending.\n\n    :param directory: (str) raw string of directory to be searched\n    :param exts: (list) list of extensions or endings to be returned\n    '''\n    all_files = []\n    for root, _, files in os.walk(directory, topdown=True):\n        if exts == ['.']:\n            all_files.extend([os.path.join(root, name) for name in files])\n        for name in files:\n            file_path = os.path.join(root, name)\n            for ext in exts:\n                if file_path.endswith(ext):\n                    all_files.append(file_path)\n    return all_files\n\ndef find_nearest(array, value):\n    '''\n    Function that searches an array and returns the value nearest to the\n    one passed.\n\n    :param array: (array-like) array to be searched\n    :param value: (int or float) experimental value\n    '''\n    array = np.asarray(array)\n    idx = (np.abs(array - value)).argmin()\n    return array[idx]\n\ndef plot_ms2_data(xs, ys, peptide, frag_dict, mods=None, show_error=False, tolerance=25):\n    '''\n    Function to return altair plot of identified fragments for a theoretical \n    peptide.\n\n    :param xs: (array) x\/time data\n    :param ys: (array) intensity data\n    :param peptide: (string) peptide sequence\n    :param frag_dict: (dict) output returned from data_processing.fragments func\n    '''\n    # handle -endian order of data\n    data = [xs, ys]\n    for i, array in enumerate(data):\n        if array.dtype.byteorder == '>': # is big-endian\n            data[i] = data[i].byteswap().newbyteorder()\n    xs, ys = data\n\n    df = pd.DataFrame({\n        'x':xs, 'y':ys,\n        'fragment':[None]*len(xs),\n        'label':['']*len(xs)\n    })\n  \n    if mods is not None:\n        assert isinstance(mods, dict), 'modifications must enter as dictionary'\n        for k in mods:\n            if not isinstance(mods[k], list):\n                frag_dict[k] = list([mods[k]])\n            else:\n                frag_dict[k] = mods[k]\n\n\n    dom = {\n        'b': '#3b5bad',\n        'y': '#c42e23',\n        'HexHexNAc': '#3d8f2e',\n        'NeuAc': '#3d8f2e',\n        'NeuAc-18': '#3d8f2e',\n        'HexNac': '#3d8f2e',\n        'HexNac-18': '#3d8f2e',\n        'HexNac-36': '#3d8f2e',\n        'HexNac-fg': '#3d8f2e',\n        'Hex': '#3d8f2e',\n        'Hex-18': '#3d8f2e',\n    }\n\n    err_mass, err_dist, err_kind= [], [], []\n\n\n    for k, v in frag_dict.items():\n        for frag in v:\n            nearest = find_nearest(df.x, frag)\n            error = mass_error(frag, nearest)\n            if abs(error) <= tolerance:\n                err_mass.append(nearest)\n                err_dist.append(error)\n                err_kind.append(k)\n                df.loc[(df.x==nearest), 'fragment'] = k\n                if k in ['b']:\n                    df.loc[(df.x==nearest), 'label'] = k+f'{v.index(frag)+1}'\n                elif k in ['y']:\n                    df.loc[(df.x==nearest), 'label'] = k+f'{len(v) - v.index(frag)+1}'\n                else:\n                    df.loc[(df.x==nearest), 'label'] = k\n  \n    df.dropna(inplace=True)\n    df.loc[:, 'y'] = df.y \/ np.max(df.y) * 100\n    df['label position'] = df.y + 5\n    \n    bars = alt.Chart(df).mark_bar(size=2).encode(\n        x=alt.X('x', title='m\/z', axis=alt.Axis(grid=False)),\n        y=alt.Y('y', title='Relative Abundance',\n                axis=alt.Axis(grid=False, tickCount=1),\n                scale=alt.Scale(domain=(0, 100))),\n        color=alt.Color('fragment', scale=alt.Scale(domain=list(dom.keys()),\n                        range=list(dom.values())), legend=None)\n    ).properties(\n        title=peptide,\n        width=600\n    )\n\n    text = alt.Chart(df).mark_text().encode(\n        y=alt.Y('label position'),\n        x=alt.X('x'),\n        text='label'\n    )\n    chart = alt.vconcat()\n    chart &= alt.layer(bars, text)\n    if show_error:\n        err_df = pd.DataFrame({\n            'mass':err_mass,\n            'error':err_dist,\n            'kind':err_kind\n        })\n        dots = alt.Chart(err_df).mark_circle().encode(\n            x=alt.X('mass:Q', title='m\/z', axis=alt.Axis(grid=False)),\n            y=alt.Y('error:Q', title='error (ppm)', axis=alt.Axis(grid=True, tickCount=3),\n                    scale=alt.Scale(domain=(-tolerance, tolerance))),\n            color=alt.Color('kind:O', scale=alt.Scale(domain=list(dom.keys()), range=list(dom.values()))\n            )).properties(height=100)\n\n        line = alt.Chart(pd.DataFrame({'y': [0]})).mark_rule(\n            strokeDash=[10, 10]).encode(y='y')\n\n\n        chart &= (dots + line)\n    return chart.configure_view(\n        strokeWidth=0\n    )\n\ndef mass_error(measured, exact):\n    '''\n    Returns mass error between measured and theoretical values.\n    '''\n    dif = measured - exact\n    quo = dif \/ exact\n    return quo * 10**6\n\nmodifications = {\n    'oxonium':{\n        'Hex-36': 127.06,\n        'HexNAc-fg': 138.05,\n        'Hex': 163.06,\n        'HexNAc-36': 168.09,\n        'HexNAc-18': 186.09,\n        'HexNAc': 204.09,\n        'NeuAc-18': 274.09,\n        'NeuAc': 292.08,\n        'HexHexNAc': 366.14,\n    }\n}"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_300","text":"<reponame>fetchai\/agents-tac<filename>data\/experiments\/analysis\/stats.py\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n# ------------------------------------------------------------------------------\n#\n#   Copyright 2018-2020 Fetch.AI Limited\n#\n#   Licensed under the Apache License, Version 2.0 (the \"License\");\n#   you may not use this file except in compliance with the License.\n#   You may obtain a copy of the License at\n#\n#     http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n#   Unless required by applicable law or agreed to in writing, software\n#   distributed under the License is distributed on an \"AS IS\" BASIS,\n#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n#   See the License for the specific language governing permissions and\n#   limitations under the License.\n#\n# ------------------------------------------------------------------------------\n\n\"\"\"Quick stats from data.\"\"\"\n\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats  # type: ignore\nimport seaborn as sns  # type: ignore\nimport matplotlib.pyplot as plt  # type: ignore\n\nsns.set(color_codes=True)\n\n\ndef analysis_scores_initial_and_final_vs_equilibrium():\n    \"\"\"Analyse the initial and final vs equilibrium scores for baseline agents only.\"\"\"\n    # load scores\n    print(\"---------------\\nAnalysis 1:\")\n    df1 = pd.read_csv(\"scores_final_ex2.csv\")\n    df1 = df1.drop([\"Unnamed: 0\"], axis=1)\n    df2 = pd.read_csv(\"scores_final_ex3.csv\")\n    df2 = df2.drop([\"Unnamed: 0\"], axis=1)\n    df_final = pd.concat([df1, df2], ignore_index=True, sort=False)\n    df_final.reset_index(inplace=True)\n\n    df3 = pd.read_csv(\"scores_equilibrium_ex2.csv\")\n    df3 = df3.drop([\"Unnamed: 0\"], axis=1)\n    df4 = pd.read_csv(\"scores_equilibrium_ex3.csv\")\n    df4 = df4.drop([\"Unnamed: 0\"], axis=1)\n    df_eq = pd.concat([df3, df4], ignore_index=True, sort=False)\n    df_eq.reset_index(inplace=True)\n\n    df5 = pd.read_csv(\"scores_initial_ex2.csv\")\n    df5 = df5.drop([\"Unnamed: 0\"], axis=1)\n    df6 = pd.read_csv(\"scores_initial_ex3.csv\")\n    df6 = df6.drop([\"Unnamed: 0\"], axis=1)\n    df_initial = pd.concat([df5, df6], ignore_index=True, sort=False)\n    df_initial.reset_index(inplace=True)\n\n    df_in_v_eq = df_initial.subtract(df_eq)\n    df_fi_v_eq = df_final.subtract(df_eq)\n    print(\"> Initial vs equilibrium and final vs equilibrium scores (only baseline)...\")\n    # sample:\n    print(\n        \"Number agents: {}, number games: {}\".format(\n            df_in_v_eq.shape[1], df_in_v_eq.shape[0]\n        )\n    )\n    # population: all games with the same config\n    in_v_eq = np.array([])\n    _in = np.array([])\n    fi_v_eq = np.array([])\n    _fi = np.array([])\n\n    for column_name in df_in_v_eq.columns:\n        if column_name == \"index\":\n            continue\n        elif column_name[-3:] == \"_wm\":\n            continue\n        else:\n            in_v_eq = np.append(in_v_eq, df_in_v_eq[column_name].to_numpy())\n            _in = np.append(_in, df_initial[column_name].to_numpy())\n\n    for column_name in df_fi_v_eq.columns:\n        if column_name == \"index\":\n            continue\n        elif column_name[-3:] == \"_wm\":\n            continue\n        else:\n            fi_v_eq = np.append(fi_v_eq, df_fi_v_eq[column_name].to_numpy())\n            _fi = np.append(_fi, df_final[column_name].to_numpy())\n\n    # scipy.stats.ttest_ind(cat1['values'], cat2['values'], equal_var=False)\n    # https:\/\/en.wikipedia.org\/wiki\/Welch%27s_t-test\n    # https:\/\/stats.stackexchange.com\/questions\/305\/when-conducting-a-t-test-why-would-one-prefer-to-assume-or-test-for-equal-vari\n    alpha = 0.0001\n    H_0 = \"H_0: (baseline) agents mean of diff in final scores to equilibrium scores <= (baseline) agents mean of diff in initial scores to equilibrium scores (one-sided t-test)\"\n    print(H_0)\n    result = stats.ttest_ind(in_v_eq, fi_v_eq)\n    p_value = result.pvalue \/ 2.0\n    reject = p_value < alpha\n    print(\"One-sided t-test p-value: {}, reject H_0: {}\".format(p_value, reject))\n    means = [np.mean(fi_v_eq), np.mean(in_v_eq)]\n    print(\"Mean: fi_v_eq={}, in_v_eq={}\".format(means[0], means[1]), \"score bin\")\n    _plot(\n        in_v_eq,\n        fi_v_eq,\n        \"scores_in_d_eq_vs_fi_d_eq.png\",\n        \"score bin\",\n        label_one=\"Difference btw initial and equilibrium scores\",\n        label_two=\"Difference btw final and equilibrium scores\",\n    )\n\n\ndef analysis_scores_final_min_initial():\n    \"\"\"Analyse the final minus initial scores for both agent groups.\"\"\"\n    # load scores\n    print(\"---------------\\nAnalysis 2:\")\n    df1 = pd.read_csv(\"scores_final_ex2.csv\")\n    df1 = df1.drop([\"Unnamed: 0\"], axis=1)\n    df2 = pd.read_csv(\"scores_final_ex3.csv\")\n    df2 = df2.drop([\"Unnamed: 0\"], axis=1)\n    df_final = pd.concat([df1, df2], ignore_index=True, sort=False)\n    df_final.reset_index(inplace=True)\n\n    df3 = pd.read_csv(\"scores_initial_ex2.csv\")\n    df3 = df3.drop([\"Unnamed: 0\"], axis=1)\n    df4 = pd.read_csv(\"scores_initial_ex3.csv\")\n    df4 = df4.drop([\"Unnamed: 0\"], axis=1)\n    df_initial = pd.concat([df3, df4], ignore_index=True, sort=False)\n    df_initial.reset_index(inplace=True)\n\n    df = df_final.subtract(df_initial)\n\n    print(\"> Initial minus final scores...\")\n    # sample:\n    print(\"Number agents: {}, number games: {}\".format(df.shape[1], df.shape[0]))\n    # population: all games with the same config\n    baseline = np.array([])\n    w_model = np.array([])\n\n    for column_name in df.columns:\n        if column_name == \"index\":\n            continue\n        elif column_name[-3:] == \"_wm\":\n            w_model = np.append(w_model, df[column_name].to_numpy())\n        else:\n            baseline = np.append(baseline, df[column_name].to_numpy())\n\n    # scipy.stats.ttest_ind(cat1['values'], cat2['values'], equal_var=False)\n    # https:\/\/en.wikipedia.org\/wiki\/Welch%27s_t-test\n    # https:\/\/stats.stackexchange.com\/questions\/305\/when-conducting-a-t-test-why-would-one-prefer-to-assume-or-test-for-equal-vari\n    alpha = 0.0001\n    H_0 = \"H_0: world modelling agents diff mean scores <= baseline agents diff mean scores (one-sided t-test)\"\n    print(H_0)\n    result = stats.ttest_ind(baseline, w_model)\n    p_value = result.pvalue \/ 2.0\n    reject = p_value < alpha\n    print(\"One-sided t-test p-value: {}, reject H_0: {}\".format(p_value, reject))\n    means = [np.mean(w_model), np.mean(baseline)]\n    print(\"Mean: w_model={}, baseline={}\".format(means[0], means[1]))\n    # sns.distplot(w_model)\n    # plt.show()\n    _plot(baseline, w_model, \"scores_final_min_initial.png\", \"score bin\")\n\n\ndef analysis_scores():\n    \"\"\"Analyse the final scores.\"\"\"\n    # load scores\n    print(\"---------------\\nAnalysis 3:\")\n    df1 = pd.read_csv(\"scores_final_ex2.csv\")\n    df1 = df1.drop([\"Unnamed: 0\"], axis=1)\n    df2 = pd.read_csv(\"scores_final_ex3.csv\")\n    df2 = df2.drop([\"Unnamed: 0\"], axis=1)\n    df = pd.concat([df1, df2], ignore_index=True, sort=False)\n    df.reset_index(inplace=True)\n\n    print(\"> Final scores...\")\n    # sample:\n    print(\"Number agents: {}, number games: {}\".format(df.shape[1], df.shape[0]))\n    # population: all games with the same config\n    baseline = np.array([])\n    w_model = np.array([])\n\n    for column_name in df.columns:\n        if column_name == \"index\":\n            continue\n        elif column_name[-3:] == \"_wm\":\n            w_model = np.append(w_model, df[column_name].to_numpy())\n        else:\n            baseline = np.append(baseline, df[column_name].to_numpy())\n\n    # scipy.stats.ttest_ind(cat1['values'], cat2['values'], equal_var=False)\n    # https:\/\/en.wikipedia.org\/wiki\/Welch%27s_t-test\n    # https:\/\/stats.stackexchange.com\/questions\/305\/when-conducting-a-t-test-why-would-one-prefer-to-assume-or-test-for-equal-vari\n    alpha = 0.0001\n    H_0 = \"H_0: world modelling agents mean scores <= baseline agents mean scores (one-sided t-test)\"\n    print(H_0)\n    result = stats.ttest_ind(baseline, w_model)\n    p_value = result.pvalue \/ 2.0\n    reject = p_value < alpha\n    print(\"One-sided t-test p-value: {}, reject H_0: {}\".format(p_value, reject))\n    means = [np.mean(w_model), np.mean(baseline)]\n    print(\"Mean: w_model={}, baseline={}\".format(means[0], means[1]))\n    # sns.distplot(w_model)\n    # plt.show()\n    _plot(baseline, w_model, \"scores.png\", \"score\", extra = 2)\n\n\ndef analysis_txs():\n    \"\"\"Analyse the txs.\"\"\"\n    # load scores\n    for typ in [\"seller\", \"buyer\"]:\n        print(\"---------------\\nAnalysis of {} txs:\".format(typ))\n        df1 = pd.read_csv(\"transactions_{}_ex2.csv\".format(typ))\n        df1 = df1.drop([\"Unnamed: 0\"], axis=1)\n        df2 = pd.read_csv(\"transactions_{}_ex3.csv\".format(typ))\n        df2 = df2.drop([\"Unnamed: 0\"], axis=1)\n        df = pd.concat([df1, df2], ignore_index=True, sort=False)\n        df.reset_index(inplace=True)\n        # sample:\n        print(\"Number agents: {}, number games: {}\".format(df.shape[1], df.shape[0]))\n        # population: all games with the same config\n        baseline = np.array([])\n        w_model = np.array([])\n\n        for column_name in df.columns:\n            if column_name == \"index\":\n                continue\n            elif column_name[-3:] == \"_wm\":\n                w_model = np.append(w_model, df[column_name].to_numpy())\n            else:\n                baseline = np.append(baseline, df[column_name].to_numpy())\n\n        # scipy.stats.ttest_ind(cat1['values'], cat2['values'], equal_var=False)\n        # https:\/\/en.wikipedia.org\/wiki\/Welch%27s_t-test\n        # https:\/\/stats.stackexchange.com\/questions\/305\/when-conducting-a-t-test-why-would-one-prefer-to-assume-or-test-for-equal-vari\n        alpha = 0.0001\n        H_0 = \"H_0: world modelling agents mean txs >= baseline agents mean txs (one-sided t-test)\"\n        print(H_0)\n        # Alternate: world modelling agents mean txs < baseline agents mean txs\n        result = stats.ttest_ind(baseline, w_model)\n        p_value = result.pvalue \/ 2.0\n        reject = p_value < alpha\n        print(\n            \"One-sided t-test p-value: {}, reject H_0 (world modelling agents mean txs >= baseline agents mean txs): {}\".format(\n                p_value, reject\n            )\n        )\n        means = [np.mean(w_model), np.mean(baseline)]\n        print(\"Mean: w_model={}, baseline={}\".format(means[0], means[1]))\n        # sns.distplot(w_model)\n        # plt.show()\n        _plot(baseline, w_model, \"txs_{}.png\".format(typ), \"no. of transactions\", extra = 2)\n\n\ndef analysis_prices():\n    \"\"\"Analyse the prices.\"\"\"\n    print(\"---------------\\nAnalysis of prices:\")\n    df1 = pd.read_csv(\"prices_ex2.csv\", dtype=np.float64)\n    df1 = df1.drop([\"Unnamed: 0\"], axis=1)\n    df2 = pd.read_csv(\"prices_ex3.csv\", dtype=np.float64)\n    df2 = df2.drop([\"Unnamed: 0\"], axis=1)\n    df = pd.concat([df1, df2], ignore_index=True, sort=False)\n    df.reset_index(inplace=True)\n    # sample:\n    print(\"Number observations: {}\".format(df.shape[0]))\n    # population: all games with the same config\n    baseline = df[\"baseline\"].to_numpy()\n    w_model = df[\"w_model\"].to_numpy()\n    w_model = w_model[~np.isnan(w_model)]\n\n    # scipy.stats.ttest_ind(cat1['values'], cat2['values'], equal_var=False)\n    # https:\/\/en.wikipedia.org\/wiki\/Welch%27s_t-test\n    # https:\/\/stats.stackexchange.com\/questions\/305\/when-conducting-a-t-test-why-would-one-prefer-to-assume-or-test-for-equal-vari\n    alpha = 0.0001\n    H_0 = \"H_0: world modelling agents mean prices <= baseline agents mean prices (one-sided t-test)\"\n    print(H_0)\n    result = stats.ttest_ind(baseline, w_model)\n    p_value = result.pvalue \/ 2.0\n    reject = p_value < alpha\n    print(\n        \"One-sided t-test p-value: {}, reject H_0 (world modelling agents mean prices <= baseline agents mean prices): {}\".format(\n            p_value, reject\n        )\n    )\n    means = [np.mean(w_model), np.mean(baseline)]\n    print(\"Mean: w_model={}, baseline={}\".format(means[0], means[1]))\n    # sns.distplot(w_model)\n    # plt.show()\n    _plot(baseline, w_model, \"prices.png\", \"price\", extra=0.2)\n\n\ndef _plot(baseline, w_model, file, x_label, label_one=\"baseline\", label_two=\"w_model\", cut_at_zero = True, extra = 10):\n    \"\"\"Plot helpert function.\"\"\"\n    min_bin = min(baseline.min(), w_model.min()) - extra\n    if cut_at_zero:\n        min_bin = max(min_bin, 0)\n    max_bin = max(baseline.max(), w_model.max()) + extra\n    bins = np.linspace(min_bin, max_bin, 100)\n    plt.hist(baseline, bins, alpha=0.5, label=label_one)\n    plt.hist(w_model, bins, alpha=0.5, label=label_two)\n    plt.legend(loc=\"upper right\")\n    plt.ylabel('count')\n    plt.xlabel(x_label)\n    # plt.show()\n    plt.savefig(file)\n    plt.clf()\n\n\nif __name__ == \"__main__\":\n    analysis_scores_initial_and_final_vs_equilibrium()\n    analysis_scores_final_min_initial()\n    analysis_scores()\n    analysis_txs()\n    analysis_prices()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_301","text":"\"\"\"\nParametric spline interpolator\n\nUseful when you need to interpolate a curve of values, like points along a flux surface or a chord\n\"\"\"\nimport warnings\nimport numpy as np\nfrom scipy.interpolate import splprep, splev\n\n\nclass ParametricSpline:\n    \"\"\"\n    A wrapper class around slprep and splev from scipy.interpolate\n    Uses cubic spline interpolation\n    \"\"\"\n\n    def __init__(\n        self,\n        sample_points: list,\n        t_points: np.array = None,\n        smoothing: float = 0.0,\n        periodic: bool = False,\n        order: int = 3,\n    ):\n        \"\"\"\n        Calculates the knots and coefficients for a parametric cubic spline interpolator\n\n        sample_points should be a list of 1D arrays, i.e. [x_points, y_points, ...]\n        If t_points is given, then the arrays given in sample points should be parametrised by t\n\n        If smoothing if > 0.0, then the input points will be smoothed. (Typically smoothing required << 1, recommend\n        to check the fit)\n\n        Order should be less than the number of sample points - 1\n        \"\"\"\n\n        sample_length = None\n        for sample_array in sample_points:\n            if sample_length is None:\n                # Use the first array to set the length\n                sample_length = len(sample_array)\n            else:\n                assert len(sample_array) == sample_length\n\n        assert sample_length > order, (\n            f\"Not enough sample points ({sample_length}) for an order ({order}) \"\n            \"ParametricSpline\"\n        )\n\n        if order < 3 and smoothing > 0.0:\n            warnings.warn(\n                UserWarning(\n                    \"Should not use smoothing for order < 3 in ParametricSpline\"\n                )\n            )\n\n        if t_points is None:\n            tck, self.t_points = splprep(\n                sample_points, s=smoothing, per=(1 if periodic else 0), k=order\n            )\n        else:\n            tck, self.t_points = splprep(\n                sample_points,\n                u=t_points,\n                s=smoothing,\n                per=(1 if periodic else 0),\n                k=order,\n            )\n\n        self.t_min, self.t_max = np.min(self.t_points), np.max(self.t_points)\n\n        self.knots, self.coeffs, self.order = tck\n\n    def __call__(self, t_evaluations: np.array):\n        \"\"\"\n        Returns the spline evaluations at points given by t_evaluations\n        N.b. if no t_points are provided to init, then the given sample points are assumed to be parametrised between 0 and 1\n        \"\"\"\n        # Interpolation only!\n        assert (\n            t_evaluations.min() >= self.t_min and t_evaluations.max() <= self.t_max\n        ), f\"Requested points in the range\\\n            {t_evaluations.min()}, {t_evaluations.max()}, which is outside the interval {self.t_min}, {self.t_max}\"\n\n        return splev(t_evaluations, (self.knots, self.coeffs, self.order))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_302","text":"import torch\nfrom collections import OrderedDict\nfrom .base_model import BaseModel\nfrom . import networks\nfrom typing import Union\nfrom util import util\nimport numpy as np\nfrom . import saw_utils\nfrom skimage.transform import resize\nfrom scipy.ndimage.filters import maximum_filter\nfrom scipy.ndimage.measurements import label\nimport cv2\nimport json\n\nclass BrightestCasModel(BaseModel):\n    \"\"\" This class implements the pix2pix model, for learning a mapping from input images to output images given paired data.\n\n    The model training requires '--dataset_mode aligned' dataset.\n    By default, it uses a '--netG unet256' U-Net generator,\n    a '--netD basic' discriminator (PatchGAN),\n    and a '--gan_mode' vanilla GAN loss (the cross-entropy objective used in the orignal GAN paper).\n\n    pix2pix paper: https:\/\/arxiv.org\/pdf\/1611.07004.pdf\n    \"\"\"\n    @staticmethod\n    def modify_commandline_options(parser, is_train=True):\n        \"\"\"Add new dataset-specific options, and rewrite default values for existing options.\n\n        Parameters:\n            parser          -- original option parser\n            is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.\n\n        Returns:\n            the modified parser.\n\n        For pix2pix, we do not use image buffer\n        The training objective is: GAN Loss + lambda_L1 * ||G(A)-B||_1\n        By default, we use vanilla GAN loss, UNet with batchnorm, and aligned datasets.\n        \"\"\"\n        # changing the default values to match the pix2pix paper (https:\/\/phillipi.github.io\/pix2pix\/)\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='vanilla')\n            parser.add_argument('--lambda_S', type=float, default=1.0, help='weight for Shading loss')\n            parser.add_argument('--lambda_AL', type=float, default=1.0, help='weight for Reflection loss')\n            parser.add_argument('--lambda_BA', type=float, default=1.0, help='weight for Brightest area loss')\n            parser.add_argument('--lambda_BP', type=float, default=1.0, help='weight for Brightest pixel loss')\n            parser.add_argument('--lambda_BC', type=float, default=1.0, help='weight for Brightest coordinate loss')\n        parser.add_argument('--cat_AL', action='store_true', help='Concat AL')\n        parser.add_argument('--cat_In', action='store_true', help='Concat Input')\n        parser.add_argument('--cat_In_AL', action='store_true', help='Concat Input and AL')\n\n        return parser\n\n    def __init__(self, opt):\n        \"\"\"Initialize the pix2pix class.\n\n        Parameters:\n            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions\n        \"\"\"\n        BaseModel.__init__(self, opt)\n\n        self.loss_names = ['G_AL', 'G_SH', 'G_BA', 'G_BP', 'G_BC']\n        self.visual_names = ['input', 'pr_BA', 'pr_BA2', 'gt_BA', 'pr_BP', 'pr_BP2', 'gt_BP', 'pr_AL', 'gt_AL', 'pr_SH', 'gt_SH', 'mask']\n\n        self.model_names = ['G1', 'G2', 'G3']\n\n        self.netG1 = networks.define_G(opt.input_nc, 3, opt.ngf, 'unet_256_multi', opt.norm,\n                                      not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n        self.netG2 = networks.define_G(opt.input_nc, 1, opt.ngf, 'resnet_9blocks_multi', opt.norm,\n                                        not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n\n        g3_input_nc = opt.input_nc\n        if opt.cat_AL or opt.cat_In:\n            g3_input_nc = g3_input_nc + 3\n        if opt.cat_In_AL:\n            g3_input_nc = g3_input_nc + 6\n        self.netG3 = networks.define_G(g3_input_nc, 1, opt.ngf, 'resnet_9blocks_multi', opt.norm,\n                                        not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)\n        if self.isTrain:\n            # define loss functions\n            self.criterionR = torch.nn.MSELoss()\n            self.criterionS = torch.nn.MSELoss()\n            self.criterionBA = torch.nn.MSELoss()\n            self.criterionBP = torch.nn.MSELoss()\n            self.criterionBC = torch.nn.MSELoss()\n            # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.\n            self.optimizer_G1 = torch.optim.Adam(self.netG1.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n            self.optimizer_G2 = torch.optim.Adam(self.netG2.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n            self.optimizer_G3 = torch.optim.Adam(self.netG3.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n            self.optimizers.append(self.optimizer_G1)\n            self.optimizers.append(self.optimizer_G2)\n            self.optimizers.append(self.optimizer_G3)\n\n    def set_input(self, input):\n        self.input = torch.squeeze(input['A'],0).to(self.device) # [bn, 3, 256, 256]\n        self.image_paths = input['A_paths']\n        self.gt_AL = torch.squeeze(input['gt_AL'],0).to(self.device) # [bn, 3, 256, 256]\n        self.gt_SH = torch.squeeze(input['gt_SH'],0).to(self.device) # [bn, 3, 256, 256]\n        self.mask = torch.squeeze(input['mask'],0).to(self.device) # [bn, 1, 256, 256]\n        self.gt_BA = torch.squeeze(input['gt_BA'],0).to(self.device) # [bn, 1, 256, 256]\n        self.gt_BP = torch.squeeze(input['gt_BP'],0).to(self.device) # [bn, 1, 256, 256]\n        self.gt_BC = input['gt_BC'].to(self.device) \n    \n    def forward(self):\n        \"\"\"Run forward pass; called by both functions <optimize_parameters> and <test>.\"\"\"\n        pr_SH, pr_AL, color = self.netG1(self.input)  # G(A)\n        self.pr_AL = pr_AL\n        pr_SH = pr_SH.repeat(1, 3, 1, 1)\n        pr_SH = pr_SH * 0.5 + 0.5\n        color = torch.unsqueeze(torch.unsqueeze(color, 2), 3)\n        self.pr_SH = pr_SH * color\n        self.pr_SH = self.pr_SH * 2.0 - 1.0\n        self.pr_BC, self.pr_BA, self.pr_BP = self.netG2(self.input)\n\n        if self.opt.cat_AL:\n            g3_input = torch.cat((self.pr_SH, self.pr_AL), 1)\n        elif self.opt.cat_In:\n            g3_input = torch.cat((self.pr_SH, self.input), 1)\n        elif self.opt.cat_In_AL:\n            g3_input = torch.cat((self.pr_SH, self.pr_AL), 1)\n            g3_input = torch.cat((g3_input, self.input), 1)\n        else:\n            g3_input = self.pr_SH\n\n        self.pr_BC2, self.pr_BA2, self.pr_BP2 = self.netG3(g3_input)\n        \n    def backward_G(self):\n        \"\"\"Calculate GAN and L1 loss for the generator\"\"\"\n        mask = self.mask*0.5 + 0.5\n        gt_BC = self.gt_BC[:,:,:2]\n        condition = int(self.gt_BC[:, 0, 2].item())\n        bc_num = int(self.gt_BC[:, 0, 3].item())\n\n        self.loss_G_AL = self.criterionR(self.pr_AL*mask, self.gt_AL*mask) * self.opt.lambda_AL\n        self.loss_G_SH = self.criterionS(self.pr_SH*mask, self.gt_SH*mask) * self.opt.lambda_S\n        self.loss_G_BA = self.criterionBA(self.pr_BA*mask, self.gt_BA*mask) * self.opt.lambda_BA\n        self.loss_G_BP = self.criterionBP(self.pr_BP*mask, self.gt_BP*mask) * self.opt.lambda_BP  \n        self.loss_G_BA2 = self.criterionBA(self.pr_BA2*mask, self.gt_BA*mask) * self.opt.lambda_BA\n        self.loss_G_BP2 = self.criterionBP(self.pr_BP2*mask, self.gt_BP*mask) * self.opt.lambda_BP  \n\n        self.loss_G = self.loss_G_AL + self.loss_G_SH + self.loss_G_BA + self.loss_G_BP + self.loss_G_BA2 + self.loss_G_BP2\n        if condition==1:\n            self.loss_G_BC = self.criterionBC(self.pr_BC, gt_BC.squeeze(1)) * self.opt.lambda_BC\n            self.loss_G_BC2 = self.criterionBC(self.pr_BC2, gt_BC.squeeze(1)) * self.opt.lambda_BC\n            self.loss_G += self.loss_G_BC + self.loss_G_BC2\n        # else:\n        elif condition==2:\n            loss_G_BC = util.min_loss_BC(self.pr_BC, gt_BC, bc_num, self.criterionBC)\n            loss_G_BC2 = util.min_loss_BC(self.pr_BC2, gt_BC, bc_num, self.criterionBC)\n\n            self.loss_G_BC = loss_G_BC * self.opt.lambda_BC\n            self.loss_G_BC2 = loss_G_BC2 * self.opt.lambda_BC\n            self.loss_G += self.loss_G_BC + self.loss_G_BC2\n        else:\n            print('Pass loss_G_BC because condition is {}'.format(condition))\n\n        self.loss_G.backward()\n\n    def optimize_parameters(self):\n        # with torch.autograd.set_detect_anomaly(True):\n        self.forward()                   # compute fake images: G(A)\n        self.optimizer_G1.zero_grad()        # set G's gradients to zero\n        self.optimizer_G2.zero_grad()        # set G's gradients to zero\n        self.optimizer_G3.zero_grad()        # set G's gradients to zero\n        self.backward_G()                   # calculate graidents for G\n        self.optimizer_G3.step()             # udpate G's weights\n        self.optimizer_G1.step()             # udpate G's weights\n        self.optimizer_G2.step()             # udpate G's weights\n\n    def get_current_visuals(self):\n        \"\"\"Return visualization images. train.py will display these images with visdom, and save the images to a HTML\"\"\"\n        visual_ret = OrderedDict()\n        for name in self.visual_names:\n            if isinstance(name, str):\n                visual_ret[name] = getattr(self, name)\n        visual_ret['pr_BP_BC'] = util.get_current_BC(self.pr_BC, self.pr_BP, self.opt)\n        visual_ret['pr_BP_BC2'] = util.get_current_BC(self.pr_BC2, self.pr_BP2, self.opt)\n        visual_ret['pr_BP_BP'] = util.get_current_BP(self.pr_BP, self.opt)\n        visual_ret['pr_BP_BP2'] = util.get_current_BP(self.pr_BP2, self.opt)\n        return visual_ret\n\n    def eval_label(self):\n        label = ['idx', 'condition', 'gt_BC_num']\n        label += self.label_base()['BC'] + self.label_sh()['BC'] + self.label_pr()['BC'] + self.label_pr(True, '2')['BC']\n        label += self.label_base()['bcDist'] + self.label_sh()['bcDist'] + self.label_pr()['bcDist'] + self.label_pr(True, '2')['dict_BC']\n        label += self.label_base()['baMSE'] + self.label_sh()['baMSE'] + self.label_pr()['baMSE'] + self.label_pr(True, '2')['baMSE']\n        label += self.label_base()['bpMSE'] + self.label_sh()['bpMSE'] + self.label_pr()['bpMSE'] + self.label_pr(True, '2')['bpMSE']\n        label += self.label_sh()['shEval']\n\n        return label\n\n    def eval_brightest_pixel(self, idx=0):\n        with torch.no_grad():\n            self.forward()     \n            self.compute_visuals()\n        \n\n        res_base = self.eval_bp_base(self.mask, self.gt_BA, self.gt_BP, self.gt_BC, self.input)\n        res_sh = self.eval_bp_sh(self.mask, self.gt_BA, self.gt_BP, self.gt_BC, self.pr_SH)\n        res_sh.update(self.eval_sh(self.mask, self.gt_SH, self.pr_SH))\n        res_pr = self.eval_bp_pr(self.mask, self.gt_BA, self.gt_BP, self.gt_BC, self.pr_BA, self.pr_BP, self.pr_BC, '')\n        res_pr2 = self.eval_bp_pr(self.mask, self.gt_BA, self.gt_BP, self.gt_BC, self.pr_BA2, self.pr_BP2, self.pr_BC2, '2')\n\n        result = [idx]\n        label = self.eval_label(idx)\n        for l in label:\n            if l in res_base:\n                result.append(res_base[l])\n            if l in res_pr:\n                result.append(res_pr[l])\n            if l in res_pr2:\n                result.append(res_pr2[l])\n        return list(result)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_303","text":"from . import select\nfrom . import utils\nfrom scipy import sparse\n\nimport numpy as np\nimport pandas as pd\nimport scipy.signal\n\n\ndef library_size(data):\n    \"\"\"Measure the library size of each cell.\n\n    Parameters\n    ----------\n    data : array-like, shape=[n_samples, n_features]\n        Input data\n\n    Returns\n    -------\n    library_size : list-like, shape=[n_samples]\n        Sum over all genes for each cell\n    \"\"\"\n    library_size = utils.matrix_sum(data, axis=1)\n    if isinstance(library_size, pd.Series):\n        library_size.name = \"library_size\"\n    return library_size\n\n\ndef gene_set_expression(\n    data,\n    genes=None,\n    library_size_normalize=False,\n    starts_with=None,\n    ends_with=None,\n    exact_word=None,\n    regex=None,\n):\n    \"\"\"Measure the expression of a set of genes in each cell.\n\n    Parameters\n    ----------\n    data : array-like, shape=[n_samples, n_features]\n        Input data\n    genes : list-like, shape<=[n_features], optional (default: None)\n        Integer column indices or string gene names included in gene set\n    library_size_normalize : bool, optional (default: False)\n        Divide gene set expression by library size\n    starts_with : str or None, optional (default: None)\n        If not None, select genes that start with this prefix\n    ends_with : str or None, optional (default: None)\n        If not None, select genes that end with this suffix\n    exact_word : str, list-like or None, optional (default: None)\n        If not None, select genes that contain this exact word.\n    regex : str or None, optional (default: None)\n        If not None, select genes that match this regular expression\n\n    Returns\n    -------\n    gene_set_expression : list-like, shape=[n_samples]\n        Sum over genes for each cell\n    \"\"\"\n    if library_size_normalize:\n        from .normalize import library_size_normalize\n\n        data = library_size_normalize(data)\n    gene_data = select.select_cols(\n        data,\n        idx=genes,\n        starts_with=starts_with,\n        ends_with=ends_with,\n        exact_word=exact_word,\n        regex=regex,\n    )\n    if len(gene_data.shape) > 1:\n        gene_set_expression = library_size(gene_data)\n    else:\n        gene_set_expression = gene_data\n    if isinstance(gene_set_expression, pd.Series):\n        gene_set_expression.name = \"expression\"\n    return gene_set_expression\n\n\ndef gene_variability(data, kernel_size=0.005, smooth=5, return_means=False):\n    \"\"\"Measure the variability of each gene in a dataset.\n\n    Variability is computed as the deviation from\n    the rolling median of the mean-variance curve\n\n    Parameters\n    ----------\n    data : array-like, shape=[n_samples, n_features]\n        Input data\n    kernel_size : float or int, optional (default: 0.005)\n        Width of rolling median window. If a float between 0 and 1, the width is given\n        by kernel_size * data.shape[1]. Otherwise should be an odd integer\n    smooth : int, optional (default: 5)\n        Amount of smoothing to apply to the median filter\n    return_means : boolean, optional (default: False)\n        If True, return the gene means\n\n    Returns\n    -------\n    variability : list-like, shape=[n_samples]\n        Variability for each gene\n    \"\"\"\n    columns = data.columns if isinstance(data, pd.DataFrame) else None\n    data = utils.to_array_or_spmatrix(data)\n    if isinstance(data, sparse.dia_matrix):\n        data = data.tocsc()\n    data_std = utils.matrix_std(data, axis=0) ** 2\n    data_mean = utils.toarray(data.mean(axis=0)).flatten()\n\n    if kernel_size < 1:\n        kernel_size = 2 * (int(kernel_size * len(data_std)) \/\/ 2) + 1\n\n    order = np.argsort(data_mean)\n    data_std_med = np.empty_like(data_std)\n    data_std_order = data_std[order]\n    # handle overhang with reflection\n    data_std_order = np.r_[\n        data_std_order[kernel_size::-1],\n        data_std_order,\n        data_std_order[:-kernel_size:-1],\n    ]\n    medfilt = scipy.signal.medfilt(data_std_order, kernel_size=kernel_size)[\n        kernel_size:-kernel_size\n    ]\n\n    # apply a little smoothing\n    for i in range(smooth):\n        medfilt = np.r_[(medfilt[1:] + medfilt[:-1]) \/ 2, medfilt[-1]]\n\n    data_std_med[order] = medfilt\n    result = data_std - data_std_med\n\n    if columns is not None:\n        result = pd.Series(result, index=columns, name=\"variability\")\n        data_mean = pd.Series(data_mean, index=columns, name=\"mean\")\n    if return_means:\n        result = result, data_mean\n    return result\n\n\ndef gene_capture_count(data, cutoff=0):\n    \"\"\"Measure the number of cells in which each gene has non-negligible counts.\n\n    Parameters\n    ----------\n    data : array-like, shape=[n_samples, n_features]\n        Input data\n    cutoff : float, optional (default: 0)\n        Number of counts above which expression is deemed non-negligible\n\n    Returns\n    -------\n    capture-count : list-like, shape=[m_features]\n        Capture count for each gene\n    \"\"\"\n    gene_sums = np.array(utils.matrix_sum(data > cutoff, axis=0)).reshape(-1)\n    if isinstance(data, pd.DataFrame):\n        gene_sums = pd.Series(gene_sums, index=data.columns, name=\"capture_count\")\n    return gene_sums\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_294","text":"<gh_stars>1-10\n#!\/usr\/bin\/env python3\n\"\"\"\nI\/O and related utils.\n\nAttributes\n----------\nEXT_1D : list\n    List of supported TXT\/1D file extensions, in lower case.\nEXT_MAT : list\n    List of supported matlab file extensions, in lower case.\nEXT_NIFTI : list\n    List of supported nifti file extensions, in lower case.\nEXT_XLS : list\n    List of supported XLS-like file extensions, in lower case.\nLGR\n    Logger\n\"\"\"\n\nimport logging\n\nfrom os import makedirs\nfrom os.path import exists, join\n\nimport numpy as np\n\nfrom nigsp.utils import change_var_type\n\n\nEXT_1D = ['.txt', '.csv', '.tsv', '.1d', '.par', '.tsv.gz', '.csv.gz']\nEXT_XLS = ['.xls']\nEXT_MAT = ['.mat']\nEXT_NIFTI = ['.nii', '.nii.gz']\nEXT_ALL = EXT_1D + EXT_XLS + EXT_MAT + EXT_NIFTI\n\nEXT_DICT = {'1D': EXT_1D, 'xls': EXT_XLS, 'mat': EXT_MAT, 'nifti': EXT_NIFTI}\n\nLGR = logging.getLogger(__name__)\n\n\ndef check_ext(all_ext, fname, scan=False, remove=False):\n    \"\"\"\n    Check which extension a file has, and possibly remove it.\n\n    Parameters\n    ----------\n    all_ext : list\n        All possible extensions to check within\n    fname : str or os.PathLikeLike\n        The filename to check\n    scan : bool, optional\n        Scan the given path to see if there is a file with that extension\n        If True and no path declared, check if fname has a path, if not scan '.'\n        If False, don't scan any folder\n    remove : bool, optional\n        Remove the extention from fname if it has one\n\n    Returns\n    -------\n    obj_return : Uses a list to return variable amount of options.\n        has_ext : boolean\n            True if the extension is found, false otherwise\n        fname : str or os.PathLike\n            If `remove` is True, return (extensionless) fname\n        ext : str\n            If both `remove` and `has_ext` are True, returns also found extension\n    \"\"\"\n    has_ext = False\n    all_ext = change_var_type(all_ext, list, stop=False, silent=True)\n    for ext in all_ext:\n        if fname.lower().endswith(ext):\n            has_ext = True\n            LGR.debug(f'{fname} ends with extension {ext}')\n            break\n\n    if not has_ext and scan:\n        for ext in all_ext:\n            if exists(f'{fname}{ext}'):\n                fname = f'{fname}{ext}'\n                LGR.warning(f'Found {fname}{ext}, using it as input henceforth')\n                has_ext = True\n                break\n\n    obj_return = [has_ext]\n\n    if remove:\n        if has_ext:\n            obj_return += [fname[:-len(ext)], ext]  # case insensitive solution\n        else:\n            obj_return += [fname, '']\n    else:\n        obj_return += [fname]\n\n    return obj_return[:]\n\n\ndef check_nifti_dim(fname, data, dim=4):\n    \"\"\"\n    Check number of dimensions in nifti file.\n\n    Parameters\n    ----------\n    fname : str\n        The name of the file representing `data`\n    data : numpy.ndarray\n        The data which dimensionality needs to be checked\n    dim : int, optional\n        The amount of dimensions expected\/desired in the data.\n\n    Returns\n    -------\n    numpy.ndarray\n        If `data.ndim` = `dim`, returns data.\n\n    Raises\n    ------\n    ValueError\n        If `data` has different dimensions than `dim`\n    \"\"\"\n    data = data.squeeze()\n\n    if data.ndim != dim:\n        raise ValueError(f'A {dim}D nifti file is required, but {fname} is '\n                         f'{data.ndim}D. Please check the input file.')\n\n    return data\n\n\ndef check_mtx_dim(fname, data, shape=None):\n    \"\"\"\n    Check dimensions of a matrix.\n\n    Parameters\n    ----------\n    fname : str\n        The name of the file representing `data`\n    data : np.ndarray\n        The data which dimensionality needs to be checked\n    shape : None, 'square', or 'rectangle'}, str, optional\n        Shape of matrix, if empty, skip shape check\n\n    Returns\n    -------\n    np.ndarray\n        If `data.ndim` = 2, returns data.\n        If `data.ndim` = 1 and `shape` == 'rectangle', \n        Returns data with added empty axis.\n\n    Raises\n    ------\n    NotImplementedError\n        If `data` has more than 3 dimensions.\n        If `shape` is not None but `data` is 3D.\n    ValueError\n        If `data` is empty\n        If `shape` == 'square' and `data` dimensions have different lenghts.\n    \"\"\"\n    data = data.squeeze()\n    LGR.info('Checking data shape.')\n\n    if data.shape[0] == 0:\n        raise ValueError(f'{fname} is empty!')\n    if data.ndim > 3:\n        raise NotImplementedError('Only matrices up to 3D are supported, but '\n                                  f'given matrix is {data.ndim}D.')\n    if shape is not None:\n        if data.ndim > 2:\n            raise NotImplementedError('Cannot check shape of 3D matrix.')\n        if data.ndim == 1 and shape == 'rectangle':\n            data = data[..., np.newaxis]\n            LGR.warning(f'Rectangular matrix required, but {fname} is a vector. '\n                        'Adding empty dimension.')\n        if shape == 'square' and data.shape[0] != data.shape[1]:\n            raise ValueError(f'Square matrix required, but {fname} matrix has '\n                             f'shape {data.shape}.')\n\n    return data\n\n\ndef load_nifti_get_mask(fname, is_mask=False, ndim=4):\n    \"\"\"\n    Load a nifti file and returns its data, its image, and a 3d mask.\n\n    Parameters\n    ----------\n    fname : str\n        The filename to read in\n    is_mask : bool, optional\n        If the file contains a mask.\n        Default: False\n    ndim : int\n        The number of dimensions expected in the mask\n\n    Returns\n    -------\n    data : numpy.ndarray\n        Data from nifti file.\n    mask : numpy.ndarray\n        If `is_mask` is False, numpy.ndarray of one dimension less than data,\n        in which any element that has at least a value different from zero\n        in the last dimension of `data` is True.\n        If `is_mask` is True, mask is a boolean representation of data.\n    img : nib.img\n        Image object from nibabel.\n\n    \"\"\"\n    try:\n        import nibabel as nib\n    except ImportError:\n        raise ImportError('nibabel is required to import nifti files. '\n                          'Please see install instructions.')\n\n    LGR.info(f'Loading {fname}.')\n    img = nib.load(fname)\n    data = img.get_fdata()\n    data = check_nifti_dim(fname, data, dim=ndim)\n\n    if is_mask:\n        mask = (data != 0)\n        LGR.info(f'{fname} loaded as mask.')\n    else:\n        mask = data.any(axis=-1).squeeze()\n        LGR.info(f'Data loaded from {fname}.')\n\n    return data, mask, img\n\n\ndef load_txt(fname, shape=None):\n    \"\"\"\n    Read files in textual format.\n\n    Parameters\n    ----------\n    fname : str or os.PathLike\n        Path to the txt file\n    shape : None, 'square', or 'rectangle', optional\n        Shape of matrix, if empty, skip check\n\n    Returns\n    -------\n    mtx : numpy.ndarray\n        Data matrix\n\n    See also\n    --------\n    check_mtx_dim\n    \"\"\"\n    LGR.info(f'Loading {fname}.')\n\n    _, _, ext = check_ext(EXT_1D, fname, scan=True, remove=True)\n\n    if ext in ['.csv', '.csv.gz']:\n        delimiter = ','\n    elif ext in ['.tsv', '.tsv.gz']:\n        delimiter = '\\t'\n    elif ext in ['.txt', '.1d', '.par']:\n        delimiter = ' '\n    else:\n        delimiter = None\n\n    mtx = np.genfromtxt(fname, delimiter=delimiter)\n\n    mtx = check_mtx_dim(fname, mtx, shape)\n\n    return mtx\n\n\ndef load_mat(fname, shape=None):\n    \"\"\"\n    Read files in matlab format.\n\n    Assumes the existence of a matrix\/vector in the mat file, rendered as \n    a numpy.ndarray. If there is more than a marix, the one with the largest \n    size will be selected.\n\n    Parameters\n    ----------\n    fname : str or os.PathLike\n        Path to the mat file\n    shape : None, 'square', or 'rectangle'}, str, optional\n        Shape of matrix, if empty, skip check\n\n    Returns\n    -------\n    mtx : numpy.ndarray\n        Data matrix\n\n    Notes\n    -----\n    Requires module pymatreader to work\n\n    See also\n    --------\n    check_mtx_dim\n\n    Raises\n    ------\n    EOFError\n        If the mat file does not contain matrix or vectors.\n    ImportError\n        If pymatreader is not installed or can't be read.\n    \"\"\"\n    try:\n        from pymatreader import read_mat\n    except ImportError:\n        raise ImportError('pymatreader is required to import mat files. '\n                          'Please see install instructions.')\n\n    LGR.info(f'Loading {fname}.')\n    data = read_mat(fname)\n\n    data_keys = []\n    for k in data.keys():\n        # Check data key only if it's not hidden\n        # (skip '__header__', '__version__', '__global__')\n        if '__' not in k:\n            LGR.info(f'Checking {fname} key {str(k)} content for data (float array\/matrices in MATLAB).')\n            if type(data[k]) is np.ndarray:\n                data_keys.append(k)\n\n    if len(data_keys) < 1:\n        raise EOFError(f'{fname} does not seem to contain a numeric matrix.')\n    elif len(data_keys) > 1:\n        LGR.warning('Found multiple possible arrays to load. '\n                    'Selecting the biggest (highest pythonic size).')\n\n    key = data_keys[0]\n    for k in data_keys[1:]:\n        if data[k].size > data[key].size:\n            key = k\n\n    LGR.info(f'Selected data from MATLAB variable {key}')\n    mtx = data[key]\n    mtx = check_mtx_dim(fname, mtx, shape)\n\n    return mtx\n\n\ndef load_xls(fname, shape=''):\n    \"\"\"\n    Read files in xls format.\n\n    Parameters\n    ----------\n    fname : str or os.PathLike\n        Path to the mat file\n    shape : None, 'square', or 'rectangle'}, str, optional\n        Shape of matrix, if empty, skip check\n\n    Notes\n    -----\n    Requires module _ to work\n\n    See also\n    --------\n    check_mtx_dim\n\n    No Longer Returned\n    ------------------\n    mtx : numpy.ndarray\n        Data matrix\n\n    Raises\n    ------\n    NotImplementedError\n        Spreadheet loading is not implemented yet.\n    \"\"\"\n    raise NotImplementedError('Spreadsheet loading is not implemented yet')\n\n\ndef export_nifti(data, img, fname):\n    \"\"\"\n    Export a nifti file.\n\n    Parameters\n    ----------\n    data : numpy.ndarray\n        Data to be exported\n    img : nib.img\n        Nibabel image object\n    fname : str or os.PathLike\n        Name of the output file\n    \"\"\"\n    try:\n        import nibabel as nib\n    except ImportError:\n        raise ImportError('nibabel is required to export nifti files. '\n                          'Please see install instructions.')\n\n    for e in EXT_NIFTI:\n        has_ext, fname, ext = check_ext(e, fname, remove=True)\n        if has_ext:\n            break\n\n    if ext == '':\n        ext = '.nii.gz'\n\n    LGR.info(f'Exporting nifti data into {fname}{ext}.')\n    out_img = nib.Nifti1Image(data, img.affine, img.header)\n    out_img.to_filename(f'{fname}{ext}')\n\n    return 0\n\n\ndef export_txt(data, fname, ext=None):\n    \"\"\"\n    Export data into a text-like or mat file.\n\n    Parameters\n    ----------\n    data : np.ndarray\n        Data to be exported.\n    fname : str or os.PathLike\n        Name of the output file.\n    ext : str or None, optional\n        Selected extension for export.\n\n    Returns\n    -------\n    0\n        On a successful run\n    \"\"\"\n    if ext.lower() in ['.csv', '.csv.gz', '', None]:\n        delimiter = ','\n    elif ext.lower() in ['.tsv', '.tsv.gz']:\n        delimiter = '\\t'\n    elif ext.lower() in ['.txt', '.1d', '.par']:\n        delimiter = ' '\n    else:\n        delimiter = None\n\n    if data.ndim < 3:\n        np.savetxt(f'{fname}{ext}', data, fmt='%.6f', delimiter=delimiter)\n    elif data.ndim == 3:\n        makedirs(fname, exist_ok=True)\n        for i in range(data.shape[-1]):\n            np.savetxt(join(fname, f'{i:03d}{ext}'), data[:, :, i], fmt='%.6f',\n                       delimiter=delimiter)\n\n    return 0\n\n\ndef export_mtx(data, fname, ext=None):\n    \"\"\"\n    Export data into a text-like or mat file.\n\n    Parameters\n    ----------\n    data : np.ndarray\n        Data to be exported.\n    fname : str or os.PathLike\n        Name of the output file.\n    ext : str or None, optional\n        Selected extension for export.\n\n    Notes\n    -----\n    Requires module scipy to export in .mat format.\n    (Will require other modules to export in XLS-like format)\n\n    Raises\n    ------\n    BrokenPipeError\n        If somewhat an extension that is not supported passes all checks.\n        (This should never happen)\n    ImportError\n        If scipy is not installed or cannot be found.\n    NotImplementedError\n        Spreadheet output is not implemented yet.\n\n    Returns\n    -------\n    0\n        On a successful run\n    \"\"\"\n    if ext is None:\n        # Check if extension was provided in fname.\n        for e in EXT_ALL:\n            has_ext, fname, ext = check_ext(e, fname, remove=True)\n            if has_ext:\n                break\n    elif ext.lower() not in EXT_ALL:\n        # Check if extension is supported.\n        ext = None\n\n    if ext in [None, '']:\n        LGR.warning('Extension not specified, or specified extension not '\n                    'supported. Forcing export in CSV format.')\n        ext = '.csv'\n    elif ext.lower() in EXT_NIFTI:\n        LGR.warning('Found nifti extension, exporting data in .1D instead')\n        ext = '.1D'\n\n    LGR.info(f'Exporting data into {fname}{ext}.')\n    if ext.lower() in EXT_MAT:\n        try:\n            import scipy\n        except ImportError:\n            raise ImportError('To export .mat files, scipy is required. '\n                              'Please install it.')\n        scipy.io.savemat(f'{fname}{ext}', {'data': data})\n    elif ext.lower() in EXT_XLS:\n        raise NotImplementedError('Spreadsheet output is not implemented yet')\n    elif ext.lower() in EXT_1D:\n        export_txt(data, fname, ext)\n    else:\n        raise BrokenPipeError(f'This should not have happened: {ext} was the '\n                              'selected extension.')\n\n    return 0\n\n\n\"\"\"\nCopyright 2022, <NAME>.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp:\/\/www.apache.org\/licenses\/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_288","text":"# Copyright 2020 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#      http:\/\/www.apache.org\/licenses\/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Test `BrownianPath`.\n\nThe suite tests both running on CPU and CUDA (if available).\n\"\"\"\nimport sys\n\nsys.path = sys.path[1:]  # A hack so that we always import the installed library.\n\nimport math\nimport numpy as np\nimport numpy.random as npr\nimport torch\nfrom scipy.stats import norm, kstest\n\nimport torchsde\nimport pytest\n\ntorch.manual_seed(1147481649)\ntorch.set_default_dtype(torch.float64)\n\nD = 3\nBATCH_SIZE = 131072\nREPS = 3\nALPHA = 0.00001\n\ndevices = [cpu, gpu] = [torch.device('cpu'), torch.device('cuda')]\n\n\ndef _setup(device):\n    t0, t1 = torch.tensor([0., 1.], device=device)\n    w0, w1 = torch.randn([2, BATCH_SIZE, D], device=device)\n    t = torch.rand([], device=device)\n    bm = torchsde.BrownianPath(t0=t0, w0=w0)\n    return t, bm\n\n\n@pytest.mark.parametrize(\"device\", devices)\ndef test_basic(device):\n    if device == gpu and not torch.cuda.is_available():\n        pytest.skip(msg=\"CUDA not available.\")\n\n    t, bm = _setup(device)\n    sample = bm(t)\n    assert sample.size() == (BATCH_SIZE, D)\n\n\n@pytest.mark.parametrize(\"device\", devices)\ndef test_determinism(device):\n    if device == gpu and not torch.cuda.is_available():\n        pytest.skip(msg=\"CUDA not available.\")\n\n    t, bm = _setup(device)\n    vals = [bm(t) for _ in range(REPS)]\n    for val in vals[1:]:\n        assert torch.allclose(val, vals[0])\n\n\n@pytest.mark.parametrize(\"device\", devices)\ndef test_normality(device):\n    if device == gpu and not torch.cuda.is_available():\n        pytest.skip(msg=\"CUDA not available.\")\n\n    t0_, t1_ = 0.0, 1.0\n    eps = 1e-2\n    for _ in range(REPS):\n        w0_ = npr.randn() * math.sqrt(t1_)\n        w0 = torch.tensor(w0_, device=device).repeat(BATCH_SIZE)\n\n        bm = torchsde.BrownianPath(t0=t0_, w0=w0)  # noqa\n\n        w1_ = bm(t1_).cpu().numpy()\n\n        t_ = npr.uniform(low=t0_ + eps, high=t1_ - eps)  # Avoid sampling too close to the boundary.\n        samples_ = bm(t_).cpu().numpy()\n\n        # True expected mean from Brownian bridge.\n        mean_ = ((t1_ - t_) * w0_ + (t_ - t0_) * w1_) \/ (t1_ - t0_)\n        std_ = math.sqrt((t1_ - t_) * (t_ - t0_) \/ (t1_ - t0_))\n        ref_dist = norm(loc=np.zeros_like(mean_), scale=np.ones_like(std_))\n\n        _, pval = kstest((samples_ - mean_) \/ std_, ref_dist.cdf)\n        assert pval >= ALPHA\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_176","text":"<reponame>codersUP\/MO-Labs\nimport numpy as np\n\nfrom scipy.optimize import minimize\n\n\n\ndef rosen(x):\n\n    \"\"\"The Rosenbrock function\"\"\"\n\n    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)\n\n\n\ndef exercise_2(n:int):\n    # x0 = np.array([0 for i in range(n)])\n    x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2]) # Este es el de la documentación\n    # x0 = np.array([20, 12, 57, 9, 76])\n    \n\n    res = minimize(rosen, x0, method='nelder-mead',\n\n               options={'xatol': 1e-8, 'disp': True})\n    print(res.x)\n\nexercise_2(5)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_177","text":"# -*- coding: utf-8 -*-\n# SPDX-License-Identifier: BSD-3-Clause\n\nfrom __future__ import annotations\nimport warnings\n\nimport numpy as np\nfrom scipy import stats\nfrom sklearn.utils.validation import check_is_fitted, check_consistent_length, check_array\nfrom tqdm.auto import tqdm\n\nfrom .base import HubnessReduction\n\n\nclass MutualProximity(HubnessReduction):\n    \"\"\" Hubness reduction with Mutual Proximity [1]_.\n\n    Parameters\n    ----------\n    method: 'normal' or 'empiric', default = 'normal'\n        Model distance distribution with 'method'.\n\n        - 'normal' or 'gaussi' model distance distributions with independent Gaussians (fast)\n        - 'empiric' or 'exact' model distances with the empiric distributions (slow)\n\n    verbose: int, default = 0\n        If verbose > 0, show progress bar.\n\n    References\n    ----------\n    .. [1] <NAME>., <NAME>., <NAME>., & <NAME>. (2012).\n           Local and global scaling reduce hubs in space. The Journal of Machine\n           Learning Research, 13(1), 2871–2902.\n    \"\"\"\n\n    def __init__(self, method: str = 'normal', verbose: int = 0, **kwargs):\n        super().__init__(**kwargs)\n        self.method = method\n        self.verbose = verbose\n\n    def fit(self, neigh_dist, neigh_ind, X=None, assume_sorted=None, *args, **kwargs) -> MutualProximity:\n        \"\"\" Fit the model using neigh_dist and neigh_ind as training data.\n\n        Parameters\n        ----------\n        neigh_dist: np.ndarray, shape (n_samples, n_neighbors)\n            Distance matrix of training objects (rows) against their\n            individual k nearest neighbors (columns).\n\n        neigh_ind: np.ndarray, shape (n_samples, n_neighbors)\n            Neighbor indices corresponding to the values in neigh_dist.\n\n        X: ignored\n\n        assume_sorted: ignored\n        \"\"\"\n        # Check equal number of rows and columns\n        check_consistent_length(neigh_ind, neigh_dist)\n        check_consistent_length(neigh_ind.T, neigh_dist.T)\n        check_array(neigh_dist, force_all_finite=False)\n        check_array(neigh_ind)\n\n        self.n_train = neigh_dist.shape[0]\n\n        if self.method in ['exact', 'empiric']:\n            self.method = 'empiric'\n            self.neigh_dist_train_ = neigh_dist\n            self.neigh_ind_train_ = neigh_ind\n        elif self.method in ['normal', 'gaussi']:\n            self.method = 'normal'\n            self.mu_train_ = np.nanmean(neigh_dist, axis=1)\n            self.sd_train_ = np.nanstd(neigh_dist, axis=1, ddof=0)\n        else:\n            raise ValueError(f'Mutual proximity method \"{self.method}\" not recognized. Try \"normal\" or \"empiric\".')\n\n        return self\n\n    def transform(self, neigh_dist, neigh_ind, X=None, assume_sorted=None, *args, **kwargs):\n        \"\"\" Transform distance between test and training data with Mutual Proximity.\n\n        Parameters\n        ----------\n        neigh_dist: np.ndarray\n            Distance matrix of test objects (rows) against their individual\n            k nearest neighbors among the training data (columns).\n\n        neigh_ind: np.ndarray\n            Neighbor indices corresponding to the values in neigh_dist\n\n        X: ignored\n\n        assume_sorted: ignored\n\n        Returns\n        -------\n        hub_reduced_dist, neigh_ind\n            Mutual Proximity distances, and corresponding neighbor indices\n\n        Notes\n        -----\n        The returned distances are NOT sorted! If you use this class directly,\n        you will need to sort the returned matrices according to hub_reduced_dist.\n        Classes from :mod:`skhubness.neighbors` do this automatically.\n        \"\"\"\n        check_is_fitted(self, ['mu_train_', 'sd_train_', 'neigh_dist_train_', 'neigh_ind_train_'], all_or_any=any)\n        check_array(neigh_dist, force_all_finite='allow-nan')\n        check_array(neigh_ind)\n\n        n_test, n_indexed = neigh_dist.shape\n\n        if n_indexed == 1:\n            warnings.warn(f'Cannot perform hubness reduction with a single neighbor per query. '\n                          f'Skipping hubness reduction, and returning untransformed distances.')\n            return neigh_dist, neigh_ind\n\n        hub_reduced_dist = np.empty_like(neigh_dist)\n\n        # Show progress in hubness reduction loop\n        disable_tqdm = False if self.verbose else True\n        range_n_test = tqdm(range(n_test),\n                            desc=f'MP ({self.method})',\n                            disable=disable_tqdm,\n                            )\n\n        # Calculate MP with independent Gaussians\n        if self.method == 'normal':\n            mu_train = self.mu_train_\n            sd_train = self.sd_train_\n            for i in range_n_test:\n                j_mom = neigh_ind[i]\n                mu = np.nanmean(neigh_dist[i])\n                sd = np.nanstd(neigh_dist[i], ddof=0)\n                p1 = stats.norm.sf(neigh_dist[i, :], mu, sd)\n                p2 = stats.norm.sf(neigh_dist[i, :], mu_train[j_mom], sd_train[j_mom])\n                hub_reduced_dist[i, :] = (1 - p1 * p2).ravel()\n        # Calculate MP empiric (slow)\n        elif self.method == 'empiric':\n            max_ind = self.neigh_ind_train_.max()\n            for i in range_n_test:\n                dI = neigh_dist[i, :][np.newaxis, :]  # broadcasted afterwards\n                dJ = np.zeros((dI.size, n_indexed))\n                for j in range(n_indexed):\n                    tmp = np.zeros(max_ind + 1) + (self.neigh_dist_train_[neigh_ind[i, j], -1] + 1e-6)\n                    tmp[self.neigh_ind_train_[neigh_ind[i, j]]] = self.neigh_dist_train_[neigh_ind[i, j]]\n                    dJ[j, :] = tmp[neigh_ind[i]]\n                # dJ = self.neigh_dist_train_[neigh_ind[i], :n_indexed]\n                d = dI.T\n                hub_reduced_dist[i, :] = 1. - (np.sum((dI > d) & (dJ > d), axis=1) \/ n_indexed)\n        else:\n            raise ValueError(f\"Internal: Invalid method {self.method}.\")\n\n        # Return the hubness reduced distances\n        # These must be sorted downstream\n        return hub_reduced_dist, neigh_ind\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_178","text":"import numpy as np\nimport open3d as o3d\nfrom transformations import *\nimport os,sys,yaml,copy,pickle,time,cv2,socket,argparse,inspect,trimesh,operator,gzip,re,random,torch\nimport resource\nrlimit = resource.getrlimit(resource.RLIMIT_NOFILE)\nresource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1]))\nfrom scipy.spatial import cKDTree\ncode_dir = os.path.dirname(os.path.realpath(__file__))\nsys.path.append(code_dir)\nsys.path.append(\"{}\/..\/\".format(code_dir))\nsys.path.append(\"{}\/ss-pybullet\".format(code_dir))\nfrom dexnet.grasping.grasp import ParallelJawPtGrasp3D\nfrom autolab_core import YamlConfig\nfrom dexnet.grasping.grasp_sampler import PointConeGraspSampler,NocsTransferGraspSampler\nfrom PIL import Image\nfrom Utils import *\nfrom data_reader import *\nfrom pointnet2 import *\nfrom aligning import *\nimport PointGroup.data.dataset_seg as dataset_seg\nfrom PointGroup.model.pointgroup.pointgroup import PointGroup\nimport PointGroup.lib.pointgroup_ops.functions.pointgroup_ops as pointgroup_ops\nimport PointGroup.util.config as config_pg\nimport spconv\nfrom spconv.modules import SparseModule\nfrom dataset_nunocs import NunocsIsolatedDataset\nfrom dataset_grasp import GraspDataset\nfrom functools import partial\nfrom sklearn.cluster import DBSCAN,MeanShift\ntorch.multiprocessing.set_sharing_strategy('file_system')\nfrom multiprocessing import Pool\nimport multiprocessing\nfrom functools import partial\nfrom itertools import repeat\n\n\n\nclass GraspPredicter:\n  def __init__(self,class_name):\n    self.class_name_to_artifact_id = {\n      'nut': 47,\n      'hnm': 51,\n      'screw': 50,\n    }\n    artifact_id = self.class_name_to_artifact_id[class_name]\n    code_dir = os.path.dirname(os.path.realpath(__file__))\n    artifact_dir = f\"{code_dir}\/artifacts\/artifacts-{artifact_id}\"\n    print('GraspPredicter artifact_dir',artifact_dir)\n    with open(f\"{artifact_dir}\/config_grasp.yml\",'r') as ff:\n      self.cfg = yaml.safe_load(ff)\n\n    normalizer_dir = '{}\/normalizer.pkl'.format(artifact_dir)\n    if os.path.exists(normalizer_dir):\n      with open(normalizer_dir,'rb') as ff:\n        tmp = pickle.load(ff)\n      self.cfg['mean'] = tmp['mean']\n      self.cfg['std'] = tmp['std']\n\n    self.dataset = GraspDataset(self.cfg,phase='test',class_name=class_name)\n\n    self.model = PointNetCls(n_in=self.cfg['input_channel'],n_out=len(self.cfg['classes'])-1)\n    self.model = load_model(self.model,ckpt_dir='{}\/best_val.pth.tar'.format(artifact_dir))\n    self.model.cuda().eval()\n\n\n  def predict_batch(self,data,grasp_poses):\n    with torch.no_grad():\n      batch_size = 200\n      input_datas = []\n      for i in range(len(grasp_poses)):\n        data_transformed = self.dataset.transform(copy.deepcopy(data),grasp_poses[i])\n        input_data = torch.from_numpy(data_transformed['input'])\n        input_datas.append(input_data)\n\n      input_datas = torch.stack(input_datas,dim=0)\n      n_split = int(np.ceil(len(input_datas)\/batch_size))\n      ids = np.arange(len(input_datas))\n      ids_split = np.array_split(ids,n_split)\n\n      out = []\n      for i in range(len(ids_split)):\n        ids = ids_split[i]\n        input_data = input_datas[ids].cuda().float()\n        pred = self.model(input_data)[0]\n        pred = pred.softmax(dim=1).data.cpu().numpy()\n        for b in range(len(pred)):\n          cur_pred = pred[b]\n          pred_label = cur_pred.argmax()\n          confidence = cur_pred[pred_label]\n          out.append([pred_label,confidence,cur_pred])\n    torch.cuda.empty_cache()\n\n    return out\n\n\n\nclass NunocsPredicter:\n  def __init__(self,class_name):\n    self.class_name = class_name\n    self.class_name_to_artifact_id = {\n      'nut': 78,\n      'hnm': 73,\n      'screw': 76\n    }\n    if self.class_name=='nut':\n      self.min_scale = [0.005,0.005,0.001]\n      self.max_scale = [0.05,0.05,0.05]\n    elif self.class_name=='hnm':\n      self.min_scale = [0.005,0.005,0.005]\n      self.max_scale = [0.15,0.05,0.05]\n    elif self.class_name=='screw':\n      self.min_scale = [0.005,0.005,0.005]\n      self.max_scale = [0.15,0.05,0.05]\n\n    artifact_id = self.class_name_to_artifact_id[class_name]\n    code_dir = os.path.dirname(os.path.realpath(__file__))\n    artifact_dir = f\"{code_dir}\/artifacts\/artifacts-{artifact_id}\"\n    print('NunocsPredicter artifact_dir',artifact_dir)\n    with open(f\"{artifact_dir}\/config_nunocs.yml\",'r') as ff:\n      self.cfg = yaml.safe_load(ff)\n    if os.path.exists('{}\/normalizer.pkl'.format(artifact_dir)):\n      with open('{}\/normalizer.pkl'.format(artifact_dir),'rb') as ff:\n        tmp = pickle.load(ff)\n      self.cfg['mean'] = tmp['mean']\n      self.cfg['std'] = tmp['std']\n    self.dataset = NunocsIsolatedDataset(self.cfg,phase='test')\n\n    self.model = PointNetSeg(n_in=self.cfg['input_channel'],n_out=3*self.cfg['ce_loss_bins'])\n\n    self.model = load_model(self.model,ckpt_dir='{}\/best_val.pth.tar'.format(artifact_dir))\n    self.model.cuda().eval()\n\n\n  def predict(self,data):\n    with torch.no_grad():\n      data['cloud_nocs'] = np.zeros(data['cloud_xyz'].shape)\n      data['cloud_rgb'] = np.zeros(data['cloud_xyz'].shape)\n      data_transformed = self.dataset.transform(copy.deepcopy(data))\n      self.data_transformed = data_transformed\n      ori_cloud = data_transformed['cloud_xyz_original']\n      input_data = torch.from_numpy(data_transformed['input']).cuda().float().unsqueeze(0)\n\n      pred = self.model(input_data)[0].reshape(-1,3,self.cfg['ce_loss_bins'])\n      bin_resolution = 1\/self.cfg['ce_loss_bins']\n      pred_coords = pred.argmax(dim=-1).float()*bin_resolution\n      probs = pred.softmax(dim=-1)\n      confidence_z = torch.gather(probs[:,2,:],dim=-1,index=pred[:,2,:].argmax(dim=-1).unsqueeze(-1)).data.cpu().numpy().reshape(-1)\n      conf_color = array_to_heatmap_rgb(confidence_z)\n      nocs_cloud = pred_coords.data.cpu().numpy()-0.5\n\n      nocs_cloud_down = copy.deepcopy(nocs_cloud)\n      ori_cloud_down = copy.deepcopy(ori_cloud)\n\n      best_ratio = 0\n      best_transform = None\n      best_nocs_cloud = None\n      best_symmetry_tf = None\n      for symmetry_tf in [np.eye(4)]:\n        tmp_nocs_cloud_down = (symmetry_tf@to_homo(nocs_cloud_down).T).T[:,:3]\n        for thres in [0.003,0.005]:\n          use_kdtree_for_eval = False\n          kdtree_eval_resolution = 0.003\n          transform, inliers = estimate9DTransform(source=tmp_nocs_cloud_down,target=ori_cloud_down,PassThreshold=thres,max_iter=10000,use_kdtree_for_eval=use_kdtree_for_eval,kdtree_eval_resolution=kdtree_eval_resolution,max_scale=self.max_scale,min_scale=self.min_scale,max_dimensions=np.array([1.2,1.2,1.2]))\n          if transform is None:\n            continue\n\n          if np.linalg.det(transform[:3,:3])<0:\n            continue\n          scales = np.linalg.norm(transform[:3,:3],axis=0)\n          print(\"thres\",thres)\n          print(\"estimated scales\",scales)\n          print(\"transform:\\n\",transform)\n          transformed = (transform@to_homo(tmp_nocs_cloud_down).T).T[:,:3]\n          err_thres = 0.003\n\n          cloud_at_canonical = (np.linalg.inv(transform)@to_homo(ori_cloud_down).T).T[:,:3]\n          dimensions = cloud_at_canonical.max(axis=0)-cloud_at_canonical.min(axis=0)\n          print(\"estimated canonical dimensions\",dimensions)\n\n          errs = np.linalg.norm(transformed-ori_cloud_down, axis=1)\n          ratio = np.sum(errs<=err_thres)\/len(errs)\n          inliers = np.where(errs<=err_thres)[0]\n\n          print(\"inlier ratio\",ratio)\n\n          if ratio>best_ratio:\n            best_ratio = ratio\n            best_symmetry_tf = symmetry_tf\n            best_transform = transform.copy()\n            best_nocs_cloud = copy.deepcopy(tmp_nocs_cloud_down)\n\n      if best_transform is None:\n        return None,None\n\n      print(f\"nocs predictor best_ratio={best_ratio}, scales={np.linalg.norm(best_transform[:3,:3],axis=0)}\")\n      print(\"nocs pose\\n\",best_transform)\n      self.best_ratio = best_ratio\n      transform = best_transform\n      self.nocs_pose = transform.copy()\n      nocs_cloud = (best_symmetry_tf@to_homo(nocs_cloud).T).T[:,:3]\n\n      return nocs_cloud, transform\n\n\nclass PointGroupPredictor:\n  def __init__(self,class_name):\n    self.class_name_to_artifact_id = {\n      'nut': 40,\n      'hnm': 68,\n      'screw': 77,\n    }\n    self.class_name = class_name\n    artifact_id = self.class_name_to_artifact_id[class_name]\n    code_dir = os.path.dirname(os.path.realpath(__file__))\n    artifact_dir = f\"{code_dir}\/artifacts\/artifacts-{artifact_id}\"\n    print('PointGroupPredictor artifact_dir',artifact_dir)\n    config_dir = f\"{artifact_dir}\/config_pointgroup.yaml\"\n    self.cfg_pg = config_pg.get_parser(config_dir=config_dir)\n    with open(config_dir,'r') as ff:\n      self.cfg = yaml.safe_load(ff)\n\n    self.dataset = dataset_seg.Dataset(cfg=self.cfg,cfg_pg=self.cfg_pg,phase='test')\n\n    self.model = PointGroup(self.cfg_pg)\n    self.model = load_model(self.model,ckpt_dir='{}\/best_val.pth.tar'.format(artifact_dir))\n    self.model.cuda().eval()\n\n    self.n_slice_per_side = 1\n\n\n  def predict(self,data):\n    with torch.no_grad():\n      xmax = data['cloud_xyz'][:,0].max()\n      xmin = data['cloud_xyz'][:,0].min()\n      ymax = data['cloud_xyz'][:,1].max()\n      ymin = data['cloud_xyz'][:,1].min()\n      xlen = (xmax-xmin)\/self.n_slice_per_side\n      ylen = (ymax-ymin)\/self.n_slice_per_side\n\n      batch_offsets = [0]\n      locs = []\n      xyz_original_all = []\n      feats = []\n      colors = []\n\n      for ix in range(self.n_slice_per_side):\n        for iy in range(self.n_slice_per_side):\n          xstart = xmin+ix*xlen\n          ystart = ymin+iy*ylen\n          keep_mask = (data['cloud_xyz'][:,0]>=xstart) & (data['cloud_xyz'][:,0]<=xstart+xlen) & (data['cloud_xyz'][:,1]>=ystart) & (data['cloud_xyz'][:,1]<=ystart+ylen)\n          xyz_origin = data['cloud_xyz'][keep_mask]\n          normals = data['cloud_normal'][keep_mask]\n          color = data['cloud_rgb'][keep_mask]\n\n          pcd = toOpen3dCloud(xyz_origin)\n          pcd = pcd.voxel_down_sample(voxel_size=self.cfg['downsample_size'])\n          pts = np.asarray(pcd.points).copy()\n          kdtree = cKDTree(xyz_origin)\n          dists,indices = kdtree.query(pts)\n          xyz_origin = xyz_origin[indices]\n          normals = normals[indices]\n          color = color[indices]\n\n          xyz = xyz_origin * self.dataset.scale\n          xyz -= xyz.min(0)\n          batch_offsets.append(batch_offsets[-1] + xyz.shape[0])\n\n          i = ix+iy*self.n_slice_per_side\n          locs.append(torch.cat([torch.LongTensor(xyz.shape[0], 1).fill_(i), torch.from_numpy(xyz).long()], 1))\n\n          xyz_original_all.append(torch.from_numpy(xyz_origin))\n          feats.append(torch.from_numpy(normals))\n          colors.append(torch.from_numpy(color))\n\n      batchsize = len(batch_offsets)-1\n      batch_offsets = torch.tensor(batch_offsets, dtype=torch.int)\n      locs = torch.cat(locs, 0)\n      xyz_original_all = torch.cat(xyz_original_all, 0).to(torch.float32)\n      feats = torch.cat(feats, 0)\n      colors = torch.cat(colors, 0)\n\n      spatial_shape = np.clip((locs.max(0)[0][1:] + 1).numpy(), self.dataset.full_scale[0], None)\n\n      voxel_locs, p2v_map, v2p_map = pointgroup_ops.voxelization_idx(locs, len(batch_offsets)-1, self.dataset.mode)\n\n      coords = locs.cuda()\n      voxel_coords = voxel_locs.cuda()\n      p2v_map = p2v_map.cuda()\n      v2p_map = v2p_map.cuda()\n\n      coords_float = xyz_original_all.cuda().float()\n      feats = feats.cuda().float()\n\n      batch_offsets = batch_offsets.cuda()\n\n\n      if self.cfg_pg.use_coords:\n          feats = torch.cat((feats, coords_float), 1)\n      voxel_feats = pointgroup_ops.voxelization(feats, v2p_map, self.cfg_pg.mode)\n\n      input_ = spconv.SparseConvTensor(voxel_feats, voxel_coords.int(), spatial_shape, self.cfg_pg.batch_size)\n\n      ret = self.model(input_, p2v_map, coords_float, coords[:, 0].int(), batch_offsets, epoch=self.model.prepare_epochs-1)\n      offsets = ret['pt_offsets'].data.cpu().numpy()\n      xyz_original_all = xyz_original_all.data.cpu().numpy()\n\n      pcd = toOpen3dCloud(xyz_original_all)\n      pcd = pcd.voxel_down_sample(voxel_size=0.002)\n      xyz_down = np.asarray(pcd.points).copy()\n      kdtree = cKDTree(xyz_original_all)\n      dists,indices = kdtree.query(xyz_down)\n      xyz_down = xyz_original_all[indices]\n      xyz_shifted = xyz_down+offsets[indices]\n      self.xyz_shifted = xyz_shifted\n\n      if self.class_name=='hnm':\n        eps = 0.003\n        min_samples = 20\n        bandwidth = 0.005\n      elif self.class_name=='nut':\n        eps = 0.003\n        min_samples = 5\n        bandwidth = 0.007\n      elif self.class_name=='screw':\n        eps = 0.003\n        min_samples = 5\n        bandwidth = 0.009\n      else:\n        raise NotImplemented\n\n      labels = MeanShift(bandwidth=bandwidth,cluster_all=True,n_jobs=-1,seeds=None).fit_predict(xyz_shifted)\n\n      kdtree = cKDTree(xyz_down)\n      dists,indices = kdtree.query(data['cloud_xyz'])\n      labels_all = labels[indices]\n\n      return labels_all\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_179","text":"import sys\nsys.path.append('.\/')\n\nimport pandas as pd\nimport os\nfrom collections import namedtuple\nimport numpy as np\nimport cv2\nfrom shutil import copyfile\nfrom tqdm import tqdm \nfrom scipy import stats\nimport time\nimport random\nimport warnings\nfrom shutil import copyfile\nimport pyexcel\nimport yaml\n\n\n\ntry: \n    dj.__version__\nexcept: # ? onlu import tables if we havent already \n    try:\n        import datajoint as dj\n        from database.dj_config import start_connection \n        dbname, _ = start_connection()    \n    except Exception as e:\n        print(\"Could not connect to database: \", e)\n    else:\n        # print(\"Importing tables\")\n        from database.TablesDefinitionsV4 import *\n\nfrom Utilities.matplotlib_config_figures import *\n\nfrom Utilities.file_io.files_load_save import *\nfrom Utilities.video_and_plotting.video_editing import Editor\nfrom Utilities.maths.math_utils import *\nfrom Utilities.maths.distributions import *\nfrom Utilities.maths.filtering import *\nfrom Utilities.constants import *\n\nfrom Plotting.utils.plotting_utils import *\nfrom Plotting.utils.plot_distributions import *\nfrom Plotting.utils.colors import *\n\n\nmpl.rc('text', usetex=False)\nparams = {\n    'text.latex.preamble': ['\\\\usepackage{gensymb}'],\n    # 'image.origin': 'lower',\n    'image.interpolation': 'nearest',\n    'image.cmap': 'gray',\n    'axes.grid': False,\n    'savefig.dpi': 150,  # to adjust notebook inline plot size\n    'axes.labelsize': 12, # fontsize for x and y labels (was 10)\n    'axes.titlesize': 12,\n    'font.size': 12, # was 10\n    'xtick.labelsize': 12,\n    'ytick.labelsize': 12,\n    'text.usetex': False,        # ! <----- use TEX\n    'legend.fontsize': 14,\n}\nmpl.rcParams.update(params)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_181","text":"<reponame>PlaytikaResearch\/abexp\n# MIT License\n# \n# Copyright (c) 2021 Playtika Ltd.\n# \n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# \n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n# \n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport numpy as np\nfrom scipy.stats import ttest_ind\nfrom statsmodels.stats.power import NormalIndPower, TTestIndPower\n\nfrom abexp.statistics.stats_metrics import cohens_d, cohens_h\n\n\nclass SampleSize:\n    \"\"\"\n    This class provides some utils to be used before running A\/B test experiments. It includes minimum sample size\n    determination, power calculation and effect size estimation. It handles both the case of means comparison and\n    proportions comparison. Results are computed via power analysis with closed-form solution or simulation under the\n    assumption that sample data are normally distributed.\n    \"\"\"\n    def __init__(self):\n        pass\n\n    @staticmethod\n    def ssd_mean(mean_contr, mean_treat, std_contr, alpha=0.05, power=0.8):\n        \"\"\"\n        Sample size determination (SDD) to compare means. Compute the minimum sample size needed to run A\/B test\n        experiments. The result is computed via power analysis with closed-form solution t-test. Effect size estimation\n        is calculated with cohen's d coefficient.\n\n        Parameters\n        ----------\n        mean_contr : float\n            Mean of the control group.\n        mean_treat : float\n            Mean of the treatment group.\n        std_contr : float > 0\n            Standard deviation of the control group. It assumes that the standard deviation of the control group is\n            equal to the standard deviation of the treatment group.\n        alpha : float in interval (0,1)\n            Significance level, default 0.05. It is the probability of a type I error, that is wrong rejections if the\n            null hypothesis is true.\n        power : float in interval (0,1)\n            Statistical power of the test, default 0.8. It is one minus the probability of a type II error. Power is\n            the probability that the test correctly rejects the null hypothesis if the alternative hypothesis is true.\n\n        Returns\n        -------\n        sample_size : int\n            Minimum sample size per each group\n        \"\"\"\n\n        # If the means are equals the function returns infinity\n        if mean_contr == mean_treat:\n            return np.Inf\n\n        # Compute effect size as Cohen's d\n        effect_size = cohens_d(mu_1=mean_contr, mu_2=mean_treat, std=std_contr)\n\n        # Compute t-test to solve sample size\n        analysis = TTestIndPower()\n        sample_size = analysis.solve_power(effect_size=effect_size, power=power, alpha=alpha, nobs1=None, ratio=1.,\n                                           alternative='two-sided')\n\n        return round(sample_size)\n\n    @staticmethod\n    def ssd_mean_sim(mean_contr, mean_treat, std_contr, alpha=0.05, power=0.8, sims=1000, start_size=100, step_size=0,\n                     max_size=10000):\n        \"\"\"\n        Sample size determination (SDD) to compare means with simulation. Compute the minimum sample size needed to run\n        A\/B test experiments. The result is computed via power analysis with simulation through t-test.\n\n        Parameters\n        ----------\n        mean_contr : float\n            Mean of the control group.\n        mean_treat : float\n            Mean of the treatment group.\n        std_contr : float > 0\n            Standard deviation of the control group. It assumes that the standard deviation of the control group is\n            equal to the standard deviation of the treatment group.\n        alpha : float in interval (0,1)\n            Significance level, default 0.05. It is the probability of a type I error, that is wrong rejections if the\n            Null Hypothesis is true.\n        power : float in interval (0,1)\n            Statistical Power of the test, default 0.8. It is one minus the probability of a type II error. Power is the\n            probability that the test correctly rejects the Null Hypothesis if the Alternative Hypothesis is true.\n        sims : int\n            Number simulations, default 1000.\n        start_size : int\n            Initial sample size, default 100, used for the first iteration.\n        step_size : int\n            Spacing between samples size, default 50. This is the distance between two adjacent sample size,\n            sample_size[i+1] - sample_size[i].\n        max_size : int\n            Maximum sample size, default 10000. The function returns this value if the desired power is not reached via\n            simulation.\n\n        Returns\n        -------\n        sample_size : int\n            Minimum sample size per each group\n        \"\"\"\n\n        # If the means are equals the function returns infinity\n        if mean_contr == mean_treat:\n            return np.Inf\n\n        # Initialize simulated power and sample size, sample size\n        sim_power, sample_size = 0, start_size - step_size\n\n        while sim_power < power and sample_size <= max_size - step_size:\n\n            # Keep incrementing sample size by step_size till the required power is reached\n            sample_size += step_size\n\n            # Model the variable for the two groups as normal distributions\n            obs_contr = np.random.normal(loc=mean_contr, scale=std_contr, size=(sample_size, sims))\n            obs_treat = np.random.normal(loc=mean_treat, scale=std_contr, size=(sample_size, sims))\n\n            # Compute t-test for control and treatment groups\n            _, p_value = ttest_ind(obs_treat, obs_contr)\n\n            # Power is the fraction of times in the simulation when the p-value was less than 0.05\n            sim_power = (p_value < alpha).sum() \/ sims\n\n        return round(sample_size)\n\n    @staticmethod\n    def ssd_prop(prop_contr, prop_treat, alpha=0.05, power=0.8):\n        \"\"\"\n        Sample size determination (SDD) to compare proportions. Compute the minimum sample size needed to run A\/B test\n        experiments. The result is computed via power analysis with closed-form solution z-test. Effect size\n        estimation is calculated with cohen's h coefficient.\n\n        Parameters\n        ----------\n        prop_contr : float in interval (0,1)\n            Proportion in the control group.\n        prop_treat : float in interval (0,1)\n            Proportion in the treatment group.\n        alpha : float in interval (0,1)\n            Significance level, default 0.05. It is the probability of a type I error, that is wrong rejections if the\n            Null Hypothesis is true.\n        power : float in interval (0,1)\n            Statistical Power of the test, default 0.8. It is one minus the probability of a type II error. Power is\n            the probability that the test correctly rejects the Null Hypothesis if the Alternative Hypothesis is true.\n\n        Returns\n        -------\n        sample_size : int\n            Minimum sample size per each group\n        \"\"\"\n\n        # If proportions are equals the function returns infinity\n        if prop_contr == prop_treat:\n            return np.Inf\n\n        # Compute effect size as Cohen's h\n        effect_size = cohens_h(p1=prop_contr, p2=prop_treat)\n\n        # Compute t-test to solve sample size\n        analysis = NormalIndPower()\n        sample_size = analysis.solve_power(effect_size=effect_size, nobs1=None, alpha=alpha, power=power, ratio=1.,\n                                           alternative='two-sided')\n        return round(sample_size)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_183","text":"from os import environ\nfrom scipy.optimize import curve_fit\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os\nimport time\nfrom random import randint\nimport subprocess\nfrom itertools import combinations\nimport matplotlib\n\nmatplotlib.use('Agg')\n\n\npp = \".\/build\/release\/examples\/\"\n\ngraphs = [\n    \"graph_alexnet\",\n    \"graph_googlenet\",\n    \"graph_mobilenet\", \n    \"graph_squeezenet\",\n    \"graph_resnet50\"\n]\n\ncp = [\"--target=NEON\", \"--threads=4\"]\ngp = [\"--target=CL\"]\nsm = [\"taskset\", \"-c\", \"0-3\"]\nbg = [\"taskset\", \"-c\", \"4-7\"]\n\ntargets = {\n    \"cpu_big\": lambda g: bg + [pp + g] + cp,\n    \"cpu_small\": lambda g: sm + [pp + g] + cp,\n    \"gpu\": lambda g: [pp + g] + gp\n}\n\nT = 5\ndt = 0.01\n\n\ndef temp_func(t, b, c): return b * (1 - np.exp(- t \/ c))\n\n\ndef get_temp():\n    with open('\/sys\/class\/thermal\/thermal_zone0\/temp') as f:\n        temp = int(f.readline())\n        return temp\n\ndef plot_temp(cmd_combi, x, y, popt, i, t0):\n    fig = plt.figure()\n    plt.plot(x, [t0+yy for yy in y])\n    yp = [t0+temp_func(xx, *popt) for xx in x]\n    plt.plot(x, yp, \n        'r-', \n        label='fit: a=%5.3f, b=%5.3f' % tuple(popt))\n    plt.axhline(80000, linestyle='--', color='r')\n    plt.xlabel('Time')\n    plt.ylabel('Temperature')\n    combi_name = \"-\".join([target for target, _ in cmd_combi])\n    plt.title('Execution ' + graph + \" \" + combi_name)\n    plt.legend(loc='best')\n    name ='temp_profile_v4\/' + graph + \"_\" + combi_name + \"_\" + str(i) + \".png\"\n    print(name)\n    plt.savefig(name)  \n    plt.close(fig)\n\nif __name__ == \"__main__\":\n    env = dict(os.environ)\n    env['LD_LIBRARY_PATH'] = '.\/build\/release'\n    for graph in graphs:\n        print(\"graph = \"+graph)\n        RCs = {}\n        cmd_combis = []\n        cmds = list((target, targets[target](graph)) for target in targets)\n        for i in range(1, len(cmds) + 1):\n            cmd_combis += list(combinations(cmds, i))\n        for cmd_combi in cmd_combis:\n            print('> ', \"-\".join([target for target, _ in cmd_combi]))\n            bp = 30000\n            cp = 5\n            bss = []\n            css = []\n            for i in range(10):\n                time.sleep(randint(0, T))\n                t=0\n                running = []\n                for target_cmd in cmd_combi:\n                    running.append(subprocess.Popen(target_cmd[1], env=env))\n                x=[]\n                y = []\n                while None in (p.poll() for p in running):\n                    x.append(t)\n                    y.append(get_temp())\n                    time.sleep(dt)\n                    t+=dt\n                y.append(get_temp())\n                x.append(t)\n                t0 = y[0]\n                mx = t0\n                y = [yy-t0 for yy in y]\n                try:\n                    popt, _ = curve_fit(temp_func, x, y, bounds=(0, np.inf), p0=(bp, cp))\n                except:\n                    continue\n                [b, c] = popt\n                bp = b\n                cp = c\n                bss.append(b)\n                css.append(c)\n                print('b=%5.3f, c=%5.3f' % (b, c))\n                plot_temp(cmd_combi, x, y, popt, i, t0)\n            bs = sum(bss)\/len(bss)\n            cs  = sum(css)\/len(css)\n            print('Average: b=%5.3f, c=%5.3f' % (bs, cs))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_184","text":"<reponame>waterjump\/alignedCelebFaces\n# Just disables the warning, doesn't enable AVX\/FMA\nimport os\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n\n\nimport tensorflow as tf\nimport numpy as np\nfrom scipy import misc\nfrom tensorflow.examples.tutorials.mnist import input_data\nimport random\nimport math\n\ndef weight_variable(shape):\n    initial = tf.truncated_normal(shape, stddev=0.1)\n    return tf.Variable(initial)\n\ndef bias_variable(shape):\n    initial = tf.constant(0.1, shape=shape)\n    return tf.Variable(initial)\n\nIMAGE_WIDTH = 64\nIMAGE_HEIGHT = 64\n\nlearning_rate = 0.0000  # Used to be 0.001\ninputs_ = tf.placeholder(tf.float32, (None, IMAGE_HEIGHT, IMAGE_WIDTH, 3), name='inputs')\ntargets_ = tf.placeholder(tf.float32, (None, IMAGE_HEIGHT, IMAGE_WIDTH, 3), name='targets')\n\n\n\n\n### Encoder\nconv0 = tf.layers.conv2d(inputs=inputs_, filters=120, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 64x64x25\nmaxpool0 = tf.layers.max_pooling2d(conv0, pool_size=(2,2), strides=(2,2), padding='same')\n# Now 32x32x25\nconv1 = tf.layers.conv2d(inputs=maxpool0, filters=160, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 32x32x40\nmaxpool1 = tf.layers.max_pooling2d(conv1, pool_size=(2,2), strides=(2,2), padding='same')\n# Now 16x16x40\nconv2 = tf.layers.conv2d(inputs=maxpool1, filters=200, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 16x16x60\nmaxpool2 = tf.layers.max_pooling2d(conv2, pool_size=(2,2), strides=(2,2), padding='same')\n# Now 8x8x60\nconv3 = tf.layers.conv2d(inputs=maxpool2, filters=240, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 8x8x80\nmaxpool3 = tf.layers.max_pooling2d(conv3, pool_size=(2,2), strides=(2,2), padding='same')\n# Now 4x4x80\n\nmaxpool3_flat = tf.reshape(maxpool3, [-1,4*4*240])\n\nW_fc1 = weight_variable([4*4*240, 300])\nb_fc1 = bias_variable([300])\ntesy = tf.matmul(maxpool3_flat, W_fc1)\nencoded = tf.nn.relu(tf.matmul(maxpool3_flat, W_fc1) + b_fc1)\n\nW_fc2 = weight_variable([300, 4*4*240])\nb_fc2 = bias_variable([4*4*240])\npredecoded_flat = tf.nn.relu(tf.matmul(encoded, W_fc2) + b_fc2)\n\npredecoded = tf.reshape(predecoded_flat, [-1,4,4,240])\n\n### Decoder\nupsample1 = tf.image.resize_images(predecoded, size=(8,8), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n# Now 8x8x80\nconv4 = tf.layers.conv2d(inputs=upsample1, filters=200, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 8x8x60\nupsample2 = tf.image.resize_images(conv4, size=(16,16), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n# Now 16x16x60\nconv5 = tf.layers.conv2d(inputs=upsample2, filters=160, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 16x16x40\nupsample3 = tf.image.resize_images(conv5, size=(32,32), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n# Now 32x32x40\nconv6 = tf.layers.conv2d(inputs=upsample3, filters=120, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 32x32x25\nupsample4 = tf.image.resize_images(conv6, size=(64,64), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n# Now 64x64x25\nconv7 = tf.layers.conv2d(inputs=upsample4, filters=15, kernel_size=(3,3), padding='same', activation=tf.nn.relu)\n# Now 64x64x10\n\n\nlogits = tf.layers.conv2d(inputs=conv7, filters=3, kernel_size=(3,3), padding='same', activation=None)\n#Now 64x64x1\n\n# Pass logits through sigmoid to get reconstructed image\ndecoded = tf.nn.sigmoid(logits)\n\n# Pass logits through sigmoid and calculate the cross-entropy loss\nloss = tf.nn.sigmoid_cross_entropy_with_logits(labels=targets_, logits=logits)\n\n# Get cost and define the optimizer\ncost = tf.reduce_mean(loss)\nopt = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n\n\nprint(\"made it here! :D\")\nIMAGE_COUNT = 13016\nDENSE_SIZE = 300\nsess = tf.Session()\nsaver = tf.train.Saver()\nsess.run(tf.global_variables_initializer())\nsaver.restore(sess,  \"\/media\/rob\/Ma Book1\/alignedCelebFaces\/models\/model27674.ckpt\")\n\ndenseArray = np.zeros((IMAGE_COUNT,DENSE_SIZE))\nfor imageIndex in range(IMAGE_COUNT):\n    imagio = misc.imread('\/media\/rob\/Ma Book1\/alignedCelebFaces\/data\/dataFace'+str(imageIndex)+'.png')\n    imagio = imagio[:,:,0:3].reshape((1,64,64,3))\/255.0\n    denseRep = sess.run([encoded], feed_dict={inputs_: imagio,targets_: imagio})\n    denseArray[imageIndex] = np.array(denseRep)\n    if imageIndex%20 == 0:\n        print(imageIndex)\nnp.save(\"denseArray27K.npy\",denseArray)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_186","text":"\"\"\"\nDirect NumPy port of tfgan.eval.classifier_metrics\n\"\"\"\n# CREDITS: https:\/\/github.com\/hojonathanho\/diffusion\/blob\/1e0dceb3b3495bbe19116a5e1b3596cd0706c543\/diffusion_tf\/tpu_utils\/classifier_metrics_numpy.py\n\nimport numpy as np\nimport scipy.special\n\n\ndef log_softmax(x, axis):\n    return x - scipy.special.logsumexp(x, axis=axis, keepdims=True)\n\n\ndef kl_divergence(p, p_logits, q):\n    assert len(p.shape) == len(p_logits.shape) == 2\n    assert len(q.shape) == 1\n    return np.sum(p * (log_softmax(p_logits, axis=1) - np.log(q)[None, :]), axis=1)\n\n\ndef _symmetric_matrix_square_root(mat, eps=1e-10):\n    \"\"\"Compute square root of a symmetric matrix.\n    Note that this is different from an elementwise square root. We want to\n    compute M' where M' = sqrt(mat) such that M' * M' = mat.\n    Also note that this method **only** works for symmetric matrices.\n    Args:\n      mat: Matrix to take the square root of.\n      eps: Small epsilon such that any element less than eps will not be square\n        rooted to guard against numerical instability.\n    Returns:\n      Matrix square root of mat.\n    \"\"\"\n    u, s, vt = np.linalg.svd(mat)\n    # sqrt is unstable around 0, just use 0 in such case\n    si = np.where(s < eps, s, np.sqrt(s))\n    return u.dot(np.diag(si)).dot(vt)\n\n\ndef trace_sqrt_product(sigma, sigma_v):\n    \"\"\"Find the trace of the positive sqrt of product of covariance matrices.\n    '_symmetric_matrix_square_root' only works for symmetric matrices, so we\n    cannot just take _symmetric_matrix_square_root(sigma * sigma_v).\n    ('sigma' and 'sigma_v' are symmetric, but their product is not necessarily).\n    Let sigma = A A so A = sqrt(sigma), and sigma_v = B B.\n    We want to find trace(sqrt(sigma sigma_v)) = trace(sqrt(A A B B))\n    Note the following properties:\n    (i) forall M1, M2: eigenvalues(M1 M2) = eigenvalues(M2 M1)\n       => eigenvalues(A A B B) = eigenvalues (A B B A)\n    (ii) if M1 = sqrt(M2), then eigenvalues(M1) = sqrt(eigenvalues(M2))\n       => eigenvalues(sqrt(sigma sigma_v)) = sqrt(eigenvalues(A B B A))\n    (iii) forall M: trace(M) = sum(eigenvalues(M))\n       => trace(sqrt(sigma sigma_v)) = sum(eigenvalues(sqrt(sigma sigma_v)))\n                                     = sum(sqrt(eigenvalues(A B B A)))\n                                     = sum(eigenvalues(sqrt(A B B A)))\n                                     = trace(sqrt(A B B A))\n                                     = trace(sqrt(A sigma_v A))\n    A = sqrt(sigma). Both sigma and A sigma_v A are symmetric, so we **can**\n    use the _symmetric_matrix_square_root function to find the roots of these\n    matrices.\n    Args:\n      sigma: a square, symmetric, real, positive semi-definite covariance matrix\n      sigma_v: same as sigma\n    Returns:\n      The trace of the positive square root of sigma*sigma_v\n    \"\"\"\n\n    # Note sqrt_sigma is called \"A\" in the proof above\n    sqrt_sigma = _symmetric_matrix_square_root(sigma)\n\n    # This is sqrt(A sigma_v A) above\n    sqrt_a_sigmav_a = sqrt_sigma.dot(sigma_v.dot(sqrt_sigma))\n\n    return np.trace(_symmetric_matrix_square_root(sqrt_a_sigmav_a))\n\n\ndef classifier_score_from_logits(logits):\n    \"\"\"Classifier score for evaluating a generative model from logits.\n    This method computes the classifier score for a set of logits. This can be\n    used independently of the classifier_score() method, especially in the case\n    of using large batches during evaluation where we would like precompute all\n    of the logits before computing the classifier score.\n    This technique is described in detail in https:\/\/arxiv.org\/abs\/1606.03498. In\n    summary, this function calculates:\n    exp( E[ KL(p(y|x) || p(y)) ] )\n    which captures how different the network's classification prediction is from\n    the prior distribution over classes.\n    Args:\n      logits: Precomputed 2D tensor of logits that will be used to compute the\n        classifier score.\n    Returns:\n      The classifier score. A floating-point scalar of the same type as the output\n      of `logits`.\n    \"\"\"\n    assert len(logits.shape) == 2\n\n    # Use maximum precision for best results.\n    logits_dtype = logits.dtype\n    if logits_dtype != np.float64:\n        logits = logits.astype(np.float64)\n\n    p = scipy.special.softmax(logits, axis=1)\n    q = np.mean(p, axis=0)\n    kl = kl_divergence(p, logits, q)\n    assert len(kl.shape) == 1\n    log_score = np.mean(kl)\n    final_score = np.exp(log_score)\n\n    if logits_dtype != np.float64:\n        final_score = final_score.astype(logits_dtype)\n\n    return final_score\n\n\ndef frechet_classifier_distance_from_activations(\n    real_activations, generated_activations\n):\n    \"\"\"Classifier distance for evaluating a generative model.\n    This methods computes the Frechet classifier distance from activations of\n    real images and generated images. This can be used independently of the\n    frechet_classifier_distance() method, especially in the case of using large\n    batches during evaluation where we would like precompute all of the\n    activations before computing the classifier distance.\n    This technique is described in detail in https:\/\/arxiv.org\/abs\/1706.08500.\n    Given two Gaussian distribution with means m and m_w and covariance matrices\n    C and C_w, this function calculates\n                  |m - m_w|^2 + Tr(C + C_w - 2(C * C_w)^(1\/2))\n    which captures how different the distributions of real images and generated\n    images (or more accurately, their visual features) are. Note that unlike the\n    Inception score, this is a true distance and utilizes information about real\n    world images.\n    Note that when computed using sample means and sample covariance matrices,\n    Frechet distance is biased. It is more biased for small sample sizes. (e.g.\n    even if the two distributions are the same, for a small sample size, the\n    expected Frechet distance is large). It is important to use the same\n    sample size to compute frechet classifier distance when comparing two\n    generative models.\n    Args:\n      real_activations: 2D Tensor containing activations of real data. Shape is\n        [batch_size, activation_size].\n      generated_activations: 2D Tensor containing activations of generated data.\n        Shape is [batch_size, activation_size].\n    Returns:\n     The Frechet Inception distance. A floating-point scalar of the same type\n     as the output of the activations.\n    \"\"\"\n    assert len(real_activations.shape) == len(generated_activations.shape) == 2\n\n    activations_dtype = real_activations.dtype\n    if activations_dtype != np.float64:\n        real_activations = real_activations.astype(np.float64)\n        generated_activations = generated_activations.astype(np.float64)\n\n    # Compute mean and covariance matrices of activations.\n    m = np.mean(real_activations, 0)\n    m_w = np.mean(generated_activations, 0)\n    num_examples_real = float(real_activations.shape[0])\n    num_examples_generated = float(generated_activations.shape[0])\n\n    # sigma = (1 \/ (n - 1)) * (X - mu) (X - mu)^T\n    real_centered = real_activations - m\n    sigma = real_centered.T.dot(real_centered) \/ (num_examples_real - 1)\n\n    gen_centered = generated_activations - m_w\n    sigma_w = gen_centered.T.dot(gen_centered) \/ (num_examples_generated - 1)\n\n    # Find the Tr(sqrt(sigma sigma_w)) component of FID\n    sqrt_trace_component = trace_sqrt_product(sigma, sigma_w)\n\n    # Compute the two components of FID.\n\n    # First the covariance component.\n    # Here, note that trace(A + B) = trace(A) + trace(B)\n    trace = np.trace(sigma + sigma_w) - 2.0 * sqrt_trace_component\n\n    # Next the distance between means.\n    mean = np.sum(np.square(m - m_w))  # Equivalent to L2 but more stable.\n    fid = trace + mean\n    if activations_dtype != np.float64:\n        fid = fid.astype(activations_dtype)\n\n    return fid\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_187","text":"import numpy as np\nfrom numpy import ndarray\nfrom typing import Callable, Tuple\nfrom pynverse import inversefunc\nfrom scipy.stats import chi2\nfrom basic.types import vector, matrix, Configuration, elemental, TP_HOTELLING\nfrom basic.decorators import document, type_checker\nimport basic.docfunc as doc\nimport copy\n\n\ndef _mvn_params(x: matrix) -> Tuple[vector, matrix]:\n    return x.mean(axis=0), np.cov(x.T, bias=True)\n\n\ndef _upper_domain(func: Callable, heuristic_step: float = 10) -> int:\n    upper = heuristic_step\n    while True:\n        try:\n            res = inversefunc(func, y_values=1, domain=[0, upper])\n        except ValueError:\n            upper += heuristic_step  # heuristically increase upper of domain\n        else:\n            return res\n\n\ndef hotelling_threshold(df: int, level: float = 0.05) -> float:\n    \"\"\"calculate the threshold of chi2 distribution, by a given test level\"\"\"\n    dis = chi2(df=df)\n    upper = _upper_domain(dis.cdf, 10)\n    return inversefunc(dis.cdf, y_values=1-level, domain=[0, upper])\n\n\ndef a(x: matrix, miu: vector, sigma: matrix) -> ndarray:\n    res = []\n    m_inv = np.array(np.matrix(sigma).I)  # inverse matrix\n    for i in range(len(x)):\n        _ = x[i] - miu\n        res.append(np.matmul(np.matmul(_, m_inv), _.T))\n    return np.array(res)\n\n\n@document(doc.en_Hotelling)\nclass Hotelling:\n\n    settings: Configuration = {\n        'model_import': np.array([]),  # ndarray, matrix-like\n        'level': 0.05,  # float, 0~1\n        'data_import': np.array([]),  # ndarray, matrix-like\n    }\n\n    @type_checker(in_class=True, kwargs_types=TP_HOTELLING, elemental_types=elemental)\n    def __init__(self, **settings: Configuration):\n        assert np.all([k in settings.keys() for k in ['model_import']]) == 1, 'missing required arg model_import.'\n        self.settings.update({k: v for k, v in settings.items()})\n        self.model = self.settings.get('model_import')\n        self.mean, self.sigma = _mvn_params(self.model)\n        self.threshold = hotelling_threshold(self.model.shape[1], self.settings.get('level'))\n\n    @type_checker(in_class=True, kwargs_types=TP_HOTELLING, elemental_types=elemental)\n    @document(doc.en_Hotelling_predict)\n    def predict(self, **settings: Configuration):\n        assert np.all([k in settings.keys() for k in ['data_import']]) == 1, 'missing required arg data_import.'\n        _settings = copy.deepcopy(self.settings)\n        _settings.update({k: v for k, v in settings.items()})\n        return a(_settings.get('data_import'), self.mean, self.sigma) <= self.threshold\n\n\nif __name__ == '__main__':\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_188","text":"<filename>IAM_GPU_improved_lib.py<gh_stars>0\nimport matplotlib\nmatplotlib.use('Agg')\n\nfrom numba import cuda\nfrom timeit import default_timer as timer\nfrom matplotlib import pylab\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\n\nfrom IAM_lib import *\n\nimport numpy as np\nimport nibabel as nib\nimport matplotlib.pyplot as plt\nimport scipy.io as sio\nimport skimage.morphology as skimorph\nimport skimage.filters as skifilters\nimport scipy.ndimage.morphology as scimorph\n\nimport math, numba, cv2, csv, gc\nimport os, errno, sys, shutil\n\nimport code\nfrom PIL import Image\n\n# Turn interactive plotting off\nplt.ioff()\n\ndef iam_lots_gpu_compute(csv_filename=\"\", patch_size=[1,2,4,8],\n                         blending_weights=[0.65,0.2,0.1,0.05], num_sample=[512],\n                         alpha=0.5, thrsh_patches = True, bin_tresh=0.5, save_jpeg=True,\n                         delete_intermediary=False, nawm_preprocessing=False):\n    '''\n    FUNCTION'S SUMMARY:\n\n    Main function of the LOTS-IAM-GPU algorithm. This function produces (i.e. saving)\n    age maps that indicate level of irregularity of voxels in brain FLAIR MRI. This\n    function reads a list of FLAIR MR image (NifTI), ICV mask (NifTI), CSF mask (NifTI),\n    NAWM mask (NifTI), and Cortical mask (NifTI) to produce the corresponding age maps\n    from a CSV file. Please note that this version only accept NifTI (.nii\/.nii.gz) files.\n\n    NOTE: NAWM and Cortical masks are optional. They will be used if they are included\n    in the CSV file.\n\n    Format of the CSV input file (NOTE: spaces are used to make the format clearer):\n\n        path_to_mri_codebase_folder, mri_code_name, path_FLAIR, path_ICV, path_CSF,\n        path_NAWM (optional), path_Cortical (optional)\n\n    Example (NOTE: spaces are used to make the format clearer):\n\n        \/dir\/MRI_DB\/, MRI001, \/dir\/MRI_DB\/MRI001\/FLAIR.nii.gz, \/dir\/MRI_DB\/MRI001\/ICV.nii.gz,\n        \/dir\/MRI_DB\/MRI001\/CSF.nii.gz, \/dir\/MRI_DB\/MRI001\/NAWM.nii.gz (optional),\n        \/dir\/MRI_DB\/MRI001\/Cortex.nii.gz (optional)\n\n    By default, the age maps are calculated by using four different sizes of source\/target\n    patches (i.e. 1x1, 2x2, 4x4, and 8x8) and 64 target samples. Furthermore, all intermediary\n    files are saved in .mat (Matlab) and JPEG files.\n\n\n    INPUT PARAMETERS:\n\n    This function's behavior can be set by using input parameters below.\n\n        1. output_filedir   : Path of directory for saving all results. Format of the path:\n                              \"output_path\/name_of_experiment\"\n\n        2. csv_filename     : Name of a CSV input file which contains list all files to be\n                              processed by the LOTS-IAM-GPU. Example: \"input.csv\"\n\n        3. patch_size       : Size of source\/target patches for IAM's computation. Default:\n                              [1,2,4,8] to calculate age maps from four different sizes of\n                              source\/target patches i.e. 1x1, 2x2, 4x4, and 8x8. The sizes\n                              of source\/target patches must be in the form of python's list.\n\n        4. blending_weights : Weights used for blending age maps produced by different size of\n                              source\/target patches. The weights must be in the form of python's\n                              list, summed to 1, and its length must be the same as `patch_size`.\n\n        5. num_sample       : A list of numbers used for randomly sampling target patches to be\n                              used in the LOTS-IAM-GPU calculation. Default: [512]. Available\n                              values: [64, 128, 256, 512, 1024, 2048]. Some important notes:\n\n                                a. Smaller number will make computation faster.\n                                b. Input the numbers as a list to automatically produce\n                                   age maps by using all different numbers of target patches.\n                                   The software will automatically create different output\n                                   folders for different number of target samples.\n                                c. For this version, only 64, 128, 256, 512, 1024, and 2048\n                                   can be used as input numbers (error will be raised if other\n                                   numbers are used).\n\n        6. alpha            : Weight of distance function to blend maximum difference and\n                              average difference between source and target patches. Default:\n                              0.5. Input value should be between 0 and 1 (i.e. floating points).\n                              The current distance function being used is:\n\n                                  d = (alpha . |max(s - t)|) + ((1 - alpha) . |mean(s - t)|)\n\n                              where d is distance value, s is source patch, and t is target patch.\n\n        7. bin_tresh        : Threshold value for cutting of probability values of brain masks,\n                              if probability masks are given instead of binary masks.\n\n        8. save_jpeg        : True  --> Save all JPEG files for visualisation.\n                              False --> Do not save the JPEG files.\n\n        9. delete_intermediary : False --> Save all intermediary files (i.e. JPEG\/.mat files).\n                                 True  --> Delete all intermediary files, saving some spaces in\n                                           the hard disk drive.\n\n    OUTPUT:\n\n    The software will automatically create a new folder provided in \"output_filedir\" variable.\n    Please make sure that the directory is accessible and writable.\n\n    Inside the experiment’s folder, each patient\/MRI mri_code will have its own folder. In default,\n    there are 6 sub-folders which are:\n    1. 1: Contains age maps of each slice generated by using 1x1 patch.\n    2. 2: Contains age maps of each slice generated by using 2x2 patch.\n    3. 4: Contains age maps of each slice generated by using 4x4 patch.\n    4. 8: Contains age maps of each slice generated by using 8x8 patch.\n    5. IAM_combined_python: Contains two sub-folders:\n        a. Patch: contains visualisation of age maps of each slices in JPEG files, and\n        b. Combined: contains visualisation of the final output of LOTS-IAM-GPU’s computation.\n    6. IAM_GPU_nifti_python: Contains one Matlab (.mat) file and three NIfTI files (.nii.gz):\n        a. all_slice_dat.mat: processed mri_code of all slices in Matlab file,\n        b. IAM_GPU_COMBINED.nii.gz: the original age map values,\n        c. IAM_GPU_GN.nii.gz: the final age map values (i.e. GN and penalty), and\n        d. IAM_GPU_GN_postprocessed.nii.gz: the final age map values plus post-processing\n           (only if NAWM mask is provided).\n\n    Note: If parameter value of `delete_intermediary` is `True`, then all folders listed above\n    will be deleted, except for folder `IAM_GPU_nifti_python` and its contents.\n\n    MORE HELP:\n\n    Please read README.md file provided in:\n        https:\/\/github.com\/febrianrachmadi\/lots-iam-gpu\n\n    VERSION (dd\/mm\/yyyy):\n    - 31\/05\/2018b: NAWM and Cortical brain masks are now optional input (will be used if available).\n    - 31\/05\/2018a: Fix header information of the LOTS-IAM-GPU's result.\n    - 08\/05\/2018 : Add lines to cutting off probability mask and deleting intermediary folders.\n    - 07\/05\/2018 : Initial release code.\n    '''\n\n    ## Check availability of input files and output path\n    if csv_filename == \"\":\n        raise ValueError(\"Please set output folder's name and CSV mri_code filename. See: help(iam_lots_gpu)\")\n        return 0\n\n    ## Check compatibility between 'patch_size' and 'blending_weights'\n    if len(patch_size) != len(blending_weights):\n        raise ValueError(\"Lengths of 'patch_size' and 'blending_weights' variables are not the same. Length of 'patch_size' is \" + str(len(patch_size)) + \", while 'blending_weights' is \" + str(len(blending_weights)) + \".\")\n        return 0\n\n    ## If intermediary files to be deleted, don't even try to save JPEGs\n    if delete_intermediary:\n        save_jpeg = False\n\n    ''' Set number of mean samples automatically '''\n    ''' num_samples_all = [64, 128, 256, 512, 1024, 2048] '''\n    ''' num_mean_samples_all = [16, 32, 32, 64, 128, 128] '''\n    num_samples_all = num_sample\n    num_mean_samples_all = []\n    for sample in num_samples_all:\n        if sample == 64:\n            num_mean_samples_all.append(16)\n        elif sample == 128:\n            num_mean_samples_all.append(32)\n        elif sample == 256:\n            num_mean_samples_all.append(32)\n        elif sample == 512:\n            num_mean_samples_all.append(64)\n        elif sample == 1024:\n            num_mean_samples_all.append(128)\n        elif sample == 2048:\n            num_mean_samples_all.append(128)\n        else:\n            raise ValueError(\"Number of samples must be either 64, 128, 256, 512, 1024 or 2048!\")\n            return 0\n\n    print(\"--- PARAMETERS - CHECKED ---\")\n    print('CSV mri_code filename: ' + csv_filename)\n    print('Patch size(s): ' + str(patch_size))\n    print('Number of samples (all): ' + str(num_samples_all))\n    print('Number of mean samples (all): ' + str(num_mean_samples_all))\n    print('Save JPEGs? ' + str(save_jpeg))\n    print(\"--- PARAMETERS - CHECKED ---\\n\")\n\n    for ii_s in range(0, len(num_samples_all)):\n        num_samples = num_samples_all[ii_s]\n        num_mean_samples = num_mean_samples_all[ii_s]\n        print('Number of samples for IAM: ' + str(num_samples))\n        print('Number of mean samples for IAM: ' + str(num_mean_samples))\n\n        with open(csv_filename, newline='') as csv_file:\n            num_subjects = len(csv_file.readlines())\n            print('Number of subject(s): ' + str(num_subjects))\n\n        with open(csv_filename, newline='', encoding=\"utf-8-sig\") as csv_file:\n            reader = csv.reader(csv_file)\n\n            timer_idx = 0\n            elapsed_times_all = np.zeros((num_subjects))\n            elapsed_times_patch_all = np.zeros((num_subjects, len(patch_size)))\n            for row in reader:\n                mri_code = row[2]\n\n                dirOutput = row[1]\n                print('Output dir: ' + dirOutput + '\\n--')\n\n                try:\n                    os.makedirs(dirOutput)\n                except OSError as e:\n                    if e.errno != errno.EEXIST:\n                        raise\n\n\n                print('--\\nNow processing mri_code: ' + mri_code)\n\n                inputSubjectDir = row[0]\n                print('Input filename (full path): ' + inputSubjectDir)\n\n                ''' Create output folder(s) '''\n                dirOutData = dirOutput + '\/' + mri_code\n                dirOutDataCom = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/'\n                dirOutDataPatch = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/Patch\/'\n                dirOutDataCombined = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/Combined\/'\n                try:\n                    print(dirOutDataCom)\n                    os.makedirs(dirOutDataCom)\n                    os.makedirs(dirOutDataPatch)\n                    os.makedirs(dirOutDataCombined)\n                except OSError as e:\n                    if e.errno != errno.EEXIST:\n                        raise\n\n                mri_data = sio.loadmat(row[0])     # Loading FLAIR\n                mri_data = mri_data[\"flair\"]\n                [x_len, y_len, z_len] = mri_data.shape\n\n                one_mri_data = timer()\n                for xy in range(0, len(patch_size)):\n                    print('>>> Processing patch-size: ' + str(patch_size[xy]) + ' <<<\\n')\n\n                    try:\n                        os.makedirs(dirOutData + '\/' + str(patch_size[xy]))\n                    except OSError as e:\n                        if e.errno != errno.EEXIST:\n                            raise\n\n                    one_patch = timer()\n                    for zz in range(0, mri_data.shape[2]):\n                        print('---> Slice number: ' + str(zz) + ' <---')\n\n                        '''\n                        KEY POINT: PRE-PROCESSING P.2 - START\n                        -------------------------------------\n                        This version still does per slice operation for extracting brain tissues.\n                        Two important variables used in the next part of the code are:\n                        1. mask_slice --->  Combination of ICV & CSF masks. It is used to find valid source patches\n                                            for LOTS-IAM-GPU computation (i.e. brain tissues' source patches).\n                        2. brain_slice -->  Brain tissues' information from FLAIR slice.\n                        '''\n\n                        mask_slice = np.nan_to_num(mri_data[:, :, zz])\n                        mask_slice[mask_slice > 0] = 1\n\n                        brain_slice = np.nan_to_num(mri_data[:, :, zz])\n\n                        '''\n                        -----------------------------------\n                        KEY POINT: PRE-PROCESSING P.2 - END\n                        '''\n\n                        ## Show brain slice to be used for computation\n                        #fig, ax = plt.subplots()\n                        #cax = ax.imshow(icv_slice, cmap=\"jet\")\n                        #cbar = fig.colorbar(cax)\n                        #fig.show()\n                        #plt.savefig(\"plot.jpg\")\n\n\n                        # Vol distance threshold\n                        vol_slice = np.count_nonzero(brain_slice) \/ (x_len * y_len)                         ## Proportion of brain slice compared to full image\n                        print('DEBUG-Patch: brain_slice - ' + str(np.count_nonzero(brain_slice)) +\n                              ', x_len * y_len - ' + str(x_len * y_len) + ', vol: ' + str(vol_slice))       ## x_len\/y_len = 512 here\n\n                        # Patch's sampling number treshold\n                        TRSH = 0.50\n                        if patch_size[xy] == 1:\n                            if vol_slice < 0.010: TRSH = 0\n                            elif vol_slice < 0.035: TRSH = 0.15\n                            elif vol_slice < 0.070 and vol_slice >= 0.035: TRSH = 0.60\n                            elif vol_slice >= 0.070: TRSH = 0.80\n                        elif patch_size[xy] == 2:\n                            if vol_slice < 0.010: TRSH = 0\n                            elif vol_slice < 0.035: TRSH = 0.15\n                            elif vol_slice < 0.070 and vol_slice >= 0.035: TRSH = 0.60\n                            elif vol_slice >= 0.070: TRSH = 0.80\n                        elif patch_size[xy] == 4 or patch_size[xy] == 8:\n                            if vol_slice < 0.035: TRSH = 0\n\n                        print('DEBUG-Patch: Size - ' + str(patch_size[xy]) + ', slice - ' + str(zz) +\n                              ', vol: ' + str(vol_slice) + ', TRSH: ' + str(TRSH))\n\n                        counter_y = int(y_len \/ patch_size[xy])                                             ## counter_y = 512 if patch of size 1 and image of size 512x512\n                        counter_x = int(x_len \/ patch_size[xy])\n                        source_patch_len = counter_x * counter_y                                            ## How many source patches are neede (e.g. for 1, we need one for each pixel)\n                        age_values_all = np.zeros(source_patch_len)                                         ## Age Map that will be filled with the actual values\n\n                        valid = 0\n                        if ((vol_slice >= 0.008 and vol_slice < 0.035) and (patch_size[xy] == 1 or patch_size[xy] == 2)) or \\\n                            ((vol_slice >= 0.035 and vol_slice < 0.065) and (patch_size[xy] == 1 or patch_size[xy] == 2 or \\\n                             patch_size[xy] == 4)) or (vol_slice > 0.065):\n                            valid = 1\n\n                            ## Creating grid-patch 'xy-by-xy'\n                            #  -- Column\n                            y_c = np.ceil(patch_size[xy] \/ 2)\n                            y_c_sources = np.zeros(int(y_len \/ patch_size[xy]))\n                            for iy in range(0, int(y_len \/ patch_size[xy])):\n                                y_c_sources[iy] = (iy * patch_size[xy]) + y_c - 1\n\n\n                            #  -- Row\n                            x_c = np.ceil(patch_size[xy] \/ 2)\n                            x_c_sources = np.zeros(int(x_len \/ patch_size[xy]))\n                            for ix in range(0, int(x_len \/ patch_size[xy])):\n                                x_c_sources[ix] = (ix * patch_size[xy]) + x_c - 1\n\n\n                            ''' Extracting Source Patches '''\n                            area_source_patch = np.zeros([1,patch_size[xy],patch_size[xy]])\n                            center_source_patch = np.zeros([1,2])\n                            icv_source_flag = np.zeros([source_patch_len])\n                            icv_source_flag_valid = np.ones([source_patch_len])\n                            index_mapping = np.ones([source_patch_len]) * -1\n\n\n                            flag = 1\n                            index = 0\n                            index_source= 0\n\n                            if patch_size[xy] == 1:\n                                area_source_patch = brain_slice[mask_slice == 1]\n                                area_source_patch = area_source_patch.reshape([area_source_patch.shape[0], 1, 1])\n                                index = source_patch_len\n                                index_source = area_source_patch.shape[0]\n                                icv_source_flag = mask_slice.flatten()\n                                positive_indices = (np.where(brain_slice.flatten() > 0))[0]\n                                index = 0\n                                for i in positive_indices:\n                                    index_mapping[i] = index\n                                    index += 1\n\n                            else:\n                                area_source_patch = []\n                                for isc in range(0, counter_x):\n                                    for jsc in range(0, counter_y):\n                                            icv_source_flag[index] = mask_slice[int(x_c_sources[isc]), int(y_c_sources[jsc])]\n                                            if icv_source_flag[index] == 1:\n                                                temp = get_area(x_c_sources[isc], y_c_sources[jsc],\n                                                                patch_size[xy], patch_size[xy], brain_slice)\n                                                area_source_patch.append(temp.tolist())\n                                                index_mapping[index] = index_source\n                                                index_source += 1\n\n                                            index += 1\n                                area_source_patch = np.asarray(area_source_patch)\n\n\n\n\n                            icv_source_flag_valid = icv_source_flag_valid[0:index_source]\n                            age_values_valid = np.zeros(index_source)\n\n                            \"\"\" TO DELETE, IT'S JUST FOR DISSERTATION\n                            for i in range(area_source_patch.shape[2]):\n                                plt.imshow(area_source_patch[i]) #Needs to be in row,col order\n                                plt.savefig(\"test.jpg\")\n                            \"\"\"\n\n\n                            ''' Extracting Target Patches '''\n                            target_patches = []\n                            index_debug = 0\n                            random_array = np.random.randint(10, size=(x_len, y_len))\n                            index_possible = np.zeros(brain_slice.shape)\n                            index_possible[(mask_slice != 0) & (random_array > TRSH*10)] = 1\n                            index_possible = np.argwhere(index_possible)\n\n\n                            for index_chosen in index_possible:\n                                x, y = index_chosen\n                                area = get_area(x, y, patch_size[xy], patch_size[xy], brain_slice)\n                                if area.size == patch_size[xy] * patch_size[xy]:\n                                    if np.random.randint(low=1, high=10)\/10 < (100\/(x*y)) * num_samples:\n                                        pass\n                                    target_patches.append(area)\n                                    index_debug += 1\n\n\n                            target_patches_np = get_shuffled_patches(target_patches, num_samples)\n                            target_patches_np = target_patches_np[0:num_samples,:,:]\n                            print('Sampling finished: ' + ' with: ' + str(index_debug) + ' samples from: ' + str(x_len * y_len))\n                            area = []\n\n                            ''''''\n                            ''' Reshaping array mri_code '''\n                            area_source_patch_cuda_all = np.reshape(area_source_patch,(area_source_patch.shape[0],\n                                                            area_source_patch.shape[1] * area_source_patch.shape[2]))\n                            target_patches_np_cuda_all = np.reshape(target_patches_np, (target_patches_np.shape[0],\n                                                            target_patches_np.shape[1] * target_patches_np.shape[2]))\n\n                            #if patch_size[xy] == 2:\n                            #    code.interact(local=dict(globals(), **locals()))\n\n                            melvin = timer()\n                            source_len = icv_source_flag_valid.shape[0]\n                            loop_len = 512 # def: 512\n                            loop_num = int(np.ceil(source_len \/ loop_len))\n                            print('\\nLoop Information:')\n                            print('Total number of source patches: ' + str(source_len))\n                            print('Number of voxels processed in one loop: ' + str(loop_len))\n                            print('Number of loop needed: ' + str(loop_num))\n                            print('Check GPU memory: ' + str(cuda.current_context().get_memory_info()))\n\n                            for il in range(0, loop_num):\n                                ''' Debug purposed printing '''\n                                print('.', end='')\n                                if np.remainder(il+1, 32) == 0:\n                                    print(' ' + str(il+1) + '\/' + str(loop_num)) # Print newline\n\n                                ''' Only process sub-array '''\n                                source_patches_loop = area_source_patch_cuda_all[il*loop_len:(il*loop_len)+loop_len,:]\n\n                                '''  SUBTRACTION '''\n                                sub_result_gm = cuda.device_array((source_patches_loop.shape[0],\n                                                                   target_patches_np_cuda_all.shape[0],\n                                                                   target_patches_np_cuda_all.shape[1]))\n                                TPB = (4,256)\n                                BPGx = int(math.ceil(source_patches_loop.shape[0] \/ TPB[0]))\n                                BPGy = int(math.ceil(target_patches_np_cuda_all.shape[0] \/ TPB[1]))\n                                BPGxy = (BPGx,BPGy)\n                                cu_sub_st[BPGxy,TPB](source_patches_loop, target_patches_np_cuda_all, sub_result_gm)\n\n                                '''  MAX-MEAN-ABS '''\n                                sub_max_mean_result = cuda.device_array((source_patches_loop.shape[0],\n                                                                         target_patches_np_cuda_all.shape[0],2))\n                                cu_max_mean_abs[BPGxy,TPB](sub_result_gm, sub_max_mean_result)\n                                sub_result_gm = 0  # Free memory\n\n                                '''  DISTANCE '''\n                                distances_result = cuda.device_array((source_patches_loop.shape[0],\n                                                                      target_patches_np_cuda_all.shape[0]))\n                                cu_distances[BPGxy,TPB](sub_max_mean_result,\n                                                        icv_source_flag_valid[il*loop_len:(il*loop_len)+loop_len],\n                                                        distances_result, alpha)\n                                sub_max_mean_result = 0  # Free memory\n\n                                ''' SORT '''\n                                TPB = 256\n                                BPG = int(math.ceil(distances_result.shape[0] \/ TPB))\n                                cu_sort_distance[BPG,TPB](distances_result)\n\n                                ''' MEAN (AGE-VALUE) '''\n                                idx_start = 8 # Starting index of mean calculation (to avoid bad example)\n                                distances_result_for_age = distances_result[:,idx_start:idx_start+num_mean_samples]\n                                distances_result = 0  # Free memory\n                                cu_age_value[BPG,TPB](distances_result_for_age,\n                                                      age_values_valid[il*loop_len:(il*loop_len)+loop_len])\n                                distances_result_for_age = 0  # Free memory\n                                del source_patches_loop  # Free memory\n                                #code.interact(local=dict(globals(), **locals()))\n                            print(' - Finished!\\n')\n                            print(timer() - melvin)\n                            raise Exception()\n                        ''' Mapping from age_value_valid to age value_all '''\n                        if valid == 1:\n                            index = 0\n                            for idx_val in index_mapping:\n                                if idx_val != -1:\n                                    age_values_all[index] = age_values_valid[int(idx_val)]\n                                index += 1\n\n                        ''' Normalisation to probabilistic map (0...1) '''\n                        if (np.max(age_values_all) - np.min(age_values_all)) == 0:\n                            all_mean_distance_normed = age_values_all\n                        else:\n                            all_mean_distance_normed = np.divide((age_values_all - np.min(age_values_all)),\n                                (np.max(age_values_all) - np.min(age_values_all)))\n\n                        ''' SAVE Result (JPG) '''\n                        slice_age_map = np.zeros([counter_x,counter_y])\n                        index = 0\n                        for ix in range(0, counter_x):\n                            for iy in range(0, counter_y):\n                                slice_age_map[ix,iy] = all_mean_distance_normed[index]\n                                index += 1\n\n                        ## Save mri_data\n                        sio.savemat(dirOutData + '\/' + str(patch_size[xy]) + '\/' + str(zz) + '_dat.mat',\n                                    {'slice_age_map':slice_age_map})\n\n                        print('Check GPU memory: ' + str(cuda.current_context().get_memory_info()))\n                        print('GPU flushing..\\n--\\n')\n                        numba.cuda.profile_stop()\n                    elapsed_times_patch_all[timer_idx,xy] = timer() - one_patch\n                    print('IAM for MRI ID: ' + mri_code + ' with patch size: ' + str(patch_size[xy])\n                          + ' elapsed for: ' + str(elapsed_times_patch_all[timer_idx,xy]))\n\n                elapsed_times_all[timer_idx] = timer() - one_mri_data\n                print('IAM for MRI ID: ' + mri_code + ' elapsed for: ' + str(elapsed_times_all[timer_idx]))\n                timer_idx += 1\n\n                ''' Save all elapsed times '''\n                sio.savemat(dirOutput + '\/elapsed_times_all_' + str(num_samples) + 's' + str(num_mean_samples) + 'm.mat',\n                            {'elapsed_times_all':elapsed_times_all})\n                sio.savemat(dirOutput + '\/elapsed_times_patch_all_' + str(num_samples) + 's' + str(num_mean_samples) + 'm.mat',\n                            {'elapsed_times_patch_all':elapsed_times_patch_all})\n                ''' IAM's (GPU Part) Computation ENDS here '''\n\n                '''\n                KEY POINT: IAM's Combination, Penalisation, and Post-processing - START\n                -----------------------------------------------------------------------\n                Part 0 - Saving output results in .mat and JPEG files.\n                Part 1 - Combination of multiple age maps.\n                Part 2 - Global normalisation and penalisation of age maps based on brain tissues.\n                Part 3 - Post-processing.\n\n                Hint: You can search the keys of Part 0\/1\/2\/3.\n                '''\n                combined_age_map_mri = np.zeros((x_len, y_len, z_len))\n                combined_age_map_mri_mult = np.zeros((x_len, y_len, z_len))\n                combined_age_map_mri_mult_normed = np.zeros((x_len, y_len, z_len))\n                for zz in range(0, mri_data.shape[2]):\n                    mri_slice = mri_data[:,:,zz]\n                    mask_slice = np.nan_to_num(mri_slice)\n                    mask_slice[mask_slice > 0] = 1\n                    penalty_slice = np.nan_to_num(mri_slice)   ### PENALTY\n\n                    slice_age_map_all = np.zeros((len(patch_size), x_len, y_len))\n\n                    dirOutData = dirOutput + '\/' + mri_code\n                    for xy in range(0, len(patch_size)):\n                        mat_contents = sio.loadmat(dirOutData + '\/' + str(patch_size[xy]) + '\/' + str(zz) + '_dat.mat')\n                        slice_age_map = mat_contents['slice_age_map']\n                        slice_age_map_res = cv2.resize(slice_age_map, None, fx=patch_size[xy],\n                                                       fy=patch_size[xy], interpolation=cv2.INTER_CUBIC)\n                        slice_age_map_res = skifilters.gaussian(slice_age_map_res,sigma=0.5,truncate=2.0)\n                        #if zz== 20:\n                        #    code.interact(local=dict(globals(), **locals()))\n                        slice_age_map_res = np.multiply(mask_slice, slice_age_map_res)\n                        slice_age_map_all[xy,:,:] = slice_age_map_res\n                    slice_age_map_all = np.nan_to_num(slice_age_map_all)\n\n\n                    if save_jpeg:\n                        ''' >>> Part 0 <<<'''\n                        ''' Show all age maps based on patch's size and saving the mri_data '''\n                        fig, axes = plt.subplots(2, 2, sharex=True, sharey=True)\n                        fig.set_size_inches(10, 10)\n                        fig.suptitle('All Patches Gaussian Filtered', fontsize=16)\n\n                        axes[0,0].set_title('Patch 1 x 1')\n                        im1 = axes[0,0].imshow(np.rot90(slice_age_map_all[0,:,:]), cmap=\"jet\", vmin=0, vmax=1)\n                        divider1 = make_axes_locatable(axes[0,0])\n                        cax1 = divider1.append_axes(\"right\", size=\"7%\", pad=0.05)\n                        cbar1 = plt.colorbar(im1, ticks=[0, 0.5, 1], cax=cax1)\n\n                        if len(patch_size) > 1:\n                            axes[0,1].set_title('Patch 2 x 2')\n                            im2 = axes[0,1].imshow(np.rot90(slice_age_map_all[1,:,:]), cmap=\"jet\", vmin=0, vmax=1)\n                            divider2 = make_axes_locatable(axes[0,1])\n                            cax2 = divider2.append_axes(\"right\", size=\"7%\", pad=0.05)\n                            cbar2 = plt.colorbar(im2, ticks=[0, 0.5, 1], cax=cax2)\n\n                            if len(patch_size) > 2:\n                                axes[1,0].set_title('Patch 4 x 4')\n                                im3 = axes[1,0].imshow(np.rot90(slice_age_map_all[2,:,:]), cmap=\"jet\", vmin=0, vmax=1)\n                                divider3 = make_axes_locatable(axes[1,0])\n                                cax3 = divider3.append_axes(\"right\", size=\"7%\", pad=0.05)\n                                cbar3 = plt.colorbar(im3, ticks=[0, 0.5, 1], cax=cax3)\n\n                                if len(patch_size) > 3:\n                                    axes[1,1].set_title('Patch 8 x 8')\n                                    im4 = axes[1,1].imshow(np.rot90(slice_age_map_all[3,:,:]), cmap=\"jet\", vmin=0, vmax=1)\n                                    divider4 = make_axes_locatable(axes[1,1])\n                                    cax4 = divider4.append_axes(\"right\", size=\"7%\", pad=0.05)\n                                    cbar4 = plt.colorbar(im4, ticks=[0, 0.5, 1], cax=cax4)\n\n                        plt.tight_layout()\n                        plt.subplots_adjust(top=0.95)\n\n                        ''' >>> Part 0 <<<'''\n                        ''' Save mri_data in *_all.jpg '''\n                        dirOutData = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/Patch\/'\n                        fig.savefig(dirOutData + str(zz) + '_all.jpg', dpi=100)\n                        print('Saving files: ' + dirOutData + str(zz) + '_all.jpg')\n                        plt.close()\n\n                    ''' >>> Part 1 <<< '''\n                    ''' Combined all patches age map information '''\n                    combined_age_map = 0\n                    for bi in range(len(patch_size)):\n                        combined_age_map += np.multiply(blending_weights[bi],slice_age_map_all[bi,:,:])\n                    combined_age_map_mri[:,:,zz] = combined_age_map\n\n                    ''' Global Normalisation - saving needed mri_data '''\n                    combined_age_map_mri_mult[:,:,zz] = np.multiply(np.multiply(combined_age_map, penalty_slice), mask_slice)  ### PENALTY\n                    normed_only = np.divide((combined_age_map_mri[:,:,zz] - np.min(combined_age_map_mri[:,:,zz])),\\\n                                            (np.max(combined_age_map_mri[:,:,zz]) - np.min(combined_age_map_mri[:,:,zz])))\n                    normed_mult = np.multiply(np.multiply(normed_only, penalty_slice), mask_slice)  ### PENALTY\n                    normed_mult_normed = np.divide((normed_mult - np.min(normed_mult)), \\\n                                            (np.max(normed_mult) - np.min(normed_mult)))\n                    combined_age_map_mri_mult_normed[:,:,zz] = normed_mult_normed\n\n                    ''' Save mri_data in *.mat '''\n                    dirOutData = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/Patch\/'\n                    print('Saving files: ' + dirOutData + 'c' + str(zz) + '_combined.mat\\n')\n                    sio.savemat(dirOutData + 'c' + str(zz) + '_combined.mat', {'slice_age_map_all':slice_age_map_all,\n                                                                'combined_age_map':normed_only,\n                                                                'mri_slice_mul_normed':normed_mult_normed,\n                                                                'combined_mult':combined_age_map_mri_mult[:,:,zz]})\n\n                ''' >>> Part 2 <<< '''\n                ''' Penalty + Global Normalisation (GN) '''\n                combined_age_map_mri_normed = np.divide((combined_age_map_mri - np.min(combined_age_map_mri)),\\\n                                            (np.max(combined_age_map_mri) - np.min(combined_age_map_mri)))\n                combined_age_map_mri_mult_normed = np.divide((combined_age_map_mri_mult - np.min(combined_age_map_mri_mult)),\\\n                                            (np.max(combined_age_map_mri_mult) - np.min(combined_age_map_mri_mult)))\n\n                if save_jpeg:\n                    for zz in range(0, mri_data.shape[2]):\n                        fig2, axes2 = plt.subplots(1, 3)\n                        fig2.set_size_inches(16,5)\n\n                        axes2[0].set_title('Combined and normalised')\n                        im1 = axes2[0].imshow(np.rot90(np.nan_to_num(combined_age_map_mri_normed[:,:,zz])), cmap=\"jet\", vmin=0, vmax=1)\n                        divider1 = make_axes_locatable(axes2[0])\n                        cax1 = divider1.append_axes(\"right\", size=\"7%\", pad=0.05)\n                        cbar1 = plt.colorbar(im1, ticks=[0, 0.5, 1], cax=cax1)\n\n                        axes2[1].set_title('Combined, penalised and normalised')\n                        im2 = axes2[1].imshow(np.rot90(np.nan_to_num(combined_age_map_mri_mult_normed[:,:,zz])), cmap=\"jet\", vmin=0, vmax=1)\n                        divider2 = make_axes_locatable(axes2[1])\n                        cax2 = divider2.append_axes(\"right\", size=\"7%\", pad=0.05)\n                        cbar2 = plt.colorbar(im2, ticks=[0, 0.5, 1], cax=cax2)\n\n                        axes2[2].set_title('Original MRI slice')\n                        im3 = axes2[2].imshow(np.rot90(np.nan_to_num(mri_data[:,:,zz])), cmap=\"gray\")\n                        divider3 = make_axes_locatable(axes2[2])\n                        cax3 = divider3.append_axes(\"right\", size=\"7%\", pad=0.05)\n                        cbar3 = plt.colorbar(im3, cax=cax3)\n\n                        plt.tight_layout()\n                        # Make space for title\n                        plt.subplots_adjust(top=0.95)\n\n                        ''' Save mri_data in *_combined.jpg '''\n                        dirOutData = dirOutput + '\/' + mri_code + '\/IAM_combined_python\/Combined\/'\n                        fig2.savefig(dirOutData + str(zz) + '_combined.jpg', dpi=100)\n                        print('Saving files: ' + dirOutData + str(zz) + '_combined.jpg')\n                        plt.close()\n\n                ''' Save mri_data in *.mat '''\n                sio.savemat(dirOutDataCom + '\/all_slice_dat.mat', {'combined_age_map_all_slice':combined_age_map_mri,\n                                                   'mri_slice_mul_all_slice':combined_age_map_mri_mult,\n                                                   'combined_age_map_mri_normed':combined_age_map_mri_normed,\n                                                   'combined_age_map_mri_mult_normed':combined_age_map_mri_mult_normed})\n\n                '''\n                combined_age_map_mri_img = nib.Nifti1Image(combined_age_map_mri_normed, mri_nii.affine)\n                nib.save(combined_age_map_mri_img, str(dirOutDataFin + '\/IAM_GPU_COMBINED.nii.gz'))\n\n                combined_age_map_mri_GN_img = nib.Nifti1Image(combined_age_map_mri_mult_normed, mri_nii.affine)\n                nib.save(combined_age_map_mri_GN_img, str(dirOutDataFin + '\/IAM_GPU_GN.nii.gz'))\n                '''\n\n                ''' >>> Part 3 <<< '''\n                ''' Post-processing '''\n                ''' COMMENTED OUT BECAUSE NOT AVAILABLE\n                if nawm_available and ~nawm_preprocessing:\n                    combined_age_map_mri_mult_normed = np.multiply(combined_age_map_mri_mult_normed,nawm_mri_code)\n                    combined_age_map_mri_GN_img = nib.Nifti1Image(combined_age_map_mri_mult_normed, mri_nii.affine)\n                    nib.save(combined_age_map_mri_GN_img, str(dirOutDataFin + '\/IAM_GPU_GN_postprocessed.nii.gz'))\n                '''\n                '''\n                ---------------------------------------------------------------------\n                KEY POINT: IAM's Combination, Penalisation, and Post-processing - END\n                '''\n\n                if delete_intermediary:\n                    shutil.rmtree(dirOutDataCom, ignore_errors=True)\n                    for xy in range(0, len(patch_size)):\n                        shutil.rmtree(dirOutput + '\/' + mri_code + '\/' + str(patch_size[xy]), ignore_errors=True)\n\n                del temp\n                del center_source_patch, icv_source_flag\n                del icv_source_flag_valid, index_mapping\n                del area_source_patch, target_patches_np   # Free memory\n                del area_source_patch_cuda_all, target_patches_np_cuda_all   # Free memory\n                gc.collect()\n\n        ## Print the elapsed time information\n        print('\\n--\\nSpeed statistics of this run..')\n        print('mean elapsed time  : ' + str(np.mean(elapsed_times_all)) + ' seconds')\n        print('std elapsed time   : ' + str(np.std(elapsed_times_all)) + ' seconds')\n        print('median elapsed time : ' + str(np.median(elapsed_times_all)) + ' seconds')\n        print('min elapsed time   : ' + str(np.min(elapsed_times_all)) + ' seconds')\n        print('max elapsed time   : ' + str(np.max(elapsed_times_all)) + ' seconds')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_190","text":"<gh_stars>0\n\"\"\"A library for 1D nodal-DG numerics.\"\"\"\n\nimport numpy as np\nimport scipy.special as ss\n\n\ndef jacobi_gq(alpha, beta, n):\n    \"\"\"Computes the n'th order Gauss quadrature points and weights.\"\"\"\n    p = ss.jacobi(n + 1, alpha, beta)\n    r = np.sort(p.r)\n    i = np.argsort(p.r)\n    w = p.weights[i]\n    return r, w\n\n\ndef jacobi_gl(alpha, beta, n):\n    \"\"\"Computes the n'th order Gauss lobatto quadrature points.\"\"\"\n    if n == 1:\n        x = np.zeros((2,))\n        x[0] = -1.0\n        x[1] = 1.0\n        return x\n\n    x, _ = jacobi_gq(alpha + 1, beta + 1, n - 2)\n    return np.concatenate([[-1.0], x, [1.0]])\n\n\ndef jacobi_p(x, alpha, beta, n):\n    \"\"\"Computes the Jacobi Polynomial.\n\n    Args:\n      x: Nodal points where the polynomial is computed.\n      alpha: Parameter of the Jacobi polynomial, must be greeater than -1.\n      beta: Parameter of the Jacobi polynomial, must be greeater than -1.\n      n: Degree of the polynomial.\n\n    Returns:\n      The Jacobi polynomial at points `r` for order `n`.\n    \"\"\"\n    p = np.zeros((len(x), 2))\n\n    # Initial values of p_0(x) and p_1(x).\n    gamma_0 = 2**(alpha + beta + 1) \/ (alpha + beta + 1) * \\\n            ss.gamma(alpha + 1) * ss.gamma(beta + 1) \/ \\\n            ss.gamma(alpha + beta + 1)\n    p[:, 0] = 1.0 \/ np.sqrt(gamma_0)\n    if n == 0:\n        return p[:, 0]\n    gamma_1 = (alpha + 1) * (beta + 1) \/ (alpha + beta + 3) * gamma_0\n    p[:, 1] = ((alpha + beta + 2) * x \/ 2 + (alpha - beta) \/ 2) \/ \\\n            np.sqrt(gamma_1)\n    if n == 1:\n        return p[:, 1]\n\n    a_old = 2.0 \/ (2.0 + alpha + beta) * \\\n            np.sqrt((alpha + 1) * (beta + 1) \/ (alpha + beta + 3))\n\n    for i in range(1, n):\n        h_1 = 2 * i + alpha + beta\n        a_new = 2.0 \/ (h_1 + 2) * np.sqrt((i + 1) * \\\n                (i + 1 + alpha + beta) * (i + 1 + alpha) * \\\n                (i + 1 + beta) \/ (h_1 + 1) \/ (h_1 + 3))\n        b_new = -(alpha**2 - beta**2) \/ h_1 \/ (h_1 + 2)\n        p_new = 1.0 \/ a_new * (-a_old * p[:, 0] + (x - b_new) * p[:, 1])\n        p[:, 0] = p[:, 1]\n        p[:, 1] = p_new\n        a_old = a_new\n\n    return p[:, 1]\n\n\ndef grad_jacobi_p(r, alpha, beta, n):\n    \"\"\"Computes the derivative of the Jacobi Polynomial.\n\n    Args:\n      r: Nodal points where the derivative is computed.\n      alpha: Parameter of the Jacobi polynomial, must be greeater than -1.\n      beta: Parameter of the Jacobi polynomial, must be greeater than -1.\n      n: Degree of the polynomial.\n\n    Returns:\n      The derivative of the Jacobi polynomial at points `r` for order `n`.\n    \"\"\"\n    if n < 0:\n        raise ValueError(\n            'Degree of the polynomial must be non-negative. '\n            '{} is given.'.format(n))\n    dp = np.zeros((len(r), 1))\n    if n > 0:\n        dp = (np.sqrt(n * (n + alpha + beta + 1.0)) *\n                jacobi_p(r, alpha + 1, beta + 1, n - 1))\n    return dp\n\n\ndef vandermonde_1d(n, r):\n    \"\"\"Initializes the 1D Vandermonde matrix, V_{ij} = phi_j(r_i).\"\"\"\n    v = np.zeros((len(r), n + 1))\n    for j in range(n + 1):\n        v[:, j] = jacobi_p(r, 0, 0, j)\n    return v\n\n\ndef grad_vandermonde_1d(n, r):\n    \"\"\"Initializes the gradient of the modal basis at `r` at order `n`.\"\"\"\n    d_vr = np.zeros((len(r), n + 1))\n    for i in range(n + 1):\n        d_vr[:, i] = np.squeeze(grad_jacobi_p(r, 0, 0, i))\n    return d_vr\n\n\ndef d_matrix_1d(n, r, v):\n    \"\"\"Initializes the differentiation matrices on the interval.\n\n    Args:\n      n: The order of the polynomial.\n      r: The nodal points.\n      v: The Vandemonde matrix.\n\n    Returns:\n      The gradient matrix D.\n    \"\"\"\n    vr = grad_vandermonde_1d(n, r)\n    return np.linalg.lstsq(v.T, vr.T, rcond=None)[0].T\n\n\ndef minmod(v):\n    \"\"\"Computes the minmod function.\"\"\"\n    m, n = v.shape\n    s = np.sum(np.sign(v), axis=0) \/ m\n    return np.where(np.abs(s) == 1, s * np.min(np.abs(v), axis=0), 0)\n\n\ndef minmodb(v, max_dd2, h):\n    \"\"\"Computes the TVB modified minmod function.\n\n    Args:\n      v: A 2D array with shape (n, k) representing k vectors of length n.\n      max_dd2: The upper bound on the second derivative at the local\n        extrema.\n      h: The grid spacing.\n\n    Returns:\n      The modified minmod function.\n    \"\"\"\n    m_fn = v[0, :]\n    ids = np.where(np.abs(m_fn) > max_dd2 * h**2)\n\n    if len(ids[0]) > 0:\n        m_fn[ids] = minmod(v[:, ids])\n\n    return m_fn\n\n\ndef slope_limit_lin(u_x, x_l, v_m1, v_0, v_p1):\n    \"\"\"Applies slope limiter to a linear function u.\n\n    Args:\n      u_x: The gradient of a linear polynomial of size (n_p, 1).\n      x_l: The collocation points of the linear element. The size of x_l is\n        (n_p, 1).\n      v_m1: The average of the left element.\n      v_0: The average of the current element.\n      v_p1: The average of the right element.\n\n    Returns:\n      The slope limited polynomial in the current element.\n    \"\"\"\n    n_p, k = u_x.shape\n    if x_l.shape[0] != n_p or x_l.shape[1] != k:\n        raise ValueError('The shape of input polynomial and collocation '\n                'points mismatches: u_l ({}), x_l({})'.format( \\\n                        u_x.shape, x_l.shape))\n    # Computes the grid size.\n    h = x_l[-1, :] - x_l[0, :]\n    h_n = np.tile(h, (n_p, 1))\n\n    # Computes the coordinates at the middle point of elements.\n    x_0 = np.tile(x_l[0, :] + 0.5 * h, (n_p, 1))\n\n    # Computes the limit function.\n    return np.tile(v_0, (n_p, 1)) + (x_l - x_0) * ( \\\n            np.tile( \\\n            minmod(np.array( \\\n            [u_x[0, :], (v_p1 - v_0) \/ h, (v_0 - v_m1) \/ h])), \\\n            (n_p, 1)))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_191","text":"\"\"\"\n    Test program to cac laulte the relation between focal length and\n    the accomodation parameter\n\"\"\"\n\nfrom poptics.lens import Eye\nimport poptics.wavelength as wl\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.optimize import curve_fit\n\n\n\ndef fit(x,a,b,c,d):\n    \"\"\"\n    the fit function for accomodation against focal length\n    \"\"\"\n    return a*x**3 + b*x**2 + c*x + d\n\ndef main():\n\n\n    #     Mahe default eye\n    eye = Eye(0.0)\n    print(\"Original Focalength : \" + str(eye.backFocalLength()))\n\n    #      Make a range of accomodation parameters, Note 1.0 is no accomodatiomn\n    acc = np.linspace(1.0,1.5,50)\n    focal = np.zeros(acc.size)\n\n    #      Go round loops finding focal length for each accomodation value\n    for i,a in enumerate(acc):\n        eye.accommodation(a)\n        focal[i] = eye.backFocalLength(wl.PhotopicPeak)\n\n    #     Do a fit\n    popt,pvar = curve_fit(fit,focal,acc)\n    print(str(popt))           # print out fite values\n\n    #     No a plot to make sure it is sensible.\n    plt.plot(focal,acc)\n    plt.plot(focal,fit(focal,*popt),\"x\")\n    plt.show()\n\n\n\nmain()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_180","text":"#!\/usr\/bin\/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nThe Jonker-Volgenant algorithm for finding the maximum assignment.\n\n<NAME>, University of Texas at Austin\nlast modified 10\/23\/2018\n\nThis is a direct adaptation of the Pascal code from\n\"A Shortest Augmenting Path Algorithm for Dense and Sparse Linear Assignment Problems\"\n<NAME> and <NAME>, Computing 1987\n\nthe __main__ code at the bottom tests this implementation, comparing it to\nScipy's linear_sum_assignment function. You'll need to have scipy in your\ndistribution to run this file on its own, but not to import it in other files.\n\"\"\"\nimport numpy as np\nimport numba as nb\n\ninf= 1e9 # inf is a suitably large number\n\n@nb.jit(nb.f8(nb.f8[:,:], nb.i8[:], nb.i8[:], nb.f8[:],\n              nb.i8[:], nb.i8, nb.i8[:], nb.i8, nb.f8[:], nb.i8[:]), nopython=True)\ndef SSP(c, x, y, v, rows2use, nrows2use, cols2use, ncols2use, d, pred):\n    \"\"\" solves full 2D assignment problem\n    c: matrix\n    x: column indices that match to row, or -1 if row is missing\n    y: match indices for column\n    v: column reductions\n    rows2use, nrows2use: rows in rows2use[:nrows2use] are considered part of the problem\n    cols2use, ncols2use: \" \"\n    d, pred: workspace for SSP, remember costs and path backwards for each column\n    returns cost of assignment\n    \"\"\"\n    C = 0.\n    \n    # basic column reduction - basically running some rows in a convenient order\n    nrows = nrows2use\n    for ri in xrange(nrows2use-1,-1,-1):\n        i = rows2use[ri]\n        j = np.argmin(c[i,:])\n        if c[i,j] < 0 and y[j] == -1:\n            x[i] = j\n            y[j] = i\n            C += c[i,j]\n            nrows -= 1\n            rows2use[ri] = rows2use[nrows]\n            rows2use[nrows] = i\n    \n    for i1 in rows2use[:nrows]:\n        d[:] = c[i1,:] - v\n        pred[:] = i1\n        minmissi = i1\n        minmissval = 0.\n        ncolsunused = ncols2use\n        emergcounter = 0\n        while True:\n            emergcounter += 1\n            assert emergcounter < 2000\n            minval = minmissval\n            minj = -1\n            mincolidx = 0\n            for colidx, j in enumerate(cols2use[:ncolsunused]):\n                dj = d[j]\n                if dj < minval:\n                    minj = j\n                    minval = dj\n                    mincolidx = colidx\n            j = minj\n            if j == -1:\n                break # hit unmatched row\n            i = y[j]\n            if i == -1:\n                break # hit unmatched column\n            # this column should no longer be considered\n            v[j] += minval\n            ncolsunused -= 1\n            cols2use[mincolidx] = cols2use[ncolsunused]\n            cols2use[ncolsunused] = j\n            # update distances to other columns\n            u1 = c[i,j] - v[j]\n            if -u1 < minmissval:\n                # this row is the closest to missing\n                minmissi = i\n                minmissval = -u1\n            for j in cols2use[:ncolsunused]:\n                dj = c[i,j] - v[j] - u1\n                if dj < d[j]:\n                    d[j] = dj\n                    pred[j] = i\n        \n        # augment\n        # travel back through shortest path to find matches\n        if j==-1:\n            i = minmissi\n            j = x[i]\n            x[i] = -1\n        emergcounter = 0\n        while i != i1:\n            emergcounter += 1\n            assert emergcounter < 2000\n            i = pred[j]\n            y[j] = i\n            k = j\n            j = x[i]\n            x[i] = k\n        # updating of column prices\n        for j in cols2use[ncolsunused:ncols2use]:\n            v[j] -= minval\n        C += minval\n    return C\n            \n\n\n            \n@nb.jit(nb.f8(nb.f8[:,:], nb.i8[:], nb.i8[:], nb.f8[:], nb.i8[:],\n              nb.i8, nb.i8[:], nb.i8, nb.f8[:], nb.i8[:],\n              nb.i8, nb.i8, nb.b1[:], nb.b1, nb.f8), nopython=True)\ndef spStep(c, x, y, v, rows2use, nrows2use, cols2use, ncols2use, d, pred,\n           i1, j1, eliminate_els, eliminate_miss, cost_bound):\n    \"\"\" solves Murty subproblem given solution to originating problem\n    same inputs as SSP and also:\n    i1, j1 = row and column that are now unassigned\n    eliminate_els = boolean array, whether matching a column with i1 is prohibited\n    eliminate_miss = whether i1 is prohibited to miss\n    cost_bound = function will stop early and return inf if the solution is known\n                    to be above this bound\n    returns cost of shortest path, a.k.a. this solution's cost minus original solution's\n    \"\"\"\n    \n    if j1>=0:\n        u0 = c[i1,j1]-v[j1] # not necessary to get solution, but gives accurate cost\n    else:\n        u0 = 0.\n    pred[:] = i1\n    ncols = ncols2use\n    for j in cols2use[:ncols]:\n        d[j] = inf if eliminate_els[j] else c[i1,j] - v[j] - u0\n    minmissj = -1\n    minmissi = i1\n    minmissval = inf if eliminate_miss else -u0\n    miss_unused = True\n    missing_from_row = False\n    missing_cost = 0. # this is a dual cost on auxiliary columns\n    emergcounter = 0\n    while True:\n        emergcounter += 1\n        assert emergcounter < 2000\n        minval = minmissval\n        minj = -2\n        minjcol = -1\n        for jcol, j in enumerate(cols2use[:ncols]):\n            dj = d[j]\n            if dj < minval:\n                minj = j\n                minval = dj\n                minjcol = jcol\n        if minval > cost_bound: return inf # that's all it takes for early stopping!\n        j = minj\n        if j==j1: break\n        if j == -2:\n            if not miss_unused: # if you got here again, costs must be really high\n                return inf\n            # entry to missing zone: row was matched but is now missing\n            missing=True\n            missing_from_row = True\n        else:\n            i = y[j]\n            # this column should no lonber be considered\n            ncols -= 1\n            cols2use[minjcol] = cols2use[ncols]\n            cols2use[ncols] = j\n            if i==-1:\n                # entry to missing zone: col was missing but is now matched\n                if miss_unused:\n                    minmissj = j\n                    missing=True\n                    missing_from_row = False\n                else:\n                    # already covered the missing zone, this is a dead end\n                    continue\n            else:\n                missing=False\n        if missing:\n            if j1 == -1:\n                j=-1\n                break\n            miss_unused = False\n            missing_cost = minval\n            minmissval = inf\n            u1 = -minval\n            # exit from missing zone: row that was missing is matched\n            for i in rows2use[:nrows2use]:\n                if x[i]==-1:\n                    for j in cols2use[:ncols]:\n                        dj = c[i,j]-v[j]-u1\n                        if dj < d[j]:\n                            d[j] = dj\n                            pred[j] = i\n            # exit from missing zone: col that was matched is missing\n            for j in cols2use[:ncols]:\n                if y[j] >= 0:\n                    dj = -v[j]-u1\n                    if dj < d[j]:\n                        d[j] = dj\n                        pred[j] = -1\n        else:\n            u1 = c[i,j]-v[j]-minval\n            if miss_unused and -u1<minmissval:\n                minmissi = i\n                minmissval = -u1\n            for j in cols2use[:ncols]:\n                dj = c[i,j]-v[j]-u1\n                if dj < d[j]:\n                    d[j] = dj\n                    pred[j] = i\n    \n    # augment\n    # updating of column prices\n    v[cols2use[ncols:ncols2use]] += d[cols2use[ncols:ncols2use]] - minval\n    if not miss_unused:\n        v[cols2use[:ncols2use]] += minval - missing_cost\n    # travel back through shortest path to find matches\n    i = i1+1 # any number that isn't i1\n    emergcounter = 0\n    while i != i1:\n        emergcounter += 1\n        assert emergcounter < 2000\n        if j == -1:\n            # exit from missing zone: row was missing but is now matched\n            i = -1\n        else:\n            i = pred[j]\n            y[j] = i\n        if i == -1:\n            # exit from missing zone: column j was matched but is now missing\n            if missing_from_row:\n                # entry to missing zone: row was matched but is now missing\n                i = minmissi\n                j = x[i]\n                x[i] = -1\n            else:\n                # entry to missing zone: col was missing but is now matched\n                j = minmissj\n        else:\n            k = j\n            j = x[i]\n            x[i] = k\n    v[y==-1] = 0.\n    return minval\n\n\n\nif __name__ == '__main__':\n    \"\"\"\n    create a random matrix\n    try assignment, check for equality\n    \"\"\"\n    from scipy.optimize import linear_sum_assignment\n    \n    m=10\n    n=20\n#    P = np.random.exponential(size=(n,m))\n#    mX = np.random.exponential(size=(n,))\n#    mY = np.random.exponential(size=(m,))\n    P = np.random.rand(m,n)\n    mX = np.random.rand(m)\n    mY = np.random.rand(n)\n    \n    # make full square version, use standard code\n    c1 = np.zeros((m+n,m+n))\n    c1[:m,:n] = P\n    c1[:m,n:] = 1e4\n    c1[range(m),range(n,m+n)] = mX\n    c1[m:,:n] = 1e4\n    c1[range(m,m+n), range(n)] = mY\n    sol = linear_sum_assignment(c1)\n    x1 = np.array(sol[1][:m])\n    x1[x1>=n] = -1\n    y1 = np.arange(n)\n    for k,j in enumerate(sol[1]):\n        j = sol[1][k]\n        if j < n:\n            if k < m:\n                y1[j] = k\n            else:\n                y1[j] = -1\n    print x1\n    print y1\n    \n\n    y = np.zeros(n, dtype=int) - 1\n    x = np.zeros(m, dtype=int) - 1\n    v = np.zeros(n)\n    c2 = P - mX[:,None] - mY[None,:]\n    rows2use = np.arange(m)\n    cols2use = np.arange(n)\n    d = np.zeros(n)\n    pred = np.zeros(n, dtype=int)\n    SSP(c2, x, y, v, rows2use, cols2use, d, pred)\n    print x\n    print y\n    \n    v += mY\n    u = mX.copy()\n    xmatch = x>=0\n    xmis = xmatch==False\n    ymis = y==-1\n    u[xmatch] = P[xmatch,x[xmatch]] - v[x[xmatch]]\n    u2 = np.append(u, np.zeros(n))\n    v2 = np.append(v, np.zeros(m))\n    x2 = np.append(x, y+n)\n    x2[np.where(x==-1)[0]] = np.where(x==-1)[0]+n\n    x2[np.where(y==-1)[0]+m] = np.where(y==-1)[0]\n    slack = c1 - u2[:,None] - v2\n    assert np.min(slack) > -1e-8\n    assert all(slack[range(m+n), x2] < 1e-8)\n    assert np.min(v[ymis]) >= -1e-8 if any(ymis) else True"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_182","text":"\"\"\"\nBSD 3-Clause License\n\nCopyright (c) 2020, Cyber Security Research Centre Limited\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n   list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\n   this list of conditions and the following disclaimer in the documentation\n   and\/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its\n   contributors may be used to endorse or promote products derived from\n   this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\"\"\"\nfrom tick.hawkes import SimuHawkesExpKernels, SimuHawkesMulti, HawkesExpKern, SimuHawkes, HawkesEM, HawkesKernelTimeFunc, HawkesBasisKernels\nfrom tick.plot import plot_hawkes_kernels, plot_point_process\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom HelperFunctions import ConcatClusters, ComputeClusterLengths\nfrom tick_goodness_of_fit import plot_resid, goodness_of_fit_par\nfrom scipy import integrate\nimport math\n\n#contains various functions used to train or simulate models related to hawkes processes\n#some maybe broken, but the ones used in the notebooks work\n\n\n#takes a list of inner cluster timestamps\n#attemps to train an exp model to produce more clusters\ndef TrainInnerClusterExp(clusters, num_decays=2000, decay_low=-10, decay_high=10):\n    data = ConcatClusters(clusters, 0)\n    best_score = -1e100\n    #decays for multiple dimention process\n    #update this to have different decays for each process\n    #num_decays = 2000\n    #print(f\"Total decay combinations = {num_decays*num_decays*num_decays*num_decays}\")\n    decay_candidates = np.logspace(decay_low, decay_high, num_decays, dtype=np.dtype('d'))\n    print(f\"Training on {len(clusters)} clusters\")\n    print(f\"Decay Range: {decay_candidates[0]} -> {decay_candidates[-1]}\")\n    best_decay = decay_candidates[0]\n    score_list = np.zeros(num_decays)\n\n    #x*e^(-xt)\n    l = 0\n    floaterrors = 0\n    baseline_errors = 0\n    for i, decay in enumerate(decay_candidates):\n        decay = decay * np.ones((2,2))\n        try:\n            #might need a hyperbolic kernel?\n            #it seems to get too excited and decays too slowly\n            #only small decay values seem to make sense\n            learner = HawkesExpKern(decay, penalty='l2', C=1000, max_iter=1000, solver='agd', tol=1e-3)#, max_iter=1000, tol=1e-5) #gofit='likelihood'\n            ###Error functions\n            #l1 - has 0 step errors\n            #l2 - runs, but the results do not look good, heavily favours higher decay values that produce nonsense graphs\n            #elasticnet (elastic_net_ratio, def 0.95) - values closer to 0 work better (since it uses l2) otherwise it produces step errors. Still similar to l2.\n            #nuclear - basically the same\n            #none - how can you have no penalty function?\n            ###solvers\n            #agd - all penalties favour super high decays, basicaly wants random event generation\n            #gd - basically the same\n            #bfgs - does weird things, but is quick\n            #svrg\n\n            learner.fit(data, start=learner.coeffs)\n\n            \"\"\"cluster_num = 0\n            for cluster in clusters:\n                if (cluster_num % 100 == 0):\n                    #print out training progress\n                    s = f\"It: {i}, Decay: {decay[0]}, Cluster: {cluster_num}\"\n                    print(f\"\\r{' '*l}\\r\", end='')\n                    print(f\"It: {i}, Decay: {decay[0]}, Cluster: {cluster_num}\", end='', flush=True)\n                    l = len(s)\n                learner.fit(cluster, start=learner.coeffs)\n                cluster_num += 1\"\"\"\n            hawkes_score = learner.score()\n            #print(hawkes_score)\n            #print(f\"Coeffs: {learner.coeffs}\")\n\n            #ensure there is a non-0 baseline\n            numb = 0\n            for b in learner.baseline:\n                if (b > 0):\n                    numb += 1\n            if (numb == 0):\n                baseline_errors += 1\n                continue\n            \n            #record the score for plotting\n            score_list[i] = hawkes_score\n\n            #record the best\n            if (hawkes_score > best_score):\n                best_score = hawkes_score\n                best_learner = learner\n                best_decay = decay\n\n            step = 0.01\n            #residuals = goodness_of_fit_par(learner,data,step,integrate.simps)\n            #plot_resid(residuals,2,1)\n\n\n\n        except ZeroDivisionError:\n            #print(\"float error\");\n            floaterrors += 1\n            continue;\n    \n    #create a score plot\n    plt.plot(decay_candidates, score_list)\n    plt.xscale('log')\n    plt.yscale('log')\n    plt.title('decay Scores')\n    plt.grid(True)\n    plt.show()\n\n    print(f\"\\nTraining Done\")\n    print(f\"Float Errors: {floaterrors} ({100\/num_decays*floaterrors}%)\")\n    print(f\"Baseline Errors: {baseline_errors} ({100\/num_decays*baseline_errors}%)\")\n    print(f\"==========\\nSuccessful Results: {num_decays - floaterrors - baseline_errors} ({100\/num_decays*(num_decays - floaterrors - baseline_errors)}%)\\n==========\\n\")\n\n    print(f\"\\nBest Score: {best_score}\")\n    print(f\"Best Decay: {best_decay}\")\n    plot_hawkes_kernels(best_learner)\n\n    print(f\"Adjacency: {best_learner.adjacency}\")\n    print(f\"Baseline: {best_learner.baseline}\")\n    print(f\"Coeffs: {best_learner.coeffs}\")\n\n    #return best_learner.adjacency, best_learner.baseline, best_decay\n    return best_learner, best_decay\n\ndef TrainSeriesExp(series, num_decays=2000, decay_low=-10, decay_high=10):\n    best_score = -1e100\n    #decays for multiple dimention process\n    #update this to have different decays for each process\n    #num_decays = 2000\n    #print(f\"Total decay combinations = {num_decays*num_decays*num_decays*num_decays}\")\n    decay_candidates = np.logspace(decay_low, decay_high, num_decays, dtype=np.dtype('d'))\n    print(f\"Decay Range: {decay_candidates[0]} -> {decay_candidates[-1]}\")\n    best_decay = decay_candidates[0]\n    score_list = np.zeros(num_decays)\n\n    #x*e^(-xt)\n    l = 0\n    floaterrors = 0\n    baseline_errors = 0\n    for i, decay in enumerate(decay_candidates):\n        #decay = decay * np.ones((2,2))\n        try:\n            #might need a hyperbolic kernel?\n            #it seems to get too excited and decays too slowly\n            #only small decay values seem to make sense\n            learner = HawkesExpKern(decay, penalty='l2', C=1e-3, max_iter=1000, solver='agd', tol=1e-5)#, max_iter=1000, tol=1e-5) #gofit='likelihood'\n            ###Error functions\n            #l1 - has 0 step errors\n            #l2 - runs, but the results do not look good, heavily favours higher decay values that produce nonsence graphs\n            #elasticnet (elastic_net_ratio, def 0.95) - values closer to 0 work better (since it uses l2) otherwise it produces step errors. Still similar to l2.\n            #nuclear - basically the same\n            #none - how can you have no penalty function?\n            ###solvers\n            #agd - all penalties favour super high decays, basicaly wants random event generation\n            #gd - basically the same\n            #bfgs - does weird things, but is quick\n            #svrg\n\n            learner.fit([series])\n\n            \"\"\"cluster_num = 0\n            for cluster in clusters:\n                if (cluster_num % 100 == 0):\n                    #print out training progress\n                    s = f\"It: {i}, Decay: {decay[0]}, Cluster: {cluster_num}\"\n                    print(f\"\\r{' '*l}\\r\", end='')\n                    print(f\"It: {i}, Decay: {decay[0]}, Cluster: {cluster_num}\", end='', flush=True)\n                    l = len(s)\n                learner.fit(cluster, start=learner.coeffs)\n                cluster_num += 1\"\"\"\n            hawkes_score = learner.score()\n            #print(hawkes_score)\n            #print(f\"Coeffs: {learner.coeffs}\")\n\n            #ensure there is a non-0 baseline\n            numb = 0\n            for b in learner.baseline:\n                if (b > 0):\n                    numb += 1\n            if (numb == 0):\n                baseline_errors += 1\n                continue\n            \n            #record the score for plotting\n            score_list[i] = hawkes_score\n\n            #record the best\n            if (hawkes_score > best_score):\n                best_score = hawkes_score\n                best_learner = learner\n                best_decay = decay\n        except ZeroDivisionError:\n            #print(\"float error\");\n            floaterrors += 1\n            continue;\n    \n    #create a score plot\n    plt.plot(decay_candidates, score_list)\n    plt.xscale('log')\n    plt.yscale('log')\n    plt.title('decay Scores')\n    plt.grid(True)\n    plt.show()\n\n    print(f\"\\nTraining Done\")\n    print(f\"Float Errors: {floaterrors} ({100\/num_decays*floaterrors}%)\")\n    print(f\"Baseline Errors: {baseline_errors} ({100\/num_decays*baseline_errors}%)\")\n    print(f\"==========\\nSuccessful Results: {num_decays - floaterrors - baseline_errors} ({100\/num_decays*(num_decays - floaterrors - baseline_errors)}%)\\n==========\\n\")\n\n    print(f\"\\nBest Score: {best_score}\")\n    print(f\"Best Decay: {best_decay}\")\n    plot_hawkes_kernels(best_learner)\n\n    print(f\"Adjacency: {best_learner.adjacency}\")\n    print(f\"Baseline: {best_learner.baseline}\")\n    print(f\"Coeffs: {best_learner.coeffs}\")\n\n    #return best_learner.adjacency, best_learner.baseline, best_decay\n    return best_learner, best_decay\n\n\n#careful, setting the time to be too high will eat up all available memory\ndef SimulateExp(baseline, adjacency, decays, time):\n\n    hawkes = SimuHawkesExpKernels(adjacency=adjacency, decays=decays, baseline=baseline, verbose=False)\n\n    hawkes.end_time = time\n    dt = 0.001 #millisecond granularity\n    #hawkes.track_intensity(dt)\n    print(f\"Starting sim\")\n    hawkes.simulate()\n    timestamps = hawkes.timestamps\n    l = 0\n    for series in timestamps:\n        l += len(series)\n    print(f\"Simulated {l} points\")\n    return hawkes.timestamps\n\ndef TrainInnerClusterEM(clusters, k_time = 1, k_size = 100):\n    #merge all the clusters, the learner seems to only be able to fit a single long datastream\n    num_clusters = len(clusters)\n    data = ConcatClusters(clusters, 0)\n\n    #kernel size is the granularity\n    #kernel support is something... (is it the size of each step?)\n    em_learner = HawkesEM(kernel_support=k_time, kernel_size=k_size, n_threads=8, verbose=True, tol=1e-5, max_iter=1000)\n    em_learner.fit(data)\n\n    \"\"\"#train the em learner on each cluster\n    cluster_num = 0\n    for cluster in clusters:\n        if (cluster_num % 10 == 0):\n            #print out training progress\n            s = f\"Cluster: {cluster_num}\/{num_clusters}\"\n            print(f\"\\r{' '*l}\\r\", end='')\n            print(f\"Cluster: {cluster_num}\/{num_clusters}\", end='', flush=True)\n            l = len(s)\n        print(em_learner.baseline)\n        print(em_learner.kernel)\n        print(\"==========\")\n        if (cluster_num == 0):\n            em_learner.fit(cluster)\n        else:\n            em_learner.fit(cluster, baseline_start=em_learner.baseline, kernel_start=em_learner.kernel)\n        cluster_num += 1\"\"\"\n    #maybe add variation in kernel sie later?\n    #use em_learner.score() to evaluate goodness\n    print(f\"\\nEM Score: {em_learner.score()}\")\n    fig = plot_hawkes_kernels(em_learner) #TODO, remove this?\n\n    t = np.linspace(0, k_time, endpoint=False, num=k_size)\n\n    m = []\n    for i in range(2):\n        for j in range(2):\n            m.append(max(em_learner.kernel[i][j]))\n    #normalise to make a proper hawkes process\n    spectral_radius = max(m)\n    if (spectral_radius < 1):\n        spectral_radius = 1\n            \n    #create a 2x2 array of time func kernels\n    k = [[],[]]\n    for i in range(2):\n        for j in range(2):\n            k[i].append(HawkesKernelTimeFunc(t_values=t, y_values=em_learner.kernel[i][j]\/np.linalg.norm(em_learner.kernel[i][j])))\n\n    #return k, em_learner.baseline #the kernel, baseline\n    return em_learner\n\ndef SimulateEM(kernel, baseline, time=600):\n    sim_em = SimuHawkes(kernels=kernel, baseline=baseline, verbose=False, end_time=time)\n\n    dt = 0.001 #millisecond granularity\n    #sim_em.track_intensity(dt)\n    sim_em.simulate()\n\n    timestamps = sim_em.timestamps\n    l = 0\n    for series in timestamps:\n        l += len(series)\n    print(f\"Simulated {l} points\")\n    return sim_em.timestamps\n\ndef TrainInnerClusterBasis(clusters, k_time=1, k_size=100, num_kernels=2):\n    num_clusters = len(clusters)\n    #data = ConcatClusters(clusters, 0)\n    l = 0\n\n    basis_learner = HawkesBasisKernels(kernel_support=k_time, kernel_size=k_size, n_basis=num_kernels, C=1e-3, n_threads=8, verbose=False, ode_tol=1e-5, max_iter=1000)\n    #train the basis learner on each cluster\n    cluster_num = 0\n    for cluster in clusters:\n        if (cluster_num % 10 == 0):\n            #print out training progress\n            s = f\"Cluster: {cluster_num}\/{num_clusters}\"\n            print(f\"\\r{' '*l}\\r\", end='')\n            print(f\"Cluster: {cluster_num}\/{num_clusters}\", end='', flush=True)\n            l = len(s)\n        if (cluster_num == 0):\n            basis_learner.fit(cluster)\n        else:\n            basis_learner.fit(cluster, baseline_start=basis_learner.baseline, amplitudes_start=basis_learner.amplitudes, basis_kernels_start=basis_learner.basis_kernels)\n        cluster_num += 1\n\n\n    #kernel size is the granularity\n    #kernel support is something... (is it the size of each step?)\n    #basis_learner = HawkesBasisKernels(kernel_support=k_time, kernel_size=k_size, n_basis=num_kernels, C=1e-3, n_threads=8, verbose=True, ode_tol=1e-5, max_iter=1000)\n    #basis_learner.fit(data)\n    #maybe add variation in kernel sie later?\n    #use em_learner.score() to evaluate goodness\n    #print(f\"\\nEM Score: {basis_learner.score()}\")\n\n    #TODO, remove this?\n    fig = plot_hawkes_kernels(basis_learner)\n\n    print(basis_learner.basis_kernels)\n    print(basis_learner.amplitudes)\n    print(basis_learner.baseline)\n    return None\n\ndef SimulateBasis(kernel, baseline, time=600):\n    sim_em = SimuHawkes(kernels=kernel, baseline=baseline, verbose=False, end_time=time)\n\n    dt = 0.001 #millisecond granularity\n    sim_em.track_intensity(dt)\n    sim_em.simulate()\n\n    timestamps = sim_em.timestamps\n    l = 0\n    for series in timestamps:\n        l += len(series)\n    print(f\"Simulated {l} points\")\n    return sim_em.timestamps\n\n\n#takes clusters of timestamps\n#trains using clusters instead of concatenating them\ndef TrainInnerTimestampsExp(clusters, num_decays=2000, decay_low=-10, decay_high=10, max_iterations=100, tolerance=1e-5, e=10):\n    cat_clusters = ConcatClusters(clusters, 0)\n    best_score = -1e100\n    print(f\"Training on {len(clusters)} clusters\")\n    unique_decays = int(num_decays**(1.0\/4))\n    num_decays = unique_decays**4\n    decay_candidates = np.logspace(decay_low, decay_high, unique_decays, dtype=np.dtype('d'))\n    print(f\"Decay Range: {decay_candidates[0]} -> {decay_candidates[-1]}\")\n    print(f\"{unique_decays} unique decays. {num_decays} total\")\n    best_decay = None\n    score_list = np.zeros(num_decays)\n\n    #x*e^(-xt)\n    l = 0\n    floaterrors = 0\n    baseline_errors = 0\n    for i in range(num_decays):\n        decay = np.ones((2,2))\n        decay[0][0] = decay_candidates[int(i\/(unique_decays**3))%unique_decays]\n        decay[0][1] = decay_candidates[int(i\/(unique_decays**2))%unique_decays]\n        decay[1][0] = decay_candidates[int(i\/(unique_decays**1))%unique_decays]\n        decay[1][1] = decay_candidates[int(i)%unique_decays]\n        prev_score = float('-inf')\n        #print(decay)\n        try:\n            learner = HawkesExpKern(decay, penalty='l2', C=e, max_iter=1, solver='agd', tol=1e-5)\n\n            #do the learning loop\n            #need a stopping point\n            for i in range(max_iterations):\n                for cluster in clusters:\n                    learner.fit(cluster, start=learner.coeffs)\n                it_score = learner.score()\n                print(f\"It: {i}, Score: {it_score}\")\n                if (it_score <= prev_score + tolerance):\n                    #barely changed\n                    break\n                prev_score = it_score\n            hawkes_score = learner.score(events=clusters)\n\n            #ensure there is a non-0 baseline\n            numb = 0\n            for b in learner.baseline:\n                if (b > 0):\n                    numb += 1\n            if (numb == 0):\n                baseline_errors += 1\n                continue\n            \n            #record the score for plotting\n            score_list[i] = hawkes_score\n\n            #record the best\n            if (hawkes_score > best_score):\n                best_score = hawkes_score\n                best_learner = learner\n                best_decay = decay\n\n        except ZeroDivisionError:\n            #print(\"float error\");\n            floaterrors += 1\n            continue;\n    \n    #create a score plot\n    plt.plot(score_list)\n    plt.xscale('log')\n    plt.yscale('log')\n    plt.title('decay Scores')\n    plt.grid(True)\n    plt.show()\n\n    print(f\"\\nTraining Done\")\n    print(f\"Float Errors: {floaterrors} ({100\/num_decays*floaterrors}%)\")\n    print(f\"Baseline Errors: {baseline_errors} ({100\/num_decays*baseline_errors}%)\")\n    print(f\"==========\\nSuccessful Results: {num_decays - floaterrors - baseline_errors} ({100\/num_decays*(num_decays - floaterrors - baseline_errors)}%)\\n==========\\n\")\n\n    print(f\"\\nBest Score: {best_score}\")\n    print(f\"Best Decay: {best_decay}\")\n    plot_hawkes_kernels(best_learner)\n\n    print(f\"Adjacency: {best_learner.adjacency}\")\n    print(f\"Baseline: {best_learner.baseline}\")\n    print(f\"Coeffs: {best_learner.coeffs}\")\n\n    #activate this for residuals (Warning, it is REALLLLLLLLLLY SLOOOOOOOOOOOOW)\n    step = 0.1\n    residuals = goodness_of_fit_par(best_learner,cat_clusters,step,integrate.simps)\n    plot_resid(residuals,2,1)\n\n    return best_learner.adjacency, best_learner.baseline, best_decay\n\n\n#\"you just put the clusters into it and it does it (tm)\"\n#takes clusters of timestamps\n#trains using clusters instead of concatenating them\ndef TrainInnerTimestampsExp2(clusters, num_decays=2000, decay_low=-10, decay_high=10, e=10):\n    best_score = -1e100\n    print(f\"Training on {len(clusters)} clusters\")\n    unique_decays = int(num_decays**(1.0\/4))\n    num_decays = unique_decays**4\n    decay_candidates = np.logspace(decay_low, decay_high, unique_decays, dtype=np.dtype('d'))\n    print(f\"Decay Range: {decay_candidates[0]} -> {decay_candidates[-1]}\")\n    print(f\"{unique_decays} unique decays. {num_decays} total\")\n    best_decay = None\n    score_list = np.zeros(num_decays)\n\n    #x*e^(-xt)\n    l = 0\n    floaterrors = 0\n    baseline_errors = 0\n    for i in range(num_decays):\n        s = f\"Decay {i} ({format(100\/num_decays*i, '.2f')}% done)\"\n        l = len(s)\n        #print(f\"{' '*l}\\r\", end=\"\", flush=True)\n        print(f\"{' '*l}\\r{s}\\r\", end='', flush=True)\n        decay = np.ones((2,2))\n        decay[0][0] = decay_candidates[int(i\/(unique_decays**3))%unique_decays]\n        decay[0][1] = decay_candidates[int(i\/(unique_decays**2))%unique_decays]\n        decay[1][0] = decay_candidates[int(i\/(unique_decays**1))%unique_decays]\n        decay[1][1] = decay_candidates[int(i)%unique_decays]\n        prev_score = float('-inf')\n        #print(decay)\n        try:\n            learner = HawkesExpKern(decay, penalty='l2', C=e, max_iter=1000, solver='agd', tol=1e-5)\n            learner.fit(clusters)\n            hawkes_score = learner.score()\n\n            #ensure there is a non-0 baseline\n            numb = 0\n            for b in learner.baseline:\n                if (b > 0):\n                    numb += 1\n            if (numb == 0):\n                baseline_errors += 1\n                continue\n            \n            #record the score for plotting\n            score_list[i] = hawkes_score\n\n            #record the best\n            if (hawkes_score > best_score):\n                best_score = hawkes_score\n                best_learner = learner\n                best_decay = decay\n\n        except ZeroDivisionError:\n            #print(\"float error\");\n            floaterrors += 1\n            continue;\n    \n    #create a score plot\n    plt.plot(score_list)\n    plt.xscale('log')\n    plt.yscale('log')\n    plt.title('decay Scores')\n    plt.grid(True)\n    plt.show()\n\n    print(f\"\\nTraining Done\")\n    print(f\"Float Errors: {floaterrors} ({100\/num_decays*floaterrors}%)\")\n    print(f\"Baseline Errors: {baseline_errors} ({100\/num_decays*baseline_errors}%)\")\n    print(f\"==========\\nSuccessful Results: {num_decays - floaterrors - baseline_errors} ({100\/num_decays*(num_decays - floaterrors - baseline_errors)}%)\\n==========\\n\")\n\n    print(f\"\\nBest Score: {best_score}\")\n    print(f\"Best Decay: {best_decay}\")\n    plot_hawkes_kernels(best_learner)\n\n    print(f\"Adjacency: {best_learner.adjacency}\")\n    print(f\"Baseline: {best_learner.baseline}\")\n    print(f\"Coeffs: {best_learner.coeffs}\")\n\n    #activate this for residuals (Warning, it is REALLLLLLLLLLY SLOOOOOOOOOOOOW)\n    cat_clusters = ConcatClusters(clusters, 0)\n    step = 0.1\n    residuals = goodness_of_fit_par(best_learner,cat_clusters,step,integrate.simps)\n    plot_resid(residuals,2,1)\n\n    return best_learner.adjacency, best_learner.baseline, best_decay\n\n\ndef SimExp(baseline, adjacency, decays, num_clusters, data):\n    hawkes = SimuHawkesExpKernels(adjacency=adjacency, decays=decays, baseline=baseline, verbose=False)\n\n    #dt = 0.001 #millisecond granularity\n    #hawkes.track_intensity(dt) # turning this on will eat up memory\n\n    #need to compute and draw from the cluster length distrbution from the original data\n    cluster_lengths = ComputeClusterLengths(data)\n\n    multi = SimuHawkesMulti(hawkes, n_simulations=num_clusters)\n\n    multi.end_time = np.random.choice(cluster_lengths, size=num_clusters, replace=True)\n    multi.simulate()\n    sim_inner_timestamps = multi.timestamps\n\n    l = 0\n    for realisation in sim_inner_timestamps:\n        for series in realisation:\n            l += len(series)\n    print(f\"Simulated {l} points\")\n    return sim_inner_timestamps\n\n#k_time is the timescale on which a model should be formed\n#k_size is how many points it should consider on this timescale\ndef TrainEM(times, k_time = 1, k_size = 100):\n\n    #kernel size is the granularity\n    #kernel support is the length of time to support\n    em_learner = HawkesEM(kernel_support=k_time, kernel_size=k_size, n_threads=4, verbose=True, tol=1e-5, max_iter=250)\n    em_learner.fit(times)\n\n    #fig = plot_hawkes_kernels(em_learner) #TODO, remove this?\n\n    return em_learner\n\ndef SimEM(smodel, time=600):\n    sim_em = SimuHawkes(kernels=smodel.time_kernel, baseline=smodel.baseline, verbose=False, end_time=time)\n    sim_em.simulate()\n    return sim_em.timestamps\n\nclass SavedModel:\n\n    def __init__(self, model, k_time, k_size, is_em=True, decay=0):\n        self.baseline = model.baseline\n        self.k_time = k_time\n        self.k_size = k_size\n        self.time_kernel = None\n        self.intensity = 0\n        self.decay = decay\n        self.is_em = is_em\n        if (is_em):\n            self.kernel = model.kernel\n            self.MakeTimeKernel(self.kernel)\n            self.n_realizations = model.n_realizations\n            self.n_nodes = model.n_nodes\n        else:\n            self.intensity = model.adjacency\n            self.coeffs = model.coeffs\n\n    def MakeTimeKernel(self, kernel):\n        #check the spectral radius\n        m = []\n        for process in kernel:\n            for intensity in process:\n                m.append(max(intensity))\n        self.spectral_radius = max(m)\n        if (self.spectral_radius > 1):\n            #oh no\n            self.time_kernel = None\n            return\n\n        #create a time kernel for simulation\n        t = np.linspace(0, self.k_time, endpoint=False, num=self.k_size)\n        k = []\n        for process in kernel:\n            for intensity in process:\n                k.append(HawkesKernelTimeFunc(t_values=t, y_values=intensity))\n\n        k = np.reshape(k, kernel.shape[:2])\n        self.time_kernel = k\n\n    def Save(self, fname):\n        np.savez(fname, savedmodel=self)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_185","text":"# -- coding: utf-8 --\n\n# Copyright 2018 <NAME> <<EMAIL>>\n\nimport scipy.optimize as opt\n\"\"\"\nProvides some useful mathematical functions which are not present in numpy.\n\"\"\"\n\nimport numpy as np\n\ndef prod(x):\n    p = 1\n    for k in x:\n        p *= k\n    return p\n\ndef perm(x):\n    \"\"\"\n    permutation with repetition of n factors\n    x = [n1,n2,n3,...nk]\n    n = n1+n2+...+nk\n    return n!\/(n1!*n2*...*nk!)\n    \"\"\"\n    n = sum(x)\n    num = list(range(2,n+1))\n    denom = list(range(2,x[0]+1))\n    for k in x[1:]:\n        denom += list(range(2,k+1))\n    for x in num:\n        if x in denom:\n            num.remove(x)\n            denom.remove(x)\n    return prod(num)\/prod(denom)\n    \ndef closest_arg(array, value):\n    return np.argmin(np.abs(array-value))\n    \ndef strictly_positify(x):\n    \"\"\"\n    Make the result strictly positive by setting the minimum value to\n    the lower allowed float value\n    \"\"\"\n    return np.fmax(x, np.finfo(x.dtype).eps)\n    \ndef positify(x):\n    \"\"\"\n    Set to zero all negative values\n    \"\"\"\n    return np.fmax(0, x)\n\ndef clip01(x):\n    \"\"\"\n    clip data x between 0 and 1\n    \"\"\"\n    return np.fmax(np.fmin(x, 1), 0)\n    \ndef fact(x):\n    \"\"\"\n    Return the factors of an integer as a list.\n    Warning: This function is not a factorial!\n    \"\"\"\n    if x < 0 or type(x) is not int:\n        raise ValueError(\"input must be a positive integer\")\n    if x < 2:\n        return x    \n    f = []\n    i = 2\n    while True:\n        while x % i == 0:\n            f.append(i)\n            x \/= i\n        i += 1\n        if x == 1:\n            return f\n            \ndef moving_average(x, N):\n    assert len(x) > N\n    c = np.cumsum(x)\n    return (c[N:]-c[:-N])\/N\n\ndef butter_lowpass(cutOff, fs, order=5):\n    import scipy.signal\n    nyq = 0.5 * fs\n    normalCutoff = cutOff \/ nyq\n    b, a = scipy.signal.butter(order, normalCutoff, btype='low', analog=True)\n    return b, a\n\ndef butter_lowpass_filter(data, cutOff, fs, order=4):\n    import scipy.signal\n    b, a = butter_lowpass(cutOff, fs, order=order)\n    y = scipy.signal.lfilter(b, a, data)\n    return y\n\ndef Gauss(x, x0, s, amp=None, **kargs):\n    if 'A' in kargs:\n        from warnings import warn\n        warn(\"Parameter A is deprecated. Please use amp in order to set the amplitude!\")\n        amp = kargs.pop('A')\n    elif 'Amp' in kargs:\n        from warnings import warn\n        warn(\"Parameter Amp is deprecated. Please use amp in order to set the amplitude!\")\n        amp = kargs.pop('Amp')\n    R = np.exp(-(x-x0)**2\/(2*s**2))\n    if amp is None:\n        R \/= (s*np.sqrt(2*np.pi))\n    else:\n        R *= amp\n    R[s==0] = (x[s==0]==x0)*1.0\n    return R\n\ndef Lorentz(x, x0, gamma, amp=None, **kargs):\n    if 'A' in kargs:\n        from warnings import warn\n        warn(\"Parameter A is deprecated. Please use amp in order to set the amplitude!\")\n        Amp = kargs['A']\n    elif 'Amp' in kargs:\n        from warnings import warn\n        warn(\"Parameter Amp is deprecated. Please use amp in order to set the amplitude!\")\n        amp = kargs.pop('Amp')\n    R = 1\/((x-x0)**2+(.5*gamma)**2)\n    if amp is None:\n        return .5*gamma*R\/np.pi\n    return amp*R*(.5*gamma)**2\n\ndef CDF(x,mu,sig, amp=1, lg=0, **kargs):\n    if 'Amp' in kargs:\n        from warnings import warn\n        warn(\"Parameter Amp is deprecated. Please use amp in order to set the amplitude!\")\n        amp = kargs.pop('Amp')\n    from scipy.special import erf\n    g = sig*np.sqrt(2*np.log(2))\n    return amp*lg*(.5+np.arctan2(x-mu,g)\/np.pi)+(1-lg)*amp*.5*(1+erf((x-mu)\/(sig*np.sqrt(2))))\n    \ndef LG(x, x0, sig=None, amp=None, lg=.5, asym=1, FWHM=None, **kargs):\n    if 'Amp' in kargs:\n        from warnings import warn\n        warn(\"Parameter Amp is deprecated. Please use amp in order to set the amplitude!\")\n        amp = kargs.pop('Amp')\n        \n    assert sig is not None or FWHM is not None\n      \n    if FWHM is None:\n        FWHM = 2*np.sqrt(2*np.log(2))*sig\n    if sig is None:\n        sig = FWHM\/(2*np.sqrt(2*np.log(2)))\n    Y = (1-lg)*Gauss(x,x0,sig,amp=amp)+lg*Lorentz(x,x0,FWHM,amp=amp)\n    if asym!=1:\n        Yr = (1-lg)*Gauss(x, x0, sig*asym, amp=amp)+lg*Lorentz(x, x0, FWHM*asym, amp=amp)\n        Y[x>x0] = Yr[x>x0]\n    return Y\n\ndef logistic(x, lower=0, upper=1, growth=1, x0=0, nu=1, C=1):\n    return lower+(upper-lower)\/(C+np.exp(-growth*(x-x0)))**(1\/nu)    \n    \ndef fitCDF1line(A):\n    line = np.zeros(A.shape[1])\n    for x in range(A.shape[1]):\n        popt, pcov = opt.curve_fit(CDF,\n            np.arange(A.shape[0]),\n            A[:,x],\n            (A.shape[0]\/2, 1, np.max(A[:,x])),\n            bounds=(0,(A.shape[1],np.inf,np.inf))\n            )\n        line[x] = popt[0]\n    return line\n\ndef FT(x, ufunc=np.real, real=False):\n    \"\"\"\n    shortcut for 1D\/2D Fourier Transform (real and centered)\n    \"\"\"\n    assert isinstance(x, np.ndarray)\n    if len(x.shape) == 1:\n        if real:\n            F = np.fft.rfft(x)\n        else:\n            F = np.fft.fft(x)\n    elif len(x.shape) == 2:\n        if real:\n            F = np.fft.rfft2(x)\n        else:\n            F = np.fft.fft2(x)\n    else:\n        raise TypeError(\"The array should be 1D or 2D\")\n    return ufunc(np.fft.fftshift(F))\n    \ndef binning(data, N=2, axis=0, ufunc=np.sum):\n    w = int(np.floor(data.shape[axis]\/N))\n    r = np.copy(data)\n    size = list(data.shape)\n    size[axis] = w\n    size = size[:axis+1]+[N]+size[axis+1:]\n    r.resize(size)\n    return ufunc(r, axis=axis+1)\n    \ndef stat_info(data):\n    import matplotlib.pyplot as plt\n    D = np.ravel(data)\n    U = np.unique(D)\n    if len(U)>1:\n        sep = np.min(U[1:]-U[:-1])\n        N = min(100, int(np.ceil((np.max(D)-np.min(D))\/sep)))\n    else:\n        N = 1\n    \n    mean = np.mean(D)\n    std = np.std(D)\n    \n    fig, ax = plt.subplots(2,1,figsize=(21,4))\n    ax[0].boxplot(D, 0, 'ro', 0);\n    ax[1].hist(D, N, density=True);\n    ax[1].axvline(mean, color='r', label='mean')\n    ax[1].axvline(mean+std, color='r', linestyle='--', label='1$\\\\sigma$')\n    ax[1].axvline(mean-std, color='r', linestyle='--', label='1$\\\\sigma$')\n    if mean-2*std >= U[0]:\n        ax[1].axvline(mean-2*std, color='r', linestyle=':', label='2$\\\\sigma$')\n    if mean+2*std <= U[-1]:\n        ax[1].axvline(mean+2*std, color='r', linestyle=':', label='2$\\\\sigma$')\n    ax[1].legend();\n    print(\"Stats\")\n    print(\"\\tAverage:\", mean)\n    print(\"\\tStandard-deviation:\", std)\n    print(\"\\tMinimum:\", np.min(D))\n    print(\"\\tQ1:\", np.percentile(D, 25))\n    print(\"\\tMedian:\", np.percentile(D, 50))\n    print(\"\\tQ3:\", np.percentile(D, 75))\n    print(\"\\tMaximum:\", np.max(D))\n\ndef ellipse(a,b,phi):\n    \"\"\"\n    return the x,y coordinates of an ellipse with major axis=a and minor axis=b at angle phi(radians)\n    \"\"\"\n    r = np.zeros(phi.shape) # if a & b is zero, result is zero\n    m = np.logical_and(a!=0,b!=0)\n    r[m] = a*b\/np.sqrt((b*np.cos(phi[m]))**2+(a*np.sin(phi[m]))**2)\n    return r\n    \ndef asymm_ellipse(left, right, upper, lower, phi):\n    phi = np.divmod(phi+2*np.pi,2*np.pi)[1] # Be sure phi ∈ [0,2π]\n    b = np.where(phi<=np.pi, upper, lower)\n    a = np.where(np.logical_or(phi<=np.pi\/2, phi>=3*np.pi\/2), right, left)\n    m = np.logical_and(a!=0,b!=0)\n    r = np.zeros(phi.shape) # if a & b is zero, result is zero\n    r[m] = a[m]*b[m]\/np.sqrt((b[m]*np.cos(phi[m]))**2+(a[m]*np.sin(phi[m]))**2)\n    return r\n\ndef LG2D(XY, amplitude=1, angle=0, sig_x=10, sig_y=10, x0=None, y0=None, LG_x=0, LG_y=0, assym_x=1, assym_y=1, bg=0):\n    \"\"\"\n    Return a 2D Lorentz-Gauss.\n    XY: (X,Y) tuple\n    A: amplitude\n    a: angle\n    sx: sigma for x-axis\n    sy: sigma fdor y-axis\n    x0,y0 : center coordinates of the peak\n    lgx, lgy: Lorentz-Gauss proportion (for x,y axis)\n    assym_x, assym_y: The assymetry in sig_x\/sig_y for the left\/right or upper\/lower part of the curve\n    \"\"\"\n    if x0 is None:\n        x0 = XY[0][0,XY[0].shape[1]\/\/2]\n    if y0 is None:\n        y0 = XY[1][XY[1].shape[0]\/\/2,0]\n    X1 = (XY[0]-x0)*np.cos(angle) - (XY[1]-y0)*np.sin(angle)\n    Y1 = (XY[0]-x0)*np.sin(angle) + (XY[1]-y0)*np.cos(angle)\n    \n    R1 = np.sqrt(X1**2+Y1**2)\n    angle = np.arctan2(Y1,X1)\n    sig = asymm_ellipse(sig_x, sig_x*assym_x, sig_y, sig_y*assym_y, angle)\n    gamma = np.sqrt(2*np.log(2))*sig\n    LG = ellipse(LG_x+1, LG_y+1, angle)-1\n    \n    Gxy = Gauss(R1, 0, sig, 1)\n    Lxy = 1\/((R1\/gamma)**2+1)\n    \n    f = (1-LG)*Gxy+LG*Lxy\n    out = bg+amplitude*f\n    return out\n    \ndef LG2Da(XY, amplitude=1, angle=0, sigN=10, sigS=None, sigE=10, sigW=None, x0=None, y0=None, LGN=0, LGS=None, LGE=0, LGW=None, bg=0):\n    if x0 is None:\n        x0 = XY[0][0,XY[0].shape[1]\/\/2]\n    if y0 is None:\n        y0 = XY[1][XY[1].shape[0]\/\/2,0]\n    if sigS is None:\n        sigS = sigN\n    if sigW is None:\n        sigW = sigE\n    if LGS is None:\n        LGS = LGN\n    if LGW is None:\n        LGW = LGE\n        \n    X1 = (XY[0]-x0)*np.cos(angle) - (XY[1]-y0)*np.sin(angle)\n    Y1 = (XY[0]-x0)*np.sin(angle) + (XY[1]-y0)*np.cos(angle)\n    \n    R1 = np.sqrt(X1**2+Y1**2)\n    angle = np.arctan2(Y1, X1)\n    sig = asymm_ellipse(sigW, sigE, sigN, sigS, angle)\n    gamma = np.sqrt(2*np.log(2))*sig # HFHM\n    LG = asymm_ellipse(LGW+1, LGE+1, LGN+1, LGS+1, angle)-1\n    \n    Gxy = Gauss(R1, 0, sig, 1)\n    Lxy = 1\/((R1\/gamma)**2+1)\n    \n    f = (1-LG)*Gxy+LG*Lxy\n    out = bg+amplitude*f\n    return out\n\ndef MaxwellBoltzmann(E, T):\n    from . import constants as const\n    return 2*const.qe*np.sqrt(E\/np.pi)*np.exp(-E\/(const.kb*T))\/(const.kb*T)**1.5\n    \ndef Voigt(x, x0, sig, gamma, A=1):\n    import scipy\n    L = Lorentz(x, x0, gamma, A=1)\n    G = Gauss(x, x0, sig)\n    out = scipy.signal.convolve(L, G, 'same')\n    out \/= np.max(out)\n    return A*out\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_189","text":"<reponame>AhmetCanSolak\/aydin\nimport math\nimport time\nfrom random import randrange\nfrom typing import Optional, Callable\n\nimport numpy\nfrom numba import jit, prange, vectorize, float32\nfrom numpy import absolute\nfrom numpy.typing import ArrayLike\nfrom scipy.ndimage import sobel, gaussian_filter\n\nfrom aydin.util.edge_filter.fast_edge_filter import fast_edge_filter\nfrom aydin.util.log.log import lprint, lsection\n\n\ndef representative_crop(\n    image: ArrayLike,\n    mode: str = 'contrast',\n    crop_size: Optional[int] = None,\n    min_length: int = 32,\n    smoothing_sigma: int = 0.5,\n    equal_sides: bool = False,\n    favour_odd_lengths: bool = False,\n    search_mode: str = 'random',\n    granularity_factor: int = 4,\n    random_search_mode_num_crops: int = 1512,\n    min_num_crops: int = 512,\n    timeout_in_seconds: float = 2,\n    return_slice: bool = False,\n    display_crop: bool = False,\n    std_fun: Callable = None,  # numpy.std\n):\n    \"\"\"Extract a representative crop from the image. Searches for the crop of given\n    (approximate) size with highest score. The score is simply the sum of sobel\n    magnitudes (~tenengrad) which is a good metric for estimating how much interesting\n    content each crop contains. Empirically, this highly correlates with where\n    I (<NAME>) tend to look at in images.\n\n\n    Parameters\n    ----------\n    image : ArrayLike\n        Image to extract representative crop from\n\n    mode : str\n        Metric for picking crop. Can be : 'contrast' (fastest), 'sobel', 'sobelmin',\n        'sobelmax' We recommend 'contrast'.\n\n    crop_size : int\n        Crop size in voxels. Default (None) is 32000.\n\n    min_length : int\n        Crop axis lengths cannot be smaller than this number.\n\n    smoothing_sigma : int\n        Sigma value for Gaussian filter smoothing to achieve some crude denoising and thus\n        make it a bit easier to estimate the score per crop.\n\n    equal_sides : bool\n        When True the crop will have all its sides of equal size (square, cube, ...)\n\n    favour_odd_lengths : bool\n        If possible favours crops that have odd shape lengths.\n\n    search_mode: bool\n        Search mode for best crops. Can be 'random' or 'systematic'. In\n        random mode we pick random crops, in systematic mode we check every\n        possible strided crop.\n\n    granularity_factor: int\n        Granularity of search. higher values correspond to more overlap between candidate crops.\n\n    random_search_mode_num_crops: int\n        Number of crops to check in 'random' search mode.\n\n    min_num_crops : int\n        Min number of crops to examine.\n\n    timeout_in_seconds: float\n        Maximum amount of time in seconds that this function should run for.\n        This avoids excessive computation for very large images.\n\n    return_slice : bool\n        If True the slice is returned too:\n\n    display_crop: bool\n        Displays crop, for debugging purposes...\n\n    Returns\n    -------\n    Most representative crop, and if return_slice is True the actual slice object too.\n\n    \"\"\"\n\n    # Debug:\n    # _fast_std.parallel_diagnostics(level=4)\n\n    # Std function:\n    if std_fun is None:\n        std_fun = _fast_std\n\n    # Compile numba functions:\n    # _fast_std(numpy.ones(100, dtype=numpy.float32))\n    # _normalise(numpy.ones(100, dtype=numpy.float32))\n\n    # Start time:\n    start_time = time.time()\n\n    with lsection(\n        f\"Cropping image of size: {image.shape} with at most {crop_size} voxels and mode {mode}\"\n    ):\n\n        # save reference to original image:\n        original_image = image\n\n        with lsection(\"Cast and normalise image...\"):\n            # Cast, if needed:\n            image = image.astype(numpy.float32, copy=False)\n            # Normalise:\n            # image = _normalise(image)\n\n        # Apply filter:\n        with lsection(f\"Apply cropping filter to image of shape: {image.shape}\"):\n\n            # Smoothing:\n            sigma = tuple(\n                (smoothing_sigma if s > min_length else 0 for s in image.shape)\n            )\n            image = gaussian_filter(image, sigma=sigma)\n\n            if mode == 'contrast':\n                pass\n            elif mode == 'sobelfast':\n                image = _sobel_fast(image)\n            elif mode == 'sobel':\n                image = _sobel_magnitude(image)\n            elif mode == 'sobelmin':\n                image = _sobel_minimum(image)\n            elif mode == 'sobelmax':\n                image = _sobel_maximum(image)\n            else:\n                raise ValueError(f\"Unknown mode: {mode}\")\n        #\n        # import napari\n        # with napari.gui_qt():\n        #     viewer = napari.Viewer()\n        #     viewer.add_image(image, name='image')\n        #     viewer.add_image(filtered_image, name='filtered_image')\n\n        # To speed up cropping we apply a divide and conquer to 'pre-crop' the image recusively:\n        # if precropping:\n        #     image = _precrop(image,\n        #                      crop_size=crop_size,\n        #                      min_length=min_length,\n        #                      mode=mode,\n        #                      smoothing_size=smoothing_size)\n\n        # Number of voxels in image:\n        num_voxels = image.size\n\n        # Default number of voxels:\n        if crop_size is None:\n            crop_size = 32000\n\n        # Ratio by which to crop to achieve max num voxels:\n        ratio = (crop_size \/ num_voxels) ** (1 \/ image.ndim)\n\n        if ratio >= 1:\n            # If the image is small enough no point in getting a crop!\n            if return_slice:\n                return image, (slice(None),) * image.ndim\n            else:\n                return image\n\n        # cropped shape:\n        cropped_shape = tuple(\n            min(max(min_length, int(s * ratio)), s) for s in image.shape\n        )\n\n        # If the crop size is still too big, we adjust that. This happens because\n        # we cannot crop dimensions that are too small, leading to an\n        # underestimation of the ratio.\n        for tries in range(8):\n            # First let's figure out the current crop size:\n            current_crop_size = math.prod(cropped_shape)\n\n            # we check if it is ok, or too large:\n            if current_crop_size < 1.05 * crop_size:\n                # we are ok if the crop size is within 5% of the desired size.\n                break\n\n            # If too large we compute the ratio by which to adjust it:\n            ratio = (crop_size \/ current_crop_size) ** (1 \/ image.ndim)\n\n            # we compute a new crop shape:\n            cropped_shape = tuple(\n                min(max(min_length, int(s * ratio)), s) for s in cropped_shape\n            )\n\n        # Favour odd lengths if requested:\n        if favour_odd_lengths:\n            cropped_shape = tuple((s \/\/ 2) * 2 + 1 for s in cropped_shape)\n\n        # We enforce equal sides if requested:\n        if equal_sides:\n            min_length = min(cropped_shape)\n            cropped_shape = tuple((min_length,) * image.ndim)\n\n        # range for translation:\n        translation_range = tuple(s - cs for s, cs in zip(image.shape, cropped_shape))\n\n        # We loop through a number of crops and keep the one wit the best score:\n        best_score = -1\n        best_slice = None\n        best_crop = None\n\n        # Instead of searching for all possible crops, we take into\n        # account the size of the crops to define a 'granularity' (\n        # stride) of the translations used for search:\n\n        granularity = tuple(cs \/\/ granularity_factor for cs in cropped_shape)\n\n        if search_mode == 'random':\n\n            # We make sure that the number of crops is not too large given\n            # the relative size of the crop versus whole image:\n            random_search_mode_num_crops = min(\n                random_search_mode_num_crops,\n                (granularity_factor**image.ndim) * int(image.size \/ crop_size),\n            )\n\n            for i in range(random_search_mode_num_crops):\n\n                # translation:\n                translation = tuple(\n                    (randrange(0, max(1, (s - cs) \/\/ g)) * g if cs != s else 0)\n                    for s, cs, g in zip(image.shape, cropped_shape, granularity)\n                )\n\n                # function to get crop slice:\n                def _crop_slice(translation, cropped_shape, downscale: int = 1):\n                    return tuple(\n                        slice(t, t + s, downscale)\n                        for t, s in zip(translation, cropped_shape)\n                    )\n\n                # slice object for cropping:\n                crop_slice = _crop_slice(\n                    translation, cropped_shape, 2 if image.size > 1e8 else 1\n                )\n\n                # extract crop:\n                crop = image[crop_slice]\n\n                score = std_fun(crop)\n\n                # slice object for the actual crop:\n                crop_slice = _crop_slice(translation, cropped_shape, 1)\n\n                # update best score and image:\n                if score > best_score and not math.isinf(score):\n                    best_score = score\n                    best_slice = crop_slice\n\n                    # We make sure to have the full and original crop!\n                    best_crop = original_image[best_slice]\n\n                if i >= min_num_crops and time.time() > start_time + timeout_in_seconds:\n                    lprint(\n                        f\"Interrupting crop search because of timeout after {i} crops examined!\"\n                    )\n                    break\n\n        elif search_mode == 'systematic':\n\n            # grid for translations:\n            translation_indices = tuple(\n                max(1, int(granularity_factor * r \/ cs))\n                for r, cs in zip(translation_range, cropped_shape)\n            )\n\n            for i, index in enumerate(numpy.ndindex(translation_indices)):\n\n                # print(\n                #     f\"i={i}, index={index}, translation_indices={translation_indices}\"\n                # )\n\n                # translation:\n                translation = tuple(\n                    int(j * cs \/ granularity_factor)\n                    for j, cs in zip(index, cropped_shape)\n                )\n\n                # slice object for cropping:\n                crop_slice = tuple(\n                    slice(t, t + s) for t, s in zip(translation, cropped_shape)\n                )\n\n                # extract crop:\n                crop = image[crop_slice]\n\n                score = std_fun(crop)\n\n                # update best score and image:\n                if score > best_score and not math.isinf(score):\n                    best_score = score\n                    best_slice = crop_slice\n\n                    # We make sure to have the full and original crop!\n                    best_crop = original_image[best_slice]\n\n                if i >= min_num_crops and time.time() > start_time + timeout_in_seconds:\n                    lprint(\n                        f\"Interrupting crop search because of timeout after {i} crops examined!\"\n                    )\n                    break\n        else:\n            raise ValueError(f\"Unsupported search mode: {search_mode}\")\n\n        if display_crop:\n\n            import napari\n\n            viewer = napari.Viewer()\n            viewer.add_image(image.squeeze(), name='image')\n            viewer.add_image(best_crop.squeeze(), name='best_crop')\n            napari.run()\n\n        #     print(_fast_std.signatures)\n        #     for sig in _fast_std.signatures:\n        #         print(_fast_std.inspect_asm(sig))`\n\n        if return_slice:\n            return best_crop, best_slice\n        else:\n            return best_crop\n\n\ndef _sobel_magnitude(image):\n    magnitude = numpy.zeros_like(image)\n    for axis in range(image.ndim):\n        if image.shape[axis] < 32:\n            continue\n        magnitude += sobel(image, axis=axis) ** 2\n    return numpy.sqrt(magnitude)\n\n\ndef _sobel_minimum(image):\n    minimum = None\n    for axis in range(image.ndim):\n        if image.shape[axis] < 32:\n            continue\n        sobel_image = absolute(sobel(image, axis=axis))\n        if minimum is None:\n            minimum = sobel_image\n        else:\n            minimum = numpy.minimum(minimum, sobel_image)\n    if minimum is None:\n        return image\n    else:\n        return minimum\n\n\ndef _sobel_maximum(image):\n    maximum = None\n    for axis in range(image.ndim):\n        if image.shape[axis] < 32:\n            continue\n        sobel_image = absolute(fast_edge_filter(image, axis=axis))\n        if maximum is None:\n            maximum = sobel_image\n        else:\n            maximum = numpy.maximum(maximum, sobel_image)\n    if maximum is None:\n        return image\n    else:\n        return maximum\n\n\ndef _sobel_fast(image):\n\n    longest_axis = max(image.shape)\n    axis = image.shape.index(longest_axis)\n\n    return absolute(fast_edge_filter(image, axis=axis))\n\n\n@jit(nopython=True, parallel=True, fastmath=True)\ndef _normalise(image):\n\n    # Normalise:\n    image_min = float32(image.min())\n    image_max = float32(image.max())\n    if image_max - image_min > 0:\n        return _rescale(image, image_min, image_max)\n    else:\n        return image - image_min\n\n\n@vectorize([float32(float32, float32, float32)])\ndef _rescale(x, min_value, max_value):\n    return (x - min_value) \/ (max_value - min_value)\n\n\n@jit(nopython=True, parallel=True, fastmath=True)\ndef _fast_std(image: ArrayLike, workers=16, decimation=1):\n\n    array = image.ravel()\n    length = array.size\n    num_chunks = workers\n    chunk_length = (length \/\/ num_chunks) + num_chunks\n\n    std = 0.0\n\n    for c in prange(num_chunks):\n\n        start = c * chunk_length\n        stop = (c + 1) * chunk_length\n        if stop >= length:\n            stop = length\n\n        sub_array = array[start:stop:decimation]\n        chunk_std = numpy.std(sub_array)\n        std = max(std, chunk_std)\n\n    return std\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_464","text":"<reponame>maartenbreddels\/mab<filename>mab\/gd\/jeans\/jeansmodel2.py\nfrom numpy import *\nimport numpy\nimport mab.gd.logging as logging\nimport mab.parallelize\nfrom scipy import special\nimport pickle\nimport mab.utils.numpy\nimport os\nimport sys\nfrom kaplot import *\n\nstore_cache = True\nlogger = logging.getLogger(\"gd.jeans.jeansmodel\")\n\ndef h3(x):\n\treturn x**3-3*x\n\ndef h4(x):\n\treturn x**4-6*x**2+3\ndef h6(x):\n\treturn x**6-15*x**4+45*x**2-15\n\nfac3 = 1*2*3\nfac4 = fac3*4\nfac6 = fac3 * 4 * 5 * 6\n\n\ndef makeresize(parameterset, i, j):\n\treturn (parameterset.ranges_org[i][0], parameterset.ranges_org[j][0]), (parameterset.ranges_org[i][1], parameterset.ranges_org[j][1])\n\nclass JeansModel(object):\n\tdef __init__(self, modelpath, modelsetname, parameterset, projection_matrix, observation, use_fourth_moment=False, vmean=0, filters=[], postfix=\"\"):\n\t\tself.modelpath = modelpath\n\t\tself.parameterset = parameterset\n\t\tself.projection_matrix = projection_matrix\n\t\tself.observation = observation\n\t\tself.schwsetname = modelsetname #\"biased_10k_jeans2\"\n\t\tself.vmean = vmean\n\t\tself.postfix = postfix\n\t\tself.filters  = filters\n\t\t\n\t\tu1=-3.\n\t\tu2=3.\n\t\tlength=250\n\t\tself.u = (arange(length)+0.5)\/(length+0.) * (u2-u1) + u1\n\t\tself.r = 10**self.u\n\t\tself.du = (u2-u1)\/length\n\t\t\n\t\tself.dimension = self.parameterset.dimension\n\t\t\n\t\t#self.schwsetname = \"biased_jeans2\"\n\t\tself.dirname = os.path.join(self.modelpath, \"jeans\", self.schwsetname)\n\t\t\n\t\t#self.probability_range = parameterset.ranges_org \n\t\t#self.labels = parameterset.paramnames\n\t\t#self.paramlabels = parameterset.paramlabels\n\t\t\n\t\tself.use_m4 = use_fourth_moment\n\t\t\n\t\tself.modelcache = {}\n\t\tresultdir = os.path.join(self.dirname, \"results\")\n\t\tif self.use_m4:\n\t\t\tself.modelcachefilename = os.path.join(resultdir, \"modelcache_m4_d%d%s_mod.pickle\" % (self.parameterset.dimension, self.postfix))\n\t\telse:\n\t\t\tself.modelcachefilename = os.path.join(resultdir, \"modelcache_d%d%s.pickle\" % (self.parameterset.dimension, self.postfix))\n\t\t\n\t\tself.init()\n\tdef save(self, iteration=0):\n\t\tresultdir = os.path.join(self.dirname, \"results\")\n\t\tlogger.info(\"ensuring directory exists: %s\" % resultdir)\n\t\tif not os.path.exists(resultdir):\n\t\t\tos.makedirs(resultdir)\n\t\t\n\t\tfilename = os.path.join(resultdir, \"probability_grid_d%d%s%03d.npy\" % (self.parameterset.dimension, self.postfix, iteration))\n\t\tlogger.info(\"storing probability grid: %s\" % filename)\n\t\tnumpy.save(filename, self.probability_grid)\n\t\tif store_cache:\n\t\t\tlogger.info(\"storing modelcache: %s\" % self.modelcachefilename)\n\t\t\tfp = open(self.modelcachefilename, \"wb\")\n\t\t\tpickle.dump(self.modelcache, fp)\n\t\t\tfp.close()\n\t\t\n\t\tfilename = os.path.join(resultdir, \"parameter_points_d%d%s%03d.npy\" % (self.parameterset.dimension, self.postfix, iteration))\n\t\tlogger.info(\"storing parameter_points: %s\" % filename)\n\t\tnumpy.save(filename, self.parameter_points)\n\t\t\n\t\t#numpy.save(filename, self.modelcache)\n\t\t\n#self.paramvalues\t\t\n\t\t\n\t\treturn\n\t\t\n\t\tfilename = os.path.join(resultdir, \"anisotropy_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"storing anisotropy grid: %s\" % filename)\n\t\tnumpy.save(filename, self.anisotropy_grid)\n\t\t\n\t\tfilename = os.path.join(resultdir, \"mass_enclosed_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"storing mass_enclosed grid: %s\" % filename)\n\t\tnumpy.save(filename, self.mass_enclosed_grid)\n\t\n\t\tfilename = os.path.join(resultdir, \"logslope_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"storing logslope grid: %s\" % filename)\n\t\tnumpy.save(filename, self.logslope_grid)\n\t\t\n\tdef load(self, iteration=0):\n\t\tresultdir = os.path.join(self.dirname, \"results\")\n\t\t\n\t\t#filename = os.path.join(resultdir, \"probability_grid_%03d.npy\" % iteration)\n\t\tfilename = os.path.join(resultdir, \"probability_grid_d%d%s%03d.npy\" % (self.parameterset.dimension, self.postfix, iteration))\n\t\tlogger.info(\"loading probability grid: %s\" % filename)\n\t\tself.probability_grid = numpy.load(filename)\n\t\t\n\t\tif os.path.exists(self.modelcachefilename):\n\t\t\tlogger.info(\"loading modelcache: %s\" % self.modelcachefilename)\n\t\t\t#self.modelcache = numpy.load(filename)\n\t\t\tfp = open(self.modelcachefilename, \"rb\")\n\t\t\tself.modelcache = pickle.load(fp)\n\t\t\tfp.close()\n\t\t\n\t\t#filename = os.path.join(resultdir, \"parameter_points_%03d.npy\" % iteration)\n\t\tfilename = os.path.join(resultdir, \"parameter_points_d%d%s%03d.npy\" % (self.parameterset.dimension, self.postfix, iteration))\n\t\tlogger.info(\"loading parameter_points: %s\" % filename)\n\t\tself.parameter_points = numpy.load(filename)\n\t\t\n\t\treturn\n\t\t\n\t\tfilename = os.path.join(resultdir, \"anisotropy_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"loading anisotropy grid: %s\" % filename)\n\t\tself.anisotropy_grid = numpy.load(filename)\n\t\t\n\t\tfilename = os.path.join(resultdir, \"mass_enclosed_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"loading mass_enclosed grid: %s\" % filename)\n\t\tself.mass_enclosed_grid = numpy.load(filename)\n\t\t\n\t\tfilename = os.path.join(resultdir, \"logslope_grid_%03d.npy\" % iteration)\n\t\tlogger.info(\"loading logslope grid: %s\" % filename)\n\t\tself.logslope_grid = numpy.load(filename)\t\t\n\t\n\tdef _collect(self, iteration=0, cores=4):\n\t\tw = 80\n\t\t\n\t\tself.parameter_points = transpose(array(self.parameterset.points))\n\t\t\n\t\t#mab.gd.gdfast.ProfilerStart(\"sparse\")\n\t\tself.probability_grid = mab.utils.numpy.mmapzeros((w,) * self.parameterset.dimension)\n\t\tmake_linear = False\n\t\tif make_linear:\n\t\t\tself.parameterset.make_linear()\n\t\tif self.parameterset.dimension == 1:\n\t\t\tfor i in range(w):\n\t\t\t\tx1, x2 = self.parameterset.ranges_org[0]\n\t\t\t\tx = x1 + (x2-x1) * i \/ (w-1.) \n\t\t\t\tself.probability_grid[i] = self.parameterset((x)) \n\t\tif self.parameterset.dimension == 2:\n\t\t\tfor i in range(w):\n\t\t\t\tx1, x2 = self.parameterset.ranges_org[0]\n\t\t\t\tx = x1 + (x2-x1) * i \/ (w-1.) \n\t\t\t\tfor j in range(w):\n\t\t\t\t\ty1, y2 = self.parameterset.ranges_org[1]\n\t\t\t\t\ty = y1 + (y2-y1) * j \/ (w-1.)\n\t\t\t\t\t#print self.parameterset((x, y))\n\t\t\t\t\tself.probability_grid[i,j] = self.parameterset((x, y)) \n\t\tif self.parameterset.dimension == 3:\n\t\t\tx1, x2 = 0., 1.#self.parameterset.ranges_org[0]\n\t\t\ty1, y2 = 0., 1.#self.parameterset.ranges_org[1]\n\t\t\tz1, z2 = 0., 1.#self.parameterset.ranges_org[2]\n\t\t\tlogger.info(\"interpolating grid\")\n\t\t\t@mab.parallelize.parallelize(cores=cores, info=info)\n\t\t\tdef do(i):\n\t\t\t\tx = x1 + (x2-x1) * i \/ (w-1.) \n\t\t\t\tfor j in range(w):\n\t\t\t\t\ty = y1 + (y2-y1) * j \/ (w-1.)\n\t\t\t\t\tfor k in range(w):\n\t\t\t\t\t\tz = z1 + (z2-z1) * k \/ (w-1.)\n\t\t\t\t\t\tself.probability_grid[i,j,k] = self.parameterset.eval_normalized((x, y, z))\n\t\t\txindices = range(w)\n\t\t\tdo(xindices)\n\t\tif self.parameterset.dimension == 4:\n\t\t\tx1, x2 = self.parameterset.ranges_org[0]\n\t\t\ty1, y2 = self.parameterset.ranges_org[1]\n\t\t\tz1, z2 = self.parameterset.ranges_org[2]\n\t\t\tv1, v2 = self.parameterset.ranges_org[3]\n\t\t\tlogger.info(\"interpolating grid\")\n\t\t\t#info = False\n\t\t\t@mab.parallelize.parallelize(cores=cores, info=info)\n\t\t\tdef do(ij):\n\t\t\t\t\ti = ij%w\n\t\t\t\t\tj = ij\/w\n\t\t\t\t\tx = x1 + (x2-x1) * i \/ (w-1.) \n\t\t\t\t\ty = y1 + (y2-y1) * j \/ (w-1.)\n\t\t\t\t\tfor k in range(w):\n\t\t\t\t\t\tz = z1 + (z2-z1) * k \/ (w-1.)\n\t\t\t\t\t\tfor l in range(w):\n\t\t\t\t\t\t\tv = v1 + (v2-v1) * l \/ (w-1.)\n\t\t\t\t\t\t\t#print (x, y, z, v), self.parameterset((x, y, z, v)) \n\t\t\t\t\t\t\tself.probability_grid[i,j,k,l] = self.parameterset((x, y, z, v))\n\t\t\txindices = range(w**2)\n\t\t\tdo(xindices)\n\t\tif self.parameterset.dimension == 5:\n\t\t\tx1, x2 = self.parameterset.ranges_org[0]\n\t\t\ty1, y2 = self.parameterset.ranges_org[1]\n\t\t\tz1, z2 = self.parameterset.ranges_org[2]\n\t\t\ta1, a2 = self.parameterset.ranges_org[3]\n\t\t\tb1, b2 = self.parameterset.ranges_org[4]\n\t\t\tlogger.info(\"interpolating grid\")\n\t\t\t#info = False\n\t\t\t@mab.parallelize.parallelize(cores=cores, info=info)\n\t\t\tdef do(ijk):\n\t\t\t\t\ti = ijk%w\n\t\t\t\t\tj = (ijk\/w)%w\n\t\t\t\t\tk = (ijk\/w)\/w\n\t\t\t\t\tx = x1 + (x2-x1) * i \/ (w-1.) \n\t\t\t\t\ty = y1 + (y2-y1) * j \/ (w-1.)\n\t\t\t\t\tz = z1 + (z2-z1) * k \/ (w-1.)\n\t\t\t\t\tfor l in range(w):\n\t\t\t\t\t\ta = a1 + (a2-a1) * l \/ (w-1.)\n\t\t\t\t\t\tfor m in range(w):\n\t\t\t\t\t\t\tb = b1 + (b2-b1) * m \/ (w-1.)\n\t\t\t\t\t\t\t#print (x, y, z, v), self.parameterset((x, y, z, v)) \n\t\t\t\t\t\t\tself.probability_grid[i,j,k,l,m] = self.parameterset((x, y, z, a, b))\n\t\t\txindices = range(w**3)\n\t\t\tdo(xindices)\n\t\t#mab.gd.gdfast.ProfilerStop()\n\t\tif not make_linear:\n\t\t\t#print self.probability_grid \n\t\t\tself.probability_grid -= self.probability_grid.max()\n\t\t\t#print self.probability_grid \n\t\t\tself.probability_grid = exp(self.probability_grid)\n\t\t\tmask = numpy.isnan(self.probability_grid)\n\t\t\tself.probability_grid[mask] = 0 \n\t\t\t#print self.probability_grid \n\t\t\n\tdef init(self, iteration=0):\n\t\tself.parameterset.init()\n\t\t#self.parameterset.load(iteration=iteration)\n\t\tself.projection_matrix.load()\n\t\tself.observation.load()\n\t\tself.aperture = self.projection_matrix.gridR\n\t\t\n\t\tself.M = self.projection_matrix.matrices\n\t\t\n\t\t#print self.Mr.shape\n\t\t#print self.projection_matrix.gridR.radial_surface_densities.shape\n\t\t\n\t\tlight_model = self.projection_matrix.light_model\n\t\tself.R = R = light_model.arcsec_to_kpc(self.projection_matrix.gridR.aperture_rcenters)\n\t\tdR = light_model.arcsec_to_kpc(self.projection_matrix.gridR.aperture_rcenters[1] - self.projection_matrix.gridR.aperture_rcenters[0])\n\t\t\n\t\ttotal_mass = light_model.total_mass()\n\t\tself.massr = light_model.densityr(self.r)\/total_mass * self.r**3 * 4 * pi * log(10) * self.du\n\t\t#massR = tensordot(self.Ms, self.massr, axes=[(1,), (0,)])\n\t\tself.massR = (2*pi*R*dR)*light_model.densityR(R,M=1.)\n\t\tprint \"sum\", sum(self.massr)\n\t\t\n\t\tfor i in range(self.M.shape[0]):\n\t\t\tself.M[i] = (self.M[i].T \/self.massR).T\n\t\t\tself.M[i] = (self.M[i] *self.massr)\n\t\t\n\t\tself.Ms = self.M[0]\n\t\tself.Mr = self.M[0] - self.M[1]\n\t\tself.Mt = self.M[1]\n\t\t#self.Mr = (self.Mr.T \/self.massR).T\n\t\t#self.Mt = (self.Mt.T \/self.massR).T\n\t\t#self.Mr = (self.Mr *self.massr)\n\t\t#self.Mt = (self.Mt *self.massr)\n\t\t\n\t\tstars = self.observation.stars\n\t\tfor filter in self.filters:\n\t\t\tstars = filter(stars)\n\t\t\n\t\tlogger.info(\"using %d stars\/observations\" % len(stars))\n\t\t#stars_inrange = stars.filter(lambda star: self.storage_2d.aperture.inrange(star.xi, star.eta))\n\t\t#print stars\n\t\tstars_inrange = []\n\t\tfor i in range(len(stars)):\n\t\t\tstar = stars[i]\n\t\t\t#print star\n\t\t\tif self.aperture.inrange(stars.xi[i], stars.eta[i]):\n\t\t\t\tstars_inrange.append(star)\n\t\tuse_numpy = not isinstance(stars, mab.cvsfile.CsvObject)\n\t\tif use_numpy:\n\t\t\tstars_inrange = array(stars_inrange, dtype=stars.dtype).view(recarray)\n\t\telse:\n\t\t\tstars_inrange = mab.cvsfile.CsvObject(stars_inrange)\n\t\t#import pdb;pdb.set_trace()\n\t\tlogger.info(\"stars in aperture range     : %d\" % len(stars_inrange))\n\t\tlogger.info(\"stars outside aperture range: %d\" % (len(stars)-len(stars_inrange)))\n\t\tstars = stars_inrange\n\t\taperture_indices = []\n\t\tfor i in range(len(stars)):\n\t\t\taperture_indices.append(self.aperture.aperture.findindex(stars.xi[i], stars.eta[i]))\n\t\tself.aperture_indices = array(aperture_indices)\n\t\t#print self.aperture_indices\n\t\t\t\n\t\treal_data = True #False\n\t\tif not real_data:\n\t\t\tsigma_v = 2.01\n\t\t\tnumpy.random.seed(8)\n\t\t\tfor i in range(len(stars)):\n\t\t\t\tstars.vlos[i] = stars.vlos_true[i] + numpy.random.normal(0, sigma_v)\n\t\t\t\t#star.v_index = int(((star.vlos+vmax)\/(2*vmax)) * self.storage_2d.Nv);\n\t\t\t\t#outlier = True\n\t\t\t\t#for losvd in losvds:\n\t\t\t\t#\tif losvd[star.v_index, star.aperture_index] != 0:\n\t\t\t\t#\t\toutlier = False\n\t\t\t\t#\t\tbreak\n\t\t\t\t#star.is_outlier = outlier\n\t\t\t\t\n\t\t\t\t#print star.aperture_index\n\t\t\t#indices = array([star.aperture_index for star in stars])\n\t\tself.vlos = stars.vlos - self.vmean #array([star.vlos for star in stars])\n\t\tself.vlos_sigma = stars.e_vlos #array([star.e_vlos for star in stars])\n\t\tprint self.aperture_indices.min(), self.aperture_indices.max()\n\t\t#print self.storage_2d.aperture\n\t\t#moment0 = self.storage_2d.aperture.radial_surface_densities\n\t\t#moment0 = self.aperture.radial_surface_densities\n\t\t#print vlos_sigma\n\t\t#print indices[argsort(indices)]\n\t\t#print stars.rc[argsort(indices)]\n\t\t\n\t\tif os.path.exists(self.modelcachefilename):\n\t\t\tlogger.info(\"loading modelcache: %s\" % self.modelcachefilename)\n\t\t\tfp = open(self.modelcachefilename, \"rb\")\n\t\t\tself.modelcache = pickle.load(fp)\n\t\t\tfp.close()\n\t\t\t#self.modelcache = numpy.load(filename)\n\t\t\tlogger.info(\"model cache contains %d models\" % len(self.modelcache))\n\t\t\n\t\t\t\t\n\t\t\n\tdef test(self, init, scope):\n\t\tself.scope = scope\n\t\tmozaic(2,1,box)\n\t\t\n\t\tscope.flush()\n\t\tscope.init()\n\t\tscope[\"dm_density_twoslope.rs\"] = 0.5\n\t\tscope[\"dm_density_twoslope.alpha\"] = 1\n\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\tjeans = scope[\"jeans\"]\n\t\tself.drawsigmar(jeans, color=\"black\")\n\t\t\n\t\tscope.flush()\n\t\tscope.init()\n\t\tscope[\"dm_density_twoslope.rs\"] = 10**-0.85\n\t\tscope[\"dm_density_twoslope.alpha\"] = -0.56\n\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\tjeans = scope[\"jeans\"]\n\t\tself.drawsigmar(jeans, color=\"green\", linestyle=\"dot\")\n\t\t\n\t\tscope.flush()\n\t\tscope.init()\n\t\tscope[\"dm_density_twoslope.rs\"] = 10**-0.57\n\t\tscope[\"dm_density_twoslope.alpha\"] = 0.37\n\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\tjeans = scope[\"jeans\"]\n\t\tself.drawsigmar(jeans, color=\"red\", linestyle=\"dash\")\n\t\t\n\t\tscope.flush()\n\t\tscope.init()\n\t\tscope[\"dm_density_twoslope.rs\"] = 10**-0.392\n\t\tscope[\"dm_density_twoslope.alpha\"] = 0.860\n\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\tjeans = scope[\"jeans\"]\n\t\tself.drawsigmar(jeans, color=\"blue\", linestyle=\"dot\")\n\t\t\n\t\tselect(0, 0)\n\t\tylim(0, 15)\n\t\tselect(1, 0)\n\t\tylim(0, 15)\n\t\tdraw()\n\t\t\t\n\tdef drawsigmar(self, jeans, **kwargs):\n\t\tm2 = array([jeans.m2(k) for k in self.r])\n\t\tsigmar = sqrt(m2)\n\t\tbeta = jeans.beta\n\t\tm2_los = tensordot(self.M[0]-beta*self.M[1], m2, axes=[(1,), (0,)])\n\t\tsigma_los = m2_los**0.5\n\t\tselect(0, 0)\n\t\tgraph(self.u, sigmar, **kwargs)\n\t\tselect(1, 0)\n\t\tgraph(self.R, sigma_los, **kwargs)\n\n\tdef run(self, args, opts, scope, info=True):\n\t\tself.scope = scope\n\t\tcores=opts.cores\n\t\t#if 1:\n\t\tlogm = 7.91\n\t\tif 0:\n\t\t\tscope.flush()\n\t\t\tscope.init()\n\t\t\tlogprior = 0\n\t\t\tparamnames = ['dm_density_twoslope.rs', 'dm_density_twoslope.alpha']#, 'jeans.beta']\n\t\t\tvalues = [10**-0.5, 0.54, -0.5]\n\t\t\tvalues = [3.16227766017, -0.25]\n\n\t\t\tfor name, value in zip(paramnames, values):\n\t\t\t\tscope[name] = value\n\t\t\t#logprior = log(paramvalue.p_prior)\n\t\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\t\tjeans = scope[\"jeans\"]\n\t\t\tprint self.run_one(0, test=True)\n\t\t\tsys.exit(0)\n\t\t\t#print \"beta = \", jeans.beta \n\t\t\tbeta = jeans.beta\n\t\t\tlogr = arange(-2, 2, 0.1)\n\t\t\tr = 10**logr\n\t\t\tm2 = numpy.array([jeans.m2(k) for k in r])\n\t\t\tm4 = numpy.array([jeans.m4(k) for k in r])\n\t\t\tgamma = m4\/m2**2\n\t\t\tgraph(logr, gamma)\n\t\t\tdraw()\n\t\t\tsys.exit(0)\n\t\t\t\n\t\tif 0:\n\t\t\tif 1:\n\t\t\t\ti = 0\n\t\t\t\tlogm += 0.01\n\t\t\t\tlogrs = -0.4796\n\t\t\t\tself.parameterset.paramvalues[i].values_org = list(self.parameterset.paramvalues[i].values_org)\n\t\t\t\tself.parameterset.paramvalues[i].values_trans = list(self.parameterset.paramvalues[i].values_trans)\n\t\t\t\tself.parameterset.paramvalues[i].values_org[0] = logm\n\t\t\t\tself.parameterset.paramvalues[i].values_trans[0] = 10**logm\n\t\t\t\tself.parameterset.paramvalues[i].values_org[1] = logrs\n\t\t\t\tself.parameterset.paramvalues[i].values_trans[1] = 10**logrs\n\t\t\t\tprint self.run_one(0)\n\t\t\t\tlogrs = -0.4795\n\t\t\t\tself.parameterset.paramvalues[i].values_org = list(self.parameterset.paramvalues[i].values_org)\n\t\t\t\tself.parameterset.paramvalues[i].values_trans = list(self.parameterset.paramvalues[i].values_trans)\n\t\t\t\tself.parameterset.paramvalues[i].values_org[0] = logm\n\t\t\t\tself.parameterset.paramvalues[i].values_trans[0] = 10**logm\n\t\t\t\tself.parameterset.paramvalues[i].values_org[1] = logrs\n\t\t\t\tself.parameterset.paramvalues[i].values_trans[1] = 10**logrs\n\t\t\t\tprint self.run_one(0)\n\t\t\t\tsys.exit(0)\n\t\t\twhile 1:\n\t\t\t\tlogm += 0.01\n\t\t\t\tprint \"run, logm=\", logm\n\t\t\t\tif 0:\n\t\t\t\t\tfor i, p in enumerate(self.parameterset.paramvalues):\n\t\t\t\t\t\tv = p.values_org\n\t\t\t\t\t\tif (v[0] >= 7.97) and (v[0] < 7.98) and (v[1] > -0.52) and (v[1] < -0.25):\n\t\t\t\t\t\t\tprint p.modelname, v\n\t\t\t\t\t\t\tprint self.modelcache[p.modelname]\n\t\t\t\t\n\t\t\t\t#logrss = arange(-0.5, -0.45, 0.01\/10)\n\t\t\t\t#logrss = arange(-0.55, -0.45, 0.01\/100)\n\t\t\t\tlogrss = arange(-0.4798, -0.4794, 0.01\/1000)\n\t\t\t\t#logrss = arange(-0.5, 0.0, 0.01\/4)\n\t\t\t\tlogps = []\n\t\t\t\tfor i, logrs in enumerate(logrss):\n\t\t\t\t\t#logm = 8.0 #7.9749999999999996\n\t\t\t\t\tself.parameterset.paramvalues[i].values_org = list(self.parameterset.paramvalues[i].values_org)\n\t\t\t\t\tself.parameterset.paramvalues[i].values_trans = list(self.parameterset.paramvalues[i].values_trans)\n\t\t\t\t\tself.parameterset.paramvalues[i].values_org[0] = logm\n\t\t\t\t\tself.parameterset.paramvalues[i].values_trans[0] = 10**logm\n\t\t\t\t\tself.parameterset.paramvalues[i].values_org[1] = logrs\n\t\t\t\t\tself.parameterset.paramvalues[i].values_trans[1] = 10**logrs\n\t\t\t\t@mab.parallelize.parallelize(cores=cores, info=info)\n\t\t\t\tdef wrap(index):\n\t\t\t\t\treturn self.run_one(index)\n\t\t\t\tlogps = wrap(range(len(logrss)))\n\t\t\t\tprint logps\n\t\t\t\t#logp = self.run_one(0)\n\t\t\t\t#print logrs, logp\n\t\t\t\t#\tlogps.append(logps)\n\t\t\t\tlogps = array(logps)\n\t\t\t\tlogps -= logps.max()\n\t\t\t\tps = exp(logps)\n\t\t\t\tclear()\n\t\t\t\tbox()\n\t\t\t\tgraph(logrss, ps)\n\t\t\t\tdraw()\n\t\t\t\t\t\n\t\t\t\t\n\t\t\tsys.exit(0)\n\t\tdef do():\n\t\t\tself.parameterset.valuemap = {}\n\t\t\tall_indices = range(len(self.parameterset.parameter_values))\n\t\t\t# skip cached models\n\t\t\tknown_indices = [i for i in all_indices if self.parameterset.parameter_values[i].name in self.modelcache]\n\t\t\tunknown_indices = [i for i in all_indices if self.parameterset.parameter_values[i].name not in self.modelcache]\n\t\t\tif 0:\n\t\t\t\tself.run_one(0)\n\t\t\telse:\n\t\t\t\t@mab.parallelize.parallelize(cores=cores, info=info)\n\t\t\t\tdef wrap(index):\n\t\t\t\t\treturn self.run_one(index)\n\t\t\t\tif cores == 1:\n\t\t\t\t\tfor i in unknown_indices:\n\t\t\t\t\t\tprint i\n\t\t\t\t\t\tprint self.run_one(i)\n\t\t\t\telse:\n\t\t\t\t\tlogps_solved = wrap(unknown_indices)\n\t\t\t\t\tlogps_solved = array(logps_solved)\n\t\t\t\t\tlogps = zeros(len(all_indices))\n\t\t\t\t\tlogps[unknown_indices] = logps_solved\n\t\t\t\t\tlogps[known_indices] = [self.modelcache[self.parameterset.parameter_values[i].name] for i in known_indices]\n\t\t\t\t\tfor i in unknown_indices:\n\t\t\t\t\t\tself.modelcache[self.parameterset.parameter_values[i].name] = logps[i]\n\t\t\t\t\tfor i in range(len(self.parameterset.parameter_values)):\n\t\t\t\t\t\tparametervalue = self.parameterset.parameter_values[i]\n\t\t\t\t\t\tself.parameterset.valuemap[tuple(parametervalue.values)] = logps[i]\n\t\t\t\t\tfilename = os.path.join(self.modelpath, \"logps.npy\")\n\t\t\t\t\tsave(filename, logps)\n\t\t\t\t\tresultdir = os.path.join(self.dirname, \"results\")\n\t\t\t\t\tif store_cache:\n\t\t\t\t\t\tdirname = os.path.dirname(self.modelcachefilename)\n\t\t\t\t\t\tif not os.path.exists(dirname):\n\t\t\t\t\t\t\tos.makedirs(dirname)\n\t\t\t\t\t\tlogger.info(\"storing modelcache: %s (%d models)\" % (self.modelcachefilename, len(self.modelcache)))\n\t\t\t\t\t\tfp = open(self.modelcachefilename, \"wb\")\n\t\t\t\t\t\tpickle.dump(self.modelcache, fp)\n\t\t\t\t\t\tfp.close()\n\t\t\t\t\t\n\t\t\t\t\tprint \"logps\", logps\n\t\t\t\t#self.parameterset.feed(logps)\n\t\t\t\n\t\t#print self.parameterset.paramnames\n\t\tdo()\n\t\tif 0:\n\t\t\tfor i in range(self.parameterset.max_iterations):\n\t\t\t\t#print \"iterate\"\n\t\t\t\tlogger.info(\"iteration %d (out of %i)\" % (i+1,self.parameterset.max_iterations)) \n\t\t\t\tself.parameterset.iterate(i,cores=cores)\n\t\t\t\tdo()\n\t\t\t\t#self.parameterset.refresh()\n\t\t\n\t\t\n\t\tself.parameterset.grid()\n\t\t#self._collect(iteration=0, cores=cores)\n\t\t\n\tdef run_one(self, index, test=False):\n\t\tscope = self.scope\n\t\tif not test:\n\t\t\t#paramnames = self.parameterset.parameter_values\n\t\t\tparamvalues = self.parameterset.parameter_values[index]\n\t\t\t#paramprior = self.parameterset.parampriors\n\t\t\t#values = paramvalue.values\n\t\t\tscope.flush()\n\t\t\tscope.re_readfiles()\n\t\t\tscope.init()\n\t\t\tlogprior = 0\n\t\t\t#for name, value in zip(paramnames, values):\n\t\t\t#for paramvalues in self.parameterset.parameter_values[index]\n\t\t\tfor name, value in paramvalues.items:\n\t\t\t\t#paramvalues.name, paramvalues.value\n\t\t\t\t#print name, value\n\t\t\t\tscope[name] = value\n\t\t\tlogprior = log(paramvalues.p_prior)\n\t\t\t#scope[\"jeans.beta\"] = -0.5 \n\t\tjeans = scope[\"jeans\"]\n\t\t#print \"beta = \", jeans.beta \n\t\tbeta = jeans.beta(self.r)\n\t\t\n\t\t#jeans = jeans.fast()\n\t\t#sigmar = jeans.sigmar(self.r)\n\t\t#print jeans.m2(280.0)\n\t\t#print [(k,jeans.m2(k)) for k in self.r]\n\t\t#dsa\n\t\t\n\t\tsigmar = array([jeans.m2(k)**0.5 for k in self.r])\n\t\t#if any(isnan(sigmar)):\n\t\tsigmar[isnan(sigmar)] = 0\n\t\t#if any(isnan(sigmar)):\n\t\t#\timport pdb;\n\t\t#\tpdb.set_trace()\n\t\t#print sigmar\n\t\t#g = 1 - 2 * self.beta * R**2\/r**2 + self.beta*(1+self.beta)\/2*R**4\/r**4\n\t\t\n\t\tuse_m4 = self.use_m4\n\t\tif use_m4:\n\t\t\tm4 = array([jeans.m4(k) for k in self.r])\n\t\t\tkappa4 = m4##\/ sigmar**4\n\t\t\n\n\t\t\n\t\tvarr = sigmar**2# * self.massr\n\t\tvart =(1-beta)*varr\n\t\t\n\t\t\n\t\tvarr_los = tensordot(self.Mr, varr, axes=[(1,), (0,)])\n\t\tvart_los = tensordot(self.Mt, vart, axes=[(1,), (0,)])\n\t\t#light_model = jeans.light_model\n\t\t#varR_los = (varr_los + vart_los)\n\t\tm2 = sigmar**2\n\t\tm2_los = tensordot(self.M[0]-beta*self.M[1], m2, axes=[(1,), (0,)])\n\t\tif use_m4:\n\t\t\t#g = 1 - 2 * self.beta * R**2\/r**2 + self.beta*(1+self.beta)\/2*R**4\/r**4\n\t\t\tm4_los = tensordot(self.M[0]-2*beta*self.M[1]+beta*(1+beta)\/2*self.M[3], m4, axes=[(1,), (0,)])\n\t\t# m2*(1-beta*\n\t\tvarR_los = m2_los\n\t\tm2_los = varR_los[self.aperture_indices] + self.vlos_sigma**2\n\t\tif use_m4:\n\t\t\tm4_los = m4_los[self.aperture_indices] + 3*self.vlos_sigma**4\n\t\t\tkappa4 = m4_los\n\t\tsigma_los = sqrt(m2_los)\n\t\t#print sigma_los\n\t\t#print sigmasqs\n\t\t#print sigmasqs.shape\n\t\tlogps = sum(- self.vlos**2\/(2*m2_los) - log(sqrt(m2_los*2*pi)))\n\t\tif use_m4:\n\t\t\tu = (kappa4\/sigma_los**4-3)\n\t\t\tg = m4_los\/sigma_los**4\n\t\t\t\n\t\t\tif 0:\n\t\t\t\ta1, a2, a3, b1, b2,b3 = [-0.10971413, -0.03265063,  0.02697869,  -0.52812814, -0.05336269, -0.0592689] # unnormalized\n\t\t\t\tgamma = g\n\t\t\t\tmask = gamma < 3\n\t\t\t\t#print \"%e\" % gamma\n\t\t\t\tsigma = sigma_los\n\t\t\t\tsigma_mod = sigma * 1.0\n\t\t\t\tsigma_mod[mask] = sigma[mask] * (1 + (3-gamma[mask])**2*a1 + (3-gamma[mask])**3*a2 + (3-gamma[mask])**4*a3)\n\t\t\t\tkappa2 = sigma**2\n\t\t\t\tkappa4 = gamma * kappa2**2\n\t\t\t\tkappa4_mod = kappa4 * 1.\n\t\t\t\tkappa4_mod[mask] = kappa4[mask] * (1 + (3-gamma[mask])**2*b1 + (3-gamma[mask])**3*b2 + (3-gamma[mask])**4*b3)\n\t\t\t\tgamma_mod = gamma * 1.\n\t\t\t\tgamma_mod[mask] = kappa4_mod[mask]\/kappa2[mask]**2\n\t\t\t\tu = gamma_mod * 1.-3\n\t\t\t\tsigma_los = sigma_mod\n\t\t\t\n\t\t\t#kappa4 = kappa4_mod\n\t\t\t#print list(g)\n\t\t\t#print \n\t\t\t#print g.min(), g.max(), mean(g)\n\t\t\t#u = minimum(u, 2)\n\t\t\t#u = maximum(u, -1)\n\t\t\t#u = maximum(u, -0.25)\n\t\t\t#u = minimum(u, 0.25)\n\t\t\tkappa4 = (u+3)*sigma_los**4\n\t\t\ts4 = (kappa4 - 3 * sigma_los**4)\/sigma_los**6\n\t\t\tb1 = 0 #self.sigma*(1.\/fac3 * self.s3 * h3(x\/self.sigma))\n\t\t\tb2 = sigma_los**2 * (1.\/fac4 * s4 * h4(self.vlos\/sigma_los))\n\t\t\t#print list(g)\n\t\t\t#print b2.min(), b2.max(), mean(b2)\n\t\t\textra = b2\n\t\t\t#mask = (1+b2)>0\n\t\t\tmask = u > 0.\n\t\t\tmask = b2 > 0.\n\t\t\tz = b2\n\t\t\tz[mask] = log(1+b2[mask])\n\t\t\t\n\t\t\tif 0:\n\t\t\t\tu = (kappa4\/sigma_los**4-3)\n\t\t\t\t#print b2[mask].max(), u.min(), u.max()\n\t\t\t\tassert numpy.all(1+b2[mask]) > 0, zip(b2[mask], u[mask], s4[mask])\n\t\t\t\toldb2 = b2 * 1 \n\t\t\t\tb2[mask] = log(1+b2[mask])\n\t\t\t\t#print b2.min(), b2.max(), mean(b2)\n\t\t\t\tnans = numpy.isnan(b2)\n\t\t\t\tif isnan(sum(b2)) and not test:\n\t\t\t\t\tfor name, value in zip(paramnames, values):\n\t\t\t\t\t\tprint name, value\n\t\t\t\t\t\n\t\t\t\t#assert not isnan(sum(b2)), zip(b2[nans], oldb2[nans], u[nans], s4[nans], (self.vlos\/sigma_los)[nans], self.vlos[nans], sigma_los[nans])\n\t\t\t\tprint logps, sum(b2)\n\t\t\telse:\n\t\t\t\tassert not isnan(sum(z)), zip(b2[nans], oldb2[nans], u[nans], s4[nans], (self.vlos\/sigma_los)[nans], self.vlos[nans], sigma_los[nans])\n\t\t\tr = logps + sum(z)\n\t\t\timport pdb;\n\t\t\t#pdb.set_trace()\n\t\t\treturn r + logprior\n\t\telse:\n\t\t\treturn logps + logprior\n\n\t\t\t\t\n\t\t\n\t\tif 0:\n\t\t\tfrom kaplot import *\n\t\t\tbox()\n\t\t\tgraph(sqrt(varR_los))\n\t\t\tsigmar = jeans.sigma_los(self.R)\n\t\t\tgraph(sigmar, color=\"green\")\n\t\t\tdraw()\n\t\tif 0:\n\t\t\tR = light_model.arcsec_to_kpc(self.projection_matrix.gridR.aperture_rcenters)\n\t\t\tdR = light_model.arcsec_to_kpc(self.projection_matrix.gridR.aperture_rcenters[1] - self.projection_matrix.gridR.aperture_rcenters[0])\n\t\t\tvarR_los = (varr_los + vart_los)#\/self.massR # \/(2*pi*R*dR)*(jeans.light_model.densityR(R)\/1e6)#massR*(2*pi*R*dR)# * 10\n\t\t\tmozaic(2,2,box)\n\t\t\tarea = 1 #R \/ jeans.light_model.densityR(R,M=1.) # * self.projection_matrix.gridR.radial_surface_densities# \/ 100\n\t\t\tsigmar = jeans.sigma_los(R)\n\t\t\tgraph(sigmar, color=\"green\")\n\t\t\tgraph(sqrt(varR_los*area))\n\t\t\tprint sigmar.shape, varR_los.shape\n\t\t\tgraph(sigmar**2\/(varR_los*area), color=\"red\")\n\t\t\tselect(0,1)\n\t\t\tgraph(self.u, jeans.light_model.densityr(self.r))\n\t\t\tselect(1,1)\n\t\t\tgraph(self.projection_matrix.gridR.radial_surface_densities)\n\t\t\tselect(1,0)\n\t\t\tgraph(self.massR\/(2*pi*R*dR), color=\"red\")\n\t\t\t\n\t\t\tgraph(jeans.light_model.densityR(R)\/1e6, color=\"green\", linestyle=\"dot\")\n\t\t\tdraw()\n\t\t#print u\n\t\t\n\t"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_465","text":"<gh_stars>0\nimport numpy\nfrom pylab import *\nfrom scipy.interpolate import interp1d\n\nd1,e1,ee1,f1,ef1=numpy.loadtxt(\"full.txt\",unpack=True)\nf1=-f1*31.6e-15\ninds=argsort(d1)\nd1=d1[inds]\nf1=f1[inds]\n\nd2,e2,ee2,f2,ef2=numpy.loadtxt(\"PEC.txt\",unpack=True)\nf2=-f2*31.6e-15\ninds=argsort(d2)\nd2=d2[inds]\nf2=f2[inds]\n\nd3,e3,ee3,f3,ef3=numpy.loadtxt(\"temp.txt\",unpack=True)\nf3=-f3*31.6e-15\ninds=argsort(d3)\nd3=d3[inds]\nf3=f3[inds]\n\ndatafile=\"..\/..\/Mathematica\/calculated_vals.tsv\"\ndist,fpfa,fnaive,fright,ftemp=numpy.loadtxt(datafile,unpack=True)\ndist=dist*1e6\n\nPFA_datafile=\"..\/..\/Mathematica\/calculated_pfa_vals.tsv\"\ndist2,fpfa2,fnaive2,fright2,ftemp2=numpy.loadtxt(PFA_datafile,unpack=True)\ndist2=dist2*1e6\n\nplot(d2,f2,label=\"PEC\")\nplot(d1,f1,label=\"SiO2\/Au\")\nplot(d3,f3,label=\"PEC T=300\")\n\nplot(dist,fpfa,label=\"PFA\",linestyle='dashed')\nplot(dist,fright,label=\"SiO2\/Au\",linestyle='dashed')\nplot(dist,ftemp,label=\"SiO2\/Au T=300\",linestyle='dashed')\nxscale('log')\nyscale('log')\nxlabel('Distance (microns)')\nylabel('Force (N)')\ntitle('Analytical (Dashed) v Numerical (Solid) Calculations')\nlegend()\nshow()\n#savefig('analytic_v_numerical')\n\nclf()\niPFA = interp1d(dist,fpfa)\nrPFA=iPFA(d2)\/f2\niPFA2 = interp1d(dist2,fpfa2)\nrPFA2=iPFA2(d2)\/f2\nplot(d2,rPFA,label=\"Gradient Expansion PFA\")\nplot(d2,rPFA2,label=\"Normal PFA\")\nxscale('log')\nyscale('log')\nxlabel('Distance (Microns)')\nylabel('(PFA\/BEM) Force Ratio')\ntitle('Comparion between Calculations, grid=1 micron')\nlegend()\nsavefig(\"pfa_v_pec.png\")\n\nclf()\ntag,xi,e,f=numpy.loadtxt(\"mesh_byXi.txt\",unpack=True)\nf=-f*31.6e-15\nxis=numpy.unique(xi)\nfor ix in range(0,len(xis)):\n    inds = numpy.where(xi == xis[ix])\n    xplot=tag[inds]\n    yplot=f[inds]\n    plot(xplot,yplot,label=str(xis[ix]))\n    \nxscale('log')\nyscale('log')\nxlim(0.5,5.0)\nlegend(title='Int. Frequency',loc='lower left')\nxlabel('Mesh length scale (microns)')\nylabel('Force Integrand Value')\ntitle('Convergence Tests @ 1 micron')\nsavefig('convergence.png')\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_466","text":"<reponame>kjanjua26\/CHIPathy<filename>generatedata\/aug.py<gh_stars>1-10\n\"\"\"\nAugment the images in the directory and generate multiple images from that \\\n    to increase the numnber of available data.\n\"\"\"\nimport cv2\nimport imgaug.augmenters as iaa\nimport matplotlib.pyplot as plt\nfrom scipy import ndimage\nimport numpy as np\nimport argparse\nfrom glob import glob\nfrom tqdm import tqdm\n\nparser = argparse.ArgumentParser(description=\"Augment the images in the directory and generate multiple images.\", \n                                formatter_class=argparse.RawTextHelpFormatter)\nparser.add_argument('--src', '-s', type=str, required=True,\n                    help='The source directory containing the images.')\nparser.add_argument('--dst', '-d', type=str, required=True,\n                    help='The destination directory to save the images.')\nparser.add_argument('--techniques', '-t', type=str,\n                    help='The techniques to apply to augment the images.\\nBy default all the techniques will be applied.')\nargs = parser.parse_args()\n\nclass Augment:\n    def __init__(self):\n        self.input_dir = args.src\n        self.output_dir = args.dst\n        self.techniques = args.techniques\n        self.zoom_factors = [1.15, 1.25, 1.35, 1.45, 1.50, 1.60, 1.70, 1.80, 1.90]\n        self.severity = [1, 2, 3, 4, 5]\n        self.count = 0\n\n        if self.techniques is not None:\n            print(f'The augmentations to apply are: {[x for x in self.techniques]}')\n        else:\n            print(\"Applying all the augmentations.\")\n        \n\n    def crop_image_from_gray(self, img, tol=10):\n        dims = img.ndim\n\n        if dims == 3:\n            gray_image = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n        elif dims == 2:\n            gray_image = img\n\n        mask = gray_image > tol\n\n        # find start crop point\n        objs = ndimage.find_objects(mask)\n        height_offset = objs[0][0].start\n        width_offset = objs[0][1].start\n        ix = np.ix_(mask.any(1),mask.any(0))\n\n        if dims == 2:\n            return img[ix], height_offset, width_offset\n        \n        check_shape = img[:,:,0][ix].shape[0]\n        if (check_shape == 0): # image is too dark so that we crop out everything,\n            return img, 0, 0 # return original image\n\n        img1 = img[:,:,0][ix]\n        img2 = img[:,:,1][ix]\n        img3 = img[:,:,2][ix]\n        img = np.stack([img1, img2, img3],axis=-1)\n\n        return img, height_offset, width_offset\n    \n    def circle_crop(self, img, sigmaX=50):   \n        \"\"\"\n        Create circular crop around image centre    \n        \"\"\"\n        img, height_offset, width_offset = self.crop_image_from_gray(img)\n        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n\n        img = cv2.addWeighted(img,4, cv2.GaussianBlur(img, (0,0), sigmaX), -4, 128)\n\n        return img, height_offset, width_offset\n    \n    def flip_image(self, img, mode='h'):\n        \"\"\"\n        Flips the image horizontally or vertically depending on the mode.\n        \"\"\"\n\n        if mode == 'h':\n            aug = iaa.Fliplr()\n        else:\n            aug = iaa.Flipud()\n            \n        flipped_img = aug(image=img)\n        return flipped_img\n    \n    def compression_blur(self, img, severity):\n        \"\"\"\n        Blur in an image caused due to the JPEG compression.\n        \"\"\"\n        aug = iaa.imgcorruptlike.JpegCompression(severity=severity)\n        return aug(image=img)\n    \n    def cv2_clipped_zoom(self, img, zoom_factor):\n        \"\"\"\n        Center zoom in\/out of the given image and returning an enlarged\/shrinked view of \n        the image without changing dimensions\n        Args:\n            img : Image array\n            zoom_factor : amount of zoom as a ratio (0 to Inf)\n\n        Ftn Taken From: https:\/\/stackoverflow.com\/a\/48097478\/6735773\n        \"\"\"\n        height, width = img.shape[:2] # It's also the final desired shape\n        new_height, new_width = int(height * zoom_factor), int(width * zoom_factor)\n\n        ### Crop only the part that will remain in the result (more efficient)\n        # Centered bbox of the final desired size in resized (larger\/smaller) image coordinates\n        y1, x1 = max(0, new_height - height) \/\/ 2, max(0, new_width - width) \/\/ 2\n        y2, x2 = y1 + height, x1 + width\n        bbox = np.array([y1,x1,y2,x2])\n        # Map back to original image coordinates\n        bbox = (bbox \/ zoom_factor).astype(np.int)\n        y1, x1, y2, x2 = bbox\n        cropped_img = img[y1:y2, x1:x2]\n\n        # Handle padding when downscaling\n        resize_height, resize_width = min(new_height, height), min(new_width, width)\n        pad_height1, pad_width1 = (height - resize_height) \/\/ 2, (width - resize_width) \/\/2\n        pad_height2, pad_width2 = (height - resize_height) - pad_height1, (width - resize_width) - pad_width1\n        pad_spec = [(pad_height1, pad_height2), (pad_width1, pad_width2)] + [(0,0)] * (img.ndim - 2)\n\n        result = cv2.resize(cropped_img, (resize_width, resize_height))\n        result = np.pad(result, pad_spec, mode='constant')\n        assert result.shape[0] == height and result.shape[1] == width\n        return result\n    \n    def main(self):\n        \"\"\"\n        The main caller function of the augmentation file.\n        \"\"\"\n\n        exts = glob(self.input_dir + \"*.jpeg\") + glob(self.input_dir + \"*.png\") + \\\n                glob(self.input_dir + \"*.jpg\") + glob(self.input_dir + \"*.tif\")\n        list_of_images = [x for x in exts]\n        list_of_transformed_images = []\n\n        for i, img_path in enumerate(list_of_images):\n            print(f\"Processing {i}\/{len(list_of_images)}\")\n            img = cv2.imread(img_path)\n            \n            print(\"Applying the base transformation: CropnBlur.\")\n            img_t, height_offset, width_offset = self.circle_crop(img, 50)\n            list_of_transformed_images.append(img_t)\n            \n            print(\"Applying the horizontal\/vertical flips.\")\n            img_t_fliplr = self.flip_image(img_t)\n            list_of_transformed_images.append(img_t_fliplr)\n\n            img_t_flipud = self.flip_image(img_t, mode='v')\n            list_of_transformed_images.append(img_t_flipud)\n            \n            print(\"Applying zoom transformation.\")\n            for zoom_factor in self.zoom_factors:\n                zoomed_img = self.cv2_clipped_zoom(img_t, zoom_factor)\n                list_of_transformed_images.append(zoomed_img)\n            \n            print(\"Applying JPEG compression blur.\")\n            for sev in self.severity:\n                compressed_img_t = self.compression_blur(img_t, sev)\n                compressed_img_fliplr = self.compression_blur(img_t_fliplr, sev)\n                compressed_img_flipud = self.compression_blur(img_t_flipud, sev)\n\n                list_of_transformed_images.append(compressed_img_t)\n                list_of_transformed_images.append(compressed_img_fliplr)\n                list_of_transformed_images.append(compressed_img_flipud)\n\n        for transformed_img in tqdm(list_of_transformed_images):\n            self.count += 1\n            transformed_img = cv2.cvtColor(transformed_img, cv2.COLOR_BGR2RGB)\n            cv2.imwrite(self.output_dir + f\"{self.count}.jpg\", transformed_img)\n\nif __name__ == \"__main__\":\n    ag = Augment()\n    ag.main()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_468","text":"<reponame>sumau\/tick<gh_stars>100-1000\n# License: BSD 3 clause\n\nimport unittest\n\nimport numpy as np\nfrom scipy.sparse import csr_matrix\n\nfrom tick.linear_model import SimuLinReg\nfrom tick.base_model.tests.generalized_linear_model import TestGLM\nfrom tick.robust import ModelLinRegWithIntercepts\nfrom tick.simulation import weights_sparse_gauss\n\n\nclass Test(TestGLM):\n    def test_ModelLinRegWithInterceptsWithGlobalIntercept(self):\n        \"\"\"...Numerical consistency check of loss and gradient for linear\n        regression with sample intercepts and a global intercept\n        \"\"\"\n        np.random.seed(12)\n        n_samples, n_features = 200, 5\n        w0 = np.random.randn(n_features)\n        intercept0 = 50 * weights_sparse_gauss(n_weights=n_samples, nnz=30)\n        c0 = None\n        X, y = SimuLinReg(w0, c0, n_samples=n_samples, verbose=False,\n                          seed=2038).simulate()\n        # Add gross outliers to the labels\n        y += intercept0\n        X_spars = csr_matrix(X)\n        model = ModelLinRegWithIntercepts(fit_intercept=False).fit(X, y)\n        model_spars = ModelLinRegWithIntercepts(fit_intercept=False) \\\n            .fit(X_spars, y)\n        self.run_test_for_glm(model, model_spars)\n        self._test_glm_intercept_vs_hardcoded_intercept(model)\n\n        self.assertAlmostEqual(model.get_lip_mean(), 6.324960325598532)\n        self.assertAlmostEqual(model.get_lip_max(), 30.277118951892113)\n        self.assertAlmostEqual(model.get_lip_mean(),\n                               model_spars.get_lip_mean())\n        self.assertAlmostEqual(model.get_lip_max(), model_spars.get_lip_max())\n        self.assertAlmostEqual(model.get_lip_best(), 2.7217793249045439)\n\n    def test_ModelLinRegWithInterceptsWithoutGlobalIntercept(self):\n        \"\"\"...Numerical consistency check of loss and gradient for linear\n        regression with sample intercepts and no global intercept\n        \"\"\"\n        np.random.seed(12)\n        n_samples, n_features = 200, 5\n        w0 = np.random.randn(n_features)\n        intercept0 = 50 * weights_sparse_gauss(n_weights=n_samples, nnz=30)\n        c0 = None\n        X, y = SimuLinReg(w0, c0, n_samples=n_samples, verbose=False,\n                          seed=2038).simulate()\n        # Add gross outliers to the labels\n        y += intercept0\n        X_spars = csr_matrix(X)\n        model = ModelLinRegWithIntercepts(fit_intercept=True).fit(X, y)\n        model_spars = ModelLinRegWithIntercepts(fit_intercept=True) \\\n            .fit(X_spars, y)\n        self.run_test_for_glm(model, model_spars)\n\n        self.assertAlmostEqual(model.get_lip_mean(), 7.324960325598536)\n        self.assertAlmostEqual(model.get_lip_max(), 31.277118951892113)\n        self.assertAlmostEqual(model.get_lip_mean(),\n                               model_spars.get_lip_mean())\n        self.assertAlmostEqual(model.get_lip_max(), model_spars.get_lip_max())\n        self.assertAlmostEqual(model.get_lip_best(), 2.7267793249045438)\n\n    def test_ModelLinRegWithInterceptsWithoutGlobalInterceptExtras(self):\n        \"\"\"...Extra tests for linear regression with sample intercepts and not\n        global intercept, check gradient wrt homemade gradient\n        \"\"\"\n        np.random.seed(12)\n        n_samples, n_features = 200, 5\n        w0 = np.random.randn(n_features)\n        intercept0 = 50 * weights_sparse_gauss(n_weights=n_samples, nnz=30)\n        c0 = None\n        X, y = SimuLinReg(w0, c0, n_samples=n_samples, verbose=False,\n                          seed=2038).simulate()\n        # Add gross outliers to the labels\n        y += intercept0\n        model = ModelLinRegWithIntercepts(fit_intercept=False).fit(X, y)\n        coeffs = np.random.randn(model.n_coeffs)\n        grad1 = model.grad(coeffs)\n        X2 = np.hstack((X, np.identity(n_samples)))\n        grad2 = X2.T.dot(X2.dot(coeffs) - y) \/ n_samples\n        np.testing.assert_almost_equal(grad1, grad2, decimal=10)\n\n    def test_ModelLinRegWithInterceptsWithGlobalInterceptExtras(self):\n        \"\"\"...Extra tests for linear regression with sample intercepts and\n        global intercept, check gradient wrt homemade gradient\n        \"\"\"\n        np.random.seed(12)\n        n_samples, n_features = 200, 5\n        w0 = np.random.randn(n_features)\n        intercept0 = 50 * weights_sparse_gauss(n_weights=n_samples, nnz=30)\n        c0 = -1.\n        X, y = SimuLinReg(w0, c0, n_samples=n_samples, verbose=False,\n                          seed=2038).simulate()\n        # Add gross outliers to the labels\n        y += intercept0\n        model = ModelLinRegWithIntercepts(fit_intercept=True).fit(X, y)\n        coeffs = np.random.randn(model.n_coeffs)\n        grad1 = model.grad(coeffs)\n        X2 = np.hstack((X, np.ones((n_samples, 1)), np.identity(n_samples)))\n        grad2 = X2.T.dot(X2.dot(coeffs) - y) \/ n_samples\n        np.testing.assert_almost_equal(grad1, grad2, decimal=10)\n\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_469","text":"<gh_stars>0\nimport os,sys,os.path,numpy as np,copy\nimport contratio as crat\nimport astropy.io.fits as pyfits\nimport scipy.ndimage as nd,matplotlib.pyplot as plt\nsys.path.append('\/Users\/awallace\/Documents\/pynrm\/')\nimport stats\nnameList = sys.argv[4:len(sys.argv)]\nif len(sys.argv)<4:\n    print('Useage: crat_all_images.py data_directory_location plot_directory num_cals_per_target object_name (with spaces)')\n    sys.exit()\n#Combine name into single string\nname = ''\nif len(nameList)>1:\n    for ii in range(0,len(nameList)):\n        name+=nameList[ii]\n        if ii<len(nameList)-1:\n            name+=' '\nelse:\n\tname = nameList[0]\n#Remove Spaces From Object Name\nobjNoSpaces = name.split(' ')\nobjName = ''.join(objNoSpaces)\nif sys.argv[1][0]=='\/':\n\tdataDir = sys.argv[1]\nelse:\n\tdataDir = os.getcwd()+'\/'+sys.argv[1]\nif sys.argv[2][0]=='\/':\n\tplotDir = sys.argv[2]\nelse:\n\tplotDir = os.getcwd()+'\/'+sys.argv[2]\n\t\nobjDir = plotDir+'\/'+objName\nif not os.path.isdir(objDir):\n\tos.makedirs(objDir)\noutfiles = []\n#cycle through all existing data files\nfor year in range(11,20):\n\tfor month in range(1,13):\n\t\tfor day in range(1,32):\n\t\t\tdirectory = '%02d'%(year,)+'%02d'%(month,)+'%02d'%(day,)\n\t\t\trawDir = dataDir+'\/'+directory\n\t\t\tcubeDir = rawDir+'_cubes'\n\t\t\tif not os.path.isfile(rawDir+'\/blockinfo.txt'):\n\t\t\t\tcontinue\n\t\t\tif not os.path.isdir(cubeDir):\n\t\t\t\tcontinue\n\t\t\tlineNums = []\n\t\t\tall_elements = []\n\t\t\telements = []\n\t\t\tcal_els = []\n\t\t\ttgt_cubes = []\n\t\t\tcal_cubes = []\n\t\t\ttotal = -1\n\t\t\tallDirs = []\n\t\t\tinfoFile = open(rawDir+'\/blockinfo.txt','r')\n\t\t\tmm = 0\n\t\t\tcount = 0\n\t\t\t#Only proceed if the given object was observed on this particular night\n\t\t\tfor line1 in infoFile:\n\t\t\t\tif name in line1:\n\t\t\t\t\tcount+=1\n\t\t\tif count<1:\n\t\t\t\tcontinue\n\t\t\tallDirs.append(rawDir)\n\t\t\tinfoFile = open(rawDir+'\/blockinfo.txt','r')\n\t\t\t#Find line and frame numbers where the name appears\n\t\t\tfor line in infoFile:\n\t\t\t\tmm+=1\n\t\t\t\tif mm==1:\n\t\t\t\t\tcontinue\n\t\t\t\ttotal+=1\n\t\t\t\tentry = line.split(' ')\n\t\t\t\tnewEntry = []\n\t\t\t\tfor nn in range(0,len(entry)):\n\t\t\t\t\tif not entry[nn]=='':\n\t\t\t\t\t\tnewEntry.append(entry[nn])\n\t\t\t\t#Find object name\n\t\t\t\tcubeFile = cubeDir+'\/cube'+str(int(entry[0]))+'.fits'\n\t\t\t\tif os.path.isfile(cubeFile) and pyfits.getheader(cubeFile)['OBJECT']==name:\n\t\t\t\t\telements.append([int(entry[0]),rawDir])\n\t\t\t\t\tlineNums.append([total,rawDir])\n\t\t\t\tall_elements.append([int(entry[0]),rawDir])\n\t\t\t#Create target cube list\n\t\t\tfor ii in range(0,len(elements)):\n\t\t\t\tcubeDir = elements[ii][1]+'_cubes'\n\t\t\t\ttgt_cubes.append(cubeDir+'\/cube'+str(elements[ii][0])+'.fits')\n\n\t\t\t#Find calibrators from objects nearby in the list.  Go one step in both directions and add frame to\n\t\t\t#list of calibrators.\n\t\t\tels = [ii for ii,jj in enumerate(tgt_cubes) if cubeDir in jj]\n\t\t\t#print(lineNums)\n\t\t\tnumCals = int(sys.argv[3])*len(els)\n\t\t\tfor kk in els:\n\t\t\t\tii = lineNums[kk][0]\n\t\t\t\tjj = lineNums[kk][0]\n\t\t\t\tcubeDir = elements[kk][1]+'_cubes'\n\t\t\t\twhile ii>=0 or jj<len(all_elements):\n\t\t\t\t\tif ii>=0 and os.path.isfile(cubeDir+'\/cube'+str(all_elements[ii][0])+'.fits'):\n\t\t\t\t\t\theader = pyfits.getheader(cubeDir+'\/cube'+str(all_elements[ii][0])+'.fits')\n\t\t\t\t\t\tif not all_elements[ii][1]==rawDir:\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif not header['OBJECT']==name:\n\t\t\t\t\t\t\tcal_els.append(all_elements[ii])\n\t\t\t\t\t\tii-=1\n\t\t\t\t\telif not os.path.isfile(cubeDir+'\/cube'+str(all_elements[ii][0])+'.fits'):\n\t\t\t\t\t\tii-=1\n\t\t\t\t\tif len(cal_els)>=int(sys.argv[3])*(kk+1):\n\t\t\t\t\t\tbreak\n\t\t\t\t\tif jj<len(all_elements) and os.path.isfile(cubeDir+'\/cube'+str(all_elements[jj][0])+'.fits'):\n\t\t\t\t\t\theader = pyfits.getheader(cubeDir+'\/cube'+str(all_elements[jj][0])+'.fits')\n\t\t\t\t\t\tif not all_elements[jj][1]==rawDir:\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tif not header['OBJECT']==name:\n\t\t\t\t\t\t\tcal_els.append(all_elements[jj])\n\t\t\t\t\t\tjj+=1\n\t\t\t\t\telif jj>=len(all_elements) or not os.path.isfile(cubeDir+'\/cube'+str(all_elements[jj][0])+'.fits'):\n\t\t\t\t\t\tjj+=1\n\t\t\t\t\tif len(cal_els)>=int(sys.argv[3])*(kk+1):\n\t\t\t\t\t\tbreak\t\t\t\n\t\t\ttgt_ims = []\n\t\t\tcal_ims = []\n\t\t\tpas = []\n\t\t\t#Make sure there are no duplicates\n\t\t\tcal_els.sort()\n\t\t\tnew_els = []\n\t\t\tfor ii in range(0,len(cal_els)):\n\t\t\t\tif ii==0:\n\t\t\t\t\tnew_els.append(cal_els[ii])\n\t\t\t\telif not cal_els[ii]==cal_els[ii-1]:\n\t\t\t\t\tnew_els.append(cal_els[ii])\n\t\t\tcal_els = new_els\n\t\t\t#Create target cube list\n\t\t\tnew_cubes = []\n\t\t\ttgt_els = []\n\t\t\tfor ii in range(0,len(tgt_cubes)):\n\t\t\t\tcube = pyfits.getdata(tgt_cubes[ii])\n\t\t\t\tpa = pyfits.getdata(tgt_cubes[ii],1)['pa']\n\t\t\t\tfor jj in range(0,len(cube)):\n\t\t\t\t\timage = cube[jj]\n\t\t\t\t\tif (np.max(image)-np.mean(image))\/np.std(image)>19:\n\t\t\t\t\t\ttgt_ims.append(image)\n\t\t\t\t\t\tpas.append(pa[jj])\n\t\t\t\t\t\tnew_cubes.append(tgt_cubes[ii])\n\t\t\t\t\t\ttgt_els.append(jj)\n\t\t\t#Create calibrator list\n\t\t\tcal_objects = []\n\t\t\tfor ii in range(0,len(cal_els)):\n\t\t\t\tcubeDir = cal_els[ii][1]+'_cubes'\n\t\t\t\tcal_cubes.append(cubeDir+'\/cube'+str(cal_els[ii][0])+'.fits')\n\t\t\t\tcube = pyfits.getdata(cal_cubes[ii])\n\t\t\t\tnum = 0\n\t\t\t\tfor jj in range(0,len(cube)):\n\t\t\t\t\timage = cube[jj]\n\t\t\t\t\tif (np.max(image)-np.mean(image))\/np.std(image)>19:\n\t\t\t\t\t\tnum+=1\n\t\t\t\tfor jj in range(0,len(cube)):\n\t\t\t\t\timage = cube[jj]\n\t\t\t\t\tcal = [pyfits.getheader(cal_cubes[ii])['OBJECT'],cubeDir+'\/cube'+str(cal_els[ii][0])+'.fits',str(num),str(jj)]\n\t\t\t\t\tif (np.max(image)-np.mean(image))\/np.std(image)>19:\n\t\t\t\t\t\tcal_ims.append(image)\n\t\t\t\t\t\tcal_objects.append(cal)\n\n\t\t\ttgt_ims = np.array(tgt_ims)\n\t\t\tcal_ims = np.array(cal_ims)\n\t\t\tall_ims = []\n\t\t\t#Restructure tgt_cubes vector so there is an entry for each image\n\t\t\t#When this is stored in the FITS file, it shows where each image came from\n\t\t\ttgt_cubes = new_cubes\n\t\t\t#Store target and calibration images in one file\n\t\t\ttempFile = plotDir+'\/temp.fits'\n\t\t\theader = pyfits.getheader(tgt_cubes[0])\n\t\t\tradec = [header['RA'],header['DEC']]\n\t\t\thdu1 = pyfits.PrimaryHDU(tgt_ims, header)\n\t\t\thdu2 = pyfits.ImageHDU(cal_ims)\n\t\t\tcol1 = pyfits.Column(name='pa', format='E', array=pas)\n\t\t\tcol2 = pyfits.Column(name='cal_objects', format='A40', array=[row[0] for row in cal_objects])\n\t\t\tcol3 = pyfits.Column(name='cal_cubes', format='A200', array=[row[1] for row in cal_objects])\n\t\t\tcol4 = pyfits.Column(name='cal_lengths', format='A40', array=[row[2] for row in cal_objects])\n\t\t\tcol5 = pyfits.Column(name='cal_els', format='A40', array=[row[3] for row in cal_objects])\n\t\t\tcol6 = pyfits.Column(name='tgt_cubes', format='A200', array=tgt_cubes)\n\t\t\tcol7 = pyfits.Column(name='tgt_els', format='E', array=tgt_els)\n\t\t\thdu3 = pyfits.BinTableHDU.from_columns(pyfits.ColDefs([col1,col2,col3,col4,col5,col6,col7]))\n\t\t\thdulist = pyfits.HDUList([hdu1,hdu2,hdu3])\n\t\t\thdulist.writeto(tempFile, clobber=True)\n\t\t\t#Create contrast ratio plots (one crat file for each night this object was observed)\n\t\t\tcrat_file = crat.best_psf_subtract(tempFile,plotDir)\n\t\t\t#Clean up and rename crat file to something unique\n\t\t\tos.system('rm -rf '+tempFile)\n\t\t\tos.system('mv '+crat_file+' crat'+str(year)+str(month)+str(day)+'.fits')\n\t\t\toutfiles.append('crat'+str(year)+str(month)+str(day)+'.fits')\n\ncrat_ims = []\npas = []\ncal_objects = []\ncal_cubes = []\ncal_lengths = []\ncal_elements = []\ntgt_cubes = []\noldHeader = pyfits.getheader(outfiles[0])\nsizes = []\ntgt_elements = []\n#Extract information from crat files creating image array\nfor ii in range(0,len(outfiles)):\n\tinfile = outfiles[ii]\n\tims = pyfits.getdata(infile)\n\textra = pyfits.getdata(infile,1)\n\tfor jj in range(0,len(ims)):\n\t\tcrat_ims.append(ims[jj])\n\t\tsizes.append(ims[jj].shape[0])\n\t\tpas.append(extra['pa'][jj])\n\t\tcal_objects.append(extra['cal_objects'][jj])\n\t\tcal_cubes.append(extra['cal_cubes'][jj])\n\t\tcal_elements.append(extra['cal_elements'][jj])\n\t\ttgt_cubes.append(extra['tgt_cubes'][jj])\n\t\ttgt_elements.append(extra['tgt_elements'][jj])\n\tos.system('rm -rf '+infile)\nbigSize = max(sizes)\n#Make all crat images same size by zooming out if necessary\nfor ii in range(0,len(crat_ims)):\n\tif crat_ims[ii].shape[0]==bigSize:\n\t\tcontinue\n\tsmallSize = crat_ims[ii].shape[0]\n\tnewArray = np.zeros((bigSize,bigSize))\n\tnewArray[bigSize\/\/2-smallSize\/\/2:bigSize\/\/2+smallSize\/\/2,bigSize\/\/2-smallSize\/\/2:bigSize\/\/2+smallSize\/\/2] = crat_ims[ii]\n\tcrat_ims[ii] = newArray\n\t\ndates = []\n#Create array showing the date each image was taken\nfor ii in range(0,len(tgt_cubes)):\n\tfor jj in range(0,len(tgt_cubes[ii])-11):\n\t\tif tgt_cubes[ii][jj:jj+11]=='_cubes\/cube':\n\t\t\tbreak\n\tdateString = tgt_cubes[ii][jj-6:jj]\n\tmonths = 'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'\n\tdate = str(int(dateString[4:6])) + '-' + months[3*(int(dateString[2:4])-1):3*int(dateString[2:4])] + '-20' + dateString[0:2]\n\tdates.append(date)\n\n#Store all crat information in one file\nsz = crat_ims[0].shape[0]\nheader = pyfits.Header(oldHeader)\nheader['CRVAL1']=header['RA']\nheader['CRVAL2']=header['DEC']\nheader['CRPIX1']=sz\/\/2\nheader['CRPIX2']=sz\/\/2\nheader['CDELT1']=-1.\/(3600*1024)\nheader['CDELT2']=1.\/(3600*1024)\nheader['CTYPE1']='RA---TAN'\nheader['CTYPE2']='DEC--TAN'\nheader['CD1_1']=-0.01\/3600.\nheader['CD2_2']=0.01\/3600.\nheader['CD1_2']=0\nheader['CD2_1']=0\nheader['OBJECT']=oldHeader['OBJECT']\nhdu = pyfits.PrimaryHDU(crat_ims,header)\ncol1 = pyfits.Column(name='pa', format='E', array=pas)\ncol2 = pyfits.Column(name='cal_objects', format='A40', array=cal_objects)\ncol3 = pyfits.Column(name='cal_cubes', format='A200', array=cal_cubes)\ncol4 = pyfits.Column(name='cal_elements', format='E', array=cal_elements)\ncol5 = pyfits.Column(name='tgt_cubes', format='A200', array=tgt_cubes)\ncol6 = pyfits.Column(name='tgt_indices', format='E', array=tgt_elements)\ncol7 = pyfits.Column(name='observation_dates', format='A40', array=dates)\nhdu2 = pyfits.BinTableHDU.from_columns(pyfits.ColDefs([col1,col2,col3,col4,col5,col6,col7]))\nhdulist = pyfits.HDUList([hdu,hdu2])\nhdulist.writeto(crat_file,clobber=True)\ncrat_im = pyfits.getdata(crat_file)\npas = pyfits.getdata(crat_file,1)['pa']\n#Take average over frames\nresult = np.mean(crat_im,axis=0)\noldSize = pyfits.getdata(tgt_cubes[0]).shape[1]\n\"\"\"newPA = np.mean(pas)\n#Set up rotation angle so image is approximately aligned\n#Make sure north is never more than 45 degrees from vertical\nnewRot = newPA\nwhile newRot>180:\n    newRot-=360\nwhile newRot<-180:\n    newRot+=360\nnewRot = 90-newRot\nwhile newRot>45 or newRot<-45:\n    if newRot<0:\n        newRot+=90\n    elif newRot>0:\n        newRot-=90\n    \nresult = nd.rotate(result,newRot,reshape=True)\nsize = result.shape[0]\nsz = pyfits.getdata(tgt_cubes[0]).shape[1]\n#Resize the result so it is the same size as original image\nresult = result[size\/\/2-sz\/\/2:size\/\/2+sz\/\/2,size\/\/2-sz\/\/2:size\/\/2+sz\/\/2]\"\"\"\n#Store average plot in FITS file\nhdu = pyfits.PrimaryHDU(result)\n#costerm = np.cos(np.radians(newRot))*0.01\/3600.\n#sinterm = np.sin(np.radians(newRot))*0.01\/3600.\nheader = pyfits.getheader(tgt_cubes[0])\nhdu.header = header\nhdu.header['CRVAL1']=radec[0]\nhdu.header['CRVAL2']=radec[1]\nhdu.header['CTYPE1']='RA---TAN'\nhdu.header['CTYPE2']='DEC--TAN'\nhdu.header['CRPIX1']=sz\/\/2\nhdu.header['CRPIX2']=sz\/\/2\nhdu.header['CD1_1']=-0.01\/3600.\nhdu.header['CD2_2']=0.01\/3600.\nhdu.header['CD1_2']=0\nhdu.header['CD2_1']=0\nhdu.header['OBJECT']=name\n#hdu.header['RADECSYS']='FK5'\nhdulist = pyfits.HDUList([hdu])\nhdulist.writeto(objDir+'\/ave_crat_'+objName+'_'+str(oldSize)+'.fits', clobber=True)\n#Find weighted mean\nmean_im = stats.weighted_mean(crat_im)\nstd_im = stats.bootstrap(crat_im,100)\nstd_im[np.where(std_im==0)] = 1e9\nsignificance = mean_im\/std_im\n\n\"\"\"mean_im = nd.rotate(mean_im,newRot,reshape=True)\nsize = mean_im.shape[0]\nmean_im = mean_im[size\/\/2-sz\/\/2:size\/\/2+sz\/\/2,size\/\/2-sz\/\/2:size\/\/2+sz\/\/2]\n\"\"\"\nhdu2 = pyfits.PrimaryHDU(mean_im)\nhdu2.header = hdu.header\nhdulist = pyfits.HDUList([hdu2])\nhdulist.writeto(objDir+'\/weighted_mean_'+objName+'_'+str(oldSize)+'.fits', clobber=True)\n\"\"\"significance = nd.rotate(significance,newRot,reshape=True)\nsize = significance.shape[0]\nsignificance = significance[size\/\/2-sz\/\/2:size\/\/2+sz\/\/2,size\/\/2-sz\/\/2:size\/\/2+sz\/\/2]\"\"\"\n#significance[np.where(significance>100*np.median(significance))] = 0\n#significance[np.where(np.isnan(significance))] = 0\nhdu3 = pyfits.PrimaryHDU(significance)\nhdu3.header = hdu.header\nhdulist = pyfits.HDUList([hdu3])\nhdulist.writeto(objDir+'\/significance_'+objName+'_'+str(oldSize)+'.fits', clobber=True)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_470","text":"import pandas as pd\r\nfrom scipy.stats import ttest_ind\r\nfrom sklearn.svm import SVC\r\nfrom sklearn.feature_selection import RFECV\r\n\r\n\r\ndef read_data(path):\r\n    \"\"\"\r\n    reads the csv data\r\n\r\n    Args:\r\n    path - path to the csv file\r\n\r\n    Returns:\r\n    A pandas dataframe and its labels\r\n    \"\"\"\r\n\r\n    data = pd.read_csv(path)\r\n    data.set_index(\"index\",inplace = True)\r\n    labels = data.pop(\"labels\")\r\n    return data, labels\r\n\r\ndef get_DEG(p_value, dataset, labels, log_FC):\r\n    \"\"\"\r\n    Finds differentially expressed genes with the given p_value and fold_change using independent t-test\r\n\r\n    Args:\r\n    p_value - int value for specifying the p value for stastical significance\r\n    dataset - csv dataset on which the differential expression analysis is to be performed\r\n    fold_change - int value depicting fold change\r\n\r\n    Returns:\r\n    A pandas dataframe containing genes that are differentially expressed with given p value and fold change\r\n    \"\"\"\r\n\r\n    dataset['labels'] = labels\r\n    groups = dataset.groupby(\"labels\")\r\n    normal_sample = groups.get_group(\"normal\")\r\n    tumor_sample = groups.get_group(\"tumor\")\r\n    tumor_sample = tumor_sample.drop([\"labels\"], axis = 1)\r\n    normal_sample = normal_sample.drop([\"labels\"], axis = 1)\r\n\r\n    columns = normal_sample.columns\r\n    print(columns)\r\n    t_data = []\r\n    for i in range(0,(len(columns)-1)):\r\n        a = normal_sample[columns[i]]\r\n        b = tumor_sample[columns[i]]\r\n        # T-test\r\n        t,p = ttest_ind(a,b)\r\n        if p<p_value:\r\n            t_data.append(columns[i])\r\n\r\n    p_data = pd.DataFrame(dataset, columns = t_data)\r\n    p_data[\"samples\"] = labels\r\n\r\n    #for fold change\r\n    group = p_data.groupby(\"samples\")\r\n    norm_sample = group.get_group(\"normal\")\r\n    tumr_sample = group.get_group(\"tumor\")\r\n    tumr_sample.drop(\"samples\", axis = 1, inplace = True)\r\n    norm_sample.drop(\"samples\", axis = 1, inplace = True)\r\n\r\n    fold = []\r\n    for i in tumr_sample.columns:\r\n        f = tumr_sample[i].mean() - norm_sample[i].mean()\r\n        if f < -(log_FC) or f >(log_FC):\r\n            fold.append(i)\r\n    deg = pd.DataFrame(dataset, columns = fold)\r\n    return deg\r\n\r\n\r\ndef svc_rfe_cv(dataset, label):\r\n    \"\"\"\r\n    Performing recursive feature elimination using support vector classifier with 10 fold cross validation\r\n\r\n    Args:\r\n    dataset - training data\r\n    label - trainig data labels\r\n\r\n    Returns:\r\n    A  list of most informative columns according to SVC_RFE\r\n    \"\"\"\r\n    estimator = SVC(kernel=\"linear\")\r\n    selector = RFECV(estimator, min_features_to_select=100, step=1, cv = 10)\r\n    selector = selector.fit(dataset, label)\r\n    training_data = dataset[dataset.columns[selector.get_support()]]\r\n\r\n    return training_data\r\n\r\n\r\nif __name__ == '__main__':\r\n    save_data_path = \"E:\/project\"\r\n    read_data_path = \"E:\/project\/gene_data.csv\"\r\n    print(\"\\nReading data\\n\")\r\n    data,labels = read_data(read_data_path)\r\n    data['labels'] = labels\r\n    print(\"\\nPerforming Differential expression analysis using independent t__test\\n\")\r\n    deg_data = get_DEG(0.0001,data,labels, 1)\r\n    print(f\"\\nDataset shape{deg_data.shape}\\nPerforming recursive feature eliminiation using SVC\\n\")\r\n    print(deg_data.columns,\"\\n\")\r\n    print(\"\\nNull values in data: \",deg_data.isnull().values.any(),\"\\nNull values in Labels: \", labels.isnull().values.any())\r\n    training_data = svc_rfe_cv(deg_data, labels)\r\n    training_data['labels'] = labels\r\n    print(f\"\\nDataset shape{training_data.shape}\\nSaving data...\\n\")\r\n    training_data.to_csv(f\"{save_data_path}\/training_data.csv\", index = True)\r\n    print(\"Done\")\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_472","text":"<reponame>terasakisatoshi\/pythonCodes<filename>fourierAnalysis\/from_scratch\/get_fourier.py\nimport numpy as np \nfrom matplotlib import pyplot as plt \nfrom scipy import integrate\n\nPi=np.pi\nT=2*Pi\nN= 50\n\ntarget_func=None\nfourier_series=None\n\ndef getVarName( var, symboltable, error=None ) :\n    \"\"\"\n    Return a var's name as a string.\\nThis funciton require a symboltable(returned value of globals() or locals()) in the name space where you search the var's name.\\nIf you set error='exception', this raise a ValueError when the searching failed.\n    \"\"\"\n    for k,v in symboltable.items() :\n        if id(v) == id(var) :\n            return k\n    else :\n        if error == \"exception\" :\n            raise ValueError(\"Undefined function is mixed in subspace?\")\n        else:\n            return error\n\ndef step_func(xs):\n\treturn np.where(xs<0,0,1)\n\ndef linear(xs,a=1):\n\treturn a*xs\n\ndef plot_func(funcs,func_name=\"function\"):\n\tfig,ax=plt.subplots()\n\tfor func in funcs:\n\t\txs=np.linspace(-T\/2,T\/2,5000)\n\t\tys=func[0](xs)\n\t\tax.plot(xs,ys,label=func[1])\n\tax.legend()\n\tax.set_title(\"target_func (= \"+func_name+\" ) and its fourier series\")\n\tplt.savefig(func_name+\".png\")\n\tplt.show()\n\ndef get_fourier(func,func_name):\n\tts=np.linspace(-T\/2,T\/2,5000)\n\tA0=integrate.simps((lambda t:func(t)\/T)(ts),ts) \n\tAs=np.array([integrate.simps((lambda t:2*func(t)*np.cos(2*n*Pi*t\/T)\/T)(ts),ts) for n in range(1,N)],dtype=np.float64)\n\tBs=np.array([integrate.simps((lambda t:2*func(t)*np.sin(2*n*Pi*t\/T)\/T)(ts),ts) for n in range(1,N)],dtype=np.float64)\n\tExplicit_Bs=np.array([(1-(-1)**n)\/(n*Pi) for n in range(1,N)])\n\tprint(Explicit_Bs)\n\tcos_part=lambda t : np.array([np.cos(2*n*Pi*t\/T) for n in range(1,N)],dtype=np.float64)\n\tsin_part=lambda t : np.array([np.sin(2*n*Pi*t\/T) for n in range(1,N)],dtype=np.float64)\n\n\tglobal target_func,fourier_series\n\ttarget_func=func\n\tfourier_series=lambda t: A0+As.dot(cos_part(t))+Bs.dot(sin_part(t))\n\tplot_func([(func,getVarName(func,globals())) for func in [func,fourier_series]],func_name)\n\ndef main():\n\tget_fourier(step_func,getVarName(step_func,globals()))\n\tget_fourier(linear,getVarName(linear,globals()))\nif __name__ == '__main__':\n\tmain()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_473","text":"<filename>1018\/Course Material\/1018_2.py<gh_stars>0\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Oct 18 20:53:35 2017\n\n@author: sitibanc\n\"\"\"\nimport numpy as np\nimport random\nfrom sklearn import datasets\nfrom scipy import stats\n\n\ndef kmeans(sample, K, max_iter):\n    N = sample.shape[0]                 # N筆資料\n    D = sample.shape[1]                 # 每筆資料有N維\n    C = np.zeros((K, D))                # K個中心點\n    L = np.zeros((N, 1))                # Label (data屬於哪一個cluster)\n    L1 = np.zeros((N, 1))               # 重新分群計算出的label\n    dist = np.zeros((N, K))\n    \n    # Random select center\n    idx = random.sample(range(N), K)\n    C = sample[idx, :]\n    iteration = 0\n    \n    while iteration <= max_iter:\n        for i in range(K):\n            #以整個矩陣做運算，求與C（中心點）距離\n            # np.tile() --> 垂直Repeat C[i, :] N次，水平repeat 1次\n            dist[:, i] = np.sum((sample - np.tile(C[i, :], (N, 1))) ** 2 , 1)\n            # 取距離最短者的input為其label\n            L1 = np.argmin(dist, 1)\n            # 若分群後各群成員不再改變（已分完，所屬cluster已定），則跳出迴圈\n            if iteration > 0 and np.array_equal(L, L1):\n                break\n            # Update Label L\n            L = L1\n            # 計算重新分群後的新center\n            for i in range(K):\n                # 取出屬於第i群者的index\n                idx = np.nonzero(L == i)[0]    # np.nonzero()亦即True\n                if len(idx) > 0:\n                    C[i, :] = np.mean(sample[idx, :], 0)    # 沿垂直方向(0)計算平均  \n        iteration += 1\n        # Calcuate wicd（within cluster distance, 群內每筆資料與群中心的距離）\n        wicd = np.sum(np.sqrt(np.sum((sample - C[L, :]) ** 2 , 1)))\n    return C, L, wicd\n\n# Practice 3 : Iris Dataset Clustering Using K-Means\ndata = datasets.load_iris()\nfeature = data.data\ncenter, label, wicd = kmeans(feature, 3, 1000)\n# Calculate Error Rate\nerror = 0\nfor i in range(len(label)):\n    if i < 50:\n        mode = stats.mode(label[:50])\n        if label[i] != mode[0][0]:\n            error += 1\n    elif i < 100:\n        mode = stats.mode(label[50:100])\n        if label[i] != mode[0][0]:\n            error += 1\n    else:\n        mode = stats.mode(label[100:])\n        if label[i] != mode[0][0]:\n            error += 1\nprint('Error rate :', error \/ len(label))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_474","text":"<filename>pyradar\/Libs\/receivers\/envelope_detector.py\n\"\"\"\nProject: RadarBook\nFile: envelope_detector.py\nCreated by: <NAME>\nOn: 9\/18\/2018\nCreated with: PyCharm\n\nCopyright (C) 2019 Artech House (<EMAIL>)\nThis file is part of Introduction to Radar Using Python and MATLAB\nand can not be copied and\/or distributed without the express permission of Artech House.\n\"\"\"\nfrom scipy.signal import hilbert\n\n\ndef envelope(if_signal):\n    \"\"\"\n    Calculate the amplitude envelope of the IF signal.\n    :param if_signal: The signal at IF.\n    :return: The amplitude envelope.\n    \"\"\"\n    return abs(hilbert(if_signal))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_475","text":"<reponame>igherzog\/hawc_hal\nfrom hawc_hal.healpix_handling.flat_sky_to_healpix import _parse_coord_system, _convert_world_coordinates, ORDER\nfrom hawc_hal.special_values import UNSEEN\nimport healpy as hp\nimport numpy as np\nimport six\nfrom scipy.ndimage import map_coordinates\n\nfrom astropy import units as u\n\ndef image_to_healpix(data, wcs_in, coord_system_out,\n                     nside, pixels_id, order='bilinear', nested=False,\n                     fill_value=UNSEEN, pixels_to_be_zeroed=None, full=False):\n\n    npix = hp.nside2npix(nside)\n\n    # Look up lon, lat of pixels in output system and convert colatitude theta\n    # and longitude phi to longitude and latitude.\n    theta, phi = hp.pix2ang(nside, pixels_id, nested)\n\n    lon_out = np.degrees(phi)\n    lat_out = 90. - np.degrees(theta)\n\n    # Convert between celestial coordinates\n    coord_system_out = _parse_coord_system(coord_system_out)\n\n    with np.errstate(invalid='ignore'):\n        lon_in, lat_in = _convert_world_coordinates(lon_out, lat_out, (coord_system_out, u.deg, u.deg), wcs_in)\n\n    # Look up pixels in input system\n    yinds, xinds = wcs_in.wcs_world2pix(lon_in, lat_in, 0)\n\n    # Interpolate\n\n    if isinstance(order, six.string_types):\n        order = ORDER[order]\n\n    healpix_data_ = map_coordinates(data, [xinds, yinds],\n                                    order=order,\n                                    mode='constant', cval=fill_value)\n\n    if not full:\n\n        # Return partial map\n        return healpix_data_\n\n    else:\n\n        # Return full healpix map\n\n        healpix_data = np.full(npix, fill_value)\n\n        healpix_data[pixels_id] = healpix_data_\n\n        if pixels_to_be_zeroed is not None:\n\n            healpix_data[pixels_to_be_zeroed] = np.where(np.isnan(healpix_data[pixels_to_be_zeroed]),\n                                                         0.0,\n                                                         healpix_data[pixels_to_be_zeroed])\n\n        return healpix_data\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_477","text":"import arrayfire as af\nimport cupy as np\nimport numpy\nimport scipy.sparse as sp\nimport warnings\nimport numbers\nfrom numpy.core.numeric import ComplexWarning\nfrom inspect import signature, isclass, Parameter\nfrom af_type_utils import typemap\n\nfrom sklearn.utils.validation import _deprecate_positional_args\nfrom sklearn._config import get_config as _get_config\n\ndef check_consistent_length(*arrays):\n    \"\"\"Check that all arrays have consistent first dimensions.\n\n    Checks whether all objects in arrays have the same shape or length.\n\n    Parameters\n    ----------\n    *arrays : list or tuple of input objects.\n        Objects that will be checked for consistent length.\n    \"\"\"\n\n    lengths = [_num_samples(X) for X in arrays if X is not None]\n    uniques = np.unique(lengths)\n    if len(uniques) > 1:\n        raise ValueError(\"Found input variables with inconsistent numbers of\"\n                         \" samples: %r\" % [int(l) for l in lengths])\n\ndef _safe_accumulator_op(op, x, *args, **kwargs):\n    \"\"\"\n    This function provides numpy accumulator functions with a float64 dtype\n    when used on a floating point input. This prevents accumulator overflow on\n    smaller floating point dtypes.\n    Parameters\n    ----------\n    op : function\n        A numpy accumulator function such as np.mean or np.sum\n    x : numpy array\n        A numpy array to apply the accumulator function\n    *args : positional arguments\n        Positional arguments passed to the accumulator function after the\n        input x\n    **kwargs : keyword arguments\n        Keyword arguments passed to the accumulator function\n    Returns\n    -------\n    result : The output of the accumulator function passed to this function\n    \"\"\"\n    if np.issubdtype(x.dtype, np.floating) and x.dtype.itemsize < 8:\n        result = op(x, *args, **kwargs, dtype=np.float64)\n    else:\n        result = op(x, *args, **kwargs)\n    return result\n\ndef _determine_key_type(key, accept_slice=True):\n    \"\"\"Determine the data type of key.\n\n    Parameters\n    ----------\n    key : scalar, slice or array-like\n        The key from which we want to infer the data type.\n\n    accept_slice : bool, default=True\n        Whether or not to raise an error if the key is a slice.\n\n    Returns\n    -------\n    dtype : {'int', 'str', 'bool', None}\n        Returns the data type of key.\n    \"\"\"\n    err_msg = (\"No valid specification of the columns. Only a scalar, list or \"\n               \"slice of all integers or all strings, or boolean mask is \"\n               \"allowed\")\n\n    dtype_to_str = {int: 'int', str: 'str', bool: 'bool', np.bool_: 'bool'}\n    array_dtype_to_str = {'i': 'int', 'u': 'int', 'b': 'bool', 'O': 'str',\n                          'U': 'str', 'S': 'str'}\n\n    if key is None:\n        return None\n    if isinstance(key, tuple(dtype_to_str.keys())):\n        try:\n            return dtype_to_str[type(key)]\n        except KeyError:\n            raise ValueError(err_msg)\n    if isinstance(key, slice):\n        if not accept_slice:\n            raise TypeError(\n                'Only array-like or scalar are supported. '\n                'A Python slice was given.'\n            )\n        if key.start is None and key.stop is None:\n            return None\n        key_start_type = _determine_key_type(key.start)\n        key_stop_type = _determine_key_type(key.stop)\n        if key_start_type is not None and key_stop_type is not None:\n            if key_start_type != key_stop_type:\n                raise ValueError(err_msg)\n        if key_start_type is not None:\n            return key_start_type\n        return key_stop_type\n    if isinstance(key, (list, tuple)):\n        unique_key = set(key)\n        key_type = {_determine_key_type(elt) for elt in unique_key}\n        if not key_type:\n            return None\n        if len(key_type) != 1:\n            raise ValueError(err_msg)\n        return key_type.pop()\n    if hasattr(key, 'dtype'):\n        try:\n            return array_dtype_to_str[key.dtype.kind]\n        except KeyError:\n            raise ValueError(err_msg)\n    raise ValueError(err_msg)\n\ndef _array_indexing(array, key, key_dtype, axis):\n    \"\"\"Index an array or scipy.sparse consistently across NumPy version.\"\"\"\n    if isinstance(key, tuple):\n        key = list(key)\n    afkey = af.interop.from_ndarray(key) #TODO: replace w\/arrayfire keys\n    return array[afkey, :] if axis == 0 else array[:, afkey]\n\ndef _safe_indexing(X, indices, *, axis=0):\n    \"\"\"Return rows, items or columns of X using indices.\n\n    .. warning::\n\n        This utility is documented, but **private**. This means that\n        backward compatibility might be broken without any deprecation\n        cycle.\n\n    Parameters\n    ----------\n    X : array-like, sparse-matrix, list, pandas.DataFrame, pandas.Series\n        Data from which to sample rows, items or columns. `list` are only\n        supported when `axis=0`.\n    indices : bool, int, str, slice, array-like\n        - If `axis=0`, boolean and integer array-like, integer slice,\n          and scalar integer are supported.\n        - If `axis=1`:\n            - to select a single column, `indices` can be of `int` type for\n              all `X` types and `str` only for dataframe. The selected subset\n              will be 1D, unless `X` is a sparse matrix in which case it will\n              be 2D.\n            - to select multiples columns, `indices` can be one of the\n              following: `list`, `array`, `slice`. The type used in\n              these containers can be one of the following: `int`, 'bool' and\n              `str`. However, `str` is only supported when `X` is a dataframe.\n              The selected subset will be 2D.\n    axis : int, default=0\n        The axis along which `X` will be subsampled. `axis=0` will select\n        rows while `axis=1` will select columns.\n\n    Returns\n    -------\n    subset\n        Subset of X on axis 0 or 1.\n\n    Notes\n    -----\n    CSR, CSC, and LIL sparse matrices are supported. COO sparse matrices are\n    not supported.\n    \"\"\"\n    if indices is None:\n        return X\n\n    if axis not in (0, 1):\n        raise ValueError(\n            \"'axis' should be either 0 (to index rows) or 1 (to index \"\n            \" column). Got {} instead.\".format(axis)\n        )\n\n    indices_dtype = _determine_key_type(indices)\n\n    if axis == 0 and indices_dtype == 'str':\n        raise ValueError(\n            \"String indexing is not supported with 'axis=0'\"\n        )\n\n    if axis == 1 and X.ndim != 2:\n        raise ValueError(\n            \"'X' should be a 2D NumPy array, 2D sparse matrix or pandas \"\n            \"dataframe when indexing the columns (i.e. 'axis=1'). \"\n            \"Got {} instead with {} dimension(s).\".format(type(X), X.ndim)\n        )\n\n    if axis == 1 and indices_dtype == 'str' and not hasattr(X, 'loc'):\n        raise ValueError(\n            \"Specifying the columns using strings is only supported for \"\n            \"pandas DataFrames\"\n        )\n\n    if hasattr(X, \"iloc\"):\n        return _pandas_indexing(X, indices, indices_dtype, axis=axis)\n    elif hasattr(X, \"shape\"):\n        return _array_indexing(X, indices, indices_dtype, axis=axis)\n    else:\n        return _list_indexing(X, indices, indices_dtype)\n\ndef _assert_all_finite(X, allow_nan=False, msg_dtype=None):\n    \"\"\"Like assert_all_finite, but only for ndarray.\"\"\"\n    # validation is also imported in extmath\n\n    if _get_config()['assume_finite']:\n        return\n    X = np.asanyarray(X)\n    # First try an O(n) time, O(1) space solution for the common case that\n    # everything is finite; fall back to O(n) space np.isfinite to prevent\n    # false positives from overflow in sum method. The sum is also calculated\n    # safely to reduce dtype induced overflows.\n    is_float = X.dtype.kind in 'fc'\n    if is_float and (np.isfinite(_safe_accumulator_op(np.sum, X))):\n        pass\n    elif is_float:\n        msg_err = \"Input contains {} or a value too large for {!r}.\"\n        if (allow_nan and np.isinf(X).any() or\n                not allow_nan and not np.isfinite(X).all()):\n            type_err = 'infinity' if allow_nan else 'NaN, infinity'\n            raise ValueError(\n                    msg_err.format\n                    (type_err,\n                     msg_dtype if msg_dtype is not None else X.dtype)\n            )\n    # for object dtype data, we only check for NaNs (GH-13254)\n    elif X.dtype == np.dtype('object') and not allow_nan:\n        if _object_dtype_isnan(X).any():\n            raise ValueError(\"Input contains NaN\")\n\ndef _ensure_no_complex_data(array):\n    if hasattr(array, 'dtype') and array.dtype is not None \\\n            and hasattr(array.dtype, 'kind') and array.dtype.kind == \"c\":\n        raise ValueError(\"Complex data not supported\\n\"\n                         \"{}\\n\".format(array))\n\ndef _num_samples(x):\n    \"\"\"Return number of samples in array-like x.\"\"\"\n    message = 'Expected sequence or array-like, got %s' % type(x)\n    if hasattr(x, 'fit') and callable(x.fit):\n        # Don't get num_samples from an ensembles length!\n        raise TypeError(message)\n\n    if not hasattr(x, '__len__') and not hasattr(x, 'shape'):\n        if hasattr(x, '__array__'):\n            x = np.asarray(x)\n        else:\n            raise TypeError(message)\n\n    if hasattr(x, 'shape') and x.shape is not None:\n        if len(x.shape) == 0:\n            raise TypeError(\"Singleton array %r cannot be considered\"\n                            \" a valid collection.\" % x)\n        # Check that shape is returning an integer or default to len\n        # Dask dataframes may not return numeric shape[0] value\n        if isinstance(x.shape[0], numbers.Integral):\n            return x.shape[0]\n\n    try:\n        return len(x)\n    except TypeError:\n        raise TypeError(message)\n\n\n@_deprecate_positional_args\ndef check_array(array, accept_sparse=False, *, accept_large_sparse=True,\n                dtype=\"numeric\", order=None, copy=False, force_all_finite=True,\n                ensure_2d=True, allow_nd=False, ensure_min_samples=1,\n                ensure_min_features=1, estimator=None):\n\n    \"\"\"Input validation on an array, list, sparse matrix or similar.\n\n    By default, the input is checked to be a non-empty 2D array containing\n    only finite values. If the dtype of the array is object, attempt\n    converting to float, raising on failure.\n\n    Parameters\n    ----------\n    array : object\n        Input object to check \/ convert.\n\n    accept_sparse : string, boolean or list\/tuple of strings (default=False)\n        String[s] representing allowed sparse matrix formats, such as 'csc',\n        'csr', etc. If the input is sparse but not in the allowed format,\n        it will be converted to the first listed format. True allows the input\n        to be any format. False means that a sparse matrix input will\n        raise an error.\n\n    accept_large_sparse : bool (default=True)\n        If a CSR, CSC, COO or BSR sparse matrix is supplied and accepted by\n        accept_sparse, accept_large_sparse=False will cause it to be accepted\n        only if its indices are stored with a 32-bit dtype.\n\n        .. versionadded:: 0.20\n\n    dtype : string, type, list of types or None (default=\"numeric\")\n        Data type of result. If None, the dtype of the input is preserved.\n        If \"numeric\", dtype is preserved unless array.dtype is object.\n        If dtype is a list of types, conversion on the first type is only\n        performed if the dtype of the input is not in the list.\n\n    order : 'F', 'C' or None (default=None)\n        Whether an array will be forced to be fortran or c-style.\n        When order is None (default), then if copy=False, nothing is ensured\n        about the memory layout of the output array; otherwise (copy=True)\n        the memory layout of the returned array is kept as close as possible\n        to the original array.\n\n    copy : boolean (default=False)\n        Whether a forced copy will be triggered. If copy=False, a copy might\n        be triggered by a conversion.\n\n    force_all_finite : boolean or 'allow-nan', (default=True)\n        Whether to raise an error on np.inf, np.nan, pd.NA in array. The\n        possibilities are:\n\n        - True: Force all values of array to be finite.\n        - False: accepts np.inf, np.nan, pd.NA in array.\n        - 'allow-nan': accepts only np.nan and pd.NA values in array. Values\n          cannot be infinite.\n\n        .. versionadded:: 0.20\n           ``force_all_finite`` accepts the string ``'allow-nan'``.\n\n        .. versionchanged:: 0.23\n           Accepts `pd.NA` and converts it into `np.nan`\n\n    ensure_2d : boolean (default=True)\n        Whether to raise a value error if array is not 2D.\n\n    allow_nd : boolean (default=False)\n        Whether to allow array.ndim > 2.\n\n    ensure_min_samples : int (default=1)\n        Make sure that the array has a minimum number of samples in its first\n        axis (rows for a 2D array). Setting to 0 disables this check.\n\n    ensure_min_features : int (default=1)\n        Make sure that the 2D array has some minimum number of features\n        (columns). The default value of 1 rejects empty datasets.\n        This check is only enforced when the input data has effectively 2\n        dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0\n        disables this check.\n\n    estimator : str or estimator instance (default=None)\n        If passed, include the name of the estimator in warning messages.\n\n    Returns\n    -------\n    array_converted : object\n        The converted and validated array.\n    \"\"\"\n    # store reference to original array to check if copy is needed when\n    # function returns\n    array_orig = array\n    #import pdb;pdb.set_trace()\n    return array #TMP todo: perform checks for af::array\n\n    # store whether originally we wanted numeric dtype\n    dtype_numeric = isinstance(dtype, str) and dtype == \"numeric\"\n\n    dtype_orig = getattr(array, \"dtype\", None)\n    if not hasattr(dtype_orig, 'kind'):\n        # not a data type (e.g. a column named dtype in a pandas DataFrame)\n        dtype_orig = None\n\n    # check if the object contains several dtypes (typically a pandas\n    # DataFrame), and store them. If not, store None.\n    dtypes_orig = None\n    has_pd_integer_array = False\n    if hasattr(array, \"dtypes\") and hasattr(array.dtypes, '__array__'):\n        # throw warning if columns are sparse. If all columns are sparse, then\n        # array.sparse exists and sparsity will be perserved (later).\n        with suppress(ImportError):\n            from pandas.api.types import is_sparse\n            if (not hasattr(array, 'sparse') and\n                    array.dtypes.apply(is_sparse).any()):\n                warnings.warn(\n                    \"pandas.DataFrame with sparse columns found.\"\n                    \"It will be converted to a dense numpy array.\"\n                )\n\n        dtypes_orig = list(array.dtypes)\n        # pandas boolean dtype __array__ interface coerces bools to objects\n        for i, dtype_iter in enumerate(dtypes_orig):\n            if dtype_iter.kind == 'b':\n                dtypes_orig[i] = np.dtype(np.object)\n            elif dtype_iter.name.startswith((\"Int\", \"UInt\")):\n                # name looks like an Integer Extension Array, now check for\n                # the dtype\n                with suppress(ImportError):\n                    from pandas import (Int8Dtype, Int16Dtype,\n                                        Int32Dtype, Int64Dtype,\n                                        UInt8Dtype, UInt16Dtype,\n                                        UInt32Dtype, UInt64Dtype)\n                    if isinstance(dtype_iter, (Int8Dtype, Int16Dtype,\n                                               Int32Dtype, Int64Dtype,\n                                               UInt8Dtype, UInt16Dtype,\n                                               UInt32Dtype, UInt64Dtype)):\n                        has_pd_integer_array = True\n\n        if all(isinstance(dtype, np.dtype) for dtype in dtypes_orig):\n            dtype_orig = np.result_type(*dtypes_orig)\n\n    if dtype_numeric:\n        if dtype_orig is not None and dtype_orig.kind == \"O\":\n            # if input is object, convert to float.\n            dtype = np.float64\n        else:\n            dtype = None\n\n    if isinstance(dtype, (list, tuple)):\n        if dtype_orig is not None and dtype_orig in dtype:\n            # no dtype conversion required\n            dtype = None\n        else:\n            # dtype conversion required. Let's select the first element of the\n            # list of accepted types.\n            dtype = dtype[0]\n\n    if has_pd_integer_array:\n        # If there are any pandas integer extension arrays,\n        array = array.astype(dtype)\n\n    if force_all_finite not in (True, False, 'allow-nan'):\n        raise ValueError('force_all_finite should be a bool or \"allow-nan\"'\n                         '. Got {!r} instead'.format(force_all_finite))\n\n    if estimator is not None:\n        if isinstance(estimator, str):\n            estimator_name = estimator\n        else:\n            estimator_name = estimator.__class__.__name__\n    else:\n        estimator_name = \"Estimator\"\n    context = \" by %s\" % estimator_name if estimator is not None else \"\"\n\n    # When all dataframe columns are sparse, convert to a sparse array\n    if hasattr(array, 'sparse') and array.ndim > 1:\n        # DataFrame.sparse only supports `to_coo`\n        array = array.sparse.to_coo()\n\n    if sp.issparse(array):\n        _ensure_no_complex_data(array)\n        array = _ensure_sparse_format(array, accept_sparse=accept_sparse,\n                                      dtype=dtype, copy=copy,\n                                      force_all_finite=force_all_finite,\n                                      accept_large_sparse=accept_large_sparse)\n    else:\n        # If np.array(..) gives ComplexWarning, then we convert the warning\n        # to an error. This is needed because specifying a non complex\n        # dtype to the function converts complex to real dtype,\n        # thereby passing the test made in the lines following the scope\n        # of warnings context manager.\n        with warnings.catch_warnings():\n            try:\n                warnings.simplefilter('error', ComplexWarning)\n                if dtype is not None and np.dtype(dtype).kind in 'iu':\n                    # Conversion float -> int should not contain NaN or\n                    # inf (numpy#14412). We cannot use casting='safe' because\n                    # then conversion float -> int would be disallowed.\n                    array = np.asarray(array, order=order)\n                    if array.dtype.kind == 'f':\n                        _assert_all_finite(array, allow_nan=False,\n                                           msg_dtype=dtype)\n                    array = array.astype(dtype, casting=\"unsafe\", copy=False)\n                else:\n                    array = np.asarray(array, order=order, dtype=dtype)\n            except ComplexWarning:\n                raise ValueError(\"Complex data not supported\\n\"\n                                 \"{}\\n\".format(array))\n\n        # It is possible that the np.array(..) gave no warning. This happens\n        # when no dtype conversion happened, for example dtype = None. The\n        # result is that np.array(..) produces an array of complex dtype\n        # and we need to catch and raise exception for such cases.\n        _ensure_no_complex_data(array)\n\n        if ensure_2d:\n            # If input is scalar raise error\n            if array.ndim == 0:\n                raise ValueError(\n                    \"Expected 2D array, got scalar array instead:\\narray={}.\\n\"\n                    \"Reshape your data either using array.reshape(-1, 1) if \"\n                    \"your data has a single feature or array.reshape(1, -1) \"\n                    \"if it contains a single sample.\".format(array))\n            # If input is 1D raise error\n            if array.ndim == 1:\n                raise ValueError(\n                    \"Expected 2D array, got 1D array instead:\\narray={}.\\n\"\n                    \"Reshape your data either using array.reshape(-1, 1) if \"\n                    \"your data has a single feature or array.reshape(1, -1) \"\n                    \"if it contains a single sample.\".format(array))\n\n        # in the future np.flexible dtypes will be handled like object dtypes\n        #if dtype_numeric and np.issubdtype(array.dtype, np.flexible):\n            #warnings.warn(\n                #\"Beginning in version 0.22, arrays of bytes\/strings will be \"\n                #\"converted to decimal numbers if dtype='numeric'. \"\n                #\"It is recommended that you convert the array to \"\n                #\"a float dtype before using it in scikit-learn, \"\n                #\"for example by using \"\n                #\"your_array = your_array.astype(np.float64).\",\n                #FutureWarning, stacklevel=2)\n\n        # make sure we actually converted to numeric:\n        if dtype_numeric and array.dtype.kind == \"O\":\n            array = array.astype(np.float64)\n        if not allow_nd and array.ndim >= 3:\n            raise ValueError(\"Found array with dim %d. %s expected <= 2.\"\n                             % (array.ndim, estimator_name))\n\n        if force_all_finite:\n            _assert_all_finite(array,\n                               allow_nan=force_all_finite == 'allow-nan')\n\n    if ensure_min_samples > 0:\n        n_samples = _num_samples(array)\n        if n_samples < ensure_min_samples:\n            raise ValueError(\"Found array with %d sample(s) (shape=%s) while a\"\n                             \" minimum of %d is required%s.\"\n                             % (n_samples, array.shape, ensure_min_samples,\n                                context))\n\n    if ensure_min_features > 0 and array.ndim == 2:\n        n_features = array.shape[1]\n        if n_features < ensure_min_features:\n            raise ValueError(\"Found array with %d feature(s) (shape=%s) while\"\n                             \" a minimum of %d is required%s.\"\n                             % (n_features, array.shape, ensure_min_features,\n                                context))\n\n    if copy and np.may_share_memory(array, array_orig):\n        array = np.array(array, dtype=dtype, order=order)\n\n    return array\n\n@_deprecate_positional_args\ndef check_X_y(X, y, accept_sparse=False, *, accept_large_sparse=True,\n              dtype=\"numeric\", order=None, copy=False, force_all_finite=True,\n              ensure_2d=True, allow_nd=False, multi_output=False,\n              ensure_min_samples=1, ensure_min_features=1, y_numeric=False,\n              estimator=None):\n    \"\"\"Input validation for standard estimators.\n\n    Checks X and y for consistent length, enforces X to be 2D and y 1D. By\n    default, X is checked to be non-empty and containing only finite values.\n    Standard input checks are also applied to y, such as checking that y\n    does not have np.nan or np.inf targets. For multi-label y, set\n    multi_output=True to allow 2D and sparse y. If the dtype of X is\n    object, attempt converting to float, raising on failure.\n\n    Parameters\n    ----------\n    X : nd-array, list or sparse matrix\n        Input data.\n\n    y : nd-array, list or sparse matrix\n        Labels.\n\n    accept_sparse : string, boolean or list of string (default=False)\n        String[s] representing allowed sparse matrix formats, such as 'csc',\n        'csr', etc. If the input is sparse but not in the allowed format,\n        it will be converted to the first listed format. True allows the input\n        to be any format. False means that a sparse matrix input will\n        raise an error.\n\n    accept_large_sparse : bool (default=True)\n        If a CSR, CSC, COO or BSR sparse matrix is supplied and accepted by\n        accept_sparse, accept_large_sparse will cause it to be accepted only\n        if its indices are stored with a 32-bit dtype.\n\n        .. versionadded:: 0.20\n\n    dtype : string, type, list of types or None (default=\"numeric\")\n        Data type of result. If None, the dtype of the input is preserved.\n        If \"numeric\", dtype is preserved unless array.dtype is object.\n        If dtype is a list of types, conversion on the first type is only\n        performed if the dtype of the input is not in the list.\n\n    order : 'F', 'C' or None (default=None)\n        Whether an array will be forced to be fortran or c-style.\n\n    copy : boolean (default=False)\n        Whether a forced copy will be triggered. If copy=False, a copy might\n        be triggered by a conversion.\n\n    force_all_finite : boolean or 'allow-nan', (default=True)\n        Whether to raise an error on np.inf, np.nan, pd.NA in X. This parameter\n        does not influence whether y can have np.inf, np.nan, pd.NA values.\n        The possibilities are:\n\n        - True: Force all values of X to be finite.\n        - False: accepts np.inf, np.nan, pd.NA in X.\n        - 'allow-nan': accepts only np.nan or pd.NA values in X. Values cannot\n          be infinite.\n\n        .. versionadded:: 0.20\n           ``force_all_finite`` accepts the string ``'allow-nan'``.\n\n        .. versionchanged:: 0.23\n           Accepts `pd.NA` and converts it into `np.nan`\n\n    ensure_2d : boolean (default=True)\n        Whether to raise a value error if X is not 2D.\n\n    allow_nd : boolean (default=False)\n        Whether to allow X.ndim > 2.\n\n    multi_output : boolean (default=False)\n        Whether to allow 2D y (array or sparse matrix). If false, y will be\n        validated as a vector. y cannot have np.nan or np.inf values if\n        multi_output=True.\n\n    ensure_min_samples : int (default=1)\n        Make sure that X has a minimum number of samples in its first\n        axis (rows for a 2D array).\n\n    ensure_min_features : int (default=1)\n        Make sure that the 2D array has some minimum number of features\n        (columns). The default value of 1 rejects empty datasets.\n        This check is only enforced when X has effectively 2 dimensions or\n        is originally 1D and ``ensure_2d`` is True. Setting to 0 disables\n        this check.\n\n    y_numeric : boolean (default=False)\n        Whether to ensure that y has a numeric type. If dtype of y is object,\n        it is converted to float64. Should only be used for regression\n        algorithms.\n\n    estimator : str or estimator instance (default=None)\n        If passed, include the name of the estimator in warning messages.\n\n    Returns\n    -------\n    X_converted : object\n        The converted and validated X.\n\n    y_converted : object\n        The converted and validated y.\n    \"\"\"\n    #import pdb; pdb.set_trace()\n    if y is None:\n        raise ValueError(\"y cannot be None\")\n\n    X = check_array(X, accept_sparse=accept_sparse,\n                    accept_large_sparse=accept_large_sparse,\n                    dtype=dtype, order=order, copy=copy,\n                    force_all_finite=force_all_finite,\n                    ensure_2d=ensure_2d, allow_nd=allow_nd,\n                    ensure_min_samples=ensure_min_samples,\n                    ensure_min_features=ensure_min_features,\n                    estimator=estimator)\n    if multi_output:\n        y = check_array(y, accept_sparse='csr', force_all_finite=True,\n                        ensure_2d=False, dtype=None)\n    else:\n        y = column_or_1d(y, warn=True)\n        _assert_all_finite(y)\n    npdtype = typemap(y.dtype())\n    if y_numeric and npdtype == 'O':\n        y = y.astype(af.Dype.f64)\n\n    check_consistent_length(X, y)\n\n    return X, y\n\n\n@_deprecate_positional_args\ndef column_or_1d(y, *, warn=False):\n    \"\"\" Ravel column or 1d numpy array, else raises an error\n\n    Parameters\n    ----------\n    y : array-like\n\n    warn : boolean, default False\n       To control display of warnings.\n\n    Returns\n    -------\n    y : array\n\n    \"\"\"\n    #y = np.asarray(y)\n    #shape = np.shape(y)\n    shape = y.dims()\n    if len(shape) == 1:\n        #return np.ravel(y)\n        return af.flat(y)\n    if len(shape) == 2 and shape[1] == 1:\n        if warn:\n            warnings.warn(\"A column-vector y was passed when a 1d array was\"\n                          \" expected. Please change the shape of y to \"\n                          \"(n_samples, ), for example using ravel().\",\n                          DataConversionWarning, stacklevel=2)\n        #return np.ravel(y)\n        return af.flat(y)\n\n    raise ValueError(\n        \"y should be a 1d array, \"\n        \"got an array of shape {} instead.\".format(shape))\n\n@_deprecate_positional_args\ndef check_is_fitted(estimator, attributes=None, *, msg=None, all_or_any=all):\n    \"\"\"Perform is_fitted validation for estimator.\n\n    Checks if the estimator is fitted by verifying the presence of\n    fitted attributes (ending with a trailing underscore) and otherwise\n    raises a NotFittedError with the given message.\n\n    This utility is meant to be used internally by estimators themselves,\n    typically in their own predict \/ transform methods.\n\n    Parameters\n    ----------\n    estimator : estimator instance.\n        estimator instance for which the check is performed.\n\n    attributes : str, list or tuple of str, default=None\n        Attribute name(s) given as string or a list\/tuple of strings\n        Eg.: ``[\"coef_\", \"estimator_\", ...], \"coef_\"``\n\n        If `None`, `estimator` is considered fitted if there exist an\n        attribute that ends with a underscore and does not start with double\n        underscore.\n\n    msg : string\n        The default error message is, \"This %(name)s instance is not fitted\n        yet. Call 'fit' with appropriate arguments before using this\n        estimator.\"\n\n        For custom messages if \"%(name)s\" is present in the message string,\n        it is substituted for the estimator name.\n\n        Eg. : \"Estimator, %(name)s, must be fitted before sparsifying\".\n\n    all_or_any : callable, {all, any}, default all\n        Specify whether all or any of the given attributes must exist.\n\n    Returns\n    -------\n    None\n\n    Raises\n    ------\n    NotFittedError\n        If the attributes are not found.\n    \"\"\"\n    if isclass(estimator):\n        raise TypeError(\"{} is a class, not an instance.\".format(estimator))\n    if msg is None:\n        msg = (\"This %(name)s instance is not fitted yet. Call 'fit' with \"\n               \"appropriate arguments before using this estimator.\")\n\n    if not hasattr(estimator, 'fit'):\n        raise TypeError(\"%s is not an estimator instance.\" % (estimator))\n\n    if attributes is not None:\n        if not isinstance(attributes, (list, tuple)):\n            attributes = [attributes]\n        attrs = all_or_any([hasattr(estimator, attr) for attr in attributes])\n    else:\n        attrs = [v for v in vars(estimator)\n                 if v.endswith(\"_\") and not v.startswith(\"__\")]\n\n    if not attrs:\n        raise NotFittedError(msg % {'name': type(estimator).__name__})\n\ndef check_random_state(seed):\n    \"\"\"Turn seed into a np.random.RandomState instance\n\n    Parameters\n    ----------\n    seed : None | int | instance of RandomState\n        If seed is None, return the RandomState singleton used by np.random.\n        If seed is an int, return a new RandomState instance seeded with seed.\n        If seed is already a RandomState instance, return it.\n        Otherwise raise ValueError.\n    \"\"\"\n    if seed is None or seed is np.random:\n        return np.random.mtrand._rand\n    if isinstance(seed, numbers.Integral):\n        return np.random.RandomState(seed)\n    if isinstance(seed, np.random.RandomState):\n        return seed\n    raise ValueError('%r cannot be used to seed a numpy.random.RandomState'\n                     ' instance' % seed)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_479","text":"from torchvision.datasets import ImageFolder\nimport torch\nfrom torch.utils.data import Dataset, ConcatDataset, Subset\nimport os\nimport numpy as np\nimport scipy.io\nfrom PIL import Image\n\n# Code Snippets by https:\/\/github.com\/zrsmithson\/Stanford-dogs\/blob\/master\/data\/stanford_dogs_data.py\n\nclass StanfordDogs(Dataset):\n    def __init__(self,\n                 train,\n                 cropped,\n                 split_seed=42,\n                 transform=None,\n                 root='data\/stanford_dogs'):\n\n        self.image_path = os.path.join(root, 'Images')\n        dataset = ImageFolder(root=self.image_path, transform=None)\n        self.dataset = dataset\n        self.cropped = cropped\n        self.root = root\n\n        self.annotations_folder = os.path.join(self.root, 'Annotation')\n        self.breeds = os.listdir(self.image_path)\n\n        self.classes = [cls.split('-', 1)[-1] for cls in self.dataset.classes]\n        self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}\n        self.idx_to_class = {i: cls for i, cls in enumerate(self.classes)}\n\n        self.targets = self.dataset.targets\n        self.name = 'stanford_dogs'\n\n        split_train = scipy.io.loadmat(os.path.join(self.root, 'train_list.mat'))['annotation_list']\n        labels_train = scipy.io.loadmat(os.path.join(self.root, 'train_list.mat'))['labels']\n        split_test = scipy.io.loadmat(os.path.join(self.root, 'test_list.mat'))['annotation_list']\n        labels_test = scipy.io.loadmat(os.path.join(self.root, 'test_list.mat'))['labels']\n\n        split = [item[0][0] for item in split_train] + [item[0][0] for item in split_test]\n        labels = [item[0]-1 for item in labels_train] + [item[0]-1 for item in labels_test]\n\n        if self.cropped:\n            self._breed_annotations = [[(annotation, box, idx)\n                                        for box in self.get_boxes(os.path.join(self.annotations_folder, annotation))]\n                                        for annotation, idx in zip(split, labels)]\n            self._flat_breed_annotations = [t[0] for t in self._breed_annotations]\n            self.targets = [t[-1][-1] for t in self._breed_annotations]\n            self._flat_breed_images = [(annotation+'.jpg', box, idx) for annotation, box, idx in self._flat_breed_annotations]\n        else:\n            self._breed_images = [(annotation+'.jpg', idx) for annotation, idx in zip(split, labels)]\n            self.targets = [t[-1] for t in self._breed_images]\n            self._flat_breed_images = self._breed_images\n\n        self.transform = transform\n        indices = list(range(len(self.dataset)))\n        np.random.seed(split_seed)\n        np.random.shuffle(indices)\n        training_set_size = int(0.9 * len(self.dataset))\n        train_idx = indices[:training_set_size]\n        test_idx = indices[training_set_size:]\n\n        if train:\n            self.dataset = np.array(self._flat_breed_images, dtype=object)[train_idx].tolist()\n            self.targets = np.array(self.targets)[train_idx].tolist()\n        else:\n            self.dataset = np.array(self._flat_breed_images, dtype=object)[test_idx].tolist()\n            self.targets = np.array(self.targets)[test_idx].tolist()\n\n    def __len__(self):\n        return len(self.dataset)\n\n    def __getitem__(self, idx):\n        # im, _ = self.dataset[idx]\n        image_name, target = self.dataset[idx][0], self.dataset[idx][-1]\n        image_path = os.path.join(self.image_path, image_name)\n        im = Image.open(image_path).convert('RGB')\n\n        if self.cropped:\n            im = im.crop(self.dataset[idx][1])\n        if self.transform:\n            return self.transform(im), target\n        else:\n            return im, target\n\n    def get_boxes(self, path):\n        import xml.etree.ElementTree\n        e = xml.etree.ElementTree.parse(path).getroot()\n        boxes = []\n        for objs in e.iter('object'):\n            boxes.append([int(objs.find('bndbox').find('xmin').text),\n                          int(objs.find('bndbox').find('ymin').text),\n                          int(objs.find('bndbox').find('xmax').text),\n                          int(objs.find('bndbox').find('ymax').text)])\n        return boxes\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_471","text":"<filename>hdn\/utils\/image_aug.py\nimport cv2\nimport numpy as np\nimport random\nfrom scipy.stats import norm\nimport matplotlib.pyplot as plt\ndef generate_spot_light_mask(mask_size,\n                             position=None,\n                             max_brightness=255,\n                             min_brightness=0,\n                             mode=\"gaussian\",\n                             linear_decay_rate=None,\n                             speedup=False):\n    \"\"\"\n    Generate decayed light mask generated by spot light given position, direction. Multiple spotlights are accepted.\n    Args:\n        mask_size: tuple of integers (w, h) defining generated mask size\n        position: list of tuple of integers (x, y) defining the center of spotlight light position,\n                  which is the reference point during rotating\n        max_brightness: integer that max brightness in the mask\n        min_brightness: integer that min brightness in the mask\n        mode: the way that brightness decay from max to min: linear or gaussian\n        linear_decay_rate: only valid in linear_static mode. Suggested value is within [0.2, 2]\n        speedup: use `shrinkage then expansion` strategy to speed up vale calculation\n    Return:\n        light_mask: ndarray in float type consisting value from max_brightness to min_brightness. If in 'linear' mode\n                    minimum value could be smaller than given min_brightness.\n    \"\"\"\n    if position is None:\n        position = [(random.randint(0, mask_size[0]), random.randint(0, mask_size[1]))]\n    if linear_decay_rate is None:\n        if mode == \"linear_static\":\n            linear_decay_rate = random.uniform(0.25, 1)\n    assert mode in [\"linear\", \"gaussian\"], \\\n        \"mode must be linear_dynamic, linear_static or gaussian\"\n    mask = np.zeros(shape=(mask_size[1], mask_size[0]), dtype=np.float32)\n    if mode == \"gaussian\":\n        mu = np.sqrt(mask.shape[0]**2+mask.shape[1]**2)\n        dev = mu \/ 3.5\n        mask = _decay_value_radically_norm_in_matrix(mask_size, position, max_brightness, min_brightness, dev)\n    mask = np.asarray(mask, dtype=np.uint8)\n    # add median blur\n    mask = cv2.medianBlur(mask, 5)\n    mask = 255 - mask\n    # cv2.imshow(\"mask\", mask)\n    # cv2.waitKey(0)\n    return mask\n\ndef _decay_value_radically_norm_in_matrix(mask_size, centers, max_value, min_value, dev):\n    \"\"\"\n    _decay_value_radically_norm function in matrix format\n    \"\"\"\n    center_prob = norm.pdf(0, 0, dev)\n    x_value_rate = np.zeros((mask_size[1], mask_size[0]))\n    for center in centers:\n        coord_x = np.arange(mask_size[0])\n        coord_y = np.arange(mask_size[1])\n        xv, yv = np.meshgrid(coord_x, coord_y)\n        dist_x = xv - center[0]\n        dist_y = yv - center[1]\n        dist = np.sqrt(np.power(dist_x, 2) + np.power(dist_y, 2))\n        x_value_rate += norm.pdf(dist, 0, dev) \/ center_prob\n    mask = x_value_rate * (max_value - min_value) + min_value\n    mask[mask > 255] = 255\n    return mask\n\ndef _decay_value_radically_norm(x, centers, max_value, min_value, dev):\n    \"\"\"\n    Calculate point value decayed from center following Gaussian decay. If multiple centers are given, value\n    from each center sums up while limiting the accumulated value into [0, 255]\n    NOTE: assuming light at each center is identical: same brightness and same decay rate\n    \"\"\"\n    center_prob = norm.pdf(0, 0, dev)\n    x_value_rate = 0\n    for center in centers:\n        distance = np.sqrt((center[0]-x[0])**2 + (center[1]-x[1])**2)\n        x_value_rate += norm.pdf(distance, 0, dev) \/ center_prob\n    x_value = x_value_rate * (max_value - min_value) + min_value\n    x_value = 255 if x_value > 255 else x_value\n    return x_value\n\ndef add_spot_light(image, light_position=None, max_brightness=255, min_brightness=0,\n                   mode='gaussian', linear_decay_rate=None, transparency=None):\n    \"\"\"\n    Add mask generated from spot light to given image\n    \"\"\"\n    # min_brightness = 0\n    # max_brightness = 128\n    if transparency is None:\n        transparency = random.uniform(0.1, 1.0)\n    # if transparency is None:\n    frame = image\n    height, width, _ = frame.shape\n    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\n    mask = generate_spot_light_mask(mask_size=(width, height),\n                                    position=light_position,\n                                    max_brightness=max_brightness,\n                                    min_brightness=min_brightness,\n                                    mode=mode,\n                                    linear_decay_rate=linear_decay_rate)\n    hsv[:, :, 2] = hsv[:, :, 2] * transparency + mask * (1 - transparency)\n    frame = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)\n    frame[frame > 255] = 255\n    frame = np.asarray(frame, dtype=np.uint8)\n    return frame\n\n\n\ndef addImage(img1, img, alpha=0.9, beta=0.1, gamma=0):\n    h, w, _ = img1.shape\n    img2 = cv2.resize(img, (w,h), interpolation=cv2.INTER_AREA)\n    #alpha，beta，gamma\n    # alpha = 0.9\n    # beta = 1-alpha\n    # gamma = 0\n    img_add = cv2.addWeighted(img1, alpha, img2, beta, gamma)\n    return img_add"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_476","text":"import numpy as np\nfrom uncertainties import ufloat\nfrom scipy import optimize\nimport matplotlib.pyplot as plt\n\nprint(\"---------------einzelspalt---------------\")\ndx1, i1 = np.genfromtxt(\"python\/einzelspalt.txt\", unpack=True)\ndsg = 0.325  # abstand schirm gitter in meter\ng = 0.075e-3  # in meter\nλ = 635e-9  # in meter\ndx1 = dx1*10**(-3) # in Metern\nmdx1 = 0.024 # Verschiebung Hauptmaxima in Meter\nphi = np.arctan((dx1-mdx1)\/dsg)\ni1 = i1\/0.78\nphi1 = np.linspace(0.019,0.030)\nphi2 = np.arctan((phi1-mdx1)\/dsg)\n\ndef fitfunc2(phi, A, b):\n    return (A**2*b**2*(np.sinc(b*np.sin(phi)\/λ))**2)\n\nparams, covariance_matrix = optimize.curve_fit(fitfunc2, phi, i1, p0=[1000, 1e-3])\nerrors = np.sqrt(np.diag(covariance_matrix))\nprint('A =', params[0], '+-', errors[0])\nprint('b =', params[1], '+-', errors[1])\n\nplt.plot(dx1, i1, \"g.\", label=\"Messdaten\")\nplt.plot(phi1, fitfunc2(phi2, *params), label=\"Fitfunktion\")\nplt.xlabel(r'$x\\:\/\\:\\si{\\meter}$')\nplt.ylabel(r'$I\\:\/\\:\\si{\\ampere}$')\nplt.legend()\nplt.grid()\nplt.xlim(0.019,0.030)\nplt.ylim(0,1.1)\nplt.savefig('build\/einzelspalt1.pdf')\nplt.clf()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_478","text":"# -*- coding: utf-8 -*-\n#\n# This module defines several normalized lineshapes for 1D and 2D spectroscopy\n#\nimport numpy\nfrom scipy import special\n\nfrom .. import REAL\nfrom .. import COMPLEX\n\n###############################################################################\n#\n#    1D absorptive lineshapes\n#\n###############################################################################\n\ndef gaussian(omega, cent, delta):\n    \"\"\"Normalized Gaussian line shape\n    \n    \"\"\"\n    return numpy.sqrt(numpy.log(2.0)\/numpy.pi)\\\n                     *numpy.exp(-numpy.log(2.0)*((omega-cent)\/delta)**2) \\\n                     \/delta\n\n\ndef lorentzian(omega, cent, gamma):\n    \"\"\"Normalized Lorenzian line shape\n    \n    \"\"\"\n    return (gamma\/numpy.pi)\/((omega-cent)**2 + gamma**2)\n\n\ndef lorentzian_im(omega, cent, gamma):\n    \"\"\"Imaginary part of a normalized Lorenzian line shape\n    \n    \"\"\"\n    return 1j*((omega-cent)\/numpy.pi)\/((omega-cent)**2 + gamma**2)\n\n\ndef voigt(omega, cent, delta, gamma=0.0):\n    \"\"\"Normalized Voigt line shape for absorption\n    \n    \"\"\"    \n    z = (omega - cent + 1j*gamma)*numpy.sqrt(numpy.log(2.0))\/delta\n    \n    return numpy.sqrt(numpy.log(2.0))*\\\n                      numpy.real(special.wofz(z)) \\\n                      \/(numpy.sqrt(numpy.pi)*delta)\n\n\ndef cvoigt(omega, cent, delta, gamma=0.0):\n    \"\"\"Complex normalized Voigt line shape\n    \n    \"\"\"\n    a = (delta**2)\/(4.0*numpy.log(2))\n    z = (gamma - 1j*(omega - cent))\/(2.0*numpy.sqrt(a))\n    \n    \n    return numpy.real(special.erfcx(z))*numpy.sqrt(numpy.pi\/a)\/2.0\n\n\n###############################################################################\n#\n#    2D lineshapes\n#\n###############################################################################\n\n\ndef gaussian2D(omega1, cent1, delta1, omega2, cent2, delta2, corr=0.0):\n    \"\"\"Two-dimensional complex Gaussian lineshape   \n    \n    \"\"\"\n    gamma1 = 0.0\n    gamma2 = 0.0\n    return voigt2D(omega1, cent1, delta1, gamma1,\n                   omega2, cent2, delta2, gamma2, corr=corr)\n\n\ndef voigt2D(omega1, cent1, delta1, gamma1, \n            omega2, cent2, delta2, gamma2, corr=0.0):\n    \"\"\"Two-dimensional complex Voigt lineshape\n    \n    \"\"\"\n    if corr == 0.0:\n        \n        N1 = omega1.shape[0]\n        N2 = omega2.shape[0]\n        \n        dat1 = cvoigt(omega1, cent1, delta1, gamma1)\n        dat2 = cvoigt(omega2, cent2, delta2, gamma2)\n        \n        data = numpy.zeros((N1, N2), dtype=COMPLEX)  \n\n        for k in range(N1):\n            data[:, k] = dat1[k]*dat2[:]\n        \n    else:\n        \n        raise Exception(\"Not implemented yet\")\n        \n    return data        \n\n\ndef lorentzian2D(omega1, cent1, gamma1, omega2, cent2, gamma2, corr=0.0):\n    \"\"\"Two-dimensional complex Lorentzian lineshape\n    \n    \"\"\"\n    \n    if corr == 0.0:\n        \n        N1 = omega1.shape[0]\n        N2 = omega2.shape[0]\n        \n        dat1 = lorentzian(omega1, cent1, gamma1) + \\\n               lorentzian_im(omega1, cent1, gamma1)\n        dat2 = lorentzian(omega2, cent2, gamma2) + \\\n               lorentzian_im(omega2, cent2, gamma2)\n        \n        data = numpy.zeros((N1, N2), dtype=COMPLEX)  \n\n        for k in range(N1):\n            data[k, :] = dat1[k]*dat2[:]\n        \n    else:\n        \n        raise Exception(\"Not implemented yet\")\n        \n    return data\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_467","text":"<gh_stars>1-10\nimport numpy as np\nimport matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as colors\nimport matplotlib.cm as cm\nfrom matplotlib import rcParams\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nfrom scipy.special import erf,erfinv\nfrom scipy.interpolate import griddata,interp2d\nfrom scipy.stats import truncnorm\nimport sys\nimport os\n\nrcParams.update({'font.size': 26})\nrcParams.update({'mathtext.fontset': 'cm'})\n\ndef colorbar(mappable,orient):\n    last_axes = plt.gca()\n    ax = mappable.axes\n    fig1 = ax.figure\n    divider = make_axes_locatable(ax)\n    if orient == 'right':\n        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n        cbar = fig1.colorbar(mappable, cax=cax,orientation='vertical')\n        cbar.ax.yaxis.set_ticks_position('right')\n    else:\n        cax = divider.append_axes(\"top\", size=\"5%\", pad=0.05)\n        cbar = fig1.colorbar(mappable, cax=cax,orientation='horizontal')\n        cbar.ax.xaxis.set_ticks_position('top')\n    cbar.set_ticks([10,100])\n    cbar.set_ticklabels(['10','100'])\n    cbar.ax.tick_params(which='major',axis='both', direction='out',length = 12.0, width = 8.0,labelsize=fs)\n    cbar.ax.tick_params(which='minor',axis='both', direction='out',length = 6.0, width = 4.0,labelsize=fs)\n    plt.sca(last_axes)\n    return cbar\n\nG = 4.*np.pi**2\nM_st = int(sys.argv[1])\nif M_st == 0:\n    M_A = 1.2\n    ymax = [45,45,65,65]\nelif M_st == 1:\n    M_A = 1.\n    ymax = [30,30,50,50]\nelse:\n    M_A = 0.8\n    ymax = [20,20,30,30]\n\ne_p = 0.\ni_m = 0. # change to i_m = 180. for retrograde moons\nm_p = 3.0035e-6 #Earth mass\nQ_p = 10.\nk2_p = 0.299\nR_p = 4.26352e-5 #Earth Radius in AU\nT = 1e10 #Moon lifetime in yr\n\ndata_dir = \"..\/data\/Fig11\/\"\nfname = data_dir + \"MC_sample_%1.2f.txt\" % M_A\n\ncmap = cm.nipy_spectral_r\nvmin = 10\nvmax = 5500\nmy_cmap=cm.get_cmap(cmap)\nnorm = colors.LogNorm(vmin,vmax)\ncmmapable =cm.ScalarMappable(norm,my_cmap)\ncmmapable.set_array(range(0,1))\ncmap.set_under('w')\n\nfs = 'x-large'\nwidth = 10.\naspect = 2.\nms = 6.\nlw = 5\n\nfig = plt.figure(figsize=(aspect*width,width),dpi=300)\nax1 = fig.add_subplot(221)\nax2 = fig.add_subplot(222)\nax3 = fig.add_subplot(223)\nax4 = fig.add_subplot(224)\n\ndata_MC = np.genfromtxt(fname,delimiter=',',comments='#')\nax_list = [ax1,ax2,ax3,ax4]\nsublbl = ['a','b','c','d']\n\nfor m in range(0,2):\n    if m ==1:\n        i_m = 180\n    else:\n        i_m = 0\n    \n    host = ['A','B']\n    color = ['k','r']\n    for k in range(0,2):\n        ax = ax_list[2*m+k]\n\n        set_cut = np.where(np.logical_and(np.abs(data_MC[:,0]-k)<1e-6,np.abs(data_MC[:,1]-i_m)<1e-6))[0]\n        xbins = np.arange(0.001,0.1005,0.0005)\n\n        ybins = np.arange(0.1,ymax[2*m+k]+0.1,0.1)\n        h,xedges,yedges = np.histogram2d(data_MC[set_cut,2],data_MC[set_cut,3],bins=[xbins,ybins])\n        CS = ax.pcolormesh(xedges[:-1],yedges[:-1],h.T,vmin=vmin,vmax=vmax,cmap=cmap,norm=norm)\n        \n        ax.minorticks_on()\n        ax.tick_params(which='major',axis='both', direction='out',length = 12.0, width = 8.0,labelsize=fs)\n        ax.tick_params(which='minor',axis='both', direction='out',length = 6.0, width = 4.0)\n        \n        ax.set_xlim(0.001,0.1)\n        ax.set_ylim(0.1,ymax[2*m+k]+10)\n        ax.set_xscale('log')\n        ax.set_yscale('log')\n\n        ax.set_yticks([1,10])\n        ax.set_yticklabels(['1','10'])\n        ax.set_xticks([0.001,0.01,0.1])\n        ax.set_xticklabels(['0.001','0.01','0.1'])\n        if m==0:\n            ax.text(0.99,0.9,\"prograde\" , color='k',fontsize='large',weight='bold',horizontalalignment='right',transform=ax.transAxes)\n        else:\n            ax.set_xlabel(\"$a_{\\\\rm p}\/a_{\\\\rm bin}$\",fontsize=fs)\n            ax.text(0.99,0.9,\"retrograde\" , color='k',fontsize='large',weight='bold',horizontalalignment='right',transform=ax.transAxes)\n        ax.text(0.02,0.88,sublbl[2*m+k], color='k',fontsize='x-large',weight='bold',horizontalalignment='left',transform=ax.transAxes)\n\n        if k == 0:\n            ax.set_ylabel(\"TTV (min)\",fontsize=fs)\n        if 2*m+k == 0:\n            ax.text(0.5,1.05,\"Star A\" , color='k',fontsize='large',weight='bold',horizontalalignment='center',transform=ax.transAxes)\n        elif 2*m+k == 1:\n            ax.text(0.5,1.05,\"Star B\" , color='k',fontsize='large',weight='bold',horizontalalignment='center',transform=ax.transAxes)\n        if (2*m+k) < 2:\n            ax.set_xticklabels([])\n\ncolor_label = 'Number of Systems'\ncax = fig.add_axes([0.92,0.11,0.015,0.77])\ncbar=plt.colorbar(cmmapable,cax=cax,orientation='vertical')\ncbar.set_label(color_label,fontsize=fs)\n\ncbar.set_ticks([10,100,1000])\ncbar.set_ticklabels(['10','100','1000'])\ncbar.ax.tick_params(which='major',axis='both', direction='out',length = 12.0, width = 8.0,labelsize=fs)\ncbar.ax.tick_params(which='minor',axis='both', direction='out',length = 6.0, width = 4.0,labelsize=fs)\n\nfig.subplots_adjust(hspace=0.1)\nfig.savefig(\"..\/Figs\/Fig11_MonteCarlo.png\",bbox_inches='tight',dpi=300)\nplt.close()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_544","text":"import tensorflow as tf\nfrom buildModel.hyperparameters import *\nfrom scipy.signal import gaussian\nimport numpy as np\n\"\"\"\nAll tensor objects will be defined as global variables.\nAny source can access to these values for restoring or\nsaving or training tensors.\n\"\"\"\ndef tensorSummaries(tensor,name):\n    with tf.name_scope(name):\n        mean = tf.reduce_mean(tensor)\n        tf.summary.scalar('mean', mean)\n        with tf.name_scope('stddev'):\n            stddev = tf.sqrt(tf.reduce_mean(tf.square(tensor - mean)))\n        tf.summary.scalar('stddev', stddev)\n        tf.summary.scalar('max', tf.reduce_max(tensor))\n        tf.summary.scalar('min', tf.reduce_min(tensor))\n        tf.summary.histogram('histogram', tensor)\n\ndef wrapTensorToTensorboard():\n    pass\n\n############# Loss & Dropout probability  ##############################\nis_train_step = tf.placeholder(tf.bool)\nloss_weight = tf.placeholder(tf.float32)\nclass_threshold = tf.placeholder(tf.float32)\np_dropout = tf.placeholder(tf.float32)\n\n############################### INPUT ##################################\ninput_data_train = tf.placeholder(tf.float32, shape=(batch_size, target_size, 1), name=\"trainingData\")\ninput_data_eval = tf.placeholder(tf.float32, shape=(batch_size, target_size, 1), name=\"testData\")\n\nlabel_data_train = tf.placeholder(tf.float32, shape=(batch_size, 1, target_size))\nlabel_data_eval = tf.placeholder(tf.float32, shape=(batch_size, 1, target_size))\n\ninput_ref_data_train = tf.placeholder(tf.float32, shape=(batch_size, target_size, 1), name=\"TrainRefData\")\ninput_ref_data_eval = tf.placeholder(tf.float32, shape=(batch_size, target_size, 1), name=\"TestRefData\")\n\nsmoothing_filter = tf.constant(gaussian(filter_size_b,50)\/np.sum(gaussian(filter_size_b,50)),tf.float32, shape=[filter_size_b,1,1], name='smoothing_filter')\n\n###################### STEM FOR REFGENEDEPTH ###########################\nconv1_ref_weight = tf.get_variable(\"Conv_REF_1\", shape=[3, 1, conv1_ref_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ STEM Layer  ###############################\nconv1_weight = tf.get_variable(\"Conv_STEM1\", shape=[5, 1, conv1_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv2_weight = tf.get_variable(\"Conv_STEM2\", shape=[3, conv1_features, conv2_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv1_bias = tf.get_variable(\"Conv_STEM1_bias\", shape=[conv1_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv2_bias = tf.get_variable(\"Conv_STEM2_bias\", shape=[conv2_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 1 ###############################\nlayer1_width = conv2_features + conv1_ref_features\nconv1a_weight = tf.get_variable(\"Conv_1A\", shape=[4, layer1_width, conv1a_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv1b_weight = tf.get_variable(\"Conv_1B\", shape=[3, layer1_width, conv1b_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv1c_weight = tf.get_variable(\"Conv_1C\", shape=[2, layer1_width, conv1c_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconvMax1_weight = tf.get_variable(\"Conv_max_W1\", shape=[2, layer1_width, convMax1_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconvAvg1_weight = tf.get_variable(\"Conv_avg_W1\", shape=[2, layer1_width, convAvg1_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\nconv1a_bias = tf.get_variable(\"conv1a_bias\", shape=[conv1a_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv1b_bias = tf.get_variable(\"conv2b_bias\", shape=[conv1b_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv1c_bias = tf.get_variable(\"conv3c_bias\", shape=[conv1c_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 2 ###############################\nlayer2_width = conv1a_features + conv1b_features + conv1c_features + (layer1_width*2)\nconv2a_weight = tf.get_variable(\"Conv_2A\", shape=[4, layer2_width, conv2a_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv2b_weight = tf.get_variable(\"Conv_2B\", shape=[3, layer2_width, conv2b_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv2c_weight = tf.get_variable(\"Conv_2C\", shape=[2, layer2_width, conv2c_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconvMax2_weight = tf.get_variable(\"Conv_max_W2\", shape=[2, layer2_width, convMax2_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconvAvg2_weight = tf.get_variable(\"Conv_avg_W2\", shape=[2, layer2_width, convAvg2_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 3 ###############################\nlayer3_width = conv2a_features + conv2b_features + (layer2_width *2 ) + conv2c_features\nconv3a_weight = tf.get_variable(\"Conv_3A\", shape=[5, layer3_width, conv3a_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv3b_weight = tf.get_variable(\"Conv_3B\", shape=[4, layer3_width, conv3b_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv3c_weight = tf.get_variable(\"Conv_3C\", shape=[3, layer3_width, conv3c_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 4 ###############################\nlayer4_width = conv3a_features + conv3b_features + conv3c_features + layer3_width\nconv4a_weight = tf.get_variable(\"Conv_4A\", shape=[4, layer4_width, conv4a_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv4b_weight = tf.get_variable(\"Conv_4B\", shape=[3, layer4_width, conv4b_features], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv4c_weight = tf.get_variable(\"Conv_4C\", shape=[2, layer4_width, conv4c_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 5 ###############################\nlayer5_width = conv4a_features + conv4b_features + conv4c_features +layer4_width\nconv5a_weight = tf.get_variable(\"Conv_5A\", shape=[4, layer5_width, conv5a_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv5b_weight = tf.get_variable(\"Conv_5B\", shape=[3, layer5_width, conv5b_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv5c_weight = tf.get_variable(\"Conv_5C\", shape=[2, layer5_width, conv5c_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 6  ###############################\nlayer6_width = conv5a_features + conv5b_features + conv5c_features +layer5_width\nconv6a_weight = tf.get_variable(\"Conv_6A\", shape=[10, layer6_width, conv6a_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv6b_weight = tf.get_variable(\"Conv_6B\", shape=[8, layer6_width, conv6b_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv6c_weight = tf.get_variable(\"Conv_6C\", shape=[6, layer6_width, conv6c_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv6d_weight = tf.get_variable(\"Conv_6D\", shape=[5, layer6_width, conv6d_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Inception 6  ###############################\nlayer7_width = conv6a_features + conv6b_features + conv6c_features + conv6d_features\nconv7a_weight = tf.get_variable(\"Conv_7A\", shape=[10, layer7_width, conv7a_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv7b_weight = tf.get_variable(\"Conv_7B\", shape=[8, layer7_width, conv7b_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv7c_weight = tf.get_variable(\"Conv_7C\", shape=[6, layer7_width, conv7c_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nconv7d_weight = tf.get_variable(\"Conv_7D\", shape=[5, layer7_width, conv7d_features],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n\n############################ Fully Connected ###############################\nlayer_full_width = conv7a_features + conv7b_features + conv7c_features + conv7d_features#conv6a_features + conv6b_features + conv6c_features + conv6d_features\nresulting_width = 1\n\nfinal_conv_size = resulting_width * ( layer_full_width )\nfull1_weight = tf.get_variable(\"Full_W1\", shape=[final_conv_size, fully_connected_size1],initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\nfull2_weight = tf.get_variable(\"Full_W2\", shape=[fully_connected_size1, fully_connected_size2], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\n\n############################ Output ###############################\noutput_weight = tf.get_variable(\"Full_Output\", shape=[fully_connected_size2, threshold_division], initializer= tf.contrib.layers.variance_scaling_initializer(factor=1.0, mode='FAN_AVG',uniform='True'))\noutput_bias = tf.Variable(tf.truncated_normal([threshold_division], stddev=0.1, dtype=tf.float32))\n\n\ndef peakPredictConvModel(input_data_depth, input_data_ref, test=False, smoothing=True, normalize=False, eps=0.00001):\n    \"\"\"\n    Define structure of convolution model.\n    It will return two final output tensor.\n     1. Sub output tensor for training steps\n     2. Final output tensor for training and test steps\n    :param logger:\n    :param input_data:\n    :return: Tensor of the output layer\n    \"\"\"\n    input_data_depth = input_data_depth + init_depth \n\n    if smoothing:\n        depth_tensor_max = tf.nn.pool(input_data_depth, [filter_size_a], strides=[1], padding='SAME', pooling_type='MAX')\n        depth_tensor_smooth = tf.nn.conv1d(depth_tensor_max, smoothing_filter, stride=1, padding='SAME')\n        input_data_depth = depth_tensor_smooth\n\n    if normalize:\n        depth_mean, depth_var = tf.nn.moments(input_data_depth, [1])\n        input_data_depth = (input_data_depth -  depth_mean)\/tf.sqrt(depth_var + eps)\n    \n\n    #Stem of read depth data\n    conv1 = tf.nn.conv1d(input_data_depth, conv1_weight, stride=1, padding='SAME')\n    conv1 = tf.contrib.layers.batch_norm(conv1, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv1 = tf.nn.relu(conv1)\n    print(\"Stem 1 : {}\".format(conv1.shape))\n\n    conv2 = tf.nn.conv1d(conv1, conv2_weight, stride=1, padding='SAME')\n    conv2 = tf.contrib.layers.batch_norm(conv2, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv2 = tf.nn.relu(conv2)\n    max_pool1 = tf.nn.pool(conv2, [max_pool_size_stem], strides=[max_pool_size_stem],\n            padding='SAME', pooling_type='MAX')\n    print(\"Stem 2 : {}\".format(max_pool1.shape))\n\n    #Stem of ref gene data\n    conv1_ref = tf.nn.conv1d(input_data_ref, conv1_ref_weight, stride=1, padding='SAME')\n    conv1_ref = tf.contrib.layers.batch_norm(conv1_ref, is_training=is_train_step, data_format=\"NHWC\", decay=0.9, zero_debias_moving_mean=True)\n    conv1_ref = tf.nn.relu(conv1_ref)\n    max_pool1_ref = tf.nn.pool(conv1_ref, [max_pool_size_stem], strides=[max_pool_size_stem],\n            padding='SAME', pooling_type='MAX')\n    print(\"Stem_Ref 1 : {}\".format(max_pool1_ref.shape))\n\n    input_concat = tf.concat([max_pool1, max_pool1_ref],axis = 2) #max_pool1\n    print(\"Stem_concat : {}\".format(input_concat.shape))\n\n    # Inception modules 1 to 6\n    concat1 = concatLayer_A(input_concat, conv1a_weight, convMax1_weight, conv1b_weight, convAvg1_weight, conv1c_weight, 2)\n\n    concat2 = concatLayer_A(concat1, conv2a_weight, convMax2_weight, conv2b_weight, convAvg2_weight, conv2c_weight, 2)\n\n    concat3 = concatLayer_B(concat2, conv3a_weight, conv3b_weight, conv3c_weight, 3)\n    concat3 = concat3 + tf.nn.pool(tf.concat([concat1 for x in range(4)], axis=2), [6], strides=[6], pooling_type='AVG', padding='SAME')\n\n    concat4 = concatLayer_B(concat3, conv4a_weight, conv4b_weight, conv4c_weight, 2)\n\n    concat5 = concatLayer_B(concat4, conv5a_weight, conv5b_weight, conv5c_weight, 2)\n    concat5 = concat5 + tf.nn.pool(tf.concat([concat3 for x in range(3)], axis=2), [4], strides=[4], pooling_type='AVG', padding='SAME')\n\n    concat6 = concatLayer_C(concat5, conv6a_weight, conv6b_weight, conv6c_weight, conv6d_weight, 5)\n\n    concat7 = concatLayer_C(concat6, conv7a_weight, conv7b_weight, conv7c_weight, conv7d_weight, 5)\n    concat7 = concat7 + tf.nn.pool(tf.concat([concat5 for x in range(2)], axis=2), [25], strides=[25], pooling_type='AVG', padding='SAME')\n\n    concat7 = tf.nn.pool(concat7, [5], strides=[5], padding='SAME', pooling_type='AVG')\n    print(\"Final Avg pool : {}\".format(concat7.shape))\n\n    final_conv_shape = concat7.get_shape().as_list()\n    final_shape = final_conv_shape[1] * final_conv_shape[2]\n    flat_output = tf.reshape(concat7, [final_conv_shape[0] , final_shape])\n\n    fully_connected1 = tf.matmul(flat_output, full1_weight)\n    fully_connected1 = tf.contrib.layers.batch_norm(fully_connected1,is_training=is_train_step, decay=0.9, zero_debias_moving_mean=True)\n    fully_connected1 = tf.nn.relu(fully_connected1)\n    print(\"Fully connected A :{}\".format(fully_connected1.shape))\n\n    fully_connected2 = tf.matmul(fully_connected1, full2_weight)\n    fully_connected2 = tf.contrib.layers.batch_norm(fully_connected2,is_training=is_train_step, decay=0.9, zero_debias_moving_mean=True)\n    fully_connected2 = tf.nn.relu(fully_connected2)\n    print(\"Fully connected B :{}\".format(fully_connected2.shape))\n\n    final_threshold_output = tf.matmul(fully_connected2, output_weight)\n    final_threshold_output = tf.add(final_threshold_output, output_bias)\n    print(\"Threshold Output :{}\".format(final_threshold_output.shape))\n\n    return final_threshold_output\n\n\ndef concatLayer_B(source_layer, conv1_w, conv2_w, conv3_w, pooling_size):\n    \"\"\"\n    Define concat layer which like Inception module.\n    :param source_layer:\n    :param conv1_w:\n    :param conv2_w:\n    :param conv1_b:\n    :param conv2_b:\n    :param pooling_size:\n    :return:\n    \"\"\"\n    conv1 = tf.nn.conv1d(source_layer, conv1_w, stride=pooling_size, padding='SAME')\n    conv1 = tf.contrib.layers.batch_norm(conv1, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv1 = tf.nn.relu(conv1)\n\n    conv2 = tf.nn.conv1d(source_layer, conv2_w, stride=pooling_size, padding='SAME')\n    conv2 = tf.contrib.layers.batch_norm(conv2, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv2 = tf.nn.relu(conv2)\n\n    conv3 = tf.nn.conv1d(source_layer, conv3_w, stride=pooling_size, padding='SAME')\n    conv3 = tf.contrib.layers.batch_norm(conv3, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv3 = tf.nn.relu(conv3)\n\n    max_pool = tf.nn.pool(source_layer, [pooling_size], strides=[pooling_size],\n            padding='SAME', pooling_type='MAX')\n\n    concat = tf.concat([conv1, conv2, conv3,  max_pool], axis=2)\n    print(\"Concat Type A :{}\".format(concat.shape))\n    return concat\n\n\ndef concatLayer_C(source_layer, conv1_w, conv2_w, conv3_w, conv4_w, pooling_size):\n    \"\"\"\n    Define concat layer which like Inception module.\n    :param source_layer:\n    :param conv1_w:\n    :param conv_max_w:\n    :param conv2_w:\n    :param conv_avg_w:\n    :param conv1_b:\n    :param conv_max_b:\n    :param conv2_b:\n    :param conv_avg_b:\n    :param pooling_size:\n    :return:\n    \"\"\"\n    conv1 = tf.nn.conv1d(source_layer, conv1_w, stride=pooling_size, padding='SAME')\n    conv1 = tf.contrib.layers.batch_norm(conv1, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv1 = tf.nn.relu(conv1)\n\n    conv2 = tf.nn.conv1d(source_layer, conv2_w, stride=pooling_size, padding='SAME')\n    conv2 = tf.contrib.layers.batch_norm(conv2, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv2 = tf.nn.relu(conv2)\n\n    conv3 = tf.nn.conv1d(source_layer, conv3_w, stride=pooling_size, padding='SAME')\n    conv3 = tf.contrib.layers.batch_norm(conv3, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv3 = tf.nn.relu(conv3)\n\n    conv4 = tf.nn.conv1d(source_layer, conv4_w, stride=pooling_size, padding='SAME')\n    conv4 = tf.contrib.layers.batch_norm(conv4, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv4 = tf.nn.relu(conv4)\n\n    concat = tf.concat([conv1, conv2, conv3, conv4], axis=2)\n    print(\"Concat Type C :{}\".format(concat.shape))\n    return concat\n\n\ndef concatLayer_A(source_layer, conv1_w, conv_max_w, conv2_w, conv_avg_w, conv3_w, pooling_size):\n    \"\"\"\n    Define concat layer which like Inception module.\n    :param source_layer:\n    :param pooling_size:\n    :return:\n    \"\"\"\n    conv1 = tf.nn.conv1d(source_layer, conv1_w, stride=2, padding='SAME')\n    conv1 = tf.contrib.layers.batch_norm(conv1, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv1 = tf.nn.relu(conv1)\n\n    conv2 = tf.nn.conv1d(source_layer, conv2_w, stride=2, padding='SAME')\n    conv2 = tf.contrib.layers.batch_norm(conv2, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv2 = tf.nn.relu(conv2)\n\n    conv3 = tf.nn.conv1d(source_layer, conv3_w, stride=2, padding='SAME')\n    conv3 = tf.contrib.layers.batch_norm(conv3, is_training=is_train_step, data_format='NHWC', decay=0.9, zero_debias_moving_mean=True)\n    conv3 = tf.nn.relu(conv3)\n\n    max_pool = tf.nn.pool(source_layer, [pooling_size], strides=[pooling_size,],\n            padding='SAME', pooling_type='MAX')\n\n    avg_pool = tf.nn.pool(source_layer, [pooling_size], strides=[pooling_size,],\n            padding='SAME', pooling_type='AVG')\n\n    concat = tf.concat([conv1, avg_pool, conv2, max_pool, conv3], axis=2)\n    print(\"Concat Type A :{}\".format(concat.shape))\n    return concat\n\n\ndef generateOutput(threshold_tensor, depth_tensor, div=10, input_size=12000, batch_size_in=batch_size, smoothing=True, normalize=False, t=1, eps=0.00001):\n    \"\"\"\n    It generate\n    :param threshold_tensor: This tensor represents read-depth thresholds which have size of 'div'\n    :param depth_tensor: This tensor represents\n    :param div:\n    :return:\n    \"\"\"\n    depth_tensor = depth_tensor + init_depth \n    \n    if smoothing:\n        depth_tensor_max = tf.nn.pool(depth_tensor, [filter_size_a], strides=[1], padding='SAME', pooling_type='MAX')\n        depth_tensor_smooth = tf.nn.conv1d(depth_tensor_max, smoothing_filter, stride=1, padding='SAME')\n        depth_tensor = depth_tensor_smooth\n\n    if normalize:\n        depth_mean, depth_var = tf.nn.moments(depth_tensor, [1])\n        depth_tensor = (depth_tensor -  depth_mean)\/tf.sqrt(depth_var + eps)\n        #depth_max = tf.reduce_max(depth_tensor)\n        #depth_tensor = ((depth_tensor - depth_mean)\/(depth_max + 0.00001))*100\n        \n    depth_tensor = tf.reshape(depth_tensor,[batch_size_in ,div, input_size\/\/div])\n    threshold_tensor = tf.reshape(threshold_tensor,[batch_size_in,div,1])\n    print(\"depth tensor :{}\".format(depth_tensor.shape))\n    print(\"threshold tensor :{}\".format(threshold_tensor.shape))\n\n    result_tensor = tf.subtract(depth_tensor, threshold_tensor, name=\"results\")\n    print(\"result tensor before:{}\".format(result_tensor.shape))\n    result_tensor = tf.reshape(result_tensor,[batch_size_in, 1, input_size])\n    print(\"result tensor after:{}\\n\".format(result_tensor.shape))\n\n    if not (t == 1):\n        result_tensor = result_tensor * t \n\n    return result_tensor\n\n\ndef aggregatedLoss(label_data_train, prediction_before_sigmoid):\n    \"\"\"\n    \"\"\"\n    loss_a = tf.reduce_mean(tf.nn.top_k(tf.nn.weighted_cross_entropy_with_logits(targets=label_data_train, logits=prediction_before_sigmoid,\n        pos_weight=tf.maximum(1.,(loss_weight))), k = topK_set_a).values)\n    tf.summary.scalar(\"Top_{}_Loss\".format(topK_set_a),loss_a)\n\n    loss_b = tf.reduce_mean(tf.nn.top_k(tf.nn.weighted_cross_entropy_with_logits(targets=label_data_train, logits=prediction_before_sigmoid,\n        pos_weight=tf.maximum(1.,(loss_weight))), k = 750).values)\n    tf.summary.scalar(\"Top_{}_Loss\".format(topK_set_b),loss_b)\n\n    return loss_a\n\n\n######################## Tensor graph for training steps #################################\nmodel_output  = peakPredictConvModel(input_data_train, input_ref_data_train)\nprediction_before_sigmoid = generateOutput(model_output, input_data_train, div=threshold_division, smoothing=True)\nprediction = tf.nn.sigmoid(prediction_before_sigmoid)\nloss = aggregatedLoss(label_data_train, prediction_before_sigmoid)\n#loss = topKAverageLoss(label_data_train, prediction_before_sigmoid)\n\nupdate_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\nwith tf.control_dependencies(update_ops):\n    optimizer = tf.train.AdamOptimizer(learning_rate)\n    train_step = optimizer.minimize(loss)\n\n####################### Tensor graph for test steps ######################################\ntest_model_output = peakPredictConvModel(input_data_eval, input_ref_data_eval)\ntest_prediction = tf.nn.sigmoid(generateOutput(test_model_output, input_data_eval, div=threshold_division, smoothing=True))"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_545","text":"from flask import Flask, render_template, Response\nimport cv2\nimport pygame\nimport numpy as np\nfrom keras.models import load_model\nfrom statistics import mode\nfrom utils.datasets import get_labels\nfrom utils.inference import detect_faces\nfrom utils.inference import draw_text\nfrom utils.inference import draw_bounding_box\nfrom utils.inference import apply_offsets\nfrom utils.inference import load_detection_model\nfrom utils.preprocessor import preprocess_input\n\n# Create Flask Entity Instant\napp = Flask(__name__)\n\n# parameters for loading data and images\nemotion_model_path = '.\/models\/emotion_model.hdf5'\nemotion_labels = get_labels('fer2013')\n\n# hyper-parameters for bounding boxes shape\nframe_window = 10\nemotion_offsets = (20, 40)\n\n# loading models\nface_cascade = cv2.CascadeClassifier('.\/models\/haarcascade_frontalface_default.xml')\nemotion_classifier = load_model(emotion_model_path)\n\n# getting input model shapes for inference\nemotion_target_size = emotion_classifier.input_shape[1:3]\n\n# starting lists for calculating modes\nemotion_window = []\n\ncap = cv2.VideoCapture(0)\n\npygame.mixer.init(16000, -16, 1, 2048)\n\nmusic_sad = \"music\/sad.mp3\"   # mp3 or mid file\nmusic_angry = \"music\/angry.mp3\"\nmusic_happy = \"music\/happy.mp3\"\n\n\ndef playmusic(soundfile):\n    if not pygame.mixer.music.get_busy():\n        pygame.mixer.music.stop()\n        pygame.mixer.music.load(soundfile)\n        pygame.mixer.music.play()\n        pygame.mixer.music.fadeout(10000)\n\ndef gen(video):\n    while True:\n        success, bgr_image = cap.read()\n\n        gray_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2GRAY)\n        rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)\n\n        faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5,\n                minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE)\n\n        for face_coordinates in faces:\n\n            x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)\n            gray_face = gray_image[y1:y2, x1:x2]\n            try:\n                gray_face = cv2.resize(gray_face, (emotion_target_size))\n            except:\n                continue\n\n            gray_face = preprocess_input(gray_face, True)\n            gray_face = np.expand_dims(gray_face, 0)\n            gray_face = np.expand_dims(gray_face, -1)\n            emotion_prediction = emotion_classifier.predict(gray_face)\n            emotion_probability = np.max(emotion_prediction)\n            emotion_label_arg = np.argmax(emotion_prediction)\n            emotion_text = emotion_labels[emotion_label_arg]\n            emotion_window.append(emotion_text)\n\n            if len(emotion_window) > frame_window:\n                emotion_window.pop(0)\n            try:\n                emotion_mode = mode(emotion_window)\n            except:\n                continue\n            \n            if emotion_text == 'angry':\n                playmusic(music_angry)\n                color = emotion_probability * np.asarray((255, 0, 0))\n            elif emotion_text == 'sad':\n                playmusic(music_sad)\n                color = emotion_probability * np.asarray((0, 0, 255))\n            elif emotion_text == 'happy':\n                playmusic(music_happy)\n                color = emotion_probability * np.asarray((255, 255, 0))\n            elif emotion_text == 'surprise':\n                color = emotion_probability * np.asarray((0, 255, 255))\n            else:\n                color = emotion_probability * np.asarray((0, 255, 0))\n\n            color = color.astype(int)\n            color = color.tolist()\n\n            draw_bounding_box(face_coordinates, rgb_image, color)\n            draw_text(face_coordinates, rgb_image, emotion_mode,\n                    color, 0, -45, 1, 1)\n\n        bgr_image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)\n\n        # flask 에서 image 재처리\n        ret, jpeg = cv2.imencode('.jpg',bgr_image)\n        frame = jpeg.tobytes()\n        yield (b'--frame\\r\\n' b'Content-Type: image\/jpeg\\r\\n\\r\\n' + frame + b'\\r\\n\\r\\n')\n        if cv2.waitKey(1) & 0xFF == ord('q'):\n            break\n    cap.release()\n\n@app.route('\/')\ndef index():\n    return render_template(\"index.html\")\n@app.route('\/run')\ndef run():\n    return render_template(\"generic.html\")\n\n@app.route('\/video_feed')\ndef video_feed():\n    global cap\n    return Response(gen(cap), mimetype='multipart\/x-mixed-replace; boundary=frame')\n\nif __name__ == \"__main__\":\n    #app.run(host='0.0.0.0', port=9900, debug=True)\n    app.run(debug=True)\n    # host 등을 직접 지정하고 싶다면\n    # app.run(host=\"127.0.0.1\", port=\"5000\", debug=True)\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_546","text":"# Author: <NAME> <<EMAIL>>\n\"\"\"Plot topographic maps of sensor space data.\"\"\"\nfrom __future__ import annotations\n\nimport dataclasses\nfrom itertools import repeat\nfrom math import floor, sqrt\nfrom typing import Any, Dict, Literal, Sequence, Tuple, Union\n\nimport matplotlib as mpl\nimport matplotlib.axes\nimport numpy as np\nfrom scipy import interpolate, linalg\nfrom scipy.spatial import ConvexHull\n\nfrom .._colorspaces import UNAMBIGUOUS_COLORS\nfrom .._data_obj import NDVarArg, CategorialArg, IndexArg, Dataset\nfrom .._text import ms\nfrom ._base import (\n    CMapArg, ColorArg,\n    PlotType, EelFigure, PlotData, AxisData, DataLayer,\n    Layout, ImLayout, VariableAspectLayout,\n    ColorMapMixin, TimeSlicerEF, TopoMapKey, XAxisMixin, YLimMixin,\n)\nfrom ._utsnd import _ax_butterfly, _ax_im_array, _plt_im\nfrom ._sensors import SENSORMAP_FRAME, SensorMapMixin, _plt_map2d\n\n\nInterpolationArg = Literal[None, 'nearest', 'linear', 'spline']\nSensorLabelsArg = Literal['', 'none', 'index', 'name', 'fullname']\n\n\nclass Topomap(SensorMapMixin, ColorMapMixin, TopoMapKey, EelFigure):\n    \"\"\"Plot individual topogeraphies\n\n    Parameters\n    ----------\n    y\n        Data to plot.\n    xax\n        Create a separate plot for each cell in this model.\n    ds\n        If a Dataset is provided, data can be specified as strings.\n    sub\n        Specify a subset of the data.\n    vmax\n        Upper limits for the colormap (default is determined from data).\n    vmin\n        Lower limit for the colormap (default ``-vmax``).\n    cmap\n        Colormap (default depends on the data).\n    contours\n        Contours to draw on topomaps. Can be an int (number of contours,\n        including ``vmin``\/``vmax``), a sequence (values at which to draw\n        contours), or a ``**kwargs`` dict (must contain at least the \"levels\"\n        key). Default is no contours.\n    proj\n        The sensor projection to use for topomaps (or one projection per plot).\n    res\n        Resolution of the topomaps (width = height = ``res``).\n    interpolation\n        Method for interpolating topo-map between sensors (default is based on\n        mne-python).\n    clip : bool | 'even' | 'circle'\n        Outline for clipping topomaps: 'even' to clip at a constant distance\n        (default), 'circle' to clip using a circle.\n    clip_distance\n        How far from sensor locations to clip (1 is the axes height\/width).\n    head_radius\n        Radius of the head outline drawn over sensors (on sensor plots with\n        normalized positions, 0.45 is the outline of the topomap); 0 to plot no\n        outline; tuple for separate (right, anterior) radius.\n        The default is determined automatically.\n    head_pos\n        Head outline position along the anterior axis (0 is the center, 0.5 is\n        the top end of the plot).\n    im_interpolation\n        Topomap image interpolation (see Matplotlib's\n        :meth:`~matplotlib.axes.Axes.imshow`). Matplotlib 1.5.3's SVG output\n        can't handle uneven aspect with ``interpolation='none'``, use\n        ``interpolation='nearest'`` instead.\n    sensorlabels\n        Show sensor labels. For 'name', any prefix common to all names\n        is removed; with 'fullname', the full name is shown.\n    mark\n        Sensors which to mark.\n    mcolor : matplotlib color\n        Color for marked sensors.\n    axtitle\n        Title for the individual axes. The default is to show the names of the\n        epochs, but only if multiple axes are plotted.\n    xlabel\n        Label below the topomaps (default is no label; ``True`` to use ``y``\n        names).\n    margins\n        Layout parameter.\n    ...\n        Also accepts :ref:`general-layout-parameters`.\n\n    Notes\n    -----\n    Keys:\n     - ``t``: open a ``Topomap`` plot for the region under the mouse pointer.\n     - ``T``: open a larger ``Topomap`` plot with visible sensor names for the\n       map under the mouse pointer.\n    \"\"\"\n    def __init__(\n            self,\n            y: Union[NDVarArg, Sequence[NDVarArg]],\n            xax: CategorialArg = None,\n            ds: Dataset = None,\n            sub: IndexArg = None,\n            vmax: float = None,\n            vmin: float = None,\n            cmap: CMapArg = None,\n            contours: Union[int, Sequence, Dict] = None,\n            # topomap args\n            proj: str = 'default',\n            res: int = None,\n            interpolation: InterpolationArg = None,\n            clip: Union[bool, str] = 'even',\n            clip_distance: float = 0.05,\n            head_radius: Union[float, Tuple[float, float]] = None,\n            head_pos: Union[float, Sequence[float]] = 0,\n            im_interpolation: str = None,\n            # sensor-map args\n            sensorlabels: SensorLabelsArg = None,\n            mark: IndexArg = None,\n            mcolor: ColorArg = None,\n            # layout\n            axtitle: Union[bool, Sequence[str]] = True,\n            xlabel: Union[bool, str] = None,\n            margins: Dict[str, float] = None,\n            **kwargs,\n    ):\n        data = PlotData.from_args(y, ('sensor',), xax, ds, sub)\n        self.plots = []\n        ColorMapMixin.__init__(self, data.data, cmap, vmax, vmin, contours, self.plots)\n        if isinstance(proj, str):\n            proj = repeat(proj, data.n_plots)\n        elif not isinstance(proj, Sequence):\n            raise TypeError(f\"proj={proj!r}\")\n        elif len(proj) != data.n_plots:\n            raise ValueError(f\"proj={proj!r}: need as many proj as axes ({data.n_plots})\")\n\n        layout = ImLayout(data.plot_used, 1.1, 2, margins, axtitle=axtitle, **kwargs)\n        EelFigure.__init__(self, data.frame_title, layout)\n        self._set_axtitle(axtitle, data, verticalalignment='top', pad=-1)\n\n        # plots\n        axes_data = data.for_plot(PlotType.IMAGE)\n        for ax, layers, proj_ in zip(self.axes, axes_data, proj):\n            h = _ax_topomap(ax, layers, clip, clip_distance, sensorlabels, mark, mcolor, None, proj_, res, im_interpolation, xlabel, self._vlims, self._cmaps, self._contours, interpolation, head_radius, head_pos)\n            self.plots.append(h)\n\n        TopoMapKey.__init__(self, self._topo_data)\n        SensorMapMixin.__init__(self, [h.sensors for h in self.plots])\n        self._show()\n\n    def _fill_toolbar(self, tb):\n        ColorMapMixin._fill_toolbar(self, tb)\n        SensorMapMixin._fill_toolbar(self, tb)\n\n    def _topo_data(self, event):\n        if event.inaxes:\n            ax_i = self.axes.index(event.inaxes)\n            p = self.plots[ax_i]\n            return p.data, p.title, p.proj\n\n\nclass TopomapBins(SensorMapMixin, ColorMapMixin, TopoMapKey, EelFigure):\n    \"\"\"Topomaps in time-bins\n\n    Parameters\n    ----------\n    y\n        Data to plot.\n    xax\n        Create a separate plot for each cell in this model.\n    ds\n        If a Dataset is provided, data can be specified as strings.\n    sub\n        Specify a subset of the data.\n    bin_length\n        Length ofthe time bins for topo-plots.\n    tstart\n        Beginning of the first time bin (default is the beginning of ``y``).\n    tstop\n        End of the last time bin (default is the end of ``y``).\n    vmax\n        Upper limits for the colormap (default is determined from data).\n    vmin\n        Lower limit for the colormap (default ``-vmax``).\n    cmap\n        Colormap (default depends on the data).\n    contours\n        Contours to draw on topomaps. Can be an int (number of contours,\n        including ``vmin``\/``vmax``), a sequence (values at which to draw\n        contours), or a ``**kwargs`` dict (must contain at least the \"levels\"\n        key). Default is no contours.\n    proj\n        The sensor projection to use for topomaps.\n    res\n        Resolution of the topomaps (width = height = ``res``).\n    interpolation\n        Method for interpolating topo-map between sensors (default is based on\n        mne-python).\n    clip : bool | 'even' | 'circle'\n        Outline for clipping topomaps: 'even' to clip at a constant distance\n        (default), 'circle' to clip using a circle.\n    clip_distance\n        How far from sensor locations to clip (1 is the axes height\/width).\n    head_radius\n        Radius of the head outline drawn over sensors (on sensor plots with\n        normalized positions, 0.45 is the outline of the topomap); 0 to plot no\n        outline; tuple for separate (right, anterior) radius.\n        The default is determined automatically.\n    head_pos\n        Head outline position along the anterior axis (0 is the center, 0.5 is\n        the top end of the plot).\n    im_interpolation\n        Topomap image interpolation (see Matplotlib's\n        :meth:`~matplotlib.axes.Axes.imshow`). Matplotlib 1.5.3's SVG output\n        can't handle uneven aspect with ``interpolation='none'``, use\n        ``interpolation='nearest'`` instead.\n    sensorlabels\n        Show sensor labels. For 'name', any prefix common to all names\n        is removed; with 'fullname', the full name is shown.\n    mark : Sensor index\n        Sensors which to mark.\n    mcolor : matplotlib color\n        Color for marked sensors.\n    ...\n        Also accepts :ref:`general-layout-parameters`.\n\n    Notes\n    -----\n    Keys:\n     - ``t``: open a ``Topomap`` plot for the map under the mouse pointer.\n     - ``T``: open a larger ``Topomap`` plot with visible sensor names for the\n       map under the mouse pointer.\n    \"\"\"\n    def __init__(\n            self,\n            y: Union[NDVarArg, Sequence[NDVarArg]],\n            xax: CategorialArg = None,\n            ds: Dataset = None,\n            sub: IndexArg = None,\n            bin_length: float = 0.050,\n            tstart: float = None,\n            tstop: float = None,\n            vmax: float = None,\n            vmin: float = None,\n            cmap: CMapArg = None,\n            contours: Union[int, Sequence, Dict] = None,\n            # topomap args\n            proj: str = 'default',\n            res: int = None,\n            interpolation: InterpolationArg = None,\n            clip: Union[bool, str] = 'even',\n            clip_distance: float = 0.05,\n            head_radius: Union[float, Tuple[float, float]] = None,\n            head_pos: Union[float, Sequence[float]] = 0,\n            im_interpolation: str = None,\n            # sensor-map args\n            sensorlabels: SensorLabelsArg = None,\n            mark: IndexArg = None,\n            mcolor: ColorArg = None,\n            **kwargs,\n    ):\n        data = PlotData.from_args(y, ('sensor', 'time'), xax, ds, sub)\n        self._plots = []\n        data._cannot_skip_axes(self)\n        bin_data = data.for_plot(PlotType.IMAGE).bin(bin_length, tstart, tstop)\n        ColorMapMixin.__init__(self, data.data, cmap, vmax, vmin, contours, self._plots)\n\n        # create figure\n        time = bin_data.y0.get_dim('time')\n        n_bins = len(time)\n        n_rows = bin_data.n_plots\n        layout = Layout(n_bins * n_rows, 1, 1.5, tight=False, nrow=n_rows, ncol=n_bins, **kwargs)\n        EelFigure.__init__(self, data.frame_title, layout)\n        self._plots.extend(repeat(None, n_bins * n_rows))\n\n        for column, t in enumerate(time):\n            t_data = bin_data.sub_time(t)\n            for row, layers in enumerate(t_data):\n                i = row * n_bins + column\n                ax = self.axes[i]\n                self._plots[i] = _ax_topomap(ax, layers, clip, clip_distance, sensorlabels, mark, mcolor, None, proj, res, im_interpolation, None, self._vlims, self._cmaps, self._contours, interpolation, head_radius, head_pos)\n\n        self._set_axtitle((str(t) for t in time), axes=self.axes[:len(time)])\n        TopoMapKey.__init__(self, self._topo_data)\n        SensorMapMixin.__init__(self, [h.sensors for h in self._plots])\n        self._show()\n\n    def _fill_toolbar(self, tb):\n        ColorMapMixin._fill_toolbar(self, tb)\n        SensorMapMixin._fill_toolbar(self, tb)\n\n    def _topo_data(self, event):\n        if event.inaxes:\n            ax_i = self.axes.index(event.inaxes)\n            p = self._plots[ax_i]\n            return p.data, p.title, p.proj\n\n\nclass TopoButterfly(ColorMapMixin, TimeSlicerEF, TopoMapKey, YLimMixin, XAxisMixin, EelFigure):\n    \"\"\"Butterfly plot with corresponding topomaps\n\n    Parameters\n    ----------\n    y : (list of) NDVar\n        Data to plot.\n    xax : None | categorial\n        Create a separate plot for each cell in this model.\n    ds : Dataset\n        If a Dataset is provided, data can be specified as strings.\n    sub : str | array\n        Specify a subset of the data.\n    vmax : scalar\n        Upper limits for the colormap (default is determined from data).\n    vmin : scalar\n        Lower limit for the colormap (default ``-vmax``).\n    cmap : str\n        Colormap (default depends on the data).\n    contours : int | sequence | dict\n        Contours to draw on topomaps. Can be an int (number of contours,\n        including ``vmin``\/``vmax``), a sequence (values at which to draw\n        contours), or a ``**kwargs`` dict (must contain at least the \"levels\"\n        key). Default is no contours.\n    color : matplotlib color\n        Color of the butterfly plots.\n    linewidth : scalar\n        Linewidth for plots (defult is to use ``matplotlib.rcParams``).\n    t\n        Time to display in the topomap.\n    proj : str\n        The sensor projection to use for topomaps.\n    res : int\n        Resolution of the topomaps (width = height = ``res``).\n    interpolation\n        Method for interpolating topo-map between sensors (default is based on\n        mne-python).\n    clip : bool | 'even' | 'circle'\n        Outline for clipping topomaps: 'even' to clip at a constant distance\n        (default), 'circle' to clip using a circle.\n    clip_distance : scalar\n        How far from sensor locations to clip (1 is the axes height\/width).\n    head_radius : scalar | tuple\n        Radius of the head outline drawn over sensors (on sensor plots with\n        normalized positions, 0.45 is the outline of the topomap); 0 to plot no\n        outline; tuple for separate (right, anterior) radius.\n        The default is determined automatically.\n    head_pos : scalar\n        Head outline position along the anterior axis (0 is the center, 0.5 is\n        the top end of the plot).\n    im_interpolation : str\n        Topomap image interpolation (see Matplotlib's\n        :meth:`~matplotlib.axes.Axes.imshow`). Matplotlib 1.5.3's SVG output\n        can't handle uneven aspect with ``interpolation='none'``, use\n        ``interpolation='nearest'`` instead.\n    sensorlabels\n        Show sensor labels. For 'name', any prefix common to all names\n        is removed; with 'fullname', the full name is shown.\n    mark : Sensor index\n        Sensors to mark in the topo-map. To highlight sensors in the butterfly\n        plot, consider using :meth:`NDVar.mask` on ``y``.\n    mcolor : matplotlib color\n        Color for marked sensors.\n    xlabel\n        X-axis label. By default the label is inferred from the data.\n    ylabel\n        Y-axis label. By default the label is inferred from the data.\n    xticklabels\n        Specify which axes should be annotated with x-axis tick labels.\n        Use ``int`` for a single axis, a sequence of ``int`` for multiple\n        specific axes, or one of ``'left' | 'bottom' | 'all' | 'none'``.\n    yticklabels\n        Specify which axes should be annotated with y-axis tick labels.\n        Use ``int`` for a single axis, a sequence of ``int`` for multiple\n        specific axes, or one of ``'left' | 'bottom' | 'all' | 'none'``.\n    axtitle : bool | sequence of str\n        Title for the individual axes. The default is to show the names of the\n        epochs, but only if multiple axes are plotted.\n    xlim : scalar | (scalar, scalar)\n        Initial x-axis view limits as ``(left, right)`` tuple or as ``length``\n        scalar (default is the full x-axis in the data).\n    ...\n        Also accepts :ref:`general-layout-parameters`.\n\n    Notes\n    -----\n    Topomap control:\n     - LMB click in a butterfly plot fixates the topomap time\n     - RMB click in a butterfly plot removes the time point, the topomaps\n       follow the mouse pointer\n     - ``.``: Increment the current topomap time (got right)\n     - ``,``: Decrement the current topomap time (go left)\n     - ``t``: open a ``Topomap`` plot for the time point under the mouse\n       pointer\n     - ``T``: open a larger ``Topomap`` plot with visible sensor names for the\n       time point under the mouse pointer\n\n    Navigation:\n     - ``↑``: scroll up\n     - ``↓``: scroll down\n     - ``←``: scroll left\n     - ``→``: scroll right\n     - ``home``: scroll to beginning\n     - ``end``: scroll to end\n     - ``f``: x-axis zoom in (reduce x axis range)\n     - ``d``: x-axis zoom out (increase x axis range)\n     - ``r``: y-axis zoom in (reduce y-axis range)\n     - ``c``: y-axis zoom out (increase y-axis range)\n    \"\"\"\n    _default_xlabel_ax = -2\n\n    def __init__(\n            self,\n            y: Union[NDVarArg, Sequence[NDVarArg]],\n            xax: CategorialArg = None,\n            ds: Dataset = None,\n            sub: IndexArg = None,\n            vmax: float = None,\n            vmin: float = None,\n            cmap: CMapArg = None,\n            contours: Union[int, Sequence, Dict] = None,\n            color: Any = None,\n            linewidth: float = None,\n            # topomap args\n            t: float = None,\n            proj: str = 'default',\n            res: int = None,\n            interpolation: InterpolationArg = None,\n            clip: Union[bool, str] = 'even',\n            clip_distance: float = 0.05,\n            head_radius: Union[float, Tuple[float, float]] = None,\n            head_pos: Union[float, Sequence[float]] = 0,\n            im_interpolation: str = None,\n            # sensor-map args\n            sensorlabels: SensorLabelsArg = None,\n            mark: IndexArg = None,\n            mcolor: ColorArg = None,\n            # layout\n            xlabel: Union[bool, str] = True,\n            ylabel: Union[bool, str] = True,\n            xticklabels: Union[str, int, Sequence[int]] = 'bottom',\n            yticklabels: Union[str, int, Sequence[int]] = 'left',\n            axtitle: Union[bool, Sequence[str]] = True,\n            frame: bool = True,\n            xlim: Union[float, Tuple[float, float]] = None,\n            **kwargs,\n    ):\n        data = PlotData.from_args(y, ('sensor', None), xax, ds, sub)\n        data._cannot_skip_axes(self)\n        xdim = data.dims[1]\n        self._topomap_data = data.for_plot(PlotType.IMAGE)\n\n        # create figure\n        row_titles = self._set_axtitle(axtitle, data, data.n_plots)\n        layout = VariableAspectLayout(data.n_plots, 3, 10, aspect=(None, 1), ax_frames=(frame, False), row_titles=row_titles, **kwargs)\n        EelFigure.__init__(self, data.frame_title, layout)\n\n        self.bfly_axes = self.axes[0::2]\n        self.topo_axes = self.axes[1::2]\n        self.bfly_plots = []\n        self.topo_plots = []\n        self.t_markers = []  # vertical lines on butterfly plots\n\n        ColorMapMixin.__init__(self, data.data, cmap, vmax, vmin, contours,\n                               self.topo_plots)\n\n        self._topo_kwargs = {\n            'clip': clip,\n            'clip_distance': clip_distance,\n            'head_radius': head_radius,\n            'head_pos': head_pos,\n            'proj': proj,\n            'contours': self._contours,\n            'res': res,\n            'interpolation': interpolation,\n            'im_interpolation': im_interpolation,\n            'sensorlabels': sensorlabels,\n            'mark': mark,\n            'mcolor': mcolor,\n        }\n\n        # plot epochs (x\/y are in figure coordinates)\n        for ax, layers in zip(self.bfly_axes, data.for_plot(PlotType.LINE)):\n            h = _ax_butterfly(ax, layers, 'time', 'sensor', mark, color, linewidth, self._vlims, clip)\n            self.bfly_plots.append(h)\n\n        # decorate axes\n        self._configure_axis_dim('x', data.time_dim, xlabel, xticklabels, self.bfly_axes)\n        self._configure_axis_data('y', data, ylabel, yticklabels, self.bfly_axes)\n\n        # setup callback\n        XAxisMixin._init_with_data(self, data.data, xdim, xlim, self.bfly_axes)\n        YLimMixin.__init__(self, self.bfly_plots + self.topo_plots)\n        TimeSlicerEF.__init__(self, xdim, data.time_dim, self.bfly_axes, False, initial_time=t)\n        TopoMapKey.__init__(self, self._topo_data)\n        self._t_label = None  # time label under lowest topo-map\n        self._frame .store_canvas()\n\n        self._show(crosshair_axes=self.bfly_axes)\n        self._init_controller()\n\n    def _fill_toolbar(self, tb):\n        ColorMapMixin._fill_toolbar(self, tb)\n\n    def _update_topo(self, t):\n        if not self.topo_plots:\n            data = self._topomap_data.sub_time(t)\n            for ax, layers in zip(self.topo_axes, data):\n                p = _ax_topomap(ax, layers, cmaps=self._cmaps, vlims=self._vlims, **self._topo_kwargs)\n                self.topo_plots.append(p)\n        else:\n            data = self._topomap_data.sub_time(t, data_only=True)\n            for p, layers in zip(self.topo_plots, data):\n                p.set_data(layers)\n\n    def _topo_data(self, event):\n        ax = event.inaxes\n        if ax is None:\n            return\n        p = self.bfly_plots[ax.id \/\/ 2]\n        if ax in self.bfly_axes:\n            t = event.xdata\n        elif ax in self.topo_axes:\n            t = self._current_time\n        else:\n            return\n        seg = [l.sub(time=t) for l in p.data]\n        return seg, f\"{ms(t)} ms\", self._topo_kwargs['proj']\n\n    def _on_leave_axes_status_text(self, event):\n        return \"Topomap: t = %.3f\" % self._current_time\n\n    def _update_time(self, t, fixate):\n        TimeSlicerEF._update_time(self, t, fixate)\n        self._update_topo(t)\n        if fixate:\n            # add time label\n            text = \"t = %i ms\" % round(t * 1e3)\n            if self._t_label:\n                self._t_label.set_text(text)\n            else:\n                ax = self.topo_axes[-1]\n                self._t_label = ax.text(.5, -0.1, text, ha='center', va='top')\n            self.canvas.draw()  # otherwise time label does not get redrawn\n        elif self._time_fixed:\n            self._t_label.remove()\n            self._t_label = None\n            self.canvas.draw()  # otherwise time label does not get redrawn\n        elif hasattr(self.canvas, 'redraw'):\n            self.canvas.redraw(self.topo_axes)\n\n\nclass _plt_topomap(_plt_im):\n    \"\"\"Topomap plot\n\n    Parameters\n    ----------\n    ...\n    im_frame : scalar\n        Empty space beyond outmost sensors in the im plot.\n    vmax : scalar\n        Override the colorspace vmax.\n    interpolation\n        Method for interpolating topo-map between sensors.\n    \"\"\"\n    _aspect = 'equal'\n\n    def __init__(\n            self,\n            ax: mpl.axes.Axes,\n            layer: DataLayer,\n            proj: str,\n            res: int,\n            im_interpolation: str,\n            vlims,\n            cmaps,\n            contours,\n            interpolation: InterpolationArg,\n            clip: str,\n            clip_distance: float,\n    ):\n        # store attributes\n        self._proj = proj\n        self._visible_data = layer.y.sensor._visible_sensors(proj)\n        self._grid = np.linspace(0, 1, res)\n        self._mgrid = tuple(np.meshgrid(self._grid, self._grid))\n        if interpolation is None and layer.y.x.dtype.kind in 'biu':\n            interpolation = 'nearest'\n        self._method = interpolation\n\n        # clip mask\n        if clip:\n            locs = layer.y.sensor.get_locs_2d(self._proj, frame=SENSORMAP_FRAME)\n            if clip == 'even':\n                hull = ConvexHull(locs)\n                points = locs[hull.vertices]\n                default_head_radius = sqrt(np.min(np.sum((points - [0.5, 0.5]) ** 2, 1)))\n                # find offset due to clip_distance\n                tangents = np.roll(points, -1, axis=0) - np.roll(points, 1, axis=0)\n                verticals = np.dot(tangents, [[0, -1], [1, 0]])\n                verticals \/= np.sqrt(np.sum(verticals ** 2, 1)[:, None])\n                verticals *= clip_distance\n                # apply offset\n                points += verticals\n                mask = mpl.patches.Polygon(points, transform=ax.transData)\n            elif clip == 'circle':\n                clip_radius = sqrt(np.max(np.sum((locs - [0.5, 0.5]) ** 2, 1)))\n                mask = mpl.patches.Circle((0.5, 0.5), clip_radius, transform=ax.transData)\n                default_head_radius = clip_radius\n            else:\n                raise ValueError('clip=%r' % (clip,))\n        else:\n            mask = None\n            default_head_radius = None\n\n        self._default_head_radius = default_head_radius\n        _plt_im.__init__(self, ax, layer, cmaps, vlims, contours, (0, 1, 0, 1), im_interpolation, mask)\n\n    def _data_from_ndvar(self, ndvar):\n        v = ndvar.get_data(('sensor',))\n        locs = ndvar.sensor.get_locs_2d(self._proj, frame=SENSORMAP_FRAME)\n        if self._visible_data is not None:\n            v = v[self._visible_data]\n            locs = locs[self._visible_data]\n\n        if self._method is None:\n            # interpolate data\n            xi, yi = self._mgrid\n\n            # code adapted from mne-python topmap _griddata()\n            xy = locs[:, 0] + locs[:, 1] * -1j\n            d = np.abs(xy - xy[:, None])\n            diagonal_step = len(locs) + 1\n            d.flat[::diagonal_step] = 1.\n\n            g = (d * d) * (np.log(d) - 1.)\n            g.flat[::diagonal_step] = 0.\n            try:\n                weights = linalg.solve(g, v.ravel())\n            except ValueError:\n                if np.isnan(v).any():\n                    raise NotImplementedError(\"Can't interpolate sensor data with NaN\")\n                unique_locs = np.unique(locs, axis=0)\n                if len(unique_locs) < len(locs):\n                    raise NotImplementedError(\"Error determining sensor map projection due to more than one sensor in a single location; try using a different projection.\")\n                raise\n\n            m, n = xi.shape\n            out = np.empty_like(xi)\n\n            g = np.empty(xy.shape)\n            for i in range(m):\n                for j in range(n):\n                    d = np.abs(xi[i, j] + -1j * yi[i, j] - xy)\n                    mask = np.where(d == 0)[0]\n                    if len(mask):\n                        d[mask] = 1.\n                    np.log(d, out=g)\n                    g -= 1.\n                    g *= d * d\n                    if len(mask):\n                        g[mask] = 0.\n                    out[i, j] = g.dot(weights)\n            return out\n        elif self._method == 'spline':\n            k = int(floor(sqrt(len(locs)))) - 1\n            tck = interpolate.bisplrep(locs[:, 1], locs[:, 0], v, kx=k, ky=k)\n            return interpolate.bisplev(self._grid, self._grid, tck)\n        else:\n            isnan = np.isnan(v)\n            if np.any(isnan):\n                nanmap = interpolate.griddata(locs, isnan, self._mgrid, self._method)\n                mask = nanmap > 0.5\n                v = np.where(isnan, 0, v)\n                vmap = interpolate.griddata(locs, v, self._mgrid, self._method)\n                np.place(vmap, mask, np.NaN)\n                return vmap\n            return interpolate.griddata(locs, v, self._mgrid, self._method)\n\n\nclass _ax_topomap(_ax_im_array):\n    \"\"\"Axes with a topomap\n\n    Parameters\n    ----------\n    mark : list of IDs\n        highlight a subset of the sensors\n    \"\"\"\n    def __init__(\n            self,\n            ax: matplotlib.axes.Axes,\n            layers: AxisData,\n            clip: str = 'even',  # even or circle (only applies if interpolation is None)\n            clip_distance: float=0.05,  # distance from outermost sensor for clip=='even'\n            sensorlabels: SensorLabelsArg = None,\n            mark: IndexArg = None,\n            mcolor: ColorArg = None,\n            mmarker=None,\n            proj: str = 'default',  # topomap projection method\n            res: int = None,  # topomap image resolution\n            im_interpolation: str = None,  # matplotlib imshow interpolation method\n            xlabel: Union[bool, str] = None,\n            vlims: dict = {},\n            cmaps: dict = {},\n            contours: dict = {},\n            interpolation: InterpolationArg = None,  # topomap interpolation method\n            head_radius: Union[float, Sequence[float]] = None,\n            head_pos: Union[float, Tuple[float, float]] = 0.,\n            head_linewidth: float = None,\n    ):\n        self.ax = ax\n        self.data = layers  # will not update from .set_data()\n        self.proj = proj\n        sensor_dim = layers.y0.sensor\n\n        if xlabel is True:\n            xlabel = layers.y0.name\n        if im_interpolation is None:\n            im_interpolation = 'bilinear'\n        if res is None:\n            res = 64 if interpolation is None else 100\n\n        ax.set_axis_off()\n        self.plots = [_plt_topomap(ax, layer, proj, res, im_interpolation, vlims, cmaps, contours, interpolation, clip, clip_distance) for layer in layers]\n\n        # head outline\n        if head_radius is None and clip == 'circle' and interpolation is None and sensor_dim._topomap_outlines(proj) == 'top':\n            head_radius = self.plots[0]._default_head_radius\n\n        # plot sensors\n        self.sensors = _plt_map2d(ax, sensor_dim, proj, 1, '.', 1, 'k', mark, mcolor, mmarker, sensorlabels, False, head_radius, head_pos, head_linewidth)\n\n        ax.set_aspect('equal')\n        ax.set_xlim(0, 1)\n        ax.set_ylim(0, 1)\n\n        if isinstance(xlabel, str):\n            x, y = ax.transData.inverted().transform(ax.transAxes.transform((0.5, 0)))\n            ax.text(x, y, xlabel, ha='center', va='top')\n\n    def set_ylim(self, bottom, top):  # Alias for YLimMixin\n        self.set_vlim(bottom, top)\n\n\n@dataclasses.dataclass\nclass _TopoWindow:\n    \"\"\"Helper class for TopoArray.\n\n    Maintains a topomap corresponding to one segment with flexible time point.\n    \"\"\"\n    ax: matplotlib.axes.Axes  # topomap-axes\n    parent: _ax_im_array  # array-plot\n    topomap_args: dict\n    connectionstyle: str = \"angle3,angleA=90,angleB=0\"\n    label_position: Literal['above', 'below', 'none'] = 'above'\n    color: ColorArg = UNAMBIGUOUS_COLORS['bluish green']\n    annotation_xy: Tuple[float, float] = (0.5, 1.05)\n    # internal plot handles\n    t_line = None\n    pointer = None\n    text_pointer = None\n    plot = None\n    t = None\n\n    def update(self, t):\n        if t is not None:\n            if self.t_line:\n                self.t_line.remove()\n            self.t_line = self.parent.ax.axvline(t, c=self.color)\n\n            t_str = f\"{ms(t)} ms\"\n            if self.pointer:\n                self.pointer.axes = self.parent.ax\n                self.pointer.xy = (t, 1)\n                if self.text_pointer:\n                    self.text_pointer.set_text(t_str)\n                self.pointer.set_visible(True)\n            else:\n                text = t_str if self.label_position == 'above' else ''\n                arrowprops = {'arrowstyle': '-', 'shrinkB': 0, 'color': self.color}\n                if self.connectionstyle:\n                    arrowprops['connectionstyle'] = self.connectionstyle\n                self.pointer = self.parent.ax.annotate(text, (t, 0), xycoords='data', xytext=self.annotation_xy, textcoords=self.ax.transData, horizontalalignment='center', verticalalignment='center', arrowprops=arrowprops, zorder=4)\n                if self.label_position == 'above':\n                    self.text_pointer = self.pointer\n                elif self.label_position == 'below':\n                    self.text_pointer = self.ax.text(0.5, 0, t_str, va='top', ha='center', transform=self.ax.transAxes)\n\n            if self.plot is None:\n                layers = self.parent.data.sub_time(t)\n                self.plot = _ax_topomap(self.ax, layers, **self.topomap_args)\n            else:\n                layers = self.parent.data.sub_time(t, data_only=True)\n                self.plot.set_data(layers)\n            self.t = t\n\n    def clear(self):\n        self.ax.cla()\n        self.ax.set_axis_off()\n        self.plot = None\n        self.t = None\n        if self.t_line:\n            self.t_line.remove()\n            self.t_line = None\n        if self.pointer:\n            self.pointer.remove()\n            self.pointer = None\n\n    def add_contour(self, meas, level, color):\n        if self.plot:\n            self.plot.add_contour(meas, level, color)\n\n    def set_cmap(self, cmap, meas):\n        if self.plot:\n            self.plot.set_cmap(cmap, meas)\n\n    def set_vlim(self, v, vmax=None, meas=None):\n        if self.plot:\n            self.plot.set_vlim(v, vmax, meas)\n\n\nclass TopoArray(ColorMapMixin, TopoMapKey, XAxisMixin, EelFigure):\n    \"\"\"Channel by sample plots with topomaps for individual time points\n\n    Parameters\n    ----------\n    y\n        Data to plot.\n    xax\n        Create a separate plot for each cell in this model.\n    ds\n        If a Dataset is provided, data can be specified as strings.\n    sub\n        Specify a subset of the data.\n    vmax\n        Upper limits for the colormap (default is determined from data).\n    vmin\n        Lower limit for the colormap (default ``-vmax``).\n    cmap\n        Colormap (default depends on the data).\n    contours\n        Contours to draw on topomaps. Can be an int (number of contours,\n        including ``vmin``\/``vmax``), a sequence (values at which to draw\n        contours), or a ``**kwargs`` dict (must contain at least the \"levels\"\n        key). Default is no contours.\n    ntopo\n        number of topomaps per array-plot.\n    t\n        Time points for topomaps.\n    xlim : scalar | (scalar, scalar)\n        Initial x-axis view limits as ``(left, right)`` tuple or as ``length``\n        scalar (default is the full x-axis in the data).\n    proj\n        The sensor projection to use for topomaps.\n    res\n        Resolution of the topomaps (width = height = ``res``).\n    interpolation\n        Method for interpolating topo-map between sensors (default is based on\n        mne-python).\n    clip : bool | 'even' | 'circle'\n        Outline for clipping topomaps: 'even' to clip at a constant distance\n        (default), 'circle' to clip using a circle.\n    clip_distance\n        How far from sensor locations to clip (1 is the axes height\/width).\n    head_radius\n        Radius of the head outline drawn over sensors (on sensor plots with\n        normalized positions, 0.45 is the outline of the topomap); 0 to plot no\n        outline; tuple for separate (right, anterior) radius.\n        The default is determined automatically.\n    head_pos\n        Head outline position along the anterior axis (0 is the center, 0.5 is\n        the top end of the plot).\n    im_interpolation\n        Topomap image interpolation (see Matplotlib's\n        :meth:`~matplotlib.axes.Axes.imshow`). Matplotlib 1.5.3's SVG output\n        can't handle uneven aspect with ``interpolation='none'``, use\n        ``interpolation='nearest'`` instead.\n    sensorlabels\n        Show sensor labels. For 'name', any prefix common to all names\n        is removed; with 'fullname', the full name is shown. Set to ``''`` to\n        hide sensor position markers completely.\n    mark : Sensor index\n        Sensors which to mark.\n    mcolor : matplotlib color\n        Color for marked sensors.\n    axtitle\n        Title for the individual axes. The default is to show the names of the\n        epochs, but only if multiple axes are plotted.\n    xlabel\n        X-axis label. By default the label is inferred from the data.\n    ylabel\n        Y-axis label. By default the label is inferred from the data.\n    xticklabels\n        Specify which axes should be annotated with x-axis tick labels.\n        Use ``int`` for a single axis, a sequence of ``int`` for multiple\n        specific axes, or one of ``'left' | 'bottom' | 'all' | 'none'``.\n    yticklabels\n        Specify which axes should be annotated with y-axis tick labels.\n        Use ``int`` for a single axis, a sequence of ``int`` for multiple\n        specific axes, or one of ``'left' | 'bottom' | 'all' | 'none'``.\n    connectionstyle\n        Style for the connections between the image array-plot and the\n        topo-maps. Set to ``''`` for straight connections. See\n        `Matplotlib demo <https:\/\/matplotlib.org\/stable\/gallery\/userdemo\/connectionstyle_demo.html>`_.\n    connection_color\n        Color for connection line.\n    topo_labels\n        Where to label time on topo-maps.\n    ...\n        Also accepts :ref:`general-layout-parameters`.\n\n    Notes\n    -----\n     - LMB click on a topomap selects it for tracking the mouse pointer\n         - LMB on the array plot fixates the topomap time point\n     - RMB on a topomap removes the topomap\n\n    \"\"\"\n    _make_axes = False\n\n    def __init__(\n            self,\n            y: Union[NDVarArg, Sequence[NDVarArg]],\n            xax: CategorialArg = None,\n            ds: Dataset = None,\n            sub: IndexArg = None,\n            vmax: float = None,\n            vmin: float = None,\n            cmap: CMapArg = None,\n            contours: Union[int, Sequence, Dict] = None,\n            ntopo: int = None,\n            t: Sequence[float] = (),\n            xlim: Union[float, Tuple[float, float]] = None,\n            # topomap args\n            proj: str = 'default',\n            res: int = None,\n            interpolation: InterpolationArg = None,\n            clip: Union[bool, str] = 'even',\n            clip_distance: float = 0.05,\n            head_radius: Union[float, Tuple[float, float]] = None,\n            head_pos: Union[float, Sequence[float]] = 0,\n            im_interpolation: str = None,\n            # sensor-map args\n            sensorlabels: SensorLabelsArg = None,\n            mark: IndexArg = None,\n            mcolor: ColorArg = None,\n            # layout\n            axtitle: Union[bool, Sequence[str]] = True,\n            xlabel: Union[bool, str] = True,\n            ylabel: Union[bool, str] = True,\n            xticklabels: Union[str, int, Sequence[int]] = 'bottom',\n            yticklabels: Union[str, int, Sequence[int]] = 'left',\n            connectionstyle: str = \"angle3,angleA=90,angleB=0\",\n            connection_color: ColorArg = UNAMBIGUOUS_COLORS['bluish green'],\n            topo_labels: Literal['above', 'below', 'none'] = 'above',\n            **kwargs,\n    ):\n        if ntopo is None:\n            ntopo = len(t) if t else 3\n\n        data = PlotData.from_args(y, ('time', 'sensor'), xax, ds, sub).for_plot(PlotType.IMAGE)\n\n        # create figure\n        if 'ncol' not in kwargs and 'nrow' not in kwargs:\n            kwargs['nrow'] = 1\n        layout = Layout(data.plot_used, 1.5, 3, tight=False, **kwargs)\n        EelFigure.__init__(self, data.frame_title, layout)\n        all_plots = []\n        ColorMapMixin.__init__(self, data.data, cmap, vmax, vmin, contours, all_plots)\n        TopoMapKey.__init__(self, self._topo_data)\n\n        # save important properties\n        self._data = data\n        self._ntopo = ntopo\n        self._default_xlabel_ax = -1 - ntopo\n        self._proj = proj\n\n        # prepare axes\n        if layout.user_axes:\n            self.axes = layout.user_axes\n        else:\n            x_frame_l = .6 \/ layout.axw \/ data.n_plots\n            x_frame_r = .025 \/ data.n_plots\n            gs = self.figure.add_gridspec(layout.nrow * 2, layout.ncol * ntopo, left=x_frame_l, right=1 - x_frame_r, bottom=.05, top=.9, wspace=.1, hspace=.3)\n            if layout.nrow == 1:\n                for col, used in enumerate(data.plot_used):\n                    if not used:\n                        continue\n                    self.figure.add_subplot(gs[0, col*ntopo:(col+1)*ntopo], picker=True)\n                    for j in range(ntopo):\n                        self.figure.add_subplot(gs[1, col*ntopo+j], picker=True, xticks=[], yticks=[])\n            elif layout.ncol == 1:\n                for row, used in enumerate(data.plot_used):\n                    if not used:\n                        continue\n                    self.figure.add_subplot(gs[row*2, 0:ntopo], picker=True)\n                    for j in range(ntopo):\n                        self.figure.add_subplot(gs[row*2+1, j], picker=True, xticks=[], yticks=[])\n            else:\n                raise ValueError(\"Layout with multiple columns and rows; set either ncol=1 or nrow=1\")\n            self.axes = self.figure.axes\n\n        # im_array plots\n        self._array_axes = []\n        self._array_plots = []\n        self._topo_windows = []\n        topomap_args = dict(clip=clip, clip_distance=clip_distance, sensorlabels=sensorlabels, mark=mark, mcolor=mcolor, proj=proj, res=res, im_interpolation=im_interpolation, vlims=self._vlims, cmaps=self._cmaps, contours=self._contours, interpolation=interpolation, head_radius=head_radius, head_pos=head_pos)\n        for i, layers in enumerate(data):\n            ax_i = i * (ntopo + 1)\n            ax = self.axes[ax_i]\n            ax.ID = i\n            ax.type = 'main'\n            im_plot = _ax_im_array(ax, layers, 'time', im_interpolation, self._vlims, self._cmaps, self._contours)\n            self._array_axes.append(ax)\n            self._array_plots.append(im_plot)\n            if i > 0:\n                ax.yaxis.set_visible(False)\n\n            # topo plots\n            for j in range(ntopo):\n                ax = self.axes[ax_i + 1 + j]\n                ax.ID = i * ntopo + j\n                ax.type = 'window'\n                win = _TopoWindow(ax, im_plot, topomap_args, connectionstyle, topo_labels, connection_color)\n                self.axes.append(ax)\n                self._topo_windows.append(win)\n        all_plots.extend(self._array_plots)\n        all_plots.extend(self._topo_windows)\n\n        # if t argument is provided, set topo-map time points\n        if t:\n            if np.isscalar(t):\n                t = [t]\n            self.set_topo_ts(*t)\n\n        self._set_axtitle(axtitle, data, self._array_axes)\n        self._configure_axis_dim('x', data.y0.time, xlabel, xticklabels, self._array_axes)\n        self._configure_axis_dim('y', 'sensor', ylabel, yticklabels, self._array_axes, False, data.data)\n\n        # setup callback\n        XAxisMixin._init_with_data(self, data.data, 'time', xlim, self._array_axes)\n        self._selected_window = None\n        self.canvas.mpl_connect('pick_event', self._pick_handler)\n        self._frame .store_canvas()\n        self._show(crosshair_axes=self._array_axes)\n\n    def _fill_toolbar(self, tb):\n        ColorMapMixin._fill_toolbar(self, tb)\n\n    def _topo_data(self, event):\n        ax = event.inaxes\n        if ax in self._array_axes:\n            t = event.xdata\n            data = self._array_plots[ax.ID].data.sub_time(t)\n        else:\n            topo_window = self._topo_windows[ax.ID]\n            t = topo_window.t\n            if t is None:\n                return\n            data = topo_window.plot.data\n        return data, f\"{ms} ms\", self._proj\n\n    def _iter_plots(self):\n        \"Iterate through non-empty plots\"\n        yield from self._array_plots\n        for w in self._topo_windows:\n            if w.plot is not None:\n                yield w.plot\n\n    def set_cmap(self, cmap, meas=None):\n        \"\"\"Change the colormap\n\n        Parameters\n        ----------\n        cmap : str | colormap\n            New colormap.\n        meas : None | str\n            Measurement to which to apply the colormap. With None, it is\n            applied to all.\n        \"\"\"\n        self._cmaps[meas] = cmap\n        for p in self._iter_plots():\n            p.set_cmap(cmap, meas)\n        self.draw()\n\n    def set_topo_t_single(self, topo_id, t):\n        \"\"\"\n        Set the time for a single topomap.\n\n        Parameters\n        ----------\n        topo_id : int\n            Index of the topomap (numbered throughout the figure).\n        t : scalar or ``None``\n            time point; ``None`` clears the topomap\n        \"\"\"\n        # get window ax\n        w = self._topo_windows[topo_id]\n        w.clear()\n\n        if t is not None:\n            w.update(t)\n\n        self.canvas.draw()\n\n    def set_topo_t(self, topo_id, t):\n        \"\"\"\n        Set the time point for a topo-map (same for all array plots)\n\n        Parameters\n        ----------\n        topo_id : int\n            Index of the topomap (numberd for each array-plot).\n        t : scalar or ``None``\n            time point; ``None`` clears the topomap\n\n        See Also\n        --------\n        .set_topo_ts : set several topomap time points at once\n        .set_topo_t_single : set the time point of a single topomap\n        \"\"\"\n        for i in range(len(self._array_plots)):\n            _topo = self._ntopo * i + topo_id\n            self.set_topo_t_single(_topo, t)\n\n    def set_topo_ts(self, *t_list):\n        \"\"\"Set the time points displayed in topo-maps across all array-plots\"\"\"\n        for i, t in enumerate(t_list):\n            self.set_topo_t(i, t)\n\n    def _pick_handler(self, pickevent):\n        mouseevent = pickevent.mouseevent\n        ax = pickevent.artist\n        if ax.type == 'window':\n            button = mouseevent.button  # 1: Left\n            window = self._topo_windows[ax.ID]\n            if button == 1:\n                self._selected_window = window\n            elif button in (2, 3):\n                Id = window.ax.ID % self._ntopo\n                self.set_topo_t(Id, None)\n            else:\n                pass\n        elif (ax.type == 'main') and (self._selected_window is not None):\n            self._selected_window.clear()  # to side track pdf export transparency issue\n            # update corresponding topo_windows\n            t = mouseevent.xdata\n            Id = self._selected_window.ax.ID % self._ntopo\n            self.set_topo_t(Id, t)\n\n            self._selected_window = None\n            self.canvas.draw()\n\n    def _on_motion_sub(self, event):\n        if (self._selected_window is not None and event.inaxes and\n                event.inaxes.type == 'main' and\n                event.xdata in self._data.plot_data[event.inaxes.ID].y0.time):\n            self._selected_window.update(event.xdata)\n            return {self._selected_window.ax}\n        return set()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_548","text":"#!\/usr\/bin\/env python\n\nimport gym\nimport mj_transfer\nfrom mj_transfer.robots import NewBrightEnv\n\nfrom time import time, sleep\nfrom scipy.misc import imshow, toimage, imsave\n\nFREQUENCY = 0.25\n\ntry:\n    # Windows\n    from msvcrt import getch\nexcept ImportError:\n    # Unix\n    import sys\n    import tty\n    import termios\n\n    def getch():\n        fd = sys.stdin.fileno()\n        old = termios.tcgetattr(fd)\n        try:\n            tty.setraw(fd)\n            return sys.stdin.read(1)\n        finally:\n            termios.tcsetattr(fd, termios.TCSADRAIN, old)\n\nif __name__ == '__main__':\n    env = NewBrightEnv('192.168.42.1', 5000)\n    time_init = time()\n    env.reset()\n    while True:\n        action = [0.0, 0.0, 0.0, 0.0]\n        c = getch()\n        # c = None\n        # sleep(0.2)\n        if c == 'q':\n            break\n        if c == 'w':\n            action[0] = 1.0\n        if c == 's':\n            action[1] = 1.0\n        if c == 'd':\n            action[2] = 1.0\n        if c == 'a':\n            action[3] = 1.0\n\n        # TODO: Move the following code in env.step ?\n        # TODO: Keep everything to 1.0 if key pressed ?\n        # TODO: Deal with opposing directions ?\n        env.step(action)\n        # env.render()\n    env.disconnect()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_549","text":"import matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport scipy as sp\nimport matplotlib.cm as cm\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\n\n\nwith open(\"output.txt\") as jurassicpark:\n\tjurassicpark_txt = jurassicpark.read()\n\t#jurassicpark.close()\n\tjurassicpark_tokens = jurassicpark_txt.split() #with no arguments, splits on whitespace\n\tprint(len(jurassicpark_tokens))\n\nlastword = jurassicpark_tokens[-1]\nprint(lastword)\n\nstrangestring = \",\".join(jurassicpark_tokens)\nstrangestring[:100]\n\njurassicparklc_tokens = [word.lower() for word in jurassicpark_tokens]\ncount = jurassicparklc_tokens.count(\"had\")\nprint(count)\n\n#find unique set of words, count how often used with count method on lists\nuniquelctokens = set(jurassicparklc_tokens)\t\n\ntokendict = {}\nfor ut in uniquelctokens:\n\ttokendict[ut] = jurassicparklc_tokens.count(ut)\n\nel = sorted(tokendict.items(), key= lambda args: args[1], reverse = True)[:100]\nprint(el)\n\ntopfreq = el[:20]\nprint(topfreq)\nwith sns.axes_style('whitegrid'):\n\tpos = np.arange(len(topfreq))\n\tplt.bar(pos, [e[1] for e in topfreq]);\n\tplt.xticks(pos+0.4, [e[0] for e in topfreq]);\n\tplt.xlabel(\"Words\")\n\tplt.ylabel(\"Count\")\n\tplt.title(\"Word Frequency in output text\")\n\nplt.show()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_550","text":"\"\"\"\n@file\n@brief  Function to solve the problem of the\n`Route Inspection Problem <https:\/\/en.wikipedia.org\/wiki\/Route_inspection_problem>`_.\n\"\"\"\nimport math\nimport random\nimport fractions\n\n\nclass SolutionException(Exception):\n    \"\"\"\n    wrong solution\n    \"\"\"\n    pass\n\n\ndef haversine_distance(lat1, lng1, lat2, lng2):\n    \"\"\"\n    Computes `Haversine formula <http:\/\/en.wikipedia.org\/wiki\/Haversine_formula>`_.\n\n    .. index:: Haversine\n\n    @param      lat1    lattitude\n    @param      lng1    longitude\n    @param      lat2    lattitude\n    @param      lng2    longitude\n    @return             distance\n    \"\"\"\n    radius = 6371\n    dlat = math.radians(lat2 - lat1)\n    dlon = math.radians(lng2 - lng1)\n    a = math.sin(dlat \/ 2) * math.sin(dlat \/ 2) + math.cos(math.radians(lat1)) \\\n        * math.cos(math.radians(lat2)) * math.sin(dlon \/ 2) * math.sin(dlon \/ 2)\n    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))\n    d = radius * c\n    return d\n\n\ndef distance_solution(edges_index, edges, distances, solution, exc=True):\n    \"\"\"\n    Checks if a solution is really a solution and returns the distance of it,\n    None if it is not a solution. The function does not case about the order.\n\n    @param      edges_index     list of indices of edges (if None --> range(len(edges))\n    @param      edges           list of tuple (vertex A, vertex B)\n    @param      distances       list of distances of each edge\n    @param      solution        proposed solutions (list of edge indices)\n    @param      exc             raises an exception in case of error\n    \"\"\"\n    if edges_index is None:\n        edges_index = list(range(len(edges)))\n    indices = set(edges_index)\n    solset = set(solution)\n    if len(indices) != len(solset):\n        if exc:\n            raise SolutionException(\"Different number of distinct edges:\\nexpected={0} got={1}\\n\"\n                                    \"Did you cover all the edges?\".format(len(indices), len(solset)))\n        return None\n\n    for s in solution:\n        if s not in indices:\n            raise SolutionException(\n                \"Index {0} is not in edges_index\".format(s))\n\n    doubles = {}\n    for a, b in edges:\n        if a > b:\n            a, b = b, a\n        if (a, b) in doubles:\n            if exc:\n                raise SolutionException(\n                    \"Edge {0} is duplicated in edges.\".format((a, b)))\n            return None\n        doubles[a, b] = 1\n\n    corres = {e: i for i, e in enumerate(edges_index)}\n    degrees = {}\n    for s in solution:\n        a, b = edges[corres[s]]\n        degrees[a] = degrees.get(a, 0) + 1\n        degrees[b] = degrees.get(b, 0) + 1\n\n    odd, even = 0, 0\n    for d in degrees.values():\n        if d % 2 == 0:\n            even += 1\n        else:\n            odd += 1\n\n    if odd > 2:\n        if exc:\n            red = list(sorted([(k, v)\n                               for k, v in degrees.items() if v % 2 != 0]))\n            if len(red) > 10:\n                red = red[:10] + [\"...\"]\n            raise SolutionException(\n                \"Are you sure? The path is inconsistent. Some help:\\n\" + str(red))\n        return None\n    else:\n        return sum(distances[corres[s]] for s in solution)\n\n\ndef compute_degrees(edges):\n    \"\"\"\n    Compute the degree of vertices.\n\n    @param      edges       list of tuple\n    @return                 dictionary {key: degree}\n    \"\"\"\n    res = {}\n    for a, b in edges:\n        res[a] = res.get(a, 0) + 1\n        res[b] = res.get(b, 0) + 1\n    return res\n\n\ndef euler_path(edges_index, edges, solution):\n    \"\"\"\n    Computes an Eulerian path.\n\n    .. index:: Eulerian\n\n    @param      edges_index     list of indices of edges (if None --> range(len(edges))\n    @param      edges           list of tuple (vertex A, vertex B)\n    @param      solution        proposed solutions (list of edge indices)\n    @return                     path, list of edges indices\n\n    The function assumes every vertex in the graph defined by *edges*\n    has an even degree.\n    \"\"\"\n    if edges_index is None:\n        edges_index = range(len(edges))\n    pos = {k: i for i, k in enumerate(edges_index)}\n    indices = [pos[s] for s in solution]\n    edges = [edges[i] for i in indices]\n\n    degrees = compute_degrees(edges)\n    odd = {k: v for k, v in degrees.items() if v % 2 == 1}\n    if len(odd) not in (0, 2):\n        odd = list(sorted((k, v) for k, v in odd.items()))\n        if len(odd) > 10:\n            odd = odd[:10] + [\"...\"]\n        raise SolutionException(\n            \"Some vertices have an odd degree. This is not allowed.\\n\" + str(odd))\n\n    if len(odd) == 2:\n        # we add an extra edge which we remove later\n        odd = list(odd.keys())\n        remove = (odd[0], odd[1])\n        edges.append(remove)\n    else:\n        remove = None\n\n    res = _euler_path(edges)\n    pathi = [_[1][0] for _ in res]\n    if remove is not None:\n        index = pathi.index(len(edges) - 1)\n        if index == 0:\n            pathi = pathi[1:]\n        elif index == len(edges) - 1:\n            pathi = pathi[:-1]\n        else:\n            pathi = pathi[index + 1:] + pathi[:index]\n    pathi = [solution[i] for i in pathi]\n    return pathi\n\n\ndef _euler_path(edges):\n    \"\"\"\n    Computes an Eulerian path.\n\n    @param      edges           edges\n    @return                     path, list of (vertex,edge)\n\n    The function assumes every vertex in the graph defined by *edges*\n    has an even degree.\n    \"\"\"\n    alledges = {}\n    edges_from = {}\n    for i, k in enumerate(edges):\n        if isinstance(k, list):\n            k = tuple(k)\n        v = (i,) + k\n        alledges[k] = v\n        a, b = k\n        alledges[b, a] = alledges[a, b]\n        if a not in edges_from:\n            edges_from[a] = []\n        if b not in edges_from:\n            edges_from[b] = []\n        edges_from[a].append(alledges[a, b])\n        edges_from[b].append(alledges[a, b])\n\n    degre = {}\n    for a, v in edges_from.items():\n        t = len(v)\n        degre[t] = degre.get(t, 0) + 1\n\n    two = [a for a, v in edges_from.items() if len(v) == 2]\n    odd = [a for a, v in edges_from.items() if len(v) % 2 == 1]\n    if len(odd) not in (0, 2):\n        add = \"\\n\" + str(odd) if len(odd) < 10 else \"\"\n        raise SolutionException(\n            \"Some vertices have an odd degree. This is not allowed.\" + add)\n\n    begin = two[0]\n\n    # checking\n    for v, le in edges_from.items():\n        for e in le:\n            to = e[1] if v != e[1] else e[2]\n            if to not in edges_from:\n                raise SolutionException(\n                    \"Unable to find vertex {0} for edge ({0},{1}).\".format(to, v))\n            if to == v:\n                raise SolutionException(\"Circular edge {0}.\".format(to))\n\n    # loop\n    path = _explore_path(edges_from, begin)\n    for p in path:\n        if len(p) == 0:\n            raise NotImplementedError(\"This exception should not happen.\")\n    while len(edges_from) > 0:\n        start = None\n        for i, p in enumerate(path):\n            if p[0] in edges_from:\n                start = i, p\n                break\n        sub = _explore_path(edges_from, start[1][0])\n        i = start[0]\n        path[i:i + 1] = path[i:i + 1] + sub\n    return path\n\n\ndef _delete_edge(edges_from, n, to):\n    \"\"\"\n    Removes an edge from the graph.\n\n    @param      edges_from      structure which contains the edges (will be modified)\n    @param      n               first vertex\n    @param      to              second vertex\n    @return                     the edge\n    \"\"\"\n    le = edges_from[to]\n    f = None\n    for i, e in enumerate(le):\n        if (e[1] == to and e[2] == n) or (e[2] == to and e[1] == n):\n            f = i\n            break\n\n    assert f is not None\n    del le[f]\n    if len(le) == 0:\n        del edges_from[to]\n\n    le = edges_from[n]\n    f = None\n    for i, e in enumerate(le):\n        if (e[1] == to and e[2] == n) or (e[2] == to and e[1] == n):\n            f = i\n            break\n\n    assert f is not None\n    keep = le[f]\n    del le[f]\n    if len(le) == 0:\n        del edges_from[n]\n\n    return keep\n\n\ndef _explore_path(edges_from, begin):\n    \"\"\"\n    Explores an Eulerian path, remove used edges from *edges_from*.\n\n    @param      edges_from      structure which contains the edges (will be modified)\n    @param      begin           first vertex to use\n    @return                     path\n    \"\"\"\n    path = [(begin, None)]\n    stay = True\n    while stay and len(edges_from) > 0:\n\n        n = path[-1][0]\n        if n not in edges_from:\n            # fin\n            break\n        le = edges_from[n]\n\n        if len(le) == 1:\n            h = 0\n            e = le[h]\n            to = e[1] if n != e[1] else e[2]\n        else:\n            to = None\n            nb = 100\n            while to is None or to == begin:\n                h = random.randint(0, len(le) - 1) if len(le) > 1 else 0\n                e = le[h]\n                to = e[1] if n != e[1] else e[2]\n                nb -= 1\n                if nb < 0:\n                    raise NotImplementedError(\n                        \"Algorithm issue {0}\".format(len(path)))\n\n        if len(edges_from[to]) == 1:\n            if begin != to:\n                raise NotImplementedError(\"Wrong algorithm.\")\n            stay = False\n\n        keep = _delete_edge(edges_from, n, to)\n        path.append((to, keep))\n\n    return path[1:]\n\n\ndef distance_vertices(edges, vertices, distances):\n    \"\"\"\n    Computes the length of edges if distances is None.\n\n    @param      edges           list of tuple (vertex A, vertex B)\n    @param      vertices        locations of the vertices\n    @param      distances       distances (None or list of floats)\n    @return                     distances (list of float)\n    \"\"\"\n    if distances is None:\n        distances = []\n    while len(distances) < len(edges):\n        distances.append(None)\n    for i, edge in enumerate(edges):\n        if distances[i] is not None:\n            continue\n        a, b = edge\n        va = vertices[a]\n        vb = vertices[b]\n        d = haversine_distance(va[0], va[1], vb[0], vb[1])\n        distances[i] = d\n    return distances\n\n\ndef bellman_distances(edges, distances, fLOG=None):\n    \"\"\"\n    Computes shortest distances between all vertices.\n    It assumes edges are symmetric.\n\n    @param      edges           list of tuple (vertex A, vertex B)\n    @param      distances       distances (list of floats)\n    @param      fLOG            logging function\n    @return                     dictionary of distances\n\n    This function could be implemented based on\n    `shortest_path <https:\/\/docs.scipy.org\/doc\/scipy\/reference\/generated\/scipy.sparse.csgraph.shortest_path.html>`_.\n    \"\"\"\n    dist = {(a, b): d for d, (a, b) in zip(distances, edges)}\n    dist.update({(b, a): d for d, (a, b) in zip(distances, edges)})\n    dist0 = dist.copy()\n\n    iter = 0  # pylint: disable=W0622\n    up = dist\n    while len(up) > 0:\n        iter += 1\n        up = {}\n        for (a, b), d1 in dist.items():\n            if (a, b) not in dist0 and (a, b) not in up:\n                # no need to continue as no update during the last iteration\n                continue\n            for (aa, bb), d2 in dist.items():\n                # not the most efficient\n                if b == aa and a != bb:\n                    d = d1 + d2\n                    if (a, bb) not in dist or dist[a, bb] > d:\n                        up[a, bb] = d\n                        up[bb, a] = d\n        dist.update(up)\n        if fLOG:\n            sum_values = sum(dist.values())\n            mes = \"iteration={0} modif={1} #dist={2} sum_values={3} avg={4}\".format(\n                iter, len(up), len(dist), sum_values, sum_values \/ len(dist))\n            fLOG(\"[bellman_distances] \" + mes)\n\n    return dist\n\n\ndef dijkstra_path(edges, distances, va, vb):\n    \"\"\"\n    Returns the best path between two vertices.\n    Uses `Dikjstra <https:\/\/en.wikipedia.org\/wiki\/Dijkstra%27s_algorithm>`_ algorithm.\n\n    @param      edges       list of edges.\n    @param      distances   list of distances\n    @param      va          first vertex\n    @param      vb          last vertex\n    @return                 list of edges\n\n    This function could be implemented based on\n    `shortest_path <https:\/\/docs.scipy.org\/doc\/scipy\/reference\/generated\/scipy.sparse.csgraph.shortest_path.html>`_.\n    \"\"\"\n    dist = {va: 0}\n    prev = {va: None}\n    modif = 1\n    while modif > 0:\n        modif = 0\n        for (a, b), d in zip(edges, distances):\n            if a in dist:\n                d2 = dist[a] + d\n                if b not in dist or dist[b] > d2:\n                    dist[b] = d2\n                    prev[b] = a\n                    modif += 1\n            if b in dist:\n                d2 = dist[b] + d\n                if a not in dist or dist[a] > d2:\n                    dist[a] = d2\n                    prev[a] = b\n                    modif += 1\n    rev = {(a, b): i for i, (a, b) in enumerate(edges)}\n    rev.update({(b, a): i for i, (a, b) in enumerate(edges)})\n    path = []\n    v = vb\n    while v is not None:\n        path.append(v)\n        v = prev[v]\n    path.reverse()\n    return [rev[a, b] for a, b in zip(path[:-1], path[1:])]\n\n\ndef matching_vertices(distances, algo=\"blossom\"):\n    \"\"\"\n    Finds the best match between vertices.\n\n    @param      distances       result of function @bellman_distances but\n                                only for odd vertices (odd = odd degree),\n                                dictionary { (vi,vj) : distance}\n    @param      algo            algorithm (see below)\n    @return                     sequences of best matches.\n\n    If ``algo=='hungarian'``,\n    the function relies on `linear_sum_assignment\n    <https:\/\/docs.scipy.org\/doc\/scipy-0.18.1\/reference\/generated\/scipy.optimize.linear_sum_assignment.html>`_\n    from `scipy <https:\/\/docs.scipy.org\/doc\/scipy-0.18.1\/>`_ which uses the\n    `Hungarian Algorithm <https:\/\/en.wikipedia.org\/wiki\/Hungarian_algorithm>`_.\n    Vertex index do not have to start from zero and be continuous.\n    The function will handle that particular case. However, the method\n    works for a bi-partite matching and is not suitable here unless\n    the algorithm is modified. Not done (yet?).\n\n    If ``algo=='blossom'``, it uses the\n    `Blossom algorithm <https:\/\/en.wikipedia.org\/wiki\/Blossom_algorithm>`_\n    which is known to be in :math:`O(n^3)` and finds the optimal matching.\n\n    If ``algo=='basic'``, the function sorts the distances\n    by increasing order and builds new edges as they come in this list.\n    It does not return an optimal solution but is much faster\n    when the graph is big.\n    \"\"\"\n    if not isinstance(distances, dict):\n        raise TypeError(\n            \"Unexpected type for distances, this should be a dictionary.\")\n    from numpy import empty\n    from scipy.optimize import linear_sum_assignment\n    unique = set(_[0] for _ in distances) | set(_[1] for _ in distances)\n    mapping = {}\n    rev = {}\n    for s in unique:\n        n = len(mapping)\n        mapping[s] = n\n        rev[n] = s\n    mx = len(mapping)\n\n    # Hungarian algorithm\n    if algo == \"hungarian\":\n        cost = empty((mx, mx))\n        mx = abs(max(distances.values())) * len(mapping) * 10\n        cost[:] = mx\n        for (i, j), v in distances.items():\n            if i == j:\n                raise ValueError(\n                    \"Unreasonable case: {0} == {1}, v={2}\".format(i, j, v))\n            cost[mapping[i], mapping[j]] = v\n\n        row_ind, col_ind = linear_sum_assignment(   # pylint: disable=W0632\n            cost)   # pylint: disable=W0632\n        pairs = [(rev[i], rev[j]) for i, j in zip(row_ind, col_ind)]\n        for a, b in pairs:\n            if a == b:\n                raise ValueError(\"Issue with one pair a == b.\\n{0}\".format(\n                    \"\\n\".join(str(_) for _ in pairs)))\n\n        # we remove duplicates\n        done = set()\n        final = []\n        for a, b in pairs:\n            if (a, b) not in done:\n                final.append((a, b))\n                done.add((b, a))\n        if len(final) * 2 != len(pairs):\n            mes = \"final={0}\\n{3}={1}\\ncost\\n{2}\".format(\n                final, pairs, cost, algo)\n            raise ValueError(\n                \"Did you use the tweak? The matching should be symmetric.\\n\" + mes)\n        return final\n    elif algo == \"basic\":\n        # we sort pair by increasing order\n        dists = [(v, i, j) for (i, j), v in distances.items()]\n        dists.sort()\n\n        # the graph is fully connected so we don't need to check\n        # if selecting an edge leads to an impossible solution\n        vdone = set()\n        pairs = []\n        for v, i, j in dists:\n            if i not in vdone and j not in vdone:\n                pairs.append((i, j))\n                vdone.add(i)\n                vdone.add(j)\n        return pairs\n\n    elif algo == \"blossom\":\n        from .blossom import Vertex, StructureUpToDate, TreeStructureChanged, MaximumDualReached, INF\n\n        vertices = {}\n        for v in mapping:\n            vertices[v] = Vertex(v)\n        for (i, j), v in distances.items():\n            f = fractions.Fraction(v)\n            vertices[i].add_edge_to(vertices[j], f)\n\n        def update_tree_structures(roots):\n            try:\n                while True:\n                    try:\n                        for root in roots:\n                            root.alter_tree(roots)\n                        raise StructureUpToDate()\n                    except TreeStructureChanged:\n                        pass\n            except StructureUpToDate:\n                pass\n\n        def get_max_delta(roots):\n            if len(roots) == 0:\n                raise MaximumDualReached()\n            delta = INF\n            for root in roots:\n                delta = min(delta, root.get_max_delta())\n            assert delta >= 0\n            return delta\n\n        roots = set(vertices.values())\n\n        try:\n            while True:\n                delta = get_max_delta(roots)\n                for root in roots:\n                    root.adjust_charge(delta)\n                update_tree_structures(roots)\n        except MaximumDualReached:\n            # done\n            pass\n\n        M = set()\n        for v in vertices.values():\n            M.update(e for e in v.edges if e.selected)\n\n        pairs = [e.extremities for e in M]\n        return pairs\n    else:\n        raise NotImplementedError(\"Not recognized: {0}\".format(algo))\n\n\ndef best_euler_path(edges, vertices, distances, edges_index=None, algo=\"blossom\", fLOG=None):\n    \"\"\"\n    Computes the final solution for the Eulerian path.\n\n    @param      edges           edges (list of tuple)\n    @param      vertices        location of the vertices (not needed if distances are filled)\n    @param      distances       distances for each edge (list of distance)\n    @param      edges_index     list of indices of edges (if None --> range(len(edges))\n    @param      algo            algorithm to use to computes the matching\n                                (see @see fn matching_vertices)\n    @param      fLOG            logging function\n    @return                     list of edges as tuple, list of edges as indices, distance\n    \"\"\"\n    if fLOG:\n        fLOG(\"[best_euler_path] distance_vertices #edges={0}\".format(\n            len(edges)))\n    distances = distance_vertices(edges, vertices, distances)\n    if fLOG:\n        fLOG(\"[best_euler_path] bellman_distances\")\n    dist = bellman_distances(edges, distances, fLOG=fLOG)\n    if fLOG:\n        fLOG(\"[best_euler_path] degrees and distances between odd vertices\")\n    degrees = compute_degrees(edges)\n    odd = {k: v for k, v in degrees.items() if v % 2 != 0}\n    odd_dist = {k: v for k, v in dist.items() if k[0] in odd and k[1] in odd}\n    if fLOG:\n        fLOG(\"[best_euler_path] matching #odd={0}, #odd_dist={1}\".format(\n            len(odd), len(odd_dist)))\n    pairs = matching_vertices(odd_dist, algo=algo)\n    if fLOG:\n        fLOG(\"[best_euler_path] build solution\")\n    solution = list(edges)\n    for va, vb in pairs:\n        dij = dijkstra_path(edges, distances, va, vb)\n        solution.extend([edges[e] for e in dij])\n    if fLOG:\n        fLOG(\"[best_euler_path] order edges to get the path #edges={0}\".format(\n            len(solution)))\n    if edges_index is None:\n        edges_index = list(range(len(edges)))\n    mapping = {}\n    rev = {}\n    for edge, index in zip(edges, edges_index):\n        mapping[edge] = index\n        rev[index] = edge\n    sol_index = [mapping[e] for e in solution]\n    euler_index = euler_path(edges_index, edges, sol_index)\n    euler = [rev[i] for i in euler_index]\n    if fLOG:\n        fLOG(\"[best_euler_path] done.\")\n    d = distance_solution(edges_index, edges, distances, sol_index)\n    return euler, euler_index, d\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_551","text":"<reponame>Kyubyong\/cross_vc\n# -*- coding: utf-8 -*-\n#\/usr\/bin\/python2\n'''\nBy <NAME>. <EMAIL>.\nhttps:\/\/www.github.com\/kyubyong\/cross_vc\n'''\n\nfrom __future__ import print_function\n\nfrom hparams import Hyperparams as hp\nimport librosa\nimport numpy as np\nfrom scipy import signal\nimport copy\nimport tensorflow as tf\n\ndef get_mfcc_and_mag(fpath, trim=True):\n    '''Returns normalized MFCCs and linear magnitude from `fpath`.\n    Args:\n      fpath: A string. The full path of a sound file.\n\n    Returns:\n      mfcc: A 2d array of shape (T, n_mfccs)\n      mag: A 2d array of shape (T, 1+n_fft\/2)\n    '''\n    # Loading sound file\n    y, sr = librosa.load(fpath, sr=hp.sr)\n\n    # Trimming\n    if trim: y, _ = librosa.effects.trim(y)\n\n    # Preemphasis\n    y = np.append(y[0], y[1:] - hp.preemphasis * y[:-1])\n\n    # stft\n    linear = librosa.stft(y=y,\n                          n_fft=hp.n_fft,\n                          hop_length=int(hp.sr * hp.frame_shift),\n                          win_length=int(hp.sr * hp.frame_length))\n\n    # magnitude spectrogram\n    mag = np.abs(linear)  # (1+n_fft\/\/2, T)\n\n    # mel spectrogram\n    mel_basis = librosa.filters.mel(hp.sr, hp.n_fft, hp.n_mels)  # (n_mels, 1+n_fft\/\/2)\n    mel = np.dot(mel_basis, mag)  # (n_mels, t)\n\n    # to decibel\n    mel = 20 * np.log10(np.maximum(1e-5, mel))\n    mag = 20 * np.log10(np.maximum(1e-5, mag))\n    mag = np.clip((mag - hp.ref_db + hp.max_db) \/ hp.max_db, 1e-8, 1)\n\n    # Get MFCCs\n    mfcc = np.dot(librosa.filters.dct(hp.n_mfccs, mel.shape[0]), mel) # (n_mfcc, t)\n\n    # Transpose for convenience\n    mfcc = mfcc.T.astype(np.float32)  # (t, n_mfcc)\n    mag = mag.T.astype(np.float32)\n    return mfcc, mag\n\ndef spectrogram2wav(mag):\n    '''# Generate wave file from magnitude spectrogram'''\n    # transpose\n    mag = mag.T\n\n    # de-noramlize\n    mag = (np.clip(mag, 0, 1) * hp.max_db) - hp.max_db + hp.ref_db\n\n    # to amplitude\n    mag = np.power(10.0, mag * 0.05)\n\n    # wav reconstruction\n    wav = griffin_lim(mag**hp.sharpening_factor)\n\n    # de-preemphasis\n    wav = signal.lfilter([1], [1, -hp.preemphasis], wav)\n\n    # trim\n    wav, _ = librosa.effects.trim(wav)\n\n    return wav.astype(np.float32)\n\n\ndef griffin_lim(spectrogram):\n    '''Applies Griffin-Lim's raw.\n    '''\n    hop_length = int(hp.sr*hp.frame_shift)\n    win_length = int(hp.sr*hp.frame_length)\n    X_best = copy.deepcopy(spectrogram)\n    for i in range(hp.n_iter):\n        X_t = invert_spectrogram(X_best)\n        est = librosa.stft(X_t, hp.n_fft, hop_length, win_length=win_length)\n        phase = est \/ np.maximum(1e-8, np.abs(est))\n        X_best = spectrogram * phase\n    X_t = invert_spectrogram(X_best)\n    y = np.real(X_t)\n\n    return y\n\n\ndef invert_spectrogram(spectrogram):\n    '''\n    spectrogram: [f, t]\n    '''\n    hop_length = int(hp.sr * hp.frame_shift)\n    win_length = int(hp.sr * hp.frame_length)\n    return librosa.istft(spectrogram, hop_length, win_length=win_length, window=\"hann\")\n\ndef learning_rate_decay(init_lr, global_step, warmup_steps=4000.):\n    '''Noam scheme from tensor2tensor'''\n    step = tf.to_float(global_step + 1)\n    return init_lr * warmup_steps**0.5 * tf.minimum(step * warmup_steps**-1.5, step**-0.5)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_552","text":"<gh_stars>0\n## Calculation of acoustic mode contributions to internal energy (E*)\r\n\r\nimport math\r\nimport numpy as np\r\nfrom scipy.integrate import quad\r\n\r\n#import params.py for all input parameters\r\nfrom params import *\r\n\r\n##########################################################################\r\n\r\nE_a = []\r\n\r\nfor i in ATEMP:\r\n    X_array = [] # Nondimensionalized branches\r\n    for j in U_array:\r\n        X_array.append((132.32*j\/(Vol**(1.\/3.)))*CONV\/i)\r\n        \r\n    acoustic = []\r\n\r\n    for z in X_array:\r\n        def f_acoustic(x):\r\n            return ((math.asin(x\/z)**2.)*x)\/(math.sqrt(z**2.-x**2.)*(math.exp(x)-1.))\r\n    \r\n        acoustic_quad, error = quad(f_acoustic, 0., z)\r\n        acoustic.append(acoustic_quad)\r\n    \r\n    acoustic_E = (3.*AVO*BOLTZ*i*(acoustic[0]+acoustic[1]+acoustic[2])\/(Natoms*Z))*(2.\/math.pi)*(2.\/math.pi)*(2.\/math.pi)\r\n    E_a.append(acoustic_E)\r\n\r\n##print(E_a)\r\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_554","text":"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Mon Feb 22 15:12:49 2021\r\n\r\n@author: Administrator\r\n\"\"\"\r\n\r\nimport math \r\nimport numpy as np\r\nimport pandas as pd\r\nfrom scipy.io import arff\r\nfrom sklearn.linear_model import LogisticRegression\r\nfrom sklearn import svm, datasets\r\nfrom sklearn.svm import SVC\r\nfrom sklearn.model_selection import train_test_split\r\nimport sklearn.preprocessing as skpre\r\nfrom matplotlib.colors import ListedColormap\r\nimport matplotlib.pyplot as plt\r\nfrom sklearn.tree import DecisionTreeClassifier\r\n\r\n#DATA PROCESSING\r\n\r\ndata, meta = arff.loadarff('C:\/Users\/Administrator\/Desktop\/4year.arff')\r\ndf=pd.DataFrame(data)\r\ndf['bankruptcy'] = (df['class']==b'1')\r\ndf.drop(columns=['class'], inplace=True)\r\ndf.columns = ['X{0:02d}'.format(k) for k in range(1,65)] + ['bankruptcy']\r\ndf.fillna(df.mean(), inplace=True)\r\nX_imp = df.values\r\nX, y = X_imp[:, :-1], X_imp[:, -1]\r\nX_train, X_test, y_train, y_test =\\\r\n    train_test_split(X, y, test_size=0.2, random_state=0, stratify=y)\r\nscaler = skpre.StandardScaler()\r\nX_train_std = scaler.fit_transform(X_train)\r\nX_test_std = scaler.transform(X_test)\r\n\r\ny_train=y_train*1\r\ny_test=y_test*1\r\ny_train=y_train.astype(int)\r\ny_test=y_test.astype(int)\r\nlr = LogisticRegression(penalty='l1',C=0.01, solver='liblinear')\r\nlr.fit(X_train_std, y_train.astype(int))\r\nlr.coef_[lr.coef_!=0].shape      \r\nX_train_std=X_train_std[:,lr.coef_[0]!=0]\r\nX_test_std=X_test_std[:,lr.coef_[0]!=0]\r\n\r\n#lR MODEL\r\nlr = LogisticRegression(penalty='l1')\r\nlr.fit(X_train_std, y_train.astype(int))\r\nprint('LR Training accuracy:', lr.score(X_train_std, y_train.astype(int)))\r\nprint('LR Test accuracy:', lr.score(X_test_std, y_test.astype(int)))\r\n\r\n#models = (svm.SVC(kernel='linear', C=C),\r\n#          svm.LinearSVC(C=C, max_iter=10000),\r\n#          svm.SVC(kernel='rbf', gamma=0.7, C=C),\r\n#          svm.SVC(kernel='poly', degree=3, gamma='auto', C=C))\r\n##for clf in models:\r\n\r\nclf=svm.SVC(C=1,kernel='rbf',gamma=10)\r\nclf.fit(X_train_std,y_train)\r\nprint('SVM Training accuracy:', clf.score(X_train_std, y_train))\r\nprint('SVM Test accuracy:', clf.score(X_test_std, y_test))\r\n\r\n\r\ntree= DecisionTreeClassifier(criterion='gini', \r\n                                    max_depth=4, \r\n                                    random_state=1)\r\ntree.fit(X_train, y_train)\r\n\r\n#############Codes below can't run, but I can't find the reason\r\n#############Codes below can't run, but I can't find the reason\r\n#############Codes below can't run, but I can't find the reason\r\n#############print('DecTree Training accuracy:', tree.score(X_train_std,y_train))\r\n#############print('DecTree Test accuracy:', tree.score(X_test_std,y_test))\r\n\r\ndef plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):\r\n\r\n    # setup marker generator and color map\r\n    markers = ('s', 'x', 'o', '^', 'v')\r\n    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')\r\n    cmap = ListedColormap(colors[:len(np.unique(y))])\r\n\r\n    # plot the decision surface\r\n    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\r\n    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\r\n    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),\r\n                           np.arange(x2_min, x2_max, resolution))\r\n    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)\r\n    Z = Z.reshape(xx1.shape)\r\n    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)\r\n    plt.xlim(xx1.min(), xx1.max())\r\n    plt.ylim(xx2.min(), xx2.max())\r\n\r\n    for idx, cl in enumerate(np.unique(y)):\r\n        plt.scatter(x=X[y == cl, 0], \r\n                    y=X[y == cl, 1],\r\n                    alpha=0.8, \r\n                    c=colors[idx],\r\n                    marker=markers[idx], \r\n                    label=cl, \r\n                    edgecolor='black')\r\n\r\n    # highlight test samples\r\n    if test_idx:\r\n        # plot all samples\r\n        X_test, y_test = X[test_idx, :], y[test_idx]\r\n\r\n        plt.scatter(X_test[:, 0],\r\n                    X_test[:, 1],\r\n                    c='',\r\n                    edgecolor='black',\r\n                    alpha=1.0,\r\n                    linewidth=1,\r\n                    marker='o',\r\n                    s=100, \r\n                    label='test set')\r\n        \r\nX_combined_std = np.vstack((X_train_std, X_test_std))\r\ny_combined = np.hstack((y_train, y_test))\r\n\r\nplot_decision_regions(X=X_combined_std, y=y_combined,\r\n                      classifier=lr, test_idx=range(0, 50))\r\nplt.xlabel('ratio1 [standardized]')\r\nplt.ylabel('ratio2[standardized]')\r\nplt.legend(loc='upper left')\r\n\r\nplt.tight_layout()\r\n\r\nplt.show()\r\n\r\n#############Codes below can't run, but I can't find the reason\r\n#############Codes below can't run, but I can't find the reason\r\n#############Codes below can't run, but I can't find the reason\r\n\r\n#plot_decision_regions(X_combined_std, y_combined,\r\n#                      classifier=svm.SVC, test_idx=range(105, 150))\r\n#plt.xlabel('petal length [standardized]')\r\n#plt.ylabel('petal width [standardized]')\r\n#plt.legend(loc='upper left')\r\n#plt.tight_layout()\r\n##plt.savefig('images\/03_15.png', dpi=300)\r\n#plt.show()\r\n#\r\n#plt.tight_layout()\r\n##plt.savefig('images\/03_01.png', dpi=300)\r\n#plt.show()\r\n#\r\n#X_combined = np.vstack((X_train_std, X_test_std))\r\n#y_combined = np.hstack((y_train, y_test))\r\n#plot_decision_regions(X_combined, y_combined, \r\n#                      classifier=tree_model,\r\n#                      test_idx=range(105, 150))\r\n#\r\n#plt.xlabel('ratio1')\r\n#plt.ylabel('ratio2')\r\n#plt.legend(loc='upper left')\r\n#plt.tight_layout()\r\n##plt.savefig('images\/03_20.png', dpi=300)\r\n#plt.show()\r\n##"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_556","text":"import os\nimport math\nimport torch\nimport random\nimport scipy as sp\nimport scipy.stats\nimport numpy as np\nimport torch.nn as nn\nfrom PIL import Image\nfrom alisuretool.Tools import Tools\nfrom torch.optim.lr_scheduler import StepLR\nimport torchvision.transforms as transforms\nfrom torch.utils.data.sampler import Sampler\nfrom torch.utils.data import DataLoader, Dataset\n\n\n##############################################################################################################\n\n\nclass ClassBalancedSampler(Sampler):\n    \"\"\" Samples 'num_inst' examples each from 'num_cl' pools of examples of size 'num_per_class' \"\"\"\n\n    def __init__(self, num_per_class, num_cl, num_inst, shuffle=True):\n        self.num_per_class = num_per_class\n        self.num_cl = num_cl\n        self.num_inst = num_inst\n        self.shuffle = shuffle\n        pass\n\n    def __iter__(self):\n        # return a single list of indices, assuming that items will be grouped by class\n        if self.shuffle:\n            batch = [[i + j * self.num_inst for i in torch.randperm(self.num_inst)[:self.num_per_class]] for j in\n                     range(self.num_cl)]\n        else:\n            batch = [[i + j * self.num_inst for i in range(self.num_inst)[:self.num_per_class]] for j in\n                     range(self.num_cl)]\n        batch = [item for sublist in batch for item in sublist]\n\n        if self.shuffle:\n            random.shuffle(batch)\n        return iter(batch)\n\n    def __len__(self):\n        return 1\n\n    pass\n\n\nclass ClassBalancedSamplerTest(Sampler):\n    \"\"\" Samples 'num_inst' examples each from 'num_cl' pools of examples of size 'num_per_class' \"\"\"\n\n    def __init__(self, num_cl, num_inst, shuffle=True):\n        self.num_cl = num_cl\n        self.num_inst = num_inst\n        self.shuffle = shuffle\n        pass\n\n    def __iter__(self):\n        # return a single list of indices, assuming that items will be grouped by class\n        if self.shuffle:\n            batches = [[i + j * self.num_inst for i in torch.randperm(self.num_inst)] for j in range(self.num_cl)]\n        else:\n            batches = [[i + j * self.num_inst for i in range(self.num_inst)] for j in range(self.num_cl)]\n        batches = [[batches[j][i] for j in range(self.num_cl)] for i in range(self.num_inst)]\n\n        if self.shuffle:\n            random.shuffle(batches)\n            for sublist in batches:\n                random.shuffle(sublist)\n        batches = [item for sublist in batches for item in sublist]\n        return iter(batches)\n\n    def __len__(self):\n        return 1\n\n    pass\n\n\nclass MiniImageNetTask(object):\n\n    def __init__(self, character_folders, num_classes, train_num, test_num):\n        self.character_folders = character_folders\n        self.num_classes = num_classes\n        self.train_num = train_num\n        self.test_num = test_num\n\n        class_folders = random.sample(self.character_folders, self.num_classes)\n        labels = dict(zip(class_folders, np.array(range(len(class_folders)))))\n\n        samples = dict()\n        self.train_roots = []\n        self.test_roots = []\n        for c in class_folders:\n            temp = [os.path.join(c, x) for x in os.listdir(c)]\n            samples[c] = random.sample(temp, len(temp))\n            random.shuffle(samples[c])\n\n            self.train_roots += samples[c][:train_num]\n            self.test_roots += samples[c][train_num:train_num + test_num]\n            pass\n\n        self.train_labels = [labels[os.path.split(x)[0]] for x in self.train_roots]\n        self.test_labels = [labels[os.path.split(x)[0]] for x in self.test_roots]\n        pass\n\n    pass\n\n\nclass MiniImageNet(Dataset):\n\n    def __init__(self, task, split='train', transform=None, target_transform=None):\n        self.transform = transform\n        self.target_transform = target_transform\n        self.task = task\n        self.split = split\n        self.image_roots = self.task.train_roots if self.split == 'train' else self.task.test_roots\n        self.labels = self.task.train_labels if self.split == 'train' else self.task.test_labels\n        pass\n\n    def __len__(self):\n        return len(self.image_roots)\n\n    def __getitem__(self, idx):\n        image_root = self.image_roots[idx]\n        image = Image.open(image_root)\n        image = image.convert('RGB')\n        if self.transform is not None:\n            image = self.transform(image)\n        label = self.labels[idx]\n        if self.target_transform is not None:\n            label = self.target_transform(label)\n        return image, label\n\n    @staticmethod\n    def mini_imagenet_folders(train_folder, val_folder, test_folder):\n        metatrain_folders = [os.path.join(train_folder, label) for label in os.listdir(train_folder)\n                             if os.path.isdir(os.path.join(train_folder, label))]\n        metaval_folders = [os.path.join(val_folder, label) for label in os.listdir(val_folder)\n                            if os.path.isdir(os.path.join(val_folder, label))]\n        metatest_folders = [os.path.join(test_folder, label) for label in os.listdir(test_folder)\n                            if os.path.isdir(os.path.join(test_folder, label))]\n        random.seed(1)\n        random.shuffle(metatrain_folders)\n        random.shuffle(metaval_folders)\n        random.shuffle(metatest_folders)\n        return metatrain_folders, metaval_folders, metatest_folders\n\n    @staticmethod\n    def get_mini_imagenet_data_loader(task, num_per_class=1, split='train', shuffle=False):\n        normalize = transforms.Normalize(mean=[0.92206, 0.92206, 0.92206], std=[0.08426, 0.08426, 0.08426])\n        dataset = MiniImageNet(task, split=split, transform=transforms.Compose([transforms.ToTensor(), normalize]))\n\n        if split == 'train':\n            sampler = ClassBalancedSampler(num_per_class, task.num_classes, task.train_num, shuffle=shuffle)\n        elif split == \"val\":\n            sampler = ClassBalancedSampler(num_per_class, task.num_classes, task.test_num, shuffle=shuffle)\n        else:  # test\n            sampler = ClassBalancedSamplerTest(task.num_classes, task.test_num, shuffle=shuffle)\n            pass\n\n        return DataLoader(dataset, batch_size=num_per_class * task.num_classes, sampler=sampler)\n\n    pass\n\n\n##############################################################################################################\n\n\nclass CNNEncoder(nn.Module):\n\n    def __init__(self):\n        super().__init__()\n        self.layer1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, padding=0),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU(), nn.MaxPool2d(2))\n        self.layer2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, padding=0),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU(), nn.MaxPool2d(2))\n        self.layer3 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, padding=1),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU())\n        self.layer4 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, padding=1),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU())\n        pass\n\n    def forward(self, x):\n        out = self.layer1(x)\n        out = self.layer2(out)\n        out = self.layer3(out)\n        out = self.layer4(out)\n        # out = out.view(out.size(0),-1)\n        return out  # 64\n\n    pass\n\n\nclass RelationNetwork(nn.Module):\n    \"\"\"docstring for RelationNetwork\"\"\"\n\n    def __init__(self, input_size, hidden_size):\n        super(RelationNetwork, self).__init__()\n        self.layer1 = nn.Sequential(nn.Conv2d(128, 64, kernel_size=3, padding=0),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU(), nn.MaxPool2d(2))\n        self.layer2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, padding=0),\n                                    nn.BatchNorm2d(64, momentum=1, affine=True), nn.ReLU(), nn.MaxPool2d(2))\n        self.fc1 = nn.Linear(input_size * 3 * 3, hidden_size)\n        self.fc2 = nn.Linear(hidden_size, 1)\n        pass\n\n    def forward(self, x):\n        out = self.layer1(x)\n        out = self.layer2(out)\n        out = out.view(out.size(0), -1)\n        out = torch.relu(self.fc1(out))\n        out = torch.sigmoid(self.fc2(out))\n        return out\n\n    pass\n\n\n##############################################################################################################\n\n\nclass Runner(object):\n\n    def __init__(self):\n        self.feature_dim = 64\n        self.relation_dim = 8\n        self.hidden_unit = 10\n\n        self.class_num = 5\n        self.sample_num_per_class = 1\n        self.batch_num_per_class = 15\n\n        self.train_episode = 1000  # 500000\n        self.val_episode = 600\n        self.test_avg_num = 10\n        self.test_episode = 600\n\n        self.learning_rate = 0.001\n\n        self.print_freq = 100\n        self.val_freq = 500  # 5000\n\n        self.feature_encoder_dir = Tools.new_dir(\"..\/models\/miniimagenet_feature_encoder_{}way_{}shot.pkl\".format(\n            self.class_num, self.sample_num_per_class))\n        self.relation_network_dir = Tools.new_dir(\"..\/models\/miniimagenet_relation_network_{}way_{}shot.pkl\".format(\n            self.class_num, self.sample_num_per_class))\n\n        # data\n        self.metatrain_folders, self.metaval_folders, self.metatest_folders = MiniImageNet.mini_imagenet_folders(\n            train_folder='\/mnt\/4T\/Data\/miniImagenet\/train',\n            val_folder='\/mnt\/4T\/Data\/miniImagenet\/val', test_folder='\/mnt\/4T\/Data\/miniImagenet\/test')\n\n        # model\n        (self.feature_encoder, self.relation_network, self.feature_encoder_scheduler,\n         self.relation_network_scheduler, self.feature_encoder_optim, self.relation_network_optim) = self._model()\n\n        self.loss = self._loss()\n        pass\n\n    @staticmethod\n    def _weights_init(m):\n        classname = m.__class__.__name__\n        if classname.find('Conv') != -1:\n            n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n            m.weight.data.normal_(0, math.sqrt(2. \/ n))\n            if m.bias is not None:\n                m.bias.data.zero_()\n        elif classname.find('BatchNorm') != -1:\n            m.weight.data.fill_(1)\n            m.bias.data.zero_()\n        elif classname.find('Linear') != -1:\n            n = m.weight.size(1)\n            m.weight.data.normal_(0, 0.01)\n            m.bias.data = torch.ones(m.bias.data.size())\n            pass\n        pass\n\n    def _model(self):\n        Tools.print(\"Init neural networks\")\n\n        feature_encoder = CNNEncoder()\n        relation_network = RelationNetwork(self.feature_dim, self.relation_dim)\n\n        feature_encoder.apply(self._weights_init)\n        relation_network.apply(self._weights_init)\n\n        feature_encoder.cuda()\n        relation_network.cuda()\n\n        feature_encoder_optim = torch.optim.Adam(feature_encoder.parameters(), lr=self.learning_rate)\n        feature_encoder_scheduler = StepLR(feature_encoder_optim, step_size=100000, gamma=0.5)\n        relation_network_optim = torch.optim.Adam(relation_network.parameters(), lr=self.learning_rate)\n        relation_network_scheduler = StepLR(relation_network_optim, step_size=100000, gamma=0.5)\n\n        return (feature_encoder, relation_network, feature_encoder_scheduler,\n                relation_network_scheduler, feature_encoder_optim, relation_network_optim)\n\n    @staticmethod\n    def _loss():\n        mse = nn.MSELoss().cuda()\n        return mse\n\n    def _val(self, meta_folders, split, episode):\n\n        def mean_confidence_interval(data, confidence=0.95):\n            a = 1.0 * np.array(data)\n            n = len(a)\n            m, se = np.mean(a), scipy.stats.sem(a)\n            h = se * sp.stats.t._ppf((1 + confidence) \/ 2., n - 1)\n            return m, h\n\n        accuracies = []\n        for i in range(episode):\n            total_rewards = 0\n            counter = 0\n            # 随机选5类，每类中取出1个作为训练样本，每类取出15个作为测试样本\n            task = MiniImageNetTask(meta_folders, self.class_num, self.sample_num_per_class, self.batch_num_per_class)\n            sample_dataloader = MiniImageNet.get_mini_imagenet_data_loader(task, 1, split=\"train\", shuffle=False)\n            batch_dataloader = MiniImageNet.get_mini_imagenet_data_loader(task, 3, split=split, shuffle=True)\n            sample_images, sample_labels = sample_dataloader.__iter__().next()\n\n            for batch_images, batch_labels in batch_dataloader:\n                ###########################################################################\n                # calculate features\n                relations = self._compare_fsl(sample_images, batch_images)\n                ###########################################################################\n\n                _, predict_labels = torch.max(relations.data, 1)\n                batch_size = batch_labels.shape[0]\n                rewards = [1 if predict_labels[j].cpu() == batch_labels[j] else 0 for j in range(batch_size)]\n                total_rewards += np.sum(rewards)\n\n                counter += batch_size\n                pass\n\n            accuracy = total_rewards \/ 1.0 \/ counter\n            accuracies.append(accuracy)\n            pass\n\n        accuracy, h = mean_confidence_interval(accuracies)\n        return accuracy, h\n\n    def load_model(self):\n        if os.path.exists(self.feature_encoder_dir):\n            self.feature_encoder.load_state_dict(torch.load(self.feature_encoder_dir))\n            # self.feature_encoder.load_state_dict(torch.load(self.feature_encoder_dir, map_location='cuda:0'))\n            Tools.print(\"load feature encoder success from {}\".format(self.feature_encoder_dir))\n\n        if os.path.exists(self.relation_network_dir):\n            self.relation_network.load_state_dict(torch.load(self.relation_network_dir))\n            # self.relation_network.load_state_dict(torch.load(self.relation_network_dir, map_location='cuda:0'))\n            Tools.print(\"load relation network success from {}\".format(self.relation_network_dir))\n        pass\n\n    def _compare_fsl(self, samples, batches):\n        # calculate features\n        sample_features = self.feature_encoder(samples.cuda())  # 5x64*19*19\n        batch_features = self.feature_encoder(batches.cuda())  # 75x64*19*19\n        batch_size, _, feature_width, feature_height = batch_features.shape\n\n        # calculate relations\n        sample_features_ext = sample_features.unsqueeze(0).repeat(batch_size, 1, 1, 1, 1)\n        batch_features_ext = batch_features.unsqueeze(0).repeat(\n            self.sample_num_per_class * self.class_num, 1, 1, 1, 1)\n        batch_features_ext = torch.transpose(batch_features_ext, 0, 1)\n        relation_pairs = torch.cat((sample_features_ext, batch_features_ext),\n                                   2).view(-1, self.feature_dim * 2, feature_width, feature_height)\n        relations = self.relation_network(relation_pairs).view(-1, self.class_num * self.sample_num_per_class)\n        return relations\n\n    def train(self):\n        Tools.print()\n        Tools.print(\"Training...\")\n\n        last_accuracy = 0.0\n        for episode in range(self.train_episode):\n            # init dataset\n            task = MiniImageNetTask(self.metatrain_folders, self.class_num,\n                                    self.sample_num_per_class, self.batch_num_per_class)\n            sample_dataloader = MiniImageNet.get_mini_imagenet_data_loader(\n                task, num_per_class=self.sample_num_per_class, split=\"train\", shuffle=False)\n            batch_dataloader = MiniImageNet.get_mini_imagenet_data_loader(\n                task, num_per_class=self.batch_num_per_class, split=\"val\", shuffle=True)\n            samples, sample_labels = sample_dataloader.__iter__().next()\n            batches, batch_labels = batch_dataloader.__iter__().next()\n\n            ###########################################################################\n            # calculate features\n            relations = self._compare_fsl(samples, batches)\n            ###########################################################################\n\n            one_hot_labels = torch.zeros(self.batch_num_per_class * self.class_num,\n                                         self.class_num).scatter_(1, batch_labels.view(-1, 1), 1).cuda()\n            loss = self.loss(relations, one_hot_labels)\n\n            self.feature_encoder.zero_grad()\n            self.relation_network.zero_grad()\n\n            loss.backward()\n\n            torch.nn.utils.clip_grad_norm_(self.feature_encoder.parameters(), 0.5)\n            torch.nn.utils.clip_grad_norm_(self.relation_network.parameters(), 0.5)\n\n            self.feature_encoder_optim.step()\n            self.relation_network_optim.step()\n            self.feature_encoder_scheduler.step(episode)\n            self.relation_network_scheduler.step(episode)\n\n            if (episode + 1) % self.print_freq == 0:\n                Tools.print(\"Episode: {} loss: {}\".format(episode + 1, loss.item()))\n                pass\n\n            if episode % self.val_freq == 0:\n                Tools.print()\n                Tools.print(\"Valing...\")\n                val_accuracy, h = self.val(is_print=True)\n                if val_accuracy > last_accuracy:\n                    # save networks\n                    torch.save(self.feature_encoder.state_dict(), self.feature_encoder_dir)\n                    torch.save(self.relation_network.state_dict(), self.relation_network_dir)\n                    Tools.print(\"Save networks for episode: {}\".format(episode))\n                    last_accuracy = val_accuracy\n                    pass\n\n                pass\n\n            pass\n\n        pass\n\n    def val(self, is_print=False):\n        val_accuracy, h = self._val(self.metaval_folders, split=\"val\", episode=self.val_episode)\n        if is_print:\n            Tools.print()\n            Tools.print(\"Val Accuracy: {} h: {}\".format(val_accuracy, h))\n            pass\n        return val_accuracy, h\n\n    def test(self, is_print=True):\n        Tools.print()\n        Tools.print(\"Testing...\")\n        total_accuracy = 0.0\n        for episode in range(self.test_avg_num):\n            test_accuracy, h = self._val(self.metatest_folders, split=\"test\", episode=self.test_episode)\n            total_accuracy += test_accuracy\n            Tools.print(\"episode={}, Test accuracy={}, H={}, Total accuracy={}\".format(episode, test_accuracy,\n                                                                                       h, total_accuracy))\n            pass\n\n        final_accuracy = total_accuracy \/ self.test_avg_num\n        if is_print:\n            Tools.print(\"Final accuracy: {}\".format(final_accuracy))\n            pass\n        return final_accuracy\n\n    pass\n\n\n##############################################################################################################\n\n\nif __name__ == '__main__':\n    os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n    runner = Runner()\n    runner.load_model()\n    runner.test(is_print=True)\n    runner.val(is_print=True)\n    # runner.train()\n    runner.val(is_print=True)\n    runner.test(is_print=True)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_558","text":"<filename>setup_scripts\/burn_streams.py\nimport os\nfrom tabnanny import check\nimport time\nimport pickle\n\n# import pandas as pd\nimport numpy as np\n\n# import shapely\n# from shapely.geometry import Polygon, Point\nimport geopandas as gpd\n\nimport xarray as xr\nimport rioxarray as rxr\nimport rasterio  as rio\nfrom rasterio import features\n\nfrom numba import jit\n\nfrom skimage.morphology import skeletonize\nfrom scipy import ndimage\n\nfrom pysheds.grid import Grid\nfrom pysheds.view import Raster, ViewFinder\n\nfrom pyproj import CRS, Proj\n\nimport warnings\nwarnings.filterwarnings('ignore')\n\nt0 = time.time()\n\nBASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\nDATA_DIR = os.path.join(BASE_DIR, 'source_data\/')\n\nprocessed_data_dir = os.path.join(BASE_DIR, 'processed_data')\ndata_dir = '\/media\/danbot\/Samsung_T5\/geospatial_data\/'\n\n# dem_dir = os.path.join(DATA_DIR, 'dem_data\/')\n# dem_dir = os.path.join(data_dir, 'DEM_data\/')\n\n# processed_dem_dir = os.path.join(dem_dir, 'processed_dem\/')\n\nprocessed_dem_dir = '\/home\/danbot\/Documents\/code\/hysets_validation\/source_data\/dem_data\/processed_dem\/'\n\n# specify the DEM source\n# either 'EarthEnv_DEM90' or 'USGS_3DEP'\nDEM_source = 'EarthEnv_DEM90'\n# DEM_source = 'USGS_3DEP'\n\ndef retrieve_and_preprocess_raster(region_code):\n    # load the region DEM once and iterate through all\n    # region_dem_path = os.path.join(processed_dem_dir, f'{region_code}_DEM_3005_{resolution}.tif')\n    if DEM_source == 'EarthEnv_DEM90':\n        region_dem_path = os.path.join(processed_dem_dir, f'{region_code}_{DEM_source}_3005_{resolution}.tif')\n    else:\n        region_dem_path = os.path.join(processed_dem_dir, f'{region_code}_DEM_3005_{resolution}.tif')\n    assert os.path.exists(region_dem_path)\n\n    rds = rxr.open_rasterio(region_dem_path, mask_and_scale=True, dtype=np.float32)    \n    \n    grid = Grid.from_raster(region_dem_path)\n    dem = grid.read_raster(region_dem_path, dtype=np.float64)\n\n    viewfinder = ViewFinder(affine=dem.affine, shape=dem.shape, crs=dem.crs, nodata=dem.nodata)\n\n    dat = rds.data[0]\n    \n    raster = Raster(dat, viewfinder=viewfinder)\n    return raster, rds\n\n\ndef get_river_mask(region_code, rds):\n    nhn_grouped_vector_path = os.path.join(processed_data_dir, 'grouped_hydrographic_features\/')\n    vector_rivers_path = os.path.join(nhn_grouped_vector_path, f'{region_code}\/NLFLOW\/')\n\n    # mask = create_mask(vector_rivers_path)\n    rivers = gpd.read_file(vector_rivers_path, mask_and_scale=True)\n    affine = rds.rio.transform(recalc=False)\n    # Rasterize river shapefile\n    river_raster = features.rasterize(rivers.geometry, out_shape=rds.shape[1:],\n                                  transform=affine, all_touched=False)\n\n    # Skeletonize river raster\n    river_raster = skeletonize(river_raster).astype(np.uint8)\n\n    # Create boolean mask based on rasterized river shapes\n    mask = river_raster.astype(bool)\n    return mask\n\n\n# now create polygons using the raster just generated\ndef retrieve_raster(fpath):\n    dem = rxr.open_rasterio(fpath, mask_and_scale=True, dtype=np.float32)\n    crs = dem.rio.crs\n    affine = dem.rio.transform(recalc=False)\n    return dem, crs, affine\n\n\n@jit(nopython=True)\ndef flatten_streams_windowed(dem, max_depth=1):\n\n    n_adjustments = 0\n    tot_adjustment = 0\n    \n    rows = dem.shape[0] # # of steps in y direction\n    cols = dem.shape[1] # # of steps in x direction\n    # print(f' dem shape = {dem.shape}')\n    # create an array to track indices of all stream ends.\n    stream_ends = np.empty((3,))\n    stream_ends.fill(np.nan)\n    # stream_nodes = np.empty((1,2))\n\n    for i in range(rows):\n        for j in range(cols):\n            px_el = dem[i, j]\n\n            # instead of iterating through the whole image,\n            # just get a list of pixel indices (streams are sparse)\n            if np.isfinite(px_el):\n                # print(i, j, px_el)\n                c1, c2 = max(0, j - max_depth), min(j + max_depth + 1, cols)\n                r1, r2 = max(0, i - max_depth), min(i + max_depth + 1, rows)\n\n                window = dem[r1:r2, c1:c2]\n                # print('---------')\n                # print(f'target cell ({i},{j}) el = {px_el:.1f}')\n                # print(window)\n\n                # the target cell is the centre of the flattened matrix\n                # or different indices based on whether or not it's at an edge\n                target_idx_coords, flat_index_loc = find_del_loc(i, j, window.shape[1], max_depth)\n\n                # get the elevations surrounding the target pixel\n                outer_vals = np.delete(window, flat_index_loc)\n               \n                # faster method of sorting when we just want the two smallest\n                # and don't care about order\n                two_smallest = np.partition(outer_vals, 2)[:2]\n\n                # print(outer_vals)\n                # print(np.count_nonzero(~np.isnan(outer_vals)))\n                \n                # print('')\n\n                if np.count_nonzero(~np.isnan(outer_vals)) == 1:\n                    # append the target index to track streamline terminus\n                    stream_ends = np.append(stream_ends,(i, j, px_el))\n\n\n                # print('outer vals and two smallest: ')\n                # print(outer_vals, two_smallest)\n                # if the centre pixel is higher or lower than both lowest\n                # neighbours, set the pixel value to the average\n                if np.isfinite(two_smallest).all():\n                    if np.less(two_smallest, np.array(px_el)).all() | np.less(np.array(px_el), two_smallest).all():\n                        new_el = np.mean(two_smallest)\n                        dem[i, j] = new_el\n                        n_adjustments += 1\n                        tot_adjustment += px_el - new_el\n                #         print('edited window')\n                #         print(dem[r1:r2, c1:c2])\n                #         print('')\n                # print('')\n                # print('_______')\n\n    return dem, stream_ends, n_adjustments, tot_adjustment\n\n@jit(nopython=True)\ndef find_del_loc(i, j, window_width, max_depth=1):   \n    if i <= max_depth:\n        ti = i\n    else:\n        ti = max_depth\n    if j <= max_depth:            \n        tj = j\n    else:\n        tj = max_depth\n    # get the index of the target pixel\n    # if the matrix is flattened\n    flat_index = window_width * ti + tj\n    # print(f'(ti, tj) = ({ti},{tj})')\n    # print(f'flat_index: {flat_index}  {window_width}')\n    return (int(ti), int(tj)), int(flat_index)\n\n\n@jit(nopython=True)\ndef get_min_outer_pixel_indices(window, outer_vals, flat_index_loc, xs, ys, ix, jx, checked_indices, prevent_inf_loop, rows, cols, max_depth):            \n\n    # print(f'outer vals: {outer_vals}')\n    # get the index of the smallest outer value\n    total_len = len(window.flatten())\n\n    # print('outer vals: ', outer_vals)\n    min_outer_val_idx = np.nanargmin(outer_vals)\n    # print('min outer val idx: ', min_outer_val_idx)\n\n    # the middle pixel was deleted from the outer_vals array,\n    # so add 1 if the minimum index is in the back half of the \n    # array so we can reconstruct its 2d position\n    if min_outer_val_idx >= flat_index_loc:\n        min_outer_val_idx += 1\n\n    # reconstruct the 2d indices of the outer pixel with min elevation\n    # retrieve the row index that the min outer value falls in\n    min_row_idx = int(np.floor(min_outer_val_idx \/ window.shape[1]))\n    # retrieve the column index that the min outer value falls in\n    min_col_idx = int(min_outer_val_idx - (min_row_idx) * window.shape[1])\n    # test that we referenced the correct elevation.\n    min_outer_el = window[min_row_idx, min_col_idx]\n\n    # print(f'min idx ({min_row_idx},{min_col_idx}): el: {min_outer_el}')\n    # print(f'(ix, jx)=({ix},{jx})')\n\n    # convert the min neighbor's window index to dem index\n    new_dem_ix = ix + (min_row_idx - max_depth)\n    if ix < max_depth:\n        new_dem_ix = ix + min_row_idx\n\n    new_dem_jx = jx + (min_col_idx - max_depth)\n    if jx < max_depth:\n        new_dem_jx = jx + min_col_idx\n\n    new_dem_idx = (new_dem_ix, new_dem_jx)\n\n    # print('new dem idx: ', new_dem_idx)\n\n    indices_idx = np.where(np.logical_and(xs == new_dem_idx[0], ys == new_dem_idx[1]))[0][0]\n\n    if not np.any(np.in1d(checked_indices, indices_idx)):\n        # print(f'outer val index: {min_outer_val_idx}')\n        if min_outer_val_idx >= flat_index_loc:\n            min_outer_val_idx -= 1\n        \n        # print('already checked cell. Update outer vals: ', outer_vals)\n        outer_vals[min_outer_val_idx] = np.nan\n        # print('already checked cell. Update outer vals: ', outer_vals)\n        # print('are all outer vals nan?: ', np.all(np.isnan(outer_vals)))\n        if np.all(np.isnan(outer_vals)):\n            return new_dem_idx, min_outer_el, indices_idx, prevent_inf_loop, True\n        else:\n            new_dem_idx, min_outer_el, indices_idx, prevent_inf_loop, end_of_line = get_min_outer_pixel_indices(window, outer_vals, flat_index_loc, xs, ys, ix, jx, checked_indices, prevent_inf_loop, rows, cols, max_depth)\n            prevent_inf_loop += 1\n            if prevent_inf_loop >= 4:\n                raise Exception; 'infinite loop!'\n\n\n    return new_dem_idx, min_outer_el, indices_idx, prevent_inf_loop, False\n\n\ndef get_windows(raster, dem, ix, jx, rows, cols):\n    i1, i2 = max(0, ix - 1), min(ix + 2, rows)\n    j1, j2 = max(0, jx - 1), min(jx + 2, cols)\n    # don't let window indices go beyond raster edges\n    dem_window = dem[i1:i2, j1:j2]\n    raster_window = raster[i1:i2, j1:j2]\n    return raster_window, dem_window\n\n\ndef check_adj_slope_elevations(raster_window, dem_window, ix, jx, rows, cols):\n    ta = time.time()\n    # sometimes the stream vector will not line\n    # up with the thalweg in the dem\n    # look at surrounding (nan) cells and \n    # replace the target cell elevation with a lower\n    # value if there is one (not on the headwater cell)\n    pairs = [[1, 0], [0, 1], [1, 2], [2, 1]]\n    if ix == 0: # top row\n        if jx == 0: # top left\n            pairs = [[1, 0], [0, 1]]\n        elif jx == cols: # top right\n            pairs = [[0, 0], [1, 1]]\n        else: # top middle\n            pairs = [[0, 0], [1, 1], [0, 2]]\n\n    if ix == rows: # bottom row\n        if jx == cols: # bottom right\n            pairs = [[1, 0], [0, 1]]\n        elif jx == 0: # bottom left\n            pairs = [[0, 0], [1, 1]]\n        else:\n            pairs = [[1, 0], [0, 1], [1, 2]]\n\n    nan_ixs = np.argwhere(np.isnan(raster_window)).tolist()\n    ics = [e for e in nan_ixs if e in pairs]\n    min_adjacent_el = 1E9\n    if len(ics) > 0:\n        els = [raster_window[ic[0], ic[1]] for ic in ics]\n        if len(els) > 0:\n            min_adjacent_el = min(els)\n\n    return min_adjacent_el\n    \n\ndef check_adj_stream_els(dem, ci, cj):\n    stream_cells = np.argwhere(np.isfinite(dem))\n    adj_px = [e for e in stream_cells if tuple(e) != (ci, cj)]\n    # max_adj_idx = np.argmax(dem)\n    adj_els = [dem[p[0], p[1]] for p in adj_px]\n    if len(adj_els) > 0:\n        return (min(adj_els), max(adj_els))\n    else:\n        return None\n\n\ndef travel_stream(raster, dem, indices, check, tot_adjustment, n_adjustments, max_depth=1):\n    # don't check the first (headwater) cell\n    headwater_cell_unchecked = False\n    n_checks = 0\n    while len(indices) > 0:\n        check += 1\n        # if check >= 10:\n        #     break\n        \n        (ix, jx) = indices.pop()\n\n        px_el = dem[ix, jx]\n        px_el_og = px_el\n\n        rows, cols = raster.shape[0], raster.shape[1]\n\n        (ci, cj), flat_idx = find_del_loc(ix, jx, dem.shape[1])\n        \n        raster_window, dem_window = get_windows(raster, dem, ix, jx, rows, cols)\n\n        min_adjacent_slope_el, next_idx = check_adj_slope_elevations(raster_window, dem_window, ix, jx, rows, cols)\n\n        if not min_adjacent_slope_el:\n            pass\n\n        # print(f'current: {i}, el: {px_el:.1f} checked_indices', checked_indices)\n        # checked_el[i] = px_el\n            # if there is an outer pixel with a lower elevation\n        # that isn't in the stream, change the current target \n        # elevation to a value slightly smaller\n        if headwater_cell_unchecked & (min_adjacent_slope_el < px_el):\n            # print(f'    Updating target cell el from {px_el:.1f} to {min_outer_el - 0.1:.1f}')\n            dem[ix, jx] = min_adjacent_slope_el - 0.1\n            headwater_cell_unchecked = False\n            px_el = min_adjacent_slope_el - 0.1\n            tot_adjustment +=  px_el_og - px_el\n            n_adjustments += 1\n            n_checks += 1\n\n        neighbor_stream_cells = check_adj_stream_els(dem_window, ci, cj)\n\n        headwater_cell_unchecked = True\n\n    \n    return dem, check, n_adjustments, tot_adjustment, n_checks\n\n\ndef find_and_sort_stream_cells(dem):\n    # indices of stream elements\n    nzidx = np.where(np.isfinite(dem))\n    # ordered stream pixel indices by elevation descending\n    el_ranking = np.argsort(dem[nzidx])[::-1]\n    xs, ys = tuple(np.array(nzidx)[:, el_ranking])    \n    stream_cell_indices = np.array(tuple(zip(xs, ys)))\n    return stream_cell_indices\n\n\ndef find_end_cells(dem, raster, stream_cell_indices, adjust_dem=True):\n    \"\"\"Find all terminations of the stream network, \n    either headwaters or outlets. \n\n    Args:\n        dem (_type_): _description_\n        raster (_type_): _description_\n        stream_cell_indices (_type_): _description_\n        adjust_dem (bool, optional): _description_. Defaults to True.\n    \"\"\"\n    # n_cells = len(stream_cell_indices)\n    rows, cols = dem.shape[0], dem.shape[1]\n    for (ix, jx) in stream_cell_indices:\n        raster_window, dem_window = get_windows(raster, dem, ix, jx, rows, cols)\n    \n\n       \ndef flatten_streams_streamwise(raster, dem, max_depth=1):\n    n_adjustments = 0\n    tot_adjustment = 0\n\n    # ta = time.time()\n    # # stream_cell_indices = find_and_sort_stream_cells(raster, dem)\n    # tb = time.time()\n    # print(f'Time to sort indices: {tb-ta:.1e}s')\n\n    # headwater_indices = find_headwater_cells(dem, raster, stream_cell_indices)\n\n    # rows, cols = dem.shape[0], dem.shape[1]\n    # checked_indices = np.empty(0)\n\n    # print(dem)\n    check = 0\n    # dem, check, n_adjustments, tot_adjustment, n_checks = travel_stream(raster, dem, indices, tot_adjustment, n_adjustments, check)\n    \n\n    # print(dem)\n    # print('')\n    # print('')\n\n    # the target cell is the centre of the flattened 3x3 matrix\n    # or different indices based on whether or not it's at an edge\n    # which makes 2x3 (left or right edge), 3x2 (top or bottom), \n    # or 2x2 (corners)\n    # target_idx_coords, flat_index_loc = find_del_loc(ix, jx, window.shape[1], rows, cols, max_depth)\n\n    # # print(f' delete flat index loc: {flat_index_loc}')\n\n    # # get the elevations of STREAM PIXELS \n    # # surrounding the target pixel\n    # outer_vals = np.delete(window, flat_index_loc)\n\n    # prevent_inf_loop = 0\n    # new_dem_idx, min_outer_el, indices_idx, prevent_inf_loop, end_of_line = get_min_outer_pixel_indices(window, outer_vals, flat_index_loc, xs, ys, ix, jx, checked_indices, prevent_inf_loop, rows, cols, max_depth)\n\n\n    # # if we've reached the end of the current streamline\n    # # skip the rest of the loop and go to the next highest index\n    # if end_of_line:\n    #     # print('')\n    #     # print('END OF CURRENT STREAMLINE')\n    #     # print('')\n    #     # reset the headwater check status so we don't modify\n    #     # the headwater cell at the start of the next stream\n    #     headwater_cell_unchecked = False\n    #     continue\n\n    # indices = np.delete(indices, indices_idx, axis=0)\n    # if i == n_cells-1:\n    #     # print(f'before append: {indices[-5:]}')\n    #     indices = np.append(indices, new_dem_idx)\n    #     # print(f'new index appended: {indices[-5:]}')\n    # else:\n    #     indices = np.insert(indices, i+1, new_dem_idx, axis=0)\n    # # track how the order of indices ends up being checked\n\n    # if not np.any(np.in1d(checked_indices, indices_idx)):\n    #     checked_indices = np.append(checked_indices, int(indices_idx)) \n\n    # if np.all(np.isnan(outer_vals)):\n    #     continue\n\n    # # if the minimum outer elevation is greater than\n    # # the current pixel, change it to slightly less than \n    # # the current pixel\n    # if min_outer_el >= px_el:\n    #     # print(f'     outer px el reduced from {min_outer_el:.1f} to {px_el-0.1:.1f}')\n    #     dem[new_dem_idx[0], new_dem_idx[1]] = round(px_el - 0.1, 1)\n    #     tot_adjustment += px_el_og - round(px_el - 0.1, 1)\n    #     n_adjustments += 1\n\n    # # remove the updated cell from the main list \n    # # so we don't loop around it again\n    # # find the min neighbor's index in the ordered indices array\n    # el_new = dem[new_dem_idx]\n      \n\n    return dem, n_adjustments, tot_adjustment, n_checks\n\n\ndir_method = 'D8' # D8, DINF\ndelineation_method = 'PYSHEDS'\n# for region in code\n\nresolution = 'res1'\n\ndem_files = os.listdir(processed_dem_dir)\ndem_files = [e for e in dem_files if resolution in e]\n\n\nregion_codes = sorted(list(set([e.split('_')[0] for e in dem_files])))\n\ni = 1\nfor region_code in region_codes:\n    print('___________________________________________________')\n    print('')\n    print(f'Starting stream burn on region {region_code} {i}\/{len(region_codes)}.')\n       \n    # get the covering region for the station\n    t_start = time.time()\n\n    if 'EarthEnv' in DEM_source:\n        resolution = 'res1'\n    \n    load_start = time.time()\n    raster, rds = retrieve_and_preprocess_raster(region_code)\n    load_end = time.time()\n    print(f'    Time to load raster = {load_end-load_start:.1f}s')\n    print(f'        --raster is {raster.shape[0]}px high by {raster.shape[1]}px wide')\n\n    river_mask = get_river_mask(region_code, rds)\n    mask_end = time.time()\n    print(f'    Time to get river mask = {mask_end-load_end:.1f}s')\n\n    # Blur mask using a gaussian filter\n    blurred_mask = ndimage.filters.gaussian_filter(river_mask.astype(np.float64), sigma=2.5)\n\n    # Set central channel to max to prevent pits\n    blurred_mask[river_mask.astype(np.bool)] = blurred_mask.max()\n\n    mask = blurred_mask\n\n    # Create a view onto the DEM array\n    # dem = grid.view('dem', dtype=np.float64, nodata=np.nan)\n    # Set elevation change for burned cells\n\n    dz = 6.5\n\n    # n_px = 6\n\n    masked_dem = np.empty_like(raster)\n    masked_dem.fill(np.nan)\n    # masked_dem = masked_dem.reshape()\n    center = (int(raster.shape[0] \/ 2), int(raster.shape[1]*0.3))\n\n    # dem = raster.view('dem', dtype=np.float64, nodata=np.nan)\n    # mask the DEM by the river pixels\n    masked_dem[river_mask > 0] = raster[river_mask > 0]\n\n    t_start = time.time()\n    \n    # two-diagonal hump\n    # test_dem = masked_dem[center[0]-10:center[0]+10, center[1]-70:center[1]-60].round(0)\n\n    # # cut a sample window to test the algorithm\n    # v1, v2 = -50, 50\n    # h1, h2 = -50, 50\n    # top_px, bot_px = max(center[0]+v1, 0), min(center[0]+v2, raster.shape[0])\n    # left_px, right_px = max(center[0]+h1, 0), min(center[0]+h2, raster.shape[1])\n    # test_dem = masked_dem[top_px:bot_px, left_px:right_px].round(1)\n    # test_raster = raster[top_px:bot_px, left_px:right_px].round(1)\n\n    # test_size = test_dem.shape[0] * test_dem.shape[1]\n    # print(f'test raster size = ({test_dem.shape}) ({test_size:.1e}px)')\n\n    # if (test_dem.shape == masked_dem.shape):\n    #     print('***************************')\n    #     print('Maximum test size reached.')\n    #     print('***************************')\n    # print(test_dem)\n    modified_dem, stream_ends, n_adjustments, tot_adjustment = flatten_streams_windowed(masked_dem)\n\n    # print('raster range: ', np.nanmin(raster),np.nanmax(raster))\n    # print('min el in masked dem')\n    # print(np.nanmin(masked_dem))\n\n    # remove the first nan entry of a 3-tuple\n    # stream_ends = stream_ends[3:]\n    # stream_ends = stream_ends.reshape(int(len(stream_ends)\/3),3)\n    # n_ends = len(stream_ends)\n    # print(f'Found {n_ends} stream ends.')\n    # # sort the array by elevations (2nd index)\n    # stream_ends = stream_ends[stream_ends[:,2].argsort()]\n\n    # t_win = time.time()\n    # raster_size = masked_dem.shape[0] * masked_dem.shape[1]\n    # print(f'   {raster_size} px raster processed in {t_win-t_start:.2e}s')\n\n\n    # modified_dem, n_adjustments, tot_adjustment, n_checks = flatten_streams_streamwise(test_raster, test_dem)\n    # modified_dem, n_adjustments, tot_adjustment = flatten_streams_streamwise(raster, masked_dem)\n    # print('')\n    # t_end = time.time()\n\n    \n    # print(modified_dem)\n    # print('')\n    # print(f'{n_adjustments}\/{test_size} cells adjusted in {n_checks} checks, total adjustment = {tot_adjustment:.1f}m')\n    # print(f'   {test_size} px raster processed in {t_end-t_start:.2e}s')\n    \n    # raster_size = raster.shape[0] * raster.shape[1]\n    # print(f'   Stream flattening completed in {t_end -t_start:.2e} for {raster_size:.2e} pixels. {n_adjustments} pixels adjusted, {tot_adjustment} m total adjustment.')\n    \n    # replace the river pixels in the original raster\n    # with the modified values\n    # raster[river_mask > 0] = modified_dem[river_mask > 0]\n\n    # Subtract a constant dz from all stream pixels\n    raster[river_mask > 0] -= dz\n\n    out_fname = f'{region_code}_{DEM_source}_burned_streams_{resolution}.tif'\n    processed_out_dir = f'\/media\/danbot\/Samsung_T5\/geospatial_data\/DEM_data\/processed_dem\/'\n    out_path = os.path.join(processed_out_dir, out_fname)\n\n    rds.data[0] = raster.data\n    # rds.rio.write_nodata(-32768, inplace=True)\n\n    rds.rio.to_raster(out_path)#, nodata=-32768)\n    # dem.to_raster(grid, out_path)\n    \n    t_end_cond = time.time()\n    t_cond = t_end_cond - t_start\n    print(f'    ...stream burn for {region_code} in {t_cond:.1f}.  Created {out_fname}')\n    i += 1\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_553","text":"<filename>silx\/opencl\/sift\/test\/test_transform.py<gh_stars>1-10\n#!\/usr\/bin\/env python\n# -*- coding: utf-8 -*-\n#\n#    Project: Sift implementation in Python + OpenCL\n#             https:\/\/github.com\/silx-kit\/silx\n#\n#    Copyright (C) 2013-2017  European Synchrotron Radiation Facility, Grenoble, France\n#\n# Permission is hereby granted, free of charge, to any person\n# obtaining a copy of this software and associated documentation\n# files (the \"Software\"), to deal in the Software without\n# restriction, including without limitation the rights to use,\n# copy, modify, merge, publish, distribute, sublicense, and\/or sell\n# copies of the Software, and to permit persons to whom the\n# Software is furnished to do so, subject to the following\n# conditions:\n#\n# The above copyright notice and this permission notice shall be\n# included in all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n# OTHER DEALINGS IN THE SOFTWARE.\n\n\"\"\"\nTest suite for transformation kernel\n\"\"\"\n\nfrom __future__ import division, print_function\n\n__authors__ = [\"<NAME>\", \"<NAME>\"]\n__contact__ = \"<EMAIL>\"\n__license__ = \"MIT\"\n__copyright__ = \"2013 European Synchrotron Radiation Facility, Grenoble, France\"\n__date__ = \"25\/06\/2018\"\n\n\nimport os\nimport unittest\nimport time\nimport logging\nimport numpy\ntry:\n    import scipy.misc\n    import scipy.ndimage\nexcept ImportError:\n    scipy = None\n\nfrom silx.opencl import ocl, kernel_workgroup_size\nif ocl:\n    import pyopencl.array\n# for Python implementation of tested functions\n# from .test_image_functions import\n# from .test_image_setup import\nfrom ..utils import calc_size, get_opencl_code, matching_correction\nfrom ..plan import SiftPlan\nfrom ..match import MatchPlan\nfrom silx.test.utils import test_options\nlogger = logging.getLogger(__name__)\n\n\n@unittest.skipUnless(scipy and ocl, \"scipy or ocl missing\")\nclass TestTransform(unittest.TestCase):\n    @classmethod\n    def setUpClass(cls):\n        super(TestTransform, cls).setUpClass()\n        if ocl:\n            cls.ctx = ocl.create_context()\n            if logger.getEffectiveLevel() <= logging.INFO:\n                cls.PROFILE = True\n                cls.queue = pyopencl.CommandQueue(cls.ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE)\n            else:\n                cls.PROFILE = False\n                cls.queue = pyopencl.CommandQueue(cls.ctx)\n            device = cls.ctx.devices[0]\n            device_id = device.platform.get_devices().index(device)\n            platform_id = pyopencl.get_platforms().index(device.platform)\n            cls.maxwg = ocl.platforms[platform_id].devices[device_id].max_work_group_size\n\n    @classmethod\n    def tearDownClass(cls):\n        super(TestTransform, cls).tearDownClass()\n        cls.ctx = None\n        cls.queue = None\n\n    def setUp(self):\n        kernel_src = get_opencl_code(os.path.join(\"sift\", \"transform\"))\n        self.program = pyopencl.Program(self.ctx, kernel_src).build()  # .build('-D WORKGROUP_SIZE=%s' % wg_size)\n        self.wg = (1, 128)\n        if hasattr(scipy.misc, \"ascent\"):\n            self.image = scipy.misc.ascent().astype(numpy.float32)\n        else:\n            self.image = scipy.misc.lena().astype(numpy.float32)\n\n    def tearDown(self):\n        self.program = None\n\n    def image_reshape(self, img, output_height, output_width, image_height, image_width):\n        '''\n        Reshape the image to get a bigger image with the input image in the center\n\n        '''\n        image3 = numpy.zeros((output_height, output_width), dtype=numpy.float32)\n        d1 = (output_width - image_width) \/\/ 2\n        d0 = (output_height - image_height) \/\/ 2\n        image3[d0:-d0, d1:-d1] = numpy.copy(img)\n        image = image3\n        image_height, image_width = output_height, output_width\n        return image, image_height, image_width\n\n    @unittest.skipIf(test_options.TEST_LOW_MEM, \"low mem\")\n    def test_transform(self):\n        '''\n        tests transform kernel\n        '''\n\n        # Transformation\n        # ---------------\n        matrix = numpy.array([[1.0, -0.75], [0.7, 0.5]], dtype=numpy.float32)\n        offset_value = numpy.array([250.0, -150.0], dtype=numpy.float32)\n        transformation = lambda img: scipy.ndimage.interpolation.affine_transform(img, matrix, offset=offset_value, order=1, mode=\"constant\")\n        image_transformed = transformation(self.image)\n\n        fill_value = numpy.float32(0.0)\n        mode = numpy.int32(1)\n\n        # computing keypoints matching with SIFT\n        sift_plan = SiftPlan(template=self.image, block_size=self.maxwg)\n        kp1 = sift_plan.keypoints(self.image)\n        kp2 = sift_plan.keypoints(image_transformed)  # image2 and image must have the same size\n        match_plan = MatchPlan()  # cls.ctx\n        matching = match_plan.match(kp2, kp1)\n\n        # Retrieve the linear transformation from the matching pairs\n        sol = matching_correction(matching)\n        logger.info(sol)\n\n        # Compute the correction matrix (inverse of transformation)\n        correction_matrix = numpy.zeros((2, 2), dtype=numpy.float32)\n        correction_matrix[0] = sol[0:2, 0]\n        correction_matrix[1] = sol[3:5, 0]\n        matrix_for_gpu = correction_matrix.reshape(4, 1)  # for float4 struct\n        offset_value[0] = sol[2, 0]\n        offset_value[1] = sol[5, 0]\n\n        # Prepare the arguments for the \"transform\" kernel call\n        maxwg = kernel_workgroup_size(self.program, \"transform\")\n        wg = maxwg, 1\n        shape = calc_size(self.image.shape[::-1], wg)\n        gpu_image = pyopencl.array.to_device(self.queue, image_transformed)\n        gpu_output = pyopencl.array.empty(self.queue, self.image.shape, dtype=numpy.float32, order=\"C\")\n        gpu_matrix = pyopencl.array.to_device(self.queue, matrix_for_gpu)\n        gpu_offset = pyopencl.array.to_device(self.queue, offset_value)\n        image_height, image_width = numpy.int32(self.image.shape)\n        output_height, output_width = numpy.int32(gpu_output.shape)\n        kargs = [\n            gpu_image.data,\n            gpu_output.data,\n            gpu_matrix.data,\n            gpu_offset.data,\n            image_width,\n            image_height,\n            output_width,\n            output_height,\n            fill_value, mode\n        ]\n\n        # Call the kernel\n        t0 = time.time()\n        k1 = self.program.transform(self.queue, shape, wg, *kargs)\n        res = gpu_output.get()\n\n        # Reference result\n        t1 = time.time()\n        ref = scipy.ndimage.interpolation.affine_transform(image_transformed, correction_matrix,\n                                                           offset=offset_value,\n                                                           output_shape=(output_height, output_width),\n                                                           order=1,\n                                                           mode=\"constant\",\n                                                           cval=fill_value)\n        t2 = time.time()\n\n        # Compare the implementations\n        delta = numpy.abs(res - ref)\n        delta_arg = delta.argmax()\n        delta_max = delta.max()\n        at_0, at_1 = delta_arg \/ output_width, delta_arg % output_width\n        logger.info(\"Max difference wrt scipy : %f at (%d, %d)\", delta_max, at_0, at_1)\n\n        if self.PROFILE:\n            logger.info(\"Global execution time: CPU %.3fms, GPU: %.3fms.\", 1000.0 * (t2 - t1), 1000.0 * (t1 - t0))\n            logger.info(\"Transformation took %.3fms\", 1e-6 * (k1.profile.end - k1.profile.start))\n\n\ndef suite():\n    testSuite = unittest.TestSuite()\n    testSuite.addTest(TestTransform(\"test_transform\"))\n    return testSuite\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_555","text":"from PyQt5 import QtWidgets\nfrom PyQt5.QtCore import QThread\nfrom scipy.ndimage import center_of_mass\nimport numpy as np\nfrom pymodaq.daq_utils.daq_utils import linspace_step\nfrom pymodaq_pid.utils import PIDModelGeneric, OutputToActuator\n\n\nclass PIDModelBeamSteering(PIDModelGeneric):\n    limits = dict(max=dict(state=True, value=1),\n                  min=dict(state=True, value=-1),)\n    konstants = dict(kp=4, ki=0.05, kd=0.001)\n\n    Nsetpoint = 2\n    setpoint_ini = [600. for ind in range(Nsetpoint)]\n\n    actuators_name = [\"Haxis\", \"Vaxis\"]\n    detectors_name = ['Camera']\n    params = [\n        {'title': 'Threshold', 'name': 'threshold', 'type': 'float', 'value': 10.},\n        {'title': 'Correction sign:', 'name': 'correction_sign', 'type': 'int', 'value': 1, 'min': -1, 'max': 1,\n         'step': 2},\n        {'title': 'Calibration', 'name': 'calibration', 'type': 'group', 'expanded': True, 'visible': True,\n         'children': [\n            {'title': 'Start calibration:', 'name': 'start_calibration', 'type': 'bool', 'value': False},\n            {'title': 'Timeout:', 'name': 'timeout', 'type': 'int', 'value': 10000},\n            {'title': 'Calibration scan', 'name': 'calibration_scan', 'type': 'group', 'expanded': True,\n             'visible': True, 'children': [\n                {'title': 'Number of steps:', 'name': 'number_of_steps', 'type': 'int', 'value': 5},\n                {'title': 'Step size:', 'name': 'step_size', 'type': 'int', 'value': 2}]},\n            {'title': 'Fit parameters', 'name': 'fit_parameters', 'type': 'group', 'expanded': True, 'visible': True,\n             'children': [\n                {'title': 'Slope:', 'name': 'slope', 'type': 'float', 'value': 0.0},\n                {'title': 'Offset:', 'name': 'offset', 'type': 'float', 'value': 0.0}]}]}\n    ]\n\n    def __init__(self, pid_controller):\n        super().__init__(pid_controller)\n        self.pid_controller = pid_controller\n\n    def update_settings(self, param):\n        \"\"\"\n        Get a parameter instance whose value has been modified by a user on the UI\n        Parameters\n        ----------\n        param: (Parameter) instance of Parameter object\n        \"\"\"\n        if param.name() == '':\n            pass\n\n    def get_beam_position(self, image):\n        \"\"\"\n        Get the center of mass of the beam from the image of the camera.\n        All the pixels that are under the threshold are nulled so they do not contribute to the center of mass\n        calculation.\n        Parameters\n        ----------\n        image: (numpy 2d array) Image from the camera.\n\n        Returns\n        -------\n        float: the pixel number corresponding to the center of mass of the beam along this axis.\n        \"\"\"\n        image = image - self.settings.child('threshold').value()\n        image[image < 0] = 0\n        x, y = center_of_mass(image)\n\n        return x, y\n\n    def ini_model(self):\n        super().ini_model()\n\n    def convert_input(self, measurements):\n        \"\"\"\n        Convert the image of the camera into x and y positions of the center of the beam.\n        Parameters\n        ----------\n        measurements: (Ordereddict) Data from the camera\n\n        Returns\n        -------\n        tuple: the coordinate of the center of the beam\n        \"\"\"\n        image = measurements['Camera']['data2D']['Camera_Mock2DPID_CH000']['data']\n        x, y = self.get_beam_position(image)\n        self.curr_input = [x, y]\n        return self.get_beam_position(image)\n\n    def convert_output(self, output, dt, stab=True):\n        \"\"\"\n        Convert the output of the PID in units to be fed into the actuator\n        Parameters\n        ----------\n        output: (float) output value from the PID from which the model extract a value of the same units as the actuator\n\n        Returns\n        -------\n        list: the converted output as a list (if there are a few actuators)\n\n        \"\"\"\n        #print('output converted')\n        \n        self.curr_output = output\n        return OutputToActuator(mode='rel', values=[output])\n\ndef main():\n    from pymodaq.dashboard import DashBoard\n    from pymodaq.daq_utils.daq_utils import get_set_preset_path\n    from pymodaq.daq_utils import gui_utils as gutils\n    from pathlib import Path\n    from PyQt5 import QtWidgets\n    from pymodaq_pid.pid_controller import DAQ_PID\n\n    import sys\n    app = QtWidgets.QApplication(sys.argv)\n    win = QtWidgets.QMainWindow()\n    area = gutils.DockArea()\n    win.setCentralWidget(area)\n    win.resize(1000, 500)\n    win.setWindowTitle('PyMoDAQ Dashboard')\n\n    dashboard = DashBoard(area)\n    file = Path(get_set_preset_path()).joinpath(\"BeamSteering.xml\")\n    if file.exists():\n        dashboard.set_preset_mode(file)\n        # prog.load_scan_module()\n        pid_area = gutils.DockArea()\n        pid_window = QtWidgets.QMainWindow()\n        pid_window.setCentralWidget(pid_area)\n\n        prog = DAQ_PID(pid_area, dashboard.modules_manager)\n        pid_window.show()\n        pid_window.setWindowTitle('PidController')\n        QtWidgets.QApplication.processEvents()\n\n\n    else:\n        msgBox = QtWidgets.QMessageBox()\n        msgBox.setText(f\"The default file specified in the configuration file does not exists!\\n\"\n                       f\"{file}\\n\"\n                       f\"Impossible to load the DAQ_PID Module\")\n        msgBox.setStandardButtons(msgBox.Ok)\n        ret = msgBox.exec()\n\n    sys.exit(app.exec_())\n\n\nif __name__ == '__main__':\n    main()\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_559","text":"\n\nfrom scipy.optimize import Bounds, LinearConstraint, minimize, minimize_scalar,fmin_powell,fmin,basinhopping\nfrom math import pi\nimport cantera as ct\nimport numpy as np\nimport pickle\nfrom keras.layers import Input, Dense, Activation, concatenate\nfrom keras.models import Model\nfrom keras import losses, metrics\nfrom keras import optimizers\nfrom keras import callbacks\nfrom keras.callbacks import CSVLogger\nfrom keras.utils import plot_model\nfrom keras import backend as K\nfrom scipy.optimize.optimize import fminbound\nimport tensorflow as tf\nimport itertools\nfrom functools import partial\nNAME='0606_FPC_modelV11'\ndef objective_function(delta_T, hf_obj, prev_y,raw_T_list,mfr=53.053,p=13,ccl4=1000,\n                       mole_cracking_heat=171, Cp=0.29, Area=pi*11.1*2.54*18\/100):                       \n\n    T_list = raw_T_list + [raw_T_list[-1]+delta_T]\n    print(f\"\\nTubes {len(T_list)-1}:\")\n    print(list(np.round(np.hstack(T_list),2)))\n    \n    compos,t,t_sum = EDC_cracking(T_list,p,ccl4,mfr,n_pfr=len(T_list)-1)\n    with open(f'..\/results\/{NAME}\/clf.pickle', 'rb') as f:\n        scaler = pickle.load(f)\n    # Load model\n    model = build_model()\n    model.load_weights(f\"..\/results\/{NAME}\/model.h5\")\n    x_predict=np.hstack([T_list[-2], T_list[-1], compos,\n                     p, ccl4, t_sum, t, prev_y]).reshape(1,-1)\n    rescaled_X_predict = scaler.transform(x_predict[:, :-1])\n    x_predict = [rescaled_X_predict[:, 0:2],\n                    rescaled_X_predict[:, 2:], x_predict[:, -1]]\n    X = float(model.predict(x_predict))\n    print(f\"prev_y:{prev_y*100:.2f}%\")\n    print(f\"X:{X*100:.2f}%\")\n\n    print(f\"delta_X:{(X-prev_y)*100:.2f}%\")\n    print(f\"delta_T:{delta_T}\")\n    mfr *= 1000  # T\/H to kg\/H\n    EDC_cracked = (X-prev_y)*mfr  # already \/ 100\n    \n    Q1 = mfr * Cp * delta_T\n\n    print(f\"Q1:{Q1}\")\n\n    Q2 = EDC_cracked * mole_cracking_heat\n\n    print(f\"Q2:{Q2}\")\n    print(f\"hf_obj:{hf_obj}\")\n    hf = (Q1+Q2)\/Area  # surface area\n    print(f\"hf_calculated:{hf}\")\n    if delta_T > 25:\n        Q1 *= 1e4\n    if X <= prev_y:\n        Q2 = 1e15*abs(X-prev_y)\n    hf = (Q1+Q2)\/Area\n    print(f\"hf loss: {abs(hf-hf_obj)}\")\n    if(abs(hf-hf_obj)< 500):\n        return 0\n    else:\n        return abs(hf-hf_obj)\/1000\n\ndef build_model(lr=0.001):\n    first_input = Input(shape=(2,), name='Input_layer_1')\n    second_input = Input(shape=(31,), name='Input_layer_2')\n    third_input = Input(shape=(1,), name='Prev_cracking')\n\n    layer = Dense(13, name='Hinden_layer_1')(first_input)\n    layer = Activation('relu')(layer)\n    layer = Dense(15, name='Hinden_layer_2')(layer)\n    layer = Activation('relu')(layer)\n    # layer = Dense(16, name='Hinden_layer_3')(layer)\n    # layer = Activation('relu')(layer)\n    layer = concatenate([layer, second_input], name='Concatenate_layer')\n    layer = Activation('relu')(layer)\n    # layer = Dense(11, name='Hinden_layer_4')(layer)\n    # layer = Activation('relu')(layer)\n    layer = Dense(12, name='Hinden_layer_4')(layer)\n    layer = Activation('relu')(layer)\n    layer = concatenate([layer, third_input], name='Concatenate_layer_2')\n    layer = Dense(1, name='Hinden_layer_5')(layer)\n    output = Activation('sigmoid')(layer)\n    model = Model(inputs=[first_input, second_input, third_input],\n                  outputs=output)\n    model.compile(optimizer=optimizers.Adam(lr=lr),\n                  loss=losses.mean_absolute_error,\n                  metrics=['accuracy', 'mae'])\n    # model.compile(optimizer=optimizers.Adam(lr=lr),\n    #               loss=losses.mean_absolute_error,\n    #               metrics=[metrics.MeanAbsoluteError()])\n\n    # model.compile(optimizer=optimizers.Adam(lr=lr),\n    #               loss='mse',\n    #               metrics=[tf.keras.metrics.MeanSquaredError()])\n    return model\n\ndef EDC_cracking(\n        T_list,\n        pressure_0,\n        CCl4_X_0,\n        mass_flow_rate,\n        reaction_mech='..\/..\/KM\/2009_Schirmeister_EDC\/test.cti',\n        n_steps=1000,\n        n_pfr=22,\n        length=18,\n        area=3.14 * (262 \/ 1000) ** 2 \/ 4\n):\n    \"\"\"\n    Module that runs a single PFR Cantera simulation via a series of CSTRs.\n    The Plug flow reactor is represented by a linear chain of zero-dimensional\n    reactors. The gas at the inlet to the first one has the specified inlet\n    composition, and for all others the inlet composition is fixed at the\n    composition of the reactor immediately upstream. Since in a PFR model there\n    is no diffusion, the upstream reactors are not affected by any downstream\n    reactors, and therefore the problem may be solved by simply marching from\n    the first to last reactor, integrating each one to steady state.\n    Parameters\n    =============== =============================================================\n    Attribute       Description\n    =============== =============================================================\n    `reaction_mech` Cantera reaction mechanism (.cti file)\n    `T_list`        Temperature profile (°C)\n    `pressure_0`    Initial pressue (atm)\n    `CCl4_X_0`      Initial CCl4 concentration (mass fraction)\n    `mass_flow_rate`Mass flow rate of input gas (T\/H)      \n    `n_steps`       Number of iterations\/number of CSTRs\n    `n_pfr`         Number of PFRs\n    `length`        Length of each PFR (m)\n    `area`          Cross-sectional area (m**2)\n    `label`         Label of this mechanism\n    =============== =============================================================\n\n\n    \"\"\"\n    #######################################################################\n    # Input Parameters\n    #######################################################################\n    if CCl4_X_0 > 1:  # ppm\n        CCl4_X_0 = float(CCl4_X_0) \/ 1000000\n    T_0 = 273.15 + T_list[0]  # inlet temperature [K]\n    pressure_0 *= ct.one_atm\n    spcs = ct.Species.listFromFile(reaction_mech)\n    for spc in spcs[::-1]:\n        if spc.composition == {'C': 2.0, 'Cl': 2.0, 'H': 4.0} and spc.charge == 0:\n            EDC_label = spc.name\n        if spc.composition == {'C': 1.0, 'Cl': 4.0} and spc.charge == 0:\n            CCl4_label = spc.name\n    EDC_X_0 = 1 - CCl4_X_0\n    composition_0 = '{}:{}, {}:{}'.format(\n        EDC_label, EDC_X_0, CCl4_label, CCl4_X_0)\n    mass_flow_rate *= 1000 \/ 3600  # T\/H to kg\/s\n\n    # import the gas model and set the initial conditions\n    model = ct.Solution(reaction_mech)\n    model.TPY = T_0, pressure_0, composition_0\n    dz = length \/ n_steps\n    r_vol = area * dz\n\n    # create a new reactor\n    r = ct.IdealGasReactor(model)\n    r.volume = r_vol\n\n    # create a reservoir to represent the reactor immediately upstream. Note\n    # that the gas object is set already to the state of the upstream reactor\n    upstream = ct.Reservoir(model, name='upstream')\n\n    # create a reservoir for the reactor to exhaust into. The composition of\n    # this reservoir is irrelevant.\n    downstream = ct.Reservoir(model, name='downstream')\n\n    # The mass flow rate into the reactor will be fixed by using a\n    # MassFlowController object.\n    m = ct.MassFlowController(upstream, r, mdot=mass_flow_rate)\n\n    # We need an outlet to the downstream reservoir. This will determine the\n    # pressure in the reactor. The value of K will only affect the transient\n    # pressure difference.\n    v = ct.PressureController(r, downstream, master=m, K=1e-5)\n\n    sim = ct.ReactorNet([r])\n\n    # define time, space, and other information vectors\n    z = (np.arange(n_steps) + 1) * dz\n    t = np.zeros(n_pfr)  # residence time in each PFR reactor\n    # compositions of output stream in each PFR reactor\n    compositions = [None] * n_pfr\n    states = ct.SolutionArray(r.thermo)\n    \n    cracking_rates = [0]\n    for i, T in enumerate(T_list[1:]):\n        Ti = T_list[i] + 273.15\n        Te = T + 273.15\n        dT = (Te - Ti) \/ n_steps\n        T = Ti\n        t_r = np.zeros_like(z)  # residence time in each CSTR reactor\n        # iterate through the PFR cells\n        for n in range(n_steps):\n            # simulate the linear T-profile in each reactor\n            T = Ti + (n + 1) * dT\n            model.TP = T, None\n            r.syncState()\n            # Set the state of the reservoir to match that of the previous reactor\n            model.TPY = r.thermo.TPY\n            upstream.syncState()\n            # integrate the reactor forward in time until steady state is reached\n            sim.reinitialize()\n            sim.set_initial_time(0)\n            sim.advance_to_steady_state()\n            # compute velocity and transform into time\n            t_r[n] = r.mass \/ mass_flow_rate  # residence time in this reactor\n            # write output data\n            states.append(r.thermo.state)\n        t[i] = np.sum(t_r)\n        compositions[i] = model.Y[4:]\n        cracking_rate = (\n            EDC_X_0 - model.Y[model.species_index(EDC_label)]) \/ EDC_X_0\n        cracking_rates.append(cracking_rate)\n        t_total = np.sum(t)\n    return compositions[-1], t[-1], t_total\n\nclass MinimizeStopper(object):\n    def __init__(self, f=objective_function, tau=10):\n        self.fun = f                     # set the objective function\n        self.best_x = None\n        self.best_func = np.inf\n        self.tau = tau                   # set the user-desired threshold\n\n    def __call__(self, xk, convergence=None,  *args, **kwds):\n        fval = self.fun(xk, *args, **kwds)\n        if fval < self.best_func:\n            self.best_func = fval\n            self.best_x = xk\n        if self.best_func <= self.tau:\n            print(\"Terminating optimization: objective function threshold triggered\")\n            print(self.best_x)\n            return True\n        else:\n            return False\n\ndef optimize_hf(Te, Ti=350., target_X=55.0, mfr=53.053, p=13., CCl4=1000,\n                mole_cracking_heat=171, Cp=0.29, SurArea=pi*11.1*2.54*18\/100):\n    Total_hf = (target_X * mole_cracking_heat*mfr*1000\/100 + (Te - Ti)*mfr*Cp*1000)\/SurArea\n    # ratio of per tube to total hf\n    ratio = [0.045775715, 0.052760646, 0.054246201, 0.057755337, 0.059452529, 0.060304555, 0.06103342,\n             0.060060211, 0.058149083, 0.052729307, 0.048923541, 0.045456762, 0.042852356, 0.04072963,\n             0.038601821, 0.036790655, 0.0348499, 0.032971834, 0.031425517, 0.029733461, 0.028328363, 0.027069159]\n    T_list = [Ti]\n    X=[0]\n    bounds=[[8,25],[8,25],[8,25],[8,25],[5,20],[3,18],[3,18],[3,18],[1,10],[1,8],[1,6],[0,3],[0,3],[0,2],[0,2],[0,1],[0,1],[0,1]]\n    for i in range(22):\n        # res = fminbound(objective_function,bounds[i][0],bounds[i][1],args=(ratio[i]*Total_hf,X[-1],T_list),\n            # disp=3)\n        # res = basinhopping(objective_function,bounds[i][0],interval=5)\n        # res = minimize(objective_function,bounds[i][0],method='Nelder-Mead',args=(ratio[i]*Total_hf,X[-1],T_list),tol=1e-2,ptions={'fatol': 10})\n        res = fmin(objective_function,1,xtol=0.05,maxiter=1000,args=(ratio[i]*Total_hf,X[-1],T_list),\n            disp=True)\n        T_list.append(T_list[-1]+res[0])\n        compos,t,t_sum = EDC_cracking(T_list,p,CCl4,mfr,n_pfr=len(T_list)-1)\n        with open(f'..\/results\/{NAME}\/clf.pickle', 'rb') as f:\n            scaler = pickle.load(f)\n        # Load model\n        model = build_model()\n        model.load_weights(f\"..\/results\/{NAME}\/model.h5\")\n        x_predict=np.hstack([T_list[-2], T_list[-1], compos,\n                        p, CCl4, t_sum, t, X[-1]]).reshape(1,-1)\n        rescaled_X_predict = scaler.transform(x_predict[:, :-1])\n        x_predict = [rescaled_X_predict[:, 0:2],\n                        rescaled_X_predict[:, 2:], x_predict[:, -1]]\n        X.append(float(model.predict(x_predict)))\n    print('T_list:')\n    print(','.join(map(str(T_list))))\n    print(X)\n        \n\nif __name__ == '__main__':\n    optimize_hf(Te=465.)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_547","text":"<gh_stars>10-100\nimport scipy.io\nimport numpy as np\n\n\ndef main():\n    mat = scipy.io.loadmat('data\/calibration_dataset.mat')\n    pts1 = np.array(mat['mA'], dtype=np.float)[:, :, np.newaxis]\n    pts2 = np.array(mat['mB'], dtype=np.float)[:, :, np.newaxis]\n    pts3 = np.array(mat['mC'], dtype=np.float)[:, :, np.newaxis]\n\n    np.set_printoptions(suppress=True, precision=10)\n\n    dev1 = dev2 = dev3 = 0.0\n    for i in range(24):\n        dev1 += np.sqrt(np.var(pts1[i * 10:(i + 1) * 10] * 1000, axis=0))\n        dev2 += np.sqrt(np.var(pts2[i * 10:(i + 1) * 10] * 1000, axis=0))\n        dev3 += np.sqrt(np.var(pts3[i * 10:(i + 1) * 10] * 1000, axis=0))\n\n    dev1 \/= 24\n    dev2 \/= 24\n    dev3 \/= 24\n\n    dev = (dev1 + dev2 + dev3) \/ 3\n\n    print(\"Coordinatewise deviation: \")\n    print(dev)\n\n    print(\"Average deviation\")\n    print(np.sum(dev) \/ 3)\n\n\nif __name__ == '__main__':\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_557","text":"<reponame>rgalhama\/wordrep_cmcl2020\nimport sys, os\nimport pandas as pd\nimport numpy as np\nfrom scipy import stats\nimport statsmodels.api as sm\nimport statsmodels.formula.api as smf\nfrom statsmodels.stats.outliers_influence import variance_inflation_factor\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=RuntimeWarning)\nfrom configs.config_loader import load_config, opts2record\n\n\n\ndata_fname=\"merged_indegree_train_th%.2faoa_wordbank_eng_understands_prop0.5_nouns_clean_means.csv\"\n\nheader_svd=\"win;thr;\"\nheader_sgns=\"dyn;thr\"\n\ndef write_output(model_type, config, datafile, similarity_threshold, pearsonr, pearson_pval, outputpath):\n\n    params_model=load_config(config)\n    header, record=opts2record(params_model[\"counts\"],params_model[model_type], params_model[\"post\"])\n\n    header=\"model;\"+header\n    record=model_type+\";\"+record\n\n    header+=\"similarity_threshold;\"\n    record+=similarity_threshold+\";\"\n\n    header+=\"pearsonr;pearson_pval\"\n    record+=\"{0:.4f};\".format(pearsonr)\n    record+=\"{0:.4f}\".format(pearson_pval)\n\n\n    outfile=os.path.join(outputpath, \"params_corr_\"+os.path.basename(datafile))\n    with open(outfile, \"w\") as fh:\n        fh.write(header+\"\\n\")\n        fh.write(record+\"\\n\")\n\n    print(\"Correlation saved at:\\n %s\\n\"%outfile)\n\n\ndef main(model_type, config, similarity_th, datafile, outputpath):\n    #Read in data with AoA and computed index\n    df = pd.read_csv(datafile, sep=\";\")\n    X=df[\"index\"]\n    Y=df[\"aoa\"]\n\n    #Read in frequency data and merge\n    df[\"logfreq\"] = np.log(df.freq)\n\n    #Compute stats\n    pearsonr, pearson_pval = stats.pearsonr(X, Y)\n\n    #Write output\n    write_output(model_type, config, datafile, similarity_th, pearsonr, pearson_pval, outputpath)\n\nif __name__ == \"__main__\":\n    args=sys.argv[1:]\n    if len(args) != 5:\n        print(\"Usage: corr_index.py <model_type> <config> <similarity_th> <datafile> <output_path>\")\n        exit(-1)\n    main(*args)\n\n#svd\n#\/home\/rgalhama\/Data_Research\/results_wordrep\/eng_0_60\/svd_thr_100_win_5_dim_500_neg_1\/post_eig_0_neg_1\/\n#0.7\n#\/home\/rgalhama\/Data_Research\/results_wordrep\/eng_0_60\/svd_thr_100_win_5_dim_500_neg_1\/post_eig_0_neg_1\/evaluation_aoa_cdi_0.5_understands_nouns"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_0","text":"import autograd.numpy as np\nfrom autograd import grad, jacobian\nimport matplotlib.pyplot as plt\nfrom scipy.interpolate import CubicSpline, PchipInterpolator\n\n\ndef get_cc_to_tangent(x, y, slope, radius):\n    cc_x = np.zeros(np.size(x))\n    cc_y = np.zeros(np.size(x))\n    for idx, slopei in enumerate(slope):\n        norm_vec = np.array((-slopei, 1))\n        norm_vec = norm_vec \/ np.sqrt(np.sum(norm_vec ** 2))\n        delta = norm_vec * radius\n        cc_x[idx] = delta[0] + x[idx]\n        cc_y[idx] = delta[1] + y[idx]\n\n    return cc_x, cc_y\n\n\ndef is_local_minimum(x, z, z_func, r):\n    # for a point at x, z, check if it is just a local minimum point w.r.t. the road\n    # The check is performed by checking if there are points in the road surface with distance to (x,z)<radius\n    #\n    # the check should be valid if: 1) the grid point is fine enough and 2) the z_func is 1-1 mapping\n    n_point = 100\n    xs = np.linspace(x-r, x+r, n_point)\n    zs = z_func(xs)\n\n    dist = np.sqrt((xs-x)**2 + (zs-z)**2)\n\n    return any(dist<r)\n\n\ndef get_distance(x, z):\n    # compute the curvilinear coordinate quantities\n    dx = np.diff(x)\n    dz = np.diff(z)\n    ds = np.sqrt(dx**2 + dz**2)\n    s = np.cumsum(np.insert(ds, 0, 0))\n    return s\n\n\ndef get_force(s, n, ndot, road_spline, k, c):\n    # compute the force in cartesian coordinate, for a wheel at s, n location in the curvilinear force field\n    # k is spring rate in N\/m, and is +ve. So the force must be opposite to deflection.\n    # c is the viscous term N*s\/m, where F = -lambda*v\n\n    # also for n > 0, the force should be zero! (no deflection, wheel in the air), but we put in a small term to\n    # help the numerics (so it still sees the gradient in the n direciton , even when in the air!)\n\n    if n > 0:\n        k = k*1e-6\n        c = c*1e-6\n\n    theta = road_spline['theta'](s)\n\n    f = -n*k - c*ndot\n    fx = f*np.sin(-theta)\n    fz = f*np.cos(-theta)\n\n    return fx, fz\n\n\ndef sn2xz(s, n, road_spline):\n    x0 = road_spline['x'](s)\n    z0 = road_spline['z'](x0)\n\n    theta = road_spline['theta'](s)\n    x = x0 + np.sin(-theta)*n\n    z = z0 + np.cos(-theta)*n\n\n    return x, z\n\n\ndef build_force_field(z_func, x_min, x_max, r):\n    # return the spline z = f(x) that represents the 0 force contour in the contact force field\n\n    # TODO: constant? (pass from outside?)\n    x_step = r\/5\n    # BUG: n_point must be an integer\n    n_point = int(np.ceil((x_max - x_min)\/x_step))\n\n    # get gradient using autograd\n    dzdx = grad(z_func)\n\n    # get the tangent line of each surface point\n    x_surf = np.linspace(x_min, x_max, n_point)\n\n    slope = [dzdx(x) for x in x_surf]\n    z_surf = z_func(x_surf)\n    cc_x, cc_z = get_cc_to_tangent(x_surf, z_surf, slope, r)\n\n    # identify the points that shouldn't be on the profile\n    b_local_min = [is_local_minimum(x, z, z_func, r) for x, z in zip(cc_x, cc_z)]\n    b_global_min = np.logical_not(b_local_min)\n\n    # create cubic spline for the forcefield centerline\n    x_f0 = cc_x[b_global_min]\n    z_f0 = cc_z[b_global_min]\n\n    # pchip is a lot smoother than cubic, which can be wiggly\n    # TODO: find something that can be differentiated with autograd!\n    zspline = PchipInterpolator(x_f0, z_f0)\n\n    # build (s, kappa) spline\n\n    # first resample uniformly from the spline\n    xs = np.linspace(x_min, x_max, n_point)\n    zs = zspline(xs)\n\n    # compute the curvilinear coordinate quantities\n    dx = np.diff(xs)\n    dz = np.diff(zs)\n    theta = np.arctan2(dz, dx)\n    theta = np.append(theta, theta[-1])\n    ds = np.sqrt(dx**2 + dz**2)\n    s = np.cumsum(np.insert(ds, 0, 0))\n\n    # plt.figure(101)\n    # plt.plot(s, theta)\n    # plt.show()\n\n    # compute theta spline\n    thetaspline = PchipInterpolator(s, theta)\n\n    # x as a function of s\n    xspline = PchipInterpolator(s, xs)\n\n    # kappa is just the 1st derivative of theta w.r.t. s\n    def kappaspline(ss):\n        return thetaspline(ss, 1)\n\n    # put everything in a dictinonary\n    road_spline = {'z':     zspline,\n                   'x':     xspline,\n                   'theta': thetaspline,\n                   'kappa': kappaspline}\n\n    return road_spline\n\ndef get_road(x_min, x_max, r):\n    # surface definition\n    # manually assigned value, further work needs to be done\n    surface_offset = 1\n    step_height = 0.1\n    def z_func(x):\n        # zs = np.linspace(0, 0, xs.size) + surface_offset\n        # zs = np.cos(x * 5 * np.pi)*0.3\n        zs = (np.tanh((x-2)*20)+1)*step_height\/2 + surface_offset\n        return zs\n\n    road_spline = build_force_field(z_func, x_min, x_max, r)\n    return road_spline\n\n\ndef main():\n    r = 0.4\n    x_min = 1.5\n    x_max = 2.5\n    road_spline = get_road(x_min, x_max, r)\n\n    n_point = 100\n    x_surf = np.linspace(x_min, x_max, n_point)\n    z_surf = road_spline['z'](x_surf)\n\n    x_fine = np.linspace(x_min, x_max, n_point*10)\n    z_fine = road_spline['z'](x_fine)\n\n    s_fine = get_distance(x_fine, z_fine)\n\n    # plot\n    plt.figure(1)\n\n    plt.plot(x_surf, z_surf, 'r')\n    plt.plot(x_fine, z_fine, 'gx')\n\n    plt.figure(2)\n    plt.plot(s_fine, road_spline['theta'](s_fine))\n    plt.plot(s_fine, road_spline['kappa'](s_fine), 'r')\n\n    plt.show()\n\n\nif __name__ == '__main__':\n    main()\n\n\n\n\n\n\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_1","text":"<reponame>ruiann\/SignatureVerification\nimport random\nimport numpy as np\nfrom scipy.fftpack import dct\n\nbase_path = '.\/SVC2004\/Task1'\nuseless_line = [0]\n\n\ndef get_writer_list():\n    return range(1, 41)\n\n\ndef genuine_data_range():\n    return range(1, 21)\n\n\ndef fake_data_range():\n    return range(21, 41)\n\n\n# data definition of BIT Handwriting\ndef read_file(path):\n    try:\n        file = open(path, 'r')\n        lines = file.readlines()\n        for line_index in useless_line:\n            del lines[line_index]\n\n        front_p = 0\n        before_front_p = 0\n        sample_x = []\n        sample_y = []\n        velocity_x = []\n        velocity_y = []\n        acceleration_x = []\n        acceleration_y = []\n        for line in lines:\n            line = line.replace('\\r', '')\n            line = line.replace('\\n', '')\n            data = line.split()\n\n            if int(data[3]) != 0:\n                x = int(data[0])\n                y = int(data[1])\n                sample_x.append(x)\n                sample_y.append(y)\n                if front_p == 1:\n                    velocity_x.append(x - front_x)\n                    velocity_y.append(y - front_y)\n                    if before_front_p == 1:\n                        acceleration_x.append(velocity_x[-1] - velocity_x[-2])\n                        acceleration_y.append(velocity_y[-1] - velocity_y[-2])\n                front_x = x\n                front_y = y\n                before_front_p = front_p\n                front_p = 1\n\n            else:\n                before_front_p = front_p\n                front_p = 0\n\n    except:\n        print(path)\n        return None\n\n    # for dct, use velocity & acceleration only\n    return [velocity_x, velocity_y, acceleration_x, acceleration_y]\n\n\ndef get_genuine_data(dir_path=base_path):\n    data = []\n    for writer in get_writer_list():\n        writer_sample = []\n        for index in genuine_data_range():\n            writer_sample.append(read_file('{}\/U{}S{}.TXT'.format(dir_path, writer, index)))\n        data.append(writer_sample)\n    return data\n\n\ndef get_fake_data(dir_path=base_path):\n    data = []\n    for writer in get_writer_list():\n        writer_sample = []\n        for index in fake_data_range():\n            writer_sample.append(read_file('{}\/U{}S{}.TXT'.format(dir_path, writer, index)))\n        data.append(writer_sample)\n    return data\n\n\nclass Data:\n    def __init__(self, dir_path=base_path):\n        self.genuine_data = get_genuine_data(dir_path)\n        self.fake_data = get_fake_data(dir_path)\n        self.writer_list = get_writer_list()\n        self.genuine_range = genuine_data_range()\n        self.fake_range = fake_data_range()\n\n    def norm(self, sequence):\n        sequence = np.array(sequence, dtype=np.float32)\n        mean = sequence.mean()\n        std = sequence.std()\n        sequence = (sequence - mean) \/ std\n        return dct(sequence)[0:20]\n\n    def normalize(self, sample):\n        for i in range(len(sample)):\n            sample[i] = self.norm(sample[i])\n        return sample\n\n    def get_genuine_pair(self):\n        writer = random.sample(self.writer_list, 1)[0] - 1\n        reference_index = random.sample(self.genuine_range, 1)[0] - 1\n        target_index = random.sample(self.genuine_range, 1)[0] - 1\n        reference = self.normalize(self.genuine_data[writer][reference_index])\n        target = self.normalize(self.genuine_data[writer][target_index])\n        return reference, target\n\n    def get_all_genuine_pair(self):\n        pair = []\n        for writer in self.writer_list:\n            writer = writer - 1\n            for reference_index in self.genuine_range:\n                for target_index in self.genuine_range:\n                    if target_index != reference_index:\n                        reference = self.normalize(self.genuine_data[writer][reference_index - 1])\n                        target = self.normalize(self.genuine_data[writer][target_index - 1])\n                        pair.append((reference, target))\n\n        return pair\n\n    def get_fake_pair(self):\n        writer = random.sample(self.writer_list, 1)[0] - 1\n        reference_index = random.sample(self.genuine_range, 1)[0] - 1\n        target_index = random.sample(self.genuine_range, 1)[0] - 1\n        reference = self.normalize(self.genuine_data[writer][reference_index - 1])\n        target = self.normalize(self.fake_data[writer][target_index - 1])\n        return reference, target\n\n    def get_all_fake_pair(self):\n        pair = []\n        for writer in self.writer_list:\n            writer = writer - 1\n            for reference_index in self.genuine_range:\n                for target_index in self.genuine_range:\n                    reference = self.normalize(self.genuine_data[writer][reference_index - 1])\n                    target = self.normalize(self.fake_data[writer][target_index - 1])\n                    pair.append((reference, target))\n\n        return pair\n\n\nif __name__ == '__main__':\n    data = Data()\n    reference, target = data.get_genuine_pair()\n    print(reference)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_2","text":"import unittest\n\nimport numpy as np\nfrom scipy import sparse\n\nfrom linkedin.learner.ds.indexed_dataset import IndexedDataset\nfrom linkedin.learner.ds.indexed_model import IndexedModel\nfrom linkedin.learner.prediction.linear_scorer import score_linear_model\nfrom linkedin.learner.utils.functions import sparse_diag_matrix\n\n\ndef mock_indexed_data():\n    \"\"\"Get a very small mock indexed dataset.\"\"\"\n    labels = np.array([1.0, -1.0, 1.0])\n    weights = np.array([1, 1, 1])\n    offsets = np.array([0.2, 0.3, 0.4])\n    design_matrix = sparse.csc_matrix(np.array([[1.0, 1.0, 0, 0, 0, 0, 0], [1.0, 0, 0, 0, 0, 0, 0], [1.0, 0, 0, 0.5, 1.0, 1.3, 0.8]]))\n    return IndexedDataset(design_matrix, labels, weights, offsets)\n\n\nclass LinearScorerTest(unittest.TestCase):\n    def test_score_linear_model(self):\n        \"\"\"Test linear scoring in the general case.\"\"\"\n        theta = np.array([1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6])\n        hessian = sparse_diag_matrix([2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6])\n        indexed_model = IndexedModel(theta, hessian)\n\n        indexed_data = mock_indexed_data()\n\n        scores = score_linear_model(indexed_model, indexed_data)\n\n        expected_scores = np.array(\n            [0.2 + 1.0 * 1.0 + 1.0 * 0.1, 0.3 + 1.0 * 1.0, 0.4 + 1.0 * 1.0 + 0.5 * 0.3 + 1.0 * 0.4 + 1.3 * 0.5 + 0.8 * 0.6]\n        )\n\n        self.assertTrue(all(scores == expected_scores), f\"Scores match expected scores. Actual {scores} == expected {expected_scores}.\")\n\n        scores_with_exploration = score_linear_model(indexed_model, indexed_data, exploration_threshold=1)\n\n        self.assertTrue(\n            all(scores_with_exploration != expected_scores),\n            f\"Scores with exploration don't exactly match expected scores. Actual {scores} == expected {expected_scores}.\",\n        )\n\n    def test_score_linear_model_offsets_only(self):\n        \"\"\"Test linear scoring when all coefficients are zero.\"\"\"\n        num_features = 7\n        theta = np.zeros(num_features)\n        indexed_model = IndexedModel(theta)\n        indexed_data = mock_indexed_data()\n\n        scores = score_linear_model(indexed_model, indexed_data)\n\n        expected_scores = np.array([0.2, 0.3, 0.4])\n\n        self.assertTrue(\n            all(scores == expected_scores),\n            f\"Offsets are used for scores when model coeffs are all zero\/missing. Actual {scores} == expected {expected_scores}.\",\n        )\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_3","text":"<reponame>qinyichen\/UCLA-Subgraph-Matching\nimport sys\nsys.path.append(\"..\")\n\nimport uclasm\nimport numpy as np\nfrom scipy import sparse\n\n# First we must generate some data\n# The number of edges between nodes will be iid geometric with the chosen params\n# A signal will be placed in the top left block of the world graph by addition\n\nn_channels = 2\nn_tmplt_nodes = 5\nn_world_nodes = 100\ntmplt_p = 0.85\nworld_p = 0.8\n\n# Now generate world and template graphs, inserting a signal in the top left\n\nnp.random.seed(0)\n\nchannels = list(range(n_channels))\n\n# TODO: allow for nodes of arbitrary dtype\n\n# Note: by design, the template nodes have the same ids as the signal nodes\ntmplt_nodes = np.arange(n_world_nodes, n_world_nodes+n_tmplt_nodes)\nworld_nodes = np.arange(n_world_nodes, 2*n_world_nodes)\n\ntmplt_adj_mats = []\nworld_adj_mats = []\n\nfor channel in channels:\n    tmplt_adj = np.random.geometric(tmplt_p, (n_tmplt_nodes, n_tmplt_nodes)) - 1\n    world_adj = np.random.geometric(world_p, (n_world_nodes, n_world_nodes)) - 1\n\n    # Embed a signal in the top left block of the world graph\n    world_adj[:n_tmplt_nodes, :n_tmplt_nodes] += tmplt_adj\n\n    tmplt_adj_mats.append(sparse.csc_matrix(tmplt_adj))\n    world_adj_mats.append(sparse.csc_matrix(world_adj))\n\n\n# initial candidate set for template nodes is the full set of world nodes\ntmplt = uclasm.Template(world_nodes, tmplt_nodes, channels, tmplt_adj_mats)\nworld = uclasm.World(world_nodes, channels, world_adj_mats)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_4","text":"import numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import fftpack\n\n\nf = 10\nf_s = 100\n\nt = np.linspace(0, 2, 2 * f_s, endpoint=False)\nx = np.sin(2 * np.pi * f * t)\n\n\n# fig, ax = plt.subplots()\n# ax.plot(t, x)\n# ax.set_xlabel(\"Time [s]\")\n# ax.set_ylabel(\"Amplitude\")\n\nX = fftpack.fft(x)\nX = X[:int(len(X)\/2)]\nfreqs = fftpack.fftfreq(len(x)) * f_s\nfreqs = freqs[:int(len(freqs)\/2)]\nprint(freqs)\n\nfig, ax = plt.subplots()\n\nax.stem(freqs, np.abs(X))\nax.set_xlabel('Frequency in Hertz [Hz]')\nax.set_ylabel('Frequency Domain (Spectrum) Magnitude')\nax.set_xlim(-f_s \/ 2, f_s \/ 2)\nax.set_ylim(-5, 110)\n\nplt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_5","text":"<gh_stars>0\n'''This script demonstrates how to build a variational autoencoder with Keras.\n\n #Reference\n\n - Auto-Encoding Variational Bayes\n   https:\/\/arxiv.org\/abs\/1312.6114\n'''\nfrom __future__ import print_function\n\nimport csv\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import norm\n\nfrom keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, BatchNormalization, Activation\nfrom keras.utils import plot_model\nfrom keras.layers import Dense, Lambda, Flatten, Reshape, Layer, Conv2DTranspose\nfrom keras.models import Model\nfrom keras import backend as K\nfrom keras import metrics\nfrom util.summary_model import summary_and_png\n\n\ndef vae_model(channel):\n\n    batch_size = 8\n    input_shape = (256,256,3)\n    img_rows,img_cols = input_shape[:2]\n    latent_dim = 2\n    intermediate_dim = 256\n    epochs = 100\n    epsilon_std = 1.0\n\n\n    # encoder architecture\n    input_img = Input(shape=input_shape)\n    x = Conv2D(16, (3, 3), padding='same')(input_img)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = MaxPooling2D((2, 2), padding='same')(x)\n    x = Conv2D(16, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = MaxPooling2D((2, 2), padding='same')(x)\n    x = Conv2D(32, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = MaxPooling2D((2, 2), padding='same')(x)\n    x = Conv2D(32, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = MaxPooling2D((2, 2), padding='same')(x)\n    x = Conv2D(64, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = MaxPooling2D((2, 2), padding='same')(x)\n    x = Conv2D(64, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    encoded = MaxPooling2D((2, 2), padding='same')(x)\n\n    flat = Flatten()(encoded)\n    hidden = Dense(intermediate_dim, activation='relu')(flat)\n    #2次元平面の平均と分散\n    z_mean = Dense(latent_dim)(hidden)\n    z_log_var = Dense(latent_dim)(hidden)\n\n    # note that \"output_shape\" isn't necessary with the TensorFlow backend\n    z = Lambda(_sampling, output_shape=(latent_dim,))([z_mean, z_log_var])\n\n    # we instantiate these layers separately so as to reuse them later\n    decoder_hid = Dense(intermediate_dim, activation='relu')(z)\n    decoder_upsample = Dense(64 * 16 * 16, activation='relu')(decoder_hid)\n    decoder_reshape = Reshape((16, 16, 64))(decoder_upsample)\n    x = Conv2D(64, (3, 3), padding='same')(decoder_reshape)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(64, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(32, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(32, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(16, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(16, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    x = Activation('relu')(x)\n    x = UpSampling2D((2, 2))(x)\n    x = Conv2D(channel, (3, 3), padding='same')(x)\n    x = BatchNormalization()(x)\n    decoded = Activation('sigmoid')(x)\n\n    y = CustomVariationalLayer()([input_img, decoded])\n    vae = Model(input_img, y)\n\n    summary_and_png(vae, summary, to_png, png_file)\n\n\n\n    def _sampling(self, args):\n        z_mean, z_log_var = args\n        epsilon = K.random_normal(shape=(K.shape(z_mean)[0], self.latent_dim), mean=0.,\n                                stddev=self.epsilon_std)\n        return z_mean + K.exp(z_log_var \/ 2) * epsilon\n\n\n    # Custom loss layer\n    class CustomVariationalLayer(Layer):\n        def __init__(self, **kwargs):\n            self.is_placeholder = True\n            super(CustomVariationalLayer, self).__init__(**kwargs)\n\n        def vae_loss(self, x, x_decoded_mean_squash):\n            x = K.flatten(x)\n            x_decoded_mean_squash = K.flatten(x_decoded_mean_squash)\n            xent_loss = img_rows * img_cols * metrics.binary_crossentropy(x, x_decoded_mean_squash)\n            kl_loss = - 0.5 * K.mean(1 + .z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)\n            return K.mean(xent_loss + kl_loss)\n\n        def call(self, inputs):\n            x = inputs[0]\n            x_decoded_mean_squash = inputs[1]\n            loss = self.vae_loss(x, x_decoded_mean_squash)\n            self.add_loss(loss, inputs=inputs)\n            return x\n\n    return vae\n\n\nif __name__ == '__main__':\n    network = VAE(channel=3)\n    model = network.get_model(to_png=True, png_file='vae_model.png')\n    model.compile(optimizer='adam', loss=None)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_6","text":"#!python36\n# -*- coding: utf-8 -*-\n\"\"\"\nNCams Toolbox\nCopyright 2019-2020 <NAME>, <NAME>\nhttps:\/\/github.com\/CMGreenspon\/NCams\n\n\"\"\"\nimport os\n\nimport matplotlib.pyplot as mpl_pp\nfrom scipy.spatial.transform import Rotation as R\n\nimport ncams\n\n\ndef import_kinematics():\n    # Translate the triangulated data into OSim trc format\n    BASE_DIR = os.path.join('C:\/\/', 'FLIR_cameras', 'PublicExample')\n    proj_path = os.path.join(BASE_DIR, '2019.12.20_8camsNoMarkers-AS-2019-12-23')\n    triangulated_path = os.path.join(proj_path, 'triangulated_full_rank_0.9', 'session4')\n    ik_dir = os.path.join(proj_path, 'inverse_kinematics')\n    if not os.path.isdir(ik_dir):\n        os.mkdir(ik_dir)\n\n    # load a csv file into a dictionary by specified column names\n    marker_name_dict = ncams.utils.dic_from_csv('marker_meta.csv', 'sDlcMarker', 'sOpenSimMarker')\n\n    triangulated_csv = os.path.join(triangulated_path, 'triangulated_points_4_smoothed.csv')\n\n    # rotate the data from the NCams coordinate system\n    # preview the rotations by loading the model and using 'File->Preview experimental data'\n    # the right click on the loaded kinematics and 'Transform'. If using our model and our\n    # calibration, the rotations should be as described below:\n    r = R.from_euler('zyx', [0, 90, 180], degrees=True)\n    # scipy.spatial.transform.Rotation.apply returns an ndarray with vertical vectors, so the\n    # function is changed in the lambda\n    rot = lambda v: r.apply(v)[0].tolist()\n\n    suffixes = ['remote', 'marshmallow', 'wave', 'pen']\n    frame_ranges = [(103, 140), (260, 360), (510, 650), (1919, 2019)]\n    for frame_range, suffix in zip(frame_ranges, suffixes):\n        trc_file = os.path.join(ik_dir, 'triangulated_4_{}.trc'.format(suffix))\n\n        # makes an IK config\n        ik_file = os.path.join(ik_dir, 'full_arm_model_IK_4_{}.xml'.format(suffix))\n        ik_out_mot_file = os.path.join(ik_dir, 'out_inv_kin_4_{}.mot'.format(suffix))\n\n        ncams.inverse_kinematics.triangulated_to_trc(\n            triangulated_csv, trc_file, marker_name_dict,\n            data_unit_convert=lambda x: x*100,  # dm to mm\n            rate=50, zero_marker='scapula_anterior', frame_range=frame_range, rotation=rot,\n            ik_file=ik_file, ik_out_mot_file=ik_out_mot_file)\n\n\ndef filter_joint_angles():\n    # Translate the triangulated data into OSim trc format\n    BASE_DIR = os.path.join('C:\/\/', 'FLIR_cameras', 'PublicExample')\n    proj_path = os.path.join(BASE_DIR, '2019.12.20_8camsNoMarkers-AS-2019-12-23')\n    ik_dir = os.path.join(proj_path, 'inverse_kinematics')\n\n    suffixes = ['remote', 'marshmallow', 'wave', 'pen']\n    for suffix in suffixes:\n        ik_out_mot_file = os.path.join(ik_dir, 'out_inv_kin_4_{}.mot'.format(suffix))\n        ik_filtered_mot_file = os.path.join(ik_dir, 'out_inv_kin_4_{}_filtered.mot'.format(suffix))\n        ncams.inverse_kinematics.smooth_motion(ik_out_mot_file, ik_filtered_mot_file,\n                                               median_kernel_size=11)\n\n\ndef make_combined_videos():\n    # Translate the triangulated data into OSim trc format\n    BASE_DIR = os.path.join('C:\/\/', 'FLIR_cameras', 'PublicExample')\n    proj_path = os.path.join(BASE_DIR, '2019.12.20_8camsNoMarkers-AS-2019-12-23')\n    config_path = os.path.join(proj_path, 'config.yaml')\n    ik_dir = os.path.join(proj_path, 'inverse_kinematics')\n\n    triangulated_path = os.path.join(proj_path, 'triangulated_full_rank_0.9', 'session4')\n    triangulated_csv = os.path.join(triangulated_path, 'triangulated_points_4_smoothed.csv')\n\n    suffixes = ['remote', 'marshmallow', 'wave', 'pen']\n    frame_ranges = [(103, 140), (260, 360), (510, 650), (1919, 2019)]\n    # estimate manually with an external program, e.g. MPC-HC, easier if recorded more than one loop\n    # from OpenSim\n    frame_offsets = [23, 0, 7, 3]\n    video_path = os.path.join(BASE_DIR, 'exp_session_2019.12.20_videos', '4_cam19335177.mp4')\n    for frame_range, suffix, frame_offset in zip(frame_ranges, suffixes, frame_offsets):\n        # Load the motion generated during inverse kinematics and play it.\n        # To record a video, press a camera button in the top right corner of the viewer. To stop\n        # recording, press the button again. Save the video path to 'ik_video_path'.\n        ik_video_path = os.path.join(ik_dir, '4_{}.webm'.format(suffix))  # manually set filename\n        output_path = os.path.join(ik_dir, '4_{}_19335177_4.mp4'.format(suffix))\n        ncams.make_triangulation_video(\n            video_path, triangulated_csv, skeleton_config=config_path,\n            frame_range=frame_range, output_path=output_path,\n            thrd_video_path=ik_video_path,\n            thrd_video_frame_offset=frame_offset,  # if the IK movement starts later\n            third_video_crop_hw=[slice(0, -100), slice(350, -700)],  # crops the IK video\n            figure_dpi=300,\n            ranges=((-0.33, 3), (-2, 2), (-1.33, 6.74)),  # manually set ranges for 3D plot\n            plot_markers=False, horizontal_subplots=True)\n\n\ndef make_gifs_and_timeseries():\n    BASE_DIR = os.path.join('C:\/\/', 'FLIR_cameras', 'PublicExample')\n    proj_path = os.path.join(BASE_DIR, '2019.12.20_8camsNoMarkers-AS-2019-12-23')\n    ik_dir = os.path.join(proj_path, 'inverse_kinematics')\n\n    filenames = ['4_marshmallow_19335177_4', '4_pen_19335177_4', '4_remote_19335177_4',\n                 '4_wave_19335177_4']\n    # filenames = ['4_marshmallow_19335177_4']\n    for filename in filenames:\n        video = os.path.join(ik_dir, '{}.mp4'.format(filename))\n        video_images_dir = os.path.join(ik_dir, '{}'.format(filename))\n        ncams.image_tools.video_to_images(video, output_directory=ik_dir, output_format='jpeg')\n        video_images = ncams.utils.get_image_list(path=video_images_dir)\n        gif = os.path.join(ik_dir, '{}.gif'.format(filename))\n        ncams.image_tools.images_to_video(video_images, gif, fps=25)\n\n        video = os.path.join(ik_dir, '{}_vertical2.mp4'.format(filename))\n        fig_name = os.path.join(ik_dir, '{}_timeseries.png'.format(filename))\n        ncams.image_tools.video_to_timeseries(video, fig_name, num_images=5, figure_size=(9, 5),\n                                              figure_dpi=200,\n                                              crop_hw=[slice(450, -350), slice(2275, -2150)])\n\n\nif __name__ == '__main__':\n    # import_kinematics()\n    # filter_joint_angles()\n    # make_combined_videos()\n    make_gifs_and_timeseries()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_7","text":"<filename>matching_algorithms.py\nfrom sys import float_info\nfrom essentia.standard import Mean\nimport numpy as np\nfrom scipy.ndimage.interpolation import shift\nfrom constants import (\n    PLSH_INDEX,\n    NLSH_INDEX,\n    COSINE_SIMILARITY,\n    JACCARD_SIMILARITY,\n    MANHATTAN_DISTANCE,\n    LINEAR_SCALING,\n    BALS,\n    BALS_SHIFT_SIZE,\n    RECURSIVE_ALIGNMENT,\n    MAX_RA_DEPTH,\n    KTRA,\n    MAX_KTRA_DEPTH,\n    INITIAL_KTRA_K_VALUE\n)\nfrom utils import percent\n\n\n__all__ = [\"apply_matching_algorithm_to_lsh\"]\n\nMAX_FLOAT = float_info.max\nmean = Mean()\n\n\ndef _mean_substract(pitch_vector):\n    pitch_vector = np.array(pitch_vector, dtype=np.float32)\n    return pitch_vector - mean.compute(pitch_vector)\n\n\ndef calculate_cosine_similarity(query_tfidfs, song_tfidfs, **kwargs):\n    \"\"\"\n    Cosine Similarity (d1, d2) = Dot product(d1, d2) \/ ||d1|| * ||d2||\n    \"\"\"\n\n    # NOTE: this ignores songs longer size, and considers only the\n    # first query-length pitches\n    dot_product = sum(p*q for p,q in zip(query_tfidfs, song_tfidfs))\n\n    query_norm = np.sqrt( np.sum( np.square(query_tfidfs)))\n    candidate_norm = np.sqrt( np.sum( np.square(song_tfidfs)))\n\n    norms = query_norm * candidate_norm\n\n    cosine = 0.0\n    if norms != 0:\n        cosine = dot_product\/norms\n\n    return cosine\n\n\ndef calculate_jaccard_similarity(query_audio, candidate, **kwargs):\n    \"\"\"\n    Calculates Jaccard distance in a generic way.\n    Jaccard Similarity algorithm in steps:\n    1. Get the shared members between both sets, i.e. intersection.\n    2. Get the members in both sets (shared and un-shared, i.e. union).\n    3. Divide the number of shared members found in (1) by the total number of\n       members found in (2).\n    4. Multiply the found number in (3) by 100.\n    \"\"\"\n    intersection = np.intersect1d(candidate, query_audio)\n    union = np.union1d(candidate, query_audio)\n\n    jaccard_similarity = 0\n    if union.size > 0:\n        jaccard_similarity = (intersection.size \/ union.size) * 100\n\n    return jaccard_similarity\n\n\ndef __calculate_jaccard_similarity(query_audio, candidate, **kwargs):\n    '''\n    WARNING: Use this algorithm ONLY for THIS LSH environment purposes. If you\n    want to calculate Jaccard distance in a generic way, please use\n    calculate_jaccard_similarity.\n    \n    Jaccard Similarity algorithm in steps:\n    1. Get the shared members between both sets, i.e. intersection.\n    2. Get the members in both sets (shared and un-shared, i.e. union).\n    3. Divide the number of shared members found in (1) by the total number of\n       members found in (2).\n    4. Multiply the found number in (3) by 100.\n    '''\n    from lsh import (\n        exec_plsh_pitch_extraction as extract_plsh_pitches,\n        exec_nlsh_pitch_extraction as extract_nlsh_pitches\n    )  # this fixes circular import error\n\n    index_type = kwargs.get('index_type')\n\n    exec_pitch_extraction = {\n        PLSH_INDEX: extract_plsh_pitches,\n        NLSH_INDEX: extract_nlsh_pitches\n    }\n\n    query_chunks = exec_pitch_extraction[index_type](query_audio.tolist())\n    candidate_chunks = exec_pitch_extraction[index_type](candidate.tolist())\n\n    jaccard_similarity = calculate_jaccard_similarity(\n        query_chunks,\n        candidate_chunks\n    )\n\n    return jaccard_similarity\n\n\ndef _rescale_audio(query_audio):\n    # ------------------[0.5, 0.75, 1.0, 1.25, 1.5]\n    scaling_factors = ((1, 2), (3, 4), (1, 1), (5, 4), (3, 2))\n    original_len = query_audio.size\n    rescaled_audios = []\n    for numerator, denominator in scaling_factors:\n        rescaled_audio = np.array([])\n        scaling_factor = numerator \/ denominator\n        if scaling_factor == 1.0:\n            rescaled_audio = np.copy(query_audio)\n        else:\n            # Shorten or lenghten audio\n            numerator, denominator = scaling_factor.as_integer_ratio()\n            for i in range(0, original_len, denominator):\n                chunck = query_audio[i:i + denominator]\n                if scaling_factor > 1.0:\n                    # Lenghten audio\n                    # FIXME: only works for 1.25 (5,4) and 1.5 (3,2)\n                    repeated = chunck[-1]\n                    chunck = np.append(chunck, repeated)\n                rescaled_audio = np.append(rescaled_audio, chunck[:numerator])\n        rescaled_audios.append(rescaled_audio)\n\n    return rescaled_audios\n\n\ndef _calculate_manhattan_distance(rescaled_audio, candidate):\n    additional_length = candidate.size - rescaled_audio.size\n\n    # Equalize size\n    if additional_length > 0:\n        rescaled_audio = np.append(rescaled_audio, np.zeros(additional_length))\n    elif additional_length < 0:\n        rescaled_audio = rescaled_audio[:candidate.size]\n\n    # Calculate distance\n    result = np.absolute(\n        np.subtract(candidate, rescaled_audio)\n    )\n    return sum(result)\n\n\ndef _calculate_linear_scaling(\n    rescaled_query_audios, candidate, **kwargs\n):\n    '''\n    Implemented as explained in \"Query-By-Singing-and-Hummimg\" from CHIAO-WEI\n    LIN.\n    '''\n    include_zero_distance = kwargs.get('include_zero_distance')\n    if not isinstance(rescaled_query_audios, list):\n        rescaled_query_audios = [rescaled_query_audios]\n    distances = []\n    for rescaled_query_audio in rescaled_query_audios:\n        distance = _calculate_manhattan_distance(\n            rescaled_query_audio,\n            candidate\n        )\n        if distance > 0.0 or include_zero_distance:\n            distances.append((distance, rescaled_query_audio))\n    if not distance:\n        # Ignoring zero distance. (It's likely a noise)\n        min_distance, query = MAX_FLOAT, None\n    else:\n        min_distance, query = min(distances, key=lambda t: t[0])\n    return min_distance, query\n\n\ndef _get_candidate_neighbourhood(**kwargs):\n    # FIXME: Looks a little bit (or a lot) wrong\n    candidate = kwargs.get('candidate')\n    candidate_name = kwargs.get('candidate_name')\n    original_positions_mapping = kwargs.get('original_positions_mapping')\n    neighbours = []\n    # Apply shift, shorthen, lengthen operations\n    # Left moved vector\n    left_moved_vector = shift(candidate, BALS_SHIFT_SIZE)\n    # Right moved vector\n    right_moved_vector = shift(candidate, -BALS_SHIFT_SIZE)\n    # TODO: Left shortened vector\n    # TODO: Right shortened vector\n    # Left lenghtened vector\n    left_lenghtened = shift(candidate, BALS_SHIFT_SIZE, mode='nearest')\n    # Right lenghtened vector\n    right_lenghtened = shift(candidate, -BALS_SHIFT_SIZE, mode='nearest')\n\n    # Tem algo que parece não estar certo... É para aplicar as operações sobre\n    # cada trecho do áudio candidato ou sobre ele como um todo? Ou ainda,\n    # sobre um único fragmento candidato?\n    neighbours = [\n        left_moved_vector,\n        right_moved_vector,\n        left_lenghtened,\n        right_lenghtened\n    ]\n\n    return neighbours\n\n\ndef _calculate_bals(rescaled_query_audios, candidate, **kwargs):\n    '''\n    Explore candidates neighbourhood\n       - For each candidate, lenghten or shorten it.\n    For each neighbor, measure LS distance.\n    Retain the fragment with the shortest distance.\n    '''\n    candidate_distance, _query = _calculate_linear_scaling(\n        rescaled_query_audios, candidate, include_zero_distance=True\n    )\n\n    kwargs['candidate'] = candidate\n\n    neighbours = _get_candidate_neighbourhood(**kwargs)\n    # Starts with the similar audio\n    nearest_neighbour_distance = candidate_distance\n    for neighbour in neighbours:\n        distance, _query = _calculate_linear_scaling(\n            rescaled_query_audios,\n            neighbour,\n            include_zero_distance=True\n        )\n        if distance < nearest_neighbour_distance:\n            nearest_neighbour_distance = distance\n\n    return nearest_neighbour_distance\n\n\ndef _recursive_align(query_audio, candidate, **kwargs):\n    # Compute the linear distance of the corresponding part\n    min_distance, rescaled_query_audio = _calculate_linear_scaling(\n        query_audio,\n        candidate=candidate,\n        include_zero_distance=False\n    )\n\n    depth = kwargs.get('depth', 0)\n\n    try:\n        if rescaled_query_audio.size == 0 or candidate.size == 0:\n            return min_distance\n        # raise Exception('size zero detected!!!')\n    except AttributeError:\n        return min_distance\n\n    if depth < MAX_RA_DEPTH:\n        query_size = rescaled_query_audio.size\n        candidate_size = candidate.size\n        query_portion_size = int((query_size \/ 2) + 1)\n        # portion_percents = [10, 20, 30, 40, 50, 60, 70, 80, 90] # Too slow\n        portion_percents = [40, 50, 60]\n        for portion_percent in portion_percents:\n            size = int(\n                percent(portion_percent, candidate_size) + 1\n            )\n            complement_size = candidate_size + 1 - size\n            left_query_portion = rescaled_query_audio[:query_portion_size]\n            right_query_portion = rescaled_query_audio[query_portion_size:]\n            left_similar_portion = candidate[:size]\n            right_similar_portion = candidate[complement_size:]\n\n            left_distance = _recursive_align(\n                left_query_portion,\n                left_similar_portion,\n                depth=depth + 1\n            )\n\n            right_distance = _recursive_align(\n                right_query_portion,\n                right_similar_portion,\n                depth=depth + 1\n            )\n\n            min_distance = min([left_distance, right_distance, min_distance])\n\n    return min_distance\n\n\ndef _calculate_ktra(query_audio, candidate, **kwargs):\n    depth = kwargs.get('depth', 0)\n\n    if depth == 0:\n        query_audio = _mean_substract(query_audio)\n        candidate = _mean_substract(candidate)\n\n    k = kwargs.get('k', INITIAL_KTRA_K_VALUE)\n\n    d_minus = _recursive_align(query_audio - k, candidate, depth=0)\n    d_zero = _recursive_align(query_audio, candidate, depth=0)\n    d_plus = _recursive_align(query_audio + k, candidate, depth=0)\n\n    min_distance = min([d_minus, d_zero, d_plus])\n    if depth < MAX_KTRA_DEPTH:\n        # FIXME: Needs to treat equal distances?\n        if d_minus == min_distance:\n            query_audio = query_audio - k\n        elif d_plus == min_distance:\n            query_audio = query_audio + k\n\n        min_distance = _calculate_ktra(\n            query_audio,\n            candidate,\n            k=k \/ 2,\n            depth=depth + 1\n        )\n\n    return min_distance\n\n\ndef apply_matching_algorithm_to_lsh(\n    choosed_algorithm, query, candidates, index_type, original_positions_mapping, use_ls\n):\n    \"\"\"\n    Applies mathing algorithm in LSH search context. It means\n    this function should be used after LSH retrieval, in order to filter\n    the found candidates.\n    \"\"\"\n    matching_algorithms = {\n        JACCARD_SIMILARITY: __calculate_jaccard_similarity,\n        LINEAR_SCALING: _calculate_linear_scaling,\n        BALS: _calculate_bals,\n        RECURSIVE_ALIGNMENT: _recursive_align,\n        KTRA: _calculate_ktra\n    }\n\n    all_queries_distances = {}\n    for query_audio_name, query_audio in query:\n        query_audio = np.array(query_audio)\n        query_audio = np.trim_zeros(query_audio)\n        query_distance = dict()\n        if use_ls or choosed_algorithm in [LINEAR_SCALING, BALS]:\n            # Rescaling here to optmize time consumption\n            query_audios = _rescale_audio(query_audio)\n        else:\n            # not an array for jaccard, ra and ktra with use_ls=False\n            query_audios = query_audio\n        for candidate_tuple in candidates:\n            candidate_filename, candidate = candidate_tuple\n            candidate = np.array(candidate)\n            candidate = np.trim_zeros(candidate)\n\n            if use_ls and choosed_algorithm == KTRA:\n                # NOTE: returns just one query audio here!\n                _min_distance, query_audios = _calculate_linear_scaling(\n                    query_audios,\n                    candidate,\n                    include_zero_distance=True\n                )\n            ##\n            distance_or_similarity = matching_algorithms[choosed_algorithm](\n                query_audios,\n                candidate,\n                query_audio_name=query_audio_name,\n                index_type=index_type,  # For Jaccard\n                include_zero_distance=True,  # For LS and BALS\n                original_positions_mapping=original_positions_mapping,\n                depth=0,  # For RA and KTRA\n                k=INITIAL_KTRA_K_VALUE  # For KTRA\n            )\n            ##\n            if choosed_algorithm == LINEAR_SCALING:\n                query_distance[candidate_filename] = distance_or_similarity[0]\n            else:\n                query_distance[candidate_filename] = distance_or_similarity\n\n        reverse_order = False\n        if choosed_algorithm == JACCARD_SIMILARITY:\n            reverse_order = True\n\n        query_distance = sorted(\n            query_distance.items(),\n            key=lambda res: res[1],\n            reverse=reverse_order\n        )\n        all_queries_distances[query_audio_name] = query_distance\n\n    return all_queries_distances\n\n\ndef apply_matching_algorithm_to_tfidf(choosed_algorithm, **kwargs):\n    \"\"\"\n    Applies mathing algorithm in TF-IDF search context.\n    \"\"\"\n    matching_algorithms = {\n        JACCARD_SIMILARITY: calculate_jaccard_similarity,\n        COSINE_SIMILARITY: calculate_cosine_similarity,\n        # MANHATTAN_DISTANCE: _calculate_manhattan_distance,\n        \n        # TODO: Adapt methods for this context\n        LINEAR_SCALING: _calculate_linear_scaling,\n        BALS: _calculate_bals,\n        RECURSIVE_ALIGNMENT: _recursive_align,\n        KTRA: _calculate_ktra\n    }\n\n    if choosed_algorithm in [LINEAR_SCALING, BALS]:\n        raise(f'{LINEAR_SCALING} and {BALS} are not implemented for tfidf.')\n\n    # if choosed_algorithm in [LINEAR_SCALING, BALS]:\n    #     _query = _rescale_audio(query)\n    # else:\n    #     _query = query\n\n    if choosed_algorithm == COSINE_SIMILARITY:\n        result = calculate_cosine_similarity(\n            query_tfidfs=kwargs.get('query_tfidfs'),\n            song_tfidfs=kwargs.get('song_tfidfs')\n        )\n    else:\n        result = matching_algorithms[choosed_algorithm](\n            query_audio=kwargs.get('query'),\n            candidate=kwargs.get('song')\n        )\n\n    # if choosed_algorithm == LINEAR_SCALING:\n    #     # Returns distance and query. Needs only the query\n    #     distance_or_similarity = distance_or_similarity[0]\n\n    return result\n\n\ndef normalize_distance_to_similarity(queries_expected_songs_and_distances):\n    \"\"\"\n    Tries to \"normalize\" distance to similarity range [0-100].\n    Bigger distances must result in the smaller similarities, and the\n    other way around.\n    Exponential function: f(x) = (e^(1\/x)) - 1\n    f(x) = similarity\n    x = distance\n    \"\"\"\n\n    similarities = {}\n    for query_name, expected_song_name, distance in queries_expected_songs_and_distances:\n        similarity = np.exp(1\/distance) - 1\n        similarities[query_name] = 100.0 if similarity > 100 else similarity \n        print(f\"{query_name} : distance={distance}\\tsimilarity={similarities[query_name]}\")\n\n    return similarities\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_8","text":"<gh_stars>0\nimport unittest\nfrom parameterized import parameterized\nimport numpy as np\nimport pandas as pd\n\nimport neuroseries as nts\nimport os\n\nclass TsTestCase(unittest.TestCase):\n    def setUp(self):\n        pass\n\n    def tearDown(self):\n        pass\n\n    def test_create_ts(self):\n        \"\"\"\n        calling convention\n        ts = nts.Ts(a)\n        ts is an instance of pd.DataFrame\n        \"\"\"\n        a = np.random.randint(0, 10000000, 100)\n        a.sort()\n        ts = nts.Ts(a)\n        self.assertIsInstance(ts, pd.Series, msg=\"ts doesn't return DataFrame\")\n        self.assertIsInstance(ts.index.values, np.ndarray,\n                              msg=\"ts doesn't return array values\")\n        self.assertIs(ts.index.dtype, np.dtype(np.int64), msg='index type is not int64')\n        np.testing.assert_array_almost_equal_nulp(a, ts.index.values)\n\n    def test_create_ts_from_double(self):\n        \"\"\"\n        data get converted to ts and back fine\n        \"\"\"\n        a = np.floor(np.random.rand(100)*1000000)\n        a.sort()\n        ts = nts.Ts(a)\n        self.assertIs(ts.index.dtype, np.dtype(np.int64), msg='index type is not int64')\n        np.testing.assert_array_almost_equal_nulp(a, ts.index.values)\n\n    def test_create_ts_time_units(self):\n        \"\"\"\n        internally data are stored as us\n        \"\"\"\n        a = np.random.randint(0, 1000, 100)\n        a.sort()\n        ts = nts.Ts(a\/1000, time_units='ms')\n        np.testing.assert_array_almost_equal_nulp(ts.index.values, a)\n        ts = nts.Ts(a\/1000000, time_units='s')\n        # np.testing.assert_array_almost_equal_nulp(ts.index.values, a.astype(np.int64), nulp=100)\n        self.assertTrue(np.all(ts.index.values >= a.astype(np.int64)-1))\n        self.assertTrue(np.all(ts.index.values <= a.astype(np.int64)+1))\n    @staticmethod\n    def test_create_ts_time_units_double():\n        \"\"\"\n        conversion of time units from floating point type\n        \"\"\"\n        a = np.floor(np.random.rand(100) * 1000000)\n        a.sort()\n        ts = nts.Ts(a.copy(), time_units='ms')\n        # noinspection PyTypeChecker\n        np.testing.assert_array_almost_equal_nulp(ts.index.values\/1000, a)\n\n    @staticmethod\n    def test_create_ts_from_non_sorted():\n        \"\"\"\n        if ts are not sorted, a warning should be returned and the timestamps sorted for you\n        \"\"\"\n        a = np.random.randint(0, 1000, 100)\n        # with self.assertWarns(UserWarning):\n        #     ts = nts.Ts(a)\n        ts = nts.Ts(a)\n\n        np.testing.assert_array_almost_equal_nulp(np.sort(a), ts.index.values)\n\n    def test_create_ts_wrong_units(self):\n        \"\"\"\n        if the units are unsupported it should raise ValueError\n        \"\"\"\n        a = np.random.randint(0, 10000000, 100)\n        a.sort()\n        # noinspection PyUnusedLocal\n        ts = 1\n        with self.assertRaises(ValueError):\n            ts = nts.Ts(a, time_units='min')\n        self.assertTrue(ts)\n\n    def test_times_data(self):\n        \"\"\"\n        tests the times and data properties\n        \"\"\"\n        a = np.random.randint(0, 10000000, 100)\n        a.sort()\n        b = np.random.randn(100)\n        t = nts.Tsd(a, b)\n        np.testing.assert_array_almost_equal_nulp(b, t.data())\n        np.testing.assert_array_almost_equal_nulp(a, t.times())\n        np.testing.assert_array_almost_equal_nulp(a\/1000., t.times(units='ms'))\n        np.testing.assert_array_almost_equal_nulp(a\/1.0e6, t.times(units='s'))\n        with self.assertRaises(ValueError):\n            t.times(units='banana')\n\n\nclass TsRestrictTestCase(unittest.TestCase):\n    def setUp(self):\n        from scipy.io import loadmat\n        self.mat_data1 = \\\n            loadmat(os.path.join(nts.get_test_data_dir(), 'restrict_ts_data_1.mat'))\n        self.mat_data_left = \\\n            loadmat(os.path.join(nts.get_test_data_dir(), 'restrict_ts_data_2.mat'))\n        self.mat_data_right = \\\n            loadmat(os.path.join(nts.get_test_data_dir(), 'restrict_ts_data_3.mat'))\n\n    def tearDown(self):\n        pass\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_realign(self, data_class):\n        \"\"\"\n        first simple realign case\n        \"\"\"\n\n        d_a = self.mat_data1['d_a']\n        d_a = d_a.reshape((len(d_a),))\n        t_a = data_class(self.mat_data1['t_a'].astype(np.int64), d_a)\n        t_b = nts.Ts(self.mat_data1['t_b'].astype(np.int64))\n        t_closest = t_a.realign(t_b, align='closest')\n        dt = self.mat_data1['d_closest'].reshape((len(self.mat_data1['d_closest'],)))\n        self.assertTrue((t_closest.values.ravel() != dt).sum() < 10)\n        np.testing.assert_array_almost_equal_nulp(t_closest.values.ravel(), dt)\n\n        t_next = t_a.realign(t_b, align='next')\n        dt = self.mat_data1['d_next'].reshape((len(self.mat_data1['d_next'],)))\n        np.testing.assert_array_almost_equal_nulp(t_next.values.ravel(), dt)\n\n        t_prev = t_a.realign(t_b, align='prev')\n        dt = self.mat_data1['d_prev'].reshape((len(self.mat_data1['d_prev'],)))\n        np.testing.assert_array_almost_equal_nulp(t_prev.values.ravel(), dt)\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_realign_left(self, data_class):\n        d_a = self.mat_data_left['d_a']\n        d_a = d_a.reshape((len(d_a),))\n        t_a = data_class(self.mat_data_left['t_a'].astype(np.int64), d_a)\n        t_b = nts.Ts(self.mat_data_left['t_b'].astype(np.int64))\n        t_closest = t_a.realign(t_b)\n        dt = self.mat_data_left['d_closest'].ravel()\n        self.assertTrue((t_closest.values.ravel() != dt).sum() < 10)\n        np.testing.assert_array_almost_equal_nulp(t_closest.values.ravel(), dt)\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_realign_right(self, data_class):\n        d_a = self.mat_data_right['d_a']\n        d_a = d_a.reshape((len(d_a),))\n        t_a = data_class(self.mat_data_right['t_a'].astype(np.int64), d_a)\n        t_b = nts.Ts(self.mat_data_right['t_b'].astype(np.int64))\n        t_closest = t_a.realign(t_b)\n        dt = self.mat_data_right['d_closest'].ravel()\n        self.assertTrue((t_closest.values.ravel() != dt).sum() < 10)\n        np.testing.assert_array_almost_equal_nulp(t_closest.values.ravel(), dt)\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_realign_wrong_units(self, data_class):\n        d_a = self.mat_data1['d_a']\n        d_a = d_a.reshape((len(d_a),))\n        t_a = data_class(self.mat_data1['t_a'].astype(np.int64), d_a)\n        t_b = nts.Ts(self.mat_data1['t_b'].astype(np.int64))\n        # noinspection PyUnusedLocal\n        t_closest = 1\n        with self.assertRaises(ValueError):\n            t_closest = t_a.realign(t_b, align='banana')\n        self.assertTrue(t_closest)\n\n\nclass IntervalSetOpsTestCase(unittest.TestCase):\n    def setUp(self):\n        from scipy.io import loadmat\n        self.mat_data1 = loadmat(os.path.join(nts.get_test_data_dir(), 'interval_set_data_1.mat'))\n\n        # note that data are n x 1 here, need to be converted to 1-D in constructor\n        self.a1 = self.mat_data1['a1']\n        self.b1 = self.mat_data1['b1']\n        self.int1 = nts.IntervalSet(self.a1, self.b1, expect_fix=True)\n\n        self.a2 = self.mat_data1['a2']\n        self.b2 = self.mat_data1['b2']\n        self.int2 = nts.IntervalSet(self.a2, self.b2, expect_fix=True)\n\n    def tearDown(self):\n        pass\n\n    def test_create_interval_set(self):\n        \"\"\"\n        create an interval set from start and end points \"to be fixed\"\n        \"\"\"\n        a_i1 = self.mat_data1['a_i1'].ravel()\n        b_i1 = self.mat_data1['b_i1'].ravel()\n        np.testing.assert_array_almost_equal_nulp(a_i1, self.int1['start'])\n        np.testing.assert_array_almost_equal_nulp(b_i1, self.int1['end'])\n\n        a_i2 = self.mat_data1['a_i2'].ravel()\n        b_i2 = self.mat_data1['b_i2'].ravel()\n        np.testing.assert_array_almost_equal_nulp(a_i2, self.int2['start'])\n        np.testing.assert_array_almost_equal_nulp(b_i2, self.int2['end'])\n\n    def test_create_interval_set_from_scalars(self):\n        int1 = nts.IntervalSet(100, 2100)\n        self.assertIsInstance(int1, nts.IntervalSet)\n        np.testing.assert_array_almost_equal_nulp(np.array((100,)), int1['start'])\n        np.testing.assert_array_almost_equal_nulp(np.array((2100,)), int1['end'])\n\n    def test_iterator(self):\n        a_i1 = self.mat_data1['a_i1'].ravel().astype(np.int64)\n        b_i1 = self.mat_data1['b_i1'].ravel().astype(np.int64)\n        for i, int_i in self.int1.iterrows():\n            self.assertEqual(a_i1[i], int_i['start'])\n            self.assertEqual(b_i1[i], int_i['end'])\n\n    def test_timespan_tot_length(self):\n        \"\"\"\n        return the total length and the timespan of the interval set\n        \"\"\"\n        a_i1 = self.mat_data1['a_i1'].ravel()\n        b_i1 = self.mat_data1['b_i1'].ravel()\n        time_span = self.int1.time_span()\n        self.assertIsInstance(time_span, nts.IntervalSet)\n        self.assertEqual(time_span['start'][0], a_i1[0])\n        self.assertEqual(time_span['end'][0], b_i1[-1])\n        tot_l = (b_i1 - a_i1).sum()\n        self.assertAlmostEqual(self.int1.tot_length(), tot_l)\n\n    def test_intersect(self):\n        \"\"\"\n        intersection of the interval sets\n        \"\"\"\n        a_intersect = self.mat_data1['a_intersect'].ravel()\n        b_intersect = self.mat_data1['b_intersect'].ravel()\n        int_intersect = self.int1.intersect(self.int2)\n        self.assertIsInstance(int_intersect, nts.IntervalSet)\n\n        np.testing.assert_array_almost_equal_nulp(int_intersect['start'], a_intersect)\n        np.testing.assert_array_almost_equal_nulp(int_intersect['end'], b_intersect)\n\n        int_intersect = self.int2.intersect(self.int1)\n\n        np.testing.assert_array_almost_equal_nulp(int_intersect['start'], a_intersect)\n        np.testing.assert_array_almost_equal_nulp(int_intersect['end'], b_intersect)\n\n    def test_union(self):\n        \"\"\"\n        union of the interval sets\n        \"\"\"\n        a_union = self.mat_data1['a_union'].ravel()\n        b_union = self.mat_data1['b_union'].ravel()\n        int_union = self.int1.union(self.int2)\n        self.assertIsInstance(int_union, nts.IntervalSet)\n\n        np.testing.assert_array_almost_equal_nulp(int_union['start'], a_union)\n        np.testing.assert_array_almost_equal_nulp(int_union['end'], b_union)\n\n        int_union = self.int2.union(self.int1)\n\n        np.testing.assert_array_almost_equal_nulp(int_union['start'], a_union)\n        np.testing.assert_array_almost_equal_nulp(int_union['end'], b_union)\n\n    def test_setdiff(self):\n        \"\"\"\n        diffs of the interval sets\n        \"\"\"\n        a_diff1 = self.mat_data1['a_diff1'].ravel()\n        b_diff1 = self.mat_data1['b_diff1'].ravel()\n        a_diff2 = self.mat_data1['a_diff2'].ravel()\n        b_diff2 = self.mat_data1['b_diff2'].ravel()\n\n        int_diff1 = self.int1.set_diff(self.int2)\n        self.assertIsInstance(int_diff1, nts.IntervalSet)\n\n        np.testing.assert_array_almost_equal_nulp(int_diff1['start'], a_diff1)\n        np.testing.assert_array_almost_equal_nulp(int_diff1['end'], b_diff1)\n\n        int_diff2 = self.int2.set_diff(self.int1)\n\n        np.testing.assert_array_almost_equal_nulp(int_diff2['start'], a_diff2)\n        np.testing.assert_array_almost_equal_nulp(int_diff2['end'], b_diff2)\n\n\nclass IntervalSetDropMergeTestCase(unittest.TestCase):\n    def setUp(self):\n        from scipy.io import loadmat\n        self.mat_data1 = loadmat(os.path.join(nts.get_test_data_dir(),\n            'interval_set_data_dropmerge1.mat'))\n\n        # note that data are n x 1 here, need to be converted to 1-D in constructor\n        self.a1 = self.mat_data1['a1'].ravel()\n        self.b1 = self.mat_data1['b1'].ravel()\n        self.int1 = nts.IntervalSet(self.a1, self.b1, expect_fix=True)\n\n        self.a1_drop = self.mat_data1['a_i1_drop'].ravel()\n        self.b1_drop = self.mat_data1['b_i1_drop'].ravel()\n        self.int1_drop = nts.IntervalSet(self.a1_drop, self.b1_drop, expect_fix=True)\n\n        self.a1_merge = self.mat_data1['a_i1_merge'].ravel()\n        self.b1_merge = self.mat_data1['b_i1_merge'].ravel()\n        self.int1_merge = nts.IntervalSet(self.a1_merge, self.b1_merge, expect_fix=True)\n\n    def tearDown(self):\n        pass\n\n    def test_drop_short(self):\n        i_drop = self.int1.drop_short_intervals(threshold=2.e3)\n        self.assertIsInstance(i_drop, nts.IntervalSet)\n        np.testing.assert_array_almost_equal_nulp(i_drop['start'], self.a1_drop)\n        np.testing.assert_array_almost_equal_nulp(i_drop['end'], self.b1_drop)\n\n    def test_merge_close(self):\n        i_merge = self.int1.merge_close_intervals(threshold=3.e3)\n        self.assertIsInstance(i_merge, nts.IntervalSet)\n        np.testing.assert_array_almost_equal_nulp(i_merge['start'], self.a1_merge)\n        np.testing.assert_array_almost_equal_nulp(i_merge['end'], self.b1_merge)\n\n\nclass TsdUnitsTestCase(unittest.TestCase):\n    def setUp(self):\n        from scipy.io import loadmat\n        self.mat_data1 = loadmat(os.path.join(nts.get_test_data_dir(), 'interval_set_data_1.mat'))\n        self.tsd_t = self.mat_data1['t'].ravel()\n        self.tsd_d = self.mat_data1['d'].ravel()\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_as_dataframe(self, data_class):\n        self.tsd = data_class(self.tsd_t, self.tsd_d)\n        if data_class == nts.Tsd:\n            df = self.tsd.as_series()\n        else:\n            df = self.tsd.as_dataframe()\n        np.testing.assert_array_almost_equal_nulp(df.values, self.tsd.values)\n        np.testing.assert_array_almost_equal_nulp(df.index.values, self.tsd.index.values)\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_units_context(self, data_class):\n        self.tsd = data_class(self.tsd_t, self.tsd_d)\n        with nts.TimeUnits('ms'):\n            t = self.tsd.times()\n            # noinspection PyTypeChecker\n            np.testing.assert_array_almost_equal_nulp(self.tsd_t\/1000., t)\n\n    @staticmethod\n    def test_times_units_ts():\n        \"\"\"\n        tests the units calling of times\n        \"\"\"\n        a = np.random.randint(0, 10000000, 100)\n        a.sort()\n        ts = nts.Ts(a)\n\n        np.testing.assert_array_almost_equal_nulp(a, ts.times('us'))\n        np.testing.assert_array_almost_equal_nulp(a\/1000., ts.times('ms'))\n        np.testing.assert_array_almost_equal_nulp(a\/1.e6, ts.times('s'))\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_as_units_ts(self, data_class):\n        \"\"\"\n        as_units returns tsd dataframe\n        :return:\n        \"\"\"\n        self.tsd = data_class(self.tsd_t, self.tsd_d)\n        tsd_ms = self.tsd.as_units('ms')\n        if data_class == nts.Tsd:\n            self.assertIsInstance(tsd_ms, pd.Series)\n        else:\n            self.assertIsInstance(tsd_ms, pd.DataFrame)\n        # noinspection PyTypeChecker\n        np.testing.assert_array_almost_equal_nulp(self.tsd_t\/1000., tsd_ms.index.values)\n\n        tsd_s = self.tsd.as_units('s')\n        # noinspection PyTypeChecker\n        np.testing.assert_array_almost_equal_nulp(self.tsd_t\/1.e6, tsd_s.index.values)\n\n\nclass TsdSupportTestCase(unittest.TestCase):\n    def setUp(self):\n        a1 = np.arange(1, 500000, 100)\n        a2 = np.arange(800000, 2300000, 100)\n        a3 = np.arange(5200000, 8900000, 100)\n        self.t = np.hstack((a1, a2, a3))\n        self.d = np.random.randn(*self.t.shape)\n\n    def tearDown(self):\n        pass\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_gaps(self, data_class):\n        self.t1 = data_class(self.t, self.d)\n        gaps = self.t1.gaps(500, method='absolute')\n        st = gaps['start']\n        en = gaps['end']\n        np.testing.assert_array_almost_equal_nulp(st, np.array((499902, 2299901)))\n        np.testing.assert_array_almost_equal_nulp(en, np.array((799999, 5199999)))\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def test_support(self, data_class):\n        self.t1 = data_class(self.t, self.d)\n        support = self.t1.support(min_gap=500, method='absolute')\n        np.testing.assert_array_almost_equal_nulp(support['start'], np.array((0, 799999, 5199999)))\n        np.testing.assert_array_almost_equal_nulp(support['end'], np.array((499902, 2299901, 8899901)))\n\n\nclass TsdIntervalSetRestrictTestCase(unittest.TestCase):\n    def setUp(self):\n        from scipy.io import loadmat\n        self.mat_data1 = loadmat(os.path.join(nts.get_test_data_dir(),\n            'interval_set_data_1.mat'))\n\n        self.a1 = self.mat_data1['a1'].ravel()\n        self.b1 = self.mat_data1['b1'].ravel()\n        self.int1 = nts.IntervalSet(self.a1, self.b1, expect_fix=True)\n\n        self.a2 = self.mat_data1['a2'].ravel()\n        self.b2 = self.mat_data1['b2'].ravel()\n        self.int2 = nts.IntervalSet(self.a2, self.b2, expect_fix=True)\n\n        self.tsd_t = self.mat_data1['t'].ravel()\n        self.tsd_d = self.mat_data1['d'].ravel()\n        self.tsd = nts.Tsd(self.tsd_t, self.tsd_d)\n\n    def tearDown(self):\n        pass\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def testRestrict(self, data_class):\n        \"\"\"\n        IntervalSet restrict of tsd\n        \"\"\"\n        self.tsd = data_class(self.tsd_t, self.tsd_d)\n        t_r1 = self.mat_data1['t_r1'].ravel()\n        d_r1 = self.mat_data1['d_r1'].ravel()\n        tsd_r1 = self.tsd.restrict(self.int1)\n        self.assertIsInstance(tsd_r1, data_class)\n        self.assertEqual(tsd_r1.index.name, \"Time (us)\")\n        np.testing.assert_array_almost_equal_nulp(t_r1, tsd_r1.times())\n        np.testing.assert_array_almost_equal_nulp(d_r1, tsd_r1.values.ravel())\n\n        t_r2 = self.mat_data1['t_r2'].ravel()\n        d_r2 = self.mat_data1['d_r2'].ravel()\n        tsd_r2 = self.tsd.restrict(self.int2)\n        np.testing.assert_array_almost_equal_nulp(t_r2, tsd_r2.times())\n        np.testing.assert_array_almost_equal_nulp(d_r2, tsd_r2.values.ravel())\n\n    @parameterized.expand([\n        (nts.Tsd,),\n        (nts.TsdFrame,)\n    ])\n    def testRange(self, data_class):\n        self.tsd = data_class(self.tsd_t, self.tsd_d)\n        range_interval = nts.IntervalSet(9.e8, 3.e9)\n\n        int1_r = self.int1.intersect(range_interval)\n        tsd_r = self.tsd.restrict(range_interval)\n        tsd_r_r1 = self.tsd.restrict(int1_r)\n\n        with nts.Range(range_interval):\n            np.testing.assert_array_almost_equal_nulp(self.tsd.r.times(), tsd_r.times())\n            np.testing.assert_array_almost_equal_nulp(self.int1.r['start'], int1_r['start'])\n            np.testing.assert_array_almost_equal_nulp(self.int1.r['end'], int1_r['end'])\n\n            np.testing.assert_array_almost_equal_nulp(self.tsd.r.restrict(self.int1.r).times(),\n                                                      tsd_r_r1.times())\n\n            # testing caching\n            self.assertIsNotNone(self.tsd.r_cache)\n            self.assertIsNotNone(self.int1.r_cache)\n            np.testing.assert_array_almost_equal_nulp(self.tsd.r.times(), tsd_r.times())\n            np.testing.assert_array_almost_equal_nulp(self.int1.r['start'], int1_r['start'])\n            np.testing.assert_array_almost_equal_nulp(self.int1.r['end'], int1_r['end'])\n            np.testing.assert_array_almost_equal_nulp(self.tsd.r.restrict(self.int1.r).times(),\n                                                      tsd_r_r1.times())\n\n        self.assertIsNone(self.tsd.r_cache)\n        self.assertIsNone(self.int1.r_cache)\n\n        with nts.Range(9.e8, 3.e9):\n            np.testing.assert_array_almost_equal_nulp(self.tsd.r.times(), tsd_r.times())\n\nif __name__ == '__main__':\n    unittest.main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_11","text":"<gh_stars>1-10\nimport pysubs2\nimport numpy as np\nimport tensorflow as tf\nfrom scipy.io import wavfile\n\ndef read_audio(audio_filepath, target_fs=1000, mono=True):\n    \"\"\"Read an audio file and optionnaly resample it into a mono channel.\n\n    Parameters\n    ----------\n        audio_filepath : string, required\n            filepath to the audio WAV file\n        target_fs : float\n            target sampling rate (default: 1 kHz)\n        mono : bool\n            convert the audio into a mono-channel (default: True)\n\n    Returns\n    -------\n        `np.array` [int16\/int32\/float32] : audio samples\n    \"\"\"\n    fs, audio = wavfile.read(audio_filepath)\n    channels = audio.shape[-1] if len(audio.shape) > 1 else 1\n\n    # sampling the signal\n    if target_fs !=  fs:\n        n_samples = int(audio.shape[0]*(target_fs\/fs))\n        resample_idx = np.insert((fs\/target_fs)*np.ones(n_samples - 1), 0, 0.)\n        resample_idx = np.array(np.round(np.cumsum(resample_idx)), dtype=int)\n        # getting mono channel\n        audio_resampled = audio[resample_idx]\n    else:\n        audio_resampled = audio\n    if mono & (channels > 1):\n        audio_resampled = audio_resampled[:, 0]\n\n    return audio_resampled, fs\n\ndef save_audio(audio, audio_filepath, fs):\n    \"\"\"Save an audio file.\n\n    Parameters\n    ----------\n        audio : `np.array` [int16\/int32\/float32], required\n            audio samples\n        audio_filepath : string, required\n            output filepath to the audio WAV file\n        fs : float, required\n            sampling rate in Hz\n    \"\"\"\n    wavfile.write(audio_filepath, fs, audio)\n\ndef read_subs(input_sub_filepath, target_fs=1000, encoding=\"utf-8\"):\n    \"\"\"Read a subtitle file and convert it into a numerical signal.\n\n    Parameters\n    ----------\n        input_sub_filepath : string, required\n            filepath to the input subtitle SRT file\n        target_fs : float\n            target sampling rate in Hz (default: 1 kHz)\n        encoding : string\n            encoding to choose (default: utf-8)\n\n    Returns\n    -------\n        subs_signal : `np.array` [np.int32] of size [last subtitle end event in ms + 1]\n            subtitle signal (takes 0. or 1. value)\n        subs : `pysubs2.ssafile.SSAFile`\n            subtitle object with all the subtitle events\n        starts : `np.array` [np.int32]\n            subtitles starts events in ms\n        ends : `np.array` [np.int32]\n            subtitles ends events in ms\n    \"\"\"\n    subs = pysubs2.load(input_sub_filepath, encoding=encoding)\n    duration_sub_in_ms = subs[-1].end\n\n    # box signal correspond to the subs\n    target_ratio = target_fs \/ 1000.\n    subs_signal = np.zeros(( np.int32(duration_sub_in_ms*target_ratio + 1),), dtype=np.float32)\n    starts = np.array([], dtype=np.int32)\n    ends = np.array([], dtype=np.int32)\n    for sub in subs:\n        start = np.int32(sub.start)\n        start_ix = np.int32(sub.start*target_ratio)\n        end = np.int32(sub.end)\n        end_ix = np.int32(sub.end*target_ratio)\n        starts = np.append(starts, start)\n        ends = np.append(ends, end)\n        subs_signal[start_ix:end_ix] = 1.\n\n    return subs_signal, subs, starts, ends\n\ndef save_subs(subs, output_sub_filepath, encoding=\"utf-8\"):\n    \"\"\"Save a subtitle file.\n\n    Parameters\n    ----------\n        subs : `pysubs2.ssafile.SSAFile`, required\n            subtitle object with all the subtitle events\n        output_sub_filepath : string, required\n            output filepath to the subtitle SRT file\n        encoding : string\n            encoding to choose (default: utf-8)\n    \"\"\"\n    subs.save(output_sub_filepath, encoding=encoding)\n\ndef save_labels(subs, output_label_filepath):\n    \"\"\"Save a subtitle file into an audacity label TXT file.\n\n    Parameters\n    ----------\n        subs : `pysubs2.ssafile.SSAFile`, required\n            subtitle object with all the subtitle events\n        output_label_filepath : string, required\n            output filepath to the label TXT file\n    \"\"\"\n    with open(output_label_filepath, \"w\") as fst:\n        for sub in subs:\n            start = sub.start\n            end = sub.end\n            text = sub.text\n            fst.write(\"{}\\t{}\\t{}\\n\".format(start\/1000., end\/1000., text))\n    fst.close()\n\ndef gaussian_kernel_1d(filter_length):\n    \"\"\"Get a 1D gaussian kernel.\n\n    Parameters\n    ----------\n        filter_length : int, required\n            width of the 1D gaussian kernel\n\n    Returns\n    -------\n        `np.array` [float] of size [filter_length] : 1D gaussian kernel\n    \"\"\"\n    #99% of the values\n    sigma = (filter_length\/2)\/2.33\n    width = int(filter_length\/2)\n\n    norm = 1.0 \/ (np.sqrt(2*np.pi) * sigma)\n    kernel = [norm * np.exp((-1)*(x**2)\/(2 * sigma**2)) for x in range(-width, width + 1)]  \n\n    return np.float32(kernel \/ np.sum(kernel))\n\ndef tf_1d_gaussian_filtering(signal, kernel_size):\n    \"\"\"Tensorflow convolution of the input signal with a gaussian kernel.\n\n    Parameters\n    ----------\n        signal : `np.array` or `tf.tensor` [float], required\n            input signal to be convolved with a gaussian kernel\n        kernel_size : int. required\n            width of the 1D gaussian kernel\n    \n    Returns\n    -------\n        `np.array` [float] : convolved input signal with a gaussian kernel\n    \"\"\"\n    f = tf.reshape(gaussian_kernel_1d(kernel_size), [-1, 1, 1])\n    signal_filtered = tf.reshape(tf.constant(signal, dtype=tf.float32), [1, -1, 1])\n\n    return tf.reshape(tf.nn.conv1d(signal_filtered, filters=f, stride=1, padding='SAME'), [-1])\n\ndef filter_audio(audio, threshold=None, kernel_size=None):\n    \"\"\"Audio pre-processing for a vocal audio input (absolute, convolution and thresholding).\n\n    Parameters\n    ----------\n        audio : `np.array` [float], required\n            input audio signal\n        threshold : float\n            input audio will be thresholded by this amount (default: np.quantile(audio, 1\/4))\n        kernel_size : int\n            width of the 1D gaussian kernel for the input audio convolution (default: 100)\n    \n    Returns\n    -------\n        `np.array` [float] : input audio pre-processed\n    \"\"\"\n    # get and convolve the audio magnitude spectrum\n    audio_mag = np.abs(audio)\n    audio_filtered = tf_1d_gaussian_filtering(audio_mag, kernel_size=kernel_size)\n    default_threshold = np.quantile(audio_filtered[audio_mag>0], 1\/4)\n    # manual threshold to filter noise\n    if threshold is None:\n        threshold = default_threshold\n    else:\n        threshold = max(threshold, default_threshold)\n    audio_preprocessed = np.array(audio_filtered > threshold, dtype=np.float32)\n\n    return audio_preprocessed\n\ndef rescale_audio_subs(audio, subs_signal):\n    \"\"\"Resize both the input audio and subtitle signal so they have the same length.\n\n    Parameters\n    ----------\n        audio : `np.array` [float], required\n            input audio signal\n        subs_signal : `np.array` [float], required\n            input subtitle signal\n    \n    Returns\n    -------\n        audio : `np.array` [float]\n            input audio signal resized\n        subs_signal : `np.array` [float]\n            input subtitle signal resized\n    \"\"\"\n    # rescaling sub or audio so they have the same length\n    duration_sub = subs_signal.shape[0]\n    duration_audio = audio.shape[0]\n\n    if duration_sub < duration_audio:\n        duration = duration_audio - duration_sub\n        subs_signal = tf.concat([subs_signal, tf.zeros((duration), dtype=tf.float32)], axis=0)\n    else:\n        duration = duration_sub - duration_audio\n        audio = tf.concat([audio, tf.zeros((duration), dtype=tf.float32)], axis=0)\n\n    return audio, subs_signal\n\ndef get_subs_mask(subs_signal, starts, ends, max_duration_allowed=10000, fs=1000):\n    \"\"\"Get a mask from a subtitle signal and starts\/ends event, where each cluster is identified by its int value.\n\n    Parameters\n    ----------\n        subs_signal : `np.array` [float], required\n            input subtitle signal\n        starts : `np.array` [np.int32], required\n            subtitles starts events in ms\n        ends : `np.array` [np.int32], required\n            subtitles ends events in ms\n        max_duration_allowed : int\n            maximum duration in ms allowed between two subtitle events to form one cluster (default: 10000 ms)\n        fs : float\n            Sampling rate in Hz (default: 1 kHz)\n    \n    Returns\n    -------\n        `np.array` [float] : mask with cluster id values for each sample in the input subtitle signal\n    \"\"\"\n    mask_subs_signal = np.zeros_like(subs_signal)\n    num_sub = len(starts)\n    middle_subs = np.array([], dtype=np.int32)\n    fs_ratio = fs \/ 1000.\n    # clustering the subs into n groups\n    for i in range(num_sub - 1):\n        dura = starts[i+1]*fs_ratio - ends[i]*fs_ratio\n        if(dura > max_duration_allowed*fs_ratio):\n            middle_sub = np.int32((ends[i]*fs_ratio + starts[i+1]*fs_ratio)\/2)\n            middle_subs = np.append(middle_subs, [middle_sub])\n    mask_subs_signal[middle_subs] = 1\n\n    return np.cumsum(mask_subs_signal)\n\ndef resync_subs(params, subs, mask=None, fs=1000, cut_start=0, cut_end=90060990):\n    \"\"\"Re-synchronize the subtitle object given the transformation parameters.\n\n    Parameters\n    ----------\n        params : `list` [float], required\n            transformation parameters\n        subs : `pysubs2.ssafile.SSAFile`, required\n            subtitle object with all the subtitle events\n        mask : `np.array` [float]\n            mask with cluster id values for each sample in the input subtitle signal\n        fs : float\n            Sampling rate in Hz (default: 1 kHz)\n        cut_start : int\n            Minimum timestamp value (ms) to include (default: 0)\n        cut_end : int\n            Maximum timestamp value (ms) to include (default: 90060990)\n    \n    Returns\n    -------\n        `pysubs2.ssafile.SSAFile` : subtitle object with all the re-synchronized subtitle events\n    \"\"\"\n    target_ratio = fs \/ 1000.\n    max_duration = int(subs[-1].end + 3600000)\n    for sub, i in zip(subs, range(len(subs))):\n        input_start = int(sub.start * target_ratio)\n        input_end = int(sub.end * target_ratio)\n        start =  params[0]*input_start + params[1]\n        end = params[0]*input_end + params[1]\n        # non-rigid\n        if len(params) != 2:\n            if mask is None:\n                idx_start =  input_start\n                idx_end = input_end\n            else:\n                idx_start = int(mask[input_start])\n                idx_end = int(mask[input_end])\n            start = start + params[2][idx_start]\n            end = end + params[2][idx_end]\n        if (cut_start < sub.start) & (sub.end < cut_end):\n            # updating subtitle file\n            subs[i].start = min(max(0, int(start\/target_ratio)), max_duration)\n            subs[i].end = min(max(0, int(end\/target_ratio)), max_duration)\n\n    return subs\n\ndef add_credits(subs):\n    \"\"\"Add credits to the software at the end of the subtitle SRT file.\n\n    Parameters\n    ----------\n        subs : `pysubs2.ssafile.SSAFile`, required\n            subtitle object with all the subtitle events\n    \n    Returns\n    -------\n        `pysubs2.ssafile.SSAFile` : subtitle object with credits appended at the end\n    \"\"\"\n\n    start = int(subs[-1].end) + 2000\n    end = start + 2000\n    text = \"Processed with <i>ReSuber<\/i>.\\nCheck the github page <font color=\\\"blue\\\"> https:\/\/github.com\/polak0v\/ReSuber <\/font> !\"\n    event = pysubs2.SSAEvent(start=start, end=end, text=text)\n    subs += [event]\n\n    return subs"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_12","text":"# This file is part of QuTiP: Quantum Toolbox in Python.\n#\n#    Copyright (c) 2011 and later, <NAME> and <NAME>.\n#    All rights reserved.\n#\n#    Redistribution and use in source and binary forms, with or without\n#    modification, are permitted provided that the following conditions are\n#    met:\n#\n#    1. Redistributions of source code must retain the above copyright notice,\n#       this list of conditions and the following disclaimer.\n#\n#    2. Redistributions in binary form must reproduce the above copyright\n#       notice, this list of conditions and the following disclaimer in the\n#       documentation and\/or other materials provided with the distribution.\n#\n#    3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names\n#       of its contributors may be used to endorse or promote products derived\n#       from this software without specific prior written permission.\n#\n#    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n#    \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n#    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n#    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n#    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n#    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n#    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n#    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n#    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n#    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n#    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n###############################################################################\n\nimport numpy as np\nimport scipy.linalg\n\nimport qutip\nfrom qutip.core import data as _data\nimport pytest\n\n\ndef f(t, args):\n    return t * (1 - 0.5j)\n\n\ndef liouvillian_ref(H, c_ops=()):\n    L = -1.0j * (qutip.spre(H) - qutip.spost(H)) if H else 0\n    for c in c_ops:\n        if c.issuper:\n            L += c\n        else:\n            cdc = c.dag() * c\n            L += qutip.sprepost(c, c.dag())\n            L -= 0.5 * (qutip.spre(cdc) + qutip.spost(cdc))\n    return L\n\n\nclass TestMatVec:\n    \"\"\"\n    A test class for the QuTiP function for matrix\/vector conversion.\n    \"\"\"\n    def testOperatorVector(self):\n        \"\"\"\n        Superoperator: Operator - vector - operator conversion.\n        \"\"\"\n        N = 3\n        rho1 = qutip.rand_dm(N)\n        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))\n        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)\n\n    def testsuperrep(self):\n        N = 3\n        rho1 = qutip.rand_dm(N)\n        as_vec = qutip.operator_to_vector(rho1)\n        assert as_vec.superrep == 'super'\n\n        with pytest.raises(TypeError) as err:\n            bad_vec = as_vec.copy()\n            bad_vec.superrep = \"\"\n            qutip.vector_to_operator(bad_vec)\n        assert err.value.args[0] == (\"only defined for operator-kets \"\n                                     \"in super format\")\n\n        with pytest.raises(TypeError) as err:\n            qutip.operator_to_vector(as_vec)\n        assert err.value.args[0] == (\"Cannot convert object already \"\n                                     \"in super representation\")\n\n\n    def testOperatorVectorTensor(self):\n        \"\"\"\n        Superoperator: Operator - vector - operator conversion with a tensor product state.\n        \"\"\"\n        Na = 3\n        Nb = 2\n        rhoa = qutip.rand_dm(Na)\n        rhob = qutip.rand_dm(Nb)\n        rho1 = qutip.tensor(rhoa, rhob)\n        rho2 = qutip.vector_to_operator(qutip.operator_to_vector(rho1))\n        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)\n\n    def testOperatorVectorNotSquare(self):\n        \"\"\"\n        Superoperator: Operator - vector - operator conversion for non-square matrix.\n        \"\"\"\n        op1 = qutip.Qobj(np.random.rand(6).reshape((3, 2)))\n        op2 = qutip.vector_to_operator(qutip.operator_to_vector(op1))\n        np.testing.assert_allclose(op1.full(), op2.full(), 1e-8)\n\n    def testOperatorSpreAppl(self):\n        \"\"\"\n        Superoperator: apply operator and superoperator from left (spre)\n        \"\"\"\n        N = 3\n        rho = qutip.rand_dm(N)\n        U = qutip.rand_unitary(N)\n        rho1 = U * rho\n        rho2_vec = qutip.spre(U) * qutip.operator_to_vector(rho)\n        rho2 = qutip.vector_to_operator(rho2_vec)\n        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)\n\n    def testOperatorSpostAppl(self):\n        \"\"\"\n        Superoperator: apply operator and superoperator from right (spost)\n        \"\"\"\n        N = 3\n        rho = qutip.rand_dm(N)\n        U = qutip.rand_unitary(N)\n        rho1 = rho * U\n        rho2_vec = qutip.spost(U) * qutip.operator_to_vector(rho)\n        rho2 = qutip.vector_to_operator(rho2_vec)\n        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)\n\n    def testOperatorUnitaryTransform(self):\n        \"\"\"\n        Superoperator: Unitary transformation with operators and superoperators\n        \"\"\"\n        N = 3\n        rho = qutip.rand_dm(N)\n        U = qutip.rand_unitary(N)\n        rho1 = U * rho * U.dag()\n        rho2_vec = qutip.sprepost(U, U.dag()) * qutip.operator_to_vector(rho)\n        rho2 = qutip.vector_to_operator(rho2_vec)\n        np.testing.assert_allclose(rho1.full(), rho2.full(), 1e-8)\n\n    def testMatrixVecMat(self):\n        \"\"\"\n        Superoperator: Conversion matrix to vector to matrix\n        \"\"\"\n        M = _data.create(np.random.rand(10, 10))\n        V = qutip.stack_columns(M)\n        M2 = qutip.unstack_columns(V)\n        np.testing.assert_allclose(M.to_array(), M2.to_array(), 1e-8)\n\n    def testVecMatVec(self):\n        \"\"\"\n        Superoperator: Conversion vector to matrix to vector\n        \"\"\"\n        V = _data.create(np.random.rand(100, 1))\n        M = qutip.unstack_columns(V)\n        V2 = qutip.stack_columns(M)\n        np.testing.assert_allclose(V.to_array(), V2.to_array(), 1e-8)\n\n    def testVecMatIndexConversion(self):\n        \"\"\"\n        Superoperator: Conversion between matrix and vector indices\n        \"\"\"\n        N = 10\n        for i in range(N * N):\n            assert i == qutip.stacked_index(N, *qutip.unstacked_index(N, i))\n\n    def testVecMatIndexCompability(self):\n        \"\"\"\n        Superoperator: Compatibility between matrix\/vector and\n        corresponding index conversions.\n        \"\"\"\n        N = 10\n        M = _data.create(np.random.rand(N, N))\n        V = qutip.stack_columns(M)\n        for idx in range(N * N):\n            i, j = qutip.unstacked_index(N, idx)\n            assert V.to_array()[idx, 0] == M.to_array()[i, j]\n\n    def test_reshuffle(self):\n        U1 = qutip.rand_unitary(2)\n        U2 = qutip.rand_unitary(3)\n        U3 = qutip.rand_unitary(4)\n        U = qutip.tensor(U1, U2, U3)\n        S = qutip.to_super(U)\n        S_col = qutip.reshuffle(S)\n        assert S_col.dims[0] == [[2, 2], [3, 3], [4, 4]]\n        assert qutip.reshuffle(S_col) == S\n\n    def test_sprepost(self):\n        U1 = qutip.rand_unitary(3)\n        U2 = qutip.rand_unitary(3)\n        S1 = qutip.spre(U1) * qutip.spost(U2)\n        S2 = qutip.sprepost(U1, U2)\n        assert S1 == S2\n\n    def testLiouvillianImplem(self):\n        \"\"\"\n        Superoperator: Randomized comparison of standard and reference\n        Liouvillian functions.\n        \"\"\"\n        N1, N2, N3 = 3, 4, 5\n        a1 = qutip.tensor(qutip.rand_dm(N1, density=0.75),\n                          qutip.qeye([N2, N3]))\n        a2 = qutip.tensor(qutip.qeye(N1),\n                          qutip.rand_dm(N2, density=0.75),\n                          qutip.qeye(N3))\n        a3 = qutip.tensor(qutip.qeye([N1, N2]),\n                          qutip.rand_dm(N3, density=0.75))\n        H = a1.dag()*a1 + a2.dag()*a2 + a3.dag()*a3\n        c_ops = [np.sqrt(0.01) * a1, np.sqrt(0.025) * a2, np.sqrt(0.05) * a3]\n        L1 = qutip.liouvillian(H, c_ops)\n        L2 = liouvillian_ref(H, c_ops)\n        np.testing.assert_allclose(L1.full(), L2.full(), 1e-8)\n\n\nclass TestSuper_td:\n    \"\"\"\n    A test class for the QuTiP superoperator functions.\n    \"\"\"\n    N = 3\n    t1 = qutip.QobjEvo([qutip.qeye(N)*(1 + 0.1j),\n                        [qutip.create(N) * (1 - 0.1j), f]])\n    t2 = qutip.QobjEvo([qutip.destroy(N) * (1 - 0.2j)])\n    t3 = qutip.QobjEvo([[qutip.num(N) * (1 + 0.2j), f]])\n    q1 = qutip.qeye(N) * (1 + 0.3j)\n    q2 = qutip.destroy(N) * (1 - 0.3j)\n    q3 = qutip.num(N) * (1 + 0.4j)\n\n    def test_spre_td(self):\n        \"Superoperator: spre, time-dependent\"\n        assert qutip.spre(self.t1)(0.5) == qutip.spre(self.t1(0.5))\n\n    def test_spost_td(self):\n        \"Superoperator: spre, time-dependent\"\n        assert qutip.spost(self.t1)(0.5) == qutip.spost(self.t1(0.5))\n\n    def test_sprepost_td(self):\n        \"Superoperator: sprepost, time-dependent\"\n        # left QobjEvo\n        assert (qutip.sprepost(self.t1, self.q2)(0.5)\n                == qutip.sprepost(self.t1(0.5), self.q2))\n        # left QobjEvo\n        assert (qutip.sprepost(self.q2, self.t1)(0.5)\n                == qutip.sprepost(self.q2, self.t1(0.5)))\n        # left 2 QobjEvo, one cte\n        assert (qutip.sprepost(self.t1, self.t2)(0.5)\n                == qutip.sprepost(self.t1(0.5), self.t2(0.5)))\n\n    def test_operator_vector_td(self):\n        \"Superoperator: operator_to_vector, time-dependent\"\n        assert (qutip.operator_to_vector(self.t1)(0.5)\n                == qutip.operator_to_vector(self.t1(0.5)))\n        vec = qutip.operator_to_vector(self.t1)\n        assert (qutip.vector_to_operator(vec)(0.5)\n                == qutip.vector_to_operator(vec(0.5)))\n\n    def test_liouvillian_td(self):\n        \"Superoperator: liouvillian, time-dependent\"\n        assert (qutip.liouvillian(self.t1)(0.5)\n                == qutip.liouvillian(self.t1(0.5)))\n        assert (qutip.liouvillian(None, [self.t2])(0.5)\n                == qutip.liouvillian(None, [self.t2(0.5)]))\n        assert (qutip.liouvillian(self.t1, [self.t2, self.q1, self.t3],\n                                  chi=[1, 2, 3])(0.5)\n                == qutip.liouvillian(self.t1(0.5),\n                                     [self.t2(0.5), self.q1, self.t3(0.5)],\n                                     chi=[1, 2, 3]))\n\n    def test_lindblad_dissipator_td(self):\n        \"Superoperator: lindblad_dissipator, time-dependent\"\n        assert (qutip.lindblad_dissipator(self.t2)(0.5)\n                == qutip.lindblad_dissipator(self.t2(0.5)))\n        assert (qutip.lindblad_dissipator(self.t2, self.q1)(0.5)\n                == qutip.lindblad_dissipator(self.t2(0.5), self.q1))\n        assert (qutip.lindblad_dissipator(self.q1, self.t2)(0.5)\n                == qutip.lindblad_dissipator(self.q1, self.t2(0.5)))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_13","text":"<reponame>mostamndi\/Merra2BC<filename>merra2_module.py\nimport config\nimport re\nimport os\nfrom netCDF4 import Dataset\nfrom datetime import datetime, timedelta\nimport numpy as np\nfrom scipy import interpolate\n\nfrom multiprocessing import Pool\nfrom functools import partial\n\nPtop_mera=1 #Pa   (=0.01 hPa)\nmera_lat=0\nmera_lon=0\n\nshifted_lons=False\nshift_index=0\n\nmerra_files=[]\nmera_times={}                           #map between time and index in file\nmera_times_files={}                     #map between time and file index\nmerra_vars=[]\nmer_number_of_x_points=0\nmer_number_of_y_points=0\nmer_number_of_z_points=0\n\nnumbers = re.compile(r'(\\d+)')\ndef numericalSort(value):\n    parts = numbers.split(value)\n    return parts[9]\n\ndef get_file_index_by_time(time):\n    return mera_times_files.get(time)\n\ndef get_index_in_file_by_time(time):\n    return mera_times.get(time)\n\ndef get_file_name_by_index(index):\n    return merra_files[index]\n\n\n\n#********************************\n#Horizontal interpolation of 3d Merra field on WRF boundary\ndef hor_interpolate_3dfield_on_wrf_boubdary(FIELD, wrf_length, wrf_lon, wrf_lat):\n    FIELD_BND=np.zeros([mer_number_of_z_points, wrf_length])\n    for z_level in range(mer_number_of_z_points):\n        f = interpolate.RectBivariateSpline(mera_lat, mera_lon, FIELD[z_level,:,:])\n        FIELD_BND[z_level,:]=f(wrf_lat,wrf_lon,grid=False)\n    return FIELD_BND\n\n#Vertical interpolation of Merra boundary on WRF boundary\ndef ver_interpolate_3dfield_on_wrf_boubdary(MER_HOR_SPECIE_BND,MER_HOR_PRES_BND,WRF_PRES_BND,wrf_nz, wrf_length):\n    WRF_SPECIE_BND = np.zeros([wrf_nz,wrf_length])  # Required SPEC on WRF boundary\n    for i in range(0,wrf_length):\n        f = interpolate.interp1d(MER_HOR_PRES_BND[:,i], MER_HOR_SPECIE_BND[:,i], kind='linear',bounds_error=False,fill_value=0)\n        WRF_SPECIE_BND[:,i]=f(WRF_PRES_BND[:,i])\n    return WRF_SPECIE_BND\n\n#Horizontal interpolation of 3d Merra field on WRF horizontal grid\ndef hor_interpolate_3dfield_on_wrf_grid(FIELD, wrf_ny, wrf_nx, wrf_lon, wrf_lat):\n    FIELD_HOR=np.zeros([mer_number_of_z_points, wrf_ny, wrf_nx])\n\n    for z_level in range(mer_number_of_z_points):\n        f = interpolate.RectBivariateSpline(mera_lat, mera_lon, FIELD[z_level,:,:])\n        FIELD_HOR[z_level,:,:]=f(wrf_lat,wrf_lon,grid=False).reshape(wrf_ny, wrf_nx)\n\n    return FIELD_HOR\n\n#Vertical interpolation on WRF grid\ndef ver_interpolate_3dfield_on_wrf_grid(MER_HOR_SPECIE, MER_HOR_PRES,WRF_PRES,wrf_nz, wrf_ny, wrf_nx):\n    WRF_SPECIE = np.zeros([wrf_nz,wrf_ny,wrf_nx])  # Required SPEC on WRF grid\n    for x in range(0,wrf_nx,1):\n        for y in range(0,wrf_ny,1):\n            f = interpolate.interp1d(MER_HOR_PRES[:,y,x], MER_HOR_SPECIE[:,y,x], kind='linear',bounds_error=False,fill_value=0)\n            WRF_SPECIE[:,y,x]=f(WRF_PRES[:,y,x])\n    return WRF_SPECIE\n#********************************\n\n#extracts 3d field from merra2 file from given time\ndef get_3dfield_by_time(time,merra_file,field_name):\n    mera_time_idx=get_index_in_file_by_time(time)\n    field=merra_file.variables[field_name][mera_time_idx,:]\n\n    if shifted_lons:\n        field=np.roll(field,shift_index,axis=2)\n\n    return np.flipud(field)\n\n\ndef get_pressure_by_time(time,merra_file):\n    global Ptop_mera\n    #MER_Pres will be restored on 73 edges\n    MER_Pres = np.zeros([mer_number_of_z_points+1,mer_number_of_y_points,mer_number_of_x_points])\n    #filling top edge with Ptop_mera\n    MER_Pres[0,:,:]=Ptop_mera\n\n    # Extract deltaP from NetCDF file at index defined by time\n    mera_time_idx=get_index_in_file_by_time(time)\n    DELP = merra_file.variables['DELP'][mera_time_idx,:]  #Pa\n\n    for z_level in range(mer_number_of_z_points):\n        MER_Pres[z_level+1]=MER_Pres[z_level]+DELP[z_level]\n\n    #BUT! we need pressure on 72 levels\n    #=> averaging pressure values on adjacent edges\n    MER_Pres = (MER_Pres[0:mer_number_of_z_points:1][:,:] + MER_Pres[1::1][:,:]) \/ 2\n\n    if shifted_lons:\n        MER_Pres=np.roll(MER_Pres,shift_index,axis=2)\n\n    MER_Pres=np.flipud(MER_Pres)\n    return MER_Pres\n\n\n\ndef initialise():\n    global merra_files,mer_number_of_x_points,mer_number_of_y_points,mer_number_of_z_points,mera_lon,mera_lat,merra_vars,shifted_lons,shift_index\n\n    merra_files=sorted([f for f in os.listdir(config.mera_dir) if re.match(config.mera_files, f)], key=numericalSort)\n    #print \"Open \"+config.mera_dir+\"\/\"+merra_files[0]\n    merra_f = Dataset(config.mera_dir+\"\/\"+merra_files[0],'r')\n    mer_number_of_x_points=merra_f.variables['lon'].size\n    mer_number_of_y_points=merra_f.variables['lat'].size\n    #not all merra2 files (loading diagnostic) have 'lev' variable\n    try:\n        mer_number_of_z_points=merra_f.variables['lev'].size\n    except Exception:\n        pass\n\n    print \"MERRA2 dimensions: [bottom_top]=\"+str(mer_number_of_z_points)+\" [south_north]=\"+str(mer_number_of_y_points)+\" [west_east]=\"+str(mer_number_of_x_points)\n\n    merra_vars = [var for var in merra_f.variables]\n\n    mera_lon  = merra_f.variables['lon'][:]\n    mera_lat  = merra_f.variables['lat'][:]\n\n    #if data is given in range of 0_360, then we need to shift lons and data to the -180_180\n    if(max(mera_lon)>180):\n        print \"###########################\"\n        print \"ATTENTION!!!:\"\n        print \"SHIFTING LONGITUDES\"\n        index=0\n        for lon in mera_lon:\n            if lon >180:\n                mera_lon[index]=mera_lon[index]-360.0\n            index=index+1\n        shift_index=len(mera_lon)\/2\n        mera_lon=np.roll(mera_lon,shift_index)\n        shifted_lons=True\n        print \"###########################\"\n\n    print \"Lower left corner: lat=\"+str(min(mera_lat))+\" long=\"+str(min(mera_lon))\n    print \"Upper right corner: lat=\"+str(max(mera_lat))+\" long=\"+str(max(mera_lon))\n\n    #number of times in  mera file\n    times_per_file=merra_f.variables['time'].size\n    merra_f.close()\n\n    index=0\n    for merra_file in merra_files:\n        date=numbers.split(merra_file)[9]\n        for i in range(0,times_per_file,1):\n            t=datetime.strptime(date, '%Y%m%d')+timedelta(minutes =(i*(24\/times_per_file)*60))\n            mera_times_files.update({t.strftime(\"%Y-%m-%d_%H:%M:%S\"):index})\n            mera_times.update({t.strftime(\"%Y-%m-%d_%H:%M:%S\"):i})\n        index=index+1\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_14","text":"<gh_stars>10-100\n#!\/usr\/bin\/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Oct 12 15:10:49 2019\nThis is a library of tensor network method for Ising models\n@author: Bruce\n\"\"\"\n\nimport numpy as np\nimport scipy.integrate as integrate\nfrom ncon import ncon\nfrom tntools.initialtensors import get_initial_tensor\n\ndef exactSol(J):\n    \"\"\"\n    g = exactSol(J).\n    ---------------------\n    Return: g is defined as ln(Z) \/ N = -beta * f, where Z is the partition\n    function, N is the total number of spin, f the free energy per site.\n    \"\"\"\n\n    g = np.zeros(len(J))\n    for i in range(len(J)):\n        k = 1 \/ (np.sinh(2*J[i])**2)\n        integrand = lambda theta: np.log((np.cosh(2*J[i]))**2\n        + 1 \/ k * np.sqrt(1 + k**2 - 2*k * np.cos(2*theta)))\n        g[i] = np.log(2) \/ 2 + 1 \/ (2 * np.pi) * integrate.quad(integrand, 0,np.pi)[0]\n    return g\n\n\ndef Ising2dT(beta = 0.4, h = 0, isSym = False):\n    \"\"\"\n    T = Ising2dT(J,h).\n    -------------------------\n    Set up the initial tensor for 2d classical Ising model on a square lattice.\n    Argument: J is defined to be beta * J = J \/ kT, and h is\n    defined to be beta*h = h \/ kT, where J and h are conventional coupling constants.\n    Return: a rank 4 tensor T[i,j,k,l]. Each index of the tensor represents\n    physical classical spin, and the tensor T represents the Boltzmann weight\n    for interaction on one plaquettes.\n    \"\"\"\n    pars = {\"model\":\"ising\", \"dtype\":\"float64\", \n            \"J\":1, \"H\":h, \"beta\":beta, \"symmetry_tensors\":isSym}\n    T0 = get_initial_tensor(pars)\n\n    return T0\n\ndef Ising2dTwall(J = 0.1):\n    \"\"\"\n    Set up the initial tensor for 2d classical Ising model on a square lattice\n    according to the method described in Xiang's HOTRG paper and Hauru's Gilt\n    paper. The number of initial tensor is the same as the number of initial\n    spin variables.\n\n    Parameters\n    ----------\n    J : double, optional\n        Inverse temperature J\/T. The default is 0.1.\n\n    Returns\n    -------\n    T: four leg tensor\n\n    \"\"\"\n    raise Warning(\"This function is deprecated now!\")\n    # The sqaure root of weight matrix (See Hauru's Gilt paper for details)\n    M = np.array([[np.sqrt(np.cosh(J)), np.sqrt(np.sinh(J))],\n         [np.sqrt(np.cosh(J)), - np.sqrt(np.sinh(J))]])\n    T = np.einsum(\"ai,aj,ak,al->ijkl\",M,M,M,M)\n    return T\n\ndef checkSym(T):\n    \"\"\"\n    Check whether a tensor T has horizontal and verticle symmetry\n\n    Parameters\n    ----------\n    T : four-leg tensor\n       j|\n     i--T--k.\n       l|\n\n    Returns\n    -------\n    None.\n\n    \"\"\"\n    Tarr = T.to_ndarray()\n    ishSym = np.allclose(Tarr,Tarr.transpose([2,1,0,3]))\n    isvSym = np.allclose(Tarr,Tarr.transpose([0,3,2,1]))\n    print(\"Horizontal symmetry: {}.\".format(ishSym))\n    print(\"Vertical symmetry: {}.\".format(isvSym))\n\ndef calg(A,Anorm,initN = 4, traceord = [1,1,2,2]):\n    numlevels = len(A)-1\n    FreeEnergy = np.zeros(numlevels)\n    Anorm = np.array(Anorm)\n    for k in range(1,numlevels+1):\n        FreeEnergy[k-1] = (np.sum(4.0 ** (-np.arange(0,k+1)) * \n                                  np.log(Anorm[:(k+1)])) + \n                           (1\/4)**k * np.log(ncon(\n                               [A[k]],[traceord]).norm())) \/(2*initN)\n    return FreeEnergy\n\nif __name__ == \"__main__\":\n    import argparse\n    from trg import mainTRG, calg\n    \n    def compareg(n_iter = 12,Dcut = 8, isSym = False):\n        Tc = 2 \/ np.log(1 + np.sqrt(2))\n        gext = exactSol([1\/Tc])[0]\n        A, Anorm = mainTRG(1.0, Dcut, n_iter, isSym = isSym)\n        gapp = calg(A,Anorm, initN = 1,  traceord = [1,2,1,2])\n        err = np.abs(gapp - gext) \/ gext\n        return err, A\n    parser = argparse.ArgumentParser(\n        \"Test TRG implementation\")\n    parser.add_argument(\"--chi\", dest = \"chi\", type = int,\n                    help = \"bound dimension (default: 10)\",\n                    default = 10)\n    parser.add_argument(\"--iterN\", dest = \"iterN\", type = int,\n                    help = \"Number of TRG iterations (default: 25)\",\n                    default = 25)\n    parser.add_argument(\"--isSym\", help = \"whether to use Z2 symmetry\",\n                        action = \"store_true\")\n    args = parser.parse_args()\n    chi = args.chi\n    iterN = args.iterN\n    isSym = args.isSym\n    err,A = compareg(iterN, chi, isSym)\n    print(\"Error of free energy at Tc is \")\n    print(err)\n    \n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_15","text":"\"\"\"Utility functions for ray computation.\"\"\"\nimport math\nimport numpy as np\nfrom scipy.spatial.transform import Rotation as R\nimport box_utils\nimport torch\n\n\ndef apply_batched_transformations(inputs, transformations):\n    \"\"\"Batched transformation of inputs.\n\n    Args:\n        inputs: List of [R, S, 3]\n        transformations: [R, 4, 4]\n\n    Returns:\n        transformed_inputs: List of [R, S, 3]\n    \"\"\"\n    # if rotation_only:\n    #    transformations[:, :3, 3] = torch.zeros((3,), dtype=torch.float)\n\n    transformed_inputs = []\n    for x in inputs:\n        N_samples = x.size()[1]\n        homog_transformations = transformations.unsqueeze(1)  # [R, 1, 4, 4]\n        homog_transformations = torch.tile(homog_transformations, (1, N_samples, 1, 1))  # [R, S, 4, 4]\n        homog_component = torch.ones_like(x)[..., 0:1]  # [R, S, 1]\n        homog_x = torch.cat((x, homog_component), axis=-1)  # [R, S, 4]\n        homog_x = homog_x.unsqueeze(2)\n        transformed_x = torch.matmul(\n            homog_x,\n            torch.transpose(homog_transformations, 2, 3))  # [R, S, 1, 4]\n        transformed_x = transformed_x[..., 0, :3]  # [R, S, 3]\n        transformed_inputs.append(transformed_x)\n    return transformed_inputs\n\n\ndef get_transformation_from_params(params):\n    translation, rotation = [0, 0, 0], [0, 0, 0]\n    if 'translation' in params:\n        translation = params['translation']\n    if 'rotation' in params:\n        rotation = params['rotation']\n    translation = torch.tensor(translation, dtype=torch.float)\n    rotmat = torch.tensor(R.from_euler('xyz', rotation, degrees=True).as_matrix(), dtype=torch.float)\n    return translation, rotmat\n\n\ndef rotate_dirs(dirs, rotmat):\n    \"\"\"\n    Args:\n        dirs: [R, 3] float tensor.\n        rotmat: [3, 3]\n    \"\"\"\n    if type(dirs) == np.ndarray:\n        dirs = torch.tensor(dirs).float()\n    #rotmat = rotmat.unsqueeze(0)\n    rotmat = torch.broadcast_to(rotmat, (dirs.shape[0], 3, 3))  # [R, 3, 3]\n    dirs_obj = torch.matmul(dirs.unsqueeze(1), torch.transpose(rotmat, 1, 2))  # [R, 1, 3]\n    dirs_obj = dirs_obj.squeeze(1)  # [R, 3]\n    return dirs_obj\n\n\ndef transform_dirs(dirs, params, inverse=False):\n    _, rotmat = get_transformation_from_params(params)  # [3,], [3, 3]\n    if inverse:\n        rotmat = torch.transpose(rotmat, 0, 1)  # [3, 3]\n    dirs_transformed = rotate_dirs(dirs, rotmat)\n    return dirs_transformed\n\n\ndef transform_rays(ray_batch, params, use_viewdirs, inverse=False):\n    \"\"\"Transform rays into object coordinate frame given o2w transformation params.\n\n    Note: do not assume viewdirs is always the normalized version of rays_d (e.g., in staticcam case).\n\n    Args:\n        ray_batch: [R, M] float tensor. Batch of rays.\n        params: Dictionary containing transformation parameters:\n            'translation': List of 3 elements. xyz translation.\n            'rotation': List of 3 euler angles in xyz.\n        use_viewdirs: bool. Whether to we are using viewdirs.\n        inverse: bool. Whether to apply inverse of the transformations provided in 'params'.\n\n    Returns:\n        ray_batch_obj: [R, M] float tensor. The ray batch, in object coordinate frame.\n    \"\"\"\n    rays_o, rays_d = ray_batch[:, 0:3], ray_batch[:, 3:6]\n    translation, rotmat = get_transformation_from_params(params)  # [3,], [3, 3]\n\n    if inverse:\n        translation = -1 * translation  # [3,]\n        rotmat = torch.transpose(rotmat, 1, 0)  # [3, 3]\n\n    translation_inverse = -1 * translation\n    rotmat_inverse = torch.transpose(rotmat, 1, 0)\n\n    # Transform the ray origin.\n    rays_o_obj, _ = box_utils.ray_to_box_coordinate_frame_pairwise(\n        box_center=translation_inverse,\n        box_rotation_matrix=rotmat_inverse,\n        rays_start_point=rays_o,\n        rays_end_point=rays_d)\n\n    # Only apply rotation to rays_d.\n    rays_d_obj = rotate_dirs(rays_d, rotmat)\n\n    ray_batch_obj = update_ray_batch_slice(ray_batch, rays_o_obj, 0, 3)\n    ray_batch_obj = update_ray_batch_slice(ray_batch_obj, rays_d_obj, 3, 6)\n    if use_viewdirs:\n        # Grab viewdirs from the ray batch itself. Because it may be different from rays_d\n        # (as in the staticcam case).\n        viewdirs = ray_batch[:, 8:11]\n        viewdirs_obj = rotate_dirs(viewdirs, rotmat)\n        ray_batch_obj = update_ray_batch_slice(ray_batch_obj, viewdirs_obj, 8, 11)\n    return ray_batch_obj\n\n\ndef transform_points_into_world_coordinate_frame(pts, params, check_numerics=False):\n    translation, rotmat = get_transformation_from_params(params)  # [3,], [3, 3]\n\n    # pts_flat = pts.view(-1, 3)  # [RS, 3]\n    # num_examples = pts_flat.size()[0]  # RS\n\n    # translation = translation.unsqueeze(0)\n    # translation = torch.tile(translation, (num_examples, 1))  # [RS, 3]\n    # rotmat = rotmat.unsqueeze(0)\n    # rotmat = torch.tile(rotmat, (num_examples, 1, 1))\n\n    # # pts_flat_transformed = torch.matmul(pts_flat[:, None, :], torch.transpose(rotmat, 2, 1))  # [RS, 1, 3]\n    # pts_flat_transformed = pts_flat[:, None, :]  # [RS, 1, 3]\n    # pts_flat_transformed += translation[:, None, :]  # [RS, 1, 3]\n    # pts_transformed = pts_flat_transformed.view(pts.size())  # [R, S, 3]\n    chunk = 256\n    # Check batch transformations works without rotation.\n    if check_numerics:\n        transformations = np.eye(4)\n        transformations[:3, 3] = translation\n        transformations = torch.tensor(transformations, dtype=torch.float)  # [4, 4]\n        transformations = torch.tile(transformations[None, ...], (pts.size()[0], 1, 1))  # [R, 4, 4]\n        pts_transformed1 = []\n        for i in range(0, pts.size()[0], chunk):\n            pts_transformed1_chunk = apply_batched_transformations(\n                inputs=[pts[i:i+chunk]], transformations=transformations[i:i+chunk])[0]\n            pts_transformed1.append(pts_transformed1_chunk)\n        pts_transformed1 = torch.cat(pts_transformed1, dim=0)\n\n        pts_transformed2 = pts + translation[None, None, :]\n\n    # Now add rotation\n    transformations = np.eye(4)\n    transformations = torch.tensor(transformations, dtype=torch.float)\n    transformations[:3, :3] = rotmat\n    transformations[:3, 3] = translation\n    #transformations = torch.tensor(transformations, dtype=torch.float)  # [4, 4]\n    transformations = torch.tile(transformations[None, ...], (pts.size()[0], 1, 1))  # [R, 4, 4]\n    pts_transformed = []\n    for i in range(0, pts.size()[0], chunk):\n        pts_transformed_chunk = apply_batched_transformations(\n            inputs=[pts[i:i+chunk]], transformations=transformations[i:i+chunk])[0]\n        pts_transformed.append(pts_transformed_chunk)\n    pts_transformed = torch.cat(pts_transformed, dim=0)\n    return pts_transformed\n\n\n# def transform_rays(ray_batch, translation, use_viewdirs):\n#    \"\"\"Apply transformation to rays.\n\n#    Args:\n#        ray_batch: [R, M] float tensor. All information necessary\n#            for sampling along a ray, including: ray origin, ray direction, min\n#            dist, max dist, and unit-magnitude viewing direction.\n#        translation: [3,] float tensor. The (x, y, z) translation to apply.\n#        use_viewdirs: Whether to use view directions.\n\n#    Returns:\n#        ray_batch: [R, M] float tensor. Transformed ray batch.\n#    \"\"\"\n#   assert translation.size()[0] == 3, \"translation.size()[0] must be 3...\"\n\n#    # Since we are only supporting translation for now, only ray origins need to be\n#    # modified. Ray directions do not need to change.\n#    rays_o = ray_batch[:, 0:3] + translation\n#    rays_remaining = ray_batch[:, 3:]\n#    ray_batch = torch.cat((rays_o, rays_remaining), dim=1)\n#    return ray_batch\n\ndef compute_rays_length(rays_d):\n    \"\"\"Compute ray length.\n\n    Args:\n        rays_d: [R, 3] float tensor. Ray directions.\n\n    Returns:\n        rays_length: [R, 1] float tensor. Ray lengths.\n    \"\"\"\n    rays_length = torch.norm(rays_d, dim=-1, keepdim=True)  # [N_rays, 1]\n    return rays_length\n\n\ndef normalize_rays(rays):\n    \"\"\"Normalize ray directions.\n\n    Args:\n        rays: [R, 3] float tensor. Ray directions.\n\n    Returns:\n        normalized_rays: [R, 3] float tensor. Normalized ray directions.\n    \"\"\"\n    normalized_rays = rays \/ compute_rays_length(rays_d=rays)\n    return normalized_rays\n\n\ndef compute_ray_dirs_and_length(rays_o, rays_dst):\n    \"\"\"Compute ray directions.\n\n    Args:\n        rays_o: [R, 3] float tensor. Ray origins.\n        rays_dst: [R, 3] float tensor. Ray destinations.\n\n    Returns:\n        rays_d: [R, 3] float tensor. Normalized ray directions.\n    \"\"\"\n    # The ray directions are the difference between the ray destinations and the\n    # ray origins.\n    rays_d = rays_dst - rays_o  # [R, 3]  # Direction out of light source\n\n    # Compute the length of the rays.\n    rays_length = compute_rays_length(rays_d=rays_d)\n\n    # Normalized the ray directions.\n    rays_d = rays_d \/ rays_length  # [R, 3]  # Normalize direction\n    return rays_d, rays_length\n\n\ndef update_ray_batch_slice(ray_batch, x, start, end):\n    left = ray_batch[:, :start]  # [R, ?]\n    right = ray_batch[:, end:]  # [R, ?]\n    updated_ray_batch = torch.cat((left, x, right), dim=-1)\n    return updated_ray_batch\n\n\ndef update_ray_batch_bounds(ray_batch, bounds):\n    updated_ray_batch = update_ray_batch_slice(ray_batch=ray_batch, x=bounds,\n                                               start=6, end=8)\n    return updated_ray_batch\n\n\ndef create_ray_batch(\n    rays_o, rays_dst, rays_i, use_viewdirs, rays_near=None, rays_far=None, epsilon=1e-10):\n    # Compute the ray directions.\n    rays_d = rays_dst - rays_o  # [R,3]  # Direction out of light source\n    rays_length = compute_rays_length(rays_d=rays_d)  # [R, 1]\n    rays_d = rays_d \/ rays_length  # [R, 3]  # Normalize direction\n    viewdirs = rays_d  # [R, 3]\n\n    # If bounds are not provided, set the beginning and end of ray as sampling bounds.\n    if rays_near is None:\n        rays_near = torch.zeros((rays_o.size()[0], 1), dtype=torch.float) + epsilon  # [R, 1]\n    if rays_far is None:\n        rays_far = rays_length  # [R, 1]\n\n    ray_batch = torch.cat((rays_o, rays_d, rays_near, rays_far), dim=-1)\n    if use_viewdirs:\n        ray_batch = torch.cat((ray_batch, viewdirs), dim=-1)\n    ray_batch = torch.cat((ray_batch, rays_i), dim=-1)\n    return ray_batch\n\n\ndef sample_random_lightdirs(num_rays, num_samples, upper_only=False):\n    \"\"\"Randomly sample directions in the unit sphere.\n\n    Args:\n        num_rays: int or tensor shape dimension. Number of rays.\n        num_samples: int or tensor shape dimension. Number of samples per ray.\n        upper_only: bool. Whether to sample only on the upper hemisphere.\n\n    Returns:\n        lightdirs: [R, S, 3] float tensor. Random light directions sampled from the unit\n            sphere for each sampled point.\n    \"\"\"\n    if upper_only:\n        min_z = 0\n    else:\n        min_z = -1\n\n    phi = torch.rand(num_rays, num_samples) * (2 * math.pi)  # [R, S]\n    cos_theta = torch.rand(num_rays, num_samples) * (1 - min_z) + min_z  # [R, S]\n    theta = torch.acos(cos_theta)  # [R, S]\n\n    x = torch.sin(theta) * torch.cos(phi)\n    y = torch.sin(theta) * torch.sin(phi)\n    z = torch.cos(theta)\n\n    lightdirs = torch.cat((x[..., None], y[..., None], z[..., None]), dim=-1)  # [R, S, 3]\n    return lightdirs\n\n\ndef get_light_positions(rays_i, img_light_pos):\n    \"\"\"Extracts light positions given scene IDs.\n\n    Args:\n        rays_i: [R, 1] float tensor. Per-ray image IDs.\n        img_light_pos: [N, 3] float tensor. Per-image light positions.\n\n    Returns:\n        rays_light_pos: [R, 3] float tensor. Per-ray light positions.\n    \"\"\"\n    rays_light_pos = img_light_pos[rays_i.long()].squeeze()  # [R, 3]\n    return rays_light_pos\n\n\ndef get_lightdirs(lightdirs_method, num_rays=None, num_samples=None, rays_i=None,\n    metadata=None, ray_batch=None, use_viewdirs=False, normalize=False):\n    \"\"\"Compute lightdirs.\n\n    Args:\n        lightdirs_method: str. Method to use for computing lightdirs.\n        num_rays: int or tensor shape dimension. Number of rays.\n        num_samples: int or tensor shape dimension. Number of samples per ray.\n        rays_i: [R, 1] float tensor. Ray image IDs.\n        metadata: [N, 3] float tensor. Metadata about each image. Currently only light\n            position is provided.\n        ray_batch: [R, M] float tensor. Ray batch.\n        use_viewdirs: bool. Whether to use viewdirs.\n        normalize: bool. Whether to normalize lightdirs.\n\n    Returns;\n        lightdirs: [R, S, 3] float tensor. Light directions for each sample.\n    \"\"\"\n    if lightdirs_method == 'viewdirs':\n        raise NotImplementedError\n        assert use_viewdirs\n        lightdirs = ray_batch[:, 8:11]  # [R, 3]\n        lightdirs *= 1.5\n        lightdirs = torch.tile(lightdirs[:, None, :], (1, num_samples, 1))\n    elif lightdirs_method == 'metadata':\n        lightdirs = get_light_positions(rays_i, metadata)  # [R, 3]\n        lightdirs = torch.tile(lightdirs[:, None, :], (1, num_samples, 1))  # [R, S, 3]\n    elif lightdirs_method == 'random':\n        lightdirs = sample_random_lightdirs(num_rays, num_samples)  # [R, S, 3]\n    elif lightdirs_method == 'random_upper':\n        lightdirs = sample_random_lightdirs(num_rays, num_samples, upper_only=True)  # [R, S, 3]\n    else:\n        raise ValueError(f'Invalid lightdirs_method: {lightdirs_method}.')\n    if normalize:\n        lightdirs_flat = lightdirs.view(-1, 3)  # [RS, 3]\n        lightdirs_flat = normalize_rays(lightdirs_flat)  # [RS, 3]\n        lightdirs = lightdirs_flat.view(lightdirs.size())  # [R, S, 3]\n    return lightdirs\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_9","text":"<gh_stars>0\nimport argparse\nimport cv2\nimport numpy as np\nimport os\nimport pickle\nimport sys\nfrom gaussian2d import gaussian2d\nfrom hashkey import hashkey\nfrom math import floor, pi\nfrom matplotlib import pyplot as plt\nfrom scipy import interpolate\nfrom skimage import transform\nfrom numba import njit, prange\n\ndef bicubic2x(mat):\n    mch=False\n    if len(mat.shape)==3:\n        h,w,ch=mat.shape\n        mch=True\n    if mch:\n        ret = np.zeros((h*2,w*2,ch))\n        for i in range(ch):\n            ret[:,:,i]=_bicubic2x(mat[:,:,i])\n        return ret\n    else:\n        return _bicubic2x(mat)\n\n#@njit(parallel=True)\ndef _bicubic2x(mat):\n    h,w=mat.shape\n    heightgridLR = np.linspace(0,h-1,h)\n    widthgridLR = np.linspace(0,w-1,w)\n    heightgridHR = np.linspace(0,h-0.5,h*2)\n    widthgridHR = np.linspace(0,w-0.5,w*2)\n    interp=interpolate.interp2d(widthgridLR, heightgridLR, mat, kind='cubic')\n    return interp(widthgridHR,heightgridHR)\n\ndef bicubic0_5x(mat):\n    mch=False\n    if len(mat.shape)==3:\n        h,w,ch=mat.shape\n        mch=True\n    if mch:        \n        ret = np.zeros((int(h\/2),int(w\/2),ch))\n        for i in range(ch):\n            ret[:,:,i]=_bicubic0_5x(mat[:,:,i])\n        return ret\n    else:\n        return _bicubic0_5x(mat)\n\n#@njit(parallel=True)\ndef _bicubic0_5x(mat):\n    h,w=mat.shape\n    heightgridHR = np.linspace(0,h-1,h)\n    widthgridHR = np.linspace(0,w-1,w)\n    heightgridLR = np.linspace(0,h-2,h\/2)\n    widthgridLR = np.linspace(0,w-2,w\/2)\n    interp=interpolate.interp2d(widthgridHR, heightgridHR, mat, kind='cubic')\n    return interp(widthgridLR,heightgridLR)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_144","text":"from statistics import mean, median\nfrom time import perf_counter\n\n\nclass Timer:\n    def __init__(self, func=None):\n        self._start = None\n        self._finish = None\n        self.runs = list()\n        self._func = func\n\n    def __enter__(self):\n        self._start = perf_counter()\n        return self\n\n    def __exit__(self, exc_type, exc_val, exc_tb):\n        self._finish = perf_counter()\n        self.runs.append(self._finish - self._start)\n\n    def __call__(self, *args, **kwargs):\n        with self:\n            return self._func(*args, **kwargs)\n\n    @property\n    def elapsed(self):\n        return sum(self.runs)\n\n    @property\n    def min(self):\n        return min(self.runs)\n\n    @property\n    def max(self):\n        return max(self.runs)\n\n    @property\n    def mean(self):\n        return mean(self.runs)\n\n    @property\n    def median(self):\n        return median(self.runs)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_145","text":"import pandas as pd\nimport numpy as np\nimport math\nfrom scipy.stats import nct\nimport torch\nfrom copy import deepcopy\nimport matplotlib.pyplot as plt\n\nfrom ..constants import ktrx as constants\nfrom ..constants.constants import (\n    CoefPriorDictKeys,\n)\nfrom ..constants.ktrx import (\n    DEFAULT_REGRESSOR_SIGN,\n    DEFAULT_COEFFICIENTS_INIT_KNOT_SCALE,\n    DEFAULT_COEFFICIENTS_INIT_KNOT_LOC,\n    DEFAULT_COEFFICIENTS_KNOT_SCALE,\n    DEFAULT_LOWER_BOUND_SCALE_MULTIPLIER,\n    DEFAULT_UPPER_BOUND_SCALE_MULTIPLIER,\n)\n\nfrom ..estimators.pyro_estimator import PyroEstimatorVI\nfrom ..exceptions import IllegalArgument, ModelException, PredictionException\nfrom ..utils.general import is_ordered_datetime\nfrom ..utils.kernels import gauss_kernel, sandwich_kernel\nfrom ..utils.features import make_fourier_series_df\nfrom .template import BaseTemplate, FullBayesianTemplate, AggregatedPosteriorTemplate\n\n\nclass BaseKTRX(BaseTemplate):\n    \"\"\"Base KTRX model object with shared functionality for PyroVI method\n\n    Parameters\n    ----------\n    level_knot_scale : float\n        sigma for level; default to be .1\n    regressor_col : array-like strings\n        regressor columns\n    regressor_sign : list\n        list of signs with '=' for regular regressor and '+' for positive regressor\n    regressor_init_knot_loc : list\n        list of regressor knot pooling mean priors, default to be 0's\n    regressor_init_knot_scale : list\n        list of regressor knot pooling sigma's to control the pooling strength towards the grand mean of regressors;\n        default to be 1.\n    regressor_knot_scale : list\n        list of regressor knot sigma priors; default to be 0.1.\n    span_coefficients : float between (0, 1)\n        window width to decide the number of windows for the regression term\n    rho_coefficients : float\n        sigma in the Gaussian kernel for the regression term\n    degree of freedom : int\n        degree of freedom for error t-distribution\n    coef_prior_list : list of dicts\n        each dict in the list should have keys as\n        'name', prior_start_tp_idx' (inclusive), 'prior_end_tp_idx' (not inclusive),\n        'prior_mean', 'prior_sd', and 'prior_regressor_col'\n    level_knot_dates : array like\n        list of pre-specified dates for level knots\n    level_knots : array like\n        list of knot locations for level\n        level_knot_dates and level_knots should be of the same length\n    seasonal_knots_input : dict\n         a dictionary for seasonality inputs with the following keys:\n            '_seas_coef_knot_dates' : knot dates for seasonal regressors\n            '_sea_coef_knot' : knot locations for sesonal regressors\n            '_seasonality' : seasonality order\n            '_seasonality_fs_order' : fourier series order for seasonality\n    coefficients_knot_length : int\n        the distance between every two knots for coefficients\n    coefficients_knot_dates : array like\n        a list of pre-specified knot dates for coefficients\n    date_freq : str\n        date frequency; if not supplied, pd.infer_freq will be used to imply the date frequency.\n    min_residuals_sd : float\n        a numeric value from 0 to 1 to indicate the upper bound of residual scale parameter; e.g.\n        0.5 means residual scale will be sampled from [0, 0.5] in a scaled Beta(2, 2) dist.\n    flat_multiplier : bool\n        Default set as True. If False, we will adjust knot scale with a multiplier based on regressor volume\n        around each knot; When True, set all multiplier as 1\n    geometric_walk : bool\n        Default set as False. If True we will sample positive regressor knot as geometric random walk\n    kwargs\n        To specify `estimator_type` or additional args for the specified `estimator_type`\n\n    \"\"\"\n    _data_input_mapper = constants.DataInputMapper\n    # stan or pyro model name (e.g. name of `*.stan` file in package)\n    _model_name = 'ktrx'\n\n    def __init__(self,\n                 level_knot_scale=0.1,\n                 regressor_col=None,\n                 regressor_sign=None,\n                 regressor_init_knot_loc=None,\n                 regressor_init_knot_scale=None,\n                 regressor_knot_scale=None,\n                 span_coefficients=0.3,\n                 rho_coefficients=0.15,\n                 degree_of_freedom=30,\n                 # time-based coefficient priors\n                 coef_prior_list=None,\n                 # knot customization\n                 level_knot_dates=None,\n                 level_knots=None,\n                 seasonal_knots_input=None,\n                 coefficients_knot_length=None,\n                 coefficients_knot_dates=None,\n                 date_freq=None,\n                 mvn=0,\n                 flat_multiplier=True,\n                 geometric_walk=False,\n                 min_residuals_sd=1.0,\n                 **kwargs):\n        super().__init__(**kwargs)  # create estimator in base class\n\n        # normal distribution of known knot\n        self.level_knot_scale = level_knot_scale\n\n        self.level_knot_dates = level_knot_dates\n        self._level_knot_dates = level_knot_dates\n\n        self.level_knots = level_knots\n        # self._level_knots = level_knots\n\n        self._kernel_level = None\n        self._num_knots_level = None\n        self.knots_tp_level = None\n\n        self._seasonal_knots_input = seasonal_knots_input\n        self._seas_term = 0\n\n        self.regressor_col = regressor_col\n        self.regressor_sign = regressor_sign\n        self.regressor_init_knot_loc = regressor_init_knot_loc\n        self.regressor_init_knot_scale = regressor_init_knot_scale\n        self.regressor_knot_scale = regressor_knot_scale\n\n        self.coefficients_knot_length = coefficients_knot_length\n        self.span_coefficients = span_coefficients\n        self.rho_coefficients = rho_coefficients\n        self.date_freq = date_freq\n\n        self.degree_of_freedom = degree_of_freedom\n\n        # multi var norm flag\n        self.mvn = mvn\n        # flat_multiplier flag\n        self.flat_multiplier = flat_multiplier\n        self.geometric_walk = geometric_walk\n        self.min_residuals_sd = min_residuals_sd\n\n        # set private var to arg value\n        # if None set default in _set_default_args()\n        self._regressor_sign = self.regressor_sign\n        self._regressor_init_knot_loc = self.regressor_init_knot_loc\n        self._regressor_init_knot_scale = self.regressor_init_knot_scale\n        self._regressor_knot_scale = self.regressor_knot_scale\n\n        self.coef_prior_list = coef_prior_list\n        self._coef_prior_list = []\n        self._coefficients_knot_dates = coefficients_knot_dates\n        self._knots_idx_coef = None\n\n        self._num_of_regressors = 0\n        self._num_knots_coefficients = 0\n\n        # positive regressors\n        self._num_of_positive_regressors = 0\n        self._positive_regressor_col = list()\n        self._positive_regressor_init_knot_loc = list()\n        self._positive_regressor_init_knot_scale = list()\n        self._positive_regressor_knot_scale = list()\n        # regular regressors\n        self._num_of_regular_regressors = 0\n        self._regular_regressor_col = list()\n        self._regular_regressor_init_knot_loc = list()\n        self._regular_regressor_init_knot_scale = list()\n        self._regular_regressor_knot_scale = list()\n        self._regressor_col = list()\n\n        # init dynamic data attributes\n        # the following are set by `_set_dynamic_attributes()` and generally set during fit()\n        # from input df\n        # response data\n        self._is_valid_response = None\n        self._which_valid_response = None\n        self._num_of_valid_response = 0\n        self._seasonality = None\n\n        # regression data\n        self._knots_tp_coefficients = None\n        self._positive_regressor_matrix = None\n        self._regular_regressor_matrix = None\n\n    def _set_model_param_names(self):\n        \"\"\"Overriding base template functions. Model parameters to extract\"\"\"\n        self._model_param_names += [param.value for param in constants.BaseSamplingParameters]\n        if self._num_of_regressors > 0:\n            self._model_param_names += [param.value for param in constants.RegressionSamplingParameters]\n\n    def _set_default_args(self):\n        \"\"\"Set default attributes for None\n        \"\"\"\n        if self.coef_prior_list is not None:\n            self._coef_prior_list = deepcopy(self.coef_prior_list)\n        if self.level_knots is None:\n            self._level_knots = list()\n        if self._seasonal_knots_input is not None:\n            self._seasonality = self._seasonal_knots_input['_seasonality']\n        else:\n            self._seasonality = list()\n        ##############################\n        # if no regressors, end here #\n        ##############################\n        if self.regressor_col is None:\n            # regardless of what args are set for these, if regressor_col is None\n            # these should all be empty lists\n            self._regressor_sign = list()\n            self._regressor_init_knot_loc = list()\n            self._regressor_init_knot_scale = list()\n            self._regressor_knot_scale = list()\n\n            return\n\n        def _validate_params_len(params, valid_length):\n            for p in params:\n                if p is not None and len(p) != valid_length:\n                    raise IllegalArgument('Wrong dimension length in Regression Param Input')\n\n        # regressor defaults\n        num_of_regressors = len(self.regressor_col)\n\n        _validate_params_len([\n            self.regressor_sign, self.regressor_init_knot_loc,\n            self.regressor_init_knot_scale, self.regressor_knot_scale],\n            num_of_regressors\n        )\n\n        if self.regressor_sign is None:\n            self._regressor_sign = [DEFAULT_REGRESSOR_SIGN] * num_of_regressors\n\n        if self.regressor_init_knot_loc is None:\n            self._regressor_init_knot_loc = [DEFAULT_COEFFICIENTS_INIT_KNOT_LOC] * num_of_regressors\n\n        if self.regressor_init_knot_scale is None:\n            self._regressor_init_knot_scale = [DEFAULT_COEFFICIENTS_INIT_KNOT_SCALE] * num_of_regressors\n\n        if self.regressor_knot_scale is None:\n            self._regressor_knot_scale = [DEFAULT_COEFFICIENTS_KNOT_SCALE] * num_of_regressors\n\n        self._num_of_regressors = num_of_regressors\n\n    def _set_static_regression_attributes(self):\n        # if no regressors, end here\n        if self._num_of_regressors == 0:\n            return\n\n        for index, reg_sign in enumerate(self._regressor_sign):\n            if reg_sign == '+':\n                self._num_of_positive_regressors += 1\n                self._positive_regressor_col.append(self.regressor_col[index])\n                # used for 'pr_knot_loc' sampling in pyro\n                self._positive_regressor_init_knot_loc.append(self._regressor_init_knot_loc[index])\n                self._positive_regressor_init_knot_scale.append(self._regressor_init_knot_scale[index])\n                # used for 'pr_knot' sampling in pyro\n                self._positive_regressor_knot_scale.append(self._regressor_knot_scale[index])\n            else:\n                self._num_of_regular_regressors += 1\n                self._regular_regressor_col.append(self.regressor_col[index])\n                # used for 'rr_knot_loc' sampling in pyro\n                self._regular_regressor_init_knot_loc.append(self._regressor_init_knot_loc[index])\n                self._regular_regressor_init_knot_scale.append(self._regressor_init_knot_scale[index])\n                # used for 'rr_knot' sampling in pyro\n                self._regular_regressor_knot_scale.append(self._regressor_knot_scale[index])\n        # regular first, then positive\n        self._regressor_col = self._regular_regressor_col + self._positive_regressor_col\n        # numpy conversion\n        self._positive_regressor_init_knot_loc = np.array(self._positive_regressor_init_knot_loc)\n        self._positive_regressor_init_knot_scale = np.array(self._positive_regressor_init_knot_scale)\n        self._positive_regressor_knot_scale = np.array(self._positive_regressor_knot_scale)\n        self._regular_regressor_init_knot_loc = np.array(self._regular_regressor_init_knot_loc)\n        self._regular_regressor_init_knot_scale = np.array(self._regular_regressor_init_knot_scale)\n        self._regular_regressor_knot_scale = np.array(self._regular_regressor_knot_scale)\n\n    @staticmethod\n    def _validate_coef_prior(coef_prior_list):\n        for test_dict in coef_prior_list:\n            if set(test_dict.keys()) != set([\n                CoefPriorDictKeys.NAME.value,\n                CoefPriorDictKeys.PRIOR_START_TP_IDX.value,\n                CoefPriorDictKeys.PRIOR_END_TP_IDX.value,\n                CoefPriorDictKeys.PRIOR_MEAN.value,\n                CoefPriorDictKeys.PRIOR_SD.value,\n                CoefPriorDictKeys.PRIOR_REGRESSOR_COL.value\n            ]):\n                raise IllegalArgument('wrong key name in inserted prior dict')\n            len_insert_prior = list()\n            for key, val in test_dict.items():\n                if key in [\n                    CoefPriorDictKeys.PRIOR_MEAN.value,\n                    CoefPriorDictKeys.PRIOR_SD.value,\n                    CoefPriorDictKeys.PRIOR_REGRESSOR_COL.value,\n                ]:\n                    len_insert_prior.append(len(val))\n            if not all(len_insert == len_insert_prior[0] for len_insert in len_insert_prior):\n                raise IllegalArgument('wrong dimension length in inserted prior dict')\n\n    @staticmethod\n    def _validate_level_knot_inputs(level_knot_dates, level_knots):\n        if len(level_knots) != len(level_knot_dates):\n            raise IllegalArgument('level_knots and level_knot_dates should have the same length')\n\n    @staticmethod\n    def _get_gap_between_dates(start_date, end_date, freq):\n        diff = end_date - start_date\n        gap = np.array(diff \/ np.timedelta64(1, freq))\n\n        return gap\n\n    @staticmethod\n    def _set_knots_tp(knots_distance, cutoff):\n        \"\"\"provide a array like outcome of index based on the knots distance and cutoff point\"\"\"\n        # start in the middle\n        knots_idx_start = round(knots_distance \/ 2)\n        knots_idx = np.arange(knots_idx_start, cutoff, knots_distance)\n\n        return knots_idx\n\n    def _set_coef_prior_idx(self):\n        if self._coef_prior_list and len(self._regressor_col) > 0:\n            for x in self._coef_prior_list:\n                prior_regressor_col_idx = [\n                    np.where(np.array(self._regressor_col) == col)[0][0]\n                    for col in x['prior_regressor_col']\n                ]\n                x.update({'prior_regressor_col_idx': prior_regressor_col_idx})\n\n    def _set_static_attributes(self):\n        \"\"\"model data input based on args at instantiation or computed from args at instantiation\"\"\"\n        self._set_default_args()\n        self._set_static_regression_attributes()\n\n        self._validate_level_knot_inputs(self.level_knot_dates, self.level_knots)\n\n        if self._coef_prior_list:\n            self._validate_coef_prior(self._coef_prior_list)\n            self._set_coef_prior_idx()\n\n    def _set_valid_response_attributes(self):\n        if self._seasonality:\n            max_seasonality = np.round(np.max(self._seasonality)).astype(int)\n            if self.num_of_observations < max_seasonality:\n                raise ModelException(\n                    \"Number of observations {} is less than max seasonality {}\".format(\n                        self.num_of_observations, max_seasonality))\n        # get some reasonable offset to regularize response to make default priors scale-insensitive\n        if self._seasonality:\n            max_seasonality = np.round(np.max(self._seasonality)).astype(int)\n            self.response_offset = np.nanmean(self.response[:max_seasonality])\n        else:\n            self.response_offset = np.nanmean(self.response)\n\n        self.is_valid_response = ~np.isnan(self.response)\n        # [0] to convert tuple back to array\n        self.which_valid_response = np.where(self.is_valid_response)[0]\n        self.num_of_valid_response = len(self.which_valid_response)\n\n    def _set_regressor_matrix(self, df):\n        # validate regression columns\n        if self.regressor_col is not None and \\\n                not set(self.regressor_col).issubset(df.columns):\n            raise ModelException(\n                \"DataFrame does not contain specified regressor column(s).\"\n            )\n\n        # init of regression matrix depends on length of response vector\n        self._positive_regressor_matrix = np.zeros((self.num_of_observations, 0), dtype=np.double)\n        self._regular_regressor_matrix = np.zeros((self.num_of_observations, 0), dtype=np.double)\n\n        # update regression matrices\n        if self._num_of_positive_regressors > 0:\n            self._positive_regressor_matrix = df.filter(\n                items=self._positive_regressor_col,).values\n\n        if self._num_of_regular_regressors > 0:\n            self._regular_regressor_matrix = df.filter(\n                items=self._regular_regressor_col,).values\n\n    def _set_coefficients_kernel_matrix(self, df):\n        \"\"\"Derive knots position and kernel matrix and other related meta data\"\"\"\n        # Note that our tp starts by 1; to convert back to index of array, reduce it by 1\n        tp = np.arange(1, self.num_of_observations + 1) \/ self.num_of_observations\n        # this approach put knots in full range\n        # TODO: consider deprecate _cutoff for now since we assume _cutoff always the same as num of obs?\n        self._cutoff = self.num_of_observations\n        self._kernel_coefficients = np.zeros((self.num_of_observations, 0), dtype=np.double)\n        self._num_knots_coefficients = 0\n\n        # kernel of coefficients calculations\n        if self._num_of_regressors > 0:\n            # if users didn't provide knot positions, evenly distribute it based on span_coefficients\n            # or knot length provided by users\n            if self._coefficients_knot_dates is None:\n                # original code\n                if self.coefficients_knot_length is not None:\n                    knots_distance = self.coefficients_knot_length\n                else:\n                    number_of_knots = round(1 \/ self.span_coefficients)\n                    knots_distance = math.ceil(self._cutoff \/ number_of_knots)\n                # derive actual date arrays based on the time-point (tp) index\n                knots_idx_coef = self._set_knots_tp(knots_distance, self._cutoff)\n                self._knots_tp_coefficients = (1 + knots_idx_coef) \/ self.num_of_observations\n                self._coefficients_knot_dates = df[self.date_col].values[knots_idx_coef]\n                self._knots_idx_coef = knots_idx_coef\n                # TODO: new idea\n                # # ignore this case for now\n                # # if self.coefficients_knot_length is not None:\n                # #     knots_distance = self.coefficients_knot_length\n                # # else:\n                # number_of_knots = round(1 \/ self.span_coefficients)\n                # # to work with index; has to be discrete\n                # knots_distance = math.ceil(self._cutoff \/ number_of_knots)\n                # # always has a knot at the starting point\n                # # derive actual date arrays based on the time-point (tp) index\n                # knots_idx_coef = np.arange(0, self._cutoff, knots_distance)\n                # self._knots_tp_coefficients = (1 + knots_idx_coef) \/ self.num_of_observations\n                # self._coefficients_knot_dates = df[self.date_col].values[knots_idx_coef]\n                # self._knots_idx_coef = knots_idx_coef\n            else:\n                # FIXME: this only works up to daily series (not working on hourly series)\n                # FIXME: didn't provide  self.knots_idx_coef in this case\n                self._coefficients_knot_dates = pd.to_datetime([\n                    x for x in self._coefficients_knot_dates if (x <= df[self.date_col].max()) \\\n                                                                and (x >= df[self.date_col].min())\n                ])\n                if self.date_freq is None:\n                    self.date_freq = pd.infer_freq(df[self.date_col])[0]\n                start_date = self.training_start\n                self._knots_idx_coef = (\n                    self._get_gap_between_dates(start_date, self._coefficients_knot_dates, self.date_freq)\n                )\n\n                self._knots_tp_coefficients = np.array(\n                    (self._knots_idx_coef + 1) \/\n                    (self._get_gap_between_dates(start_date, self.training_end, self.date_freq) + 1)\n                )\n                self._knots_idx_coef = list(self._knots_idx_coef.astype(np.int32))\n\n            kernel_coefficients = gauss_kernel(tp, self._knots_tp_coefficients, rho=self.rho_coefficients)\n\n            self._num_knots_coefficients = len(self._knots_tp_coefficients)\n            self._kernel_coefficients = kernel_coefficients\n\n    def _set_knots_scale_matrix(self):\n        if self._num_of_positive_regressors > 0:\n            # calculate average local absolute volume for each segment\n            local_val = np.ones((self._num_of_positive_regressors, self._num_knots_coefficients))\n            if self.flat_multiplier:\n                multiplier = np.ones(local_val.shape)\n            else:\n                multiplier = np.ones(local_val.shape)\n                # store local value for the range on the left side since last knot\n                for idx in range(len(self._knots_idx_coef)):\n                    if idx < len(self._knots_idx_coef) - 1:\n                        str_idx = self._knots_idx_coef[idx]\n                        end_idx = self._knots_idx_coef[idx + 1]\n                    else:\n                        str_idx = self._knots_idx_coef[idx]\n                        end_idx = self.num_of_observations\n\n                    local_val[:, idx] = np.mean(np.fabs(self._positive_regressor_matrix[str_idx:end_idx]), axis=0)\n\n                # adjust knot scale with the multiplier derive by the average value and shift by 0.001 to avoid zeros in\n                # scale parameters\n                global_med = np.expand_dims(np.mean(np.fabs(self._positive_regressor_matrix), axis=0), -1)\n                test_flag = local_val < 0.01 * global_med\n\n                multiplier[test_flag] = DEFAULT_LOWER_BOUND_SCALE_MULTIPLIER\n                # replace entire row of nan (when 0.1 * global_med is equal to global_min) with upper bound\n                multiplier[np.isnan(multiplier).all(axis=-1)] = 1.0\n\n            # also note that after the following step,\n            # _positive_regressor_knot_scale is a 2D array unlike _regular_regressor_knot_scale\n            # geometric drift i.e. 0.1 = 10% up-down in 1 s.d. prob.\n            # after line below, self._positive_regressor_knot_scale has shape num_of_pr x num_of_knot\n            self._positive_regressor_knot_scale = (\n                    multiplier * np.expand_dims(self._positive_regressor_knot_scale, -1)\n            )\n            # keep a lower bound of scale parameters\n            self._positive_regressor_knot_scale[self._positive_regressor_knot_scale < 1e-4] = 1e-4\n            # TODO: we change the type here, maybe we should change it earlier?\n            self._positive_regressor_init_knot_scale = np.array(self._positive_regressor_init_knot_scale)\n            self._positive_regressor_init_knot_scale[self._positive_regressor_init_knot_scale < 1e-4] = 1e-4\n\n        if self._num_of_regular_regressors > 0:\n            # do the same for regular regressor\n            # calculate average local absolute volume for each segment\n            local_val = np.ones((self._num_of_regular_regressors, self._num_knots_coefficients))\n            if self.flat_multiplier:\n                multiplier = np.ones(local_val.shape)\n            else:\n                multiplier = np.ones(local_val.shape)\n            # store local value for the range on the left side since last knot\n            for idx in range(len(self._knots_idx_coef)):\n                if idx < len(self._knots_idx_coef) - 1:\n                    str_idx = self._knots_idx_coef[idx]\n                    end_idx = self._knots_idx_coef[idx + 1]\n                else:\n                    str_idx = self._knots_idx_coef[idx]\n                    end_idx = self.num_of_observations\n\n                local_val[:, idx] = np.mean(np.fabs(self._regular_regressor_matrix[str_idx:end_idx]), axis=0)\n\n            # adjust knot scale with the multiplier derive by the average value and shift by 0.001 to avoid zeros in\n            # scale parameters\n            global_med = np.expand_dims(np.median(np.fabs(self._regular_regressor_matrix), axis=0), -1)\n            test_flag = local_val < 0.01 * global_med\n            multiplier[test_flag] = DEFAULT_LOWER_BOUND_SCALE_MULTIPLIER\n            # replace entire row of nan (when 0.1 * global_med is equal to global_min) with upper bound\n            multiplier[np.isnan(multiplier).all(axis=-1)] = 1.0\n\n            # also note that after the following step,\n            # _regular_regressor_knot_scale is a 2D array unlike _regular_regressor_knot_scale\n            # geometric drift i.e. 0.1 = 10% up-down in 1 s.d. prob.\n            # self._regular_regressor_knot_scale has shape num_of_pr x num_of_knot\n            self._regular_regressor_knot_scale = (\n                    multiplier * np.expand_dims(self._regular_regressor_knot_scale, -1)\n            )\n            # keep a lower bound of scale parameters\n            self._regular_regressor_knot_scale[self._regular_regressor_knot_scale < 1e-4] = 1e-4\n            # TODO: we change the type here, maybe we should change it earlier?\n            self._regular_regressor_init_knot_scale = np.array(self._regular_regressor_init_knot_scale)\n            self._regular_regressor_init_knot_scale[self._regular_regressor_init_knot_scale < 1e-4] = 1e-4\n\n    def _generate_tp(self, prediction_date_array):\n        \"\"\"Used in _generate_coefs\"\"\"\n        prediction_start = prediction_date_array[0]\n        output_len = len(prediction_date_array)\n        if prediction_start > self.training_end:\n            start = self.num_of_observations\n        else:\n            start = pd.Index(self.date_array).get_loc(prediction_start)\n\n        new_tp = np.arange(start + 1, start + output_len + 1) \/ self.num_of_observations\n        return new_tp\n\n    def _generate_insample_tp(self, date_array):\n        \"\"\"Used in _generate_coefs\"\"\"\n        idx = np.nonzero(np.in1d(self.date_array, date_array))[0]\n        tp = (idx + 1) \/ self.num_of_observations\n        return tp\n\n    def _generate_coefs(self, prediction_date_array, coef_knot_dates, coef_knot):\n        \"\"\"Used in _generate_seas\"\"\"\n        new_tp = self._generate_tp(prediction_date_array)\n        knots_tp_coef = self._generate_insample_tp(coef_knot_dates)\n        kernel_coef = sandwich_kernel(new_tp, knots_tp_coef)\n        coefs = np.squeeze(np.matmul(coef_knot, kernel_coef.transpose(1, 0)), axis=0).transpose(1, 0)\n        return coefs\n\n    def _generate_seas(self, df, coef_knot_dates, coef_knot, seasonality, seasonality_fs_order):\n        \"\"\"To calculate the seasonality term based on the _seasonal_knots_input.\n\n        :param df: input df\n        :param coef_knot_dates: dates for coef knots\n        :param coef_knot: knot values for coef\n        :param seasonality: seasonality input\n        :param seasonality_fs_order: seasonality_fs_order input\n        :return:\n        \"\"\"\n        prediction_date_array = df[self.date_col].values\n        prediction_start = prediction_date_array[0]\n\n        df = df.copy()\n        if prediction_start > self.training_end:\n            forecast_dates = set(prediction_date_array)\n            n_forecast_steps = len(forecast_dates)\n            # time index for prediction start\n            start = self.num_of_observations\n        else:\n            # compute how many steps to forecast\n            forecast_dates = set(prediction_date_array) - set(self.date_array)\n            # check if prediction df is a subset of training df\n            # e.g. \"negative\" forecast steps\n            n_forecast_steps = len(forecast_dates) or \\\n                               - (len(set(self.date_array) - set(prediction_date_array)))\n            # time index for prediction start\n            start = pd.Index(self.date_array).get_loc(prediction_start)\n\n        fs_cols = []\n        for idx, s in enumerate(seasonality):\n            order = seasonality_fs_order[idx]\n            df, fs_cols_temp = make_fourier_series_df(df, s, order=order, prefix='seas{}_'.format(s), shift=start)\n            fs_cols += fs_cols_temp\n\n        sea_regressor_matrix = df.filter(items=fs_cols).values\n        sea_coefs = self._generate_coefs(prediction_date_array, coef_knot_dates, coef_knot)\n        seas = np.sum(sea_coefs * sea_regressor_matrix, axis=-1)\n\n        return seas\n\n    def _set_levs_and_seas(self, df):\n        tp = np.arange(1, self.num_of_observations + 1) \/ self.num_of_observations\n        # trim level knots dates when they are beyond training dates\n        lev_knot_dates = list()\n        lev_knots = list()\n        # TODO: any faster way instead of a simple loop?\n        for i, x in enumerate(self.level_knot_dates):\n            if (x <= df[self.date_col].max()) and (x >= df[self.date_col].min()):\n                lev_knot_dates.append(x)\n                lev_knots.append(self.level_knots[i])\n        self._level_knot_dates = pd.to_datetime(lev_knot_dates)\n        self._level_knots = np.array(lev_knots)\n        infer_freq = pd.infer_freq(df[self.date_col])[0]\n        start_date = self.training_start\n\n        if len(self.level_knots) > 0 and len(self.level_knot_dates) > 0:\n            self.knots_tp_level = np.array(\n                (self._get_gap_between_dates(start_date, self._level_knot_dates, infer_freq) + 1) \/\n                (self._get_gap_between_dates(start_date, self.training_end, infer_freq) + 1)\n            )\n        else:\n            raise ModelException(\"User need to supply a list of level knots.\")\n\n        kernel_level = sandwich_kernel(tp, self.knots_tp_level)\n        self._kernel_level = kernel_level\n        self._num_knots_level = len(self._level_knot_dates)\n\n        if self._seasonal_knots_input is not None:\n            self._seas_term = self._generate_seas(\n                df,\n                self._seasonal_knots_input['_seas_coef_knot_dates'],\n                self._seasonal_knots_input['_sea_coef_knot'],\n                # self._seasonal_knots_input['_sea_rho'],\n                self._seasonal_knots_input['_seasonality'],\n                self._seasonal_knots_input['_seasonality_fs_order'])\n\n    def _filter_coef_prior(self, df):\n        if self._coef_prior_list and len(self._regressor_col) > 0:\n            # iterate over a copy due to the removal operation\n            for test_dict in self._coef_prior_list[:]:\n                prior_regressor_col = test_dict['prior_regressor_col']\n                m = test_dict['prior_mean']\n                sd = test_dict['prior_sd']\n                end_tp_idx = min(test_dict['prior_end_tp_idx'], df.shape[0])\n                start_tp_idx = min(test_dict['prior_start_tp_idx'], df.shape[0])\n                if start_tp_idx < end_tp_idx:\n                    expected_shape = (end_tp_idx - start_tp_idx, len(prior_regressor_col))\n                    test_dict.update({'prior_end_tp_idx': end_tp_idx})\n                    test_dict.update({'prior_start_tp_idx': start_tp_idx})\n                    # mean\/sd expanding\n                    test_dict.update({'prior_mean': np.full(expected_shape, m)})\n                    test_dict.update({'prior_sd': np.full(expected_shape, sd)})\n                else:\n                    # removing invalid prior\n                    self._coef_prior_list.remove(test_dict)\n\n    def _set_dynamic_attributes(self, df):\n        \"\"\"Overriding: func: `~orbit.models.BaseETS._set_dynamic_attributes\"\"\"\n        self._set_valid_response_attributes()\n        self._set_regressor_matrix(df)\n        self._set_coefficients_kernel_matrix(df)\n        self._set_knots_scale_matrix()\n        self._set_levs_and_seas(df)\n        self._filter_coef_prior(df)\n\n    @staticmethod\n    def _concat_regression_coefs(pr_beta=None, rr_beta=None):\n        \"\"\"Concatenates regression posterior matrix\n\n        In the case that `pr_beta` or `rr_beta` is a 1d tensor, transform to 2d tensor and\n        concatenate.\n\n        Args\n        ----\n        pr_beta : array like\n            postive-value constrainted regression betas\n        rr_beta : array like\n            regular regression betas\n\n        Returns\n        -------\n        array like\n            concatenated 2d array of shape (1, len(rr_beta) + len(pr_beta))\n\n        \"\"\"\n        regressor_beta = None\n        if pr_beta is not None and rr_beta is not None:\n            pr_beta = pr_beta if len(pr_beta.shape) == 2 else pr_beta.reshape(1, -1)\n            rr_beta = rr_beta if len(rr_beta.shape) == 2 else rr_beta.reshape(1, -1)\n            regressor_beta = torch.cat((rr_beta, pr_beta), dim=1)\n        elif pr_beta is not None:\n            regressor_beta = pr_beta\n        elif rr_beta is not None:\n            regressor_beta = rr_beta\n\n        return regressor_beta\n\n    def _predict(self, posterior_estimates, df, include_error=False, decompose=False, store_prediction_array=False,\n                 coefficient_method=\"smooth\",\n                 **kwargs):\n        \"\"\"Vectorized version of prediction math\n\n        Args\n        ----\n        coefficient_method: str\n            either \"smooth\" or \"empirical\". when \"empirical\" is used, curves are sampled\/aggregated directly\n            from beta posteriors; when \"smooth\" is used, first extract sampled\/aggregated posteriors of knots\n            then beta.\n            this mainly impacts the aggregated estimation method; full bayesian should not be impacted\n        \"\"\"\n\n        # remove reference from original input\n        df = df.copy()\n        prediction_df_meta = self.get_prediction_df_meta(df)\n\n        ################################################################\n        # Model Attributes\n        ################################################################\n\n        model = deepcopy(posterior_estimates)\n        arbitrary_posterior_value = list(model.values())[0]\n        num_sample = arbitrary_posterior_value.shape[0]\n\n        ################################################################\n        # Prediction Attributes\n        ################################################################\n        output_len = prediction_df_meta['df_length']\n        prediction_start = prediction_df_meta['prediction_start']\n\n        # Here assume dates are ordered and consecutive\n        # if prediction_df_meta['prediction_start'] > self.training_end,\n        # assume prediction starts right after train end\n        if prediction_start > self.training_end:\n            # time index for prediction start\n            start = self.num_of_observations\n        else:\n            start = pd.Index(self.date_array).get_loc(prediction_start)\n\n        new_tp = np.arange(start + 1, start + output_len + 1) \/ self.num_of_observations\n        if include_error:\n            # in-sample knots\n            lev_knot_in = model.get(constants.BaseSamplingParameters.LEVEL_KNOT.value)\n            # TODO: hacky way; let's just assume last two knot distance is knots distance for all knots\n            lev_knot_width = self.knots_tp_level[-1] - self.knots_tp_level[-2]\n            # check whether we need to put new knots for simulation\n            if new_tp[-1] >= self.knots_tp_level[-1] + lev_knot_width:\n                # derive knots tp\n                knots_tp_level_out = np.arange(self.knots_tp_level[-1] + lev_knot_width, new_tp[-1], lev_knot_width)\n                new_knots_tp_level = np.concatenate([self.knots_tp_level, knots_tp_level_out])\n                lev_knot_out = np.random.laplace(0, self.level_knot_scale,\n                                                 size=(lev_knot_in.shape[0], len(knots_tp_level_out)))\n                lev_knot_out = np.cumsum(np.concatenate([lev_knot_in[:, -1].reshape(-1, 1), lev_knot_out],\n                                                        axis=1), axis=1)[:, 1:]\n                lev_knot = np.concatenate([lev_knot_in, lev_knot_out], axis=1)\n            else:\n                new_knots_tp_level = self.knots_tp_level\n                lev_knot = lev_knot_in\n            kernel_level = sandwich_kernel(new_tp, new_knots_tp_level)\n        else:\n            lev_knot = model.get(constants.BaseSamplingParameters.LEVEL_KNOT.value)\n            kernel_level = sandwich_kernel(new_tp, self.knots_tp_level)\n        obs_scale = model.get(constants.BaseSamplingParameters.OBS_SCALE.value)\n        obs_scale = obs_scale.reshape(-1, 1)\n\n        if self._seasonal_knots_input is not None:\n            seas = self._generate_seas(df,\n                                       self._seasonal_knots_input['_seas_coef_knot_dates'],\n                                       self._seasonal_knots_input['_sea_coef_knot'],\n                                       # self._seasonal_knots_input['_sea_rho'],\n                                       self._seasonal_knots_input['_seasonality'],\n                                       self._seasonal_knots_input['_seasonality_fs_order'])\n            # seas is 1-d array, add the batch size back\n            seas = np.expand_dims(seas, 0)\n        else:\n            # follow component shapes\n            seas = np.zeros((1, output_len))\n\n        trend = np.matmul(lev_knot, kernel_level.transpose((1, 0)))\n        regression = np.zeros(trend.shape)\n        if self._num_of_regressors > 0:\n            regressor_matrix = df.filter(items=self._regressor_col,).values\n            regressor_betas = self._get_regression_coefs_matrix(\n                model, coefficient_method, prediction_df_meta['date_array']\n            )\n            regression = np.sum(regressor_betas * regressor_matrix, axis=-1)\n\n        if include_error:\n            epsilon = nct.rvs(self.degree_of_freedom, nc=0, loc=0,\n                              scale=obs_scale, size=(num_sample, len(new_tp)))\n            pred_array = trend + seas + regression + epsilon\n        else:\n            pred_array = trend + seas + regression\n\n        # if decompose output dictionary of components\n        if decompose:\n            decomp_dict = {\n                'prediction': pred_array,\n                'trend': trend,\n                'seasonality_input': seas,\n                'regression': regression\n            }\n        else:\n            decomp_dict = {'prediction': pred_array}\n\n        if store_prediction_array:\n            self.pred_array = pred_array\n        else:\n            self.pred_array = None\n\n        return decomp_dict\n\n    def _get_regression_coefs_matrix(self, model, coefficient_method='smooth', date_array=None):\n        \"\"\"internal function to provide coefficient matrix given a date array\n\n        Args\n        ----\n        model: dict\n            posterior samples\n        date_array: array like\n            array of date stamp\n        coefficient_method: str\n            either \"empirical\" or \"smooth\"; when \"empirical\" is used; curve are sampled\/aggregated directly from\n            coefficients posteriors whereas when \"smooth\" is used we first extract sampled\/aggregated posteriors of knot\n            and extract coefficients this mainly impact the aggregated estimation method; full bayesian should not be\n            impacted\n        \"\"\"\n        if self._num_of_regular_regressors + self._num_of_positive_regressors == 0:\n            return None\n\n        if date_array is None:\n            if coefficient_method == 'smooth':\n                # if date_array not specified, dynamic coefficients in the training perior will be retrieved\n                coef_knots = model.get(constants.RegressionSamplingParameters.COEFFICIENTS_KNOT.value)\n                regressor_betas = np.matmul(coef_knots, self._kernel_coefficients.transpose((1, 0)))\n                # back to batch x time step x regressor columns shape\n                regressor_betas = regressor_betas.transpose((0, 2, 1))\n            elif coefficient_method == 'empirical':\n                regressor_betas = model.get(constants.RegressionSamplingParameters.COEFFICIENTS.value)\n            else:\n                raise IllegalArgument('Wrong coefficient_method:{}'.format(coefficient_method))\n        else:\n            date_array = pd.to_datetime(date_array).values\n            output_len = len(date_array)\n            train_len = self.num_of_observations\n            # some validation of date array\n            if not is_ordered_datetime(date_array):\n                raise IllegalArgument('Datetime index must be ordered and not repeat')\n            prediction_start = date_array[0]\n\n            if prediction_start < self.training_start:\n                raise PredictionException('Prediction start must be after training start.')\n\n            # If we cannot find a match of prediction range, assume prediction starts right after train end\n            if prediction_start > self.training_end:\n                # time index for prediction start\n                start = train_len\n                coef_repeats = [0] * (start - 1) + [output_len]\n            else:\n                # time index for prediction start\n                start = pd.Index(self.date_array).get_loc(prediction_start)\n                if output_len <= train_len - start:\n                    coef_repeats = [0] * start + [1] * output_len + [0] * (train_len - start - output_len)\n                else:\n                    coef_repeats = [0] * start + [1] * (train_len - start - 1) + [output_len - train_len + start + 1]\n            new_tp = np.arange(start + 1, start + output_len + 1) \/ self.num_of_observations\n\n            if coefficient_method == 'smooth':\n                kernel_coefficients = gauss_kernel(new_tp, self._knots_tp_coefficients, rho=self.rho_coefficients)\n                # kernel_coefficients = parabolic_kernel(new_tp, self._knots_tp_coefficients)\n                coef_knots = model.get(constants.RegressionSamplingParameters.COEFFICIENTS_KNOT.value)\n                regressor_betas = np.matmul(coef_knots, kernel_coefficients.transpose((1, 0)))\n                regressor_betas = regressor_betas.transpose((0, 2, 1))\n            elif coefficient_method == 'empirical':\n                regressor_betas = model.get(constants.RegressionSamplingParameters.COEFFICIENTS.value)\n                regressor_betas = np.repeat(regressor_betas, repeats=coef_repeats, axis=1)\n            else:\n                raise IllegalArgument('Wrong coefficient_method:{}'.format(coefficient_method))\n\n        return regressor_betas\n\n    def _get_regression_coefs(self, aggregate_method, coefficient_method='smooth', date_array=None,\n                              include_ci=False, lower=0.05, upper=0.95):\n        \"\"\"Return DataFrame regression coefficients\n        \"\"\"\n        posteriors = self._aggregate_posteriors.get(aggregate_method)\n        coefs = np.squeeze(self._get_regression_coefs_matrix(posteriors,\n                                                             coefficient_method=coefficient_method,\n                                                             date_array=date_array))\n        if len(coefs.shape) == 1:\n            coefs = coefs.reshape((1, -1))\n        reg_df = pd.DataFrame(data=coefs, columns=self._regressor_col)\n        if date_array is not None:\n            reg_df[self.date_col] = date_array\n        else:\n            reg_df[self.date_col] = self.date_array\n\n        # re-arrange columns\n        reg_df = reg_df[[self.date_col] + self._regressor_col]\n        if include_ci:\n            posteriors = self._posterior_samples\n            coefs = self._get_regression_coefs_matrix(posteriors, coefficient_method=coefficient_method)\n\n            coefficients_lower = np.quantile(coefs, lower, axis=0)\n            coefficients_upper = np.quantile(coefs, upper, axis=0)\n\n            reg_df_lower = reg_df.copy()\n            reg_df_upper = reg_df.copy()\n            for idx, col in enumerate(self._regressor_col):\n                reg_df_lower[col] = coefficients_lower[:, idx]\n                reg_df_upper[col] = coefficients_upper[:, idx]\n            return reg_df, reg_df_lower, reg_df_upper\n\n        return reg_df\n\n    def _get_regression_coef_knots(self, aggregate_method):\n        \"\"\"Return DataFrame regression coefficient knots\n        \"\"\"\n        # init dataframe\n        knots_df = pd.DataFrame()\n        # end if no regressors\n        if self._num_of_regular_regressors + self._num_of_positive_regressors == 0:\n            return knots_df\n\n        knots_df[self.date_col] = self._coefficients_knot_dates\n        # TODO: make the label as a constant\n        knots_df['step'] = self._knots_idx_coef\n        coef_knots = self._aggregate_posteriors \\\n            .get(aggregate_method) \\\n            .get(constants.RegressionSamplingParameters.COEFFICIENTS_KNOT.value)\n\n        for idx, col in enumerate(self._regressor_col):\n            knots_df[col] = np.transpose(coef_knots[:, idx])\n\n        return knots_df\n\n    @staticmethod\n    def _plot_regression_coefs(coef_df, knot_df=None, coef_df_lower=None, coef_df_upper=None,\n                               ncol=2, figsize=None, ylim=None, markersize=200):\n        \"\"\"Plot regression coefficients\n        \"\"\"\n        # assume your first column is the date; this way can use a static method\n        regressor_col = coef_df.columns.tolist()[1:]\n        nrow = math.ceil(len(regressor_col) \/ ncol)\n        fig, axes = plt.subplots(nrow, ncol, figsize=figsize, squeeze=False)\n\n        for idx, col in enumerate(regressor_col):\n            row_idx = idx \/\/ ncol\n            col_idx = idx % ncol\n            coef = coef_df[col]\n            axes[row_idx, col_idx].plot(coef, alpha=.8, label='coefficients')\n            if coef_df_lower is not None and coef_df_upper is not None:\n                coef_lower = coef_df_lower[col]\n                coef_upper = coef_df_upper[col]\n                axes[row_idx, col_idx].fill_between(np.arange(0, coef_df.shape[0]), coef_lower, coef_upper, alpha=.3)\n            if knot_df is not None:\n                step = knot_df['step']\n                knots = knot_df[col].values\n                axes[row_idx, col_idx].scatter(x=step, y=knots, marker='^', s=markersize, color='green', alpha=0.5)\n            if ylim is not None:\n                axes[row_idx, col_idx].set_ylim(ylim)\n            axes[row_idx, col_idx].set_title('{}'.format(col))\n            axes[row_idx, col_idx].ticklabel_format(useOffset=False)\n\n        plt.tight_layout()\n        return axes\n\n\nclass KTRXFull(FullBayesianTemplate, BaseKTRX):\n    \"\"\"Concrete KTRX model for full Bayesian prediction\"\"\"\n    _supported_estimator_types = [PyroEstimatorVI]\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n    def get_regression_coefs(self, aggregate_method='median',\n                             coefficient_method='smooth',\n                             date_array=None,\n                             include_ci=False, lower=0.05, upper=0.95):\n        self._set_aggregate_posteriors()\n        return self._get_regression_coefs(aggregate_method=aggregate_method,\n                                          coefficient_method=coefficient_method,\n                                          date_array=date_array,\n                                          include_ci=include_ci,\n                                          lower=lower, upper=upper)\n\n    def get_regression_coef_knots(self, aggregate_method='median'):\n        self._set_aggregate_posteriors()\n        return self._get_regression_coef_knots(aggregate_method=aggregate_method)\n\n    def plot_regression_coefs(self, with_knot=False, aggregate_method='median', include_ci=False, **kwargs):\n        if with_knot:\n            knot_df = self.get_regression_coef_knots(aggregate_method=aggregate_method)\n        else:\n            knot_df = None\n        if include_ci:\n            coef_df, coef_df_lower, coef_df_upper = self.get_regression_coefs(\n                aggregate_method=aggregate_method,\n                include_ci=True\n            )\n        else:\n            coef_df = self.get_regression_coefs(aggregate_method=aggregate_method,\n                                                include_ci=False)\n            coef_df_lower = None\n            coef_df_upper = None\n        return self._plot_regression_coefs(coef_df=coef_df,\n                                           knot_df=knot_df,\n                                           coef_df_lower=coef_df_lower,\n                                           coef_df_upper=coef_df_upper,\n                                           **kwargs)\n\n\nclass KTRXAggregated(AggregatedPosteriorTemplate, BaseKTRX):\n    \"\"\"Concrete KTRX model for aggregated Bayesian prediction\"\"\"\n    _supported_estimator_types = [PyroEstimatorVI]\n\n    def __init__(self, **kwargs):\n        super().__init__(**kwargs)\n\n    def get_regression_coefs(self, coefficient_method='smooth', date_array=None):\n        return self._get_regression_coefs(aggregate_method=self.aggregate_method,\n                                          coefficient_method=coefficient_method,\n                                          date_array=date_array,\n                                          include_ci=False)\n\n    def get_regression_coef_knots(self):\n        return self._get_regression_coef_knots(aggregate_method=self.aggregate_method)\n\n    def plot_regression_coefs(self, with_knot=False, coefficient_method='smooth', **kwargs):\n        coef_df = self._get_regression_coefs(aggregate_method=self.aggregate_method,\n                                             coefficient_method=coefficient_method,\n                                             include_ci=False)\n        if with_knot:\n            knot_df = self.get_regression_coef_knots()\n        else:\n            knot_df = None\n        return self._plot_regression_coefs(coef_df=coef_df, knot_df=knot_df, **kwargs)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_146","text":"<filename>NeuroMechFly\/utils\/plotting.py\n\"\"\" Script to plot the simulation results. \"\"\"\n\nimport os\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport scipy.stats\nimport scipy.signal\nimport scipy.ndimage\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as mpatches\nfrom matplotlib.lines import Line2D\nfrom matplotlib.markers import MarkerStyle\nfrom typing import List\n\nfrom .sensitivity_analysis import calculate_forces\nfrom scipy.interpolate import pchip_interpolate\n\n\ndef plot_mu_sem(\n    mu,\n    error,\n    conf=None,\n    plot_label='Mean',\n    x=None,\n    alpha=0.3,\n    color=None,\n    ax=None,\n    beg=0,\n    time_step=0.001,\n    end=100,\n):\n    \"\"\" Plots mean, confidence interval, and standard deviation (Author: JB)\n\n    Parameters\n    ----------\n    mu: <np.array>\n        Mean, shape [N_samples, N_lines] or [N_samples].\n    error: <np.array>\n        Error to be plotted, e.g. standard error of the mean, shape [N_samples, N_lines] or [N_samples].\n    conf: <int>\n        Confidence interval, if none, stderror is plotted instead of std.\n    plot_label: <str>\n        The label for each line either a string if only one line or list of strings if multiple lines.\n    x: <np.array>\n        shape [N_samples]. If not specified will be np.arange(mu.shape[0]).\n    alpha: <float>\n        Transparency of the shaded area. default 0.3.\n    color:\n        Pre-specify colour. if None, use Python default colour cycle.\n    ax:\n        axis to be plotted on, otherwise the current is axis with plt.gca().\n    \"\"\"\n    if ax is None:\n        ax = plt.gca()\n    if x is None:\n        x = np.arange(0, mu.shape[0], 1) * time_step\n    p = ax.plot(x[beg:end], mu[beg:end], lw=1, color=color, label=plot_label)\n    if len(mu.shape) == 1:\n        if conf is not None:\n            ax.plot(x[beg:end],\n                    mu[beg:end] - conf * error[beg:end],\n                    alpha=alpha,\n                    linewidth=1.5,\n                    linestyle=':',\n                    color='black',\n                    label=\"Confidence Interval {}%\".format(conf))\n            ax.plot(x[beg:end], mu[beg:end] + conf * error[beg:end],\n                    alpha=alpha, linewidth=1.5, linestyle=':', color='black')\n        ax.fill_between(x[beg:end],\n                        mu[beg:end] - error[beg:end],\n                        mu[beg:end] + error[beg:end],\n                        alpha=alpha,\n                        color=p[0].get_color())\n    else:\n        for i in np.arange(mu.shape[1]):\n            if conf is not None:\n                ax.plot(x[beg:end],\n                        mu[beg:end,\n                           i] - conf * error[beg:end,\n                                             i],\n                        alpha=alpha,\n                        linewidth=1.5,\n                        linestyle=':',\n                        color='black',\n                        label=\"Confidence Interval {}%\".format(conf))\n                ax.plot(x[beg:end], mu[beg:end, i] + conf * error[beg:end, i],\n                        alpha=alpha, linewidth=1.5, linestyle=':', color='black')\n            ax.fill_between(x[beg:end], mu[beg:end, i] -\n                            error[beg:end, i], mu[beg:end, i] +\n                            error[beg:end, i], alpha=alpha, color=p[i].get_color())\n\n\ndef plot_kp_joint(\n    *args,\n    show_vector=False,\n    calc_force=False,\n    full_name='joint_LMTibia',\n    gain_range=np.arange(0.1, 1.1, 0.2),\n    scaling_factor=1,\n    ax=None,\n    constant='kv0.9',\n    condition='kp0.4_kv0.9',\n    beg=2000,\n    intv=250,\n    time_step=0.001,\n    ground_truth=None\n):\n    \"\"\"Plot the joint info of one specific leg versus independent variable.\n\n    Parameters\n    ----------\n    *args: <np.array>\n        Force to be plotted, i.e. grf, lateral friction, thorax.\n    multiple: <bool>\n        Plots vectors instead of norm.\n    data: <dictionary>\n        Dictionary to be plotted, i.e. joint torques.\n    full_name: <str>\n        Key name, e.g., 'joint_LMTibia'.\n    gain_range: <np.array>\n        Range of gains to be plotted, i.e. np.arange(0.1,1.4,0.2).\n    scaling_factor: <int>\n        Scale to change the units.\n    ax:\n        Axis to be plotted on, otherwise the current is axis with plt.gca().\n    beg: <int>\n        Beginning of the data to be plotted. the entire data is long.\n    intv: <int>\n        Int of the data to be plotted.\n    ground_truth: <np.array>\n        Ground truth for position or velocity.\n    \"\"\"\n    if ax is None:\n        ax = plt.gca()\n    if ground_truth is not None:\n        ax.plot(np.array(ground_truth[beg:beg + intv]) * scaling_factor,\n                linewidth=2.5, color=\"red\", label=\"Ground Truth\")\n\n    for k in gain_range:\n        k_value = \"_\".join((constant, 'kv' +\n                            str(round(k, 1)))) if 'kp' in constant else \"_\".join(('kp' +\n                                                                                  str(round(k, 1)), constant))\n\n        color = plt.cm.winter(np.linalg.norm(k))\n        if condition == k_value:\n            color = 'red'\n\n        if not calc_force:\n            time = np.arange(\n                0, len(\n                    args[0][k_value][full_name]), 1) * time_step\n            ax.plot(time[beg: beg +\n                         intv], np.array(args[0][k_value][full_name][beg:beg +\n                                                                     intv]) *\n                    scaling_factor, color=color, label=k_value)\n            ax.legend(bbox_to_anchor=(1.1, 1), loc='upper right')\n\n        else:\n            vector, norm = calculate_forces(full_name, k_value, *args)\n            if show_vector:\n                for i, axis in enumerate(['x', 'y', 'z']):\n                    time = np.arange(0, len(vector), 1) * time_step\n                    ax[i].plot(time[beg: beg +\n                                    intv], np.array(vector[i, beg:beg +\n                                                           intv]) *\n                               scaling_factor, color=color, label=k_value)\n                    ax[i].set_ylabel(axis)\n                ax.legend(bbox_to_anchor=(1.1, 0.), loc='upper right')\n            else:\n                time = np.arange(0, len(norm), 1) * time_step\n                ax.plot(time[beg: beg + intv], norm[beg:beg + intv]\n                        * scaling_factor, color=color, label=k_value)\n                ax.legend(bbox_to_anchor=(1.1, 1), loc='upper right')\n\n\ndef heatmap_plot(\n        title,\n        joint_data,\n        colorbar_title,\n        annot=True,\n        precision=\"g\",\n        linewidth=\"0.005\",\n        ax=None,\n        cmap='magma',\n        annot_size = 10,\n        xticklabels=[],\n        yticklabels=[]):\n    \"\"\" Plots a heatmap plot for global sensitivity analysis.\n\n    Parameters\n    ----------\n    title: <str>\n        Title of the heatmap.\n    joint_data: <dict>\n        Dictionary containing the joint information (angle etc).\n    colorbar_title: <str>\n        Title of the colorbar.\n    precision: <str>\n        Precision of the heatmap entries.\n    linewidth: <str>\n        Width of the lines in heatmap.\n    ax:\n        Axis to be plotted on, otherwise plt.gca().\n    cmap: <str>\n        Color map of the heatmap.\n    \"\"\"\n    if ax is None:\n        ax = plt.gca()\n\n    if xticklabels:\n        x_tick = xticklabels\n    else:\n        x_tick = 'auto'\n\n    if yticklabels:\n        y_tick = yticklabels\n    else:\n        y_tick = 'auto'\n\n    ax = sns.heatmap(\n        joint_data,\n        annot=annot,\n        ax=ax,\n        linewidth=linewidth,\n        cmap=cmap,\n        vmin=np.nanmin(joint_data),\n        vmax=np.nanmax(joint_data),\n        fmt=precision,\n        xticklabels=x_tick,\n        yticklabels=y_tick,\n        annot_kws={\"size\": annot_size},\n        cbar_kws={\n            'label': colorbar_title})\n    ax.set_title(title)\n    ax.invert_yaxis()\n    #plt.show()\n\n\ndef plot_pareto_gens(\n    parent_dir,\n    generations,\n    inds_to_annotate,\n    export_path=None\n):\n    \"\"\" Plots multiple generations with selected individuals.\n    Parameters\n    ----------\n    parent_dir : <str>\n        Directory where the FUN and VAR files are located.\n    generations : <np.darray>\n        Generations to be plotted.\n    inds_to_annotate : <dict>\n        A dictionary with keys 'gen<number>' and values int or string ('fastest' etc.) format\n    export_path: <str>\n        Path at which the plot will be saved.\n\n    Example usage:\n        plot_pareto_gens(\n        parent_dir='\/home\/NeuroMechFly\/scripts\/neuromuscular_optimization\/optimization_results\/run_Drosophila_var_63_obj_2_pop_200_gen_100_211022_134952',\n        generations=np.arange(15,100,14),\n        inds_to_annotate = {\n            'gen15': [0,3,5],\n            'gen29': 12,\n            'gen57': 14,\n            'gen85': 48\n        },\n        export_path='.\/pareto.png'\n        )\n\n        OR\n\n        plot_pareto_gens(\n        parent_dir='\/home\/NeuroMechFly\/scripts\/neuromuscular_optimization\/optimization_results\/run_Drosophila_var_63_obj_2_pop_200_gen_100_211022_134952',\n        generations=99,\n        inds_to_annotate = {\n            'gen99': ['fastest', 'win_win', 'most_stable']\n        },\n        export_path='.\/pareto.png'\n        )\n\n    \"\"\"\n    from NeuroMechFly.experiments.network_optimization.neuromuscular_control import DrosophilaSimulation as ds\n    # import directly from collections for Python < 3.3\n    from collections.abc import Iterable\n\n    rc_params = {\n        'axes.spines.right': False,\n        'axes.spines.top': False,\n    }\n    plt.rcParams.update(rc_params)\n    colors = (\n        '#808080',\n        '#B4479A',\n        '#3953A4',\n        '#027545',\n        '#FE420F',\n        '#650021',\n        '#E6DAA6',\n        '#008080',\n        '#FFC0CB')\n\n    if not isinstance(generations, Iterable):\n        generations = [generations]\n\n    fig, ax = plt.subplots(figsize=(7, 4))\n\n    for i, gen in enumerate(generations):\n        fun_path = os.path.join(parent_dir, f'FUN.{gen}')\n        var_path = os.path.join(parent_dir, f'VAR.{gen}')\n        fun, var = np.loadtxt(fun_path), np.loadtxt(var_path)\n\n        ax.scatter(fun[:, 0], fun[:, 1], c=colors[i % len(colors)], alpha=0.3, s=30, label=f'Gen {gen+1}')\n        if 'gen' + str(gen) in inds_to_annotate:\n            if not isinstance(inds_to_annotate['gen' + str(gen)], Iterable):\n                individuals = [inds_to_annotate['gen' + str(gen)]]\n            else:\n                individuals = inds_to_annotate['gen' + str(gen)]\n\n            for j, ind_ in enumerate(individuals):\n                ind_number = ds.select_solution(ind_, fun)\n                if len(generations) > 1:\n                    ax.scatter(fun[ind_number, 0], fun[ind_number, 1],\n                               s=95, c=colors[i % len(colors)], edgecolor='black')\n                else:\n                    cycle = ('#B4479A', '#3953A4', '#027545')\n                    ax.scatter(fun[ind_number, 0], fun[ind_number, 1], label=f'Sol {ind_}', s=60, edgecolor='black', c=cycle[j])\n\n    ax.set_xlabel('Distance')\n    ax.set_ylabel('Stability')\n    ax.legend()\n    if export_path is not None:\n        fig.savefig(export_path, bbox_inches='tight')\n    plt.show()\n\n\ndef plot_population_statistics(\n    result_directory,\n    pop_no,\n    generations,\n    penalty_number,\n    penalty_name,\n    export_path=None\n):\n    \"\"\" Plots the population statistics (i.e. penalties across generations)\n\n    Parameters\n    ----------\n    result_directory : str\n        Directory where the PENALTIES.<gen> are.\n    pop_no : int\n        Number of individual in a population.\n    generations : list\n        Generations to be analyzed.\n        e.g.: np.arange(15,100,14)\n    penalty_number : int\n        Column number of the penalty based on the log file.\n    penalty_name : str\n        Name of the penalty\n    export_path: <str>\n        Path at which the plot will be saved if not None\n    \"\"\"\n    rc_params = {\n        'axes.spines.right': False,\n        'axes.spines.top': False,\n    }\n    plt.rcParams.update(rc_params)\n\n    fig, ax = plt.subplots(figsize=(4, 6))\n    penalty = np.zeros((pop_no, len(generations)))\n\n    for i, generation in enumerate(generations):\n        penalty[:, i] = np.loadtxt(\n            os.path.join(\n                result_directory, f'PENALTIES.{generation}'\n            )\n        )[:, penalty_number]\n\n    cols = [f'{gen + 1}' for gen in generations]\n    rows = [f'Ind {ind}' for ind in range(pop_no)]\n\n    penalty_df = pd.DataFrame(penalty, columns=cols, index=rows)\n    sns.stripplot(\n        data=penalty_df,\n        size=5,\n        color='red',\n        edgecolor='black',\n        alpha=0.3,\n        ax=ax)\n    sns.violinplot(\n        data=penalty_df,\n        scale='count',\n        color='white',\n        edgecolor='black',\n        bw=0.35,\n        ax=ax,\n        cut=0,\n        showfliers=False,\n        showextrema=False)\n\n    ax.set_xlabel('Generations')\n    ax.set_title(penalty_name)\n\n    if export_path is not None:\n        fig.savefig(export_path, bbox_inches='tight')\n    plt.show()\n\n\ndef plot_gait_diagram(data, ts=1e-4, ax=None, export_path=None):\n    \"\"\" Plot the contacts from the given contact_flag data.\n\n    Parameters\n    ----------\n    data: <pandas.DataFrame>\n        Contact flag data.\n    ts: <float>\n        Time step of the simulation.\n    ax:\n        axis to be plotted on, otherwise the current is axis with plt.gca().\n    export_path: <str>\n        Path at which the plot will be saved.\n    \"\"\"\n    # Total time\n    total_time = len(data) * ts\n    # Define the legs and its order for the plot\n    legs = (\"RH\", \"RM\", \"RF\", \"LH\", \"LM\", \"LF\")\n    # Setup the contact data\n    contact_intervals = {}\n    for leg in legs:\n        # Combine contact information of all the tarsus segments\n        values = np.squeeze(np.any(\n            [value for key, value in data.items() if leg in key],\n            axis=0,\n        ).astype(int))\n        intervals = np.where(\n            np.abs(np.diff(values, prepend=[0], append=[0])) == 1\n        )[0].reshape(-1, 2) * ts\n        intervals[:, 1] = intervals[:, 1] - intervals[:, 0]\n        contact_intervals[leg] = intervals\n    # Define the figure\n    if ax is None:\n        fig, ax = plt.subplots(figsize=(7, 3))\n    width = 0.75\n    for index, (key, value) in enumerate(contact_intervals.items()):\n        ax.broken_barh(\n            value, (index - width * 0.5, width), facecolor='k'\n        )\n    ax.set_xlabel(\"Time (s)\")\n    ax.set_yticks((0, 1, 2, 3, 4, 5))\n    ax.set_yticklabels(legs)\n\n    if export_path is not None:\n        plt.savefig(export_path, bbox_inches='tight')\n\n\ndef load_opt_log(results_path):\n    \"\"\" Loads the optimization muscle torques and joint position results.\n    \n    Parameters\n    ----------\n    results_path: str\n        Directory containing the muscle, neural and physics folders.\n\n    Returns\n    ----------\n    (muscle, joint_pos): Tuple\n        Muscle and joint positions both in pandas.DataFrame format.\n    \"\"\"\n    muscle_path = os.path.join(results_path, 'muscle\/outputs.h5')\n    joint_angle_path = os.path.join(results_path, 'physics\/joint_positions.h5')\n    muscle, joint_pos = pd.read_hdf(muscle_path), pd.read_hdf(joint_angle_path)\n    return muscle, joint_pos\n\n\ndef plot_network_activity(\n        results_path,\n        time_step=1e-4,\n        sim_duration=2.0,\n        beg=1,\n        end=1.5,\n        torque_scale=1e9,\n        link='Femur',\n        export_path=None,\n        lw=1.5):\n    \"\"\" Plots the CPG activity, muscle torques and joint angles.\n\n    Parameters\n    ----------\n    results_path: str\n        Directory containing the muscle, neural and physics folders.\n    time_step : float, optional\n        Time step of the simulation, by default 1e-4\n    sim_duration : float, optional\n        Duration of the simulation in seconds, by default 2.0\n    beg : int, optional\n        Beginning from which the data will be plotted, by default 1\n    end : float, optional\n        Beginning at which the data will end, by default 1.5\n    torque_scale : [type], optional\n        Conversion scale from SI units to uNmm, by default 1e9\n    link : str, optional\n        Link to be plotted, by default 'Femur', could be 'Coxa' or 'Tibia' as well.\n    export_path : str, optional\n        If not None then the plot will be saved to that path, by default None\n    \"\"\"\n    from matplotlib.gridspec import GridSpec\n\n    # Load data\n    muscle, joint_pos = load_opt_log(results_path)\n\n    rc_params = {'axes.spines.right': False, 'axes.spines.top': False}\n    plt.rcParams.update(rc_params)\n    cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']\n    linestyles = ('solid', 'dashed', 'dotted')\n\n    equivalence = {'ThC_yaw': 'Coxa_yaw',\n                   'ThC_pitch': 'Coxa',\n                   'ThC_roll': 'Coxa_roll',\n                   'CTr_pitch': 'Femur',\n                   'CTr_roll': 'Femur_roll',\n                   'FTi_pitch': 'Tibia',\n                   'TiTa_pitch': 'Tarsus1'}\n\n    actuated_joints = {\n        'F': ['ThC_pitch', 'CTr_pitch', 'FTi_pitch'],\n        'M': ['ThC_roll', 'CTr_pitch', 'FTi_pitch'],\n        'H': ['ThC_roll', 'CTr_pitch', 'FTi_pitch'],\n\n    }\n    sides = ['Front', 'Middle', 'Hind']\n\n    duration = np.arange(0, sim_duration, time_step)\n    beg = int(beg \/ time_step)\n    end = int(end \/ time_step)\n\n    fig = plt.figure(figsize=(8, 8))\n    gs = plt.GridSpec(4, 3, figure=fig)\n    ax1 = fig.add_subplot(gs[0, :])\n    ax2 = fig.add_subplot(gs[1, :])\n    ax3 = fig.add_subplot(gs[2, :])\n    (ax4, ax5, ax6) = fig.add_subplot(gs[3, 0]), fig.add_subplot(\n        gs[3, 1]), fig.add_subplot(gs[3, 2])\n\n    for i, side in enumerate(sides):\n        part = side[0]\n        if part in ('M', 'H') and link[0] == 'C':\n            link = 'Coxa_roll'\n\n        ax1.plot(duration[beg:end], muscle[f'joint_R{part}{link}_flexor_act'][beg:end], label=f'R{part}', linewidth=lw, color=cycle[i * 2])\n        ax1.plot(duration[beg:end], muscle[f'joint_L{part}{link}_flexor_act'][beg:end], label=f'L{part}', linewidth=lw, color=cycle[i * 2 + 1])\n        ax1.legend(bbox_to_anchor=(1.1, 1))\n        ax1.set_ylabel(f'{link} Flexor (AU)')\n\n        ax2.plot(duration[beg:end], muscle[f'joint_R{part}{link}_torque'][beg:end] * torque_scale, linewidth=lw, color=cycle[i * 2])\n        ax2.plot(duration[beg:end], muscle[f'joint_L{part}{link}_torque'][beg:end] * torque_scale, linewidth=lw, color=cycle[i * 2 + 1])\n        ax2.set_ylabel(f'{link} Torques ($\\mu$Nmm)')\n\n        ax3.plot(duration[beg:end], np.rad2deg(joint_pos[f'joint_R{part}{link}'][beg:end]), linewidth=lw, color=cycle[i * 2])\n        ax3.plot(duration[beg:end], np.rad2deg(joint_pos[f'joint_L{part}{link}'][beg:end]), linewidth=lw, color=cycle[i * 2 + 1])\n        ax3.set_ylabel(f'{link} Joint Angles(deg)')\n        ax3.set_xlabel('Time (s)')\n\n        for j, joint_angle in enumerate(actuated_joints[part]):\n            ls = linestyles[j] if not joint_angle == 'ThC_pitch' else 'dashdot'\n            if part == 'F':\n                ax4.plot(duration[beg:end], np.rad2deg(joint_pos[f'joint_L{part}{equivalence[joint_angle]}'][beg:end]), linewidth=lw, label='LF ' + joint_angle, color=cycle[1], linestyle=ls)\n            elif part == 'M':\n                ax5.plot(duration[beg:end], np.rad2deg(joint_pos[f'joint_L{part}{equivalence[joint_angle]}'][beg:end]), linewidth=lw, label='LM ' + joint_angle, color=cycle[3], linestyle=ls)\n            if part == 'H':\n                ax6.plot(duration[beg:end], np.rad2deg(joint_pos[f'joint_L{part}{equivalence[joint_angle]}'][beg:end]), linewidth=lw, label='LH ' + joint_angle, color=cycle[5], linestyle=ls)\n        ax4.legend(\n            loc='upper center', bbox_to_anchor=(\n                0.5, -0.1), fancybox=True)\n        ax5.legend(\n            loc='upper center', bbox_to_anchor=(\n                0.5, -0.1), fancybox=True)\n        ax6.legend(\n            loc='upper center', bbox_to_anchor=(\n                0.5, -0.1), fancybox=True)\n        ax4.set_ylabel('Joint Angles(deg)')\n\n    plt.tight_layout()\n    if export_path is not None:\n        plt.savefig(export_path, bbox_inches='tight')\n    plt.show()\n\n\ndef read_ground_contacts(path_data):\n    \"\"\" Reads ground contact's data obtained after running a simulation.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n\n    Returns\n    ----------\n    grf: <dict>\n        Ground reaction forces for all segments in all legs.\n    \"\"\"\n    grf_data = os.path.join(path_data, 'physics', 'contact_normal_force.h5')\n    data = pd.read_hdf(grf_data)\n    grf = {}\n    check = []\n    for key, force in data.items():\n        leg, force_axis = key.split('_')\n        if leg not in check and \"-\" not in leg:\n            check.append(leg)\n            components = [k for k in data.keys() if leg in k and \"-\" not in k]\n            data_x = data[components[0]].values\n            data_y = data[components[1]].values\n            data_z = data[components[2]].values\n            res_force = np.linalg.norm([data_x, data_y, data_z], axis=0)\n            if leg[:2] not in grf.keys():\n                grf[leg[:2]] = []\n            grf[leg[:2]].append(res_force)\n\n    return grf\n\n\ndef read_collision_forces(path_data):\n    \"\"\" Reads collision force's data obtained after running a simulation.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n\n    Returns\n    ----------\n    collisions: <dict>\n        Collision forces for all segments in all legs.\n    \"\"\"\n    collisions_data = os.path.join(path_data, 'physics', 'contact_normal_force.h5')\n    data = pd.read_hdf(collisions_data)\n\n    collisions = {}\n    check = []\n    for key in data.keys():\n        body_parts, force_axis = key.split('_')\n        if body_parts not in check and \"-\" in body_parts:\n            segment1, segment2 = body_parts.split('-')\n            check.append(body_parts)\n            components = [k for k in data.keys() if body_parts in k]\n            data_x = data[components[0]].values\n            data_y = data[components[1]].values\n            data_z = data[components[2]].values\n            res_force = np.linalg.norm([data_x, data_y, data_z], axis=0)\n            if segment1 not in collisions.keys():\n                collisions[segment1] = {}\n            if segment2 not in collisions.keys():\n                collisions[segment2] = {}\n            collisions[segment1][segment2] = res_force\n            collisions[segment2][segment1] = res_force\n\n    return collisions\n\n\ndef get_stance_periods(leg_force, start, stop):\n    \"\"\" Get stance periods from GRF data.\n\n    Parameters\n    ----------\n    leg_force: <np.array>\n        GRF data associated with a leg.\n    start: <float>\n        Starting time for checking stance periods.\n    stop: <float>\n        Stoping time for checking stance periods.\n\n    Returns\n    ----------\n    stance_plot: <list>\n        Indices indicating beginning and ending of stance periods.\n    \"\"\"\n    stance_ind = np.where(leg_force > 0)[0]\n    if stance_ind.size != 0:\n        stance_diff = np.diff(stance_ind)\n        stance_lim = np.where(stance_diff > 1)[0]\n        stance = [stance_ind[0] - 1]\n        for ind in stance_lim:\n            stance.append(stance_ind[ind] + 1)\n            stance.append(stance_ind[ind + 1] - 1)\n        stance.append(stance_ind[-1])\n        start_gait_list = np.where(np.array(stance) >= start)[0]\n        if len(start_gait_list) > 0:\n            start_gait = start_gait_list[0]\n        else:\n            start_gait = start\n        stop_gait_list = np.where(\n            (np.array(stance) <= stop) & (\n                np.array(stance) > start))[0]\n        if len(stop_gait_list) > 0:\n            stop_gait = stop_gait_list[-1] + 1\n        else:\n            stop_gait = start_gait\n        if start_gait != stop_gait:\n            stance_plot = stance[start_gait:stop_gait]\n            if start_gait % 2 != 0:\n                stance_plot.insert(0, start)\n            if len(stance_plot) % 2 != 0:\n                stance_plot.append(stop)\n        else:\n            stance_plot = [start, start]\n    else:\n        stance_plot = [start, start]\n\n    return stance_plot\n\n\ndef plot_data(\n    path_data,\n    leg_key='RF',\n    sim_data='walking',\n    angles={},\n    plot_angles_intraleg=False,\n    plot_torques=True,\n    plot_grf=True,\n    plot_collisions=True,\n    collisions_across=True,\n    begin=0.0,\n    end=0.0,\n    time_step=5e-4,\n    torqueScalingFactor=1e9,\n    grfScalingFactor=1e6\n):\n    \"\"\" Plots data from the simulation.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n    leg_key: <str>\n        Key for specifying a leg to plot: angles (intraleg or interleg), torques, grf, or collisions. Options: 'LF', 'LM', 'LH', 'RF', 'RM', 'RH'.\n    sim_data: <str>\n        Behavior from data. Options: 'walking' or 'grooming'.\n    plot_angles_intraleg: <bool>\n        Plotting joint angles from all joints in leg 'leg_key'.\n    plot_torques: <bool>\n        Plotting torques generated by PyBullet controllers.\n    plot_grf: <bool>\n        Plotting ground reaction forces (if sim_data='walking').\n    plot_collisions: <bool>\n        Plotting self-collision forces (if sim_data='grooming').\n    plot_collisions_across: <bool>\n        Plotting grf\/collisions as gray background across other plots.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    time_step: <float>\n        Data time step.\n    torqueScalingFactor: <float>\n        Scaling factor for torques (from Nm to uNmm).\n    grfScalingFactor: <float>\n        Scaling factor for ground reaction forces (from N to uN).\n    \"\"\"\n    data2plot = {}\n\n    equivalence = {'ThC_yaw': 'Coxa_yaw',\n                   'ThC_pitch': 'Coxa',\n                   'ThC_roll': 'Coxa_roll',\n                   'CTr_pitch': 'Femur',\n                   'CTr_roll': 'Femur_roll',\n                   'FTi_pitch': 'Tibia',\n                   'TiTa_pitch': 'Tarsus1'}\n\n    leg_order = ['LF', 'LM', 'LH', 'RF', 'RM', 'RH']\n\n    length_data = 0\n\n    if plot_angles_intraleg:\n        if bool(angles):\n            angles_raw = angles[leg_key + '_leg']\n        else:\n            angles_data = read_joint_positions(\n                path_data, equivalence, leg_order)\n            angles_raw = angles_data[leg_key + '_leg']\n        data2plot['angles'] = {}\n        for k in equivalence.keys():\n            data2plot['angles'][k] = []\n        for label, values in angles_raw.items():\n            if length_data == 0:\n                length_data = len(values)\n            data2plot['angles'][label] = values\n\n    if plot_torques:\n        torques_data = os.path.join(path_data, 'physics', 'joint_torques.h5')\n        torques_all = pd.read_hdf(torques_data)\n        torques_raw = {}\n        for joint, torque in torques_all.items():\n            if leg_key in joint and 'Haltere' not in joint:\n                if 'Tarsus' not in joint or 'Tarsus1' in joint:\n                    joint_data = joint.split('joint_')\n                    label = joint_data[1][2:]\n                    torques_raw[label] = torque.values\n        data2plot['torques'] = {}\n        for label, match_labels in equivalence.items():\n            for key in torques_raw.keys():\n                if key == match_labels:\n                    if length_data == 0:\n                        length_data = len(torques_raw[key])\n                    data2plot['torques'][label] = torques_raw[key]\n\n    if plot_grf:\n        if sim_data == 'walking':\n            data2plot['grf'] = read_ground_contacts(path_data)\n            grf_leg = data2plot['grf'][leg_key]\n            sum_force = np.sum(np.array(grf_leg), axis=0)\n            leg_force = np.delete(sum_force, 0)\n\n    if plot_collisions:\n        if sim_data == 'grooming':\n            data2plot['collisions'] = read_collision_forces(path_data)\n            leg_collisions = []\n            ant_collisions = []\n            all_collisions = []\n            for segment, coll in data2plot['collisions'].items():\n                if segment[:2] == leg_key:\n                    for k, val in coll.items():\n                        all_collisions.append(val)\n                        if 'Antenna' not in k:\n                            leg_collisions.append(val)\n                if 'Antenna' in segment and leg_key[0] == segment[0]:\n                    for k, val in coll.items():\n                        ant_collisions.append(val)\n\n            sum_all = np.sum(np.array(all_collisions), axis=0)\n            sum_leg = np.sum(np.array(leg_collisions), axis=0)\n            sum_ant = np.sum(np.array(ant_collisions), axis=0)\n            leg_force = np.delete(sum_all, 0)\n            leg_vs_leg = np.delete(sum_leg, 0)\n            leg_vs_ant = np.delete(sum_ant, 0)\n\n    if end == 0:\n        end = length_data * time_step\n\n    steps = 1 \/ time_step\n    start = int(begin * steps)\n    stop = int(end * steps)\n\n    if collisions_across:\n        if not plot_grf and sim_data == 'walking':\n            grf_data = read_ground_contacts(path_data)\n            grf_leg = grf_data[leg_key]\n            sum_force = np.sum(np.array(grf_leg), axis=0)\n            leg_force = np.delete(sum_force, 0)\n        if not plot_collisions and sim_data == 'grooming':\n            collisions_dict = read_collision_forces(path_data)\n            leg_collisions = []\n            ant_collisions = []\n            all_collisions = []\n            for segment, coll in collisions_dict.items():\n                if segment[:2] == leg_key:\n                    for k, val in coll.items():\n                        all_collisions.append(val)\n                        if 'Antenna' not in k:\n                            leg_collisions.append(val)\n                if 'Antenna' in segment and leg_key[0] == segment[0]:\n                    for k, val in coll.items():\n                        ant_collisions.append(val)\n\n            sum_all = np.sum(np.array(all_collisions), axis=0)\n            sum_leg = np.sum(np.array(leg_collisions), axis=0)\n            sum_ant = np.sum(np.array(ant_collisions), axis=0)\n            leg_force = np.delete(sum_all, 0)\n            leg_vs_leg = np.delete(sum_leg, 0)\n            leg_vs_ant = np.delete(sum_ant, 0)\n\n        stance_plot = get_stance_periods(leg_force, start, stop)\n\n    fig, axs = plt.subplots(len(data2plot.keys()), sharex=True)\n    fig.suptitle('NeuroMechFly Plots')\n\n    torque_min = np.inf\n    torque_max = 0\n    grf_min = np.inf\n    grf_max = 0\n\n    for i, (plot, data) in enumerate(data2plot.items()):\n        if plot == 'angles':\n            for name, angle_rad in data.items():\n                time = np.arange(0, len(angle_rad), 1) \/ steps\n                angle = np.array(angle_rad) * 180 \/ np.pi\n                if len(data2plot.keys()) == 1:\n                    axs.plot(time[start:stop], angle[start:stop],\n                             label=name.replace('_', ' '))\n                else:\n                    axs[i].plot(time[start:stop], angle[start:stop],\n                                label=name.replace('_', ' '))\n            if len(data2plot.keys()) == 1:\n                axs.set_ylabel('Joint angles (deg)')\n            else:\n                axs[i].set_ylabel('Joint angles (deg)')\n\n        if plot == 'torques':\n            for joint, torque in data.items():\n                torque_adj = np.delete(torque, 0)\n                time = np.arange(0, len(torque_adj), 1) \/ steps\n                if len(data2plot.keys()) == 1:\n                    axs.plot(time[start:stop], torque_adj[start:stop] *\n                             torqueScalingFactor, label=joint.replace('_', ' '))\n                else:\n                    axs[i].plot(time[start:stop], torque_adj[start:stop]\n                                * torqueScalingFactor, label=joint.replace('_', ' '))\n\n                t_min = np.min(torque_adj[start:stop] * torqueScalingFactor)\n                t_max = np.max(torque_adj[start:stop] * torqueScalingFactor)\n\n                if t_min < torque_min:\n                    torque_min = t_min\n\n                if t_max > torque_max:\n                    torque_max = t_max\n\n            if len(data2plot.keys()) == 1:\n                axs.set_ylabel('Joint torque ' + r'$(\\mu Nmm)$')\n                axs.set_ylim(1.2 * torque_min, 1.1 * torque_max)\n            else:\n                axs[i].set_ylabel('Joint torque ' + r'$(\\mu Nmm)$')\n                axs[i].set_ylim(1.2 * torque_min, 1.1 * torque_max)\n\n        if plot == 'grf':\n            time = np.arange(0, len(leg_force), 1) \/ steps\n            if len(data2plot.keys()) == 1:\n                axs.plot(time[start:stop], leg_force[start:stop]\n                         * grfScalingFactor, color='black')\n                axs.set_ylabel('Ground reaction forces ' + r'$(\\mu N)$')\n            else:\n                axs[i].plot(time[start:stop], leg_force[start:stop]\n                            * grfScalingFactor, color='black')\n                axs[i].set_ylabel('Ground reaction forces ' + r'$(\\mu N)$')\n            f_min = np.min(leg_force[start:stop] * grfScalingFactor)\n            f_max = np.max(leg_force[start:stop] * grfScalingFactor)\n\n            if f_min < grf_min:\n                grf_min = f_min\n\n            if f_max > grf_max:\n                grf_max = f_max\n\n            if len(data2plot.keys()) == 1:\n                axs.set_ylim(-0.003, 1.1 * grf_max)\n            else:\n                axs[i].set_ylim(-0.003, 1.1 * grf_max)\n\n        if plot == 'collisions':\n            time = np.arange(0, len(leg_force), 1) \/ steps\n            if len(data2plot.keys()) == 1:\n                axs.plot(time[start:stop],\n                         np.array(leg_vs_leg[start:stop]) * grfScalingFactor,\n                         color='black',\n                         label='Leg vs leg force')\n                axs.plot(time[start:stop],\n                         np.array(leg_vs_ant[start:stop]) * grfScalingFactor,\n                         color='dimgray',\n                         label='Leg vs antenna force')\n                axs.set_ylabel('Collision forces ' + r'$(\\mu N)$')\n            else:\n                axs[i].plot(time[start:stop],\n                            np.array(leg_vs_leg[start:stop]) * grfScalingFactor,\n                            color='black',\n                            label='Leg vs leg force')\n                axs[i].plot(time[start:stop],\n                            np.array(leg_vs_ant[start:stop]) * grfScalingFactor,\n                            color='dimgray',\n                            label='Leg vs antenna force')\n                axs[i].set_ylabel('Collision forces ' + r'$(\\mu N)$')\n\n        if len(data2plot.keys()) == 1:\n            axs.grid(True)\n        else:\n            axs[i].grid(True)\n\n        if (plot != 'grf' and i == 0) or ('angles' in plot and plot_angles_interleg):\n            if len(data2plot.keys()) == 1:\n                plot_handles, plot_labels = axs.get_legend_handles_labels()\n            else:\n                plot_handles, plot_labels = axs[i].get_legend_handles_labels()\n            if collisions_across and sim_data == 'walking':\n                gray_patch = mpatches.Patch(color='gray')\n                all_handles = plot_handles + [gray_patch]\n                all_labels = plot_labels + ['Stance']\n            elif sim_data == 'grooming':\n                gray_patch = mpatches.Patch(color='dimgray')\n                darkgray_patch = mpatches.Patch(color='darkgray')\n                if plot_collisions and plot != 'collisions' and collisions_across:\n                    dark_line = Line2D([0], [0], color='black')\n                    gray_line = Line2D([0], [0], color='dimgray')\n                    all_handles = plot_handles + \\\n                        [dark_line] + [gray_line] + [gray_patch] + [darkgray_patch]\n                    all_labels = plot_labels + ['Leg vs leg force'] + [\n                        'Leg vs antenna force'] + ['Foreleg grooming'] + ['Antennal grooming']\n                elif plot_collisions and plot != 'collisions' and not collisions_across:\n                    dark_line = Line2D([0], [0], color='black')\n                    gray_line = Line2D([0], [0], color='dimgray')\n                    all_handles = plot_handles + \\\n                        [dark_line] + [gray_line]\n                    all_labels = plot_labels + ['Leg vs leg force'] + [\n                        'Leg vs antenna force']\n                else:\n                    all_handles = plot_handles + \\\n                        [gray_patch] + [darkgray_patch]\n                    all_labels = plot_labels + \\\n                        ['Foreleg grooming'] + ['Antennal grooming']\n            else:\n                all_handles = plot_handles\n                all_labels = plot_labels\n\n            if len(data2plot.keys()) == 1:\n                axs.legend(\n                    all_handles,\n                    all_labels,\n                    loc='upper right',\n                    bbox_to_anchor=(\n                        1.135,\n                        1))\n            else:\n                axs[i].legend(\n                    all_handles,\n                    all_labels,\n                    loc='upper right',\n                    bbox_to_anchor=(\n                        1.135,\n                        1))\n\n        if collisions_across:\n            for ind in range(0, len(stance_plot), 2):\n                time = np.arange(0, len(leg_force), 1) \/ steps\n                if sim_data == 'walking':\n                    c = 'gray'\n                if sim_data == 'grooming':\n                    if np.sum(leg_vs_leg[stance_plot[ind]:stance_plot[ind + 1]]) > 0:\n                        c = 'dimgray'\n                    elif np.sum(leg_vs_ant[stance_plot[ind]:stance_plot[ind + 1]]) > 0:\n                        c = 'darkgray'\n                    else:\n                        c = 'darkgray'\n                if len(data2plot.keys()) == 1:\n                    axs.fill_between(time[stance_plot[ind]:stance_plot[ind + 1]], 0,\n                                     1, facecolor=c, alpha=0.5, transform=axs.get_xaxis_transform())\n                else:\n                    axs[i].fill_between(time[stance_plot[ind]:stance_plot[ind + 1]], 0,\n                                        1, facecolor=c, alpha=0.5, transform=axs[i].get_xaxis_transform())\n\n    if len(data2plot.keys()) == 1:\n        axs.set_xlabel('Time (s)')\n    else:\n        axs[len(axs) - 1].set_xlabel('Time (s)')\n    plt.show()\n\n\ndef plot_collision_diagram(\n        path_data,\n        sim_data,\n        begin=0,\n        end=0,\n        time_step=0.0005):\n    \"\"\" Plots collision\/gait diagrams.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n    sim_data: <str>\n        Behavior from data. Options: 'walking' or 'grooming'.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    time_step: <float>\n        Data time step.\n    \"\"\"\n    data = {}\n    length_data = 0\n\n    if sim_data == 'walking':\n        title_plot = 'Gait diagram'\n        collisions = {\n                'LF': [],\n                'LM': [],\n                'LH': [],\n                'RF': [],\n                'RM': [],\n                'RH': []}\n\n        data = read_ground_contacts(path_data)\n\n        for leg in collisions.keys():\n            sum_force = np.sum(np.array(data[leg]), axis=0)\n            segment_force = np.delete(sum_force, 0)\n            collisions[leg].append(segment_force)\n            if length_data == 0:\n                length_data = len(segment_force)\n\n    elif sim_data == 'grooming':\n        data = read_collision_forces(path_data)\n        title_plot = 'Collisions diagram'\n        collisions = {\n            'LAntenna': [],\n            'LFTibia': [],\n            'LFTarsus1': [],\n            'LFTarsus2': [],\n            'LFTarsus3': [],\n            'LFTarsus4': [],\n            'LFTarsus5': [],\n            'RFTarsus5': [],\n            'RFTarsus4': [],\n            'RFTarsus3': [],\n            'RFTarsus2': [],\n            'RFTarsus1': [],\n            'RFTibia': [],\n            'RAntenna': []}\n\n        for segment1 in collisions.keys():\n            seg_forces = []\n            for segment2, force in data[segment1].items():\n                seg_forces.append(force)\n            sum_force = np.sum(np.array(seg_forces), axis=0)\n            segment_force = np.delete(sum_force, 0)\n            collisions[segment1].append(segment_force)\n            if length_data == 0:\n                length_data = len(segment_force)\n\n    if end == 0:\n        end = length_data * time_step\n\n    steps = 1 \/ time_step\n    start = int(begin * steps)\n    stop = int(end * steps)\n\n    fig, axs = plt.subplots(len(collisions.keys()),\n                            sharex=True, gridspec_kw={'hspace': 0})\n    fig.suptitle(title_plot)\n\n    for i, (segment, force) in enumerate(collisions.items()):\n        time = np.arange(0, len(force[0]), 1) \/ steps\n        stance_plot = get_stance_periods(force[0], start, stop)\n        for ind in range(0, len(stance_plot), 2):\n            axs[i].fill_between(time[stance_plot[ind]:stance_plot[ind + 1]], 0, 1,\n                                facecolor='black', alpha=1, transform=axs[i].get_xaxis_transform())\n\n        axs[i].fill_between(time[start:stance_plot[0]],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=1,\n                            transform=axs[i].get_xaxis_transform())\n\n        axs[i].fill_between(time[stance_plot[-1]:stop],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=1,\n                            transform=axs[i].get_xaxis_transform())\n        axs[i].set_yticks((0.5,))\n        axs[i].set_yticklabels((segment,))\n\n    axs[len(axs) - 1].set_xlabel('Time (s)')\n    if sim_data == 'walking':\n        black_patch = mpatches.Patch(color='black', label='Stance')\n    elif sim_data == 'grooming':\n        black_patch = mpatches.Patch(color='black', label='Collision')\n    axs[0].legend(\n        handles=[black_patch],\n        loc='upper right',\n        bbox_to_anchor=(\n            1.1,\n            1))\n    plt.show()\n\n\ndef plot_fly_path(\n        path_data,\n        generations=None,\n        solutions=None,\n        sequence=False,\n        heading=True,\n        ball_radius=5.0,\n        begin=0,\n        end=0,\n        time_step=0.001,\n        ax=None\n):\n    \"\"\" Plots collision\/gait diagrams.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n    generations: <list>\n        Numbers of the generations to plot (for optimization experiments).\n    solutions: <list>\n        Names of the solutions to plot (for optimization experiments).\n    sequence: <bool>\n        Plotting path every time step.\n    heading: <bool>\n        Plotting heading of the fly (if sequence=True).\n    ball_radius: <float>\n        Radius of the spherical treadmill in millimeters.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    time_step: <float>\n        Data time step.\n    \"\"\"\n    ball_data_list = []\n\n    val_max = 0\n    val_min = np.inf\n\n    if generations:\n        if not isinstance(generations, list):\n            g = [generations]\n        else:\n            g = generations\n\n        for gen in g:\n            if solutions:\n                if not isinstance(solutions, list):\n                    s = [solutions]\n                else:\n                    s = solutions\n            else:\n                gen_folder = os.path.join(path_data, f'gen_{gen}')\n                s = [d.split('_')[-1] for d in os.listdir(gen_folder)]\n            for sol in s:\n                sim_res_folder = os.path.join(path_data, f'gen_{gen}', f'sol_{sol}', 'physics', 'ball_rotations.h5')\n                ball_data_list.append(sim_res_folder)\n    else:\n        sim_res_folder = os.path.join(\n            path_data, 'physics', 'ball_rotations.h5')\n        ball_data_list.append(sim_res_folder)\n\n    if ax is None:\n        fig = plt.figure()\n        ax = plt.axes()\n\n    m = MarkerStyle(marker=r'$\\rightarrow$')\n    ax.set_xlabel('x (mm)')\n    ax.set_ylabel('y (mm)')\n    colors = plt.cm.jet(np.linspace(0.3, 1, len(ball_data_list)))\n\n    for ind, ball_data in enumerate(ball_data_list):\n\n        data = pd.read_hdf(ball_data)\n\n        if end == 0:\n            end = len(data) * time_step\n\n        steps = 1 \/ time_step\n        start = int(begin * steps)\n        stop = int(end * steps)\n\n        data_array = np.array(data.values)\n\n        x = []\n        y = []\n\n        for count, i in enumerate(range(start, stop - 1)):\n            th = data_array[i][2]\n            forward = (data_array[i][0] - data_array[0][0]) * ball_radius\n            lateral = (data_array[i][1] - data_array[0][1]) * ball_radius\n            x.append(forward)\n            y.append(lateral)\n\n            if sequence:\n                ax.clear()\n                curr_time = (i + 2) \/ steps\n                print(f'\\rTime: {curr_time:.3f}', end='')\n                sc = ax.scatter(\n                    x,\n                    y,\n                    c=np.linspace(\n                        begin,\n                        begin + len(x) \/ steps,\n                        len(x)),\n                    cmap='jet',\n                    vmin=begin,\n                    vmax=end)\n\n                if heading:\n                    m._transform.rotate_deg(th * 180 \/ np.pi)\n                    ax.scatter(x[-1], y[-1], marker=m, s=200, color='black')\n                    m._transform.rotate_deg(-th * 180 \/ np.pi)\n\n                if count == 0:\n                    sc.set_clim([begin, end])\n                    cb = plt.colorbar(sc)\n                    cb.set_label('Time (s)')\n\n                ax.set_xlabel('x (mm)')\n                ax.set_ylabel('y (mm)')\n                plt.draw()\n                plt.pause(0.001)\n\n        max_x = np.max(np.array(x))\n        min_x = np.min(np.array(x))\n\n        if max_x > val_max:\n            val_max = max_x\n\n        if min_x < val_min:\n            val_min = min_x\n\n        lim = val_max + 0.05 * val_max\n        low = val_min - 0.05 * val_min\n        # ax.set_xlim(low, lim)\n\n        if not sequence:\n            if generations:\n                gen_label = g[int(ind \/ len(s))] + 1\n                sol_label = s[int(ind % len(s))]\n                ax.plot(x,\n                        y,\n                        linewidth=2,\n                        label=f'Gen {gen_label}-{sol_label}',\n                        c=colors[ind])\n            else:\n                ax.plot(x, y, linewidth=2)\n\n\ndef get_data(\n        data_path,\n        begin,\n        end,\n        time_step,\n        data_from=[],\n        offset=0,\n        window_time=0.2,\n        baseline_time=0.1):\n\n    \"\"\" Read data from simulation results or fictrac ground truth.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to data.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    time_step: <float>\n        Data time step.\n    data_from: <list>\n        Fictrac keys from which the data will be obtained.\n    offset: <float>\n        Offset in seconds of simulation with respect to fictrac data.\n    window_time: <float>\n        Window size in seconds for smoothing the signals.\n    baseline_time: <float>\n        Time in seconds for calculating the baseline of the signal.\n\n    Returns\n    ----------\n    norm_data: <dict>\n        Dictionary with the required data.\n    \"\"\"\n\n    fictrac_columns = [\"Frame_counter\",\n                       \"delta_rot_cam_x\",\n                       \"delta_rot_cam_y\",\n                       \"delta_rot_cam_z\",\n                       \"delta_rot_error\",\n                       \"delta_rot_lab_x\",\n                       \"delta_rot_lab_y\",\n                       \"delta_rot_lab_z\",\n                       \"abs_rot_cam_x\",\n                       \"abs_rot_cam_y\",\n                       \"abs_rot_cam_z\",\n                       \"abs_rot_lab_x\",\n                       \"abs_rot_lab_y\",\n                       \"abs_rot_lab_z\",\n                       \"integrated_lab_x\",\n                       \"integrated_lab_y\",\n                       \"integrated_lab_heading\",\n                       \"animal_movement_direction_lab\",\n                       \"animal_movement_speed\",\n                       \"integrated_side_movement\",\n                       \"integrated_forward_movement\",\n                       \"timestamp\",\n                       \"seq_counter\",\n                       \"delta_time\",\n                       \"alt_time\"]\n\n    if \".dat\" in data_path:\n        data = pd.read_csv(data_path, header=None, names=fictrac_columns)\n\n    if \".h5\" in data_path:\n        try:\n            data = pd.read_hdf(data_path)\n        except:\n            data_path = data_path.replace('ball_velocity','ball_velocities')\n            data = pd.read_hdf(data_path)\n    if end == 0:\n        end = len(data) * time_step\n\n    steps = 1 \/ time_step\n    start = int((begin + offset) * steps)\n    stop = int((end + offset) * steps)\n\n    if not data_from:\n        data_from = list(data.columns)\n\n    norm_data = {}\n    for key in data_from:\n        if window_time > 0:\n            filtered_data = scipy.ndimage.median_filter(\n                data[key], size=int(window_time \/ time_step))\n        else:\n            filtered_data = np.array(data[key].values)\n        baseline = np.mean(filtered_data[start:start+int(baseline_time\/time_step)])\n        norm_data[key] = filtered_data[start:stop] - baseline\n        if \"lab_heading\" in key:\n            diff_heading = np.abs(np.diff(norm_data[key]))\n            cross_points = np.where(diff_heading > np.pi)[0]\n            if len(cross_points) % 2 != 0:\n                cross_points = np.append(cross_points, stop)\n            heading_fictrac = norm_data[key].copy()\n            for p in range(1, len(cross_points), 2):\n                init = cross_points[p - 1] + 1\n                fin = cross_points[p] + 1\n                heading_fictrac[init:fin] = heading_fictrac[init:fin] - 2 * np.pi\n            norm_data[key] = heading_fictrac\n\n    return norm_data\n\n\ndef plot_treadmill_rotations_comparison(\n        fictrac_path,\n        sim_path,\n        plot_vel=True,\n        plot_traj=False,\n        ball_radius=5,\n        begin=0,\n        end=0,\n        offset_fictrac=0,\n        offset_sim=0,\n        time_step_fictrac=0.01,\n        time_step_sim=5e-4,\n        filter_window_time=0.1,\n        baseline_time=0.2\n        ):\n    \"\"\" Comparing fly path\/treadmill rotations between ground truth (obtained from FicTrac) and simulation.\n\n    Parameters\n    ----------\n    fictrac_path: <str>\n        Path to fictrac data.\n    sim_path: <str>\n        Path to simulation results.\n    plot_vel: <bool>\n        Plot rotational velocities.\n    plot_traj: <bool>\n        Plot integrated path and displacement.\n    ball_radius: <float>\n        Radius of the spherical treadmill in millimeters.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    offset_fictrac: <float>\n        Offset in seconds of fictrac data with respect to the simulation.\n    offset_sim: <float>\n        Offset in seconds of the simulation with respect to the fictrac data.\n    time_step_fictrac: <float>\n        Fictrac time step.\n    time_step_sim: <float>\n        Simulation results time step.\n    filter_window_time: <float>\n        Window size in seconds for smoothing the signals.\n    baseline_time: <float>\n        Time in seconds for calculating the baseline of the signal.\n\n    Returns\n    ----------\n    corr_coefs: <dict>\n        Dictionary with the Spearman correlation coefficients for each axis (forward, lateral, and yaw).\n    \"\"\"\n    data_from_fictrac = [\"integrated_forward_movement\",\n                         \"integrated_side_movement\",\n                         \"integrated_lab_heading\",\n                         \"delta_rot_lab_x\",\n                         \"delta_rot_lab_y\",\n                         \"delta_rot_lab_z\"]\n\n    fictrac_data = get_data(\n        fictrac_path,\n        begin,\n        end,\n        time_step_fictrac,\n        data_from_fictrac,\n        offset_fictrac,\n        filter_window_time,\n        baseline_time)\n\n    fw_fictrac = fictrac_data[\"integrated_forward_movement\"] * ball_radius\n    side_fictrac = fictrac_data[\"integrated_side_movement\"] * ball_radius\n    heading_fictrac = fictrac_data[\"integrated_lab_heading\"]\n\n    vel_fw_fictrac = -fictrac_data[\"delta_rot_lab_x\"] \/ time_step_fictrac\n    vel_side_fictrac = -fictrac_data[\"delta_rot_lab_y\"] \/ time_step_fictrac\n    vel_heading_fictrac = -fictrac_data[\"delta_rot_lab_z\"] \/ time_step_fictrac\n\n    data_from_sim = [\"x\", \"y\", \"z\"]\n    sim_data_path = os.path.join(sim_path, 'physics', 'ball_rotations.h5')\n    ball_data = get_data(\n        sim_data_path,\n        begin,\n        end,\n        time_step_sim,\n        data_from_sim,\n        offset_sim,\n        filter_window_time,\n        baseline_time)\n\n    fw_sim = ball_data[\"x\"] * ball_radius\n    side_sim = ball_data[\"y\"] * ball_radius\n    heading_sim = ball_data[\"z\"]\n\n    sim_vel_data_path = os.path.join(sim_path, 'physics', 'ball_velocity.h5')\n    vel_data = get_data(\n        sim_vel_data_path,\n        begin,\n        end,\n        time_step_sim,\n        data_from_sim,\n        offset_sim,\n        filter_window_time,\n        baseline_time)\n    vel_fw_sim = -vel_data[\"y\"]\n    vel_side_sim = vel_data[\"x\"]\n    vel_heading_sim = -vel_data[\"z\"]\n\n    window = 11\n    order = 3\n\n    if end == 0:\n        end = len(fw_fictrac) * time_step_fictrac\n\n    time_fictrac = np.arange(begin, end, time_step_fictrac)\n    time_sim = np.arange(begin, end, time_step_sim)\n\n    corr_coefs = {}\n\n    interp_fw_fictrac, corr_coef_fw = calculate_correlation_between(vel_fw_fictrac,vel_fw_sim,time_fictrac,time_sim)\n    corr_coefs['forward']=corr_coef_fw\n\n    interp_side_fictrac, corr_coef_side = calculate_correlation_between(vel_side_fictrac,vel_side_sim,time_fictrac,time_sim)\n    corr_coefs['lateral']=corr_coef_side\n\n    interp_heading_fictrac, corr_coef_heading = calculate_correlation_between(vel_heading_fictrac,vel_heading_sim,time_fictrac,time_sim)\n    corr_coefs['yaw']=corr_coef_heading\n\n    if plot_traj:\n        x_head_fictrac, y_head_fictrac = get_flat_trajectory(fw_fictrac,side_fictrac,heading_fictrac)\n        x_head_sim, y_head_sim = get_flat_trajectory(fw_sim, side_sim, heading_sim)\n\n        plt.figure()\n        plt.plot(x_head_fictrac, y_head_fictrac, label=\"Fictrac path\")\n        plt.plot(x_head_sim, y_head_sim, label=\"NeuroMechFly path\")\n        plt.xlabel('Distance (mm)', fontsize=14)\n        plt.ylabel('Distance (mm)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n        plt.figure()\n        plt.plot(time_fictrac, side_fictrac, label='Fictrac')\n        plt.plot(time_sim, side_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Lateral distance (mm)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n        plt.figure()\n        plt.plot(time_fictrac, fw_fictrac, label='Fictrac')\n        plt.plot(time_sim, fw_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Forward distance (mm)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n        plt.figure()\n        plt.plot(time_fictrac, heading_fictrac, label='Fictrac')\n        plt.plot(time_sim, heading_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Yaw rotation (rad)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n    if plot_vel:\n        plt.figure()\n        plt.plot(time_sim, interp_fw_fictrac, label='Fictrac')\n        plt.plot(time_sim, vel_fw_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Forward Velocity (rad\/s)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n        plt.figure()\n        plt.plot(time_sim, interp_side_fictrac, label='Fictrac')\n        plt.plot(time_sim, vel_side_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Lateral Velocity (rad\/s)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n        plt.figure()\n        plt.plot(time_sim, interp_heading_fictrac, label='Fictrac')\n        plt.plot(time_sim, vel_heading_sim, label='NeuroMechFly')\n        plt.xlabel('Time (s)', fontsize=14)\n        plt.ylabel('Yaw Velocity (rad\/s)', fontsize=14)\n        plt.legend(fontsize=11)\n        plt.xticks(fontsize=13)\n        plt.yticks(fontsize=13)\n\n    if plot_vel or plot_traj:\n        plt.show()\n\n    return corr_coefs\n\n\ndef calculate_correlation_between(\n        fictrac,\n        sim,\n        time_fictrac,\n        time_sim):\n    \"\"\" Calculates the Spearman correlation coefficient betwen two signals.\n\n    Parameters\n    ----------\n    fictrac: <np.array>\n        Fictrac data (higher timestep).\n    sim: <np.array>\n        Simulation data (smaller timestep).\n    time_fictrac: <np.array>\n        Time vector for fictrac data.\n    time_sim: <np.array>\n        Time vector for simulation data.\n\n    Returns\n    ----------\n    interpolated_fictrac: <np.array>\n        Interpolated data from the higher to the smaller time step.\n    corr_coef:\n        Spearman correlation coefficient between both signals.\n    \"\"\"\n\n    interpolated_fictrac = pchip_interpolate(time_fictrac, fictrac, time_sim)\n    corr_coef, p_value = scipy.stats.spearmanr(interpolated_fictrac, sim)\n\n    return interpolated_fictrac, corr_coef\n\n\ndef get_flat_trajectory(\n        fw,\n        side,\n        heading):\n\n    \"\"\" Integrates path trajectory.\n\n    Parameters\n    ----------\n    fw: <np.array>\n        Fictrac data (higher timestep).\n    side: <np.array>\n        Simulation data (smaller timestep).\n    heading: <np.array>\n        Time vector for fictrac data.\n\n    Returns\n    ----------\n    x_trajectory: <list>\n        Integrated path for the x axis.\n    y_trajectory: <list>\n        Integrated path for the y axis.\n    \"\"\"\n\n    x_trajectory = [0]\n    y_trajectory = [0]\n    diff_x = np.diff(fw)\n    diff_y = np.diff(side)\n    for ind in range(len(diff_x)):\n        new_x = diff_x[ind] * np.cos(heading[ind + 1]) + \\\n            diff_y[ind] * np.sin(heading[ind + 1]) + x_trajectory[-1]\n        new_y = diff_x[ind] * np.sin(heading[ind + 1]) - \\\n            diff_y[ind] * np.cos(heading[ind + 1]) + y_trajectory[-1]\n        x_trajectory.append(new_x)\n        y_trajectory.append(new_y)\n\n    return x_trajectory, y_trajectory\n\n\ndef compare_collision_diagram(\n        path_data,\n        gt_data,\n        sim_data,\n        begin=0,\n        end=0,\n        time_step_sim=0.0005,\n        time_step_gt=0.01):\n    \"\"\" Plots collision\/gait diagrams.\n\n    Parameters\n    ----------\n    path_data: <str>\n        Path to simulation results.\n    sim_data: <str>\n        Behavior from data. Options: 'walking' or 'grooming'.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    time_step_sim: <float>\n        Simulation data time step.\n    time_step_gt: <float>\n        Ground truth time step.\n    \"\"\"\n    data = {}\n    length_data = 0\n\n    if sim_data == 'walking':\n        title_plot = 'Gait diagram'\n        collisions = {\n            'LF': [],\n            'LM': [],\n            'LH': [],\n            'RF': [],\n            'RM': [],\n            'RH': []}\n\n        collisions_gt = {\n            'LF': [],\n            'LM': [],\n            'LH': [],\n            'RF': [],\n            'RM': [],\n            'RH': []}\n\n        data_sim = read_ground_contacts(path_data)\n\n        gt_file_path = os.path.join(gt_data, \"ground_truth_contact.pkl\")\n        data_gt = np.load(gt_file_path, allow_pickle=True)\n\n        for leg in collisions.keys():\n            sum_force = np.sum(np.array(data_sim[leg]), axis=0)\n            segment_force = np.delete(sum_force, 0)\n            collisions[leg].append(segment_force)\n            if length_data == 0:\n                length_data = len(segment_force)\n\n        for leg in collisions_gt.keys():\n            sum_force = np.sum(np.array(data_gt[leg]), axis=0)\n            segment_force = np.delete(sum_force, 0)\n            collisions_gt[leg].append(segment_force)\n            if length_data == 0:\n                length_data = len(segment_force)\n\n    elif sim_data == 'grooming':\n        data = read_collision_forces(path_data)\n        title_plot = 'Collisions diagram'\n        collisions = {\n            'LAntenna': [],\n            'LFTibia': [],\n            'LFTarsus1': [],\n            'LFTarsus2': [],\n            'LFTarsus3': [],\n            'LFTarsus4': [],\n            'LFTarsus5': [],\n            'RFTarsus5': [],\n            'RFTarsus4': [],\n            'RFTarsus3': [],\n            'RFTarsus2': [],\n            'RFTarsus1': [],\n            'RFTibia': [],\n            'RAntenna': []}\n\n        for segment1 in collisions.keys():\n            seg_forces = []\n            for segment2, force in data[segment1].items():\n                seg_forces.append(force)\n            sum_force = np.sum(np.array(seg_forces), axis=0)\n            segment_force = np.delete(sum_force, 0)\n            collisions[segment1].append(segment_force)\n            if length_data == 0:\n                length_data = len(segment_force)\n\n    if end == 0:\n        end = length_data * time_step_sim\n\n    steps_sim = 1 \/ time_step_sim\n    start_sim = int(begin * steps_sim)\n    stop_sim = int(end * steps_sim)\n\n    steps_gt = 1 \/ time_step_gt\n    start_gt = int(begin * steps_gt)\n    stop_gt = int(end * steps_gt)\n\n    fig, axs = plt.subplots(len(collisions.keys()),\n                            sharex=True, gridspec_kw={'hspace': 0})\n    fig.suptitle(title_plot)\n    stance_frames = {}\n    stance_frames_gt = {}\n    for i, (segment, force) in enumerate(collisions.items()):\n        time = np.arange(0, len(force[0]), 1) \/ steps_sim\n        stance_plot = get_stance_periods(force[0], start_sim, stop_sim)\n        stance_frames[segment] = []\n        for ind in range(0, len(stance_plot), 2):\n            start_stance = stance_plot[ind]\n            stop_stance = stance_plot[ind + 1]\n            num_steps = int(stop_stance - start_stance)\n            axs[i].fill_between(time[start_stance:stop_stance], 0, 1,\n                                facecolor='deepskyblue', alpha=0.5,\n                                transform=axs[i].get_xaxis_transform())\n            stance_frames[segment].extend(np.linspace(start_stance,\n                                                      stop_stance,\n                                                      num_steps,\n                                                      endpoint=False))\n\n        axs[i].fill_between(time[start_sim:stance_plot[0]],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=0.5,\n                            transform=axs[i].get_xaxis_transform())\n\n        axs[i].fill_between(time[stance_plot[-1]:stop_sim],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=0.5,\n                            transform=axs[i].get_xaxis_transform())\n\n        axs[i].set_yticks((0.5,))\n        axs[i].set_yticklabels((segment,))\n\n    for i, (segment, force) in enumerate(collisions_gt.items()):\n        scale_factor = time_step_gt \/ time_step_sim\n        stop_time = np.round(len(force[0]) * scale_factor)\n        time = np.arange(0, stop_time, 1) \/ steps_sim\n        time_gt = np.arange(0, len(force[0]), 1) \/ steps_gt\n        stance_plot = get_stance_periods(force[0], start_gt, stop_gt)\n        stance_frames_gt[segment] = []\n        for ind in range(0, len(stance_plot), 2):\n\n            start_stance = int(np.floor(stance_plot[ind] * scale_factor))\n            stop_stance = int(np.ceil(stance_plot[ind + 1] * scale_factor))\n            num_steps = int(stop_stance - start_stance)\n\n            axs[i].fill_between(time[start_stance:stop_stance], 0, 1,\n                                facecolor='y', alpha=0.5,\n                                transform=axs[i].get_xaxis_transform())\n            stance_frames_gt[segment].extend(np.linspace(start_stance,\n                                                         stop_stance,\n                                                         num_steps,\n                                                         endpoint=False))\n\n        axs[i].fill_between(time_gt[start_gt:stance_plot[0]],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=0.5,\n                            transform=axs[i].get_xaxis_transform())\n\n        axs[i].fill_between(time_gt[stance_plot[-1]:stop_gt],\n                            0,\n                            1,\n                            facecolor='white',\n                            alpha=0.5,\n                            transform=axs[i].get_xaxis_transform())\n\n        axs[i].set_yticks((0.5,))\n        axs[i].set_yticklabels((segment,))\n\n    results = pd.DataFrame()\n    tot_frames = stop_sim - start_sim\n    for leg, frames in stance_frames.items():\n        tp = np.count_nonzero(\n            np.isin(\n                np.array(frames),\n                np.array(\n                    stance_frames_gt[leg])))\n        fp = len(frames) - tp\n        tp_count_gt = np.count_nonzero(\n            np.isin(\n                np.array(\n                    stance_frames_gt[leg]),\n                np.array(frames)))\n        fn = len(stance_frames_gt[leg]) - tp_count_gt\n        tn = tot_frames - tp - fp - fn\n\n        df_vals = pd.DataFrame([[tp \/ tot_frames,\n                                 tn \/ tot_frames,\n                                 fp \/ tot_frames,\n                                 fn \/ tot_frames,\n                                 (tp + tn) \/ tot_frames]],\n                               columns=['True positive',\n                                        'True negative',\n                                        'False positive',\n                                        'False negative',\n                                        'Accuracy'])\n        df_vals['Leg'] = leg\n        results = results.append(df_vals, ignore_index=True)\n        #print(leg, [[key, v\/tot_frames] for key, v in results[leg].items()])\n\n    axs[len(axs) - 1].set_xlabel('Time (s)')\n    if sim_data == 'walking':\n        gt_patch = mpatches.Patch(color='y', alpha=0.5, label='GT-Stance')\n        sim_patch = mpatches.Patch(\n            color='deepskyblue',\n            alpha=0.5,\n            label='NMF-Stance')\n        patches = [gt_patch, sim_patch]\n    elif sim_data == 'grooming':\n        black_patch = mpatches.Patch(color='black', label='Collision')\n        patches = [black_patch]\n    axs[0].legend(\n        handles=patches,\n        loc='upper right',\n        bbox_to_anchor=(\n            1.1,\n            1))\n\n    print(results)\n    print(np.mean(results['Accuracy']))\n    fig, ax2 = plt.subplots()\n    ax2.bar(results['Leg'], results['True positive'], label='True positive')\n    ax2.bar(\n        results['Leg'],\n        results['True negative'],\n        bottom=results['True positive'],\n        label='True negative')\n    ax2.bar(\n        results['Leg'],\n        results['False negative'],\n        bottom=results['True positive'] +\n        results['True negative'],\n        label='False negative')\n    ax2.bar(\n        results['Leg'],\n        results['False positive'],\n        bottom=results['True positive'] +\n        results['True negative'] +\n        results['False negative'],\n        label='False positive')\n    ax2.set_xlabel('Leg')\n    ax2.set_ylabel('Percentage')\n    ax2.legend()\n    plt.show()\n\n\ndef compare_movement_on_ground(\n        fictrac_path,\n        path_data_ball,\n        path_data_floor,\n        animation = False,\n        save_imgs = False,\n        begin=0,\n        end = 0,\n        offset = 0.0,\n        time_step_fictrac=0.01,\n        time_step_sim = 5e-4,\n        ball_radius = 5,\n        filter_window_time=0.1,\n        baseline_time=0.2\n):\n\n    \"\"\" Comparing fly integrated path between FicTrac data, and tethered kinematic replay on the treadmill and on flat ground.\n\n    Parameters\n    ----------\n    fictrac_path: <str>\n        Path to fictrac data.\n    path_data_ball: <str>\n        Path to simulation results from tethered walking.\n    path_data_floor: <str>\n        Path to simulation results from flat ground (untethered) walking.\n    animation: <bool>\n        Plot integrated path step by step.\n    save_imgs: <bool>\n        Save plot from animation.\n    begin: <float>\n        Starting time for initiating the plots.\n    end: <float>\n        Stoping time for finishing the plots. If 0.0, all data is plotted.\n    offset: <float>\n        Offset in seconds of the simulation with respect to the fictrac data.\n    time_step_fictrac: <float>\n        Fictrac time step.\n    time_step_sim: <float>\n        Simulation results time step.\n    ball_radius: <float>\n        Radius of the spherical treadmill in millimeters.\n    filter_window_time: <float>\n        Window size in seconds for smoothing the signals.\n    baseline_time: <float>\n        Time in seconds for calculating the baseline of the signal.\n\n    Returns\n    ----------\n    corr_coefs: <dict>\n        Dictionary with the Spearman correlation coefficients for each axis (forward, lateral, and yaw).\n    \"\"\"\n\n    data_from_fictrac = [\"integrated_forward_movement\",\n                         \"integrated_side_movement\",\n                         \"integrated_lab_heading\",\n                         \"delta_rot_lab_x\",\n                         \"delta_rot_lab_y\",\n                         \"delta_rot_lab_z\"]\n\n    fictrac_data = get_data(fictrac_path,begin,end,time_step_fictrac,data_from_fictrac,offset,filter_window_time, baseline_time)\n    fw_fictrac = fictrac_data[\"integrated_forward_movement\"] * ball_radius\n    side_fictrac = fictrac_data[\"integrated_side_movement\"] * ball_radius\n    heading_fictrac = fictrac_data[\"integrated_lab_heading\"]\n\n    vel_fw_fictrac = -fictrac_data[\"delta_rot_lab_x\"] \/ time_step_fictrac  * ball_radius\n    vel_side_fictrac = -fictrac_data[\"delta_rot_lab_y\"] \/ time_step_fictrac  * ball_radius\n    vel_heading_fictrac = -fictrac_data[\"delta_rot_lab_z\"] \/ time_step_fictrac\n\n    data_from_sim = [\"x\", \"y\", \"z\"]\n    path_ball = os.path.join(path_data_ball, 'physics','ball_rotations.h5')\n    ball_data = get_data(path_ball,begin,end,time_step_sim,data_from_sim, offset, filter_window_time, baseline_time)\n    fw_ball = ball_data[\"x\"] * ball_radius\n    side_ball = ball_data[\"y\"] * ball_radius\n    heading_ball = ball_data[\"z\"]\n\n    sim_vel_data_path = os.path.join(path_data_ball, 'physics','ball_velocity.h5')\n    vel_data = get_data(sim_vel_data_path,begin,end,time_step_sim,data_from_sim, offset, filter_window_time,baseline_time)\n    fw_vel_ball = -vel_data[\"y\"] * ball_radius\n    side_vel_ball = vel_data[\"x\"] * ball_radius\n    heading_vel_ball = -vel_data[\"z\"]\n\n    path_pos = os.path.join(path_data_floor,'physics','base_position.h5')\n    pos_data = get_data(path_pos,begin,end,time_step_sim,data_from_sim, offset, filter_window_time,baseline_time)\n    x_floor = pos_data['x']*1000\n    y_floor = pos_data['y']*1000\n\n    path_vel = os.path.join(path_data_floor,'physics','base_linear_velocity.h5')\n    vel_floor = get_data(path_vel,begin,end,time_step_sim,data_from_sim, offset, filter_window_time,baseline_time)\n    fw_vel_floor = vel_floor['x']*1000\n    side_vel_floor = -vel_floor['y']*1000\n    z_vel_floor = vel_floor['z']*1000\n\n    path_ori = os.path.join(path_data_floor,'physics','base_orientation.h5')\n    th_floor = get_data(path_ori,begin,end,time_step_sim,data_from_sim, offset, filter_window_time,baseline_time)\n    th_x = th_floor['x']\n    th_y = th_floor['y']\n    th_z = -th_floor['z']\n\n    path_ang_vel = os.path.join(path_data_floor,'physics','base_angular_velocity.h5')\n    ang_vel_floor = get_data(path_ang_vel,begin,end,time_step_sim,data_from_sim, offset, filter_window_time,baseline_time)\n    ang_vel_x = ang_vel_floor['x']\n    ang_vel_y = ang_vel_floor['y']\n    heading_vel_floor = ang_vel_floor['z']\n\n\n    if end == 0:\n        end = len(x_sim) * time_step_sim\n\n    time_sim = np.arange(begin+offset, end, time_step_sim)\n    time_fictrac = np.arange(begin, end, time_step_fictrac)\n\n\n    x_fictrac, y_fictrac = get_flat_trajectory(fw_fictrac,side_fictrac,heading_fictrac)\n    x_ball, y_ball = get_flat_trajectory(fw_ball, side_ball, heading_ball)\n    fw_vel, side_vel = get_flat_trajectory(fw_vel_floor, side_vel_floor, th_z)\n\n    interp_fw_fictrac, corr_coef_fw = calculate_correlation_between(vel_fw_fictrac,fw_vel,time_fictrac,time_sim)\n\n    interp_side_fictrac, corr_coef_side = calculate_correlation_between(vel_side_fictrac,side_vel,time_fictrac,time_sim)\n\n    interp_heading_fictrac, corr_coef_heading = calculate_correlation_between(vel_heading_fictrac,heading_vel_floor,time_fictrac,time_sim)\n\n    print(corr_coef_fw)\n    print(corr_coef_side)\n    print(corr_coef_heading)\n\n    if animation:\n        fig = plt.figure()\n        ax = plt.axes()\n        #m = MarkerStyle(marker=r'$\\rightarrow$')\n        m = MarkerStyle(marker=\">\")\n        m2 = MarkerStyle(marker=\">\")\n        ax.set_xlabel('X (mm)')\n        ax.set_ylabel('Y (mm)')\n        #colors = plt.cm.Greens(np.linspace(0.3,1,len(ball_data_list)))\n\n        for count, i in enumerate(range(0,len(x_floor),int(time_step_fictrac\/time_step_sim))):\n            ax.clear()\n            curr_time = (i+2)*time_step_sim\n            print(f'\\rTime: {curr_time:.3f}', end='')\n            sc = ax.scatter(\n                    x_floor[0:i],\n                    y_floor[0:i],\n                    c=np.linspace(\n                        begin,\n                        begin+len(x_floor[0:i])*time_step_sim,\n                        len(x_floor[0:i])),\n                    cmap='Greens',\n                    vmin=begin,\n                    vmax=end)\n\n            m._transform.rotate_deg(-th_z[i] * 180 \/ np.pi)\n            ax.scatter(x_floor[i], y_floor[i], marker=m, s=200, color='green',label='Flat ground')\n            m._transform.rotate_deg(th_z[i] * 180 \/ np.pi)\n\n            ax.scatter(\n                    x_ball[0:i],\n                    y_ball[0:i],\n                    c=np.linspace(\n                        begin,\n                        begin+len(x_ball[0:i])*time_step_sim,\n                        len(x_ball[0:i])),\n                    cmap='Oranges',\n                    vmin=begin,\n                    vmax=end)\n\n            m2._transform.rotate_deg(heading_ball[i] * 180 \/ np.pi)\n            ax.scatter(x_ball[i], y_ball[i], marker=m2, s=200, color='orange', label='Tethered')\n            m2._transform.rotate_deg(-heading_ball[i] * 180 \/ np.pi)\n\n            if i == 0:\n                sc.set_clim([begin, end])\n                cb = plt.colorbar(sc)\n                cb.set_label('Time (s)')\n\n            ax.set_xlabel('X (mm)')\n            ax.set_ylabel('Y (mm)')\n            ax.set_xlim([np.min(x_floor)-2,np.max(x_floor)+2])\n            ax.set_ylim([np.min(y_ball)-2,np.max(y_ball)+1])\n            plt.legend(loc='upper left')\n            if save_imgs:\n                new_folder = os.path.join(path_data_floor,'fly_path')\n                if not os.path.exists(new_folder):\n                    os.makedirs(new_folder)\n                name = new_folder + '\/img_' + '{:06}'.format(count) + '.jpg'\n                fig.set_size_inches(6,4)\n                plt.savefig(name, dpi=300)\n            else:\n                plt.draw()\n                plt.pause(0.001)\n\n\n    plt.figure()\n    plt.plot(x_fictrac, y_fictrac, label=\"Fictrac\")\n    plt.plot(x_ball,y_ball, label = 'Tethered')\n    plt.plot(x_floor,y_floor, label = 'Flat ground')\n    plt.xlabel('Distance (mm)', fontsize=14)\n    plt.ylabel('Distance (mm)', fontsize=14)\n    plt.legend(fontsize=11)\n    plt.xticks(fontsize=13)\n    plt.yticks(fontsize=13)\n\n    plt.figure()\n    plt.plot(time_sim, interp_fw_fictrac, label = 'Fictrac')\n    plt.plot(time_sim, fw_vel_ball, label = 'Tethered')\n    plt.plot(time_sim, fw_vel, label = 'Flat ground')\n    plt.xlabel('Time (s)', fontsize=14)\n    plt.ylabel('Forward Velocity (mm\/s)', fontsize=14)\n    plt.legend(fontsize=11)\n    plt.xticks(fontsize=13)\n    plt.yticks(fontsize=13)\n\n    plt.figure()\n    plt.plot(time_sim, interp_side_fictrac, label = 'Fictrac')\n    plt.plot(time_sim, side_vel_ball, label = 'Tethered')\n    plt.plot(time_sim, np.array(side_vel), label = 'Flat ground')\n    plt.xlabel('Time (s)', fontsize=14)\n    plt.ylabel('Lateral Velocity (mm\/s)', fontsize=14)\n    plt.legend(fontsize=11)\n    plt.xticks(fontsize=13)\n    plt.yticks(fontsize=13)\n\n    plt.figure()\n    plt.plot(time_sim, interp_heading_fictrac, label = 'Fictrac')\n    plt.plot(time_sim, heading_vel_ball, label = 'Thetered')\n    plt.plot(time_sim, heading_vel_floor, label = 'Flat ground')\n    plt.xlabel('Time (s)', fontsize=14)\n    plt.ylabel('Yaw Velocity (rad\/s)', fontsize=14)\n    plt.legend(fontsize=11)\n    plt.xticks(fontsize=13)\n    plt.yticks(fontsize=13)\n\n    plt.show()\n\n\ndef plot_sensitivity_constraints(\n        data_path,\n        fictrac_path,\n        annot = True,\n        annot_size = 18\n        ):\n    \"\"\" Plots the heatmaps for the constraints sensitivity analysis. Three heatmaps correspond to each rotation axis (forward, lateral, and yaw) and the fourth one corresponds to the normalized weighted sum for selecting the best combination.\n\n    Parameters\n    ----------\n    data_path: <str>\n        Path to the simulation results.\n    fictrac_path: <str>\n        Path to the fictrac data.\n    annot: <bool>\n        Show annotations in heatmaps.\n    annot_size: <int>\n        Font size for the annotations in heatmaps.\n    \"\"\"\n    coef_mat_fw = np.zeros((11, 11))\n    coef_mat_side = np.zeros((11, 11))\n    coef_mat_heading = np.zeros((11, 11))\n\n    x_ticks = np.linspace(0, 10, num=11, endpoint=True)\n    y_ticks = np.linspace(0, 1, num=11, endpoint=True)\n\n    x_tick_labels = [f'{val:.1f}' for val in x_ticks]\n    y_tick_labels = [f'{val:.1f}' for val in y_ticks]\n\n    experiments = next(os.walk(data_path))[1]\n    date_time = [exp.split('_')[-2]+exp.split('_')[-1] for exp in experiments]\n\n    date_time_array = np.array([int(x) for x in date_time])\n\n    order = np.argsort(date_time_array)\n\n    for i, ind in enumerate(order):\n        print(f'Exp: {i+1}\/{len(order)}',end='\\r')\n        exp_path = os.path.join(data_path,experiments[ind])\n        row = int(i\/11)\n        col = int(i%11)\n        corr_coef = plot_fly_path_comparison(fictrac_path, exp_path, plot_vel=False, end=6.0, offset_fictrac=0.5)\n        coef_mat_fw[row][col] = corr_coef['forward']\n        coef_mat_side[row][col] = corr_coef['lateral']\n        coef_mat_heading[row][col] = corr_coef['yaw']\n\n    std_fw = np.std(coef_mat_fw.flatten())\n    std_side = np.std(coef_mat_side.flatten())\n    std_heading = np.std(coef_mat_heading.flatten())\n    tot_dev = std_fw+std_side+std_heading\n\n    alpha = std_fw\/tot_dev\n    beta = std_side\/tot_dev\n    gamma = std_heading\/tot_dev\n\n    print()\n\n    sum_mat = alpha*coef_mat_fw + beta*coef_mat_side + gamma*coef_mat_heading\n\n    norm_sum = (sum_mat - np.min(sum_mat))\/(np.max(sum_mat) - np.min(sum_mat))\n\n    sort_sum = np.argsort(norm_sum.flatten())\n    for ind in range(-1,-6,-1):\n        row = int(sort_sum[ind]\/11)\n        col = int(sort_sum[ind]%11)\n        print(f\"{ind*-1}: ERP = {row\/10} - CFM = {col}\")\n\n    fig = plt.figure()\n    ax_fw = plt.axes()\n    fig = plt.figure()\n    ax_side = plt.axes()\n    fig = plt.figure()\n    ax_heading = plt.axes()\n    fig = plt.figure()\n    ax_sum = plt.axes()\n\n    heatmap_plot('Constraints sensitivity analysis: forward',\n                 coef_mat_fw,\n                 'Spearman coefficient',\n                 annot=annot,\n                 annot_size=annot_size,\n                 precision=\".3g\",\n                 ax=ax_fw,\n                 xticklabels=x_tick_labels,\n                 yticklabels=y_tick_labels)\n    ax_fw.set_xlabel(\"CFM\")\n    ax_fw.set_ylabel(\"ERP\")\n\n    heatmap_plot('Constraints sensitivity analysis: lateral',\n                 coef_mat_side,\n                 'Spearman coefficient',\n                 annot=annot,\n                 annot_size=annot_size,\n                 precision=\".3g\",\n                 ax=ax_side,\n                 xticklabels=x_tick_labels,\n                 yticklabels=y_tick_labels)\n    ax_side.set_xlabel(\"CFM\")\n    ax_side.set_ylabel(\"ERP\")\n\n    heatmap_plot('Constraints sensitivity analysis: yaw',\n                 coef_mat_heading,\n                 'Spearman coefficient',\n                 annot=annot,\n                 annot_size=annot_size,\n                 precision=\".3g\",\n                 ax=ax_heading,\n                 xticklabels=x_tick_labels,\n                 yticklabels=y_tick_labels)\n    ax_heading.set_xlabel(\"CFM\")\n    ax_heading.set_ylabel(\"ERP\")\n\n    heatmap_plot('Constraints sensitivity analysis: normalized weighted sum',\n                 norm_sum,\n                 'values',\n                 annot=annot,\n                 annot_size=annot_size,\n                 precision=\".3g\",\n                 ax=ax_sum,\n                 xticklabels=x_tick_labels,\n                 yticklabels=y_tick_labels)\n    ax_heading.set_xlabel(\"CFM\")\n    ax_heading.set_ylabel(\"ERP\")\n\n    plt.show()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_147","text":"\n# coding: utf-8\n\n# In[1]:\n\n\ns = [15,17,13,20,19,17,25,10,18,40,21,35,11,25,30,29,35,34,25,18,27,45,36,22,28,38,46,47,24,11,14,16,27,61,52,33,35,48,16,27,26,48,51,50,60,62,54,58,25,27,35,42,47,45,55,38,70,61,47,44,34,36,35,61,65,70,53,54,54,56,47,11,21,22,24,53,52,53,70,62,61,21,18,11,21,18,27,24,25,26,22,12,11,22,23,33,35,41,18,11]\n\n\n# In[2]:\n\n\nlen(s)\n\n\n# In[3]:\n\n\ns.sort()\n\n\n# In[4]:\n\n\nprint(s)\n\n\n# In[5]:\n\n\nfrom collections import Counter\nfrom fractions import Fraction\nimport operator\nfrom matplotlib import pyplot as plt\nimport math\n\nd = Counter(s)\nd.keys()\n\n\n# In[7]:\n\n\nfor i in d.keys():\n    print('{0}, {2}, {1}'.format(d[i], i, Fraction(d[i], 100)))\n\n\n# In[8]:\n\n\nprint('Мода {0}, Медіана {1}, Розмах {2}'.format(max(d, key=d.get), (s[49]+s[50])\/2, s[99]-s[0]))\n\n\n# In[9]:\n\n\nplt.figure(figsize=(20, 10))\nplt.grid()\nplt.plot(d.keys(), d.values())\nplt.xticks(s)\n\n\n# In[10]:\n\nplt.figure(figsize=(20, 10))\nplt.bar(d.keys(), d.values())\nplt.xticks(s)\nplt.show(s)\n\n\n# In[21]:\n\n\ninterv = []\nsuma = 0\nt = 10\nfor i in range(20,90,10):\n    for j in d.keys():\n        if j < i and j >= t:\n            suma += d[j]\n    interv.append(((t,i),suma, Fraction(suma,100)))\n    suma = 0\n    t = i\n\n\n# In[22]:\n\n\ninterv\n\n\n# In[35]:\n\n\nser = 0\nfor i in d.keys():\n    ser += i*d[i]\n    \nprint('Середнє вибіркове {0}'.format(ser\/100))\n\n\n# In[36]:\n\n\nser = 0\nfor i in interv:\n    ser+=(i[0][1]+i[0][0])\/2 * i[1]\n\nser_int = ser\/100\nprint('Сер��днє вибіркове {0}'.format(ser_int))\n\n\n# In[47]:\n\n\ndispersion = 0\n\nfor i in interv:\n    dispersion += ((i[0][1]+i[0][0])\/2)**2 * i[1]\n\ndispersion \/= 100\n\ndispersion -= ser_int**2\n\nser_quad = math.sqrt(dispersion)\nprint('Дисперсія {0}, Середньоквадратичне відхилення {1}'.format(dispersion, ser_quad))\n\n\n# In[48]:\n\n\nprint('Коефіцієнт варіації {0}'.format(ser_quad\/ser_int))\n\n\n# In[49]:\n\n\nemp3 = 0\nemp4 = 0\n\nfor i in interv:\n    emp3 += ((i[0][1]+i[0][0])\/2 - ser_int)**3 * i[1]\n    emp4 += ((i[0][1]+i[0][0])\/2 - ser_int)**4 * i[1]\n\nemp3 \/= 100\nemp4 \/= 100\n\nprint('Центральні емпіричні моменти 3-го {0} і 4-го порядків {1}'.format(emp3, emp4))\n\n\n# In[50]:\n\n\nprint('Асиметрія {0} і Ексцес {1}'.format(emp3\/(ser_quad**3), emp4\/(ser_quad**4)-3))\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_148","text":"#!\/usr\/bin\/env python3\nimport os\nimport time\nimport timeit\nimport numpy as np\nfrom numba import njit\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import bisect\nimport pandas as pd\n\ndef main():\n    \"\"\"\n    goal: define a new operation on a 2d numpy ndarray of waveforms\n    \"\"\"\n    # example_1()\n    # example_2()\n    example_3()\n\n\ndef run_timer(stmt, setup=None, rpt=5, num=50000, verbose=False):\n    \"\"\"\n    similar to ipython's timeit magic for an arbitrary line of code in a script\n    \"\"\"\n    tot = min(timeit.Timer(stmt, globals=globals()).repeat(rpt, num))\n    rate = tot\/num\/1e-9\n    print(\"{:.0f} ns per call  (manual timer)\".format(rate))\n    return rate\n\n# ==============================================================================\n\ndef example_1():\n    \"\"\"\n    an example of a loop operation calling a kernel function (maybe a log-likelihood fit).\n    let's bisect a function f(x) and find its roots, comparing speed of\n    scipy.optimize.bisect and a manual implementation using Numba\n    \"\"\"\n    # scipy\n    x0, f = bisect(python_func, a=-0.5, b=50., full_output=True)\n    print(f)\n    t1 = run_timer('bisect(kernel_func, a=-.5, b=50.)')\n\n    # numba\n    numba_bisect(a=-0.5, b=50.)\n    t2 = run_timer('numba_bisect(a=0.5, b=50.)')\n\n    # summary\n    print(\"scipy: {:.1e}  numba {:.1e}\".format(t1, t2))\n\n\ndef python_func(x):\n    \"\"\"\n    this is just to comapre against the numba version\n    \"\"\"\n    return x**4 - 2*x**2 - x - 3\n\n\n@njit\ndef kernel_func(x):\n    \"\"\"\n    arbitrary function goes here\n    \"\"\"\n    return x**4 - 2*x**2 - x - 3\n\n\n@njit\ndef numba_bisect(a, b, tol=1e-8, mxiter=500):\n    \"\"\"\n    arbitrary loop operation goes here\n    \"\"\"\n    its = 0\n    fa, fb = kernel_func(a), kernel_func(b)\n    if abs(fa) < tol:\n        return a\n    elif abs(fb) < tol:\n        return b\n    c = (a+b)\/2.\n    fc = kernel_func(c)\n    while abs(fc)>tol and its<mxiter:\n        its = its + 1\n        if fa*fc < 0:\n            b, fb = c, fc\n        else:\n            a, fa = c, fc\n        c = (a+b)\/2.\n        fc = kernel_func(c)\n    return c\n\n# ==============================================================================\n\ndef example_2():\n    \"\"\"\n    try the fractal generation program from the numba documentation\n    https:\/\/numba.pydata.org\/numba-doc\/dev\/user\/examples.html\n    \"\"\"\n    image = np.zeros((500 * 2, 750 * 2), dtype=np.uint8)\n    t_start = time.time()\n\n    # this is a loop-based computation on a 2d numpy array\n    create_fractal(image, -2.0, 1.0, -1.0, 1.0, 20)\n\n    print(\"elapsed: {:.2e} sec\".format(time.time()-t_start))\n    plt.imshow(image)\n    plt.show()\n\n\n@njit\ndef mandel(x, y, max_iters):\n    \"\"\"\n    given the real and imaginary parts of a complex number,\n    determine if it is a candidate for membership in the Mandelbrot\n    set given a fixed number of iterations.\n    \"\"\"\n    i = 0\n    c = complex(x,y)\n    z = 0.0j\n    for i in range(max_iters):\n        z = z*z + c\n        if (z.real*z.real + z.imag*z.imag) >= 4:\n            return i\n    return 255\n\n\n@njit\ndef create_fractal(image, min_x, max_x, min_y, max_y, iters):\n    \"\"\"\n    do a calculation on the input array\n    \"\"\"\n    height = image.shape[0]\n    width = image.shape[1]\n    pixel_size_x = (max_x - min_x) \/ width\n    pixel_size_y = (max_y - min_y) \/ height\n    for x in range(width):\n        real = min_x + x * pixel_size_x\n        for y in range(height):\n            imag = min_y + y * pixel_size_y\n            color = mandel(real, imag, iters)\n            image[y, x] = color\n    return image\n\n# ==============================================================================\n\ndef example_3():\n    \"\"\"\n    read in some waveforms from a Tier 2 file and find the mean or something\n    \"\"\"\n    t1_file = os.path.expandvars(\"~\/Data\/MJ60\/pygama\/t1_run204.h5\")\n    # with pd.HDFStore(t1_file, 'r') as store:\n    #     print(store.keys())\n\n    key = \"\/ORSIS3302DecoderForEnergy\"\n    chunk = pd.read_hdf(t1_file, key, where=\"ievt < {}\".format(1000))\n    chunk.reset_index(inplace=True) # required step -- fix pygama \"append\" bug\n\n    # create waveform block.  todo: mask wfs of unequal lengths\n    icols = []\n    for idx, col in enumerate(chunk.columns):\n        if isinstance(col, int):\n            icols.append(col)\n    wfs = chunk[icols].values\n    # print(wfs.shape, type(wfs))\n\n    # use pygama DSP functions on the wf block.\n    # requires:\n    # - 'waves': a dict of (nwfs, nsamp) ndarrays,\n    # - 'calcs': a pd.DataFrame, and a clock freq\n    rise, flat = 4, 1.8\n    waves = {\"waveform\":wfs, \"settings\":{\"clk\":100e6}}\n    calcs = pd.DataFrame()\n    avg_bl(waves, calcs)\n    # waves[\"wf_blsub\"] = blsub(waves, calcs)[\"wf_blsub\"]\n    # waves[\"wf_trap\"] = trap(waves, calcs, rise, flat)[\"wf_trap\"]\n\n    # print(calcs)\n\n@njit\ndef avg_bl(waves, calcs, ilo=0, ihi=500, wfin=\"waveform\", calc=\"bl_p0\", test=False):\n    \"\"\"\n    simple mean, vectorized baseline calculator\n    \"\"\"\n    wfs = waves[\"waveform\"]\n\n    # find wf means\n    avgs = np.mean(wfs[:, ilo:ihi], axis=1)\n\n    # add the result as a new column\n    calcs[calc] = avgs\n\n\nif __name__==\"__main__\":\n    main()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_149","text":"import os\nimport pandas as pd, numpy as np\nfrom sklearn.metrics import r2_score, mean_squared_error, auc\nfrom scipy.stats import pearsonr\nfrom itertools import chain\nfrom glob import glob\nimport pdb\n\n\n\ndef score(mols, nn, return_mse=False):\n    r2=r2_score(mols,nn)\n    rmse=(mean_squared_error(mols, nn, squared=False))\/(max(mols)-min(mols))\n    mse=mean_squared_error(mols, nn, squared=True)\n    auc_diff=((auc(np.arange(len(mols)),mols)-auc(np.arange(len(nn)),nn))\/auc(np.arange(len(mols)),mols))\n    pearson=pearsonr(mols,nn)\n    return (max(0,r2), rmse, auc_diff, pearson[0], mse) if return_mse==True else (max(0,r2), rmse, auc_diff, pearson[0])\n\n\ndef gen_perf_metrics(data,seasonal=False,exception=[]):\n    groups=data.groupby(['County','Year'])\n    r2s,rmses,auc_diffs,pearsons=list(),list(),list(),list()\n    probs=list()\n    for group in groups:\n        if group[0] not in exception:\n            mols=group[1][\"MoLS\"]\n            nn=group[1][\"Neural Network\"]\n            r2,rmse,auc_diff,pearson=score(mols,nn)\n            r2s.append(r2)\n            rmses.append(rmse)\n            auc_diffs.append(auc_diff)\n            pearsons.append(pearson)\n    r2s=np.asarray(r2s)\n    r2s = r2s[np.isfinite(r2s)]\n    rmses=np.asarray(rmses)\n    rmses = rmses[np.isfinite(rmses)]\n    auc_diffs=np.asarray(auc_diffs)\n    auc_diffs = auc_diffs[np.isfinite(auc_diffs)]\n    pearsons=np.asarray(pearsons)\n    pearsons = pearsons[np.isfinite(pearsons)]\n    to_return=[np.mean(r2s), np.std(r2s), np.mean(rmses), np.std(rmses),\n               np.mean((auc_diffs)), np.std((auc_diffs)), np.mean(pearsons), np.std(pearsons)]\n    return to_return\n\ndef gen_county_perf_metrics(data,seasonal=False,exception=[]):\n    groups=data.groupby(['County','Year'])\n    r2s,rmses,auc_diffs,pearsons=list(),list(),list(),list()\n    counties,yrs=list(),list()\n    for group in groups:\n        if group[0] not in exception:\n            mols=group[1][\"MoLS\"]\n            nn=group[1][\"Neural Network\"]\n            r2,rmse,auc_diff,pearson=score(mols,nn)\n            if (np.isfinite(r2) & np.isfinite(rmse) & np.isfinite(auc_diff) & np.isfinite(pearson)):\n                r2s.append(r2)            \n                rmses.append(rmse)\n                auc_diffs.append(auc_diff)\n                pearsons.append(pearson)\n                counties.append(group[0][0])\n                yrs.append(group[0][1])\n    results=pd.DataFrame()\n    results[\"Counties\"]=np.asarray(counties)\n    results[\"Year\"]=np.asarray(yrs)\n    results[\"R2\"]=np.asarray(r2s)\n    results[\"RMSE\"]=np.asarray(rmses)\n    results[\"AUC_Diff\"]=np.asarray(auc_diffs)\n    results[\"Pearson\"]=np.asarray(pearsons)\n    return results\n    \n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_150","text":"<filename>examples\/dielectric\/broad_dielectric_box_charging.py\n# # Dielectric charging script development and testing\n# \n# **7\/18\/2017**\n# \n# This notebook will develop and troubleshoot scripts for testing dielectric charging from electron impact.\n# \n# 1. Simple geometry (fast) - 1 micron x 1 micron (z). 100 x 100 grid\n# 2. Rectangular dielectric - 500 nm x 100 nm (z). Centered transversely, closer to anode along z.\n# 3. Uniform parallel emission -> 20 particles, user-injected,no transverse velocity, clustered about central axis.\n# \n# <NAME>\n\nfrom __future__ import division\nimport sys\ndel sys.argv[1:] #  Necessry to run 'from warp import *' in IPython notebook without conflict.\nfrom warp import * \nimport numpy as np\nimport matplotlib as mpl\nmpl.use('TkAgg')\nimport matplotlib.pyplot as plt\nimport os\nimport pickle\nimport h5py\nfrom re import findall\nfrom scipy.special import erfinv\nfrom datetime import datetime\n\nimport rswarp\nfrom warp.data_dumping.openpmd_diag import ParticleDiagnostic\nfrom rswarp.diagnostics import FieldDiagnostic\nfrom rswarp.utilities.file_utils import cleanupPrevious\nfrom rswarp.utilities.file_utils import readparticles\nfrom rswarp.utilities.file_utils import loadparticlefiles\nfrom rswarp.cathode import sources\nfrom rswarp.cathode import injectors\nfrom warp.particles.singleparticle import TraceParticle\n\nimport matplotlib.lines as mlines\nimport matplotlib.patches as patches\n\n# Constants imports\nfrom scipy.constants import e, m_e, c, k\nkb_eV = 8.6173324e-5 #Bolztmann constant in eV\/K\nkb_J = k #Boltzmann constant in J\/K\nm = m_e\n\n\ndiagDir = 'diags\/xzsolver\/hdf5\/'\nfield_base_path = 'diags\/fields\/'\ndiagFDir = {'magnetic':'diags\/fields\/magnetic','electric':'diags\/fields\/electric'}\n\n# Cleanup previous files\ncleanupPrevious(diagDir,diagFDir)\n\n\n### Grid parameters, Solver, and Boundaries\nepsn = 7.\n\nif comm_world.size != 1:\n    synchronizeQueuedOutput_mpi4py(out=False, error=False)\n\nprint \"rank:\", comm_world.rank\n\ntop.inject = 0 \ntop.npinject = 0\n\n#Dimensions\n\nPLATE_SPACING = 1.e-6 #plate spacing\nCHANNEL_WIDTH = 1e-6 #width of simulation box\n\nX_MAX = CHANNEL_WIDTH*0.5\nX_MIN = -1.*X_MAX\nY_MAX = CHANNEL_WIDTH*0.5\nY_MIN = -1.*Y_MAX\nZ_MIN = 0.\nZ_MAX = PLATE_SPACING\n\n\n#Grid parameters\nNUM_X = 100 #256-1#64-1\nNUM_Z = 100 #256-1#64-1\n\n# # Solver Geometry\n\nw3d.solvergeom = w3d.XZgeom\n\n\n# Set boundary conditions\nw3d.bound0  = dirichlet\nw3d.boundnz = dirichlet\nw3d.boundxy = periodic \n\n\n# Set grid boundaries\nw3d.xmmin = X_MIN\nw3d.xmmax = X_MAX\nw3d.zmmin = 0. \nw3d.zmmax = Z_MAX\n\nw3d.nx = NUM_X\nw3d.nz = NUM_Z\n\nw3d.dx = (w3d.xmmax-w3d.xmmin)\/w3d.nx\nw3d.dz = (w3d.zmmax-w3d.zmmin)\/w3d.nz\n\nzmesh = np.linspace(0,Z_MAX,NUM_Z+1) #holds the z-axis grid points in an array\n\nANODE_VOLTAGE = 10.\nCATHODE_VOLTAGE = 0.\nvacuum_level = ANODE_VOLTAGE - CATHODE_VOLTAGE\nbeam_beta = 5e-4\n#Determine an appropriate time step based upon estimated final velocity\nvzfinal = sqrt(2.*abs(vacuum_level)*np.abs(e)\/m_e)+beam_beta*c\ndt = w3d.dz\/vzfinal #5e-15\ntop.dt = 0.1*dt\n\nif vzfinal*top.dt > w3d.dz:\n    print \"Time step dt = {:.3e}s does not constrain motion to a single cell\".format(top.dt)\n\n\n#### Set up field solver\n\ntop.depos_order = 1\nf3d.mgtol = 1e-6 # Multigrid solver convergence tolerance, in volts. 1 uV is default in Warp.\nsolverE = MultiGrid2DDielectric()\nregistersolver(solverE)\n\n\n#### Define conductors and dielectrics using new wrapper\n\nsource = ZPlane(zcent=w3d.zmmin+0*w3d.dz,zsign=-1.,voltage=CATHODE_VOLTAGE)\nsolverE.installconductor(source, dfill=largepos)\n\nplate = ZPlane(voltage=ANODE_VOLTAGE, zcent=Z_MAX-0.*w3d.dz)\nsolverE.installconductor(plate,dfill=largepos)\n\n\nbox = Box(xsize=0.5*(w3d.xmmax-w3d.xmmin),\n          ysize=0.5*(w3d.ymmax-w3d.ymmin),\n          zsize=0.1*(w3d.zmmax-w3d.zmmin),\n          xcent=0.5*(w3d.xmmax+w3d.xmmin),\n          ycent=0.5*(w3d.ymmax+w3d.ymmin),\n          zcent=0.8*(w3d.zmmax+w3d.zmmin),\n          permittivity=epsn)\n\nsolverE.installconductor(box,dfill=largepos)\n\n\n### Diagnostics\n\nparticleperiod = 100\nparticle_diagnostic_0 = ParticleDiagnostic(period = particleperiod, top = top, w3d = w3d,\n                                          species = {species.name: species for species in listofallspecies},\n                                          comm_world=comm_world, lparallel_output=False, write_dir = diagDir[:-5])\nfieldperiod = 100\nefield_diagnostic_0 = FieldDiagnostic.ElectrostaticFields(solver=solverE, top=top, w3d=w3d, comm_world = comm_world,\n                                                          period=fieldperiod)\n\ninstallafterstep(particle_diagnostic_0.write)\ninstallafterstep(efield_diagnostic_0.write)\n\n\n### Generate and Run\n\n#Generate PIC code and Run Simulation\nsolverE.mgmaxiters = 1\n\n#prevent GIST from starting upon setup\ntop.lprntpara = false\ntop.lpsplots = false\ntop.verbosity = 0 \n\nsolverE.mgmaxiters = 10000 #rough approximation needed for initial solve to converge\npackage(\"w3d\")\ngenerate()\nsolverE.mgmaxiters = 100\n\n\n#Need to compute the fields first\nepsilon_array = solverE.epsilon\/eps0\n\n#Now plot\nfig = plt.figure(figsize=(12,6))\n\nX_CELLS = NUM_X\nZ_CELLS = NUM_Z\n\nxl = 0\nxu = NUM_X\nzl = 0 \nzu = NUM_Z \n\nplt.xlabel(\"z ($\\mu$m)\")\nplt.ylabel(\"x ($\\mu$m)\")\nplt.title(r\"$\\kappa$ across domain - with box\")\n\npxmin = ((X_MAX - X_MIN) \/ X_CELLS * xl + X_MIN) * 1e6\npxmax = ((X_MAX - X_MIN) \/ X_CELLS * xu + X_MIN) * 1e6\npzmin = (Z_MIN + zl \/ Z_CELLS * Z_MAX) * 1e6\npzmax = (Z_MAX * zu \/ Z_CELLS) * 1e6\n\nplt.xlim(pzmin, pzmax)\nplt.ylim(pxmin, pxmax)\n\neps_plt = plt.imshow(epsilon_array[xl:xu,zl:zu],cmap='viridis',extent=[pzmin, pzmax, pxmin, pxmax],aspect='auto')\n\ncbar = fig.colorbar(eps_plt)\ncbar.ax.set_xlabel(r\"$\\kappa$\")\ncbar.ax.xaxis.set_label_position('top')\n\nplt.savefig('eps_broad_box.png',bbox_inches='tight')\n\n\n#### Specify emission\n\nelectrons_tracked_t0 = Species(type=Electron, weight=1.0)\nntrack = 20\nZ_PART_MIN = w3d.dz\/8 #Add a minimum z coordinate to prevent absorption\n\n# Uniform velocity used for all particles\nx_vals = np.arange(-0.25*CHANNEL_WIDTH,0.25*CHANNEL_WIDTH,0.5*CHANNEL_WIDTH \/ ntrack)\ny_vals = CHANNEL_WIDTH*(np.random.rand(ntrack)-0.5)\nz_vals = np.zeros(ntrack) + Z_PART_MIN #Add a minimum z coordinate to prevent absorption\n\nvx_vals = np.zeros(ntrack)\nvy_vals = np.zeros(ntrack)\nvz_vals = beam_beta*clight*np.ones(ntrack) #beta = 0.0005\n\neptclArray = np.asarray([x_vals,vx_vals,y_vals,vy_vals,z_vals,vz_vals]).T\n\nelectron_tracker_0 = TraceParticle(js=electrons_tracked_t0.jslist[0],\n                     x=x_vals,\n                     y=y_vals,\n                     z=z_vals,\n                     vx=vx_vals,\n                     vy=vy_vals,\n                     vz=vz_vals)\n\n\nnum_steps = 2000\nstep(num_steps)\n\nprint solverE.getselfe().shape\nprint getselfe('z').shape\nzfield = getselfe('z')\nif comm_world.size > 1:\n\tif comm_world.rank == 0:\n\t\tnp.save('diel_para.npy',zfield)\nelif comm_world.size == 1:\n\tnp.save('diel_ser.npy',zfield)\n\n\n\n### Plot particle trajectories\n\ndef particle_trace(trace,ntrack):\n    kept_electronsx = []\n    kept_electronsz = []\n    lost_electronsx = []\n    lost_electronsz = []\n    for electron in range(ntrack):\n        for step in range(len(trace.getx(i=electron)) - 1):\n            if abs(trace.getx(i=electron)[step] - \n                   trace.getx(i=electron)[step + 1]) > (X_MAX - X_MIN) \/ 2.:\n                lost_electronsx.append(trace.getx(i=electron)[0:step])\n                lost_electronsz.append(trace.getz(i=electron)[0:step])\n                break\n            if step == (len(trace.getx(i=electron)) - 2):\n                kept_electronsx.append(trace.getx(i=electron))\n                kept_electronsz.append(trace.getz(i=electron))\n    return [kept_electronsx,kept_electronsz], [lost_electronsx,lost_electronsz]\n\nkept_electrons, lost_electrons = particle_trace(electron_tracker_0,ntrack)\n\ncond_list = solverE.conductordatalist\n\nfig = plt.figure(figsize=(12,6))\nplt.title(\"Broad Dielectric Particle Trace\")\n\nscale = 1e6\n\nax2 = plt.subplot(111)\n\nsteps2cross = 1900 #computed # of steps to cross\n\ncond_list = solverE.conductordatalist\nfor cond in cond_list[2:]: #ignore first two conductors - these are the plates\n    co = cond[0]\n    specs = co.getkwlist()\n    xw = specs[0] #x-dimension (y in plot)\n    xc = specs[3] #center\n    xll = xc - xw\/2. #lower left\n    zw = specs[2] #z-dimension (x in plot)\n    zc = specs[-1] #center\n    zll = zc - zw\/2. #lower left\n\n    \n    ax2.add_patch(\n        patches.Rectangle(\n            (zll * scale, xll * scale),\n            zw * scale,\n            xw * scale,\n            facecolor=\"grey\",\n            edgecolor=\"grey\"  \n        )\n    )\n\nax1 = plt.subplot(111)\nkept_electrons, lost_electrons = particle_trace(electron_tracker_0,ntrack)\n\nfor i in range(len(kept_electrons[1])):\n    ax1.plot(kept_electrons[1][i][:steps2cross] * scale,kept_electrons[0][i][:steps2cross] * scale, c = '#1f77b4')\n\nfor i in range(len(lost_electrons[1])):\n    ax1.plot(lost_electrons[1][i][:steps2cross] * scale,lost_electrons[0][i][:steps2cross] * scale, c = '#2ca02c')\n\n\nkept = mlines.Line2D([], [], color='#1f77b4',label='Absorbed Particles')\nlost = mlines.Line2D([], [], color='#2ca02c',label='Reflected Particles')\n\nbox = ax1.get_position()\nax1.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n\nplt.xlim(Z_MIN * scale,Z_MAX * scale)\nplt.ylim(X_MIN * scale, X_MAX * scale)\nplt.legend(handles=[kept, lost],loc='best', bbox_to_anchor=(1, 1))\nplt.xlabel('z ($\\mu$m)')\nplt.ylabel('x ($\\mu$m)')\nplt.savefig('broad_dielectric_trace.png')\nplt.show()\n\n\n\n### Plot fields\n\n#Need to compute the fields first\nfieldEz = solverE.getez()\n\n#Now plot\nfig = plt.figure(figsize=(12,6))\n\nX_CELLS = NUM_X\nZ_CELLS = NUM_Z\n\nxl = 0\nxu = NUM_X\nzl = 0 \nzu = NUM_Z \n\nplt.xlabel(\"z ($\\mu$m)\")\nplt.ylabel(\"x ($\\mu$m)\")\nplt.title(\"$E_z$ across domain - with box\")\n\npxmin = ((X_MAX - X_MIN) \/ X_CELLS * xl + X_MIN) * 1e6\npxmax = ((X_MAX - X_MIN) \/ X_CELLS * xu + X_MIN) * 1e6\npzmin = (Z_MIN + zl \/ Z_CELLS * Z_MAX) * 1e6\npzmax = (Z_MAX * zu \/ Z_CELLS) * 1e6\n\nplt.xlim(pzmin, pzmax)\nplt.ylim(pxmin, pxmax)\n\nez_plt = plt.imshow(fieldEz[xl:xu,zl:zu],cmap='viridis',extent=[pzmin, pzmax, pxmin, pxmax],aspect='auto')\n\ncbar = fig.colorbar(ez_plt)\ncbar.ax.set_xlabel(\"V\/m\")\ncbar.ax.xaxis.set_label_position('top')\n\nplt.savefig('Ez_broad_box.png',bbox_inches='tight')\nplt.close()\n\n#Need to compute the fields first\nfieldEx = solverE.getex()\n\nExr = fieldEx[::-1]\n\n#Now plot\nfig = plt.figure(figsize=(12,6))\n\nX_CELLS = NUM_X\nZ_CELLS = NUM_Z\n\nxl = 0\nxu = NUM_X\nzl = 0 \nzu = NUM_Z \n\nplt.xlabel(\"z ($\\mu$m)\")\nplt.ylabel(\"x ($\\mu$m)\")\nplt.title(\"$E_x$ across domain - with box\")\n\npxmin = ((X_MAX - X_MIN) \/ X_CELLS * xl + X_MIN) * 1e6\npxmax = ((X_MAX - X_MIN) \/ X_CELLS * xu + X_MIN) * 1e6\npzmin = (Z_MIN + zl \/ Z_CELLS * Z_MAX) * 1e6\npzmax = (Z_MAX * zu \/ Z_CELLS) * 1e6\n\nplt.xlim(pzmin, pzmax)\nplt.ylim(pxmin, pxmax)\n\nex_plt = plt.imshow(Exr[xl:xu,zl:zu],cmap='viridis',extent=[pzmin, pzmax, pxmin, pxmax],aspect='auto')\n\n\ncbar = fig.colorbar(ex_plt)\ncbar.ax.set_xlabel(\"V\/m\")\ncbar.ax.xaxis.set_label_position('top')\n\nplt.savefig('Ex_broad_box.png',bbox_inches='tight')\nplt.close()\n\n\n#### Plot potential\n\n#Need to compute the potential first\npotential = solverE.getphi()\n\n#Now plot\nfig = plt.figure(figsize=(12,6))\n\nX_CELLS = NUM_X\nZ_CELLS = NUM_Z\n\npotential = solverE.getphi()\n\nxl = 0\nxu = NUM_X\nzl = 0 \nzu = NUM_Z \n\nplt.xlabel(\"z ($\\mu$m)\")\nplt.ylabel(\"x ($\\mu$m)\")\nplt.title(\"$\\phi$ across domain -with box\")\n\npxmin = ((X_MAX - X_MIN) \/ X_CELLS * xl + X_MIN) * 1e6\npxmax = ((X_MAX - X_MIN) \/ X_CELLS * xu + X_MIN) * 1e6\npzmin = (Z_MIN + zl \/ Z_CELLS * Z_MAX) * 1e6\npzmax = (Z_MAX * zu \/ Z_CELLS) * 1e6\n\nplt.xlim(pzmin, pzmax)\nplt.ylim(pxmin, pxmax)\n\nphi_plt = plt.imshow(potential[xl:xu,zl:zu],cmap='RdBu',extent=[pzmin, pzmax, pxmin, pxmax],aspect='auto')\n\ncbar = fig.colorbar(phi_plt)\ncbar.ax.set_xlabel(\"Volts\")\ncbar.ax.xaxis.set_label_position('top')\n\nplt.savefig('phi_broad_box.png',bbox_inches='tight')\nplt.close()\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_151","text":"import csv, json, argparse, copy, re, os, urllib2\n\nimport numpy as np\nfrom scipy.spatial import distance\nfrom sklearn import manifold, metrics, decomposition, preprocessing\n\nimport igraph\n\nimport jsmin\n\nimport rdkit\nfrom rdkit import Chem, DataStructs, Geometry\nfrom rdkit.DataStructs import cDataStructs\nfrom rdkit.Chem import Draw, AllChem, Scaffolds, Lipinski, Crippen, rdMolDescriptors, TemplateAlign\nfrom rdkit.Chem.Scaffolds import MurckoScaffold\n\nPROPS_ORDER = [\"mw\", \"hba\", \"hbd\", \"rb\", \"rc\", \"arc\", \"logp\", \"tpsa\"]\n        \nPROP2FNC = {\n    \"mw\": rdMolDescriptors.CalcExactMolWt,\n    \"hba\": Lipinski.NumHAcceptors,\n    \"hbd\": Lipinski.NumHDonors,\n    \"rb\": Lipinski.NumRotatableBonds,\n    \"rc\": Lipinski.RingCount,\n    \"arc\": Lipinski.NumAromaticRings,\n    \"logp\": Crippen.MolLogP, \n    \"tpsa\": rdMolDescriptors.CalcTPSA,\n}\n\nPROP2LABEL = {\n    \"mw\": \"Molecular weight\",\n    \"hba\": \"H-bond acceptors\",\n    \"hbd\": \"H-bond donors\",\n    \"rb\": \"Rotatable bonds\",\n    \"rc\": \"Rings\",\n    \"arc\": \"Aromatic rings\",\n    \"logp\": \"cLogP\",\n    \"tpsa\": \"TPSA\"\n}\n\nFP2FNC = {\n    \"ecfp4\": lambda rdmol: AllChem.GetMorganFingerprintAsBitVect(rdmol, radius=2, nBits=1024),\n    \"ecfp6\": lambda rdmol: AllChem.GetMorganFingerprintAsBitVect(rdmol, radius=3, nBits=1024),\n    \"apfp\": lambda rdmol: AllChem.GetHashedAtomPairFingerprintAsBitVect(rdmol, nBits=1024),\n    \"ttfp\": lambda rdmol: AllChem.GetHashedTopologicalTorsionFingerprintAsBitVect(rdmol, nBits=1024),\n    \"maccs\": lambda rdmol: AllChem.GetMACCSKeysFingerprint(rdmol),\n}\n\nAVAILABLE_METRICS = [\"Tanimoto\", \"Dice\", \"Cosine\", \"Sokal\", \"Russel\", \"RogotGoldberg\", \"AllBit\", \"Kulczynski\", \"McConnaughey\", \"Asymmetric\", \"BraunBlanquet\"]\n\nclass ChemSpace():\n\n    def __init__(self):\n        self.category_field = False\n        self.category_field_delimiter = False\n        self.label_field = False\n        self.compound_structure_field = False\n        self.sdf = False\n        self.write_structures = True\n        self.fp = \"ecfp4\"\n        self.fingerprint_field = False\n        self.metric = \"Tanimoto\"\n\n        if self.metric not in AVAILABLE_METRICS:\n            raise Exception(\"Metric '{}' not found in available similarity metrics: {}\".format(self.metric, AVAILABLE_METRICS))\n\n        self.index2rdmol = {}\n        self.index2fpobj = {}\n\n    def read_csv(self, filename, delimiter=\",\", header=False, missing_value=False, remove_columns=False):\n        \"\"\"Reads data from the CSV file\"\"\"\n        print(\"Reading file: {}\".format(filename))\n\n        self.filename = filename\n        with open(self.filename, \"r\") as input_file:\n            reader = csv.reader(input_file, delimiter=delimiter)\n            rows = [row for row in reader]\n        \n        self.read_data(rows, header, missing_value, remove_columns)\n\n    def read_sdf(self, filename):\n        \"\"\"Reads data from a sdf file\"\"\"\n        print(\"Reading file: {}\".format(filename))\n        self.sdf = True\n        self.header = False\n        self.data = []\n        self.filename = filename\n        self.index2rdmol = {}\n        self.index2fpobj = {}\n        self.index2props = {}\n        self.index2category = {}\n        self.index2label = {}\n        self.index2id = {}\n\n        molsupplier = Chem.SDMolSupplier(str(filename))\n        not_parsed = []\n\n        for index, m in enumerate(molsupplier):\n            try:\n                Chem.SanitizeMol(m)\n                self.index2rdmol[index] = m\n                self.index2fpobj[index] = FP2FNC[self.fp](m)\n                self.index2props[index] = m.GetPropsAsDict()\n                self.index2id[index] = index\n\n            except Exception, e:\n                print(e)\n                not_parsed.append(index)\n\n        self.index_order = self.index2rdmol.keys()\n        self.index_order.sort()\n        self.index2row = {i: [] for i in self.index_order}\n        self.data = self.index2row.values()\n\n        if self.label_field is not False and self.label_field in self.index2props[self.index_order[0]]:\n            self.index2label = {i: self.index2props[i].get(self.label_field) for i in self.index_order}\n\n        if self.category_field is not False and self.category_field in self.index2props[self.index_order[0]]:\n            self.index2category = {i: self.index2props[i].get(self.category_field) for i in self.index_order}\n\n        self.__create_chemspace_format__()\n\n    def add_compounds_from_file(self, filename, delimiter=\",\"):\n        print(\"Reading compounds: {}\".format(filename))\n        self.filename = filename\n\n        with open(self.filename, \"r\") as input_file:\n            reader = csv.reader(input_file, delimiter=delimiter)\n            rows = [row for row in reader]\n\n        self.add_compounds(rows)\n\n    def add_category(self, category):\n        if not \"categories\" in self.chemical_space:\n            self.chemical_space[\"categories\"] = []\n\n        self.chemical_space[\"categories\"].append(category)\n\n\n    def add_compounds(self, rows):\n        \"\"\"Reads data in a form of list of lists (tuples)\"\"\"\n        self.compounds = {r[0]: r[1] for r in rows}\n        self.chemical_space[\"compounds\"] = {}\n        self.__parse_compounds__()\n\n        for key in self.chemical_space[\"points\"]:\n            if key in self.id2rdmol:\n                self.chemical_space[\"compounds\"][key] = {\"structure\": self.__get_compound__(key)}\n\n    def read_data(self, rows, header=False, missing_value=False, remove_columns=False):\n        \"\"\"Reads data in a form of list of lists (tuples)\"\"\"\n        self.header = header\n        self.missing_value = missing_value\n        data_start = 0\n\n        self.data = rows\n        self.index2id = {}\n        self.index2row = {}\n        self.index2compound = {}\n        self.index2label = {}\n        self.index2category = {}\n\n        if self.header:\n            self.header = self.data[0]\n            self.data = self.data[1:]\n\n        if self.header:\n            if remove_columns is not False and len(remove_columns) > 0:\n                for col in remove_columns:\n                    self.__remove_field__(col)\n\n            if self.compound_structure_field and self.compound_structure_field in self.header:\n                self.index2compound = self.__extract_field__(self.compound_structure_field)\n                self.__read_compounds__()\n\n            if self.label_field and self.label_field in self.header:\n                self.index2label = self.__extract_field__(self.label_field)\n\n            if self.category_field and self.category_field in self.header:\n                self.index2category = self.__extract_field__(self.category_field)\n\n            if self.fingerprint_field and self.fingerprint_field in self.header:\n                self.index2fp = self.__extract_field__(self.fingerprint_field)\n                self.index2fpobj = {}\n\n                for index, fp in self.index2fp.items():\n                    self.index2fpobj[index] = self.__get_bitvect_for_fp__(fp)\n\n            # remove ID field\n            self.header.pop(0)\n\n        self.index2id = {i: row[0] for i, row in enumerate(self.data)}\n        self.index2row = {i: [round(float(v), 2) if v not in [\"\", None, \"None\", self.missing_value] else None for v in row[1:]] for i, row in enumerate(self.data)}\n        self.index_order = [i for i, row in enumerate(self.data)]\n        self.data = [self.index2row[i] for i in self.index_order]\n        \n        if self.missing_value is not False:\n            self.data, self.missing_values_indexes = self.__impute_missing_values__(self.data)\n            # self.original_data = self.__return_missing_values__(copy.deepcopy(self.data), self.missing_values_indexes)\n\n        # self.original_data = copy.deepcopy(self.index2row)        \n        self.__create_chemspace_format__()\n\n    def __read_compounds__(self):\n        for i, smi in self.index2compound.items():\n            try:\n                self.index2rdmol[i] = Chem.MolFromSmiles(smi)\n                self.index2fpobj[i] = FP2FNC[self.fp](self.index2rdmol[i])\n\n            except Exception, e:\n                print(e)\n                self.index2rdmol[i] = None\n                self.index2fpobj[i] = None\n\n    def __remove_field__(self, field):\n        if field in self.header:\n            index = self.header.index(field)\n\n            if index is not False:\n                self.header.pop(index)\n\n                for i, row in enumerate(self.data):\n                    self.data[i].pop(index)\n\n    def __extract_field__(self, field):\n        index2value = {}\n\n        if field in self.header:\n            index = self.header.index(field)\n\n            if index is not False:\n                self.header.pop(index)\n\n                for i, row in enumerate(self.data):\n                    index2value[i] = row[index]\n                    self.data[i].pop(index)\n\n        return index2value\n\n    def __impute_missing_values__(self, data):\n        datatype2impute = {\"numeric\": {\"strategy\":\"mean\", \n                                        \"value\": lambda x: round(float(value), 3)}, \n                           \"binary\": {\"strategy\":\"most_frequent\", \n                                      \"value\": lambda x: int(value)}\n                           }\n\n        missing_values_indexes = []\n        \n        for i, row in enumerate(self.data):\n            missing_values_indexes.append([j for j, v in enumerate(row) if v == self.missing_value])\n\n            for j, value in enumerate(row):\n                if value == self.missing_value:\n                    data[i][j] = np.nan\n        imputer = preprocessing.Imputer(missing_values=\"NaN\", strategy=datatype2impute[\"numeric\"][\"strategy\"])\n        #error when using median strategy - minus one dimension in imputed data... omg\n        imputed_data = [list(row) for row in imputer.fit_transform(self.data)]\n        imputed_data = [[datatype2impute[\"numeric\"][\"value\"](value) for value in row] for row in imputed_data]\n        return imputed_data, missing_values_indexes\n\n    def __return_missing_values__(self, data, missing_values_indexes):\n        for i, indexes in enumerate(missing_values_indexes):\n            if indexes:\n                for index in indexes:\n                    data[i][index] = None\n        return data\n\n    def __create_chemspace_format__(self):\n        self.chemical_space = {\"points\": {}}\n\n        for index in self.index_order:\n            self.chemical_space[\"points\"][index] = {\"object_ids\": [self.index2id[index]]}\n\n        if len(self.index2category):\n            self.__parse_categories__()\n\n        if len(self.index2label):\n            for index, label in self.index2label.items():\n                self.chemical_space[\"points\"][index][\"label\"] = label\n        \n        for index, row in self.index2row.items():\n            self.chemical_space[\"points\"][index][\"features\"] = copy.copy(row)\n\n        if self.header:\n            current_header = self.chemical_space.get(\"feature_names\", [])\n            current_header.extend(self.header)\n            self.chemical_space[\"feature_names\"] = current_header\n\n        if len(self.index2rdmol) and self.write_structures:\n            self.chemical_space[\"compounds\"] = {}\n\n            for index, rdmol in self.index2rdmol.items():\n                # self.chemical_space[\"compounds\"][index] = {\"structure\": self.__get_compound__(rdmol), \"smiles\": Chem.MolToSmiles(rdmol, True)}\n\n                self.chemical_space[\"compounds\"][index] = {\"smiles\": Chem.MolToSmiles(rdmol, True)}\n\n    def __parse_categories__(self):\n        category2ids = {}\n        \n        for index, category in self.index2category.items():\n            categories = [category] if self.category_field_delimiter is False else [c.strip() for c in category.split(self.category_field_delimiter)]\n\n            for c in categories:\n                if c in category2ids:\n                    category2ids[c].add(index)\n                else:\n                    category2ids[c] = {index}\n        \n        if not \"categories\" in self.chemical_space:\n            self.chemical_space[\"categories\"] = []\n\n        for c, ids in category2ids.items():\n            self.chemical_space[\"categories\"].append({\"label\": c, \"points\": list(ids)})\n\n    def add_paths(self, paths):\n        if not self.chemical_space.get(\"paths\", False):\n            self.chemical_space[\"paths\"] = []\n\n        self.chemical_space[\"paths\"].extend(paths)\n\n    def add_paths_from_file(self):\n        pass\n\n    def add_physico_chemical_properties(self):\n        print(\"Calculating physico-chemical properties: {} compounds\".format(len(self.index2rdmol)))\n        self.pcp = True\n        if len(self.index2rdmol):\n            count = len(self.index2rdmol)\n            i = 0\n\n            id2pcp = {}\n            for index, rdmol in self.index2rdmol.items():\n                if i%100 == 0 or i == count:\n                    print(\"{}\/{}\".format(i, count))\n\n                id2pcp[index] = self.__get_pcp_for_rdmol__(rdmol)\n                i+=1\n\n            empty = [None for x in PROP2LABEL]\n            for i, index in enumerate(self.index_order):\n                \n                if id2pcp.get(index, False):\n                    pcps = id2pcp[index]\n                else:\n                    pcps = empty\n                \n                self.chemical_space[\"points\"][index][\"features\"].extend(pcps)\n                self.data[i].extend(pcps)                \n\n            current_header = self.chemical_space.get(\"feature_names\", [])\n            current_header.extend([PROP2LABEL[prop] for prop in PROPS_ORDER])\n            self.chemical_space[\"feature_names\"] = current_header\n            self.original_data = copy.deepcopy(self.data)\n\n    def __get_pcp_for_rdmol__(self, rdmol):\n        return [round(PROP2FNC[prop](rdmol), 2) for prop in PROPS_ORDER]\n\n    def __get_compound__(self, rdmol):\n        if rdmol is not None:\n            Chem.Kekulize(rdmol)\n            AllChem.Compute2DCoords(rdmol)\n            compound = {\"atoms\": {}}\n            atoms = [a for a in rdmol.GetAtoms()]\n            bond_types = []\n            for i, a in enumerate(atoms, 1):\n                number = a.GetIdx()\n                position = rdmol.GetConformer().GetAtomPosition(number)\n\n                compound[\"atoms\"][number] = {\n                    \"bonds\": {b.GetEndAtomIdx():b.GetBondTypeAsDouble() for b in a.GetBonds() if b.GetEndAtomIdx() != number},\n                    \"symbol\": a.GetSymbol(),\n                    \"charge\": a.GetFormalCharge(),\n                    \"coordinates\": [round(position.x, 3), round(position.y, 3)]\n                }\n\n                bond_types.extend(compound[\"atoms\"][number][\"bonds\"].values())\n        else:\n            compound = None\n\n        return compound\n\n    def normalize_data(self, feature_range=(0,1)):\n        \"\"\"Normalizes data to a scale from 0 to 1.\"\"\"\n        print(\"Data normalization (scale): {}\".format(feature_range))\n\n        min_max_scaler = preprocessing.MinMaxScaler(feature_range)\n        self.data = min_max_scaler.fit_transform(self.data)\n        self.data = [[round(v, 3) for v in row] for row in self.data]\n\n    def __calculate_distance_matrix__(self, similarity_threshold):\n        print(\"\\nCalculating distance matrix: {} compounds\".format(len(self.index2fpobj)))\n\n        self.dist_matrix = {x:[] for x in self.index_order}\n        self.edges = []\n        self.index2edges = {}\n\n        fps_count = len(self.index_order)\n        \n        for i, index_1 in enumerate(self.index_order):\n            self.index2edges[index_1] = []\n\n            if i%100 == 0 or i == fps_count:\n                print(\"{}\/{}\".format(i, fps_count))\n            \n            for j, index_2 in enumerate(self.index_order[i:], i):\n                sim = DataStructs.FingerprintSimilarity(self.index2fpobj[index_1], self.index2fpobj[index_2], metric=getattr(DataStructs, \"{}Similarity\".format(self.metric)))\n                self.dist_matrix[index_1].append(1-sim)\n                \n                if index_1 != index_2:\n                    self.dist_matrix[index_2].append(1-sim)\n\n                    if sim >= similarity_threshold:\n                        self.edges.append((index_1, index_2))\n                        self.index2edges[index_1].append([index_2])\n\n    def __get_edges__(self, similarity_threshold=0.7, k=2):\n        print(\"\\nCalculating edges [similarity threshold={}]: {} compounds\".format(similarity_threshold, len(self.index2fpobj)))\n        self.edges = []\n        self.index2edges = {}\n        count = len(self.index_order)\n\n        for i, index in enumerate(self.index_order):\n            if (i+1)%100 == 0:\n                print(\"{}\/{}\".format(i, count))\n\n            values = [[idx, v] for idx, v in zip(self.index_order, self.dist_matrix[index]) if idx != index]\n            values.sort(key=lambda x: x[1])\n\n            if 1-values[1][1] >= similarity_threshold: \n                self.index2edges[index] = []\n\n                for v in values:\n                    if 1-v[1] >= similarity_threshold:\n                        self.edges.append((index, v[0]))\n                        self.index2edges[index].append([v[0]])\n\n                        if len(self.index2edges[index]) == k:\n                            break\n                    else:\n                        break\n\n        print(\"EDGES: {}\".format(len(self.edges)))\n        \n    def __convert_fps_to_bitvects__(self, fps):\n        converted = []\n\n        for fp in fps:\n            row = [fp[0], self.__get_bitvect_for_fp__(fp[1:])]\n            converted.append(row)\n\n        return converted\n\n    def __get_bitvect_for_fp__(self, fp):\n        if type(fp) is list and len(fp) == 1:\n            fp = fp[0]\n        bitvect = cDataStructs.ExplicitBitVect(len(fp))\n        on_indexes = [i for i, b in enumerate(fp) if int(b) == 1]\n        bitvect.SetBitsFromList(on_indexes)\n        return bitvect\n\n    def arrange(self, by=\"fps\", fps=[], method=\"pca\", similarity_threshold=0.7, add_edges=False, k=None):\n        self.index2edges = False\n        self.edges = False\n        self.dist_matrix = False\n        bitvects = False\n\n        if type(method) is not list:\n            methods = [method]\n        else:\n            methods = method\n\n        for method in methods:\n            if by == \"scaffolds\":\n                self.__arrange_by_scaffolds__()\n\n                g = igraph.Graph(len(self.index_order))\n                print(\"\\nCalculating Chemical Space Network...\")\n                feature_names = [\"CSN1\", \"CSN2\"]\n\n                g.add_edges(self.edges)\n                layout = g.layout_fruchterman_reingold()\n                coords = layout.coords\n\n            elif by == \"dm\" or method == \"sas\":\n                if len(fps) == 0:\n                    for index in self.index_order:\n                        fps.append(self.index2fpobj[index])\n                    bitvects = True\n                        \n                elif type(fps[0][1]) in [unicode, int] and not bitvects:\n                    fps = self.__convert_fps_to_bitvects__(fps)\n                    bitvects = True\n\n                if not self.dist_matrix:\n                    self.__calculate_distance_matrix__(similarity_threshold)\n\n                dist_matrix = np.matrix([np.array(self.dist_matrix[index]) for index in self.index_order])\n                g = igraph.Graph(len(self.index_order))\n\n                if method == \"csn\":\n                    print(\"\\nCalculating Chemical Space Network...\")\n                    feature_names = [\"CSN1\", \"CSN2\"]\n                    if k is not None:\n                        # k = len(self.index_order)\n                        self.__get_edges__(similarity_threshold=similarity_threshold, k=k)\n\n                    print(\"Fruchterman-Reingold Layout calculation...\")\n                    g.add_edges(self.edges)\n                    layout = g.layout_fruchterman_reingold()\n                    coords = layout.coords\n\n                elif method == \"mds\":\n                    print(\"\\nCalculating MDS...\")\n                    feature_names = [\"MDS1\", \"MDS2\"]\n                    # sklearn implementation\n                    mds = manifold.MDS(n_components=2, dissimilarity='precomputed')\n                    coords = mds.fit_transform(dist_matrix)\n\n                    # igraph implementation\n                    # layout = g.layout_mds(dist_matrix, 2, arpack_options=igraph.ARPACKOptions(iter=1000))\n                    # coords = layout.coords\n\n                elif method == \"pca\":\n                    print(\"\\nCalculating PCA...\")\n                    feature_names = [\"PC1\", \"PC2\"]\n                    pca = decomposition.PCA(n_components=2)\n                    coords = pca.fit_transform(dist_matrix)\n\n                elif method == \"fa\":\n                    print(\"\\nCalculating Factor Analysis...\")\n                    feature_names = [\"FA1\", \"FA2\"]\n                    fa = decomposition.FactorAnalysis(n_components=2)\n                    coords = fa.fit_transform(dist_matrix)\n\n                elif method == \"isomap\":\n                    print(\"\\nCalculating Isomap...\")\n                    feature_names = [\"Isomap1\", \"Isomap2\"]\n                    isomap = manifold.Isomap(n_neighbors=200, n_components=2)\n                    coords = isomap.fit_transform(dist_matrix)\n\n                elif method == \"tsne\":\n                    print(\"\\nCalculating t-SNE...\")\n                    feature_names = [\"t-SNE1\", \"t-SNE2\"]\n                    tsne = manifold.TSNE(n_components=2, metric='precomputed')\n                    coords = tsne.fit_transform(dist_matrix)\n\n                elif method == \"sas\":\n                    print(\"\\nCalculating SAS...\")\n                    feature_names = [\"Similarity\", \"Activity difference\"]\n                    self.chemical_space = {\"points\": {}, \"feature_names\": [\"SALI\"]}\n                    ai = self.header.index(self.activity_field)\n                    ids = []\n                    coords = []\n                    \n                    for i, index_1 in enumerate(self.index_order[:-1]):\n                        for j, index_2 in enumerate(self.index_order[i:], i):\n                            if i != j:\n                                activity_diff = round(abs(float(self.data[i][ai]) - float(self.data[j][ai])), 2)\n                                distance = self.dist_matrix[i][j]\n                                distance = distance if distance > 0 else 0.01\n\n                                sali = round(activity_diff\/distance, 2)\n                                coord = [round(1 - self.dist_matrix[i][j], 2), activity_diff]\n                                self.chemical_space[\"points\"][\"{}_{}\".format(index_1, index_2)] = {\"features\": [sali]}\n                                ids.append(\"{}_{}\".format(index_1, index_2))\n                                coords.append(coord)\n\n                    self.index_order = ids\n\n            elif by in [\"data\", \"fps\"]:\n                if by == \"fps\":\n                    if len(fps) == 0 and len(self.index2fpobj):\n                        for index in self.index_order:\n                            fps.append(self.index2fpobj[index])\n                    \n                    data = [[int(b) for b in fp] for fp in fps]\n                else:\n                    data = self.data\n\n                if method == \"pca\":\n                    print(\"\\nCalculating PCA...\")\n                    feature_names = [\"PC1\", \"PC2\"]\n                    pca = decomposition.PCA(n_components=2)\n                    coords = pca.fit_transform(data)\n\n                elif method == \"fa\":\n                    print(\"\\nCalculating Factor Analysis...\")\n                    feature_names = [\"FA1\", \"FA2\"]\n                    fa = decomposition.FactorAnalysis(n_components=2)\n                    coords = fa.fit_transform(data)\n\n            if method in [\"csn\", \"nn\"] or add_edges or by == \"scaffolds\":\n                if self.dist_matrix is False and self.edges is False:\n                    self.__calculate_distance_matrix__()\n\n                if self.edges is False:\n                    if k is None:\n                        k = len(self.index_order)\n                    self.__get_edges__(similarity_threshold=similarity_threshold, k=k)\n\n                if by != \"scaffolds\":\n                    for cid, es in self.index2edges.items():\n                        if not self.chemical_space[\"points\"][cid].get(\"links\", False):\n                            self.chemical_space[\"points\"][cid][\"links\"] = []\n\n                        for e in es:\n                            self.chemical_space[\"points\"][cid][\"links\"].extend(e)\n\n            index2coords = {index:coords[i] for i, index in enumerate(self.index_order)}\n\n            for index, values in self.chemical_space[\"points\"].items():\n                if index in index2coords:\n                    point_features = self.chemical_space[\"points\"][index][\"features\"]\n                    features = [round(index2coords[index][0], 3), round(index2coords[index][1], 3)]\n                    features.extend(point_features)\n                    self.chemical_space[\"points\"][index][\"features\"] = features\n\n                else:\n                    self.chemical_space[\"points\"].pop(index, None)\n\n            feature_names.extend(self.chemical_space.get(\"feature_names\", []))\n            self.chemical_space[\"feature_names\"] = feature_names\n\n    def __arrange_by_scaffolds__(self, align_by_scaffold=True):\n        self.scaffold2indexes = {}\n        self.scaffold2rdmol = {}\n        self.index2scaffold = {}\n\n        for index, rdmol in self.index2rdmol.items():\n            AllChem.Compute2DCoords(rdmol)\n\n            if align_by_scaffold:\n                scaffold = Scaffolds.MurckoScaffold.GetScaffoldForMol(rdmol)\n                AllChem.Compute2DCoords(scaffold)\n                scaffold_smiles = Chem.MolToSmiles(scaffold)\n                self.scaffold2rdmol[scaffold_smiles] = scaffold\n                \n                matched = rdmol.GetSubstructMatch(scaffold)\n                coords = [rdmol.GetConformer().GetAtomPosition(x) for x in matched]\n                coords2D = [Geometry.Point2D(pt.x,pt.y) for pt in coords]\n\n                coordDict = {}\n                for i,coord in enumerate(coords2D):\n                    coordDict[matched[i]] = coord\n\n                AllChem.Compute2DCoords(rdmol, coordMap=coordDict)\n\n                if scaffold_smiles in self.scaffold2indexes:\n                    self.scaffold2indexes[scaffold_smiles].append(index)\n                else:\n                    self.scaffold2indexes[scaffold_smiles] = [index]\n\n        self.scaffold2indexes = {scaffold: indexes for scaffold, indexes in self.scaffold2indexes.items() if len(indexes) > 1}\n\n        for index, scaffold in enumerate(self.scaffold2indexes.keys(), len(self.index_order)):\n                self.index2scaffold[index] = scaffold\n                self.index2rdmol[index] = self.scaffold2rdmol[scaffold]\n                self.index_order.append(index)\n\n        self.edges = []\n        self.index2edges = {}\n\n        for index_1, scaffold in self.index2scaffold.items():\n            self.index2edges[index_1] = []\n\n            for index_2 in self.scaffold2indexes[scaffold]:\n                self.edges.append((index_1, index_2))\n                self.index2edges[index_1].append(index_2)\n\n        self.__add_scaffolds_to_chemical_space__()\n\n    def __add_scaffolds_to_chemical_space__(self):\n        for index, scaffold in self.index2scaffold.items():\n            self.chemical_space[\"points\"][index] = {\n                # \"features\": self.__get_pcp_for_rdmol__(self.scaffold2rdmol[scaffold]),\n                \"object_ids\": self.scaffold2indexes[scaffold],\n                \"links\": self.scaffold2indexes[scaffold],\n            }\n            if self.pcp:\n                self.chemical_space[\"points\"][index][\"features\"] = [None for i in range(len(self.chemical_space[\"feature_names\"]) - len(PROPS_ORDER))]\n                self.chemical_space[\"points\"][index][\"features\"].extend(self.__get_pcp_for_rdmol__(self.scaffold2rdmol[scaffold]))\n            self.chemical_space[\"compounds\"][index] = {\"smiles\": scaffold, \"color\": \"red\"}\n\n    def get_chemspace_compound_from_smiles(self, smi):\n        mol_obj = Chem.MolFromSmiles(smi)\n        if mol_obj is not None:\n            AllChem.Compute2DCoords(mol_obj)\n            mol = self.__get_compound__(mol=mol_obj)\n        else:\n            mol = False\n        return mol\n\n    def export_chemical_space_as_html(self, htmldir=\".\", ):\n        \"\"\"Export a simple HTML page with embedded chemical space and dependencies into a given directory.\"\"\"\n        if not os.path.exists(htmldir):\n            os.makedirs(htmldir)\n\n        chemspace_json = self.export_chemical_space_as_json(minify=True, dump=True)\n        \n        libs = [\n            (\"chemspace-0.2.0.min.js\", \"https:\/\/openscreen.cz\/software\/chemspace\/static\/js\/chemspace-0.2.0.min.js\"),\n            (\"jquery-3.3.1.min.js\", \"https:\/\/code.jquery.com\/jquery-3.3.1.min.js\"),\n            (\"konva.min.js\", \"https:\/\/cdn.rawgit.com\/konvajs\/konva\/1.7.6\/konva.min.js\")\n        ]\n        \n        js_html = []\n        for l in libs:\n            js_html.append(\"<script src='{}'><\/script>\".format(l[0]))\n\n        settings = {\n            \"target\": \"chemspace\"\n        }\n\n        template = \"\"\"<html>\n        <head>\n            {}\n            <script>\n                $(document).ready(function() {{\n                    var data = {};\n                    var chemspace = new ChemSpace({});\n                    chemspace.read_data(data);\n                    chemspace.draw();\n                }});\n            <\/script>\n        <\/head>\n\n        <body>\n            <div id=\"chemspace\"><\/div>\n        <\/body>\n        <\/html>\"\"\".format('\\n'.join(js_html), chemspace_json, json.dumps(settings))\n\n        \n        for l in libs:\n            lib, url = l\n            try:\n                source = urllib2.urlopen(url)\n                source_html = source.read()\n\n                with open(os.path.join(htmldir, lib), \"w\") as output:\n                    output.write(source_html)\n            except urllib2.URLError, e:\n                raise Exception(\"\"\"\n                        \\nCan't download file {}.\\nPlease check your internet connection and try again.\\nIf the error persists there can be something wrong with the InCHlib server.\\n\"\"\".format(url)\n                    )\n\n        with open(os.path.join(htmldir, \"chemspace.html\"), \"w\") as output:\n            output.write(template)\n\n    def export_chemical_space_as_json(self, filename=None, minify=False, dump=True):\n        \"\"\"Returns space in a JSON format or exports it to the file specified by the filename parameter.\"\"\"\n        space_json = self.chemical_space\n\n        if minify:\n            space_json = json.dumps(space_json)\n            space_json = self.__minify_data(space_json)\n        elif dump:\n            space_json = json.dumps(space_json, indent=4)\n\n        if filename:\n            output = open(filename, \"w\")\n            output.write(space_json)\n        \n        return space_json\n\n    def __minify_data(self, data):\n        return jsmin.jsmin(data)\n\ndef _process_(arguments):\n    s = ChemSpace()\n    s.sdf_file = False\n    s.write_structures = False if arguments.dont_write_structures else True\n    s.fp = arguments.fingerprint\n    s.category_field = arguments.category_field\n    s.category_field_delimiter = arguments.category_field_delimiter\n    s.label_field = arguments.label_field\n    s.activity_field = arguments.activity_field\n    s.compound_structure_field = arguments.compound_structure_field\n    s.fingerprint_field = arguments.fingerprint_field\n    s.metric = arguments.similarity_metric\n\n    if arguments.data_file.split(\".\")[-1].lower() == \"sdf\":\n        s.read_sdf(arguments.data_file)\n    else:\n        s.read_csv(arguments.data_file, arguments.data_delimiter, arguments.data_header, arguments.missing_values, arguments.remove_columns)\n\n    if s.compound_structure_field is not False or s.sdf == True:\n        if arguments.physico_chemical_properties:\n            s.add_physico_chemical_properties()\n\n    if arguments.normalize:\n        s.normalize_data()\n\n    if arguments.arrange_by:\n        s.arrange(\n            method=arguments.dimensional_reduction_method,\n            similarity_threshold=float(arguments.compound_similarity_threshold),\n            add_edges=arguments.add_edges,\n            by=arguments.arrange_by,\n            k=arguments.knn\n        )\n    \n    if arguments.html_dir:\n        s.export_chemical_space_as_html(arguments.html_dir)\n    elif arguments.output_file:\n        s.export_chemical_space_as_json(arguments.output_file, minify=arguments.minify_output)\n    else:\n        print(s.export_chemical_space_as_json(minify=arguments.minify_output))\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n    parser.add_argument(\"data_file\", type=str, help=\"csv(text) data file with delimited values or a sdf file\")\n    parser.add_argument(\"-dh\", \"--data_header\", default=False, help=\"whether the first row of data file is a header\", action=\"store_true\")\n    parser.add_argument(\"-dd\", \"--data_delimiter\", type=str, default=\",\", help=\"delimiter of values in data file\")\n    parser.add_argument(\"-o\", \"--output_file\", type=str, help=\"the name of output file\")\n    parser.add_argument(\"-fpf\", \"--fingerprint_field\", type=str, default=False, help=\"set a fingerprint field name in case it is in the data file\")\n    parser.add_argument(\"-cf\", \"--category_field\", type=str, default=False, help=\"set a category field name in case it is in the data file\")\n    parser.add_argument(\"-cfd\", \"--category_field_delimiter\", type=str, default=False, help=\"a category field delimiter\")\n    parser.add_argument(\"-lf\", \"--label_field\", type=str, default=False, help=\"set a label field name in case it is in the data file\")\n    parser.add_argument(\"-af\", \"--activity_field\", type=str, default=False, help=\"set an activity field name in case it is in the data file\")\n    parser.add_argument(\"-csf\", \"--compound_structure_field\", type=str, default=False, help=\"the name of a column with a compound structure\")\n    parser.add_argument(\"-fp\", \"--fingerprint\", type=str, default=\"ecfp4\", help=\"fingerprint used for a compound representation (ecfp4, ecfp6, maccs, topological, atom_pairs)\")\n    parser.add_argument(\"-arr\", \"--arrange_by\", default=False, help=\"arrange data by compound structures (distance matrix) or by input data (data\/fps)\", type=str)\n    parser.add_argument(\"-cst\", \"--compound_similarity_threshold\", default=0.7, help=\"compound similarity threshold\")\n    parser.add_argument(\"-drm\", \"--dimensional_reduction_method\", nargs='+', type=str, default=\"pca\", help=\"which method use for dimensional reduction (pca\/isomap\/csn)\")\n    parser.add_argument(\"-dws\", \"--dont_write_structures\", default=False, help=\"dont write structures to output file\", action=\"store_true\")\n    parser.add_argument(\"-min\", \"--minify_output\", default=False, help=\"minify the JSON output format\", action=\"store_true\")\n    parser.add_argument(\"-html\", \"--html_dir\", type=str, default=False, help=\"the directory to store HTML page with dependencies\")\n    parser.add_argument(\"-pcp\", \"--physico_chemical_properties\", default=False, help=\"calculate basic phyisico-chemical properties and add them ass features\", action='store_true')\n    parser.add_argument(\"-edges\", \"--add_edges\", default=False, help=\"add edges based on compound similarity to the graph\", action='store_true')\n    parser.add_argument(\"-n\", \"--normalize\", default=False, help=\"normalize data to [0, 1] range\", action=\"store_true\")\n    parser.add_argument(\"-mv\", \"--missing_values\", type=str, default=False, help=\"define the string representating missing values in the data\")\n    parser.add_argument(\"-k\", \"--knn\", type=int, default=None, help=\"the number of neighbours (k) used for the construction of csn using the nn method\")\n    parser.add_argument(\"-sm\", \"--similarity_metric\", type=str, default=\"Tanimoto\", help=\"similarity metric\")\n    parser.add_argument('-rmc','--remove_columns', nargs='+', default=False, help='columns in data that should not be used')\n    \n    args = parser.parse_args()\n    _process_(args)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_152","text":"\"\"\"This module implements numerical functions.\"\"\"\nfrom __future__ import annotations\n\nimport numpy as np\nimport scipy as sp\n\nfrom bqskit.qis.pauli import PauliMatrices\nfrom bqskit.qis.unitary.unitary import RealVector\n\n\ndef dexpmv(M: np.ndarray, dM: np.ndarray) -> tuple[np.ndarray, np.ndarray]:\n    \"\"\"\n    Compute the Matrix exponential F = e^M and its derivative dF.\n\n    User must provide M and its derivative dM. If the argument dM is a\n    vector of partials then dF will be the respective partial vector.\n    This is done using a Pade Approximat with scaling and squaring.\n\n    Args:\n        M (np.ndarray): Matrix to exponentiate.\n\n        dM (np.ndarray): Derivative(s) of M.\n\n    Returns:\n        tuple: Tuple containing\n            - F (np.ndarray): Exponentiated matrix, i.e. e^M.\n\n            - dF (np.ndarray): Derivative(s) of F.\n\n    References:\n        Brančík, Lubomír. \"Matlab programs for matrix exponential function\n        derivative evaluation.\" Proc. of Technical Computing Prague 2008\n        (2008): 17-24.\n    \"\"\"\n\n    e = np.log2(np.linalg.norm(M, np.inf))\n    r = int(max(0, e + 1))\n    M = M \/ (2 ** r)\n    dM = dM \/ (2 ** r)\n    X = M\n    Y = dM\n    c = 0.5\n    F = np.identity(M.shape[0]) + c * M\n    D = np.identity(M.shape[0]) - c * M\n    dF = c * dM\n    dD = -c * dM\n    q = 6\n    p = True\n    for k in range(2, q + 1):\n        c = c * (q - k + 1) \/ (k * (2 * q - k + 1))\n        Y = dM @ X + M @ Y\n        X = M @ X\n        cX = c * X\n        cY = c * Y\n        F = F + cX\n        dF = dF + cY\n        if p:\n            D = D + cX\n            dD = dD + cY\n        else:\n            D = D - cX\n            dD = dD - cY\n        p = not p\n    Dinv = np.linalg.inv(D)\n    F = Dinv @ F\n    dF = Dinv @ (dF - dD @ F)\n\n    for k in range(1, r + 1):\n        dF = dF @ F + F @ dF\n        F = F @ F\n\n    return F, dF\n\n\ndef softmax(x: np.ndarray, beta: int = 20) -> np.ndarray:\n    \"\"\"\n    Computes the softmax of vector x.\n\n    Args:\n        x (np.ndarray): Input vector to softmax.\n\n        beta (int): Beta coefficient to scale steepness of softmax.\n\n    Returns:\n        np.ndarray: Output vector of softmax.\n    \"\"\"\n\n    shiftx = beta * (x - np.max(x))\n    exps = np.exp(shiftx)\n    return exps \/ np.sum(exps)\n\n\ndef dot_product(alpha: RealVector, sigma: RealVector) -> np.ndarray:\n    \"\"\"\n    Computes the standard dot product of `alpha` with `sigma`.\n\n    Args:\n        alpha (RealVector): The alpha vector.\n\n        sigma (RealVector): The sigma vector.\n\n    Returns:\n        np.ndarray: Sum of element-wise multiplication of `alpha`\n        and `sigma`.\n    \"\"\"\n\n    return np.array(np.sum([a * s for a, s in zip(alpha, sigma)], 0))\n\n\ndef unitary_log_no_i(U: np.ndarray) -> np.ndarray:\n    \"\"\"\n    Solves for H in U = e^{iH}\n\n    Args:\n        U (np.ndarray): The unitary to decompose.\n\n    Returns:\n        np.ndarray: H in e^{iH} = U.\n\n    Note:\n        This assumes the input is unitary but does not check. The output\n        is undefined on non-unitary inputs.\n    \"\"\"\n\n    T, Z = sp.linalg.schur(U)\n    T = np.diag(T)\n    D = T \/ np.abs(T)\n    D = np.diag(np.log(D))\n    H0 = -1j * (Z @ D @ Z.conj().T)\n    return 0.5 * H0 + 0.5 * H0.conj().T\n\n\ndef pauli_expansion(H: np.ndarray) -> np.ndarray:\n    \"\"\"\n    Computes a Pauli expansion of the hermitian matrix H.\n\n    Args:\n        H (np.ndarray): The hermitian matrix to expand.\n\n    Returns:\n        np.ndarray: The coefficients of a Pauli expansion for H,\n        i.e., X dot Sigma = H where Sigma is Pauli matrices of\n        same size of H.\n\n    Note:\n        This assumes the input is hermitian but does not check. The\n        output is undefined on non-hermitian inputs.\n    \"\"\"\n\n    # Change basis of H to Pauli Basis (solve for coefficients -> X)\n    n = int(np.log2(len(H)))\n    paulis = PauliMatrices(n)\n    flatten_paulis = [np.reshape(pauli, 4 ** n) for pauli in paulis]\n    flatten_H = np.reshape(H, 4 ** n)\n    A = np.stack(flatten_paulis, axis=-1)\n    X = np.real(np.matmul(np.linalg.inv(A), flatten_H))\n    return np.array(X)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_153","text":"<gh_stars>0\nfrom ._stopping_criterion import StoppingCriterion\nfrom ..accumulate_data import MLQMCData\nfrom ..discrete_distribution import Lattice\nfrom ..true_measure import Gaussian\nfrom ..integrand import MLCallOptions\nfrom ..util import MaxSamplesWarning, ParameterError, MaxLevelsWarning\nfrom numpy import *\nfrom numpy.linalg import lstsq\nfrom scipy.stats import norm\nfrom time import time\nimport warnings\n\n\nclass CubQMCMLCont(StoppingCriterion):\n    \"\"\"\n    Stopping criterion based on continuation multi-level quasi-Monte Carlo.\n\n    >>> mlco = MLCallOptions(Lattice(seed=7))\n    >>> sc = CubQMCMLCont(mlco,abs_tol=.05)\n    >>> solution,data = sc.integrate()\n    >>> solution\n    10.394...\n    >>> data\n    Solution: 10.3948        \n    MLCallOptions (Integrand Object)\n        option          european\n        sigma           0.200\n        k               100\n        r               0.050\n        t               1\n        b               85\n    Lattice (DiscreteDistribution Object)\n        d               1\n        randomize       1\n        order           natural\n        seed            561339\n        mimics          StdUniform\n    Gaussian (TrueMeasure Object)\n        mean            0\n        covariance      1\n        decomp_type     pca\n    CubQMCMLCont (StoppingCriterion Object)\n        rmse_tol        0.019\n        n_init          2^(8)\n        n_max           10000000000\n        replications    2^(5)\n        levels_min      2^(1)\n        levels_max      10\n        n_tols          10\n        tol_mult        1.668\n        theta_init      2^(-1)\n        theta           2^(-3)\n    MLQMCData (AccumulateData Object)\n        levels          2^(2)\n        dimensions      [1. 2. 4. 8.]\n        n_level         [4096.  256.  256.  256.]\n        mean_level      [10.053  0.184  0.102  0.055]\n        var_level       [8.703e-05 6.794e-05 2.603e-05 8.925e-06]\n        bias_estimate   0.035\n        n_total         155648\n        time_integrate  ...\n    \n    References:\n        \n        [1] <NAME> and <NAME>. 'Multilevel quasi-Monte Carlo path simulation'.\n        pp.165-181 in Advanced Financial Modelling, in Radon Series on Computational and Applied Mathematics,\n        de Gruyter, 2009. http:\/\/people.maths.ox.ac.uk\/~gilesm\/files\/radon.pdf\n    \"\"\"\n\n    def __init__(self, integrand, abs_tol=.05, alpha=.01, rmse_tol=None, n_init=256., n_max=1e10, \n        replications=32., levels_min=2, levels_max=10, n_tols=10, tol_mult=100**(1\/9), theta_init=0.5):\n        \"\"\"\n        Args:\n            integrand (Integrand): integrand with multi-level g method\n            abs_tol (float): absolute tolerance\n            alpha (float): uncertaintly level.\n                If rmse_tol not supplied, then rmse_tol = abs_tol\/norm.ppf(1-alpha\/2)\n            rmse_tol (float): root mean squared error\n                If supplied (not None), then absolute tolerance and alpha are ignored\n                in favor of the rmse tolerance\n            n_max (int): maximum number of samples\n            replications (int): number of replications on each level\n            levels_min (int): minimum level of refinement >= 2\n            levels_max (int): maximum level of refinement >= Lmin\n            n_tols (int): number of coarser tolerances to run\n            tol_mult (float): coarser tolerance multiplication factor\n            theta_init (float) : initial error splitting constant\n\n        \"\"\"\n        self.parameters = ['rmse_tol','n_init','n_max','replications','levels_min',\n            'levels_max','n_tols','tol_mult','theta_init','theta']\n        # initialization\n        if rmse_tol:\n            self.target_tol = float(rmse_tol)\n        else: # use absolute tolerance\n            self.target_tol =  float(abs_tol) \/ norm.ppf(1-alpha\/2)\n        self.n_init = float(n_init)\n        self.n_max = float(n_max)\n        self.replications = float(replications)\n        self.levels_min = levels_min\n        self.levels_max = levels_max\n        self.theta_init = theta_init\n        self.theta = theta_init\n        self.n_tols = n_tols\n        self.tol_mult = tol_mult\n        # QMCPy Objs\n        self.integrand = integrand\n        self.true_measure = self.integrand.true_measure\n        self.discrete_distrib = self.integrand.discrete_distrib\n        # Verify Compliant Construction\n        allowed_levels = ['adaptive-multi']\n        allowed_distribs = [\"Lattice\", \"Sobol\",\"Halton\"]\n        super(CubQMCMLCont,self).__init__(allowed_levels, allowed_distribs)\n\n    def integrate(self):\n        # Construct AccumulateData Object to House Integration Data\n        self.data = MLQMCData(self, self.integrand, self.true_measure, self.discrete_distrib,\n            self.levels_min, self.levels_max, self.n_init, self.replications)\n        # Loop over coarser tolerances\n        for t in range(self.n_tols):\n            self.rmse_tol = self.tol_mult**(self.n_tols-t-1)*self.target_tol # Set new target tolerance\n            self._integrate()\n        return self.data.solution,self.data\n\n    def _integrate(self):\n        \"\"\" See abstract method. \"\"\"\n        t_start = time()\n        #self.theta = self.theta_init\n        self.data.levels = int(self.levels_min+1)\n\n        converged = False\n        while not converged:\n            # Ensure that we have samples on the finest level\n            self.data.update_data()\n            self._update_theta()\n\n            while self._varest() > (1-self.theta)*self.rmse_tol**2:\n                efficient_level = argmax(self.data.var_cost_ratio_level[:self.data.levels])\n                self.data.eval_level[efficient_level] = True\n\n                # Check if over sample budget\n                total_next_samples = (self.data.replications*self.data.eval_level*self.data.n_level*2).sum()\n                if (self.data.n_total + total_next_samples) > self.n_max:\n                    warning_s = \"\"\"\n                    Alread generated %d samples.\n                    Trying to generate %d new samples, which would exceed n_max = %d.\n                    Stopping integration process.\n                    Note that error tolerances may no longer be satisfied\"\"\" \\\n                    % (int(self.data.n_total), int(total_next_samples), int(self.n_max))\n                    warnings.warn(warning_s, MaxSamplesWarning)\n                    self.data.time_integrate += time() - t_start\n                    return\n\n                self.data.update_data()\n                self._update_theta()\n\n            # Check for convergence\n            converged = self._rmse() < self.rmse_tol\n            if not converged:\n                if self.data.levels == self.levels_max:\n                    warnings.warn(\n                        'Failed to achieve weak convergence. levels == levels_max.',\n                        MaxLevelsWarning)\n                    converged = True\n                else:\n                    self.data._add_level()\n\n        self.data.time_integrate += time() - t_start\n    \n    def set_tolerance(self, abs_tol=None, alpha=.01, rmse_tol=None):\n        \"\"\"\n        See abstract method. \n        \n        Args:\n            integrand (Integrand): integrand with multi-level g method\n            abs_tol (float): absolute tolerance. Reset if supplied, ignored if not. \n            alpha (float): uncertaintly level.\n                If rmse_tol not supplied, then rmse_tol = abs_tol\/norm.ppf(1-alpha\/2)\n            rel_tol (float): relative tolerance. Reset if supplied, ignored if not.\n                Takes priority over aboluste tolerance and alpha if supplied. \n        \"\"\"\n        if rmse_tol != None:\n            self.rmse_tol = float(rmse_tol)\n        elif abs_tol != None:\n            self.rmse_tol = (float(abs_tol) \/ norm.ppf(1-alpha\/2.))\n\n    def _update_theta(self):\n        \"\"\"Update error splitting parameter\"\"\"\n        max_levels = len(self.data.n_level)\n        A = ones((2,2))\n        A[:,0] = range(max_levels-2, max_levels)\n        y = ones(2)\n        y[0] = log2(abs(self.data.mean_level_reps[max_levels-2].mean()))\n        y[1] = log2(abs(self.data.mean_level_reps[max_levels-1].mean()))\n        x = lstsq(A, y, rcond=None)[0]\n        alpha = maximum(.5,-x[0])\n        real_bias = 2**(x[1]+max_levels*x[0]) \/ (2**alpha - 1)\n        self.theta = max(0.01, min(0.125, (real_bias\/self.rmse_tol)**2))\n\n    def _rmse(self):\n        \"\"\"Returns an estimate for the root mean square error\"\"\"\n        return sqrt(self._mse())\n\n    def _mse(self):\n        \"\"\"Returns an estimate for the mean square error\"\"\"\n        return (1-self.theta)*self._varest() + self.theta*self.data.bias_estimate**2\n\n    def _varest(self):\n        \"\"\"Returns the variance of the estimator\"\"\"\n        return self.data.var_level[:self.data.levels].sum()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_154","text":"<reponame>daniyaljamal\/Personality-prediction-based-on-video-using-CNN<filename>dan.py\n########################################################################################\n#                                                                                      #\n# VGG16 implementation in TensorFlow                                                   #\n# Details:                                                                             #\n# http:\/\/www.cs.toronto.edu\/~frossard\/post\/vgg16\/                                      #\n#                                                                                      #\n# Model from https:\/\/gist.github.com\/ksimonyan\/211839e770f7b538e2d8#file-readme-md     #\n# Weights from Caffe converted using https:\/\/github.com\/ethereon\/caffe-tensorflow      #\n########################################################################################\n\nimport pickle\nimport warnings\n\nimport numpy as np\nimport tensorflow as tf\nfrom scipy.io import loadmat\n\nwarnings.filterwarnings(\"ignore\")\n\n\nclass DAN:\n    def __init__(self, imgs, REG_PENALTY=0, preprocess=None):\n        self.imgs = imgs\n        if preprocess == \"vggface\":\n            self.mean = [129.1862793, 104.76238251, 93.59396362]\n        self.convlayers()\n        self.dan_part()\n        self.output = tf.nn.sigmoid(self.reg_head, name=\"output\")\n        self.cost_reg = REG_PENALTY * tf.reduce_mean(tf.square(self.parameters[-2])) \/ 2\n\n    def convlayers(self):\n        self.parameters = []\n\n        # zero-mean input\n        with tf.name_scope(\"preprocess\") as scope:\n            mean = tf.constant(\n                self.mean, dtype=tf.float32, shape=[1, 1, 1, 3], name=\"img_mean\"\n            )\n            images = self.imgs - mean\n\n        # conv1_1\n        with tf.name_scope(\"conv1_1\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 3, 64], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[64], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv1_1 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv1_2\n        with tf.name_scope(\"conv1_2\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 64, 64], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv1_1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[64], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv1_2 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # pool1\n        self.pool1 = tf.nn.max_pool(\n            self.conv1_2,\n            ksize=[1, 2, 2, 1],\n            strides=[1, 2, 2, 1],\n            padding=\"SAME\",\n            name=\"pool1\",\n        )\n\n        # conv2_1\n        with tf.name_scope(\"conv2_1\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 64, 128], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.pool1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[128], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv2_1 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv2_2\n        with tf.name_scope(\"conv2_2\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 128, 128], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv2_1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[128], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv2_2 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # pool2\n        self.pool2 = tf.nn.max_pool(\n            self.conv2_2,\n            ksize=[1, 2, 2, 1],\n            strides=[1, 2, 2, 1],\n            padding=\"SAME\",\n            name=\"pool2\",\n        )\n\n        # conv3_1\n        with tf.name_scope(\"conv3_1\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 128, 256], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.pool2, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[256], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv3_1 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv3_2\n        with tf.name_scope(\"conv3_2\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv3_1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[256], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv3_2 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv3_3\n        with tf.name_scope(\"conv3_3\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv3_2, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[256], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv3_3 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # pool3\n        self.pool3 = tf.nn.max_pool(\n            self.conv3_3,\n            ksize=[1, 2, 2, 1],\n            strides=[1, 2, 2, 1],\n            padding=\"SAME\",\n            name=\"pool3\",\n        )\n\n        # conv4_1\n        with tf.name_scope(\"conv4_1\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 256, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.pool3, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv4_1 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv4_2\n        with tf.name_scope(\"conv4_2\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv4_1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv4_2 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv4_3\n        with tf.name_scope(\"conv4_3\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv4_2, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv4_3 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # pool4\n        self.pool4 = tf.nn.max_pool(\n            self.conv4_3,\n            ksize=[1, 2, 2, 1],\n            strides=[1, 2, 2, 1],\n            padding=\"SAME\",\n            name=\"pool4\",\n        )\n\n        # conv5_1\n        with tf.name_scope(\"conv5_1\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.pool4, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv5_1 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv5_2\n        with tf.name_scope(\"conv5_2\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv5_1, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv5_2 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # conv5_3\n        with tf.name_scope(\"conv5_3\") as scope:\n            kernel = tf.Variable(\n                tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            conv = tf.nn.conv2d(self.conv5_2, kernel, [1, 1, 1, 1], padding=\"SAME\")\n            biases = tf.Variable(\n                tf.constant(0.0, shape=[512], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n            out = tf.nn.bias_add(conv, biases)\n            self.conv5_3 = tf.nn.relu(out, name=scope)\n            self.parameters += [kernel, biases]\n\n        # pool5\n        self.pool5 = tf.nn.max_pool(\n            self.conv5_3,\n            ksize=[1, 2, 2, 1],\n            strides=[1, 2, 2, 1],\n            padding=\"SAME\",\n            name=\"pool5\",\n        )\n        # MaxPool6\n        self.maxpool5 = tf.nn.max_pool(\n            self.pool5,\n            ksize=[1, 7, 7, 1],\n            strides=[1, 1, 1, 1],\n            padding=\"SAME\",\n            name=\"maxpool5\",\n        )\n\n        # AvgPool6\n        self.avgpool5 = tf.nn.avg_pool(\n            self.pool5,\n            ksize=[1, 7, 7, 1],\n            strides=[1, 1, 1, 1],\n            padding=\"SAME\",\n            name=\"avgpool5\",\n        )\n\n    def dan_part(self):\n\n        # fc1\n        with tf.name_scope(\"reg_head\") as scope:\n            shape = 2 * int(np.prod(self.maxpool5.get_shape()[1:]))\n            fc1w = tf.Variable(\n                tf.truncated_normal([shape, 5], dtype=tf.float32, stddev=1e-1),\n                name=\"weights\",\n            )\n            fc1b = tf.Variable(\n                tf.constant(1.0, shape=[5], dtype=tf.float32),\n                trainable=True,\n                name=\"biases\",\n            )\n\n            maxpool5_flat = tf.nn.l2_normalize(\n                tf.reshape(self.maxpool5, [-1, int(shape \/ 2)]), 1\n            )\n            avgpool5_flat = tf.nn.l2_normalize(\n                tf.reshape(self.avgpool5, [-1, int(shape \/ 2)]), 1\n            )\n\n            self.concat = tf.concat([maxpool5_flat, avgpool5_flat], 1)\n            self.reg_head = tf.nn.bias_add(\n                tf.matmul(self.concat, fc1w), fc1b, name=scope\n            )\n            self.parameters += [fc1w, fc1b]\n\n    def initialize_with_vggface(self, weight_file, sess):\n        data = loadmat(weight_file)\n        layers = data[\"layers\"][0]\n        i = 0\n        for layer in layers:\n            name = layer[0][\"name\"][0][0]\n            layer_type = layer[0][\"type\"][0][0]\n            if layer_type == \"conv\" and name[0:2] != \"fc\":\n                kernel, bias = layer[0][\"weights\"][0][0]\n                sess.run(self.parameters[i].assign(kernel))\n                sess.run(self.parameters[i + 1].assign(bias.reshape(bias.shape[0])))\n                i += 2\n\n    def load_trained_model(self, pickle_file, sess):\n        with open(pickle_file, \"rb\") as pfile:\n            param = pickle.load(pfile)\n        for i in range(len(param)):\n            sess.run(self.parameters[i].assign(param[i]))\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_155","text":"'''\npunjabi-pca: PCA analysis for Punjabi project (Kochetov, Faytak, Nara).\n  WARNING: Largely superceded by .\/punjabi-series-pca-lda.py\n'''\n\nimport argparse\nimport glob\nimport matplotlib.pyplot as plt\nimport numpy as np \nimport os\nimport pandas as pd\nimport re\nimport sys\n\nfrom hashlib import sha1\nfrom scipy.ndimage import median_filter\nfrom sklearn.decomposition import PCA\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n\n# read in args\nparser = argparse.ArgumentParser()\nparser.add_argument(\"directory\", help=\"Experiment directory containing all subjects\")\nargs = parser.parse_args()\n\n# check for appropriate directory\nexpdir = args.directory\ntry:\n    assert os.path.exists(args.directory)\nexcept AssertionError:\n    # TODO raise exception\n    print(\"\\tDirectory provided doesn't exist\")\n    parser.print_help()\n    sys.exit(2)\n\ndata_in = os.path.join(expdir,\"frames.npy\")\ndata = np.load(data_in)\nmetadata_in = os.path.join(expdir,\"frames_metadata.pickle\")\nmd = pd.read_pickle(metadata_in)\n\n# sanity checks\nassert(len(md) == data.shape[0]) # make sure one md row for each frame\nassert(md.loc[0, 'sha1'] == sha1(data[0].ravel()).hexdigest()) # checksums\nassert(md.loc[len(md)-1,'sha1'] == sha1(data[-1].ravel()).hexdigest())\n\nn_pca = 4\n#n_lda = 1\nimage_shape = data[0].shape # base off of first frame\n\nsubject = []\nphase = []\ntrial = []\nphone = []\n\nfor s in np.unique(md['subject']):\n\t# subset data by subject ID\n\tsubj_mask = (md['subject'] == s) \n\tsubj_mask = subj_mask.as_matrix()\n\tmodel_data = data[subj_mask]\n\tmodel_md = md[subj_mask]\n\t\t\t\n\t# preallocate array for ultrasound frames for PCA\n\tmodel_array = np.empty([model_data.shape[0]] + list(model_data[0].shape)) * np.nan\n\tmodel_array = model_array.astype('uint8')\n\t\t\n\t# fill in the preallocated array, applying median filter (and any other desired transforms)\n\tfor idx,frame in enumerate(model_data):\n\t\tfilt_frame = median_filter(frame, 5)\n\t\tmodel_array[idx,:,:] = filt_frame # frame\n\t\n\t# run PCA with three PCs\n\tn_components = int(n_pca)\n\tpca = PCA(n_components=int(n_components)) \n\tarray_reshaped = model_array.reshape([\n\t\t\t\tmodel_array.shape[0],\n\t\t\t\tmodel_array.shape[1] * model_array.shape[2]\n\t\t\t\t])\n\tpca.fit(array_reshaped)\n\tcumulative_var_exp = sum(pca.explained_variance_ratio_)\n\n\tprint(\"Subj.{}: PCA with {} PCs explains {} of variation\".format(s,\n\t\t\tn_components,\n\t\t\tround(cumulative_var_exp,4)\n\t\t\t))\n\n\tpca_out = pca.transform(array_reshaped)\n\n\t# output PC values by acquisition\n\n\t# create output table headers\n\tpc_headers = [\"pc\"+str(i+1) for i in range(0,n_components)] # n. of PC columns changes acc. to n_components\n\tmeta_headers = list(md.columns.values)\n\theaders = meta_headers + pc_headers\n\n\t# create output table\n\theadless = np.column_stack((md[meta_headers], pca_out))\n\td = np.row_stack((headers, headless)) \n\n\tout_filename = \"{}_pca.csv\".format(s)\n\tout_path = os.path.join(expdir,out_filename)\n\tnp.savetxt(out_path, d, fmt=\"%s\", delimiter ='\\t')\n\n\t# TODO once relevant, output one table across multiple subjects?\n\n\t# output eigentongues\n\tif n_components < 5:\n\t\tn_output_pcs = n_components\n\telse:\n\t\tn_output_pcs = 5\n\n\tfor n in range(0,n_output_pcs):\n\t\tdd = pca.components_[n].reshape(image_shape)\n\t\tmag = np.max(dd) - np.min(dd)\n\t\tpc_load = (dd-np.min(dd))\/mag*255\n\t\tplt.title(\"PC{:} min\/max loadings, Subj. {:}\".format((n+1),s))\n\t\tplt.imshow(pc_load, cmap=\"Greys_r\")\n\t\tfile_ending = \"{:}-pc{:}.pdf\".format(s, (n+1))\n\t\tsavepath = os.path.join(expdir,file_ending) # TODO redefine save path if needed\n\t\tplt.savefig(savepath)"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_156","text":"<filename>tests\/plot\/fixtures.py\n# fixtures.py\n# Copyright (c) 2013-2016 <NAME>\n# See LICENSE for details\n# pylint: disable=C0111,E0611,W0621\n\n# Standard library imports\nfrom __future__ import print_function\nimport os\nimport shutil\nimport subprocess\n# PyPI imports\nimport numpy\nimport pytest\nimport scipy\nfrom scipy.misc import imread\n# Putil imports\nimport putil.plot\n\n\n###\n# Global variables\n###\nIMGTOL = 1e-3\n\n###\n# Fixtures\n###\ndef compare_images(image_file_name1, image_file_name2, no_print=True):\n    \"\"\" Compare two images by calculating Manhattan and Zero norms \"\"\"\n    # Source: http:\/\/stackoverflow.com\/questions\/189943\/\n    # how-can-i-quantify-difference-between-two-images\n    img1 = imread(image_file_name1).astype(float)\n    img2 = imread(image_file_name2).astype(float)\n    if img1.size != img2.size:\n        m_norm, z_norm = 2*[2*IMGTOL]\n    else:\n        # Element-wise for Scipy arrays\n        diff = img1-img2\n        # Manhattan norm\n        m_norm = scipy.sum(numpy.abs(diff))\n        # Zero norm\n        z_norm = scipy.linalg.norm(diff.ravel(), 0)\n    result = bool((m_norm < IMGTOL) and (z_norm < IMGTOL))\n    if not no_print:\n        print(\n            'Image 1: {0}, Image 2: {1} -> ({2}, {3}) [{4}]'.format(\n                image_file_name1, image_file_name2, m_norm, z_norm, result\n            )\n        )\n    return result\n\n\ndef compare_image_set(tmpdir, images_dict_list, section):\n    \"\"\" Compare image sets \"\"\"\n    subdir = 'test_images_{0}'.format(section)\n    tmpdir.mkdir(subdir)\n    global_result = True\n    for images_dict in images_dict_list:\n        ref_file_name_list = images_dict['ref_fname']\n        test_file_name = images_dict['test_fname']\n        print('Reference images:')\n        for ref_file_name in ref_file_name_list:\n            print('   file:\/\/{0}'.format(\n                    os.path.realpath(ref_file_name)\n                )\n            )\n        print('Actual image:')\n        print('   file:\/\/{0}'.format(\n                os.path.realpath(test_file_name)\n            )\n        )\n        partial_result = []\n        for ref_file_name in ref_file_name_list:\n            partial_result.append(\n                compare_images(ref_file_name, test_file_name)\n            )\n        result = any(partial_result)\n        global_result = global_result and partial_result\n        if not result:\n            print('Images do not match')\n            export_image(test_file_name)\n        print('')\n    if global_result:\n        try:\n            tmpdir.remove(subdir)\n        except OSError: # pragma: no cover\n            pass\n    return global_result\n\n\n@pytest.fixture\ndef default_source():\n    \"\"\"\n    Provides a default source to be used in testing the\n    putil.plot.Series class\n    \"\"\"\n    return putil.plot.BasicSource(\n        indep_var=numpy.array([5, 6, 7, 8]),\n        dep_var=numpy.array([0, -10, 5, 4])\n    )\n\n\n@pytest.fixture\ndef default_series(default_source):\n    \"\"\"\n    Provides a default series object to be used in testing the\n    putil.plot.Panel class\n    \"\"\"\n    return putil.plot.Series(\n        data_source=default_source,\n        label='test series'\n    )\n\n\n@pytest.fixture\ndef default_panel(default_series):\n    \"\"\"\n    Provides a default panel object to be used in testing the\n    putil.plot.Figure class\n    \"\"\"\n    return putil.plot.Panel(\n        series=default_series,\n        primary_axis_label='Primary axis',\n        primary_axis_units='A',\n        secondary_axis_label='Secondary axis',\n        secondary_axis_units='B'\n    )\n\n\ndef export_image(fname, method=True):\n    tdir = os.path.dirname(\n        os.path.dirname(\n            os.path.dirname(os.path.abspath(__file__))\n        )\n    )\n    artifact_dir = os.path.join(tdir, 'artifacts')\n    if not os.path.exists(artifact_dir):\n        os.makedirs(artifact_dir)\n    if method:\n        src = fname\n        dst = os.path.join(artifact_dir, os.path.basename(fname))\n        shutil.copyfile(src, dst)\n    else:\n        if os.environ.get('APPVEYOR', None):\n            proc = subprocess.Popen(\n                ['appveyor', 'PushArtifact', os.path.realpath(fname)],\n                stdout=subprocess.PIPE,\n                stderr=subprocess.STDOUT\n            )\n            proc.communicate()\n        elif os.environ.get('TRAVIS', None):\n            # If only a few binary files need to be exported a hex dump works,\n            # otherwise the log can grow past 4MB and the process is terminated\n            # by Travis\n            proc = subprocess.Popen(\n                [\n                    os.path.join(tdir, 'sbin', 'png-to-console.sh'),\n                    os.path.realpath(fname)\n                ],\n                stdout=subprocess.PIPE,\n                stderr=subprocess.STDOUT\n            )\n            stdout, _ = proc.communicate()\n            print(stdout)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_158","text":"<reponame>whdcumt\/exposure_correction\n\nimport cv2\nimport numpy as np\nimport scipy.sparse as spsparse\n\n\t\t# 1. find all boundaries between two components using adj_mat\n\t\t# 2. find the minimum weight between them\n\t\t# scratch that, instead need to form and maintain a new adjacency matrix\n\t\t# which retains the minimum weight between each component\n\n\t\t# Adjacency matrix is going to shrink by 1 for each component merged \n\t\t# at stage 0 the adjacency matrix and components hash are consistent\n\t\t# updates need to handle both components hash AND adjacency matrix\n\n\t\t# NEWEST ISSUE:\n\t\t# Need to deal with max internal weights in adjacency\n\n\t\t# TODO: solve out ground truth for test image\n\nclass ExposureCorrector():\n\timg = []\n\tadj_mat = []\n\t# ^ this guy represents adjacency of COMPONENTS, not individual pixels\n\t# the weights indicate the minimum weight between neighboring components\n\t# diagonal = max internal weight\n\n\tcomponents = {}\n\t# self.internal_weights = {}\n\tw = 0\n\th = 0\n\t\n\tk = 300\n\n\tdef get_adjacency_matrix(self, img):\n\t\tself.img = img\n\t\trows = np.shape(img)[0]\n\t\tcols = np.shape(img)[1]\n\n\t\tself.w = cols\n\t\tself.h = rows\n\n\t\th_connections = np.ones((cols, 1))\n\t\th_connections[-1] = 0;\n\n\t\tdiag_h = np.tile(h_connections, (rows, 1))\n\t\tdiag_h = diag_h[0:-1]\n\t\tprint diag_h.shape\n\t\tassert(diag_h.shape[0] == rows*cols - 1)\n\t\t\n\t\tdiag_v = np.ones((cols*(rows-1), 1))\n\t\tprint diag_v.shape\n\t\tassert(diag_v.shape[0] == rows*cols - cols)\n\n\t\tdiagonals = [diag_h.T, diag_v.T]\n\n\t\tself.adj_mat = spsparse.diags(diagonals, [1, cols], shape=(rows*cols, rows*cols), format='lil', dtype=np.uint8)\n\t\t\n\t\treturn self.adj_mat\n\n\tdef init_components(self):\n\t\t# make a hash of the initial components with each pixel in it's own \n\t\t# component\n\t\tnum_pixels = self.w * self.h\n\n\t\tfor i in range(num_pixels):\n\t\t\tpixel_row = int(i \/ self.w);\n\t\t\tpixel_col = i % self.w;\n\t\t\tself.components[i] = [(pixel_row, pixel_col)]\n\n\t\treturn self.components\n\n\n\tdef init_adj_weights(self):\n\t\t# at this point each pixel is in it's own component\n\n\t\t# for each pixel, initial weight = abs(pix[i] - pix[j])\n\t\tnonzero = self.adj_mat.nonzero()\n\t\tprint nonzero[0]\n\t\tprint nonzero[1]\t\t\n\n\t\tfor i in range(len(nonzero[0])):\n\t\t\thome_pix = nonzero[0][i]\n\t\t\tneighbor = nonzero[1][i]\n\n\t\t\thome_i = self.pix_num_to_index(home_pix)\n\t\t\thome_val = self.img[home_i[0], home_i[1]]\n\t\t\t\n\t\t\tneighbor_i = self.pix_num_to_index(neighbor)\n\t\t\tneighbor_val = self.img[neighbor_i[0], neighbor_i[1]]\n\n\t\t\tself.adj_mat[home_pix, neighbor] = abs(home_val - neighbor_val)\n\n\t\t# for i in range(len(self.components.keys())):\n\t\t# \tself.adj_mat[i, i] = 0\n\n\tdef segment_img(self):\n\t\tnum_changes = 1\n\t\twhile (num_changes != 0):\n\t\t\tkeys_to_delete = []\n\t\t\tnum_changes = 0\n\n\t\t\tcomponents = self.components.keys()\n\n\t\t\tfor c in components:\n\t\t\t\tif (c in self.components):\n\t\t\t\t\t# keys = self.update_component(c)\n\t\t\t\t\tnum_changes += self.update_component(c)\n\t\t\t\t\t\n\t\t\t\t\t# for j in keys:\n\t\t\t\t\t# \tkeys_to_delete.append(j)\n\t\t\t\n\t\t\t# Delete Keys from merges:\n\t\t\t# for k in keys_to_delete:\n\t\t\t# \tself.components.pop(k, None)\n\n\t\t\tprint \"Number of merges: \" + str(num_changes)\n\t\t\tprint \"Total components: \" + str(len(self.components.keys()))\n\t\t\tprint \"\"\n\n\t\treturn self.components\n\n\n\tdef update_component(self, c1):\n\t\tkeys_to_delete = []\n\t\tnum_changes = 0\n\t\tadj_components = self.adj_mat.getrow(c1).nonzero()\n\t\tprint adj_components[1]\n\t\tfor c2 in adj_components[1]:\n\t\t\t# skip if we deleted component already\n\t\t\tif (c2 != c1) and (c2 in self.components):\n\t\t\t\tif (self.check_boundary(c1, c2, self.k) == False):\n\t\t\t\t\tself.merge_components(c1, c2)\n\t\t\t\t\tprint \"merged \" + str(c1) + \" and \" + str(c2)\n\t\t\t\t\tnum_changes += 1\n\t\t\t\t\t# keys_to_delete.append(c2)\n\n\n\t\treturn num_changes\n\n\n\tdef check_boundary(self, c1, c2, k):\n\t\tboundary = True\n\t\tm_int = min([self.adj_mat[c1, c1] + k\/len(self.components[c1]), self.adj_mat[c2, c2] + k\/len(self.components[c2])]) \n\t\t\n\t\tif self.adj_mat[c1, c2] > m_int:\n\t\t\tboundary = True\n\t\telse:\n\t\t\tboundary = False\n\n\t\treturn boundary\n\n\tdef merge_components(self, c1, c2):\n\t\t# copy all elements of c2 into c1 \n\t\tto_copy = self.components[c2]\n\t\tfor pixel in to_copy:\n\t\t\tself.components[c1].append(pixel)\n\n\t\t# copy adjacency matrix info\n\t\tself.merge_adj_mat(c1, c2)\n\n\t\t# delete component in component hash\n\t\tself.components.pop(c2, None)\n\n\t\tprint self.adj_mat.toarray()\n\t\treturn 0\n\n\tdef merge_adj_mat(self, c1, c2):\n\t\tc1_adj = self.adj_mat.getrow(c1)\n\t\tc2_adj = self.adj_mat.getrow(c2)\n\n\t\tc2_nonzero = c2_adj.nonzero()\n\n\t\tfor component in c2_nonzero[1]:\n\t\t\tif component == c1:\n\t\t\t\tprint \"update max\"\n\t\t\t\t# update max internal weight\n\t\t\t\tc1_adj[0, component] = max(c1_adj[0, component], c2_adj[0, component])\n\t\t\telse:\n\t\t\t\t# update minimum connection to neighbors\n\t\t\t\tif (c1_adj[0, component] == 0):\n\t\t\t\t\tc1_adj[0, component] = c2_adj[0, component]\n\t\t\t\telif (c2_adj[0, component] == 0): \n\t\t\t\t\tc1_adj[0, component] = c1_adj[0, component]\n\t\t\t\telse:\n\t\t\t\t\tc1_adj[0, component] = min(c1_adj[0, component], c2_adj[0, component])\n\t\t\t\t\t\n\n\n\t\tself.adj_mat[c1, :] = c1_adj\n\n\t\t# delete c2's row and col in adj_mat?\n\t\t# for now, zero out\n\t\tself.adj_mat[c2, :] = 0\n\t\tself.adj_mat[:, c2] = 0\n\n\t\treturn 0\n\n\t\n\tdef pix_num_to_index(self, pix_num):\n\t\trow = int(pix_num \/ self.w)\n\t\tcol = pix_num % self.w\n\t\treturn (row, col)\n\n\n\tdef min_x_weight(self, c1, c2):\n\t\t# get the minimum weight between two components\n\n\t\tpass\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_159","text":"<gh_stars>1-10\n\"\"\"LQR, iLQR and MPC.\"\"\"\n\nfrom deeprl_hw3.controllers import approximate_A, approximate_B\nimport numpy as np\nimport scipy.linalg\nimport time\n\nfrom ipdb import set_trace as debug\n\ndef simulate_dynamics_next(env, x, u):\n    \"\"\"Step simulator to see how state changes.\n\n    Parameters\n    ----------\n    env: gym.core.Env\n      The environment you are try to control. In this homework the 2\n      link arm.\n    x: np.array\n      The state to test. When approximating A you will need to perturb\n      this.\n    u: np.array\n      The command to test. When approximating B you will need to\n      perturb this.\n\n    Returns\n    -------\n    next_x: np.array\n    \"\"\"\n\n    env.state = x.copy()\n    x1, _, _, _ = env.step(u)\n    return x1\n\n\ndef cost_inter(env, x, u, discrete=False):\n    \"\"\"intermediate cost function\n\n    Parameters\n    ----------\n    env: gym.core.Env\n      The environment you are try to control. In this homework the 2\n      link arm.\n    x: np.array\n      The state to test. When approximating A you will need to perturb\n      this.\n    u: np.array\n      The command to test. When approximating B you will need to\n      perturb this.\n    discrete: boolean\n      if True, multiply the env.dt\n\n    Returns\n    -------\n    l, l_x, l_xx, l_u, l_uu, l_ux. The first term is the loss, where the remaining terms are derivatives respect to the\n    env, corresponding variables, ex: (1) l_x is the first order derivative d l\/d x (2) l_xx is the second order derivative\n    d^2 l\/d x^2\n    \"\"\"\n    num_actions = env.action_space.shape[0]\n    num_states = env.observation_space.shape[0]\n    dt = env.dt if discrete else 1.\n\n    l = np.sum(u**2)*dt\n    l_x = np.zeros(num_states)*dt\n    l_xx = np.zeros((num_states, num_states))*dt\n    l_u = 2 * u*dt\n    l_uu = 2 * np.eye(num_actions)*dt\n    l_ux = np.zeros((num_actions, num_states))*dt\n\n    return l, l_x, l_xx, l_u, l_uu, l_ux\n\n\ndef cost_final(env, x):\n    \"\"\"cost function of the last step\n\n    Parameters\n    ----------\n    env: gym.core.Env\n      The environment you are try to control. In this homework the 2\n      link arm.\n    x: np.array\n      The state to test. When approximating A you will need to perturb\n      this.\n\n    Returns\n    -------\n    l, l_x, l_xx The first term is the loss, where the remaining terms are derivatives respect to the\n    corresponding variables\n    \"\"\"\n\n    num_states = env.observation_space.shape[0]\n    target = env.goal.copy()\n\n    # calculate l, l_x, l_xx\n    weight = 1e4\n    l = weight * np.sum((x-target)**2)\n    l_x = 2.*weight*(x-target)\n    l_xx = 2.*weight*np.eye(num_states)\n    \n    return l, l_x, l_xx\n\n    \ndef simulate(env, x0, U):\n    tN = U.shape[0]\n    num_states = env.observation_space.shape[0]\n\n    X = np.zeros((tN, num_states))\n    X[0] = x0\n    cost = 0.\n    for t in range(tN-1):\n        X[t+1] = simulate_dynamics_next(env, X[t], U[t])\n        l,_,_,_,_,_ = cost_inter(env, X[t], U[t], discrete=True)\n        cost += l\n\n    l_f,_,_ = cost_final(env, X[-1])\n    cost += l_f\n\n    return X, cost\n\n\ndef solve(env, x0, U, max_iter, useLM, debug_flag):\n    # initialize paramters\n    action_dim = env.action_space.shape[0] \n    state_dim = env.observation_space.shape[0]\n\n    sim_new_trajectory = True \n    lamb = 1.0\n    lamb_factor = 10\n    lamb_max = 1000\n    eps_converge = 0.001\n    tN = U.shape[0]\n\n    x0 = env.state.copy()\n    for ii in range(int(max_iter)):\n        # f, c            \n        if sim_new_trajectory: \n\n            X, cost = simulate(env, x0, U)\n            oldcost = np.copy(cost)\n\n            # linearized dynamics\n            f_x = np.zeros((tN, state_dim, state_dim)) \n            f_u = np.zeros((tN, state_dim, action_dim)) \n\n            # quadratized cost function \n            l = np.zeros((tN,1)) \n            l_x = np.zeros((tN, state_dim))\n            l_xx = np.zeros((tN, state_dim, state_dim))\n            l_u = np.zeros((tN, action_dim)) \n            l_uu = np.zeros((tN, action_dim, action_dim)) \n            l_ux = np.zeros((tN, action_dim, state_dim))\n\n            for t in range(tN-1):\n                A = approximate_A(env, X[t].copy(), U[t].copy(), dt=env.dt)\n                B = approximate_B(env, X[t].copy(), U[t].copy(), dt=env.dt) \n                f_x[t] = np.eye(state_dim) + A * env.dt\n                f_u[t] = B * env.dt\n                \n                (l[t], l_x[t], l_xx[t], l_u[t], l_uu[t], l_ux[t]) = \\\n                    cost_inter(env, X[t], U[t], discrete=True)\n\n            l[-1], l_x[-1], l_xx[-1] = cost_final(env, X[-1])   \n            sim_new_trajectory = False\n\n        # f, k update\n        V = l[-1].copy() # value function\n        V_x = l_x[-1].copy() # dV \/ dx\n        V_xx = l_xx[-1].copy() # d^2 V \/ dx^2\n        k = np.zeros((tN, action_dim)) # feedforward modification\n        K = np.zeros((tN, action_dim, state_dim)) # feedback gain \n\n        # backward\n        for t in range(tN-2, -1, -1):\n            Q_x = l_x[t] + np.dot(f_x[t].T, V_x) \n            Q_u = l_u[t] + np.dot(f_u[t].T, V_x)\n\n            Q_xx = l_xx[t] + np.dot(f_x[t].T, np.dot(V_xx, f_x[t])) \n            Q_ux = l_ux[t] + np.dot(f_u[t].T, np.dot(V_xx, f_x[t]))\n            Q_uu = l_uu[t] + np.dot(f_u[t].T, np.dot(V_xx, f_u[t]))\n\n            # Calculate Q_uu^-1 with regularization term set by \n            # Levenberg-Marquardt heuristic (at end of this loop)\n            Q_uu_evals, Q_uu_evecs = np.linalg.eig(Q_uu)\n            Q_uu_evals[Q_uu_evals < 0] = 0.0\n            Q_uu_evals += lamb\n            Q_uu_inv = np.dot(Q_uu_evecs, \n                np.dot(np.diag(1.0\/Q_uu_evals), Q_uu_evecs.T))\n\n            k[t] = -np.dot(Q_uu_inv, Q_u)\n            K[t] = -np.dot(Q_uu_inv, Q_ux)\n\n            V_x = Q_x - np.dot(K[t].T, np.dot(Q_uu, k[t]))\n            V_xx = Q_xx - np.dot(K[t].T, np.dot(Q_uu, K[t]))\n\n\n        # forward\n        Unew = np.zeros((tN, action_dim))\n        xnew = x0.copy() \n        for t in range(tN - 1): \n            Unew[t] = U[t] + k[t] + np.dot(K[t], xnew - X[t]) \n            xnew = simulate_dynamics_next(env, xnew, Unew[t]) \n\n        # evaluate the new trajectory \n        Xnew, costnew = simulate(env, x0, Unew)\n\n        # Levenberg-Marquardt heuristic\n        if costnew <= cost: \n\n            if useLM:\n                lamb \/= lamb_factor\n\n            X = np.copy(Xnew) # update trajectory \n            U = np.copy(Unew) # update control signal\n            oldcost = np.copy(cost)\n            cost = np.copy(costnew)\n\n            sim_new_trajectory = True \n\n            if ii > 0 and ((abs(oldcost-cost)\/cost) < eps_converge):\n                if debug_flag: \n                    print(\"Converged at iteration = %d; Cost = %.4f;\"%(ii,costnew) + \n                            \" logLambda = %.1f\"%np.log(lamb))\n                break\n\n        else: \n            #  gradient descent\n            if useLM:\n                lamb *= lamb_factor\n            if debug_flag and lamb > lamb_max: \n                print(\"lambda > max_lambda at iteration = %d;\"%ii + \n                        \" Cost = %.4f; logLambda = %.1f\"%(cost, \n                                                          np.log(lamb)))\n\n    return X, U, cost\n\n\nU = None\nt = -1\ndef calc_ilqr_input(env, sim_env, \n    tN=50, max_iter=1e6, useLM=False, debug_flag=False):\n    \"\"\"Calculate the optimal control input for the given state.\n\n\n    Parameters\n    ----------\n    env: gym.core.Env\n      This is the true environment you will execute the computed\n      commands on. Use this environment to get the Q and R values as\n      well as the state.\n    sim_env: gym.core.Env\n      A copy of the env class. Use this to simulate the dynamics when\n      doing finite differences.\n    tN: number of control steps you are going to execute\n    max_itr: max iterations for optmization\n\n    Returns\n    -------\n    U: np.array\n      The SEQUENCE of commands to execute. The size should be (tN, #parameters)\n    \"\"\"\n    global U\n    global t\n\n    action_dim = env.action_space.shape[0]\n\n    # update t\n    t = np.mod(t+1,tN)\n    sim_env.state = env.state.copy()\n\n    if U is None:\n        if debug_flag: t0 = time.time()\n        U = np.zeros((tN,action_dim))\n        x0 = sim_env.state.copy()\n        X, U, cost = solve(sim_env, x0, U, max_iter, useLM, debug_flag)\n        if debug_flag: print('solve with {}'.format(time.time()-t0))\n\n    u = U[t]\n\n    # reset\n    if t == tN-1:\n        if debug_flag: print('reset')\n        U = None\n\n    return u\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_402","text":"import pandas as pd\nfrom scipy.stats import chi2_contingency\n\nclass ContingencyChiSquare:\n    \"\"\"\n    Helper class for generating contingency table and chi square statistics\n    \"\"\"\n   \n    # Defining the function for creating contigency table\n    def get_contingency_table(self,column1, column2):\n        self.contingeny_table = pd.crosstab(index= column1, columns= column2)\n        return self.contingeny_table\n\n    #Definig function for getting chi square test\n    def get_chi_square_stats(self,column1,column2):\n        self.contingeny_table = self.get_contingency_table(column1,column2)\n        self.chi_results = chi2_contingency(self.contingeny_table.values)\n        return self.chi_results\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_403","text":"'''\nCreated on Sep 29, 2015\n\n@author: ash\n'''\n\n# import libraries\nimport networkx as nx\nimport matplotlib.pyplot as plt\nimport random\nimport math\nimport numpy as np\nfrom scipy.interpolate import UnivariateSpline\nfrom scipy.interpolate import splprep, splev\nfrom numpy import linspace\nfrom optparse import OptionParser\nimport sys\nimport os\nimport pysal\n\nshpRoomURL = \"\/home\/ash\/Dropbox\/OSU\/BIM\/osuSmithLabShpFile\/065-0b.shp\"\nshpTrajectoryURL = \"\/home\/ash\/Dropbox\/OSU\/BIM\/osuSmithLabShpFile\/osusmith065-0b.shp\"\n\nshpFileURL = \"\/home\/ash\/Data\/FixedShapeFiles\/osusmithlabfloor02\/065-02lines.shp\"\n\n\ndef showRoomNTrajectories():\n    roomd = nx.read_shp(shpRoomURL)\n    trajectoryd = nx.read_shp(shpTrajectoryURL)\n    \n    room = roomd.to_undirected()\n    trajectory = trajectoryd.to_undirected()\n    \n    print room.nodes(data=False)\n    print trajectory.nodes(data=False)\n    \n    nodeList = room.nodes(data=True)\n    nNode = len(nodeList)\n    pos = []\n    for i in xrange(nNode): pos.append(nodeList[i][0])\n    roomLayout = dict(zip(room,pos))\n    \n    nodeList = trajectory.nodes(data=True)\n    nNode = len(nodeList)\n    pos = []\n    for i in xrange(nNode): pos.append(nodeList[i][0])\n    trajectoryLayout = dict(zip(trajectory, pos))\n    \n    plt.figure(1)\n    nx.draw_networkx_edges(room, pos=roomLayout, edgelist=None, width=2, edge_color='k', style='-', alpha=0.8)\n    nx.draw_networkx_edges(trajectory, pos = trajectoryLayout, edgelist=None, width=1, edge_color='b', style='-', alpha=0.2)\n    plt.show()\n    pass\n\ndef showShpFileData(shpFileURL):\n    shpData = nx.read_shp(shpFileURL)\n    shpData = shpData.to_undirected()\n    \n    print shpData.nodes(data=True)\n    for edge in shpData.edges(data=True):\n        print edge\n    \n    nodeList = shpData.nodes(data=True)\n    nNode = len(nodeList)\n    \n    pos = []\n    for i in xrange(nNode):\n        pos.append(nodeList[i][0])\n        pass\n    \n    shpLayout = dict(zip(shpData,pos))\n    \n    plt.figure(1)\n    nx.draw_networkx_edges(shpData, pos=shpLayout, edgelist=None, width=1, edge_color='b', style='-', alpha=0.5)\n    nx.draw_networkx_nodes(shpData, pos=shpLayout, nodelist=None, node_size=2)\n    \n    print len(shpData.nodes(data=False))\n    print len(shpData.edges(data=False))\n    \n    plt.show()\n\n\nif __name__ == '__main__':\n#     showRoomNTrajectories()\n    showShpFileData(shpFileURL)\n    pass"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_405","text":"<gh_stars>1-10\n#!\/usr\/bin\/env python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pickle\n\nfrom astropy.io import fits\nfrom astropy.io import ascii\nfrom argparse import ArgumentParser\nfrom os import listdir\nfrom os.path import isfile, join\nfrom sklearn.decomposition import PCA\nfrom scipy.stats import norm\nfrom scipy.stats import lognorm\n\nplt.rcParams[\"figure.figsize\"] = (8, 6)\nplt.rcParams[\"font.size\"] = 14\n\n''' Parsing arguments '''\nparser = ArgumentParser()\nparser.add_argument(\"-d\", \"--display\", help=\"Plot spectra\", dest='display', action='store_true')\nparser.set_defaults(display=False)\nparser.add_argument(\"-m\", \"--model\", help=\"Model of PCA to generate the QSO\", type=str, metavar=\"PATH_TO_MODEL\", default=\"\")\nparser.add_argument(\"-o\", \"--output_file\", help=\"Output file for the spectrum - Will overwrite existing file\", type=str, metavar=\"OUTPUT_FILE\", default=\"..\/output\/spectrum.txt\")\nparser.add_argument(\"-p\", \"--set_p_values\", help=\"Set the p_value at which to draw the coefficients of the components from the cumulative pdf (cdf) - no need to specify all the p_value of all the components\", type=float, metavar=\"p_value_1 p_value_2 ... p_value_n\", nargs='+')\nparser.add_argument(\"-s\", \"--seed\", help=\"Seed for random generator\", type=int, metavar=\"SEED\", default=0)\nparser.add_argument(\"-z\", \"--redshift\", help=\"Redshift of the generated spectrum\", type=float, metavar=\"REDSHIFT\")\narg = parser.parse_args()\nmodel_file = arg.model\nredshift = arg.redshift\noutput_file = arg.output_file\nseed = arg.seed\ndisplay = arg.display\ninput_p_values = arg.set_p_values \nnp.random.seed(seed)\nprint(input_p_values)\n\n''' Loading model '''\nwith open(model_file,\"rb\") as model:\n\tpca_redshifts = np.array(pickle.load(model,encoding='latin1'))\n\tpcas = pickle.load(model,encoding='latin1')\n\tlambda_centers = pickle.load(model,encoding='latin1')\n\tmu = pickle.load(model,encoding='latin1')\n\tsigma = pickle.load(model,encoding='latin1')\n\tlognormal = pickle.load(model,encoding='latin1')\n\n''' Finding model for given redshift '''\ndelta_z = abs(pca_redshifts - redshift)\nind = np.where(delta_z == delta_z.min())[0][0]\nprint('Delta_z between spectrum and model:', delta_z.min())\n\n''' Computing coeffs '''\nbins_norm = np.linspace(-100,100,20000)\nbins_lognorm = np.logspace(-1,7,20000)\n\np_values = np.ones(len(mu[ind])) * -99\np_values[:len(input_p_values)] = np.array(input_p_values)\n\ncoeffs = np.zeros(len(p_values))\nfor i,ip_value in enumerate(p_values):\n\tif ip_value==-99: # Draw random number from distrib\n\t\tif lognormal[ind][i]==0:\n\t\t\tcoeffs[i] = np.random.normal(mu[ind][i],sigma[ind][i])\n\t\telse:\n\t\t\tcoeffs[i] = np.random.lognormal(mu[ind][i],sigma[ind][i])\n\telse: # Estimate coefficient from number of sigmas\n\t\tif lognormal[ind][i]==0:\n\t\t\tcdf = lambda x: norm.cdf(x,mu[ind][i],sigma[ind][i])\n\t\t\tcoeffs[i] = bins_norm[len(cdf(bins_norm)[cdf(bins_norm)<ip_value])]\n\t\telse:\n\t\t\tcdf = lambda x: lognorm.cdf(x,mu[ind][i],sigma[ind][i])\n\t\t\tcoeffs[i] = bins_lognorm[max(len(cdf(bins_lognorm)[cdf(bins_lognorm)<=ip_value])-1,0)]\n\t\t\tprint(bins_lognorm[max(len(cdf(bins_lognorm)[cdf(bins_lognorm)<=ip_value])-1,0)])\n\nprint(coeffs)\n''' Saving spectra '''\nlamb = lambda_centers[ind]*(1+redshift)\nflux = pcas[ind].inverse_transform(coeffs)\nascii.write([lamb,flux],output_file,names=['lambda','flux'],overwrite=True)\n\n''' Drawing random parameters '''\nif display:\n\tplt.figure()\n\tplt.plot(lamb,flux)\n\tplt.xlabel(r'$\\lambda$')\n\tplt.ylabel(r'$F - \\bar{F}$')\n\tplt.grid(True,ls='--')\n\tplt.title(\"Simulated QSO\")\n\tplt.show()\n\n\n\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_406","text":"<filename>stonesoup\/models\/transition\/tests\/test_cv.py\n# coding: utf-8\nimport datetime\n\nfrom pytest import approx\nimport numpy as np\nfrom scipy.stats import multivariate_normal\n\nfrom ..linear import ConstantVelocity\nfrom ....types.state import State\n\n\ndef test_cvmodel():\n    \"\"\" ConstanVelocity Transition Model test \"\"\"\n\n    # State related variables\n    state = State(np.array([[3.0], [1.0]]))\n    old_timestamp = datetime.datetime.now()\n    timediff = 1  # 1sec\n    new_timestamp = old_timestamp + datetime.timedelta(seconds=timediff)\n    time_interval = new_timestamp - old_timestamp\n\n    # Model-related components\n    noise_diff_coeff = 0.001  # m\/s^2\n    F = np.array([[1, timediff], [0, 1]])\n    Q = np.array([[timediff**3 \/ 3,\n                   timediff**2 \/ 2],\n                  [timediff**2 \/ 2,\n                   timediff]]) * noise_diff_coeff\n\n    # Create and a Constant Velocity model object\n    cv = ConstantVelocity(noise_diff_coeff=noise_diff_coeff)\n\n    # Ensure ```cv.transfer_function(time_interval)``` returns F\n    assert np.array_equal(F, cv.matrix(\n        timestamp=new_timestamp, time_interval=time_interval))\n\n    # Ensure ```cv.covar(time_interval)``` returns Q\n    assert np.array_equal(Q, cv.covar(\n        timestamp=new_timestamp, time_interval=time_interval))\n\n    # Propagate a state vector through the model\n    # (without noise)\n    new_state_vec_wo_noise = cv.function(\n        state,\n        timestamp=new_timestamp,\n        time_interval=time_interval)\n    assert np.array_equal(new_state_vec_wo_noise, F@state.state_vector)\n\n    # Evaluate the likelihood of the predicted state, given the prior\n    # (without noise)\n    prob = cv.pdf(State(new_state_vec_wo_noise),\n                  state,\n                  timestamp=new_timestamp,\n                  time_interval=time_interval)\n    assert approx(prob) == multivariate_normal.pdf(\n        new_state_vec_wo_noise.T,\n        mean=np.array(F@state.state_vector).ravel(),\n        cov=Q)\n\n    # Propagate a state vector throught the model\n    # (with internal noise)\n    new_state_vec_w_inoise = cv.function(\n        state,\n        noise=True,\n        timestamp=new_timestamp,\n        time_interval=time_interval)\n    assert not np.array_equal(new_state_vec_w_inoise, F@state.state_vector)\n\n    # Evaluate the likelihood of the predicted state, given the prior\n    # (with noise)\n    prob = cv.pdf(State(new_state_vec_w_inoise),\n                  state,\n                  timestamp=new_timestamp,\n                  time_interval=time_interval)\n    assert approx(prob) == multivariate_normal.pdf(\n        new_state_vec_w_inoise.T,\n        mean=np.array(F@state.state_vector).ravel(),\n        cov=Q)\n\n    # Propagate a state vector throught the model\n    # (with external noise)\n    noise = cv.rvs(timestamp=new_timestamp, time_interval=time_interval)\n    new_state_vec_w_enoise = cv.function(\n        state,\n        timestamp=new_timestamp,\n        time_interval=time_interval,\n        noise=noise)\n    assert np.array_equal(new_state_vec_w_enoise, F@state.state_vector+noise)\n\n    # Evaluate the likelihood of the predicted state, given the prior\n    # (with noise)\n    prob = cv.pdf(State(new_state_vec_w_enoise), state,\n                  timestamp=new_timestamp, time_interval=time_interval)\n    assert approx(prob) == multivariate_normal.pdf(\n        new_state_vec_w_enoise.T,\n        mean=np.array(F@state.state_vector).ravel(),\n        cov=Q)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_407","text":"<filename>bnpy\/viz\/PlotTrace.py<gh_stars>0\n'''\nPlotTrace.py\n\nExecutable for plotting trace stats of learning algorithm progress, including\n* objective function (ELBO) vs laps thru data\n* number of active components vs laps thru data\n* hamming distance vs laps thru data\n\nUsage (command-line)\n-------\npython -m bnpy.viz.PlotTrace dataName jobpattern [kwargs]\n'''\nimport numpy as np\nimport argparse\nimport glob\nimport os\nimport scipy.io\n\nfrom PlotUtil import pylab\nfrom bnpy.ioutil import BNPYArgParser\nfrom JobFilter import filterJobs\n\ntaskidsHelpMsg = \"ids of trials\/runs to plot from given job.\" + \\\n                 \" Example: '4' or '1,2,3' or '2-6'.\"\n\nColors = [(0, 0, 0),  # black\n          (0, 0, 1),  # blue\n          (1, 0, 0),  # red\n          (0, 1, 0.25),  # green (darker)\n          (1, 0, 1),  # magenta\n          (0, 1, 1),  # cyan\n          (1, 0.6, 0),  # orange\n          ]\n\nLabelMap = dict(laps='num pass thru data',\n                iters='num alg steps',\n                times='elapsed time (sec)',\n                K='num topics K',\n                evidence='train objective',\n                )\nLabelMap['laps-saved-params'] = 'num pass thru data'\nLabelMap['hamming-distance'] = 'Hamming dist.'\nLabelMap['Keff'] = 'num topics K'\n\n\ndef plotJobsThatMatchKeywords(jpathPattern='\/tmp\/', **kwargs):\n    ''' Create line plots for jobs matching pattern and provided kwargs\n    '''\n    if not jpathPattern.startswith(os.path.sep):\n        jpathPattern = os.path.join(os.environ['BNPYOUTDIR'], jpathPattern)\n    jpaths, legNames = filterJobs(jpathPattern, **kwargs)\n    plotJobs(jpaths, legNames, **kwargs)\n\n\ndef plotJobs(jpaths, legNames, styles=None, density=2,\n             xvar='laps', yvar='evidence', loc='upper right',\n             xmin=None, xmax=None,\n             taskids=None, savefilename=None, tickfontsize=None,\n             bbox_to_anchor=None, **kwargs):\n    ''' Create line plots for provided jobs.\n    '''\n    nLines = len(jpaths)\n    if nLines == 0:\n        raise ValueError('Empty job list. Nothing to plot.')\n\n    nLeg = len(legNames)\n\n    for lineID in xrange(nLines):\n        if styles is None:\n            curStyle = dict(colorID=lineID)\n        else:\n            curStyle = styles[lineID]\n\n        plot_all_tasks_for_job(jpaths[lineID], legNames[lineID],\n                               xvar=xvar, yvar=yvar,\n                               taskids=taskids, density=density, **curStyle)\n    \n    # Y-axis limit determination\n    # If we have \"enough\" data about the run beyond two full passes of dataset,\n    # we zoom in on the region of data beyond lap 2\n    if xvar == 'laps' and yvar == 'evidence':\n        xmax = 0\n        ymin = np.inf\n        ymin2 = np.inf\n        ymax = -np.inf\n        allRunsHaveXBeyond1 = True\n        for line in pylab.gca().get_lines():\n            xd = line.get_xdata()\n            yd = line.get_ydata()\n            if xd.size < 3:\n                allRunsHaveXBeyond1 = False\n                continue\n            posLap1 = np.searchsorted(xd, 1.0)\n            posLap2 = np.searchsorted(xd, 2.0)\n            if posLap1 < xd.size:\n                ymin = np.minimum(ymin, yd[posLap1])\n                ymax = np.maximum(ymax, yd[posLap1:].max())\n            if posLap2 < xd.size:\n                ymin2 = np.minimum(ymin2, yd[posLap2])\n            xmax = np.maximum(xmax, xd.max())\n            if xd.max() <= 1:\n                allRunsHaveXBeyond1 = False\n        if allRunsHaveXBeyond1 and xmax > 1.5:\n            # If all relevant curves extend beyond x=1, only show that part\n            xmin = 1.0 - 1e-5\n        else:\n            xmin = 0\n        if allRunsHaveXBeyond1 and ymin2 < ymax:\n            range1 = ymax - ymin\n            range2 = ymax - ymin2\n            if 10 * range2 < range1:\n                # Y values jump from lap1 to lap2 is enormous,\n                # so let's just show y values from lap2 onward...\n                ymin = ymin2\n        if (not np.allclose(ymax, ymin)) and allRunsHaveXBeyond1:\n            pylab.ylim([ymin, ymax + 0.1 * (ymax - ymin)])\n        pylab.xlim([xmin, xmax + .05 * (xmax - xmin)])\n    \n    if loc is not None and len(jpaths) > 1:\n        pylab.legend(loc=loc, bbox_to_anchor=bbox_to_anchor)\n    if tickfontsize is not None:\n        pylab.tick_params(axis='both', which='major', labelsize=tickfontsize)\n\n    if savefilename is not None:\n        try:\n            pylab.show(block=False)\n        except TypeError:\n            pass  # when using IPython notebook\n        pylab.savefig(savefilename, bbox_inches='tight', pad_inches=0)\n    else:\n        try:\n            pylab.show(block=True)\n        except TypeError:\n            pass  # when using IPython notebook\n\n\ndef plot_all_tasks_for_job(jobpath, label, taskids=None,\n                           lineType='.-',\n                           color=None,\n                           colorID=0,\n                           density=2,\n                           yvar='evidence',\n                           markersize=10,\n                           linewidth=2,\n                           xvar='laps', **kwargs):\n    ''' Create line plot in current figure for each task\/run of jobpath\n    '''\n    if not os.path.exists(jobpath):\n        if not jobpath.startswith(os.path.sep):\n            jobpath_tmp = os.path.join(os.environ['BNPYOUTDIR'], jobpath)\n            if not os.path.exists(jobpath_tmp):\n                raise ValueError(\"PATH NOT FOUND: %s\" % (jobpath))\n            jobpath = jobpath_tmp\n    if color is None:\n        color = Colors[colorID % len(Colors)]\n    taskids = BNPYArgParser.parse_task_ids(jobpath, taskids)\n\n    if yvar == 'hamming-distance':\n        if xvar == 'laps':\n            xvar = 'laps-saved-params'\n\n    for tt, taskid in enumerate(taskids):\n        try:\n            var_ext = ''\n            ytxtfile = os.path.join(jobpath, taskid, yvar + '.txt')\n            if not os.path.isfile(ytxtfile):\n                var_ext = '-saved-params'\n                ytxtfile = os.path.join(\n                    jobpath, taskid, yvar + var_ext + '.txt')\n            ys = np.loadtxt(ytxtfile)\n\n            xtxtfile = os.path.join(jobpath, taskid, xvar + var_ext + '.txt')\n            if not os.path.isfile(xtxtfile):\n                var_ext = '-saved-params'\n                xtxtfile = os.path.join(\n                    jobpath, taskid, xvar + var_ext + '.txt')\n            xs = np.loadtxt(xtxtfile)\n\n        except IOError as e:\n            try:\n                xs, ys = loadXYFromTopicModelFiles(jobpath, taskid)\n            except ValueError:\n                try:\n                    xs, ys = loadXYFromTopicModelSummaryFiles(jobpath, taskid)\n                except ValueError:\n                    raise e\n\n        if yvar == 'hamming-distance' or yvar == 'Keff':\n            if xvar == 'laps-saved-params':\n                # fix off-by-one error, if we save an extra dist on final lap\n                if xs.size == ys.size - 1:\n                    ys = ys[:-1]\n                elif ys.size == xs.size - 1:\n                    xs = xs[:-1]  # fix off-by-one error, if we quit early\n            elif xs.size != ys.size:\n                # Try to subsample both time series at laps where they\n                # intersect\n                laps_x = np.loadtxt(os.path.join(jobpath, taskid, 'laps.txt'))\n                laps_y = np.loadtxt(os.path.join(jobpath, taskid,\n                                                 'laps-saved-params.txt'))\n                assert xs.size == laps_x.size\n                if ys.size == laps_y.size - 1:\n                    laps_y = laps_y[:-1]\n                xs = xs[np.in1d(laps_x, laps_y)]\n                ys = ys[np.in1d(laps_y, laps_x)]\n\n        if xs.size != ys.size:\n            raise ValueError('Dimension mismatch. len(xs)=%d, len(ys)=%d'\n                             % (xs.size, ys.size))\n\n        if xs.size < 3:\n            continue\n\n        # Cleanup laps data. Verify that it is sorted, with no collisions.\n        if xvar == 'laps':\n            diff = xs[1:] - xs[:-1]\n            goodIDs = np.flatnonzero(diff >= 0)\n            if len(goodIDs) < xs.size - 1:\n                print 'WARNING: looks like multiple runs writing to this file!'\n                print jobpath\n                print 'Task: ', taskid\n                print len(goodIDs), xs.size - 1\n                xs = np.hstack([xs[goodIDs], xs[-1]])\n                ys = np.hstack([ys[goodIDs], ys[-1]])\n\n        if xvar == 'laps' and yvar == 'evidence':\n            mask = xs >= 1.0\n            xs = xs[mask]\n            ys = ys[mask]\n\n        # Force plot density (data points per lap) to desired specification\n        # This avoids making plots that have huge file sizes,\n        # due to too much content in the given display space\n        if xvar == 'laps' and xs.size > 20 and np.sum(xs > 5) > 10:\n            if (xs[-1] - xs[9]) != 0:\n                curDensity = (xs.size - 10) \/ (xs[-1] - xs[9])\n            else:\n                curDensity = density\n            while curDensity > density and xs.size > 11:\n                # Thin xs and ys data by a factor of 2\n                # while preserving the first 10 data points\n                xs = np.hstack([xs[:10], xs[10::2]])\n                ys = np.hstack([ys[:10], ys[10::2]])\n                curDensity = (xs.size - 10) \/ (xs[-1] - xs[9])\n\n        plotargs = dict(markersize=markersize, linewidth=linewidth, label=None,\n                        color=color, markeredgecolor=color)\n        plotargs.update(kwargs)\n        if tt == 0:\n            plotargs['label'] = label\n\n        pylab.plot(xs, ys, lineType, **plotargs)\n\n    pylab.xlabel(LabelMap[xvar])\n    pylab.ylabel(LabelMap[yvar])\n\n\ndef loadXYFromTopicModelSummaryFiles(jobpath, taskid, xvar='laps', yvar='K'):\n    ''' Load x and y variables for line plots from TopicModel files\n    '''\n    ypath = os.path.join(jobpath, taskid, 'predlik-' + yvar + '.txt')\n    if not os.path.exists(ypath):\n        raise ValueError('No TopicModel summary text files found')\n    lappath = os.path.join(jobpath, taskid, 'predlik-lapTrain.txt')\n    xs = np.loadtxt(lappath)\n    ys = np.loadtxt(ypath)\n    return xs, ys\n\n\ndef loadXYFromTopicModelFiles(jobpath, taskid, xvar='laps', yvar='K'):\n    ''' Load x and y variables for line plots from TopicModel files\n    '''\n    tmpathList = glob.glob(os.path.join(jobpath, taskid, 'Lap*TopicModel.mat'))\n    if len(tmpathList) < 1:\n        raise ValueError('No TopicModel.mat files found')\n    tmpathList.sort()  # ascending, from lap 0 to lap 1 to lap 100 to ...\n    basenames = [x.split(os.path.sep)[-1] for x in tmpathList]\n    laps = np.asarray([float(x[3:11]) for x in basenames])\n    Ks = np.zeros_like(laps)\n    for tt, tmpath in enumerate(tmpathList):\n        if yvar == 'K':\n            Q = scipy.io.loadmat(tmpath, variable_names=['K', 'probs'])\n            try:\n                Ks[tt] = Q['K']\n            except KeyError:\n                Ks[tt] = Q['probs'].size\n        else:\n            raise ValueError('Unknown yvar type for topic model: ' + yvar)\n    return laps, Ks\n\n\ndef parse_args(xvar='laps', yvar='evidence'):\n    ''' Returns Namespace of parsed arguments retrieved from command line\n    '''\n    parser = argparse.ArgumentParser()\n    parser.add_argument('dataName', type=str, default='AsteriskK8')\n    parser.add_argument('jpath', type=str, default='demo*')\n\n    parser.add_argument('--xvar', type=str, default=xvar,\n                        choices=LabelMap.keys(),\n                        help=\"name of x axis variable to plot.\")\n\n    parser.add_argument('--yvar', type=str, default=yvar,\n                        choices=LabelMap.keys(),\n                        help=\"name of y axis variable to plot.\")\n\n    helpMsg = \"ids of trials\/runs to plot from given job.\" + \\\n              \" Example: '4' or '1,2,3' or '2-6'.\"\n    parser.add_argument(\n        '--taskids', type=str, default=None, help=helpMsg)\n    parser.add_argument(\n        '--savefilename', type=str, default=None,\n        help=\"location where to save figure (absolute path directory)\")\n\n    args, unkList = parser.parse_known_args()\n\n    argDict = BNPYArgParser.arglist_to_kwargs(unkList, doConvertFromStr=False)\n    argDict.update(args.__dict__)\n    argDict['jpathPattern'] = os.path.join(os.environ['BNPYOUTDIR'],\n                                           args.dataName,\n                                           args.jpath)\n    del argDict['dataName']\n    del argDict['jpath']\n    return argDict\n\nplotJobsThatMatch = plotJobsThatMatchKeywords\n\nif __name__ == \"__main__\":\n    argDict = parse_args('laps', 'evidence')\n    plotJobsThatMatchKeywords(**argDict)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_410","text":"\"\"\"\nThis module creat data generators for the following datasets:\nIIIT5K, IC13, SVHN\n\"\"\"\nimport scipy.io\nimport mat73\n\nlen_IIIT5K = 500 # max 3000\nlen_IC13 = 500   # max 848\nlen_SVHN = 500   # max 13068\n\npath_IIIT5K = 'data\/IIIT5K\/'\nfile_IIIT5K = path_IIIT5K + 'testdata.mat'\n\npath_IC13 = 'data\/Challenge2_Training_Task3_Images_GT\/'\nfile_IC13 = path_IC13 + 'gt.txt'\n\npath_SVHN = 'data\/test\/'\nfile_SVHN = path_SVHN + 'digitStruct.mat'\n\n\ndef get_label(content): # for SVHN\n    \n    label = ''\n    \n    if type(content) == list:\n        \n        for v in content:\n            v = int(v.item())\n            if v == 10: v = 0 \n            label += str(v)\n    else:\n        v = int(content.item())\n        if v == 10: v = 0   \n        label += str(v)\n        \n    return label\n\n\ndef generator_IIIT5K(desc, len_):\n    \n    for i, row in enumerate(desc['testdata'][0]):\n        if i >= len_:\n            return\n        \n        yield path_IIIT5K + row[0][0], row[1][0]\n        \n        \ndef generator_IC13(desc, len_):\n    \n    for i, row in enumerate(desc):\n        if i >= len_:\n            return\n        \n        split = row.split(', ')\n        \n        yield path_IC13 + split[0], split[1][1:-2]\n        \n        \ndef generator_SVHN(desc, len_):  \n    \n    for i, img_name in enumerate(desc['digitStruct']['name']):\n        if i >= len_:\n            return\n        \n        data = desc['digitStruct']['bbox'][i]['label']\n        label = get_label(data)\n        \n        yield path_SVHN + img_name, label\n\n        \ndef postprocessing_IIIT5K(predicted):\n    \n    punc = '''!()-[]{};:'\"\\, <>.\/?@#$%^&*_~'''\n    \n    for i, content in enumerate(predicted):\n        \n        result = \"\"\n        \n        for char in content:\n            if char not in punc:\n                result += char\n        \n        predicted[i] = result\n        \n    return predicted\n\n\ndef postprocessing_IC13(predicted):\n    return predicted\n\n\ndef postprocessing_SVHN(predicted):\n    return predicted\n\n\ngt_IIIT5K = scipy.io.loadmat(file_IIIT5K)\ngt_IC13 = open(file_IC13, 'r')\ngt_SVHN = mat73.loadmat(file_SVHN, 'r')\n\ngen_IIIT5K = generator_IIIT5K(gt_IIIT5K, len_IIIT5K)\ngen_IC13 = generator_IC13(gt_IC13, len_IC13)\ngen_SVHN = generator_SVHN(gt_SVHN, len_SVHN)\n\ndatasets = {\n    \"IIIT5K\":{\"gen\":gen_IIIT5K, \n              \"len\":len_IIIT5K, \n              \"postprocessing\": postprocessing_IIIT5K},\n    \"IC13\":  {\"gen\":gen_IC13, \n              \"len\":len_IC13, \n              \"postprocessing\": postprocessing_IC13},\n    \"SVHN\":  {\"gen\":gen_SVHN, \n              \"len\":len_SVHN, \n              \"postprocessing\": postprocessing_SVHN}  \n}\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_411","text":"<reponame>photonics-project\/notebooks<filename>src\/optics.py\n# %%\n# %matplotlib widget\nimport ipyvuetify as v\nimport ipywidgets as widgets\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.special as sc\n\nfrom controls import (\n    DetectorFormatControlPanel,\n    OpticsControlPanel,\n    WavelengthsControlPanel\n)\n\n\nparameters = {\n    'diameter': 1,\n    'focal_length': 2,\n    'fnumber': 2,\n    'Hdim': 1280,\n    'Vdim': 720,\n    'pitch': 20,\n    'wavelengths': [3.0, 5.0],\n}\n\n\noutput = widgets.Output()\n\n\nclass Figure():\n    def __init__(self):\n        (fig, [ax1, ax2]) = plt.subplots(ncols=2, constrained_layout=True)\n\n        fig.canvas.header_visible = False\n        fig.canvas.toolbar_visible = True\n        fig.canvas.toolbar_position = 'right'\n\n        self.fig = fig\n        self.ax1 = ax1\n        self.ax2 = ax2\n\n        self.update()\n\n    @property\n    def canvas(self):\n        return self.fig.canvas\n\n    def update(self):\n        Npixels = 9\n        fnumber = parameters['fnumber']\n        pitch = parameters['pitch']\n        xlambda = np.array(parameters['wavelengths'])\n\n        blur_spots = 2*sc.jn_zeros(1, 1)[0]\/np.pi*xlambda*fnumber\/pitch\n\n        self.ax1.clear()\n        self.ax2.clear()\n\n        for ax in [self.ax1, self.ax2]:\n            ax.set_aspect('equal')\n            ax.set_xticklabels([])\n            ax.set_xticks(np.arange(Npixels+1))\n            ax.set_yticklabels([])\n            ax.set_yticks(np.arange(Npixels+1))\n            ax.set_axisbelow(True)\n            ax.grid(True)\n\n        self.ax1.set_title(f'Blur spot = {blur_spots[0]*pitch:g} µm', color='red')\n        self.ax2.set_title(f'Blur spot = {blur_spots[1]*pitch:g} µm', color='blue')\n\n        circle1 = mpl.patches.Circle((0.5, 0.5), blur_spots[0]\/Npixels\/2, color='red', alpha=0.5, transform=self.ax1.transAxes)\n        circle2 = mpl.patches.Circle((0.5, 0.5), blur_spots[1]\/Npixels\/2, color='blue', alpha=0.5, transform=self.ax2.transAxes)\n\n        self.ax1.add_patch(circle1)\n        self.ax2.add_patch(circle2)\n\n        self.ax1.grid(True)\n        self.ax2.grid(True)\n\n        self.fig.canvas.draw()\n\n\nclass Table():\n    def __init__(self):\n        self.widget = v.Html(tag='div', class_='d-flex flex-row', children=[])\n\n        self.update()\n\n    def update(self):\n        fnumber = parameters['fnumber']\n        Hdim = parameters['Hdim']\n        Vdim = parameters['Vdim']\n        pitch = parameters['pitch']\n        xlambda = np.array(parameters['wavelengths'])\n\n        blur_spots = 2*sc.jn_zeros(1, 1)[0]\/np.pi*xlambda*fnumber\/pitch\n\n        table = v.DataTable(\n            style_='width: 100%',\n            hide_default_footer=True,\n            disable_sort=True,\n            headers=[\n                {'text': 'Parameter', 'value': 'parameter'},\n                {'text': 'Value', 'value': 'value'},\n                {'text': 'Units', 'value': 'units'},\n            ],\n            items=[\n                {\n                    'parameter': 'Chip Width',\n                    'value': f'{Hdim*(pitch\/1e3):g}',\n                    'units': 'mm',\n                },\n                {\n                    'parameter': 'Chip Height',\n                    'value': f'{Vdim*(pitch\/1e3):g}',\n                    'units': 'mm',\n                },\n                {\n                    'parameter': 'Chip Area',\n                    'value': f'{Hdim*Vdim*(pitch\/1e3)**2:g}',\n                    'units': 'mm²',\n                },\n                {\n                    'parameter': 'Blur Spot (Wavelength #1)',\n                    'value': f'{blur_spots[0]*pitch:g}',\n                    'units': 'µm',\n                },\n                {\n                    'parameter': 'Blur Spot (Wavelength #2)',\n                    'value': f'{blur_spots[1]*pitch:g}',\n                    'units': 'µm',\n                },\n            ],\n        )\n        self.widget.children = [table]\n\n\nplt.ioff()\n\nfigure = Figure()\n\ntable = Table()\n\noptics_control_panel = OpticsControlPanel(\n    diameter=parameters['diameter'],\n    focal_length=parameters['focal_length'],\n)\ndetector_format_control_panel = DetectorFormatControlPanel(\n    Hdim=parameters['Hdim'],\n    Vdim=parameters['Vdim'],\n    pitch=parameters['pitch'],\n)\nwavelengths_control_panel = WavelengthsControlPanel(xlambda=parameters['wavelengths'])\n\n\ndef update():\n    figure.update()\n    table.update()\n\n\ndef update_optics():\n    parameters['diameter'] = optics_control_panel.diameter\n    parameters['focal_length'] = optics_control_panel.focal_length\n    parameters['fnumber'] = optics_control_panel.fnumber\n    update()\n\n\ndef update_detector_format():\n    parameters['Hdim'] = detector_format_control_panel.Hdim\n    parameters['Vdim'] = detector_format_control_panel.Vdim\n    parameters['pitch'] = float(detector_format_control_panel.pitch)\n    update()\n\n\ndef update_wavelengths():\n    parameters['wavelengths'] = wavelengths_control_panel.xlambda\n    update()\n\n\noptics_control_panel.on_change(update_optics)\ndetector_format_control_panel.on_change(update_detector_format)\nwavelengths_control_panel.on_change(update_wavelengths)\n\n\nv.Container(children=[\n    v.Row(children=[\n        v.Col(cols=12, md=6, children=[\n            v.Card(\n                class_='mb-4',\n                outlined=True,\n                children=[\n                    v.CardTitle(children=['Optics']),\n                    v.CardText(children=[\n                        optics_control_panel.widget,\n                    ]),\n            ]),\n            v.Card(\n                class_='mb-4',\n                outlined=True,\n                children=[\n                    v.CardTitle(children=['Wavelengths']),\n                    v.CardText(children=[\n                        wavelengths_control_panel.widget,\n                    ]),\n            ]),\n            v.Card(\n                class_='mb-4',\n                outlined=True,\n                children=[\n                    v.CardTitle(children=['Detector']),\n                    v.CardText(children=[\n                        detector_format_control_panel.widget,\n                    ]),\n            ]),\n            v.Card(\n                class_='mb-4',\n                outlined=True,\n                children=[\n                    v.CardTitle(children=['Results']),\n                    v.CardText(children=[\n                        table.widget,\n                    ]),\n            ]),\n        ]),\n        v.Col(cols=12, md=6, children=[\n            v.Card(\n                class_='mb-4',\n                outlined=True,\n                children=[\n                    v.CardTitle(children=['Figure']),\n                    v.CardText(children=[\n                        figure.canvas,\n                    ]),\n            ]),\n        ]),\n    ]),\n    # v.Row(children=[\n    #     v.Col(cols=12, md=6, children=[\n    #         output\n    #     ]),\n    # ]),\n])\n\n# %%\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_412","text":"<filename>2021\/day07\/part1.py\nfrom statistics import median\n\n# Simple logging\nfrom loguru import logger\n\n# Personal utilities\nfrom bsoyka_aoc_utils import get_data\n\nCRABS = get_data(2021, 7, func=int, split=\",\")\nlogger.debug(\"Loaded crabs data\")\n\n# Finding the best alignment position can be done by getting the median\n# of the crab positions.\n\nalign_position: int = int(median(CRABS))\n\nfuel: int = sum(abs(crab - align_position) for crab in CRABS)\n\nlogger.success(\"Result: {}\", fuel)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_413","text":"from network import *\nimport cv2, os, time, math\nimport glob\nimport scipy.io as io\nfrom loss import *\nfrom utils import *\n\nis_training = False  # if test, set this 'False'\nuse_viewdirection = True  # use view direction\nrenew_input = True   # optimize input point features.\nconstant_initial = True  # use constant value for initialization.\nuse_RGB = True     # use RGB information for initialization.\nrandom_crop = True  # crop image.\n\nd = 32   # how many planes are used, identity with pre-processing.\nh = 480  # image height, identity with pre-processing.\nw = 640  # image width, identity with pre-processing.\ntop_left_v = 0  # top left position\ntop_left_u = 0  # top left position\nh_croped = 240  # crop size height\nw_croped = 320  # crop size width\nforward_time = 4  # optimize input point features after cropping 4 times on one image.\noverlap = 32  # size of overlap region of crops.\n\nchannels_i = int(8)  # dimension of input point features\nchannels_o = 3  # output image dimensions\nchannels_v = 3  # view direction dimensions\n\ngpu_id = 3\nnum_epoch = 21\ndecrease_epoch = 7  # epochs, learning_rate_1 decreased.\nlearning_rate = 0.0001  # learning rate for network parameters optimization\nlearning_rate_1 = 0.01  # initial learning rate for input point features.\n\ndataset = 'ScanNet'     # datasets\nscene = 'scene0010_00'  # scene name\ntask = '%s_npcr_%s' % (dataset, scene)  # task name, also path of checkpoints file\ndir1 = 'data\/%s\/%s\/color\/' % (dataset, scene)  # path of color image\ndir2 = 'data\/%s\/%s\/pose\/' % (dataset, scene)  # path of camera poses.\ndir3 = 'pre_processing_results\/%s\/%s\/reproject_results_%s\/' % (dataset, scene, d)  # voxelization information path.\ndir4 = 'pre_processing_results\/%s\/%s\/weight_%s\/' % (dataset, scene, d)  # aggregation information path.\ndir5 = 'pre_processing_results\/%s\/%s\/point_clouds_simplified.ply' % (dataset, scene)  # point clouds file path\n\nnum_image = len(glob.glob(os.path.join(dir1, '*.jpg')))\n\nimage_names_train, index_names_train, camera_names_train, index_names_1_train,\\\nimage_names_test, index_names_test, camera_names_test, index_names_1_test = prepare_data_ScanNet(dir1, dir2, dir3, dir4, num_image)\n\n# load point clouds information\npoint_clouds, point_clouds_colors = loadfile(dir5)\nnum_points = point_clouds.shape[1]\n\n# initial descriptor\ndescriptors = np.random.normal(0, 1, (1, num_points, channels_i))\n\nif os.path.isfile('%s\/descriptor.mat' % task):\n    content = io.loadmat('%s\/descriptor.mat' % task)\n    descriptors = content['descriptors']\n    print('loaded descriptors.')\nelse:\n    if constant_initial:\n        descriptors = np.ones((1, num_points, channels_i), dtype=np.float32) * 0.5\n\n    if use_RGB:\n        descriptors[0, :, 0:3] = np.transpose(point_clouds_colors) \/ 255.0\n\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"%s\" % gpu_id\nos.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\nsess = tf.Session()\n\ninput1 = tf.placeholder(dtype=tf.float32, shape=[1, d, None, None, channels_i])\ninput2 = tf.placeholder(dtype=tf.float32, shape=[1, d, None, None, channels_v])\noutput = tf.placeholder(dtype=tf.float32, shape=[1, None, None, channels_o])\n\nwith tf.variable_scope(tf.get_variable_scope()):\n    inputs = input1\n    total_channels = channels_i\n\n    if use_viewdirection:\n        inputs = tf.concat([input1, input2], axis=4)\n        total_channels = total_channels + channels_v\n\n    color_layer, alpha, network = neural_render(input=inputs, reuse=False, use_dilation=True)\n    loss, p0, p1, p2, p3, p4, p5 = VGG_loss(network, output, reuse=False)\n\n    loss_all = loss\n\n    # calculate gradient for aggregated point features.\n    gradient = tf.gradients(loss_all, input1)\n\nvar_list_all = [var for var in tf.trainable_variables()]\nopt = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss_all, var_list=var_list_all)\n\nsaver = tf.train.Saver(var_list=var_list_all, max_to_keep=1000)\n\nsess.run(tf.global_variables_initializer())\n\nckpt = tf.train.get_checkpoint_state(task)\nif ckpt:\n    print('load ' + ckpt.model_checkpoint_path)\n    saver.restore(sess, ckpt.model_checkpoint_path)\n\n##############################################################################################\nif is_training:\n    print('begin training!')\n    all = np.zeros(20000, dtype=float)\n    cnt = 0\n\n    for epoch in range(num_epoch):\n\n        if epoch >= decrease_epoch:\n            learning_rate_1 = 0.005\n\n        if epoch >= decrease_epoch*2:\n            learning_rate_1 = 0.001\n\n        if os.path.isdir(\"%s\/%04d\" % (task, epoch)):\n            continue\n\n        for i in np.random.permutation(len(image_names_train)):\n        # for i in range(4):\n            st = time.time()\n            image_descriptor = np.zeros([1, d, h, w, channels_i], dtype=np.float32)\n            view_direction = np.zeros([1, d, h, w, channels_v], dtype=np.float32)\n            input_gradient_all = np.zeros([1, d, h, w, channels_i], dtype=np.float32)\n            count = np.zeros([1, d, h, w, 1], dtype=np.float32)\n            camera_name = camera_names_train[i]\n            index_name = index_names_train[i]\n            image_name = image_names_train[i]\n            index_name_1 = index_names_1_train[i]\n\n            if not (os.path.isfile(camera_name) and os.path.isfile(image_name) and os.path.isfile(index_name) and os.path.isfile(index_name_1)):\n                print(\"Missing file!\")\n                continue\n\n            # we pre-process the voxelization and aggregation, in order to save time.\n            npzfile = np.load(index_name)\n            u = npzfile['u']  # u position on image plane\n            v = npzfile['v']  # v position on image plane\n            n = npzfile['d']  # indicates which plane\n            select_index = npzfile['select_index']   # select index of all points.\n            group_belongs = npzfile['group_belongs']  # points belong to which group\/voxel\n            index_in_each_group = npzfile['index_in_each_group']  # index in each group\/voxel\n            distance = npzfile['distance']  # distance to grid center\n            each_split_max_num = npzfile['each_split_max_num']  # max num of points in one group\/voxel in each plane.\n\n            # load weight\n            npzfile_weight = np.load(index_name_1)\n            weight = npzfile_weight['weight_average']  # normalized weights for points aggregation.\n            distance_to_depth_min = npzfile_weight['distance_to_depth_min']  # distance to minimum depth value in one group\/voxel.\n\n            # calculate update weight of each point feature\n            descriptor_renew_weight = (1-distance)*(1\/(1+distance_to_depth_min))\n\n            extrinsic_matrix = CameraPoseRead(camera_name)  # camera to world\n            camera_position = np.transpose(extrinsic_matrix[0:3, 3])\n\n            max_num = np.max(each_split_max_num)  # max number of points in all group\/voxel\n            group_descriptor = np.zeros([(max(group_belongs+1)), max_num, channels_i], dtype=np.float32)\n            group_descriptor[group_belongs, index_in_each_group, :] = descriptors[0, select_index, :] * np.expand_dims(weight, axis=1)\n\n            image_descriptor[0, n, v, u, :] = np.sum(group_descriptor, axis=1)[group_belongs, :]\n\n            view_direction[0, n, v, u, :] = np.transpose(point_clouds[0:3, select_index]) - camera_position\n            view_direction[0, n, v, u, :] = view_direction[0, n, v, u, :] \/ (np.tile(np.linalg.norm(view_direction[0, n, v, u, :], axis=1, keepdims=True), (1, 3)) + 1e-10)\n\n            image_output = np.expand_dims(cv2.resize(cv2.imread(image_name, -1), (w, h)), axis=0) \/ 255.0\n\n            if random_crop:\n\n                # limitation of memory etc, we crop the image.\n                # Also, we hope crops almost cover the whole image to uniformly optimize point features.\n                for j in np.random.permutation(forward_time):\n                    movement_v = np.random.randint(0, overlap)\n                    movement_u = np.random.randint(0, overlap)\n\n                    if j==0:\n                        top_left_u = 0 + movement_u\n                        top_left_v = 0 + movement_v\n                    if j==1:\n                        top_left_u = w_croped - movement_u\n                        top_left_v = 0 + movement_v\n                    if j==2:\n                        top_left_u = 0 + movement_u\n                        top_left_v = h_croped - movement_v\n                    if j==3:\n                        top_left_u = w_croped - movement_u\n                        top_left_v = h_croped - movement_v\n\n\n                    [_, current_loss, l1, input_gradient] = sess.run([opt, loss_all, loss, gradient],\n                                                                     feed_dict={input1: image_descriptor[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :],\n                                                                                input2: view_direction[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :],\n                                                                                output: image_output[:, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :]\n                                                                                })\n\n                    input_gradient_all[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :] = input_gradient[0] + input_gradient_all[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :]\n                    count[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :] = count[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :] + 1\n                    # print(np.max(count))\n\n                if renew_input:\n                    input_gradient_all = input_gradient_all\/(count+1e-10)\n                    descriptors[0, select_index, :] = descriptors[0, select_index, :] - learning_rate_1 * np.expand_dims(descriptor_renew_weight, axis=1) * input_gradient_all[0, n, v, u, :]\n\n\n            else:\n\n                [_, current_loss, l1, input_gradient] = sess.run([opt, loss_all, loss, gradient],\n                                                                     feed_dict={input1: image_descriptor,\n                                                                                input2: view_direction,\n                                                                                output: image_output\n                                                                                })\n\n                if renew_input:\n                    descriptors[0, select_index, :] = descriptors[0, select_index, :] - learning_rate_1 * np.expand_dims(descriptor_renew_weight, axis=1) * input_gradient[0][0, n, v, u, :]\n\n            all[i] = current_loss * 255.0\n            cnt = cnt + 1\n\n            print('%s %s %s %.2f %.2f %s' % (epoch, i, cnt, current_loss, np.mean(all[np.where(all)]), time.time() - st))\n\n        os.makedirs(\"%s\/%04d\" % (task, epoch))\n        saver.save(sess, \"%s\/model.ckpt\" % (task))\n        io.savemat(\"%s\/\" % task + 'descriptor.mat', {'descriptors': descriptors})\n\n        if epoch % 5 == 0:\n            saver.save(sess, \"%s\/%04d\/model.ckpt\" % (task, epoch))\n            io.savemat(\"%s\/%04d\/\" % (task, epoch) + 'descriptor.mat', {'descriptors': descriptors})\n\n\n        for id in range(len(image_names_test)):\n\n            top_left_v = 120\n            top_left_u = 160\n            st = time.time()\n            image_descriptor = np.zeros([1, d, h, w, channels_i])\n            view_direction = np.zeros([1, d, h, w, channels_v])\n            camera_name = camera_names_test[id]\n            index_name = index_names_test[id]\n            index_name_1 = index_names_1_test[id]\n\n            if not (os.path.isfile(index_name) and os.path.isfile(camera_name) and os.path.isfile(index_name_1)):\n                print('Missingg file 1!')\n                continue\n\n            npzfile = np.load(index_name)\n            u = npzfile['u']\n            v = npzfile['v']\n            n = npzfile['d']\n            select_index = npzfile['select_index']\n            group_belongs = npzfile['group_belongs']\n            index_in_each_group = npzfile['index_in_each_group']\n            distance = npzfile['distance']\n            each_split_max_num = npzfile['each_split_max_num']\n\n            # load weight\n            npzfile_weight = np.load(index_name_1)\n            weight = npzfile_weight['weight_average']\n            distance_to_depth_min = npzfile_weight['distance_to_depth_min']\n\n            extrinsic_matrix = CameraPoseRead(camera_name)  # camera to world\n            camera_position = np.transpose(extrinsic_matrix[0:3, 3])\n\n            max_num = np.max(each_split_max_num)\n            group_descriptor = np.zeros([(max(group_belongs + 1)), max_num, channels_i], dtype=np.float32)\n            group_descriptor[group_belongs, index_in_each_group, :] = descriptors[0, select_index, :] * np.expand_dims(weight, axis=1)\n\n            image_descriptor[0, n, v, u, :] = np.sum(group_descriptor, axis=1)[group_belongs, :]\n\n            view_direction[0, n, v, u, :] = np.transpose(point_clouds[0:3, select_index]) - camera_position\n            view_direction[0, n, v, u, :] = view_direction[0, n, v, u, :] \/ (np.tile(np.linalg.norm(view_direction[0, n, v, u, :], axis=1, keepdims=True), (1, 3)) + 1e-10)\n\n            [result] = sess.run([network], feed_dict={input1: image_descriptor[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :],\n                                                      input2: view_direction[:, :, top_left_v:(top_left_v + h_croped), top_left_u:(top_left_u + w_croped), :]})\n            result = np.minimum(np.maximum(result, 0.0), 1.0) * 255.0\n            cv2.imwrite('%s\/%04d\/%06d.png' % (task, epoch, id), np.uint8(result[0, :, :, :]))\n\n            print(time.time() - st)\nelse:\n\n    output_path = \"%s\/Test_Result\/\" % (task)\n    if not os.path.isdir(output_path):\n        os.makedirs(output_path)\n\n    for id in range(len(camera_names_test)):\n\n        st = time.time()\n        image_descriptor = np.zeros([1, d, h, w, channels_i])\n        view_direction = np.zeros([1, d, h, w, channels_v])\n        camera_name = camera_names_test[id]\n        index_name = index_names_test[id]\n        index_name_1 = index_names_1_test[id]\n\n        if not (os.path.isfile(index_name) and os.path.isfile(camera_name) and os.path.isfile(index_name_1)):\n            print('Missingg file 1!')\n            continue\n\n        npzfile = np.load(index_name)\n        u = npzfile['u']\n        v = npzfile['v']\n        n = npzfile['d']\n        select_index = npzfile['select_index']\n        group_belongs = npzfile['group_belongs']\n        index_in_each_group = npzfile['index_in_each_group']\n        distance = npzfile['distance']\n        each_split_max_num = npzfile['each_split_max_num']\n\n        # load weight\n        npzfile_weight = np.load(index_name_1)\n        weight = npzfile_weight['weight_average']\n        distance_to_depth_min = npzfile_weight['distance_to_depth_min']\n\n        extrinsic_matrix = CameraPoseRead(camera_name)  # camera to world\n        camera_position = np.transpose(extrinsic_matrix[0:3, 3])\n\n        max_num = np.max(each_split_max_num)\n        group_descriptor = np.zeros([(max(group_belongs + 1)), max_num, channels_i], dtype=np.float32)\n        group_descriptor[group_belongs, index_in_each_group, :] = descriptors[0, select_index, :] * np.expand_dims(weight, axis=1)\n\n        image_descriptor[0, n, v, u, :] = np.sum(group_descriptor, axis=1)[group_belongs, :]\n\n        view_direction[0, n, v, u, :] = np.transpose(point_clouds[0:3, select_index]) - camera_position\n        view_direction[0, n, v, u, :] = view_direction[0, n, v, u, :] \/ (\n        np.tile(np.linalg.norm(view_direction[0, n, v, u, :], axis=1, keepdims=True), (1, 3)) + 1e-10)\n\n        [result] = sess.run([network], feed_dict={input1: image_descriptor, input2: view_direction})\n        result = np.minimum(np.maximum(result, 0.0), 1.0) * 255.0\n        cv2.imwrite(output_path + '%06d.png' % id, np.uint8(result[0, :, :, :]))\n\n        print(time.time() - st)\n\n\nif __name__ == '__main__':\n    pass\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_401","text":"import numpy as np\nfrom scipy.stats import sem\nfrom uncertainties import ufloat\nimport uncertainties.unumpy as unp\nimport matplotlib.pyplot as plt\nimport scipy.constants as sc\nfrom scipy.optimize import curve_fit\n#from pint import UnitRegistry\nimport operator\n\n\n#u = UnitRegistry()\n#Q_ = u.Quantity\n\nTime_ges = 81591 #Bsp lambda_r = Q_(643.2, 'nanometer')\nC_Start = 1444133\nC_Stop = 4255\n\nprint(\"Gesamter Messzeitraum: \", Time_ges)\nprint(\"Gemessene Startimpulse: \", C_Start)\nprint(\"Gemessene Stopimpulse: \", C_Stop, '\\n')\nTime_Search = 10 *10**(-6)\n\nC_Start_r = ufloat(C_Start, np.sqrt(C_Start))\n\nRate = C_Start_r\/Time_ges\nN_Search = Time_Search*Rate\n\nW = N_Search * unp.exp(N_Search)\nU_Search = W*C_Start\/512\n\nprint(\"Rate pro Sekunde: \", Rate)\nprint(\"Wahrscheinlichkeit: \", W)\nprint(\"Untergrund nach Poisson: \", U_Search, '\\n')\n\n\n#Datenaufnahme etwas umständlich\nCounts_M = np.genfromtxt('Messung.txt', unpack=True)\nChannels = np.linspace(0, 511, 512)\n\n\nMessung_Errors = np.sqrt(Counts_M)\nMessung = unp.uarray(Counts_M, Messung_Errors)\n\n#Kalibrierung_Errors = np.sqrt(Counts_K)\n#Kalibrierung_Werte = np.array([ufloat(n, Kalibrierung_Errors[i]) for i,n in enumerate(Counts_K) ])\n#Kalibrierung_y = np.array([Kalibrierung_Werte[i] for i,n in enumerate(Counts_K) if n!= 0])\n\nCounts_K = np.genfromtxt('Kalibrierung.txt', unpack=True)\nKalibrierung_x = np.array([Channels[i] for i,n in enumerate(Counts_K) if n!= 0])\nK_x = Kalibrierung_x\nKalibrierung_y = np.array([0.3,1,2,3,4,5,6,7,8,9,10])\nChannels_real = np.array([K_x[0],K_x[2],K_x[3],K_x[4],K_x[6],K_x[7],K_x[8],K_x[9],K_x[10],K_x[12],K_x[13]])\n\n\n\n\nPlateau_x = np.array([-24,-22,-20,-18,-16,-14,-12,-10,-8,-6,-4,-2,-1,0,1,2,4,6,8,10,12,14,16,18,20])\n\nP1 = unp.uarray([154,186,186,173], np.sqrt([154,186,186,173]))\nP2 = unp.uarray([176,189,164,172], np.sqrt([176,189,164,172]))\nP4 = unp.uarray([183,167,178,194], np.sqrt([183,167,178,194]))\nP6 = unp.uarray([178,193,165,180], np.sqrt([178,193,165,180]))\nP8 = unp.uarray([186,168,147,168], np.sqrt([186,168,147,168]))\n\nM0  = unp.uarray([167,184,180], np.sqrt([167,184,180]))\nM1  = unp.uarray([177,189,178], np.sqrt([177,189,178]))\nM2  = unp.uarray([169,180,171,171], np.sqrt([169,180,171,171]))\nM4  = unp.uarray([177,168,183,158], np.sqrt([177,168,183,158]))\nM6  = unp.uarray([167,164,179,153], np.sqrt([167,164,179,153]))\nM8  = unp.uarray([176,144,151,135], np.sqrt([176,144,151,135]))\nM10 = unp.uarray([123, 134], np.sqrt([123, 134]))\n\nPlateau = unp.uarray([6,2,12,10,37,54,86,unp.nominal_values(M10.mean()),unp.nominal_values(M8.mean()),\nunp.nominal_values(M6.mean()),unp.nominal_values(M4.mean()),unp.nominal_values(M2.mean()),\nunp.nominal_values(M1.mean()),unp.nominal_values(M0.mean()),unp.nominal_values(P1.mean()),\nunp.nominal_values(P2.mean()),unp.nominal_values(P4.mean()),unp.nominal_values(P6.mean()),\nunp.nominal_values(P8.mean()),140,120,63,40,0,0] , [np.sqrt(6),np.sqrt(2),\nnp.sqrt(12),np.sqrt(10),np.sqrt(37),np.sqrt(54),np.sqrt(86),unp.std_devs(M10.mean()),\nunp.std_devs(M8.mean()),unp.std_devs(M6.mean()),unp.std_devs(M4.mean()),unp.std_devs(M2.mean()),\nunp.std_devs(M1.mean()),unp.std_devs(M0.mean()),unp.std_devs(P1.mean()),unp.std_devs(P2.mean()),\nunp.std_devs(P4.mean()),unp.std_devs(P6.mean()),unp.std_devs(P8.mean()),np.sqrt(140),\nnp.sqrt(120),np.sqrt(63),np.sqrt(40),np.sqrt(0),np.sqrt(0)])\n\n#print(\"Plateau: \", Plateau, '\\n')\n\n# nächste Abschnitt für das Plateau\n\nfit_x = np.linspace(-25,25,1000)#Plateau_x[9],Plateau_x[18],100)\n\ndef PlateauFit(x, b):\n    return 0*x+b\n\ndef Flankenfit(x, A, b):\n    return A*x + b\n\nLinksParams, LinksCovariance = curve_fit(Flankenfit, Plateau_x[3:10], unp.nominal_values(Plateau[3:10]))\nRechtsParams, RechtsCovariance = curve_fit(Flankenfit, Plateau_x[19:24], unp.nominal_values(Plateau[19:24]))\nLinks_errors = np.sqrt(np.diag(LinksCovariance))\nRechts_errors = np.sqrt(np.diag(RechtsCovariance))\n\nfitParams, fitCovariance = curve_fit(PlateauFit, Plateau_x[9:19], unp.nominal_values(Plateau[9:19]), sigma = unp.std_devs(Plateau[9:19]), absolute_sigma = True )\nPlateau_errors = np.sqrt(np.diag(fitCovariance))\nHöhe = ufloat(fitParams[0], Plateau_errors[0])\n\n\nA_L = ufloat(LinksParams[0], Links_errors[0])\nA_R = ufloat(RechtsParams[0], Rechts_errors[0])\nB_L = ufloat(LinksParams[1], Links_errors[1])\nB_R = ufloat(RechtsParams[1], Rechts_errors[1])\n\nx_L = (Höhe\/2-B_L)\/A_L\nx_R = (Höhe\/2-B_R)\/A_R\n\nprint(\"zeiten: \", x_L, x_R, '\\n')\nprint(\"Links: \", Plateau_x[3:10], A_L, B_L, '\\n')\nprint(\"rechts: \", Plateau_x[19:24], A_R, B_R, '\\n')\n\n\nplt.errorbar(Plateau_x, unp.nominal_values(Plateau), xerr= 0, yerr = unp.std_devs(Plateau), fmt = 'kx', label = r'Messwerte')\nplt.plot(fit_x, PlateauFit(fit_x, *fitParams), 'r-', label = r'linearer Fit')\nplt.axvline(unp.nominal_values(x_L), color = 'r', linestyle = '--', label = r'$T_{\\mathrm{VZ,links}}$')\nplt.axvline(unp.nominal_values(x_R), color = 'r', linestyle = '--', label = r'$T_{\\mathrm{VZ,rechts}}$')\nplt.ylabel(r'N(t)')\nplt.xlabel(r'$T_{\\mathrm{VZ}}$ in $\\mathrm{ns}$')\nplt.legend(loc = 'best')\nplt.savefig('Plateau.pdf')\n#plt.show()\n\nprint(\"Bestimmte Höhe des Plateaus: \", Höhe, '\\n')\n\n# Kalibrierung\n\ndef Kalibrierung(x, A, B):\n    return A*x + B\n\nKParams, KCovariance = curve_fit(Kalibrierung, Channels_real, Kalibrierung_y)\nK_errors = np.sqrt(np.diag(KCovariance))\nSteigung = ufloat(KParams[0], K_errors[0])\nAbschnitt = ufloat(KParams[1], K_errors[1])\nprint(\"Abschnitt der Gerade: \", Abschnitt, '\\n')\nprint(\"Steigung der Gerade: \", Steigung, '\\n')\n\nplt.clf()\nplt.plot(Channels_real, Kalibrierung_y, 'kx', label = r'Messwerte')\nplt.plot(Channels, Kalibrierung(Channels, *KParams), 'r-', label = r'linearer Fit')\nplt.ylabel(r'$t$ in $\\mathrm{\\mu s}$')\nplt.xlabel(r'Kanal')\nplt.legend(loc = 'best')\n#plt.savefig('Kalibrierung.pdf')\n#plt.show()\n\n\n# Auswertung der Zeiten\n\ndef Lebensdauer(x, N0, LB, U):\n    return N0 * np.exp(-LB*x) + U\n\nZeiten = Kalibrierung(Channels, *KParams)\n\n\nZeiten_neu = np.linspace(0,0,512)\nCounts_neu = np.linspace(0,0,512)\n\n\nZählstruktur = np.linspace(0,255,256)\nCounts_neu_1 = np.array([Counts_M[2*i]+Counts_M[2*i+1] for i,n in enumerate(Zählstruktur)])\nZeiten_neu_1 = np.array([(Zeiten[2*i]+Zeiten[2*i+1])\/2 for i,n in enumerate(Zählstruktur)])\n\nfor i,n in enumerate(Counts_neu_1):\n    if n == 0:\n        print(\"Index von 0:\", i)\n\nCounts_r = np.array([n for n in Counts_M])\nZeiten_r = np.array([n for n in Zeiten])\n\n#print(Counts_M)\n\nCounts_M[0] = 1\nCounts_M[1] = 1\nCounts_M[2] = 1\n\nfor i,n in enumerate(Counts_M):\n    #print(\"Schlaufe\", i, Counts_M[i-1:i+2])\n    k = i\n    #print(i)\n    if Counts_M[i]!=0:\n        Counts_neu[i] = Counts_M[i]\n        Zeiten_neu[i] = Zeiten[i]\n        #print(i,n,\"--------------\")\n    elif Counts_M[i]==0:\n        if Counts_M[i-1]!=0 and Counts_M[i+1]!=0:\n            #print(i,0)\n            Zeiten_neu[i-1] = (Zeiten[i]+Zeiten[i-1])\/2\n            Counts_neu[i] = Counts_M[i+1]\n            Zeiten_neu[i] = Zeiten[i+1]\n            #print(\"nächster\", Counts_M[k+1])\n            while k < 510:\n                Counts_M[k] = Counts_M[k+1]\n                Zeiten[k] = Zeiten[k+1]\n                k=k+1\n            #print(Counts_M[i:i+10])\n        elif Counts_M[i-1]!=0 and Counts_M[i+1]==0 and Counts_M[i+2]!=0:\n            #print(i, 00)\n            Zeiten_neu[i-1] = (Zeiten[i]+Zeiten[i-1])\/2\n            Counts_neu[i] = Counts_M[i+2]\n            Zeiten_neu[i] = (Zeiten[i+1]+Zeiten[i+2])\/2\n            while k <= 509:\n                Counts_M[k] = Counts_M[k+2]\n                Zeiten[k] = Zeiten[k+2]\n                k=k+1\n        elif Counts_M[i-1]==0:\n            #print(i, i-1, i+1, \"Abbruch\")\n            break\n        else:\n            #print(i,Counts_M[i-3:i+2], \"Abbruch\")\n            break\n\nfor i,n in enumerate(Counts_neu):\n    if n == 0:\n        print(\"Fehler\", i)\n        break\n#print(Counts_neu[0:378])\n\nCounts_M = Counts_r\nZeiten = Zeiten_r\n\nCounts_neu[0] = 0\nCounts_neu[1] = 0\nCounts_neu[2] = 0\n\n\n#Counts_fusch = np.array([n for n in Counts_neu if n != 0]) # mach aus Counts_M Counts_neu\n#Zeiten_fusch = np.array([Zeiten_neu[i] for i,n in enumerate(Counts_neu) if n != 0]) # mach aus Counts_M Counts_neu und Zeiten\n#Errors_fusch = np.sqrt(Counts_fusch)\n\nCounts_fusch = Counts_neu_1[1:184]\nZeiten_fusch = Zeiten_neu_1[1:184]\nErrors_fusch = np.sqrt(Counts_fusch)\n\nLD_Params, LD_Covariance = curve_fit(Lebensdauer, Zeiten_fusch, Counts_fusch,  sigma = Errors_fusch, absolute_sigma = True)\nLD_Errors = np.sqrt(np.diag(LD_Covariance))\n\nN0 = ufloat(LD_Params[0], LD_Errors[0])\nLB = ufloat(LD_Params[1], LD_Errors[1])\nLD = 1 \/LB\nU_fit = ufloat(LD_Params[2], LD_Errors[2])\n\nprint(\"Wert für N0: \", N0)\nprint(\"Zerfallskonstante: \", LB)\nprint(\"Lebensdauer: \", LD)\nprint(\"Untergrund durch Fit: \", U_fit, '\\n')\n\nZeiten_x = np.linspace(-2, 12, 1000)\n\nplt.clf()\nplt.errorbar(Zeiten_fusch, Counts_fusch, xerr = 0, yerr = Errors_fusch, fmt = 'kx', label = r'Messwerte')\nplt.plot(Zeiten_x, Lebensdauer(Zeiten_x, *LD_Params), 'r-', label = r'Exponentieller Fit')\nplt.xlim(-0.5,11.5)\n#plt.ylim(-2, 65)\nplt.axvline(0, color = 'b', linestyle = '-', label = r'$t=0$')\nplt.ylabel(r'N(t)')\nplt.yscale('log')\nplt.xlabel(r'$t$ in $\\mathrm{ns}$')\nplt.legend(loc = 'best')\nplt.savefig('Spektrum_klein_log.pdf')\nplt.show()\n\nprint(\"Verhältnisse Untergrund:\", U_Search\/U_fit)\n\nLD_Lit = 2.20\n\nprint(\"Verhältniss Lebensdaier:\", LD\/LD_Lit)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_404","text":"<gh_stars>0\nimport sys\nimport os\nimport numpy\nimport scipy.linalg\nimport matplotlib.animation\nimport matplotlib.pyplot as plt\n\n\ndef phi(N, x):\n    coef = tuple(0 if i < N else 1 for i in range(N+1))\n    return numpy.polynomial.hermite.hermval(x, c=coef) * numpy.exp(-(x**2) \/ 2) \/ (numpy.power(numpy.pi, 0.25) * numpy.sqrt(2**N * numpy.math.factorial(N)))\n\n\ndef V1D(lam, x):\n    return x*x \/ 2 + lam * numpy.power(x, 4)\n\n\ndef V2D(lam, x, y):\n    return (x*x + y*y) \/ 2 + lam * x*x*y*y\n\n\ndef finite_difference_step(psi, tau, h, V):\n    return psi + 1j * tau * ((numpy.roll(psi,1) + numpy.roll(psi,-1) - 2 * psi) \/ (2*h**2) - V * psi)\n\n\ndef finite_propagator_step(psi, tau, h, K, V):\n    hbar_psi = psi\n    state = psi\n    for k in range(1, K+1):\n        hbar_psi = - (1j * tau * ((numpy.roll(hbar_psi,1) + numpy.roll(hbar_psi,-1) - 2 * hbar_psi) \/ (2*h**2) - V * hbar_psi))\n        state += (-1j*tau)**k \/ numpy.math.factorial(k) * hbar_psi\n    return state\n\n\ndef implicit_scheme_step(psi, tau, h, V):\n    upper = - 1j * tau \/ (4*h*h) * numpy.ones(len(psi))\n    upper[0] = 0\n    lower = - 1j * tau \/ (4*h*h) * numpy.ones(len(psi))\n    lower[-1] = 0\n    diag = 1j * tau \/ 2 * V + 1 + 1j * tau \/ (2*h*h)\n\n    ab = numpy.array([upper, diag, lower], dtype=complex)\n    b = psi + 1j * tau \/ 4 * ((numpy.roll(psi,1) + numpy.roll(psi,-1) - 2 * psi) \/ (h**2) - 2 * V * psi)\n    \n    return scipy.linalg.solve_banded((1,1), ab, b)\n\n\ndef time_evolution(N, lam, x, h, tau, niter, method, K=None):\n    if method == 1 and K is None:\n        print(\"Specify K for finite propagator\")\n        sys.exit()\n\n    Vm = V1D(lam, x)\n    states = numpy.zeros((niter+1, len(Vm)), dtype=complex)\n\n    states[0] = phi(N, x)\n    for n in range(niter):\n        states[n][0] = 0\n        states[n][-1] = 0\n        if method == 0:\n            states[n+1] = finite_difference_step(states[n], tau, h, Vm)\n        elif method == 1:\n            states[n+1] = finite_propagator_step(states[n], tau, h, K, Vm)\n        elif method == 2:\n            states[n+1] = implicit_scheme_step(states[n], tau, h, Vm)\n\n    return states\n\n\ndef animate(x, states, filename, lam, h, tau, N, interval_base=200, interval_slow=500, range_slow=None, frames_slow=20):\n    print(\"Rendering animation ...\")\n    fig, ax = plt.subplots()\n    plt.suptitle(\"Time evolution of anharmonic oscilator wave function\\n($\\\\lambda = {0}, h = {1}, \\\\tau = {2}, N = {3}$)\".format(lam, h, tau, N))\n    plt.xlabel(r\"$x$\")\n    plt.ylabel(r\"$|\\psi|^2$\")\n    \n    def animate_func(frame):\n        ax.clear()\n        ax.plot(x, numpy.abs(states[frame])**2)\n\n    def animate_func2(frame):\n        ax.clear()\n        ax.plot(x, numpy.abs(states[frame+range_slow])**2)\n\n    os.chdir(\"hw1_schroedinger-equation-spectrum-and-time-evolution\/images\/\")\n    \n    animation = matplotlib.animation.FuncAnimation(fig, animate_func, frames=len(states), interval=interval_base)\n    animation.save(filename+\".html\")\n\n    if range_slow is not None:\n        animation = matplotlib.animation.FuncAnimation(fig, animate_func2, frames=frames_slow, interval=interval_slow)\n        animation.save(filename+\"_slow.html\")\n\n\ndef testing(method=2):\n    if method == 0:  # tau < h**2\n        N = 0\n        lam = 0\n        L = 10\n        h = 0.1\n        tau = 0.0099\n        niter = 120\n        x = numpy.linspace(-L, L, 2*L\/h)\n\n        states = time_evolution(N, lam, x, h, tau, niter, method)\n        animate(x, states, \"naloga1_finite_diff\"+str(N)+\",\"+str(lam)+\",\"+str(h)+\",\"+str(tau), lam, h, tau, N, range_slow=90)\n\n    elif method == 1:  # tau < 2 * pi * h**2\n        N = 0\n        lam = 0\n        L = 10\n        h = 0.1\n        tau = 0.0099 * 3.14\n        niter = 400\n        K = 10\n        x = numpy.linspace(-L, L, 2*L\/h)\n        states = time_evolution(N, lam, x, h, tau, niter, method, K=K)\n        animate(x, states, \"naloga1_finite_propagator\"+str(N)+\",\"+str(lam)+\",\"+str(h)+\",\"+str(tau)+\",\"+str(K), lam, h, tau, N, interval_base=20, range_slow=340, frames_slow=60)\n\n    elif method == 2:\n        N = 0\n        lam = 0\n        L = 10\n        h = 0.1\n        tau = 0.0099\n        niter = 1000\n        x = numpy.linspace(-L, L, 2*L\/h)\n        states = time_evolution(N, lam, x, h, tau, niter, method)\n        animate(x, states, \"naloga1_implicit_scheme\"+str(N)+\",\"+str(lam)+\",\"+str(h)+\",\"+str(tau), lam, h, tau, N, interval_base=5)\n\n\ndef task1():\n    Ns = range(6)\n    lams = numpy.linspace(0, 0.5, 3)\n    L = 10\n    h = 0.1\n    tau = 0.0099\n    niter = 1000\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n\n    print(\"Generating states ...\")\n    N_to_lams_to_states = {}\n    for N in Ns:\n        N_to_lams_to_states[N] = {}\n        for lam in lams:\n            N_to_lams_to_states[N][lam] = time_evolution(N, lam, x, h, tau, niter, method=2)\n\n    # # for lambda = 0 it's constant\n    # fig, axes = plt.subplots(2, 3, figsize=(16,9))\n    # fig.suptitle(\"Evolution for $\\\\lambda=0$ is time independent\")\n    # for N in Ns:\n    #     i = N \/\/ 3\n    #     j = N % 3\n    #     axes[i, j].set_title(\"$N={}$\".format(N))\n    #     axes[i, j].set_ylim(bottom=0, top=1)\n    #     axes[i, j].plot(x, numpy.abs(N_to_lams_to_states[N][0][0])**2)\n    # fig.savefig(\"naloga1_N_lambda_0.pdf\", bbox_inches=\"tight\")\n    # sys.exit()\n\n    # plot each subplot different N\n    print(\"Animating per N ...\")\n    fig, axes = plt.subplots(2, 3, figsize=(32,18))\n    fig.suptitle(\"Time evolution\")\n\n    def animate_per_N(frame):\n        print(\"\\t{0} | {1}\".format(niter, frame+1))\n        for N in Ns:\n            i = N \/\/ 3\n            j = N % 3\n            axes[i, j].clear()\n            axes[i, j].set_title(\"$N = {}$\".format(N))\n            axes[i, j].set_ylim(bottom=0, top=1.5)\n            for lam in lams:\n                axes[i, j].plot(x, numpy.abs(N_to_lams_to_states[N][lam][frame])**2)\n\n    animation = matplotlib.animation.FuncAnimation(fig, animate_per_N, frames=niter, interval=50)\n    animation.save(\"naloga1_N.mp4\")\n\n    # plot each subplot different lambda\n    print(\"Animating per lambda ...\")\n    fig, axes = plt.subplots(1, 3, figsize=(32,18))\n    fig.suptitle(\"Time evolution\")\n\n    def animate_per_lam(frame):\n        print(\"\\t{0} | {1}\".format(niter, frame+1))\n        for lam in lams:\n            i = int(lam * 4)\n            axes[i].clear()\n            axes[i].set_title(\"$\\\\lambda = {}$\".format(lam))\n            axes[i].set_ylim(bottom=0, top=1.5)\n            for N in Ns:\n                axes[i].plot(x, numpy.abs(N_to_lams_to_states[N][lam][frame])**2)\n\n    animation = matplotlib.animation.FuncAnimation(fig, animate_per_lam, frames=niter, interval=50)\n    animation.save(\"naloga1_lambda.mp4\")\n\n    # plot each subplot different N, lambda=0\n    print(\"Animating different N, lambda = 0 ...\")\n    fig, axes = plt.subplots(2, 3, figsize=(32,18))\n    fig.suptitle(\"Time evolution for $\\\\lambda=0$\")\n\n    def animate_per_N_fixed_lambda(frame):\n        print(\"\\t{0} | {1}\".format(niter, frame+1))\n        lam = 0\n        for N in Ns:\n            i = N \/\/ 3\n            j = N % 3\n            axes[i, j].clear()\n            axes[i, j].set_title(\"$N = {}$\".format(N))\n            axes[i, j].set_ylim(bottom=0, top=1)\n            axes[i, j].plot(x, numpy.abs(N_to_lams_to_states[N][lam][frame])**2)\n\n    animation = matplotlib.animation.FuncAnimation(fig, animate_per_N_fixed_lambda, frames=niter, interval=5)\n    animation.save(\"naloga1_N_lambda_0.mp4\")\n\n\ndef time_evolution_changing_lambda(lams, x, h, tau, niter, L, a=5):\n    interval = int(numpy.ceil(niter \/ len(lams)))\n    \n    print(\"Generating states ...\")\n    states = numpy.zeros((niter+1, len(x)), dtype=complex)\n    states[0] = phi(0, x-a)\n    for n in range(niter):\n        Vm = V1D(lams[n\/\/interval], x)\n        states[n][0] = 0\n        states[n][-1] = 0\n        states[n+1] = implicit_scheme_step(states[n], tau, h, Vm)\n\n    print(\"Animating TASK 2 ...\")\n    fig, ax = plt.subplots()\n    fig.suptitle(\"Task 2: $N=0, a={0}, \\\\lambda \\\\in {1}$\".format(a, lams))\n\n    def animate(frame):\n        print(\"Animating TASK 2\\t{0} | {1}\".format(niter, frame+1))\n        ax.clear()\n        ax.set_title(\"$\\\\lambda={}$\".format(lams[frame\/\/interval]))\n        ax.set_ylim(bottom=0, top=1.5)\n        ax.plot(x, numpy.abs(states[frame])**2)\n\n    animation = matplotlib.animation.FuncAnimation(fig, animate, frames=niter, interval=5)\n    animation.save(\"naloga2_L{0}_a{1}.mp4\".format(L, a))\n\n\ndef task2(a):\n    Ns = range(6)\n    lams = numpy.linspace(0, 0.5, 11)\n    lams = [0]\n    L = 10\n    h = 0.1\n    tau = 0.0099\n    niter = 10000\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n\n    states = time_evolution_changing_lambda(lams, x, h, tau, niter, L, a=a)\n\n\ndef task2_extra():\n    \"\"\"\n    Time of travel of Gaussian to 0 from a = L\/2 with respect to L.\n    \"\"\"\n    N = 0\n    lam = 0\n    Ls = numpy.array([2*L for L in range(1,23)])\n    h = 0.01\n    tau = 0.000099\n\n    iterss = []\n\n    for L in Ls:\n        a = L \/\/ 2\n        print(L)\n        x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n        # eps = int(0.1 * len(x))\n\n        Vm = V1D(lam, x)\n        state = phi(N, x-a)\n\n        iters = 0\n        while True:\n            prob = numpy.abs(state)**2\n            mid = int(2*L\/h) \/\/ 2\n            # if max(prob) in prob[mid-eps:mid+eps]:\n            if numpy.argmax(prob) <= mid:\n                print(iters)\n                iterss.append(iters)\n                break\n\n            state[0] = 0\n            state[-1] = 0\n            state = implicit_scheme_step(state, tau, h, Vm)\n            iters += 1\n\n    fig = plt.figure()\n    plt.title(\"Iterations of Gaussian travel to center\")\n    plt.xlabel(\"$L$\")\n    plt.ylabel(\"Time\")\n    plt.plot(Ls, tau*numpy.array(iterss))\n    plt.show()\n    fig.savefig(\"naloga2_iters_of_gaussian_travel.pdf\", bbox_inches=\"tight\")\n\n\ndef task2_extra2():\n    \"\"\"\n    Time of travel of Gaussian to 0 for fixed L and different a.\n    \"\"\"\n    N = 0\n    lam = 0\n    L = 10\n    h = 0.001\n    tau = 0.000099\n    aa = numpy.array([0.25*a for a in range((L-1)*4)])\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n    Vm = V1D(lam, x)\n    # eps=int(0.1*len(x))\n\n    iterss = []\n    for a in aa:\n        print(a)\n        state = phi(N, x-a)\n\n        iters = 0\n        while True:\n            prob = numpy.abs(state)**2\n            mid = int(2*L\/h) \/\/ 2\n            # if max(prob) in prob[mid-eps:mid+eps]:\n            if numpy.argmax(prob) <= mid:\n                print(iters)\n                iterss.append(iters)\n                break\n\n            state[0] = 0\n            state[-1] = 0\n            state = implicit_scheme_step(state, tau, h, Vm)\n            iters += 1\n\n    fig = plt.figure()\n    plt.title(\"Iterations of Gaussian travel to center ($L={}$)\".format(L))\n    plt.xlabel(\"$a$\")\n    plt.ylabel(\"Time\")\n    plt.plot(aa, tau*numpy.array(iterss))\n    plt.show()\n    fig.savefig(\"naloga2_iters_of_gaussian_travel_fixedL={}.pdf\".format(L), bbox_inches=\"tight\")\n\n\ndef task2_extra3():\n    N = 0\n    lam = 0\n    L = 10\n    h = 0.01\n    tau = 0.001\n    aa = numpy.array([0, 0.1, 0.2, 0.3, 0.4] + [0.5*a for a in range(1,L-1)])\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n    Vm = V1D(lam, x)\n    niter = 20000\n\n    errorss = []\n    for a in aa:\n        print(a)\n        errors = []\n        initial = numpy.abs(phi(N, x-a))**2\n        initial[0] = 0\n        initial[-1] = 0\n        state = phi(N, x-a)\n        for i in range(niter):\n            diff = (numpy.abs(state)**2 - initial)\n            errors.append(numpy.sqrt(diff.dot(diff)))\n            state[0] = 0\n            state[-1] = 0\n            state = implicit_scheme_step(state, tau, h, Vm)\n        errorss.append(errors)\n    \n    fig = plt.figure()\n    plt.title(\"Distance between initial state and running state\")\n    plt.xlabel(\"Time\")\n    plt.ylabel(\"Distance ($||\\\\,|\\psi(t=n\\\\tau)|^2 - |\\\\psi(0)|^2\\\\,||$)\")\n    plots = []\n    for i in range(len(aa)):\n        plots += plt.plot(tau*numpy.array(range(niter)), numpy.array(errorss[i]) \/ numpy.amax(errorss), linewidth=1)\n    plt.legend(plots, aa, title=\"$a$\", loc=\"upper right\")\n    fig.savefig(\"naloga2_distance.pdf\", bbox_inches=\"tight\")\n    plt.show()\n\n\ndef task2_extra3a():\n    N = 0\n    lam = 0\n    L = 10\n    h = 0.01\n    tau = 0.001\n    a = 3\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n    Vm = V1D(lam, x)\n    niter = 20000\n\n    states = numpy.zeros((niter+1, len(x)), dtype=complex)\n    states[0] = phi(0, x-a)\n    initial = numpy.abs(states[0])**2\n    for n in range(niter):\n        states[n][0] = 0\n        states[n][-1] = 0\n        states[n+1] = implicit_scheme_step(states[n], tau, h, Vm)\n\n    print(\"Animating TASK 2 ...\")\n    fig, ax = plt.subplots()\n    fig.suptitle(\"Time evolution ($a = 3$)\")\n\n    def animate(frame):\n        print(\"Animating TASK 2\\t{0} | {1}\".format(niter, frame+1))\n        diff = (numpy.abs(states[frame])**2 - initial)\n        dist = numpy.sqrt(diff.dot(diff))\n        ax.clear()\n        ax.set_title(\"$d(\\\\psi(0), \\\\psi({0})) = {1}$\".format(frame, numpy.round(dist, decimals=5)))\n        ax.set_ylim(bottom=0, top=1)\n        ax.plot(x, initial, \"k-\", linewidth=1)\n        ax.plot(x, numpy.abs(states[frame])**2)\n\n    animation = matplotlib.animation.FuncAnimation(fig, animate, frames=niter, interval=2)\n    animation.save(\"naloga2_L{0}_a{1}.mp4\".format(L, a))\n\n    \n\n\ndef task3(a=5):\n    Ns = range(6)\n    lams = numpy.linspace(0, 0.5, 11)\n    L = 10\n    h = 0.1\n    tau = 0.0099\n    niter = 10000\n    x = numpy.linspace(-L, L, int(2*L\/h) + 1)\n    \n\nif __name__ == \"__main__\":\n    os.chdir(\"hw1_schroedinger-equation-spectrum-and-time-evolution\/images\/\")\n\n    # task1()\n    for a in [1, 3, 5]:\n        task2(a)\n    # task3()\n    # task2_extra()\n    # task2_extra2()\n    task2_extra3a()"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_408","text":"<filename>adapt\/prepare\/cluster.py<gh_stars>10-100\n\"\"\"Functions for clustering sequences before input.\n\nThis includes computing a distance matrix using MinHash, and\nclustering that matrix.\n\"\"\"\n\nfrom collections import defaultdict\nfrom collections import OrderedDict\nimport logging\nimport operator\n\nimport numpy as np\nfrom scipy.cluster import hierarchy\n\nfrom adapt.utils import lsh\n\n__author__ = '<NAME> <<EMAIL>>'\n\nlogger = logging.getLogger(__name__)\n\n\ndef make_signatures_with_minhash(family, seqs):\n    \"\"\"Construct a signature using MinHash for each sequence.\n\n    Args:\n        family: lsh.MinHashFamily object\n        seqs: dict mapping sequence header to sequences\n\n    Returns:\n        dict mapping sequence header to signature\n    \"\"\"\n    # Construct a single hash function; use the same for all sequences\n    h = family.make_h()\n\n    signatures = {}\n    for name, seq in seqs.items():\n        signatures[name] = h(seq)\n    return signatures\n\n\ndef create_condensed_dist_matrix(n, dist_fn):\n    \"\"\"Construct a 1d condensed distance matrix for scipy.\n\n    Args:\n        n: number of elements whose pairwise distances to store in the\n            matrix\n        dist_fn: function such that dist_fn(i, j) gives the distance\n            between i and j, for all i<j<n\n\n    Returns:\n        condensed 1d distance matrix for input to scipy functions\n    \"\"\"\n    def idx(i, j):\n        # Compute index in 1d vector for pair (i, j)\n        return int((-1 * i*i)\/2 + i*n - 3*i\/2 + j - 1)\n\n    dist_matrix_len = int(n*(n-1)\/2)\n    dist_matrix = np.zeros(dist_matrix_len)\n\n    for j in range(n):\n        for i in range(j):\n            dist_matrix[idx(i, j)] = dist_fn(i, j)\n\n    return dist_matrix\n\n\ndef cluster_from_dist_matrix(dist_matrix, threshold, num_clusters=None):\n    \"\"\"Use scipy to cluster a distance matrix.\n\n    Args:\n        dist_matrix: distance matrix, represented in scipy's 1d condensed form\n        threshold: maximum inter-cluster distance to merge clusters (higher\n            results in fewer clusters)\n        num_clusters: if set, cluster such that this is the maximum number\n            of clusters; threshold is ignored and must be None\n\n    Returns:\n        list c such that c[i] is a collection of all the observations\n        (whose pairwise distances are indexed in dist) in the i'th\n        cluster, in sorted order by descending cluster size\n    \"\"\"\n    if threshold is None and num_clusters is None:\n        raise ValueError((\"threshold or num_clusters must be set\"))\n    elif threshold is not None and num_clusters is not None:\n        raise ValueError((\"Only one of threshold or num_clusters can be \"\n            \"set\"))\n\n    linkage = hierarchy.linkage(dist_matrix, method='average')\n    if threshold:\n        clusters = hierarchy.fcluster(linkage, threshold, criterion='distance')\n    elif num_clusters:\n        clusters = hierarchy.fcluster(linkage, num_clusters,\n            criterion='maxclust')\n\n    # clusters are numbered starting at 1, but base the count on\n    # first_clust_num just in case this changes\n    first_clust_num = min(clusters)\n    num_clusters_found = max(clusters) + 1 - first_clust_num\n    elements_in_cluster = defaultdict(list)\n    for i, clust_num in enumerate(clusters):\n        elements_in_cluster[clust_num].append(i)\n    cluster_sizes = {c: len(elements_in_cluster[c])\n                     for c in range(first_clust_num,\n                                    num_clusters_found + first_clust_num)}\n\n    elements_in_cluster_sorted = []\n    for clust_num, _ in sorted(cluster_sizes.items(),\n            key=operator.itemgetter(1), reverse=True):\n        elements_in_cluster_sorted += [elements_in_cluster[clust_num]]\n    return elements_in_cluster_sorted\n\n\ndef cluster_with_minhash_signatures(seqs, k=12, N=100, threshold=0.1,\n        num_clusters=None, return_dist_matrix_and_indices=False):\n    \"\"\"Cluster sequences based on their MinHash signatures.\n\n    Args:\n        seqs: dict mapping sequence header to sequences\n        k: k-mer size to use for k-mer hashes (smaller is likely more\n            sensitive for divergent genomes, but may lead to false positives\n            in determining which genomes are close)\n        N: number of hash values to use in a signature (higher is slower for\n            clustering, but likely more sensitive for divergent genomes)\n        threshold: maximum inter-cluster distance to merge clusters, in\n            average nucleotide dissimilarity (1-ANI, where ANI is\n            average nucleotide identity); higher results in fewer\n            clusters\n        num_clusters: if set, cluster such that this is the maximum number\n            of clusters; threshold is ignored and must be None\n        return_dist_matrix_and_indices: if set, return the pairwise distance\n            matrix and sequences indices in each cluster; when used,\n            seqs should be an OrderedDict\n\n    Returns:\n        if return_dist_matrix_and_indices:\n            tuple (dm, c) such that dm is the pairwise distance matrix and\n            c is a list such that c[i] gives a collection of sequence\n            indices (corresponding to indices in dm) in the same cluster\n            (note dm is a 1d condensed matrix in scipy's form); clusters in\n            c are sorted in descending order of size\n        else:\n            list c such that c[i] gives a collection of sequence headers\n            in the same cluster, and the clusters in c are sorted\n            in descending order of size\n    \"\"\"\n    if len(seqs) == 1:\n        # Simply return one cluster\n        if return_dist_matrix_and_indices:\n            return None, [[0]]\n        else:\n            return [[list(seqs.keys())[0]]]\n\n    family = lsh.MinHashFamily(k, N=N)\n    signatures_map = make_signatures_with_minhash(family, seqs)\n\n    # Map each sequence header to an index (0-based), and get\n    # the signature for the corresponding index\n    num_seqs = len(seqs)\n    seq_headers = []\n    signatures = []\n    for name, seq in seqs.items():\n        seq_headers += [name]\n        signatures += [signatures_map[name]]\n\n    # Eq. 4 of the Mash paper (Ondov et al. 2016) shows that the\n    # Mash distance, which is shown to be closely related to 1-ANI, is:\n    #  D = (-1\/k) * ln(2*j\/(1+j))\n    # where j is a Jaccard similarity. Solving for j:\n    #  j = 1\/(2*exp(k*D) - 1)\n    # So, for a desired distance D in terms of 1-ANI, the corresponding\n    # Jaccard distance is:\n    #  1.0 - 1\/(2*exp(k*D) - 1)\n    # We can use this to calculate a clustering threshold in terms of\n    # Jaccard distance\n    if threshold is not None:\n        jaccard_dist_threshold = 1.0 - 1.0\/(2.0*np.exp(k*threshold) - 1)\n    else:\n        # Ignore inter-cluster distance; use num_clusters instead\n        jaccard_dist_threshold = None\n\n    def jaccard_dist(i, j):\n        # Return estimated Jaccard dist between signatures at\n        # index i and index j\n        return family.estimate_jaccard_dist(\n            signatures[i], signatures[j])\n\n    dist_matrix = create_condensed_dist_matrix(num_seqs, jaccard_dist)\n    clusters = cluster_from_dist_matrix(dist_matrix,\n        jaccard_dist_threshold, num_clusters=num_clusters)\n\n    if return_dist_matrix_and_indices:\n        return dist_matrix, clusters\n    else:\n        seqs_in_cluster = []\n        for cluster_idxs in clusters:\n            seqs_in_cluster += [[seq_headers[i] for i in cluster_idxs]]\n        return seqs_in_cluster\n\n\ndef find_representative_sequences(seqs, k=12, N=100, threshold=0.1,\n        num_clusters=None, frac_to_cover=1.0):\n    \"\"\"Find a set of representative sequences.\n\n    This clusters seqs, and then determines a medoid for each cluster.\n    It returns the medoids.\n\n    This will not return representative sequences with ambiguity or NNNs.\n\n    Args:\n        seqs, k, N, threshold, num_clusters: see cluster_with_minhash_signatures()\n        frac_to_cover: return medoids from clusters that collectively\n            account for at least this fraction of all sequences; this\n            allows ignoring representative sequences for outlier\n            clusters\n\n    Returns:\n        tuple (set of sequence headers representing cluster medoids,\n        fraction of all sequences contained in cluster)\n    \"\"\"\n    seqs = OrderedDict(seqs)\n    dist_matrix, clusters = cluster_with_minhash_signatures(\n            seqs, k=k, N=N, threshold=threshold, num_clusters=num_clusters,\n            return_dist_matrix_and_indices=True)\n\n    seqs_items = list(seqs.items())\n    n = len(seqs)\n    def idx(i, j):\n        # Compute index in 1d vector for pair (i, j)\n        if i > j:\n            i, j = j, i\n        return int((-1 * i*i)\/2 + i*n - 3*i\/2 + j - 1)\n\n    rep_seqs = []\n    rep_seqs_frac = []\n    num_seqs_accounted_for = 0\n    for cluster_idxs in clusters:\n        # Stop if we have already accounted for frac_to_cover of the\n        # sequences\n        # Note that clusters should be sorted in descending order of\n        # size, so any clusters after this one will be the same size\n        # or smaller\n        if float(num_seqs_accounted_for) \/ len(seqs) >= frac_to_cover:\n            break\n\n        # Find the medoid of this cluster\n        # Simply look over all pairs in the cluster (there are faster\n        # algorithms, though not linear)\n        curr_medoid = None\n        curr_medoid_dist_total = None\n        for i in cluster_idxs:\n            # Only allow i to be the medoid if it does not have ambiguity\n            seq = seqs_items[i][1]\n            if sum(seq.count(b) for b in ('A','C','G','T')) != len(seq):\n                # Has ambiguity or NNNs; skip\n                continue\n\n            # Compute the total distance to all other sequences in this\n            # cluster, and check if this is the medoid\n            dist_total = 0\n            for j in cluster_idxs:\n                if i == j:\n                    continue\n                dist_total += dist_matrix[idx(i,j)]\n            if curr_medoid is None or dist_total < curr_medoid_dist_total:\n                curr_medoid = i\n                curr_medoid_dist_total = dist_total\n        if curr_medoid is not None:\n            rep_seqs += [curr_medoid]\n            rep_seqs_frac += [float(len(cluster_idxs)) \/ len(seqs)]\n            num_seqs_accounted_for += len(cluster_idxs)\n        else:\n            # All sequences have ambiguity or NNNs; raise a warning and\n            # skip this cluster\n            logger.warning((\"Cannot find medoid for cluster of size %d \"\n                \"because all sequences have ambiguity or NNNs; skipping \"\n                \"this cluster\"),\n                len(cluster_idxs))\n\n    return ([seqs_items[i][0] for i in rep_seqs], rep_seqs_frac)\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_409","text":"<filename>src\/beatmapsynth.py\nfrom __future__ import print_function\nimport numpy as np\nimport pandas as pd\nimport librosa\nimport json\n#import requests\nimport pickle\n#import matplotlib.pyplot as plt\nfrom io import BytesIO, TextIOWrapper, StringIO\nfrom zipfile import ZipFile\nimport os\nimport soundfile as sf\nimport audioread\nfrom pydub import AudioSegment\n#from sklearn.multioutput import MultiOutputClassifier, ClassifierChain\n#from sklearn.ensemble import RandomForestClassifier\nimport markovify\nimport sklearn.cluster\n#import librosa.display\nimport scipy\nimport sys\nimport argparse\nimport shutil\n\n#Main Function:\ndef beat_map_synthesizer(song_path, song_name, difficulty, model, k=5, version = 2):\n    \"\"\"\n    Function to load a music file and generate a custom Beat Saber map based on the specified model and difficulty. Outputs a zipped folder of necessary files to play the custom map in the Beat Saber game.\n    \n    ***\n    song_path = string file path to music file location\n    \n    song_name = string to name level as it will appear in the game\n    \n    difficulty = desired difficulty level, can be: 'easy', 'normal', 'hard', 'expert', or 'expertPlus'\n    \n    model = desired model to use for map generation, can be: 'random', 'HMM', 'segmented_HMM', or 'rate_modulated_segmented_HMM'\n    \n    k = number of song segments if using a segmented model. Default is 5, may want to increase or decrease based on song complexity\n   \n    version = for HMM models, can choose either 1 or 2. 1 was trained on a smaller, but potentially higher quality dataset (custom maps with over 90% rating on beatsaver.com), while 2 was trained on a larger dataset of custom maps with over 70% rating, so it may have a larger pool of \"potential moves.\"\n    ***\n    \"\"\"\n    if model == 'random':\n        random_mapper(song_path, song_name, difficulty)\n    elif model == 'HMM':\n        HMM_mapper(song_path, song_name, difficulty, version = version)\n    elif model == 'segmented_HMM':\n        segmented_HMM_mapper(song_path, song_name, difficulty, k = k, version = version)\n    elif model == 'rate_modulated_segmented_HMM':\n        rate_modulated_segmented_HMM_mapper(song_path, song_name, difficulty, version = version, k = k)\n    else:\n        print('Please specify model for mapping.')\n\n#Basic File Writing Functions\ndef write_info(song_name, bpm, difficulty):\n    \"\"\"This function creates the 'info.dat' file that needs to be included in the custom folder.\"\"\"\n\n    difficulty_rank = None\n    jump_movement = None\n    if difficulty.casefold() == 'easy'.casefold():\n        difficulty_rank = 1\n        jump_movement = 8\n        diff_name = 'Easy'\n    elif difficulty.casefold() == 'normal'.casefold():\n        difficulty_rank = 3\n        jump_movement = 10\n        diff_name = 'Normal'\n    elif difficulty.casefold() == 'hard'.casefold():\n        difficulty_rank = 5\n        jump_movement = 12\n        diff_name = 'Hard'\n    elif difficulty.casefold() == 'expert'.casefold():\n        difficulty_rank = 7\n        jump_movement = 14\n        diff_name = 'Expert'\n    elif difficulty.casefold() == 'expertPlus'.casefold():\n        difficulty_rank = 9\n        jump_movement = 16\n        diff_name = 'ExpertPlus'\n            \n    info = {'_version': '2.0.0',\n            '_songName': f\"{song_name}\",\n            '_songSubName': '',\n            '_songAuthorName': '',\n            '_levelAuthorName': 'BeatMapSynth',\n            '_beatsPerMinute': round(bpm),\n            '_songTimeOffset': 0,\n            '_shuffle': 0,\n            '_shufflePeriod': 0,\n            '_previewStartTime': 10,\n            '_previewDuration': 30,\n            '_songFilename': 'song.egg',\n            '_coverImageFilename': 'cover.jpg',\n            '_environmentName': 'DefaultEnvironment',\n            '_customData': {},\n             '_difficultyBeatmapSets': [{'_beatmapCharacteristicName': 'Standard',\n                                         '_difficultyBeatmaps': [{'_difficulty': diff_name,\n                                                                  '_difficultyRank': difficulty_rank,\n                                                                  '_beatmapFilename': f\"{difficulty}.dat\",\n                                                                  '_noteJumpMovementSpeed': jump_movement,\n                                                                  '_noteJumpStartBeatOffset': 0,\n                                                                  '_customData': {}}]}]}\n    with open('info.dat', 'w') as f:\n        json.dump(info, f)\n\ndef write_level(difficulty, events_list, notes_list, obstacles_list):\n    \"\"\"This function creates the 'level.dat' file that contains all the data for that paticular difficulty level\"\"\"\n    \n    level = {'_version': '2.0.0',\n             '_customData': {'_time': '', #not sure what time refers to \n                             '_BPMChanges': [], \n                             '_bookmarks': []},\n             '_events': events_list,\n             '_notes': notes_list,\n             '_obstacles': obstacles_list}\n    with open(f\"{difficulty}.dat\", 'w') as f:\n        json.dump(level, f)\n\ndef music_file_converter(song_path):\n    \"\"\"This function makes sure the file type of the provided song will be converted to the music file type that \n    Beat Saber accepts\"\"\"\n    if song_path.endswith('.mp3'):\n        AudioSegment.from_mp3(song_path).export('song.egg', format='ogg')\n    elif song_path.endswith('.wav'):\n        AudioSegment.from_wav(song_path).export('song.egg', format='ogg')\n    elif song_path.endswith('.flv'):\n        AudioSegment.from_flv(song_path).export('song.egg', format='ogg')\n    elif song_path.endswith('.raw'):\n        AudioSegment.from_raw(song_path).export('song.egg', format='ogg')\n    elif song_path.endswith('.ogg') or song_path.endswith('.egg'):\n        shutil.copy2(song_path, 'song.egg')\n    else:\n        print(\"Unsupported song file type. Choose a file of type .mp3, .wav, .flv, .raw, or .ogg.\")\n\ndef events_writer(beat_times):\n    \"\"\"Placeholder function for writing a list of events to be incorporated into a beatmap file. May have future support.\"\"\"\n    events_list = []\n    return events_list\n\ndef obstacles_writer(beat_times, difficulty):\n    \"\"\"Placeholder function for writing a list of obstacles to be incorporated into a beatmap file.\"\"\"\n    obstacles_list = []\n    return obstacles_list\n\ndef zip_folder_exporter(song_name, difficulty):\n    \"This function exports the zip folder containing the info.dat, difficulty.dat, cover.jpg, and song.egg files.\"\n    files = ['info.dat', f\"{difficulty}.dat\", 'cover.jpg', 'song.egg']\n    with ZipFile(f\"{song_name}.zip\", 'w') as custom:\n        for file in files:\n            custom.write(file)\n    for file in files:\n        if file != 'cover.jpg':\n            os.remove(file)\n\n#Random Mapping Functions\ndef random_mapper(song_path, song_name, difficulty):\n    \"\"\"Function to output the automatically created completely random map (i.e. baseline model) for a provided song. Returns a zipped folder that can be unzipped and placed in the 'CustomMusic' folder in the Beat Saber game directory and played. CAUTION: This is completely random and is likely not enjoyable if even playable!\"\"\"\n    #Load song and get beat features\n    print(\"Loading Song...\")\n    bpm, beat_times, y, sr = beat_features(song_path)\n    print(\"Song loaded successfully!\")\n    #Write lists for note placement, event placement, and obstacle placement\n    print(\"Random mapping...\")\n    #notes_list = random_notes_writer(beat_times, difficulty) \n    notes_list = random_notes_writer_v2(beat_times, difficulty, bpm) #fixes _time != beat time\n    events_list = events_writer(beat_times)\n    obstacles_list = obstacles_writer(beat_times, difficulty)\n    print(\"Mapping done!\")\n    #Write and zip files\n    print(\"Writing files to disk...\")\n    write_info(song_name, bpm, difficulty)\n    write_level(difficulty, events_list, notes_list, obstacles_list)\n    print(\"Converting music file...\")\n    music_file_converter(song_path)\n    print(\"Zipping folder...\")\n    zip_folder_exporter(song_name, difficulty)\n    print(\"Finished! Look for zipped folder in your current path, unzip the folder, and place in the 'CustomMusic' folder in the Beat Saber directory\")\n\ndef beat_features(song_path):\n    \"\"\"This function takes in the song stored at 'song_path' and estimates the bpm and beat times.\"\"\"\n    #Load song and split into harmonic and percussive parts.\n    y, sr = librosa.load(song_path)\n    #y_harmonic, y_percussive = librosa.effects.hpss(y)\n    #Isolate beats and beat times\n    bpm, beat_frames = librosa.beat.beat_track(y=y, sr=sr, trim = False)\n    beat_times = librosa.frames_to_time(beat_frames, sr=sr)\n    return bpm, beat_times, y, sr\n\ndef random_notes_writer_v2(beat_times, difficulty, bpm):\n    \"\"\"This function randomly places blocks at approximately each beat or every other beat depending on the difficulty.\"\"\"\n    notes_list = []\n    line_index = [0, 1, 2, 3]\n    line_layer = [0, 1, 2]\n    types = [0, 1, 2, 3]\n    directions = list(range(0, 10))\n    #beat_times = [float(x) for x in beat_times]\n    beat_times = [x*(bpm\/60) for x in beat_times] #list(range(len(beat_times)))\n    \n    if difficulty == 'Easy' or difficulty == 'Normal':\n        for beat in beat_times:\n            empty = np.random.choice([0,1])\n            if empty == 1:\n                note = {'_time': beat,\n                        '_lineIndex': int(np.random.choice(line_index)),\n                        '_lineLayer': int(np.random.choice(line_layer)),\n                        '_type': int(np.random.choice(types)),\n                        '_cutDirection': int(np.random.choice(directions))}\n                notes_list.append(note)\n            else:\n                continue\n    else:\n        random_beats = np.random.choice(beat_times, np.random.choice(range(len(beat_times)))) #randomly choose beats to have more than one note placed\n        randomly_duplicated_beat_times = np.concatenate([beat_times, random_beats])\n        randomly_duplicated_beat_times.sort()\n        randomly_duplicated_beat_times = [float(x) for x in randomly_duplicated_beat_times]\n        for beat in randomly_duplicated_beat_times:\n            note = {'_time': beat,\n                    '_lineIndex': int(np.random.choice(line_index)),\n                    '_lineLayer': int(np.random.choice(line_layer)),\n                    '_type': int(np.random.choice(types)),\n                    '_cutDirection': int(np.random.choice(directions))}\n            notes_list.append(note)\n    #Remove potential notes that come too early in the song:\n    for i, x in enumerate(notes_list):\n        if notes_list[i]['_time'] >= 0 and notes_list[i]['_time'] <= 1.5:\n            del notes_list[i]\n        elif notes_list[i]['_time'] > beat_times[-1]:\n            del notes_list[i]\n\n    return notes_list\n\n#Hidden Markov Models Mapping Functions\ndef HMM_mapper(song_path, song_name, difficulty, version = 2):\n    \"\"\"This function generates a custom map based on a Hidden Markov Model.\"\"\"\n    #Load song and get beat features\n    print(\"Loading Song...\")\n    bpm, beat_times, y, sr = beat_features(song_path)\n    beat_times = [x*(bpm\/60) for x in beat_times] #list(range(len(beat_times)))\n    print(\"Song loaded successfully!\")\n    #Write lists for note placement, event placement, and obstacle placement\n    print(\"Mapping with Hidden Markov Model...\")\n    notes_list = HMM_notes_writer(beat_times, difficulty, version)\n    events_list = events_writer(beat_times)\n    obstacles_list = obstacles_writer(beat_times, difficulty)\n    print(\"Mapping done!\")\n    #Write and zip files\n    print(\"Writing files to disk...\")\n    write_info(song_name, bpm, difficulty)\n    write_level(difficulty, events_list, notes_list, obstacles_list)\n    print(\"Converting music file...\")\n    music_file_converter(song_path)\n    print(\"Zipping folder...\")\n    zip_folder_exporter(song_name, difficulty)\n    print(\"Finished! Look for zipped folder in your current path, unzip the folder, and place in the 'CustomMusic' folder in the Beat Saber directory\")\n\ndef walk_to_df(walk):\n    \"\"\"Function for turning a Markov walk sequence into a DataFrame of note placement predictions\"\"\"\n    sequence = []\n    for step in walk:\n        sequence.append(step.split(\",\"))\n    constant = ['notes_type_0', 'notes_lineIndex_0', 'notes_lineLayer_0',\n                    'notes_cutDirection_0', 'notes_type_1', 'notes_lineIndex_1', 'notes_lineLayer_1', \n                    'notes_cutDirection_1', 'notes_type_3', 'notes_lineIndex_3',\n                    'notes_lineLayer_3', 'notes_cutDirection_3']\n    df = pd.DataFrame(sequence, columns = constant)\n    return df\n\ndef HMM_notes_writer(beat_list, difficulty, version):\n    \"\"\"Writes a list of notes based on a Hidden Markov Model walk.\"\"\"\n    #Load model\n    if version == 1:\n        with open(f\"..\/..\/models\/HMM_{difficulty}.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n    elif version == 2:\n        with open(f\"..\/..\/models\/HMM_{difficulty}_v2.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n    #Set note placement rate dependent on difficulty level\n    counter = 2\n    beats = []\n    rate = None\n    if difficulty == 'easy':\n        rate = 3\n    elif difficulty == 'normal':\n        rate = 2\n    else:\n        rate = 1\n    while counter <= len(beat_list):\n        beats.append(counter)\n        counter += rate\n    #Get HMM walk long enough to cover number of beats\n    random_walk = MC.walk()\n    while len(random_walk) < len(beats):\n        random_walk = MC.walk()\n    df_walk = walk_to_df(random_walk)\n    #Combine beat numbers with HMM walk steps\n    df_preds = pd.concat([pd.DataFrame(beats, columns = ['_time']), df_walk], axis = 1, sort = True)\n    df_preds.dropna(axis = 0, inplace = True)\n    #Write notes dictionaries\n    notes_list = []\n    for index, row in df_preds.iterrows():\n        for x in list(filter(lambda y: y.startswith('notes_type'), df_preds.columns)):\n            if row[x] != '999':\n                num = x[-1]\n                note = {'_time': row['_time'],\n                        '_lineIndex': int(row[f\"notes_lineIndex_{num}\"]),\n                        '_lineLayer': int(row[f\"notes_lineLayer_{num}\"]),\n                        '_type': num,\n                        '_cutDirection': int(row[f\"notes_cutDirection_{num}\"])}\n                notes_list.append(note)\n   #Remove potential notes that come too early in the song:\n    for i, x in enumerate(notes_list):\n        if notes_list[i]['_time'] >= 0 and notes_list[i]['_time'] <= 1.5:\n            del notes_list[i]\n        elif notes_list[i]['_time'] > beats[-1]:\n            del notes_list[i]\n\n    return notes_list\n\n#Segmented HMM Functions\n\ndef segmented_HMM_mapper(song_path, song_name, difficulty, k = 5, version = 2):\n    \"\"\"This function generates a custom map based on a HMM model that operates on song segments. First, Laplacian song segmentation is performed to identify similar portions of songs. Then, a HMM is used to generate a block sequence through the first of each of these identified song segments. If that segment is repeated later in the song, the block sequence will be repeated.\"\"\"\n    #Load song and get beat features\n    print(\"Loading Song...\")\n    bpm, beat_times, y, sr = beat_features(song_path)\n    beat_times = [x*bpm\/60 for x in beat_times]\n    print(\"Song loaded successfully!\")\n    #Write lists for note placement, event placement, and obstacle placement\n    print(\"Mapping with segmented Hidden Markov Model...\")\n    notes_list = segmented_HMM_notes_writer(y, sr, k, difficulty, version)\n    events_list = events_writer(beat_times)\n    obstacles_list = obstacles_writer(beat_times, difficulty)\n    print(\"Mapping done!\")\n    #Write and zip files\n    print(\"Writing files to disk...\")\n    write_info(song_name, bpm, difficulty)\n    write_level(difficulty, events_list, notes_list, obstacles_list)\n    print(\"Converting music file...\")\n    music_file_converter(song_path)\n    print(\"Zipping folder...\")\n    zip_folder_exporter(song_name, difficulty)\n    print(\"Finished! Look for zipped folder in your current path, unzip the folder, and place in the 'CustomMusic' folder in the Beat Saber directory\")\n\ndef laplacian_segmentation(y, sr, k = 5):\n    \"\"\"This function uses the Laplacian Segmentation method described in McFee and Ellis, 2014, and adapted from example code in the librosa documentation. It returns the segment boundaries (in frame number and time and segment ID's of isolated music file segments.\"\"\"\n    BINS_PER_OCTAVE = 12 * 3\n    N_OCTAVES = 7\n    C = librosa.amplitude_to_db(np.abs(librosa.cqt(y=y, sr=sr,\n                                        bins_per_octave=BINS_PER_OCTAVE,\n                                        n_bins=N_OCTAVES * BINS_PER_OCTAVE)),\n                                        ref=np.max)\n    tempo, beats = librosa.beat.beat_track(y=y, sr=sr, trim=False)\n    Csync = librosa.util.sync(C, beats, aggregate=np.median)\n\n    # For plotting purposes, we'll need the timing of the beats\n    # we fix_frames to include non-beat frames 0 and C.shape[1] (final frame)\n    beat_times = librosa.frames_to_time(librosa.util.fix_frames(beats,\n                                                                x_min=0,\n                                                                x_max=C.shape[1]),\n                                                                sr=sr)\n    \n    R = librosa.segment.recurrence_matrix(Csync, width=3, mode='affinity',\n                                          sym=True)\n    # Enhance diagonals with a median filter (Equation 2)\n    df = librosa.segment.timelag_filter(scipy.ndimage.median_filter)\n    Rf = df(R, size=(1, 7))\n    mfcc = librosa.feature.mfcc(y=y, sr=sr)\n    Msync = librosa.util.sync(mfcc, beats)\n    path_distance = np.sum(np.diff(Msync, axis=1)**2, axis=0)\n    sigma = np.median(path_distance)\n    path_sim = np.exp(-path_distance \/ sigma)\n    R_path = np.diag(path_sim, k=1) + np.diag(path_sim, k=-1)\n    deg_path = np.sum(R_path, axis=1)\n    deg_rec = np.sum(Rf, axis=1)\n    mu = deg_path.dot(deg_path + deg_rec) \/ np.sum((deg_path + deg_rec)**2)\n    A = mu * Rf + (1 - mu) * R_path\n    L = scipy.sparse.csgraph.laplacian(A, normed=True)\n    # and its spectral decomposition\n    evals, evecs = scipy.linalg.eigh(L)\n    # We can clean this up further with a median filter.\n    # This can help smooth over small discontinuities\n    evecs = scipy.ndimage.median_filter(evecs, size=(9, 1))\n    # cumulative normalization is needed for symmetric normalize laplacian eigenvectors\n    Cnorm = np.cumsum(evecs**2, axis=1)**0.5\n    # If we want k clusters, use the first k normalized eigenvectors.\n    # Fun exercise: see how the segmentation changes as you vary k\n    k = k\n    X = evecs[:, :k] \/ Cnorm[:, k-1:k]\n    KM = sklearn.cluster.KMeans(n_clusters=k)\n    seg_ids = KM.fit_predict(X)\n    bound_beats = 1 + np.flatnonzero(seg_ids[:-1] != seg_ids[1:])\n    # Count beat 0 as a boundary\n    bound_beats = librosa.util.fix_frames(bound_beats, x_min=0)\n    # Compute the segment label for each boundary\n    bound_segs = list(seg_ids[bound_beats])\n    # Convert beat indices to frames\n    bound_frames = beats[bound_beats]\n    # Make sure we cover to the end of the track\n    bound_frames = librosa.util.fix_frames(bound_frames,\n                                           x_min=None,\n                                           x_max=C.shape[1]-1)\n    bound_times = librosa.frames_to_time(bound_frames)\n    bound_times = [(x\/60)*tempo for x in bound_times]\n    beat_numbers = list(range(len(bound_frames)))\n    bound_beats = np.append(bound_beats, list(range(len(beats)))[-1])\n    segments = list(zip(zip(bound_times, bound_times[1:]), zip(bound_beats, bound_beats[1:]), bound_segs))\n    \n    return segments, beat_times, tempo\n\ndef segments_to_df(segments):\n    \"\"\"Helper function to translate a song semgmenation to a pandas DataFrame.\"\"\"\n    lengths = []\n    for seg in segments:\n        length = seg[1][1] - seg[1][0]\n        lengths.append(length)\n    df = pd.concat([pd.Series(lengths, name = 'length'), pd.Series([x[2] for x in segments], name = 'seg_no')], axis = 1)\n    return df\n\ndef segment_predictions(segment_df, HMM_model):\n    \"\"\"This function predicts a Markov chain walk for each segment of a segmented music file. It will repeat a walk for segments that it has already mapped previously (truncating or extending as necessary).\"\"\"\n   \n    preds = pd.DataFrame([])\n    completed_segments = {}\n    for index, row in segment_df.iterrows():\n        if row['seg_no'] not in completed_segments.keys():\n            if index == 0:\n                pred = HMM_model.walk()\n                while len(pred) < row['length']:\n                    pred = HMM_model.walk()\n                completed_segments.update({row['seg_no']: {'start':0, 'end': len(pred)}})\n                preds = pd.concat([preds, pd.Series(pred[0: row['length']])], axis = 0, ignore_index = True)\n                \n            else:\n                try:\n                    pred = HMM_model.walk(init_state = tuple(preds.iloc[-5:, 0]))\n                    while len(pred) < row['length']:\n                        pred = HMM_model.walk(init_state = tuple(preds.iloc[-5:, 0]))\n                    completed_segments.update({row['seg_no']: {'start': len(preds)+1, 'end': len(preds)+len(pred)}})\n                    preds = pd.concat([preds, pd.Series(pred[0: row['length']])], axis = 0, ignore_index = True)\n                except:\n                    pred = HMM_model.walk()\n                    while len(pred) < row['length']:\n                        pred = HMM_model.walk()\n                    completed_segments.update({row['seg_no']: {'start': len(preds)+1, 'end': len(preds)+len(pred)}})\n                    preds = pd.concat([preds, pd.Series(pred[0: row['length']])], axis = 0, ignore_index = True)\n\n        else:\n            if row['length'] <= (completed_segments[row['seg_no']]['end'] - completed_segments[row['seg_no']]['start']): \n                pred = preds.iloc[completed_segments[row['seg_no']]['start']: completed_segments[row['seg_no']]['start'] + row['length'], 0]\n                preds = pd.concat([preds, pred], axis = 0, ignore_index = True)\n            else:\n                try:\n                    extend = HMM_model.walk(init_state = tuple(preds.iloc[completed_segments[row['seg_no']]['end'] - 5 : completed_segments[row['seg_no']]['end'], 0]))\n                    pred = preds.iloc[completed_segments[row['seg_no']]['start']: completed_segments[row['seg_no']]['end'], 0]\n                    diff = row['length'] - len(pred)\n                    pred = pd.concat([pred, pd.Series(extend[0: diff+1])], axis = 0, ignore_index = True)\n                    completed_segments.update({row['seg_no']: {'start': len(preds)+1, 'end': len(preds)+len(pred)}})\n                    preds = pd.concat([preds, pred], axis = 0, ignore_index = True)\n                except:\n                    extend = HMM_model.walk()\n                    pred = preds.iloc[completed_segments[row['seg_no']]['start']: completed_segments[row['seg_no']]['end'], 0]\n                    diff = row['length'] - len(pred)\n                    pred = pd.concat([pred, pd.Series(extend[0: diff+1])], axis = 0, ignore_index = True)\n                    completed_segments.update({row['seg_no']: {'start': len(preds)+1, 'end': len(preds)+len(pred)}})\n                    preds = pd.concat([preds, pred], axis = 0, ignore_index = True)\n    \n    preds_list = list(preds.iloc[:, 0])\n    preds = walk_to_df(preds_list)\n    return preds\n\ndef segmented_HMM_notes_writer(y, sr, k, difficulty, version = 2):\n    \"\"\"This function writes the list of notes based on the segmented HMM model.\"\"\"\n    #Load model:\n    if version == 1:\n        with open(f\"..\/..\/models\/HMM_{difficulty}.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n    elif version == 2:\n        with open(f\"..\/..\/models\/HMM_{difficulty}_v2.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n            \n    segments, beat_times, tempo = laplacian_segmentation(y, sr, k)\n    segments_df = segments_to_df(segments)\n    preds = segment_predictions(segments_df, MC)\n    #Combine beat numbers with HMM walk steps\n    beats = [(x\/60)* tempo for x in beat_times]\n    df_preds = pd.concat([pd.DataFrame(beats, columns = ['_time']), preds], axis = 1, sort = True)\n    df_preds.dropna(axis = 0, inplace = True)\n    #Write notes dictionaries\n    notes_list = []\n    for index, row in df_preds.iterrows():\n        for x in list(filter(lambda y: y.startswith('notes_type'), df_preds.columns)):\n            if row[x] != '999':\n                num = x[-1]\n                note = {'_time': row['_time'],\n                        '_lineIndex': int(row[f\"notes_lineIndex_{num}\"]),\n                        '_lineLayer': int(row[f\"notes_lineLayer_{num}\"]),\n                        '_type': num,\n                        '_cutDirection': int(row[f\"notes_cutDirection_{num}\"])}\n                notes_list.append(note)\n    #Remove potential notes that come too early in the song:\n    for i, x in enumerate(notes_list):\n        if notes_list[i]['_time'] >= 0 and notes_list[i]['_time'] <= 1.5:\n            del notes_list[i]\n        elif notes_list[i]['_time'] > beats[-1]:\n            del notes_list[i]\n    \n    return notes_list\n\n#Rate Modulated Segmented HMM mapping functions\ndef rate_modulated_segmented_HMM_mapper(song_path, song_name, difficulty, version = 2, k = 5):\n    \"\"\"This function generates the files for a custom map using a rate modulated segmented HMM model.\"\"\"\n    #Load song and get beat features\n    print(\"Loading Song...\")\n    bpm, beat_times, y, sr = beat_features(song_path)\n    print(\"Song loaded successfully!\")\n    #Write lists for note placement, event placement, and obstacle placement\n    print(\"Mapping with rate modulated segmented Hidden Markov Model...\")\n    notes_list, modulated_beat_list = rate_modulated_segmented_HMM_notes_writer(y, sr, k, difficulty, version)\n    events_list = events_writer(modulated_beat_list)\n    obstacles_list = obstacles_writer(modulated_beat_list, difficulty)\n    print(\"Mapping done!\")\n    #Write and zip files\n    print(\"Writing files to disk...\")\n    write_info(song_name, bpm, difficulty)\n    write_level(difficulty, events_list, notes_list, obstacles_list)\n    print(\"Converting music file...\")\n    music_file_converter(song_path)\n    print(\"Zipping folder...\")\n    zip_folder_exporter(song_name, difficulty)\n    print(\"Finished! Look for zipped folder in your current path, unzip the folder, and place in the 'CustomMusic' folder in the Beat Saber directory\")\n\ndef choose_rate(db, difficulty):\n    \"\"\"\n    This function modulates the block placement rate by using the average amplitude (i.e., 'loudness') across beats to choose how many blocks per beat will be placed. Takes in the difficulty level and the amplitude and returns an integer in the set {0, 1, 2, 4, 8, 16}.\n    \n    If you are finding that your maps are too fast or too slow for you, you might want to play with the probabilities in this file.\n    \"\"\"\n    db = np.abs(db)\n    p = None\n    if difficulty.casefold() == 'easy'.casefold():\n        if db > 70:\n            p = [0.95, 0.05, 0, 0, 0, 0]\n        elif db <= 70 and db > 55:\n            p = [0.90, 0.10, 0, 0, 0, 0]\n        elif db <= 55 and db > 45:\n            p = [0.80, 0.2, 0, 0, 0, 0]\n        elif db <= 45 and db > 35:\n            p = [0.4, 0.5, 0.1, 0, 0, 0]\n        else:\n            p = [0.3, 0.6, 0.1, 0, 0, 0]\n    elif difficulty.casefold() == 'normal'.casefold():\n        if db > 70:\n            p = [0.95, 0.05, 0, 0, 0, 0]\n        elif db <= 70 and db > 55:\n            p = [0.5, 0.5, 0, 0, 0, 0]\n        elif db <= 55 and db > 45:\n            p = [0.3, 0.7, 0, 0, 0, 0]\n        elif db <= 45 and db > 35:\n            p = [0.2, 0.7, 0.1, 0, 0, 0]\n        else:\n            p = [0.05, 0.7, 0.25, 0, 0, 0]\n    elif difficulty.casefold() == 'hard'.casefold():\n        if db > 70:\n            p = [0.95, 0.05, 0, 0, 0, 0]\n        elif db <= 70 and db > 55:\n            p = [0.5, 0.5, 0, 0, 0, 0]\n        elif db <= 55 and db > 45:\n            p = [0.2, 0.6, 0.2, 0, 0, 0]\n        elif db <= 45 and db > 35:\n            p = [0.1, 0.5, 0.4, 0, 0, 0]\n        else:\n            p = [0.05, 0.35, 0.6, 0, 0, 0]\n    elif difficulty.casefold() == 'expert'.casefold():\n        if db > 70:\n            p = [0.8, 0.2, 0, 0, 0, 0]\n        elif db <= 70 and db > 55:\n            p = [0.2, 0.7, 0.1, 0, 0, 0]\n        elif db <= 55 and db > 50:\n            p = [0.1, 0.4, 0.3, 0.2, 0, 0]\n        elif db <= 50 and db > 45:\n            p = [0, 0.05, 0.6, 0.35, 0, 0]\n        else:\n            p = [0, 0, 0.35, 0.65, 0, 0]\n    elif difficulty.casefold() == 'expertPlus'.casefold():\n        if db > 70:\n            p = [0, 0.5, 0.4, 0.1, 0, 0]\n        elif db <= 70 and db > 55:\n            p = [0, 0.3, 0.6, 0.1, 0, 0]\n        elif db <= 55 and db > 50:\n            p = [0, 0.1, 0.6, 0.3, 0, 0]\n        elif db <= 50 and db > 45:\n            p = [0, 0.05, 0.1, 0.6, 0.25, 0]\n        else:\n            p = [0, 0, 0, 0.5, 0.3, 0.2]\n    return np.random.choice([0, 1, 2, 4, 8, 16], p = p)\n\ndef amplitude_rate_modulation(y, sr, difficulty):\n    \"\"\"This function uses the average amplitude (i.e., 'loudness') of a beat and the difficulty level to determine \n    how many blocks will be placed within the beat. Returns a list of beat numbers.\"\"\"\n    #Make amplitude matrix\n    D = np.abs(librosa.stft(y))\n    db = librosa.amplitude_to_db(D, ref=np.max)\n    #Get beat frames and sync with amplitudes\n    tempo, beat_frames = librosa.beat.beat_track(y, sr, trim = False)\n    beat_db = pd.DataFrame(librosa.util.sync(db, beat_frames, aggregate = np.mean))\n    #Mean amplitude per beat\n    avg_beat_db = beat_db.mean()\n    #Choose rates and smooth rate transitions\n    rates = [0]\n    counter = 1\n    while counter < len(avg_beat_db)-1:\n        rate = choose_rate(np.mean([avg_beat_db.iloc[counter-1], avg_beat_db.iloc[counter], avg_beat_db.iloc[counter+1]]), difficulty)\n        diff = np.abs(rate - rates[-1])\n        if difficulty.casefold() == 'expert'.casefold():\n            maxdiff = 4\n        elif difficulty.casefold() == 'expertPlus'.casefold():\n            maxdiff = 8\n        else:\n            maxdiff = 2\n        while diff > maxdiff:\n            rate = choose_rate(np.mean([avg_beat_db.iloc[counter-1], avg_beat_db.iloc[counter], avg_beat_db.iloc[counter+1]]), difficulty)\n            diff = rates[-1] - rate\n        if rate == 4 and rates[-1] == 4: #and rates[-2] == 4:\n            rate = np.random.choice([0, 1, 2])\n        rates.append(rate)\n        counter +=1\n    #Make list of beat numbers based on rates\n    beat_num_list = []\n    for ind, val in enumerate(rates):\n        if val == 0:\n            continue\n        elif val == 1:\n            beat_num_list.append(ind)\n        else:\n            num_list = [ind, ind+1]\n            for x in range(1, val):\n                num_list.append(ind+(x\/val))\n            for y in num_list:\n                beat_num_list.append(y)\n    beat_num_list = list(set(beat_num_list))\n    beat_num_list.sort()\n    return beat_num_list\n\ndef segments_to_df_rate_modulated(segments, modulated_beat_list):\n    \"\"\"This function returns a DataFrame of the number of blocks needed for each song segment.\"\"\"\n    expanded_beat_list = []\n    for x in segments:\n        for y in modulated_beat_list:\n            if y > x[1][0] and y <= x[1][1]:\n                expanded_beat_list.append({'_time': y, 'segment': x[2]})\n    \n    df = pd.DataFrame([], columns = ['length', 'seg_no'])\n    counter = 0\n    first = None\n    last = None\n    while counter < len(expanded_beat_list):\n        if counter == 0:\n            first = counter\n            counter += 1\n        elif expanded_beat_list[counter]['segment'] != expanded_beat_list[counter-1]['segment']:\n            first = counter\n            counter += 1\n        elif expanded_beat_list[counter] == expanded_beat_list[-1]:\n            length = len(expanded_beat_list[first: -1])\n            df = df.append(pd.DataFrame({'length': length, 'seg_no': expanded_beat_list[-1]['segment']}, index = [0]))\n            break\n        elif expanded_beat_list[counter]['segment'] == expanded_beat_list[counter+1]['segment']:\n            counter += 1  \n        elif expanded_beat_list[counter]['segment'] != expanded_beat_list[counter+1]['segment']:\n            last = counter\n            length = len(expanded_beat_list[first: last+1])\n            df = df.append(pd.DataFrame({'length': length, 'seg_no': expanded_beat_list[counter]['segment']}, index = [0]))\n            counter += 1\n    \n    return df\n\ndef rate_modulated_segmented_HMM_notes_writer(y, sr, k, difficulty, version):\n    \"\"\"Function to write the notes to a list after predicting with the rate modulated segmented HMM model.\"\"\"\n    #Load model:\n    if version == 1:\n        with open(f\"..\/..\/models\/HMM_{difficulty}.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n    elif version == 2:\n        with open(f\"..\/..\/models\/HMM_{difficulty}_v2.pkl\", 'rb') as m:\n            MC = pickle.load(m)\n    \n    segments, beat_times, bpm = laplacian_segmentation(y, sr, k)\n    modulated_beat_list = amplitude_rate_modulation(y, sr, difficulty)\n    segments_df = segments_to_df_rate_modulated(segments, modulated_beat_list)\n    preds = segment_predictions(segments_df, MC)\n    #Combine beat numbers with HMM walk steps\n    beat_times = [(x\/60)*bpm for x in beat_times]\n    beat_count = list(range(len(beat_times)))\n    beats = pd.concat([pd.Series(beat_times, name = '_time'), pd.Series(beat_count, name = 'beat_count')], axis = 1)\n    for index, value in beats.iterrows():\n        if value['beat_count'] not in modulated_beat_list:\n            beats.drop(index = index, inplace=True)\n    merged_beats = pd.merge(left = beats, right = pd.Series(modulated_beat_list, name = 'beat_count'), how='outer', on='beat_count', sort = True)\n    merged_beats.interpolate(inplace=True)\n    merged_beats.drop(columns = 'beat_count', inplace = True)\n    \n    df_preds = pd.concat([merged_beats, preds], axis = 1, sort = True)\n    df_preds.dropna(axis = 0, inplace = True)\n    #Write notes dictionaries\n    notes_list = []\n    for index, row in df_preds.iterrows():\n        for x in list(filter(lambda y: y.startswith('notes_type'), df_preds.columns)):\n            if row[x] != '999':\n                num = x[-1]\n                note = {'_time': row['_time'],\n                        '_lineIndex': int(row[f\"notes_lineIndex_{num}\"]),\n                        '_lineLayer': int(row[f\"notes_lineLayer_{num}\"]),\n                        '_type': num,\n                        '_cutDirection': int(row[f\"notes_cutDirection_{num}\"])}\n                notes_list.append(note)\n    #Remove potential notes that come too early in the song:\n    for i, x in enumerate(notes_list):\n        if notes_list[i]['_time'] >= 0 and notes_list[i]['_time'] <= 1.5:\n            del notes_list[i]\n        elif notes_list[i]['_time'] > beat_times[-1]:\n            del notes_list[i]\n\n    return notes_list, modulated_beat_list\n\nif __name__ == '__main__':\n    parser = argparse.ArgumentParser()\n    parser.add_argument('song_path', metavar='path', type=str, help='File Path to song file')\n    parser.add_argument('song_name', type=str, help='Name of song to be displayed in Beat Saber')\n    parser.add_argument('difficulty', type=str, help=\"Desired difficulty level: 'easy', 'normal', 'hard', 'expert', or 'expertPlus'\")\n    parser.add_argument('model', type=str, help=\"Desired model for mapping: 'random', 'HMM', 'segmented_HMM', 'rate_modulated_segmented_HMM'\")\n    parser.add_argument('-k', type=int, help=\"Number of expected segments for segmented model. Default 5\", default=5, required=False)\n    parser.add_argument('--version', type=int, help=\"Version of HMM model to use: 1 (90% rating or greater) or 2 (70% rating or greater)\", default=2, required=False)\n\n    args = parser.parse_args()\n    \n    beat_map_synthesizer(args.song_path, args.song_name, args.difficulty, args.model, args.k, args.version)\n    "}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_415","text":"#!\/usr\/bin\/python3\n\nimport numpy as np\nimport pandas as pd\n\nimport random\n\nfrom instance import Instance\nfrom solver import Solver\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import colorConverter\nfrom matplotlib.patches import Patch\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nimport matplotlib.patches as mpatches\n\nfrom matplotlib import cm\nfrom matplotlib import colors as mcolors\n\n\nimport visualizer\nimport histogram\n\nimport math\n\nfrom numpy.random import default_rng\n\nfrom scipy.stats import t\nfrom scipy.stats import levy_stable\nfrom scipy.stats import cauchy\n\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.decomposition import PCA\nimport umap\n\nimport pylfit # perform a comparision with PRIDE implementation of LFIT\n\n#---------------------------------------------------------------------\ndef singlecell_matrix_experiment():\n    \n    random.seed(42)\n    np.random.seed(42)\n    \n    ####################################################################\n    ###### read cell types\n    ####################################################################\n    file_name = '..\/dataset\/IMAGINE\/cell_types.csv'\n    df_cell_types = pd.read_csv(file_name, index_col=0)\n    df_cell_types.rename(columns={'cellType_final': 'Label'}, inplace=True)\n    print(df_cell_types.head())\n    \n    ####################################################################\n    ###### read macro cell types\n    ####################################################################\n    file_name = '..\/dataset\/IMAGINE\/cell_types_macro.csv'\n    df_cell_types_macro = pd.read_csv(file_name, index_col=0)\n    df_cell_types_macro.rename(columns={'cellType_macro': 'Label'}, inplace=True)\n    print(df_cell_types_macro.head())\n    \n    \n    ####################################################################\n    ###### read the normalized dataset\n    ####################################################################\n    file_name = '..\/..\/..\/Learning\/IMAGINE_dataset\/dataset\/ctls_normalised_counts.csv'\n    \n    df_normalised = pd.read_csv(file_name, index_col = 0).T\n    print(df_normalised.head())\n    \n    ####################################################################\n    ###### read the discretized dataset\n    ####################################################################\n    \n    file_name = '..\/dataset\/IMAGINE\/IMAGINE_normalised_discrete_adaptive.csv'\n    \n    # Load the discrete dataset\n    df = pd.read_csv(file_name, index_col=0)\n        \n    # select only the T cells\n    #df = df.loc[df_cell_types_macro.loc[df_cell_types_macro['Label']=='T'].index]\n    \n    # remove axis name (name of the previously first column)\n    df.rename_axis('Barcode', axis=0, inplace=True)\n    \n    # select a sub dataset\n    # df = df.loc[cd4_negatives+cd4_positives]\n    \n    print(df.head())\n    \n    \n    \n    # classification of CD8+\n    inst = Instance.create_cluster_instance(df, df_cell_types, 'NK')\n    #inst = Instance.create_cluster_instance(df, df_cell_types, 'CD14')\n    instance_name = 'NK'\n    \n    # inst = Instance.create_random_instance(df, 0.3)\n    \n    # extract positive\/negative solutions for solution visualisation\n    positive_cells = inst._pos_samples\n    negative_cells = inst._neg_samples\n    \n    print('Original instance:')\n    # print('n atoms: ', inst.n_atoms())\n    print('n positive samples: ', inst.n_positives())\n    print('n negative samples: ', inst.n_negatives())\n    \n    solver = Solver(inst)\n    \n    \n    ############################################\n    ### computation of supported front\n    ############################################\n    \n    body_length = 20\n    \n    # create line equations from these points\n    x1, y1 = 0.,0.\n    x2, y2 = (inst.n_positives(), inst.n_negatives())\n    a = 1.\n    b = (x1-x2)\/(y2-y1)\n    c = -a*x1 - b*y1\n    \n    max_dist = a*0+b*y2+c\n    \n    # compute a line at distance 0.3\n    p031 = [0,0]\n    p031[1] = (0.3*max_dist-c)\/b\n    \n    p032 = [0,y2]\n    p032[0] = (0.3*max_dist-c-b*p032[1])\/a\n    \n    # compute the list of distances to the diagonal\n    atom_distance = [-1 for ind_atom in range(inst.n_atoms())]\n    for ind_atom in range(inst.n_atoms()):\n        score = inst.atom_score[ind_atom]\n        atom_distance[ind_atom] = (a*score[0] + b*score[1] + c)\/max_dist\n    sorted_atoms = [ind for ind in range(inst.n_atoms())]\n    sorted_atoms.sort(key=lambda ind:atom_distance[ind], reverse=True)\n    \n    \n    stop_ind = 0\n    for elt in sorted_atoms:\n        if atom_distance[elt] < 0.3:\n            break\n        else:\n            stop_ind += 1\n    \n    sorted_atoms = sorted_atoms[:stop_ind]\n    \n    #selected_atoms, scores = solver.select_k_best_atoms(50)\n    selected_atoms, scores = solver.select_best_atoms_threshold(0.3)\n    \n    # print([(inst.get_atom(ind), atom_distance[ind]) for ind in sorted_atoms])\n    \n    print('n atoms selected: ', len(selected_atoms))\n    #for elt in [(inst.get_atom(ind), atom_distance[ind]) for ind in selected_atoms]:\n    #    print(elt)\n    \n    body_length = 20\n    body = selected_atoms[:body_length]\n    \n    # plot the body\n    print([inst.get_atom(ind) for ind in body])\n    \n    # create an histogram to visualize rule error over samples\n    histo = histogram.Histogram(inst, body)\n    \n    \n    # plot the histogram\n    fig, ax = plt.subplots()\n    ax.set_title('Histograms for ' + instance_name + ' classification')\n    visualizer.plot_histograms(ax, histo, True)\n    \n    nPos = inst.n_positives()\n    nNeg = inst.n_negatives()\n    \n    \n    # plot each atom score\n    fig,ax = plt.subplots()\n    \n    ax.set_xlim((0,nPos))\n    ax.set_ylim((0,nNeg))\n    \n    #ax.set_aspect('equal')\n    \n    # ax.set_title('Atoms score')\n    # ax.set_xlabel('Positive score')\n    # ax.set_ylabel('Negative score')\n    \n    ax.set_title('Erreurs des atomes logiques (classification de NK)')\n    ax.set_xlabel('Erreur positive')\n    ax.set_ylabel('Erreur négative')\n    \n    \n    \n    # colors = ['royalblue' for _ in range(len(inst.atom_score))]\n    ax.scatter([elt[0] for elt in inst.atom_score], [elt[1] for elt in inst.atom_score], marker='x')\n    \n    # y \/ x\n    # ax.plot([0, inst.n_positives()], [0, inst.n_negatives()], color='red')\n    \n    # 0.3 threshold\n    # ax.plot([p031[0], p032[0]], [p031[1], p032[1]], color='lightseagreen')\n    \n    # compute atom distance to the diagonal vs its lateral position on the diagonal\n    nPos = inst.n_positives()\n    nNeg = inst.n_negatives()\n    \n    a_diag = nNeg\n    b_diag = -nPos\n    c_diag = 0\n    \n    \n    # diagonal\n    ax.plot([0, nPos], [0, -a_diag*nPos\/b_diag], color='red')\n    \n    ax.legend(['score = 0.0'], loc='lower right')\n    \n    # orthogonal projection\n    x_mid = nPos\/2\n    y_mid = nNeg\/2\n    \n    # compute the relative distances do diagonal and normal for each atoms\n    atom_relative_distances = [(0,0) for _ in range(inst.n_atoms())]\n    \n    max_dist = -a_diag*0 -b_diag*nNeg\n    \n    k = math.sqrt(a_diag**2 + b_diag**2)\n    for atom_index in range(inst.n_atoms()):\n        pos = inst.atom_score[atom_index]\n        c = -a_diag*pos[0] - b_diag*pos[1]\n        dist_diag = c\/max_dist\n        if c > 0:\n            x1 = 0\n            y1 = (-a_diag*x1-c)\/b_diag\n            y2 = nNeg\n            x2 = (-b_diag*y2-c)\/a_diag\n        else:\n            x2 = nPos\n            y2 = (-a_diag*x2-c)\/b_diag\n            y1 = 0\n            x1 = (-b_diag*y1-c)\/a_diag\n            \n        dist_left = math.sqrt((pos[0]-x1)**2 + (pos[1]-y1)**2)\n        length = math.sqrt((x2-x1)**2 + (y2-y1)**2)\n        lateral_dist = dist_left\/length\n    \n        atom_relative_distances[atom_index] = (dist_diag, lateral_dist)\n    \n    colors = [max(inst.atom_score[ind_atom][0],inst.atom_score[ind_atom][1])\/(inst.atom_score[ind_atom][0]+inst.atom_score[ind_atom][1]) for ind_atom in range(inst.n_atoms())]\n    \n    fig, ax = plt.subplots()\n    ax.scatter([elt[0] for elt in atom_relative_distances], [elt[1] for elt in atom_relative_distances], marker='x', c=colors)\n    ax.set_xlabel('distance to diagonal')\n    ax.set_ylabel('lateral position')\n    \n    # add histograms\n    \n    # verif: atom with colors\n    # plot each atom score\n    fig,ax = plt.subplots()\n    # ax.set_aspect('equal')\n    ax.set_xlim((0,nPos))\n    ax.set_ylim((0,nNeg))\n    ax.set_title('Atoms score')\n    ax.set_xlabel('Positive score')\n    ax.set_ylabel('Negative score')\n\n    \n    ax.scatter([elt[0] for elt in inst.atom_score], [elt[1] for elt in inst.atom_score], marker='x', c=[elt[1] for elt in atom_relative_distances])\n    \n    ax.plot([0, nPos], [0, nNeg], color='red')\n    \n    selected_atoms = [ind for ind in range(inst.n_atoms())]\n    selected_atoms.sort(key=lambda ind: atom_relative_distances[ind][0], reverse=False)\n    \n    fig, axs = plt.subplots(3)\n    axs[0].hist([elt[0] for elt in atom_relative_distances], edgecolor='k', bins=100)\n    axs[1].hist([elt[1] for elt in atom_relative_distances], edgecolor='k', bins=100)\n    axs[2].hist([max(inst.atom_score[ind_atom][0],inst.atom_score[ind_atom][1])\/(inst.atom_score[ind_atom][0]+inst.atom_score[ind_atom][1]) for atom_index in range(inst.n_atoms())], edgecolor='k', bins=100)\n    \n    plt.show()\n\n\n\n\n###############################################################\ndef artificial_data_experiment():\n    \n    nPos = 1000\n    nNeg = 1000\n    \n    nVar = 10000\n    nAtoms = nVar*2\n    \n    # random_seed = 46\n    random_seed = 52 # worst dataset\n    \n    random.seed(random_seed)\n    np.random.seed(random_seed)\n    \n    # sampling over the normal distribution\n    \n    \n    rng = default_rng(random_seed)\n    \n    # mu, sigma = 0, 0.1 # mean and standard deviation\n    # sample_normal = rng.normal(mu, sigma, nAtoms)\n    \n    sample_uniform = rng.uniform(0, 1, nVar*2)\n    \n    df = 10\n    sample_score = t.rvs(df, size=nVar)\n    # sample_student = [elt for elt in sample_student if elt >= 0]\n\n    # https:\/\/en.wikipedia.org\/wiki\/Stable_distribution\n    # https:\/\/docs.scipy.org\/doc\/scipy\/reference\/generated\/scipy.stats.levy_stable.html\n    # stable distribution\n    # alpha, beta = 1.995, 0.\n    # sample_score = levy_stable.rvs(alpha, beta, size=nVar)\n    \n    # x0 = 0\n    # gamma = 0.5\n    # global sample_score\n    # sample_score = cauchy.rvs(loc=x0, scale=gamma, size=nVar)\n    \n    # normal is normalized\n    max_normal = np.max(sample_score)\n    min_normal = np.min(sample_score)\n    \n    print(min_normal, max_normal)\n    \n    max_abs = max(max_normal, -min_normal) + 0.2\n    for ind in range(len(sample_score)):\n        sample_score[ind] = sample_score[ind]\/max_abs\n        sample_score[ind] *= 0.70\n    # threshold = 50\n    # for ind in range(len(sample_score)):\n    #     sample_score[ind] = sample_score[ind]\/threshold\n    \n    fig, axs = plt.subplots(2)\n    axs[0].hist(sample_score, edgecolor='k', bins=100)\n    axs[1].hist(sample_uniform, edgecolor='k', bins=100)\n\n    \n    #print(sample_normal)\n\n    # fig,ax = plt.subplots()\n    # ax.scatter(sample_normal, sample_uniform, marker='x')\n    # ax.set_xlim([-1, 1])\n    \n    a = nNeg\n    b = -nPos\n    \n    atoms = [(ind_var, 0) for ind_var in range(nVar)]\n    atoms += [(ind_var, 1) for ind_var in range(nVar)]\n    \n    atom_scores = []\n    \n    for ind_atom in range(len(sample_score)):\n        c = sample_score[ind_atom]*nPos*nNeg\n        if c < 0:\n            p1 = (-c\/nPos, 0)\n            p2 = (nPos, nPos+c\/nNeg)\n        else:\n            p1 = (0, c\/nPos)\n            p2 = (nNeg-c\/nPos, nNeg)\n        v = (p2[0]-p1[0], p2[1]-p1[1])\n        lateral = sample_uniform[ind_atom]\n        p_star = (p1[0]+v[0]*lateral, p1[1]+v[1]*lateral) \n        p_star = (math.floor(p_star[0]), math.floor(p_star[1]))\n        atom_scores.append(p_star)\n        \n        \n    # generating positiv and negative examples\n    global positives\n    global negatives\n    positives = [ [0 for _ in range(nVar)] for _ in range(nPos) ]\n    negatives = [ [0 for _ in range(nVar)] for _ in range(nNeg) ]\n\n    for ind_atom in range(nVar):\n        score = atom_scores[ind_atom]\n        \n        # positive examples\n        pos_indexes = [ind for ind in range(nPos)]\n        np.random.shuffle(pos_indexes)\n        for ind_pos in range(nPos):\n            if ind_pos < score[0]:\n                positives[pos_indexes[ind_pos]][ind_atom] = 1\n            else:\n                positives[pos_indexes[ind_pos]][ind_atom] = 0\n        \n        # negative examples\n        neg_indexes = [ind for ind in range(nNeg)]\n        np.random.shuffle(neg_indexes)\n        for ind_neg in range(nNeg):\n            if ind_neg < score[1]:\n                negatives[neg_indexes[ind_neg]][ind_atom] = 1\n            else:\n                negatives[neg_indexes[ind_neg]][ind_atom] = 0\n        \n        \n    atom_scores_sym = []\n    for score in atom_scores:\n        atom_scores_sym.append( (nPos-score[0], nNeg-score[1]) )\n    atom_scores += atom_scores_sym\n\n    fig,ax = plt.subplots()\n    ax.scatter([elt[0] for elt in atom_scores], [elt[1] for elt in atom_scores], marker='x')\n    ax.plot([0, nPos], [0, nNeg], color='red')    \n    ax.set_xlim([0, nPos])\n    ax.set_ylim([0, nNeg])\n    \n    ind_atoms_sorted = [ind for ind in range(len(atom_scores))]\n    score = [-nNeg*error[0] +nPos*error[1] for error in atom_scores]\n    ind_atoms_sorted.sort(key = lambda ind: score[ind], reverse=True)\n    fig, ax = plt.subplots()\n    ax.scatter([atom_scores[ind][0] for ind in ind_atoms_sorted], [atom_scores[ind][1] for ind in ind_atoms_sorted], c=[score[ind] for ind in ind_atoms_sorted], marker='x')\n    ax.set_xlim([0, nPos])\n    ax.set_ylim([0, nNeg])\n    ax.plot([0, nPos], [0, nNeg], color='red')\n    \n    selected_atoms = ind_atoms_sorted[:20]\n    \n    pos_histogram = [0 for _ in range(len(selected_atoms)+1)]\n    neg_histogram = [0 for _ in range(len(selected_atoms)+1)]\n    \n    for pos in positives:\n        score = 0\n        for ind_atom in selected_atoms:\n            atom = atoms[ind_atom]\n            if pos[atom[0]] != atom[1]:\n                score += 1\n        pos_histogram[score] += 1\n        \n    for neg in negatives:\n        score = 0\n        for ind_atom in selected_atoms:\n            atom = atoms[ind_atom]\n            if neg[atom[0]] != atom[1]:\n                score += 1\n        neg_histogram[score] += 1\n        \n    \n        \n    for score in range(len(pos_histogram)):\n        pos_histogram[score] \/= float(nPos)\n        \n    for score in range(len(neg_histogram)):\n        neg_histogram[score] \/= float(nNeg)\n    \n    print('positive histogram: ')\n    print(pos_histogram)\n    \n    print('negative histogram:')\n    print(neg_histogram)\n    \n    height = 10\n    output = ''\n    \n    for y in range(height, 0, -1):\n        for score in pos_histogram:\n            if score*height*2 >= y:\n                output += '*'\n            else:\n                output += ' '\n        output += '\\n'\n    for score in pos_histogram:\n        output += '.'\n    print(output)\n    \n    output = ''\n    for y in range(height, 0, -1):\n        for score in neg_histogram:\n            if score*height*2 >= y:\n                output += '*'\n            else:\n                output += ' '\n        output += '\\n'\n    for score in neg_histogram:\n        output += '.'\n    print(output)\n    \n    \n    # create a csv file with the matrix (ordered positive and negative examples)\n    matrix = positives + negatives\n    variables = ['v_'+str(ind) for ind in range(nVar)]\n    examples = ['s_' + str(ind) for ind in range(nPos+nNeg)]\n    \n    # exportation into a dataframe\n    # global dataframe\n    # dataframe = pd.DataFrame(matrix, columns = variables, index= examples)\n    # dataframe.to_csv('..\/dataset\/artificial_matrix_worst.csv')\n    \n    return\n\n\n\n\n#------------------------------------------------------------------------------\ndef compute_pride_bodies(instance):\n    \n    # computation of the bodies of all rules returned from pride algorithm on the instance\n    \n    variable = -1\n    value = -1 # not important, just for rules'head\n\n    nb_features = instance.dataset.shape[0] # nb columns in the dataframe\n\n    positives = instance.dataset.loc[instance._pos_samples].values.tolist()\n    negatives = instance.dataset.loc[instance._neg_samples].values.tolist()\n\n    verbose = 0\n    output = pylfit.algorithms.pride.PRIDE.fit_var_val(variable, value, nb_features, positives, negatives, verbose)\n    \n    # compute the bodies of PRIDE rules: indexes of the selected atoms from the instance of NK cells\n    pride_bodies = []\n    for rule in output:\n\n        pride_body = []\n        \n        for var_index in rule._body_variables:\n            gene = instance.dataset.columns[var_index]\n            value = rule._body_values[var_index]\n            atom_index = instance.get_atom_index((gene, value))\n            pride_body.append(atom_index)\n\n        pride_bodies.append(pride_body)\n    \n    return pride_bodies\n\n\n#------------------------------------------------------------------------------\ndef LOLH_artificial_data():\n    \n    \n    \n    random.seed(42)\n    np.random.seed(42)\n    \n\n    \n\n    \n    \n    ####################################################################\n    ###### read the discretized dataset\n    ####################################################################\n    \n    file_name = '..\/dataset\/artificial_matrix.csv'\n    # file_name = '..\/dataset\/artificial_matrix_worst.csv'\n    \n    # Load the discrete dataset\n    df = pd.read_csv(file_name, index_col=0)\n\n    \n    print(df.head())\n    \n    \n    # compute a UMAP from the data\n    X = df.values.copy()\n    # standard scaling before PCA\n    X=StandardScaler().fit_transform(X)\n    # PCA with ten principal components\n    X_pca = PCA(n_components=10).fit_transform(X)\n\n    reducer = umap.UMAP(min_dist=0.3,n_neighbors=50,spread=1.0)\n    embedding = reducer.fit_transform(X_pca)\n    \n    fig, axs = plt.subplots(1,2)\n    \n    col = ['forestgreen' for _ in range(int(df.shape[0]\/2))] + ['darkred' for _ in range(int(df.shape[0]\/2))]\n    \n    axs[0].scatter(embedding[:, 0], embedding[:, 1], s=2, c=col)\n    axs[0].set_aspect('equal', 'datalim')\n    axs[0].set_title('projection UMAP')\n    axs[0].set_xlabel('UMAP 1')\n    axs[0].set_ylabel('UMAP 2')\n    axs[0].legend(handles=[mpatches.Patch(color='forestgreen', label='exemples positifs'), mpatches.Patch(color='darkred', label='exemples négatifs')], loc='lower right')\n    \n    # PCA projection\n    X = df.values.copy()\n    X=StandardScaler().fit_transform(X)\n    X_pca = PCA(n_components=2).fit_transform(X)\n    axs[1].scatter(X_pca[:,0], X_pca[:,1], c=col, s=2)\n    axs[1].set_title('projection PCA')\n    axs[1].set_xlabel('PCA 1')\n    axs[1].set_ylabel('PCA 2')\n    axs[1].legend(handles=[mpatches.Patch(color='forestgreen', label='exemples positifs'), mpatches.Patch(color='darkred', label='exemples négatifs')])\n\n    \n    # classification from positive vs negative\n    pos_samples = ['s_'+str(ind) for ind in range(0, int(df.shape[0]\/2.))]\n    neg_samples = ['s_'+str(ind) for ind in range(int(df.shape[0]\/2.)+1, df.shape[0])]\n\n    instance_name = 'artificial'\n    \n    inst = Instance.create_instance_explicit(df, pos_samples, neg_samples)\n    \n    # extract positive\/negative solutions for solution visualisation\n    positive_cells = inst._pos_samples\n    negative_cells = inst._neg_samples\n    \n    print('Original instance:')\n    # print('n atoms: ', inst.n_atoms())\n    print('n positive samples: ', inst.n_positives())\n    print('n negative samples: ', inst.n_negatives())\n    \n    solver = Solver(inst)\n    \n    \n    ############################################\n    ### computation of supported front\n    ############################################\n    \n    body_length = 20\n    \n    # create line equations from these points\n    x1, y1 = 0.,0.\n    x2, y2 = (inst.n_positives(), inst.n_negatives())\n    a = 1.\n    b = (x1-x2)\/(y2-y1)\n    c = -a*x1 - b*y1\n    \n    max_dist = a*0+b*y2+c\n    \n    # compute a line at distance 0.3\n    p031 = [0,0]\n    p031[1] = (0.3*max_dist-c)\/b\n    \n    p032 = [0,y2]\n    p032[0] = (0.3*max_dist-c-b*p032[1])\/a\n    \n    # compute the list of distances to the diagonal\n    atom_distance = [-1 for ind_atom in range(inst.n_atoms())]\n    for ind_atom in range(inst.n_atoms()):\n        score = inst.atom_score[ind_atom]\n        atom_distance[ind_atom] = (a*score[0] + b*score[1] + c)\/max_dist\n    sorted_atoms = [ind for ind in range(inst.n_atoms())]\n    sorted_atoms.sort(key=lambda ind:atom_distance[ind], reverse=True)\n    \n    \n    stop_ind = 0\n    for elt in sorted_atoms:\n        if atom_distance[elt] < 0.3:\n            break\n        else:\n            stop_ind += 1\n    \n    sorted_atoms = sorted_atoms[:stop_ind]\n    \n    # selection score = 0.75\n    selection_score = 0.75\n    \n    selected_atoms, scores = solver.select_best_atoms_threshold(selection_score)\n\n    \n    print('n atoms selected: ', len(selected_atoms))\n\n    \n    body = selected_atoms\n    \n    # plot the body\n    print([inst.get_atom(ind) for ind in body])\n    \n    nPos = inst.n_positives()\n    nNeg = inst.n_negatives()\n    \n    ########################################################\n    # compute pride rules\n    pride_bodies = compute_pride_bodies(inst)\n    pride_atoms = list(np.unique([ind_atom for pride_body in pride_bodies for ind_atom in pride_body]))\n    print('n rules pride: ', len(pride_bodies))\n    print('rule 0: ', pride_bodies[0])\n    \n    # inspection des indices des atomes des règles pride\n    \n    ###\n    \n    # number of atoms for pride rules\n    # n_atoms = [len(elt) for elt in pride_bodies]\n    # print('number of atoms pride: ', np.bincount(n_atoms))\n    # print(sorted(n_atoms))\n    \n    # plot each atom score\n    fig,ax = plt.subplots()\n    \n    ax.set_xlim((0,nPos))\n    ax.set_ylim((0,nNeg))\n    \n    #ax.set_aspect('equal')\n    \n    ax.set_title('Atoms score')\n    ax.set_xlabel('erreur positive')\n    ax.set_ylabel('erreur négative')\n    \n    \n    other_atoms = [ind_atom for ind_atom in range(inst.n_atoms()) if not ind_atom in body and not ind_atom in pride_atoms]\n    \n    # plot LOLH atoms\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in body], [inst.atom_score[ind_atom][1] for ind_atom in body], marker='o', facecolor='darkorange', edgecolor='black', linewidth=0.5, zorder=2, label='atomes LOLH')\n    \n    # plot pride atoms\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in pride_atoms], [inst.atom_score[ind_atom][1] for ind_atom in pride_atoms], marker='s', facecolor='dodgerblue', edgecolor='black', linewidth=0.5, zorder=2, label='atomes PRIDE')\n    \n    # other (not used) atoms\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in range(inst.n_atoms())], [inst.atom_score[ind_atom][1] for ind_atom in range(inst.n_atoms())], alpha=0.5, marker='x', zorder=0, label='autres atomes')\n    \n    # score = 0.0\n    ax.plot([0, nPos], [0, nNeg], '--', color='black', label='score = 0.0', lw=1.5)\n\n    \n    # compute the line corresponding to the selection score\n    nPos = inst.n_positives()\n    nNeg = inst.n_negatives()\n    \n    # line for score = 0.75\n    A = (0,selection_score*nNeg)\n    B = (nPos*(1.-selection_score), nNeg)\n    ax.plot([A[0], B[0]], [A[1], B[1]], '--', color='forestgreen', label='score = 0.75', lw=1.5)\n    \n    ax.legend(loc='lower right')\n    \n    # compute a global score for each rule\n    pride_rule_scores = []\n    for pride_body in pride_bodies:\n        score = (0, 0)\n        for atom_index in pride_body:\n            atom_score = inst.atom_score[atom_index]\n            score = (score[0] + atom_score[0]\/nPos, score[1] + atom_score[1]\/nNeg)\n        score = (score[0] \/ len(pride_body), score[1] \/ len(pride_body))\n        pride_rule_scores.append(score)\n    \n    # compute the rule score for the LOLH rule\n    lolh_rule_score = (0,0)\n    for index in body:\n        atom_score = inst.atom_score[index]\n        lolh_rule_score = (lolh_rule_score[0] + atom_score[0]\/nPos, lolh_rule_score[1] + atom_score[1]\/nNeg)\n    lolh_rule_score = (lolh_rule_score[0]\/len(body), lolh_rule_score[1]\/len(body))\n    \n    ############################################\n    # plot the rule scores\n    # display the normalized scores for all rules (between (0,0) and (n_positives, n_negatives))\n    fig, ax = plt.subplots()\n    \n    ax.set_xlim((0, 1.))\n    ax.set_ylim((0, 1.))\n    ax.set_xlabel('score positif')\n    ax.set_ylabel('score négatif')\n    # ax.set_title('Comparaison des règles de PRIDE et LOLH')\n\n    # diagonal indicating independant values\n    ax.plot([0, 1], [0, 1], color='black', zorder=0) \n    \n    # plot the pride rules\n    pride_indexes = [ind for ind in range(len(pride_bodies))]\n    pride_indexes.sort(key=lambda ind: len(pride_bodies[ind]))\n    pride_rule_scores_sorted = [pride_rule_scores[ind] for ind in pride_indexes] # sort all the points\n    longest_rule = np.max([len(body) for body in pride_bodies])\n    colors = [len(pride_bodies[ind]) for ind in pride_indexes]\n    cnorm = mcolors.Normalize(vmin=0, vmax=longest_rule)\n    \n    \n    ax.scatter([score[0] for score in pride_rule_scores_sorted], [score[1] for score in pride_rule_scores_sorted], c=colors, norm=cnorm, cmap=plt.get_cmap('viridis'), marker='x',  zorder=1, label='règles PRIDE', facecolor='darkblue')\n    cbar = fig.colorbar(cm.ScalarMappable(norm=cnorm, cmap=plt.get_cmap('viridis')), ax=ax)\n    cbar.set_label('longueur des règles PRIDE')\n    ax.scatter(lolh_rule_score[0], lolh_rule_score[1], marker='*', s=70, color='chocolate', zorder=1, label='règle LOLH') # plot the optimized rule\n    # plot the domination cone of the optimized rule\n    ax.plot([lolh_rule_score[0], lolh_rule_score[0]], [lolh_rule_score[1], 0], linestyle='--', color='darkgrey', zorder=0) \n    ax.plot([lolh_rule_score[0], 1.], [lolh_rule_score[1], lolh_rule_score[1]], linestyle='--', color='darkgrey', zorder=0) \n    legend = ax.legend(loc='lower right')\n    legend.legendHandles[0].set_color('darkcyan')\n    \n    ######################################################\n    # create an histogram to visualize rule error over samples\n    histo = histogram.Histogram(inst, body)\n    # plot the histogram\n    fig, ax = plt.subplots()\n    #ax.set_title('Histograms for ' + instance_name + ' classification')\n    visualizer.plot_histograms(ax, histo, True)\n    \n    ######################################################\n    # histogramme de PRIDE à partir de l'apprentissage sur un sous jeu de données\n    # histo = histogram.Histogram(inst, body)\n    # # plot the histogram\n    # fig, ax = plt.subplots()\n    # #ax.set_title('Histograms for ' + instance_name + ' classification')\n    # visualizer.plot_histograms(ax, histo, True)\n    \n    # histogramme de la meilleure règle PRIDE\n    scores_pride = []\n    ind_pride_bodies_sorted =  list(range(len(pride_bodies)))\n    ind_pride_bodies_sorted.sort(key=lambda ind: pride_rule_scores[ind][1] - pride_rule_scores[ind][0], reverse=True)\n    # print('pride scores sorted: ', [pride_rule_scores[ind][1] - pride_rule_scores[ind][0] for ind in ind_pride_bodies_sorted])\n\n    ind_best_pride_body = ind_pride_bodies_sorted[0]\n    print('best pride body: ', pride_bodies[ind_best_pride_body])\n      \n    # study atom indexes in pride bodies\n    atom_indexes_pride = [inst.get_atom(ind) for body in pride_bodies for ind in body]\n    print('pride body indexes (unique): ', np.unique(atom_indexes_pride, axis=0))\n\n    \n    # occ = np.bincount(atom_indexes_pride)\n    # print('occurences: ')\n    # for ind_atom in range(len(occ)):\n    #     print(ind_atom, ', ', inst.atom_score[ind_atom][1]\/nNeg - inst.atom_score[ind_atom][0]\/nPos, ', ', occ[ind_atom])\n    \n    # fig, ax_ = plt.subplots()\n    # ax_.scatter([inst.atom_score[ind_atom][0]\/nPos for ind_atom in range(len(occ))], [inst.atom_score[ind_atom][1]\/nPos for ind_atom in range(len(occ))], c=occ)\n    # ax_.set_title('indexes des atomes de PRIDE')\n    # ax_.set_xlabel('positive score')\n    # ax_.set_ylabel('negative score')\n    # cbar = fig.colorbar(cm.ScalarMappable(cmap=plt.get_cmap('viridis')), ax=ax_)\n    # cbar.set_label('nb occurences')\n    \n    # histo = histogram.Histogram(inst, pride_bodies[ind_best_pride_body])\n    # fig, ax = plt.subplots()\n    # ax.set_title('Meilleure règle PRIDE')\n    # visualizer.plot_histograms(ax, histo, True)\n    \n    \n    \n    ################################################################\n    # histogramme de la plus longue règle PRIDE et de la meilleure règle PRIDE\n    longest_pride = pride_bodies[0]\n    for pride_body in pride_bodies:\n        if len(pride_body) > len(longest_pride):\n            longest_pride = pride_body\n    histo1 = histogram.Histogram(inst, longest_pride)\n    histo2 = histogram.Histogram(inst, pride_bodies[ind_best_pride_body])\n    \n    # plot the histogram\n    fig, axs = plt.subplots(1, 2, gridspec_kw={'width_ratios': [1,0.9]})\n    \n    fig.tight_layout(w_pad=2)\n    \n    # ax.set_title('Histogrammes pour PRIDE')\n    visualizer.plot_histograms(axs[0], histo1, True)\n    axs[0].set_title(r'Plus longue règle PRIDE')\n    \n    visualizer.plot_histograms(axs[1], histo2, True)\n    axs[1].set_title(r'Meilleure règle PRIDE')\n    \n    \n    \n    ################################################################\n    # visualisation des règles en multi-objectif\n    body_length = 10\n    biobj_score, biobj_bodies, biobj_weight = solver.compute_supported(body_length, 1, 1)\n    \n    biobj_score = [ (score[0]\/float(inst.n_positives()), score[1]\/float(inst.n_negatives())) for score in biobj_score]\n    \n    # sélection de deux règles \"extrêmes\"\n    ind_left = 0\n    for ind in range(len(biobj_score)):\n        score = biobj_score[ind]\n        if score[0] >= -0.2 and score[0] <= 0.2:\n            if score[1] >= 6.4 and score[1] <= 6.6:\n                print('left: ', ind)\n                ind_left = ind\n    print('left body: ', biobj_bodies[ind_left])\n    left_score = biobj_score[ind_left]\n    \n    ind_right = 0\n    for ind in range(len(biobj_score)):\n        score = biobj_score[ind]\n        if score[0] >= 2.9 and score[0] <= 3.0:\n            if score[1] >= 9.8 and score[1] <= 10.0:\n                print('right: ', ind)\n                ind_right = ind\n    print('right body: ', biobj_bodies[ind_right])\n    right_score = biobj_score[ind_right]\n    \n    fig, ax = plt.subplots()\n    # ax.set_title('Score des règles bi-objectives')\n    ax.set_xlabel('score positif')\n    ax.set_ylabel('score négatif')\n    ind_reduced = [ind for ind in range(len(biobj_score)) if ind != ind_left and ind != ind_right]\n    ax.scatter([biobj_score[ind][0] for ind in ind_reduced], [biobj_score[ind][1] for ind in ind_reduced], marker='x', s=25)\n    ax.scatter([biobj_score[ind_left][0], biobj_score[ind_right][0]], [biobj_score[ind_left][1], biobj_score[ind_right][1]], color='red', marker='x', s=30) \n    ax.text(5-0.3, 5+0.3, 'score négatif - score positif = 0', horizontalalignment='center', verticalalignment='center', rotation=45)\n    ax.plot([0, body_length], [0, body_length], '--', color='k')\n    \n    ax.text(left_score[0] + 0.5, left_score[1]-0.2, r'$p_1$')\n    ax.text(right_score[0] + 0.0, right_score[1]-0.6, r'$p_2$')\n    \n    delta = 0.5\n    ax.set_xlim((0-delta, body_length+delta))\n    ax.set_ylim((0-delta, body_length+delta))\n    ax.set_aspect('equal')\n    \n    histo_left = histogram.Histogram(inst, biobj_bodies[ind_left])\n    histo_right = histogram.Histogram(inst, biobj_bodies[ind_right])\n    \n    fig,axs = plt.subplots(1,2)\n    fig.tight_layout(w_pad=3)\n    axs[0].set_title(r'Histogramme de la règle $p_1$')\n    visualizer.plot_histograms(axs[0], histo_left, True)\n    axs[1].set_title(r'Histogramme de la règle $p_2$')\n    visualizer.plot_histograms(axs[1], histo_right, True)\n    \n    \n    ################################################################\n    # display several rules with histograms\n    \n    fig, ax = plt.subplots()\n    ax.set_xlim([0, nPos])\n    ax.set_ylim([0, nNeg])\n    ax.scatter([inst.atom_score[ind][0] for ind in range(inst.n_atoms())], [inst.atom_score[ind][1] for ind in range(inst.n_atoms())], marker='x', zorder=1, alpha=0.5)\n    # ax.set_title('Visualisation de plusieurs règles logiques')\n    # ax.plot([0, nPos], [0, nNeg], '--', color='grey', zorder=3, alpha=0.7)\n    ax.set_xlabel('erreur positive')\n    ax.set_ylabel('erreur négative')\n    \n    fig, axsh = plt.subplots(2,2)\n    fig.tight_layout(h_pad=4)\n    \n    ##########################################\n    def compute_A_B(score, nPos, nNeg):\n        return (0, score*nNeg), ((1.-score)*nPos, nNeg)\n    \n    score1 = 0.3\n    score2 = 0.4\n    A1, B1 = compute_A_B(score1, nPos, nNeg)\n    A2, B2 = compute_A_B(score2, nPos, nNeg)\n    selected_atoms, scores = solver.select_best_atoms_threshold(0.0)\n    atoms_sandwich = [selected_atoms[ind] for ind in range(len(selected_atoms)) if scores[ind] >= score1 and scores[ind] <= score2]\n    np.random.shuffle(atoms_sandwich)\n    nAtomsSel = 10\n    body_worst = atoms_sandwich[:nAtomsSel]\n    print('body: ', body_worst)\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in body_worst], [inst.atom_score[ind_atom][1] for ind_atom in body_worst], marker='x', color='orangered', zorder=4)\n    # histogramme\n    histo = histogram.Histogram(inst, body_worst)\n    axsh[0,0].set_title('Règle sous-optimale')\n    visualizer.plot_histograms(axsh[0,0], histo, True)\n    \n    \n    ax.fill([A1[0], B1[0], B2[0], A2[0]], [A1[1], B1[1], B2[1], A2[1]], zorder=3, color='green', alpha=0.3, label='règle sous-optimale')\n    ax.plot([A1[0], B1[0]], [A1[1], B1[1]], '--', color='k', zorder=3)\n    ax.plot([A2[0], B2[0]], [A2[1], B2[1]], '--', color='k', zorder=3)\n    \n    score1 = -0.8\n    score2 = -0.7\n    A1, B1 = compute_A_B(score1, nPos, nNeg)\n    \n    A2, B2 = compute_A_B(score2, nPos, nNeg)\n    \n    selected_atoms, scores = solver.select_best_atoms_threshold(-1.)\n    atoms_sandwich = [selected_atoms[ind] for ind in range(len(selected_atoms)) if scores[ind] >= score1 and scores[ind] <= score2]\n    np.random.shuffle(atoms_sandwich)\n    nAtomsSel = 10\n    body_worst = atoms_sandwich[:nAtomsSel]\n    print('body: ', body_worst)\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in body_worst], [inst.atom_score[ind_atom][1] for ind_atom in body_worst], marker='x', color='orangered', zorder=4)\n    # histogramme\n    histo = histogram.Histogram(inst, body_worst)\n    axsh[0,1].set_title('Règle inverse')\n    visualizer.plot_histograms(axsh[0,1], histo, True)\n    \n    ax.fill([A1[0], B1[0], B2[0], A2[0]], [A1[1], B1[1], B2[1], A2[1]], zorder=3, color='orange', alpha=0.3, label='règle inverse')\n    ax.plot([A1[0], B1[0]], [A1[1], B1[1]], '--', color='k', zorder=3)\n    ax.plot([A2[0], B2[0]], [A2[1], B2[1]], '--', color='k', zorder=3)\n    \n    score1 = -0.05\n    score2 = 0.05\n    A1, B1 = compute_A_B(score1, nPos, nNeg)\n    A2, B2 = compute_A_B(score2, nPos, nNeg)\n    selected_atoms, scores = solver.select_best_atoms_threshold(-1.)\n    atoms_sandwich = [selected_atoms[ind] for ind in range(len(selected_atoms)) if scores[ind] >= score1 and scores[ind] <= score2]\n    np.random.shuffle(atoms_sandwich)\n    nAtomsSel = 10\n    body_worst = atoms_sandwich[:nAtomsSel]\n    print('body: ', body_worst)\n    ax.scatter([inst.atom_score[ind_atom][0] for ind_atom in body_worst], [inst.atom_score[ind_atom][1] for ind_atom in body_worst], marker='x', color='orangered', zorder=4, label='atomes sélectionnés')\n    # histogramme\n    histo = histogram.Histogram(inst, body_worst)\n    axsh[1,0].set_title('Règle inappropriée')\n    visualizer.plot_histograms(axsh[1,0], histo, True)\n    \n    \n    ax.fill([A1[0], B1[0], B2[0], A2[0]], [A1[1], B1[1], B2[1], A2[1]], zorder=3, color='red', alpha=0.3, label='règle inappropriée')\n    ax.plot([A1[0], B1[0]], [A1[1], B1[1]], '--', color='k', zorder=3)\n    ax.plot([A2[0], B2[0]], [A2[1], B2[1]], '--', color='k', zorder=3)\n    \n    atomes = [ind for ind in range(inst.n_atoms())]\n    np.random.shuffle(atomes)\n    body_random = atomes[:10]\n    histo = histogram.Histogram(inst, body_random)\n    axsh[1,1].set_title('Règle aléatoire')\n    visualizer.plot_histograms(axsh[1,1], histo, True)\n    \n    \n    legend = ax.legend(loc='lower left')\n    \n    handles_old, labels_old = ax.get_legend_handles_labels()\n    \n    new_handles = []\n    for ind_handle in range(len(handles_old)-1):\n        patch = handles_old[ind_handle]\n        new_handles.append(Patch(edgecolor='k', facecolor=colorConverter.to_rgba(patch.get_facecolor(), alpha=0.3), linewidth=0.5, label=labels_old[ind_handle]))\n    new_handles.append(handles_old[-1])\n    ax.legend(loc='lower left', handles=new_handles, labels=labels_old)\n    \n    \n    ################################################################\n    # K-fold validation on PRIDE and LOLH\n    k = 10\n    \n    # create nsamples\/k subset of the data\n    pos_indexes = inst._pos_samples\n    pos_sub_indexes = [[] for _ in range(k)]\n    for ind in range(len(pos_indexes)):\n        k_prime = int((ind\/nPos)*k)\n        pos_sub_indexes[k_prime].append(pos_indexes[ind])\n        \n    neg_indexes = inst._neg_samples\n    neg_sub_indexes = [[] for _ in range(k)]\n    for ind in range(len(neg_indexes)):\n        k_prime = int((ind\/nNeg)*k)\n        neg_sub_indexes[k_prime].append(neg_indexes[ind])\n    \n    LOLH_perf = [[],[]]\n    PRIDE_perf = [[],[]]\n    \n    for ind_k in range(1):\n    \n        # create the training and test set\n        #ind_K = 0\n        train_pos = pos_sub_indexes[ind_k]\n        train_neg = neg_sub_indexes[ind_k]\n        test_pos = []\n        test_neg = []\n        for ind in range(k):\n            if ind != ind_k:\n                test_pos += pos_sub_indexes[ind]\n                test_neg += neg_sub_indexes[ind]\n        \n        # test_pos = train_pos\n        # test_neg = train_neg\n        \n        df_train = df.loc[train_pos+train_neg]\n        df_test = df.loc[test_pos+test_neg]\n        \n        # training set\n        inst_train = Instance.create_instance_explicit(df_train, train_pos, train_neg)\n        \n         # test set\n        inst_test = Instance.create_instance_explicit(df_test, test_pos, test_neg)\n        \n        # compute the model on the training set\n        solver = Solver(inst_train)\n        \n        # computation of the solution with LOLH and PRIDE\n        # the atom indexes are converted from the train instance to the test instance\n        \n        # compute LOLH body\n        LOLH_body, scores = solver.select_best_atoms_threshold(0.75)\n        LOLH_body = [inst_train.get_atom(atom_index) for atom_index in LOLH_body]\n        LOLH_body = [inst_test.get_atom_index(atom) for atom in LOLH_body]\n        \n        # compute PRIDE bodies\n        PRIDE_bodies = compute_pride_bodies(inst_train)\n        PRIDE_bodies = [[inst_train.get_atom(atom_index) for atom_index in pride_body] for pride_body in PRIDE_bodies]\n        PRIDE_bodies = [[inst_test.get_atom_index(atom) for atom in PRIDE_body] for PRIDE_body in PRIDE_bodies]\n        \n        \n        # atoms in the train and test instance\n        atoms_train_test = [inst_train.get_atom(atom_index) for atom_index in range(inst_train.n_atoms()) if inst_test.has_atom(inst_train.get_atom(atom_index))]\n        col = []\n        for atom in atoms_train_test:\n            ind_atom_train = inst_train.get_atom_index(atom)\n            score = -inst_train.atom_score[ind_atom_train][0]*len(train_neg)+inst_train.atom_score[ind_atom_train][1]*len(train_pos)\n            col.append(score)\n                \n        # fig, ax = plt.subplots()\n        # ax.scatter([inst_test.atom_score[inst_test.get_atom_index(atom)][0] for atom in atoms_train_test], [inst_test.atom_score[inst_test.get_atom_index(atom)][1] for atom in atoms_train_test], marker='x', c=col)\n        # ax.set_xlim([0, len(test_pos)])\n        # ax.set_ylim([0, len(test_neg)])\n        # ax.plot([0, len(test_pos)], [0, len(test_neg)], '--', color='k')\n    \n        # histogramme de LOLH\n        # histo = histogram.Histogram(inst_test, LOLH_body)\n        # fig, ax = plt.subplots()\n        # ax.set_title('histo LOLH données test')\n        # visualizer.plot_histograms(ax, histo, True)\n        \n        # LOLH performance\n        pos_match = 0\n        neg_match = 0\n        for pos in test_pos:\n            matching_error = 0\n            for ind_atom in LOLH_body:\n                atom = inst_test.get_atom(ind_atom)\n                if df_test[atom[0]][pos] != atom[1]:\n                    matching_error += 1\n            if matching_error < len(LOLH_body)\/2.:\n                pos_match += 1\n        for neg in test_neg:\n            matching_error = 0\n            for ind_atom in LOLH_body:\n                atom = inst_test.get_atom(ind_atom)\n                if df_test[atom[0]][neg] != atom[1]:\n                    matching_error += 1\n            if matching_error < len(LOLH_body)\/2.:\n                neg_match += 1\n        # print('pos match: ', pos_match)\n        # print('neg match: ', neg_match)\n        LOLH_perf[0].append(float(pos_match)\/len(test_pos))\n        LOLH_perf[1].append(float(neg_match)\/len(test_neg))\n        \n        # PRIDE performance\n        pos_match = 0\n        neg_match = 0\n        \n        for pos in test_pos:\n            match = False\n            for pride_body in PRIDE_bodies:\n                matching_error = 0\n                for ind_atom in pride_body:\n                    atom = inst_test.get_atom(ind_atom)\n                    if df_test[atom[0]][pos] != atom[1]:\n                        matching_error += 1\n                if matching_error == 0:\n                    match = True\n                    pos_match += 1\n                    break\n        for neg in test_neg:\n            match = False\n            for pride_body in PRIDE_bodies:\n                matching_error = 0\n                for ind_atom in pride_body:\n                    atom = inst_test.get_atom(ind_atom)\n                    if df_test[atom[0]][neg] != atom[1]:\n                        matching_error += 1\n                if matching_error == 0:\n                    match = True\n                    neg_match += 1\n                    break\n        PRIDE_perf[0].append(pos_match\/len(test_pos))\n        PRIDE_perf[1].append(neg_match\/len(test_neg))\n        \n    print(LOLH_perf)\n    print(PRIDE_perf)\n    \n    return\n\n# singlecell_matrix_experiment()\n\n# artificial_data_experiment()\n\nLOLH_artificial_data()\n"}
+{"id":"MathCode-Pile_decontaminated_package-filtered_train-00002-of-00059_doc_414","text":"\"\"\"\nThe pymaf submodule is designed for working with MAF files. It implements\n``pymaf.MafFrame`` which stores MAF data as ``pandas.DataFrame`` to allow\nfast computation and easy manipulation. The ``pymaf.MafFrame`` class also\ncontains many useful plotting methods such as ``MafFrame.plot_oncoplot`` and\n``MafFrame.plot_summary``. The submodule strictly adheres to the\nstandard `MAF specification\n<https:\/\/docs.gdc.cancer.gov\/Data\/File_Formats\/MAF_Format\/>`_.\n\nA typical MAF file contains many columns ranging from gene symbol to\nprotein change. However, most of the analysis in pymaf uses the\nfollowing columns:\n\n+-----+------------------------+----------------------+-------------------------------+\n| No. | Name                   | Description          | Examples                      |\n+=====+========================+======================+===============================+\n| 1   | Hugo_Symbol            | HUGO gene symbol     | 'TP53', 'Unknown'             |\n+-----+------------------------+----------------------+-------------------------------+\n| 2   | Chromosome             | Chromosome name      | 'chr1', '1', 'X'              |\n+-----+------------------------+----------------------+-------------------------------+\n| 3   | Start_Position         | Start coordinate     | 119031351                     |\n+-----+------------------------+----------------------+-------------------------------+\n| 4   | End_Position           | End coordinate       | 44079555                      |\n+-----+------------------------+----------------------+-------------------------------+\n| 5   | Variant_Classification | Translational effect | 'Missense_Mutation', 'Silent' |\n+-----+------------------------+----------------------+-------------------------------+\n| 6   | Variant_Type           | Mutation type        | 'SNP', 'INS', 'DEL'           |\n+-----+------------------------+----------------------+-------------------------------+\n| 7   | Reference_Allele       | Reference allele     | 'T', '-', 'ACAA'              |\n+-----+------------------------+----------------------+-------------------------------+\n| 8   | Tumor_Seq_Allele1      | First tumor allele   | 'A', '-', 'TCA'               |\n+-----+------------------------+----------------------+-------------------------------+\n| 9   | Tumor_Seq_Allele2      | Second tumor allele  | 'A', '-', 'TCA'               |\n+-----+------------------------+----------------------+-------------------------------+\n| 10  | Tumor_Sample_Barcode   | Sample ID            | 'TCGA-AB-3002'                |\n+-----+------------------------+----------------------+-------------------------------+\n| 11  | Protein_Change         | Protein change       | 'p.L558Q'                     |\n+-----+------------------------+----------------------+-------------------------------+\n\nIt is also recommended to include additional custom columns such as variant\nallele frequecy (VAF) and transcript name.\n\nIf sample annotation data are available for a given MAF file, use\nthe :class:`common.AnnFrame` class to import the data.\n\nThere are nine nonsynonymous variant classifcations that pymaf primarily\nuses: Missense_Mutation, Frame_Shift_Del, Frame_Shift_Ins, In_Frame_Del,\nIn_Frame_Ins, Nonsense_Mutation, Nonstop_Mutation, Splice_Site, and\nTranslation_Start_Site.\n\"\"\"\n\nimport re\nimport copy\nimport warnings\nimport itertools\n\nfrom . import pyvcf, common\n\nimport numpy as np\nimport pandas as pd\nimport statsmodels.formula.api as smf\nfrom matplotlib_venn import venn2, venn3\nfrom scipy.stats import fisher_exact\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as mpatches\nimport matplotlib.gridspec as gridspec\n\n\nCHROM_LENGTHS = {\n    'hg18': [\n        247249719, 242951149, 199501827, 191273063, 180857866, 170899992,\n        158821424, 146274826, 140273252, 135374737, 134452384, 132349534,\n        114142980, 106368585, 100338915, 88827254, 78774742, 76117153,\n        63811651, 62435964, 46944323, 49691432, 154913754, 57772954\n    ],\n    'hg19': [\n        249250621, 243199373, 198022430, 191154276, 180915260, 171115067,\n        159138663, 146364022, 141213431, 135534747, 135006516, 133851895,\n        115169878, 107349540, 102531392, 90354753, 81195210, 78077248,\n        59128983, 63025520, 48129895, 51304566, 155270560, 59373566\n    ],\n    'hg38': [\n        248956422, 242193529, 198295559, 190214555, 181538259, 170805979,\n        159345973, 145138636, 138394717, 133797422, 135086622, 133275309,\n        114364328, 107043718, 101991189, 90338345, 83257441, 80373285,\n        58617616, 64444167, 46709983, 50818468, 156040895, 57227415\n    ],\n}\n\nCOMMON_COLUMNS = [\n    'Hugo_Symbol', 'Entrez_Gene_Id', 'Center', 'NCBI_Build', 'Chromosome',\n    'Start_Position', 'End_Position', 'Strand', 'Variant_Classification',\n    'Variant_Type', 'Reference_Allele', 'Tumor_Seq_Allele1',\n    'Tumor_Seq_Allele2', 'Tumor_Sample_Barcode', 'Protein_Change'\n]\n\n# Below is the list of calculated variant consequences from Ensembl VEP:\n# https:\/\/m.ensembl.org\/info\/genome\/variation\/prediction\/predicted_data.html\n# (accessed on 2021-05-31)\n#\n# Note that both frameshift_variant and protein_altering_variant require\n# additional information to find their correct Variant_Classification.\n\nVEP_CONSEQUENCES = {\n    'transcript_ablation':                'Splice_Site',\n    'splice_acceptor_variant':            'Splice_Site',\n    'splice_donor_variant':               'Splice_Site',\n    'stop_gained':                        'Nonsense_Mutation',\n    'frameshift_variant':                 'AMBIGUOUS',\n    'stop_lost':                          'Nonstop_Mutation',\n    'start_lost':                         'Translation_Start_Site',\n    'transcript_amplification':           'Intron',\n    'inframe_insertion':                  'In_Frame_Ins',\n    'inframe_deletion':                   'In_Frame_Del',\n    'missense_variant':                   'Missense_Mutation',\n    'protein_altering_variant':           'AMBIGUOUS',\n    'splice_region_variant':              'Splice_Region',\n    'incomplete_terminal_codon_variant':  'Silent',\n    'start_retained_variant':             'Silent',\n    'stop_retained_variant':              'Silent',\n    'synonymous_variant':                 'Silent',\n    'coding_sequence_variant':            'Missense_Mutation',\n    'mature_miRNA_variant':               'RNA',\n    '5_prime_UTR_variant':                \"5'UTR\",\n    '3_prime_UTR_variant':                \"3'UTR\",\n    'non_coding_transcript_exon_variant': 'RNA',\n    'intron_variant':                     'Intron',\n    'NMD_transcript_variant':             'Silent',\n    'non_coding_transcript_variant':      'RNA',\n    'upstream_gene_variant':              \"5'Flank\",\n    'downstream_gene_variant':            \"3'Flank\",\n    'TFBS_ablation':                      'Targeted_Region',\n    'TFBS_amplification':                 'Targeted_Region',\n    'TF_binding_site_variant':            'IGR',\n    'regulatory_region_ablation':         'Targeted_Region',\n    'regulatory_region_amplification':    'Targeted_Region',\n    'feature_elongation':                 'Targeted_Region',\n    'regulatory_region_variant':          'IGR',\n    'feature_truncation':                 'Targeted_Region',\n    'intergenic_variant':                 'IGR',\n}\n\nVARCLS_LIST = [\n    \"3'Flank\",\n    \"3'UTR\",\n    \"5'Flank\",\n    \"5'UTR\",\n    'De_novo_Start_InFrame',\n    'De_novo_Start_OutOfFrame',\n    'Frame_Shift_Del',\n    'Frame_Shift_Ins',\n    'IGR',\n    'In_Frame_Del',\n    'In_Frame_Ins',\n    'Intron',\n    'Missense_Mutation',\n    'Nonsense_Mutation',\n    'Nonstop_Mutation',\n    'RNA',\n    'Silent',\n    'Splice_Region',\n    'Splice_Site',\n    'Start_Codon_Ins',\n    'Start_Codon_SNP',\n    'Stop_Codon_Del',\n    'Targeted_Region',\n    'Translation_Start_Site',\n    'lincRNA',\n]\n\nNONSYN_NAMES = [\n    'Missense_Mutation', 'Frame_Shift_Del', 'Frame_Shift_Ins',\n    'In_Frame_Del', 'In_Frame_Ins', 'Nonsense_Mutation',\n    'Nonstop_Mutation', 'Splice_Site', 'Translation_Start_Site'\n]\n\nNONSYN_COLORS = [\n    'tab:green', 'tab:blue', 'tab:purple', 'tab:olive', 'tab:red',\n    'tab:cyan', 'tab:pink', 'tab:orange', 'tab:brown'\n]\n\nSNV_CLASSES = {\n    'A>C': {'class': 'T>G', 'type': 'Tv'},\n    'A>G': {'class': 'T>C', 'type': 'Ti'},\n    'A>T': {'class': 'T>A', 'type': 'Tv'},\n    'C>A': {'class': 'C>A', 'type': 'Tv'},\n    'C>G': {'class': 'C>G', 'type': 'Tv'},\n    'C>T': {'class': 'C>T', 'type': 'Ti'},\n    'G>A': {'class': 'C>T', 'type': 'Ti'},\n    'G>C': {'class': 'C>G', 'type': 'Tv'},\n    'G>T': {'class': 'C>A', 'type': 'Tv'},\n    'T>A': {'class': 'T>A', 'type': 'Tv'},\n    'T>C': {'class': 'T>C', 'type': 'Ti'},\n    'T>G': {'class': 'T>G', 'type': 'Tv'},\n}\n\nSNV_CLASS_ORDER = ['C>A', 'C>G', 'C>T', 'T>A', 'T>C', 'T>G']\n\nclass MafFrame:\n    \"\"\"Class for storing MAF data.\n\n    Parameters\n    ----------\n    df : pandas.DataFrame\n        DataFrame containing MAF data.\n\n    See Also\n    --------\n    MafFrame.from_file\n        Construct MafFrame from a MAF file.\n    \"\"\"\n    def __init__(self, df):\n        self.df = df.reset_index(drop=True)\n\n    @property\n    def shape(self):\n        \"\"\"tuple : Dimensionality of MafFrame (variants, samples).\"\"\"\n        return (self.df.shape[0], len(self.samples))\n\n    @property\n    def samples(self):\n        \"\"\"list : List of the sample names.\"\"\"\n        return list(self.df.Tumor_Sample_Barcode.unique())\n\n    @property\n    def genes(self):\n        \"\"\"list : List of the genes.\"\"\"\n        return list(self.df.Hugo_Symbol.unique())\n\n    def copy(self):\n        \"\"\"Return a copy of the MafFrame.\"\"\"\n        return self.__class__(self.df.copy())\n\n    def compute_clonality(self, vaf_col, threshold=0.25):\n        \"\"\"\n        Compute the clonality of variants based on\n        :ref:`VAF <glossary:Variant allele frequency (VAF)>`.\n\n        A mutation will be defined as \"Subclonal\" if the VAF is less than the\n        threshold percentage (e.g. 25%) of the highest VAF in the sample and\n        is defined as \"Clonal\" if it is equal to or above this threshold.\n\n        Parameters\n        ----------\n        vaf_col : str\n            MafFrame column containing VAF data.\n        threshold : float\n            Minimum VAF to be considered as \"Clonal\".\n\n        Returns\n        -------\n        panda.Series\n            Clonality for each variant.\n\n        Examples\n        --------\n\n        >>> import matplotlib.pyplot as plt\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        >>> mf.df['Clonality'] = mf.compute_clonality('i_TumorVAF_WU')\n        >>> mf.df['Clonality'][:10]\n        0    Clonal\n        1    Clonal\n        2    Clonal\n        3    Clonal\n        4    Clonal\n        5    Clonal\n        6    Clonal\n        7    Clonal\n        8    Clonal\n        9    Clonal\n        Name: Clonality, dtype: object\n        \"\"\"\n        d = self.df.groupby('Tumor_Sample_Barcode')[vaf_col].max().to_dict()\n        def one_row(r):\n            m = d[r.Tumor_Sample_Barcode]\n            if r[vaf_col] < m * threshold:\n                result = 'Subclonal'\n            else:\n                result = 'Clonal'\n            return result\n        s = self.df.copy().apply(one_row, axis=1)\n        return s\n\n    @classmethod\n    def from_file(cls, fn):\n        \"\"\"\n        Construct MafFrame from a MAF file.\n\n        Parameters\n        ----------\n        fn : str\n            MAF file (compressed or uncompressed).\n\n        Returns\n        -------\n        MafFrame\n            MafFrame object.\n\n        See Also\n        --------\n        MafFrame\n            MafFrame object creation using constructor.\n\n        Examples\n        --------\n\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        \"\"\"\n        # Read the input MAF file.\n        df = pd.read_table(fn)\n\n        # Check the letter case of column names. This will help distinguish\n        # missing columns from columns with incorrect letter case (e.g.\n        # 'End_Position' vs. 'End_position').\n        lower_names = [x.lower() for x in COMMON_COLUMNS]\n        for col in df.columns:\n            if col.lower() in lower_names:\n                i = lower_names.index(col.lower())\n                if col != COMMON_COLUMNS[i]:\n                    message = (\n                        f\"Input column '{col}' will be renamed \"\n                        f\"as '{COMMON_COLUMNS[i]}'.\"\n                    )\n                    warnings.warn(message)\n                    df = df.rename(columns={col: COMMON_COLUMNS[i]})\n\n        # Set the data type of chromosomes as string (e.g. 'chr1' vs. '1').\n        if 'Chromosome' in df.columns:\n            df.Chromosome = df.Chromosome.astype(str)\n\n        return cls(df)\n\n    @classmethod\n    def from_vcf(cls, vcf, keys=None, names=None):\n        \"\"\"\n        Construct MafFrame from a VCF file or VcfFrame.\n\n        It is recommended that the input VCF data be functionally annotated\n        by an annotation tool such as Ensembl VEP, SnpEff, and ANNOVAR;\n        however, the method can handle unannotated VCF data as well.\n\n        The preferred tool for functional annotation is Ensembl VEP with\n        \"RefSeq transcripts\" as the transcript database and the filtering\n        option \"Show one selected consequence per variant\".\n\n        Parameters\n        ----------\n        vcf : str or VcfFrame\n            VCF file or VcfFrame.\n        keys : str or list\n            Genotype key (e.g. 'AD', 'AF') or list of genotype keys to be\n            added to the MafFrame.\n        names : str or list\n            Column name or list of column names for ``keys`` (must be the\n            same length). By default, the genotype keys will be used as\n            column names.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        >>> from fuc import pyvcf, pymaf\n        >>> data = {\n        ...     'CHROM': ['chr1', 'chr2'],\n        ...     'POS': [100, 101],\n        ...     'ID': ['.', '.'],\n        ...     'REF': ['G', 'T'],\n        ...     'ALT': ['A', 'C'],\n        ...     'QUAL': ['.', '.'],\n        ...     'FILTER': ['.', '.'],\n        ...     'INFO': ['CSQ=T|missense_variant|MODERATE|MTOR|2475|Transcript|NM_001386500.1|protein_coding|47\/58||||6792|6644|2215|S\/Y|tCt\/tAt|rs587777894&COSV63868278&COSV63868313||-1||EntrezGene||||||||G|G||deleterious(0)|possibly_damaging(0.876)||||||||||||||||||likely_pathogenic&pathogenic|0&1&1|1&1&1|26619011&27159400&24631838&26018084&27830187|||||', 'CSQ=C|splice_donor_variant|HIGH|MTOR|2475|Transcript|NM_001386500.1|protein_coding||46\/57||||||||||-1||EntrezGene||||||||A|A|||||||||||||||||||||||||||||'],\n        ...     'FORMAT': ['GT:AD:DP:AF', 'GT:AD:DP:AF'],\n        ...     'A': ['0\/1:176,37:213:0.174', '0\/1:966,98:1064:0.092']\n        ... }\n        >>> vf = pyvcf.VcfFrame.from_dict([], data)\n        >>> vf.df\n          CHROM  POS ID REF ALT QUAL FILTER                                               INFO       FORMAT                      A\n        0  chr1  100  .   G   A    .      .  CSQ=T|missense_variant|MODERATE|MTOR|2475|Tran...  GT:AD:DP:AF   0\/1:176,37:213:0.174\n        1  chr2  101  .   T   C    .      .  CSQ=C|splice_donor_variant|HIGH|MTOR|2475|Tran...  GT:AD:DP:AF  0\/1:966,98:1064:0.092\n        >>> mf = pymaf.MafFrame.from_vcf(vf)\n        >>> mf.df\n          Hugo_Symbol Entrez_Gene_Id Center NCBI_Build Chromosome  Start_Position  End_Position Strand Variant_Classification Variant_Type Reference_Allele Tumor_Seq_Allele1 Tumor_Seq_Allele2 Protein_Change Tumor_Sample_Barcode\n        0        MTOR           2475      .          .       chr1             100           100      -      Missense_Mutation          SNP                G                 A                 A       p.S2215Y                    A\n        1        MTOR           2475      .          .       chr2             101           101      -            Splice_Site          SNP                T                 C                 C              .                    A\n\n        We can add genotype keys such as AD and AF:\n\n        >>> mf = pymaf.MafFrame.from_vcf(vf, keys=['AD', 'AF'])\n        >>> mf.df\n          Hugo_Symbol Entrez_Gene_Id Center NCBI_Build Chromosome  Start_Position  End_Position Strand Variant_Classification Variant_Type Reference_Allele Tumor_Seq_Allele1 Tumor_Seq_Allele2 Protein_Change Tumor_Sample_Barcode      AD     AF\n        0        MTOR           2475      .          .       chr1             100           100      -      Missense_Mutation          SNP                G                 A                 A       p.S2215Y                    A  176,37  0.174\n        1        MTOR           2475      .          .       chr2             101           101      -            Splice_Site          SNP                T                 C                 C              .                    A  966,98  0.092\n\n        The method can accept a VCF file as input instead of VcfFrame:\n\n        >>> mf = pymaf.MafFrame.from_vcf('annotated.vcf')\n\n        The method can also handle unannotated VCF data:\n\n        >>> data = {\n        ...     'CHROM': ['chr1', 'chr1', 'chr1'],\n        ...     'POS': [100, 200, 300],\n        ...     'ID': ['.', '.', '.'],\n        ...     'REF': ['G', 'C', 'TTC'],\n        ...     'ALT': ['A', 'CAG', 'T'],\n        ...     'QUAL': ['.', '.', '.'],\n        ...     'FILTER': ['.', '.', '.'],\n        ...     'INFO': ['.', '.', '.'],\n        ...     'FORMAT': ['GT', 'GT', 'GT'],\n        ...     'A': ['0\/1', '0\/1', '0\/1']\n        ... }\n        >>> vf = pyvcf.VcfFrame.from_dict([], data)\n        >>> vf.df\n          CHROM  POS ID  REF  ALT QUAL FILTER INFO FORMAT    A\n        0  chr1  100  .    G    A    .      .    .     GT  0\/1\n        1  chr1  200  .    C  CAG    .      .    .     GT  0\/1\n        2  chr1  300  .  TTC    T    .      .    .     GT  0\/1\n        >>> mf = pymaf.MafFrame.from_vcf(vf)\n        >>> mf.df\n          Hugo_Symbol Entrez_Gene_Id Center NCBI_Build Chromosome  Start_Position  End_Position Strand Variant_Classification Variant_Type Reference_Allele Tumor_Seq_Allele1 Tumor_Seq_Allele2 Protein_Change Tumor_Sample_Barcode\n        0           .              .      .          .       chr1             100           100      .                      .          SNP                G                 A                 A              .                    A\n        1           .              .      .          .       chr1             200           201      .                      .          INS                -                AG                AG              .                    A\n        2           .              .      .          .       chr1             301           302      .                      .          DEL               TC                 -                 -              .                    A\n        \"\"\"\n        # Parse the input VCF.\n        if isinstance(vcf, str):\n            vf = pyvcf.VcfFrame.from_file(vcf)\n        else:\n            vf = vcf\n\n        # Set some default values in case the VCF is not annotated.\n        ncbi_build = '.'\n\n        # Get the NCBI_Build data.\n        for line in vf.meta:\n            if line.startswith('##VEP'):\n                ncbi_build = re.search(r'assembly=\"(.*?)\"', line).group(1)\n                break\n\n        # Define the conversion algorithm.\n        def one_row(r):\n            has_annot = 'CSQ=' in r.INFO\n\n            # Set some default values in case the VCF is not annotated.\n            strand = '.'\n            variant_classification = '.'\n            protein_change = '.'\n            hugo_symbol = '.'\n            entrez_gene_id = '.'\n\n            # Get the sequence data.\n            inframe = abs(len(r.REF) - len(r.ALT)) \/ 3 == 0\n            if len(r.REF) == len(r.ALT) == 1:\n                variant_type = 'SNP'\n                start_position = r.POS\n                end_position = r.POS\n                reference_allele = r.REF\n                tumor_seq_allele1 = r.ALT\n                tumor_seq_allele2 = r.ALT\n            elif len(r.REF) > len(r.ALT):\n                variant_type = 'DEL'\n                start_position = r.POS + 1\n                end_position = r.POS + len(r.REF) - len(r.ALT)\n                reference_allele = r.REF[1:]\n                tumor_seq_allele1 = '-'\n                tumor_seq_allele2 = '-'\n            else:\n                variant_type = 'INS'\n                start_position = r.POS\n                end_position = r.POS + 1\n                reference_allele = '-'\n                tumor_seq_allele1 = r.ALT[1:]\n                tumor_seq_allele2 = r.ALT[1:]\n\n            fields = r.INFO.replace('CSQ=', '').split(',')[0].split('|')\n\n            # Get the Strand data.\n            if has_annot:\n                strand = '+' if fields[19] == '1' else '-'\n\n            # Get the Variant_Classification data.\n            if has_annot:\n                consequence = fields[1].split('&')[0]\n                if consequence == 'frameshift_variant':\n                    if variant_type == 'DEL':\n                        variant_classification = 'Frame_Shift_Del'\n                    else:\n                        variant_classification = 'Frame_Shift_Ins'\n                elif consequence == 'protein_altering_variant':\n                    if inframe:\n                        if variant_type == 'DEL':\n                            variant_classification = 'In_Frame_Del'\n                        else:\n                            variant_classification = 'In_Frame_Ins'\n                    else:\n                        if variant_type == 'DEL':\n                            variant_classification = 'Frame_Shift_Del'\n                        else:\n                            variant_classification = 'Frame_Shift_Ins'\n                elif consequence in VEP_CONSEQUENCES:\n                    variant_classification = VEP_CONSEQUENCES[consequence]\n                else:\n                    m = f'Found unknown Ensembl VEP consequence: {consequence}'\n                    raise ValueError(m)\n\n            # Get the Tumor_Sample_Barcode data.\n            s = r[9:].apply(pyvcf.gt_hasvar)\n            tumor_sample_barcode = ','.join(s[s].index.to_list())\n\n            # Get the Protein_Change data.\n            if has_annot:\n                pos = fields[14]\n                aa = fields[15].split('\/')\n                if len(aa) > 1:\n                    protein_change = f'p.{aa[0]}{pos}{aa[1]}'\n\n            # Get other data.\n            if has_annot:\n                hugo_symbol = fields[3]\n                entrez_gene_id = fields[4]\n\n            d = dict(\n                Hugo_Symbol = hugo_symbol,\n                Entrez_Gene_Id = entrez_gene_id,\n                Center = '.',\n                NCBI_Build = ncbi_build,\n                Chromosome = r.CHROM,\n                Start_Position = start_position,\n                End_Position = end_position,\n                Strand = strand,\n                Variant_Classification = variant_classification,\n                Variant_Type = variant_type,\n                Reference_Allele = reference_allele,\n                Tumor_Seq_Allele1 = tumor_seq_allele1,\n                Tumor_Seq_Allele2 = tumor_seq_allele2,\n                Tumor_Sample_Barcode = tumor_sample_barcode,\n                Protein_Change = protein_change,\n                CHROM = r.CHROM, # will be dropped\n                POS = r.POS,     # will be dropped\n                REF = r.REF,     # will be dropped\n                ALT = r.ALT,     # will be dropped\n            )\n\n            return pd.Series(d)\n\n        # Apply the conversion algorithm.\n        df = vf.df.apply(one_row, axis=1)\n\n        # Expand the Tumor_Sample_Barcode column to multiple rows.\n        s = df['Tumor_Sample_Barcode'].str.split(',').apply(\n            pd.Series, 1).stack()\n        s.index = s.index.droplevel(-1)\n        s.name = 'Tumor_Sample_Barcode'\n        del df['Tumor_Sample_Barcode']\n        df = df.join(s)\n\n        # Append extra genotype keys, if necessary.\n        if keys is not None:\n            if names is None:\n                names = keys\n            if isinstance(keys, str):\n                keys = [keys]\n            if isinstance(names, str):\n                names = [names]\n            for i, key in enumerate(keys):\n                temp_df = vf.extract_format(key)\n                temp_df = pd.concat([vf.df.iloc[:, :9], temp_df], axis=1)\n                temp_df = temp_df.drop(\n                    columns=['ID', 'QUAL', 'FILTER', 'INFO', 'FORMAT'])\n                temp_df = pd.melt(\n                    temp_df,\n                    id_vars=['CHROM', 'POS', 'REF', 'ALT'],\n                    var_name='Tumor_Sample_Barcode',\n                )\n                temp_df = temp_df[temp_df.value != '.']\n                df = df.merge(temp_df,\n                    on=['CHROM', 'POS', 'REF', 'ALT', 'Tumor_Sample_Barcode'])\n                df = df.rename(columns={'value': names[i]})\n\n        # Drop the extra columns.\n        df = df.drop(columns=['CHROM', 'POS', 'REF', 'ALT'])\n\n        return cls(df)\n\n    def matrix_prevalence(self):\n        \"\"\"\n        Compute a matrix of variant counts with a shape of (genes, samples).\n\n        Returns\n        -------\n        pandas.DataFrame\n            The said matrix.\n        \"\"\"\n        s = self.df.groupby(\n            'Hugo_Symbol')['Tumor_Sample_Barcode'].value_counts()\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n        df = df.pivot(index='Hugo_Symbol',\n            columns='Tumor_Sample_Barcode', values='Count')\n        df.columns.name = ''\n        df = df.fillna(0)\n        return df\n\n    def matrix_genes(self, mode='variants', count=10):\n        \"\"\"\n        Compute a matrix of counts with a shape of (genes, variant\n        classifications).\n\n        This method only considers the nine nonsynonymous variant\n        classifications.\n\n        Parameters\n        ----------\n        mode : {'variants', 'samples'}, default: 'variants'\n            Determines how to identify top mutated genes:\n\n            * 'variants': Count the number of observed variants.\n            * 'samples': Count the number of affected samples. Using this\n              option will create an additional variant classification called\n              'Multi_Hit'.\n\n        count : int, default: 10\n            Number of top mutated genes to include.\n\n        Returns\n        -------\n        pandas.DataFrame\n            The said matrix.\n        \"\"\"\n        if mode == 'variants':\n            df = self.df[self.df.Variant_Classification.isin(NONSYN_NAMES)]\n            df = df.groupby('Hugo_Symbol')[\n                'Variant_Classification'].value_counts().to_frame()\n            df.columns = ['Count']\n            df = df.reset_index()\n            df = df.pivot(index='Hugo_Symbol', columns='Variant_Classification',\n                values='Count')\n            df = df.fillna(0)\n            for varcls in NONSYN_NAMES:\n                if varcls not in df.columns:\n                    df[varcls] = 0\n            i = df.sum(axis=1).sort_values(ascending=False).index\n            df = df.reindex(index=i)\n            df = df[NONSYN_NAMES]\n            df = df[:count]\n            df = df.rename_axis(None, axis=1)\n        elif mode == 'samples':\n            df = self.matrix_waterfall(count)\n            df = df.apply(lambda r: r.value_counts(), axis=1)\n            for varcls in NONSYN_NAMES + ['Multi_Hit']:\n                if varcls not in df.columns:\n                    df[varcls] = np.nan\n            df = df[NONSYN_NAMES + ['Multi_Hit']]\n            df = df.fillna(0)\n        else:\n            raise ValueError(f'Found incorrect mode: {mode}')\n        return df\n\n    def matrix_tmb(self):\n        \"\"\"\n        Compute a matrix of variant counts with a shape of (samples, variant\n        classifications).\n\n        Returns\n        -------\n        pandas.DataFrame\n            The said matrix.\n        \"\"\"\n        df = self.df[self.df.Variant_Classification.isin(NONSYN_NAMES)]\n        df = df.groupby('Tumor_Sample_Barcode')[\n            'Variant_Classification'].value_counts().to_frame()\n        df.columns = ['Count']\n        df = df.reset_index()\n        df = df.pivot(index='Tumor_Sample_Barcode',\n            columns='Variant_Classification', values='Count')\n        df = df.fillna(0)\n        for varcls in NONSYN_NAMES:\n            if varcls not in df.columns:\n                df[varcls] = 0\n        i = df.sum(axis=1).sort_values(ascending=False).index\n        df = df.reindex(index=i)\n        df = df[NONSYN_NAMES]\n        df = df.rename_axis(None, axis=1)\n        return df\n\n    def matrix_waterfall(self, count=10, keep_empty=False):\n        \"\"\"\n        Compute a matrix of variant classifications with a shape of\n        (genes, samples).\n\n        If there are multiple variant classifications available for a given\n        cell, they will be replaced as 'Multi_Hit'.\n\n        Parameters\n        ----------\n        count : int, default: 10\n            Number of top mutated genes to include.\n        keep_empty : bool, default: False\n            If True, keep samples with all ``NaN``'s.\n\n        Returns\n        -------\n        pandas.DataFrame\n            The said matrix.\n        \"\"\"\n        df = self.df[self.df.Variant_Classification.isin(NONSYN_NAMES)]\n\n        f = lambda x: ''.join(x) if len(x) == 1 else 'Multi_Hit'\n        df = df.groupby(['Hugo_Symbol', 'Tumor_Sample_Barcode'])[\n            'Variant_Classification'].apply(f).to_frame()\n        df = df.reset_index()\n        df = df.pivot(index='Hugo_Symbol', columns='Tumor_Sample_Barcode',\n            values='Variant_Classification')\n\n        # Sort the rows (genes).\n        i = df.isnull().sum(axis=1).sort_values(ascending=True).index\n        df = df.reindex(index=i)\n\n        # Select the top mutated genes.\n        df = df[:count]\n\n        # Drop samples with all NaN's.\n        if not keep_empty:\n            df = df.dropna(axis=1, how='all')\n\n        # Sort the columns (samples).\n        c = df.applymap(lambda x: 0 if pd.isnull(x) else 1).sort_values(\n            df.index.to_list(), axis=1, ascending=False).columns\n        df = df[c]\n        df = df.fillna('None')\n        df = df.rename_axis(None, axis=1)\n\n        return df\n\n    def plot_genes(\n        self, mode='variants', count=10, flip=False, ax=None, figsize=None,\n        **kwargs\n    ):\n        \"\"\"\n        Create a bar plot showing variant distirbution for top mutated genes.\n\n        Parameters\n        ----------\n        mode : {'variants', 'samples'}, default: 'variants'\n            Determines how to identify top mutated genes:\n\n            * 'variants': Count the number of observed variants.\n            * 'samples': Count the number of affected samples. Using this\n              option will create an additional variant classification called\n              'Multi_Hit'.\n        count : int, default: 10\n            Number of top mutated genes to display.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`pandas.DataFrame.plot.bar` or\n            :meth:`pandas.DataFrame.plot.barh`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n        By default (``mode='variants'``), the method identifies top mutated\n        genes by counting the number of observed variants:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_genes()\n            >>> plt.tight_layout()\n\n        We can also identify top mutated genes by counting the number of\n        affected samples:\n\n        .. plot::\n            :context: close-figs\n\n            >>> mf.plot_genes(mode='samples')\n            >>> plt.tight_layout()\n        \"\"\"\n        if mode == 'variants':\n            colors = NONSYN_COLORS\n        elif mode == 'samples':\n            colors = NONSYN_COLORS + ['k']\n        else:\n            raise ValueError(f'Found incorrect mode: {mode}')\n        df = self.matrix_genes(count=count, mode=mode)\n        df = df.iloc[::-1]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            df = df.iloc[::-1]\n            kind = 'bar'\n            xlabel, ylabel = '', 'Count'\n        else:\n            kind = 'barh'\n            xlabel, ylabel = 'Count', ''\n\n        df.plot(\n            kind=kind, ax=ax, stacked=True, legend=False,\n            color=colors, **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_oncoplot(\n        self, count=10, keep_empty=False, figsize=(15, 10), label_fontsize=15,\n        ticklabels_fontsize=15, legend_fontsize=15\n    ):\n        \"\"\"\n        Create an oncoplot.\n\n        See this :ref:`tutorial <tutorials:Create customized oncoplots>` to\n        learn how to create customized oncoplots.\n\n        Parameters\n        ----------\n        count : int, default: 10\n            Number of top mutated genes to display.\n        keep_empty : bool, default: False\n            If True, display samples that do not have any mutations.\n        figsize : tuple, default: (15, 10)\n            Width, height in inches. Format: (float, float).\n        label_fontsize : float, default: 15\n            Font size of labels.\n        ticklabels_fontsize : float, default: 15\n            Font size of tick labels.\n        legend_fontsize : float, default: 15\n            Font size of legend texts.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_oncoplot()\n        \"\"\"\n        g = {'height_ratios': [1, 10, 1], 'width_ratios': [10, 1]}\n        fig, axes = plt.subplots(3, 2, figsize=figsize, gridspec_kw=g)\n        [[ax1, ax2], [ax3, ax4], [ax5, ax6]] = axes\n\n        # Create the TMB plot.\n        samples = list(self.matrix_waterfall(count=count,\n            keep_empty=keep_empty).columns)\n        self.plot_tmb(ax=ax1, samples=samples, width=0.95)\n        ax1.set_xlabel('')\n        ax1.spines['right'].set_visible(False)\n        ax1.spines['top'].set_visible(False)\n        ax1.spines['bottom'].set_visible(False)\n        ax1.set_xlim(-0.5, len(samples)-0.5)\n        ax1.set_ylabel('TMB', fontsize=label_fontsize)\n        ax1.set_yticks([0, self.matrix_tmb().sum(axis=1).max()])\n        ax1.tick_params(axis='y', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Remove the top right plot.\n        ax2.remove()\n\n        # Create the waterfall plot.\n        self.plot_waterfall(count=count, ax=ax3, linewidths=1, keep_empty=keep_empty)\n        ax3.set_xlabel('')\n        ax3.tick_params(axis='y', which='major', labelrotation=0,\n                        labelsize=ticklabels_fontsize)\n\n        # Create the genes plot.\n        self.plot_genes(count=count, ax=ax4, mode='samples', width=0.95)\n        ax4.spines['right'].set_visible(False)\n        ax4.spines['left'].set_visible(False)\n        ax4.spines['top'].set_visible(False)\n        ax4.set_yticks([])\n        ax4.set_xlabel('Samples', fontsize=label_fontsize)\n        ax4.set_xticks([0, self.matrix_genes(\n            count=10, mode='samples').sum(axis=1).max()])\n        ax4.set_ylim(-0.5, count-0.5)\n        ax4.tick_params(axis='x', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Create the legend.\n        handles = common.legend_handles(NONSYN_NAMES+['Multi_Hit'],\n            colors=NONSYN_COLORS+['k'])\n        ax5.legend(\n            handles=handles,\n            title='Variant_Classification',\n            loc='upper center',\n            ncol=4,\n            fontsize=legend_fontsize,\n            title_fontsize=legend_fontsize\n        )\n        ax5.axis('off')\n\n        # Remove the bottom right plot.\n        ax6.remove()\n\n        plt.tight_layout()\n        plt.subplots_adjust(wspace=0.01, hspace=0.01)\n\n    def plot_oncoplot_matched(\n        self, af, patient_col, group_col, group_order, colors='Set2',\n        figsize=(15, 10), label_fontsize=12, ticklabels_fontsize=12,\n        legend_fontsize=12\n    ):\n        \"\"\"\n        Create an oncoplot for mached samples.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        patient_col : str\n            AnnFrame column containing patient information.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        colors : str\n            Colormap name for the sample groups.\n        figsize : tuple, default: (15, 10)\n            Width, height in inches. Format: (float, float).\n        label_fontsize : float, default: 12\n            Font size of labels.\n        ticklabels_fontsize : float, default: 12\n            Font size of tick labels.\n        legend_fontsize : float, default: 12\n            Font size of legend texts.\n        \"\"\"\n        fig, axes = plt.subplots(3, 2, figsize=figsize,\n            gridspec_kw={'height_ratios': [1, 10, 1.5], 'width_ratios': [10, 1]}\n        )\n\n        [[ax1, ax2], [ax3, ax4], [ax5, ax6]] = axes\n\n        patients = self.matrix_waterfall_matched(af, patient_col, group_col, group_order).columns\n\n        self.plot_tmb_matched(\n            af, patient_col, group_col, group_order=group_order, ax=ax1,\n            legend=False, patients=patients, width=0.90,\n            color=sns.color_palette(colors)[:3]\n        )\n        ax1.set_xticks([])\n        ax1.set_xlim(-0.5, 53-0.5)\n        ax1.spines['right'].set_visible(False)\n        ax1.spines['top'].set_visible(False)\n        ax1.spines['bottom'].set_visible(False)\n        ax1.set_ylabel('TMB', fontsize=label_fontsize)\n        ax1.tick_params(axis='y', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        ax2.remove()\n\n        self.plot_waterfall_matched(af, patient_col, group_col, group_order=group_order, ax=ax3)\n        ax3.set_xticks([])\n        ax3.tick_params(axis='y', which='major', labelrotation=0,\n                        labelsize=ticklabels_fontsize)\n\n        self.plot_mutated_matched(\n            af, patient_col, group_col, group_order=group_order, ax=ax4, palette=colors\n        )\n        ax4.set_yticks([])\n        ax4.legend().remove()\n        ax4.spines['right'].set_visible(False)\n        ax4.spines['left'].set_visible(False)\n        ax4.spines['top'].set_visible(False)\n        ax4.tick_params(axis='x', which='major',\n                        labelsize=ticklabels_fontsize)\n        ax4.set_xlabel('Patients', fontsize=label_fontsize)\n\n        # Create the legends.\n        handles1 = common.legend_handles(NONSYN_NAMES+['Multi_Hit'],\n            colors=NONSYN_COLORS+['k'])\n        handles2 = common.legend_handles(group_order, colors=colors)\n        leg1 = ax5.legend(handles=handles1, loc=(0, 0), title='Variant_Classification', ncol=4, fontsize=legend_fontsize, title_fontsize=legend_fontsize)\n        leg2 = ax5.legend(handles=handles2, loc=(0.8, 0), title=group_col, fontsize=legend_fontsize, title_fontsize=legend_fontsize)\n        ax5.add_artist(leg1)\n        ax5.add_artist(leg2)\n        ax5.axis('off')\n\n        # Remove the bottom right plot.\n        ax6.remove()\n\n        plt.tight_layout()\n        plt.subplots_adjust(wspace=0.01, hspace=0.01)\n\n    def plot_clonality(\n        self, vaf_col, af=None, group_col=None, group_order=None, count=10,\n        threshold=0.25, subclonal=False, ax=None, figsize=None\n    ):\n        \"\"\"\n        Create a bar plot summarizing the clonality of variants in top\n        mutated genes.\n\n        Clonality will be calculated based on VAF using\n        :meth:`MafFrame.compute_clonality`.\n\n        Parameters\n        ----------\n        vaf_col : str\n            MafFrame column containing VAF data.\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        count : int, defualt: 10\n            Number of top mutated genes to display.\n        threshold : float, default: 0.25\n            VAF threshold percentage.\n        subclonal : bool, default: False\n            If True, display subclonality (1 - clonality).\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        See Also\n        --------\n        MafFrame.compute_clonality\n            Compute the clonality of variants based on VAF.\n\n        Examples\n        --------\n\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_clonality('i_TumorVAF_WU')\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_clonality('i_TumorVAF_WU',\n            ...                   af=af,\n            ...                   group_col='FAB_classification',\n            ...                   group_order=['M0', 'M1', 'M2'])\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.df.copy()\n        df['Clonality'] = self.compute_clonality(vaf_col, threshold=threshold)\n\n        if group_col is None:\n            s = df.groupby('Hugo_Symbol')['Clonality'].value_counts()\n            s.name = 'Count'\n            df = s.to_frame().reset_index()\n            df = df.pivot(index='Hugo_Symbol', columns='Clonality', values='Count')\n        else:\n            df = df.merge(af.df[group_col], left_on='Tumor_Sample_Barcode', right_index=True)\n            s = df.groupby(['Hugo_Symbol', group_col])['Clonality'].value_counts()\n            s.name = 'Count'\n            df = s.to_frame().reset_index()\n            df = df.pivot(index=['Hugo_Symbol', group_col], columns='Clonality', values='Count')\n\n        df = df.reset_index()\n        df = df.fillna(0)\n        l = ['Clonal', 'Subclonal']\n        df[l] = df[l].div(df[l].sum(axis=1), axis=0)\n        genes = self.matrix_genes(count=count).index\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if subclonal:\n            y = 'Subclonal'\n        else:\n            y = 'Clonal'\n\n        sns.barplot(\n            x='Hugo_Symbol', y=y, data=df, order=genes, hue=group_col,\n            hue_order=group_order, ax=ax\n        )\n\n        ax.set_xlabel('')\n\n        return ax\n\n    def plot_evolution(\n        self, samples, vaf_col, anchor=None, normalize=True, count=5,\n        ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a line plot visualizing changes in VAF between specified\n        samples.\n\n        Parameters\n        ----------\n        samples : list\n            List of samples to display.\n        vaf_col : str\n            MafFrame column containing VAF data.\n        anchor : str, optional\n            Sample to use as the anchor. If absent, use the first sample in\n            the list.\n        normalize : bool, default: True\n            If False, do not normalize VAF by the maximum value.\n        count : int, default: 5\n            Number of top variants to display.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.lineplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        \"\"\"\n        df = self.df[self.df.Tumor_Sample_Barcode.isin(samples)]\n\n        if df.empty:\n            message = f'No variants to display for the samples: {samples}.'\n            raise ValueError(message)\n\n        df = df[df.Variant_Classification.isin(NONSYN_NAMES)]\n\n        def one_row(r):\n            if r.Protein_Change == '.':\n                variant_name = f'{r.Hugo_Symbol} ({r.Variant_Classification})'\n            else:\n                variant_name = f'{r.Hugo_Symbol} ({r.Protein_Change})'\n            return variant_name\n\n        df['Variant_Name'] = df.apply(one_row, axis=1)\n        df = df.pivot(index=['Variant_Name'],\n            columns=['Tumor_Sample_Barcode'], values=[vaf_col])\n        df.columns = df.columns.get_level_values(1)\n        df.columns.name = ''\n        df = df.fillna(0)\n\n        for sample in samples:\n            if sample not in df.columns:\n                df[sample] = 0\n\n        df = df[samples]\n\n        if anchor is None:\n            anchor = samples[0]\n\n        df = df.sort_values(by=anchor, ascending=False)\n        if normalize:\n            df = df \/ df.max()\n        df = df.fillna(0)\n        df = df.iloc[:count, :].T\n        df = df.loc[samples]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.lineplot(data=df, ax=ax, **kwargs)\n\n        ax.set_ylabel('Fraction')\n\n        return ax\n\n    def plot_genepair(\n        self, x, y, vaf_col, af=None, group_col=None, group_order=None,\n        ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a scatter plot of VAF between Gene X and Gene Y.\n\n        Parameters\n        ----------\n        x, y : str\n            Gene names.\n        vaf_col : str\n            MafFrame column containing VAF data.\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.scatterplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> import seaborn as sns\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_genepair('DNMT3A', 'FLT3', 'i_TumorVAF_WU')\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_genepair('DNMT3A', 'FLT3', 'i_TumorVAF_WU',\n            ...                  af=af,\n            ...                  group_col='FAB_classification')\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.df[self.df.Hugo_Symbol.isin([x, y])]\n        df = df[['Tumor_Sample_Barcode', 'Hugo_Symbol', vaf_col]]\n        df = df.sort_values(vaf_col, ascending=False)\n        df = df.drop_duplicates(subset=['Tumor_Sample_Barcode', 'Hugo_Symbol'])\n        df = df.pivot(index='Tumor_Sample_Barcode',\n            columns='Hugo_Symbol', values=vaf_col)\n        df = df.fillna(0)\n\n        if group_col is not None:\n            df = df.merge(af.df[group_col], left_index=True, right_index=True)\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.scatterplot(\n            x=x, y=y, data=df, ax=ax, hue=group_col, hue_order=group_order,\n            **kwargs\n        )\n\n        # Print summary statistics including R-squared and p-value.\n        results = smf.ols(f'{y} ~ {x}', data=df).fit()\n        print(f'Results for {y} ~ {x}:')\n        print(f'R^2 = {results.rsquared:.2f}')\n        print(f'  P = {results.f_pvalue:.2e}')\n\n        return ax\n\n    def plot_regplot(\n        self, af, group_col, a, b, a_size=None, b_size=None, genes=None,\n        count=10, to_csv=None, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a scatter plot with a linear regression model fit visualizing\n        correlation between gene mutation frequencies in two sample groups\n        A and B.\n\n        Each point in the plot represents a gene.\n\n        The method will automatically calculate and print summary statistics\n        including R-squared and p-value.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        group_col : str\n            AnnFrame column containing sample group information.\n        a, b : str\n            Sample group names.\n        a_size, b_size : int, optional\n            Sample group sizes to use as denominator. By default, these are\n            inferred from the MafFrame and AnnFrame objects.\n        genes : list, optional\n            Genes to display. When absent, top mutated genes (``count``) will\n            be used.\n        count : int, defualt: 10\n            Number of top mutated genes to display. Ignored if ``genes`` is\n            specified.\n        to_csv : str, optional\n            Write the plot's data to a CSV file.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.regplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_regplot(af, 'FAB_classification', 'M1', 'M2')\n            Results for M2 ~ M1:\n            R^2 = 0.43\n              P = 3.96e-02\n            >>> plt.tight_layout()\n        \"\"\"\n        df1 = self.matrix_prevalence()\n        df2 = af.df[af.df.index.isin(df1.columns)]\n        i_a = df2[df2[group_col] == a].index\n        i_b = df2[df2[group_col] == b].index\n\n        # Determine which genes to display.\n        if genes is None:\n            genes = self.matrix_genes(count=count).index.to_list()\n\n        # Determine each group's sample size.\n        if a_size is None:\n            a_size = len(i_a)\n        if b_size is None:\n            b_size = len(i_b)\n\n        f = lambda x: 0 if x == 0 else 1\n        s_a = df1.T.loc[i_a].applymap(f).sum().loc[genes] \/ a_size\n        s_b = df1.T.loc[i_b].applymap(f).sum().loc[genes] \/ b_size\n        df3 = pd.concat([s_a, s_b], axis=1)\n        df3.columns = [a, b]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        # Draw the main plot.\n        sns.regplot(x=a, y=b, data=df3, ax=ax, **kwargs)\n\n        # Write the DataFrame to a CSV file.\n        if to_csv is not None:\n            df3.to_csv(to_csv)\n\n        # Print summary statistics including R-squared and p-value.\n        results = smf.ols(f'{b} ~ {a}', data=df3).fit()\n        print(f'Results for {b} ~ {a}:')\n        print(f'R^2 = {results.rsquared:.2f}')\n        print(f'  P = {results.f_pvalue:.2e}')\n\n        return ax\n\n    def plot_interactions(\n        self, count=10, cmap=None, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a heatmap representing mutually exclusive or co-occurring set\n        of genes.\n\n        This method performs pair-wise Fisher’s Exact test to detect such\n        significant pair of genes.\n\n        Parameters\n        ----------\n        count : int, defualt: 10\n            Number of top mutated genes to display.\n        cmap : str, optional\n            Color map.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.heatmap`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_interactions(count=25, cmap='BrBG')\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.matrix_prevalence()\n        genes = self.matrix_genes(count=count, mode='samples').index.to_list()\n        df = df.loc[genes]\n        df = df.applymap(lambda x: True if x else False)\n        df = df.T\n        pairs = list(itertools.combinations(genes, 2))\n        data = []\n\n        def one_pair(a, b):\n            s_a = df[a].to_list()\n            s_b = df[b].to_list()\n            ab = 0\n            AB = 0\n            aB = 0\n            Ab = 0\n            for i in range(len(s_a)):\n                if s_a[i] and s_b[i]:\n                    AB += 1\n                elif s_a[i] and not s_b[i]:\n                    Ab += 1\n                elif not s_a[i] and s_b[i]:\n                    aB += 1\n                else:\n                    ab += 1\n            return (ab, AB, aB, Ab)\n\n        for pair in pairs:\n            a = pair[0]\n            b = pair[1]\n            ab, AB, aB, Ab = one_pair(a, b)\n            event = 'Co_Occurence' if AB else 'Mutually_Exclusive'\n            data.append([a, b, ab, AB, aB, Ab, event])\n\n        df = pd.DataFrame(data,\n            columns=['A', 'B', 'ab', 'AB', 'aB', 'Ab', 'Event'])\n\n        def one_row(r):\n            oddsr, p = fisher_exact([[r.AB, r.aB], [r.Ab, r.ab]],\n                alternative='two-sided')\n            return pd.Series([oddsr, p], index=['Odds_Ratio', 'P_Value'])\n\n        df = pd.concat([df.apply(one_row, axis=1), df], axis=1)\n        df = df.sort_values('P_Value')\n\n        def one_row(r):\n            r['Log_P_Value'] = -np.log10(r.P_Value)\n            if r.P_Value < 0.05:\n                r['Label'] = '*'\n            elif r.P_Value < 0.1:\n                r['Label'] = '.'\n            else:\n                r['Label'] = ''\n            if r.Event == 'Mutually_Exclusive':\n                r.Log_P_Value *= -1\n            return r\n\n        df = df.apply(one_row, axis=1)\n\n        annot = df.pivot(index='A', columns='B', values='Label')\n        annot = annot.fillna('')\n\n        df = df.pivot(index='A', columns='B', values='Log_P_Value')\n        df = df.fillna(0)\n\n        for gene in genes:\n            if gene not in df.columns:\n                df[gene] = 0\n            if gene not in annot.columns:\n                annot[gene] = ''\n\n        df = df.T\n        annot = annot.T\n\n        for gene in genes:\n            if gene not in df.columns:\n                df[gene] = 0\n            if gene not in annot.columns:\n                annot[gene] = ''\n\n        annot = annot[genes]\n        annot = annot.loc[genes]\n\n        df = df[genes]\n        df = df.loc[genes]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        # Create a mask for the heatmap.\n        corr = np.corrcoef(np.random.randn(count, 200))\n        mask = np.zeros_like(corr)\n        mask[np.triu_indices_from(mask)] = True\n\n        sns.heatmap(\n            df, annot=annot, fmt='', cmap=cmap, mask=mask, vmax=3, vmin=-3,\n            center=0, ax=ax, **kwargs\n        )\n\n        ax.set_xlabel('')\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_lollipop(\n        self, gene, alpha=0.7, ax=None, figsize=None, legend=True\n    ):\n        \"\"\"\n        Create a lollipop or stem plot showing amino acid changes of a gene.\n\n        Parameters\n        ----------\n        gene : str\n            Name of the gene.\n        alpha : float, default: 0.7\n            Set the color transparency. Must be within the 0-1 range,\n            inclusive.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_lollipop('DNMT3A')\n            >>> plt.tight_layout()\n        \"\"\"\n        # Only select variants from the gene.\n        df1 = self.df[self.df.Hugo_Symbol == gene]\n\n        # Raise an error if there are no SNVs to plot.\n        if df1.empty:\n            raise ValueError(f\"No variants to plot for the gene: '{gene}'.\")\n\n        # Count each amino acid change.\n        df2 = df1.Protein_Change.value_counts().to_frame().reset_index()\n        df2.columns = ['Protein_Change', 'Count']\n\n        # Identify variant classification for each amino acid change.\n        df3 = df1[['Protein_Change', 'Variant_Classification']\n            ].drop_duplicates(subset=['Protein_Change'])\n        df4 = pd.merge(df2, df3, on='Protein_Change')\n\n        # Extract amino acid positions. Sort the counts by position.\n        def one_row(r):\n            digits = [x for x in r.Protein_Change if x.isdigit()]\n            if not digits:\n                return np.nan\n            return int(''.join(digits))\n        df4['Protein_Position'] = df4.apply(one_row, axis=1)\n        df4 = df4.dropna(subset=['Protein_Position'])\n        df4 = df4.sort_values(['Protein_Position'])\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        for i, nonsyn_name in enumerate(NONSYN_NAMES):\n            temp = df4[df4.Variant_Classification == nonsyn_name]\n            color = NONSYN_COLORS[i]\n            ax.vlines(temp.Protein_Position, ymin=0, ymax=temp.Count,\n                alpha=alpha, color=color)\n            ax.plot(temp.Protein_Position, temp.Count, 'o', alpha=alpha,\n                color=color, label=nonsyn_name)\n\n        ax.set_xlabel('Position')\n        ax.set_ylabel('Count')\n\n        if legend:\n            ax.legend()\n\n        return ax\n\n    def plot_mutated(\n        self, af=None, group_col=None, group_order=None, genes=None,\n        count=10, ax=None, figsize=None\n    ):\n        \"\"\"\n        Create a bar plot visualizing the mutation prevalence of top\n        mutated genes.\n\n        Parameters\n        ----------\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        genes : list, optional\n            Genes to display. When absent, top mutated genes (``count``) will\n            be used.\n        count : int, defualt: 10\n            Number of top mutated genes to display. Ignored if ``genes`` is\n            specified.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> import seaborn as sns\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_mutated()\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_mutated(af=af,\n            ...                 group_col='FAB_classification',\n            ...                 group_order=['M0', 'M1', 'M2'])\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.matrix_prevalence()\n\n        # Determine which genes to display.\n        if genes is None:\n            genes = self.matrix_genes(count=count).index.to_list()\n\n        df = df.loc[genes]\n        df = df.applymap(lambda x: True if x else False)\n        if group_col is None:\n            df = (df.sum(axis=1) \/ df.shape[1]).to_frame().reset_index()\n            df.columns.values[1] = 'Prevalence'\n        else:\n            df = df.T\n            df = pd.merge(df, af.df[group_col], left_index=True, right_index=True)\n            df = df.groupby([group_col]).mean().reset_index()\n            df = df.melt(id_vars=[group_col])\n            df.columns = [group_col, 'Hugo_Symbol', 'Prevalence']\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.barplot(\n            x='Hugo_Symbol', y='Prevalence', data=df, hue=group_col,\n            hue_order=group_order, ax=ax\n        )\n\n        ax.set_xlabel('')\n\n        return ax\n\n    def plot_mutated_matched(\n        self, af, patient_col, group_col, group_order, ax=None, figsize=None,\n        **kwargs\n    ):\n        \"\"\"\n        Create a bar plot visualizing the mutation prevalence of top\n        mutated genes.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        patient_col : str\n            AnnFrame column containing patient information.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list\n            List of sample group names.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        \"\"\"\n        df = self.matrix_waterfall_matched(af, patient_col, group_col, group_order)\n        df = df.applymap(lambda x: 0 if x == 'None' else 1)\n        s = df.sum(axis=1) \/ len(df.columns) * 100\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.barplot(\n            x='Count', y='Gene', hue='Group', data=df, hue_order=group_order,\n            orient='h', ax=ax, **kwargs\n        )\n\n        ax.set_xlabel('Patients (%)')\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_rainfall(\n        self, sample, palette=None, legend='auto', ax=None, figsize=None,\n        **kwargs\n    ):\n        \"\"\"\n        Create a rainfall plot visualizing inter-variant distance on a linear\n        genomic scale for single sample.\n\n        Parameters\n        ----------\n        sample : str\n            Name of the sample.\n        palette : str, optional\n            Name of the seaborn palette. See the :ref:`tutorials:Control plot\n            colors` tutorial for details.\n        legend : {'auto', 'brief', 'full', False}, default: 'auto'\n            Display setting of the legend according to\n            :meth:`seaborn.scatterplot`.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.scatterplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> import seaborn as sns\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('brca')\n            >>> maf_file = '~\/fuc-data\/brca\/brca.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_rainfall('TCGA-A8-A08B',\n            ...                  figsize=(14, 7),\n            ...                  palette=sns.color_palette('Set2')[:6])\n            >>> plt.tight_layout()\n        \"\"\"\n        # Select variants from the sample.\n        df = self.df[self.df.Tumor_Sample_Barcode == sample]\n\n        # Remove indels.\n        df = df[df.Variant_Type == 'SNP']\n\n        # Raise an error if there are no SNVs to plot.\n        if df.empty:\n            message = (\n                'There are no SNVs to be drawn '\n                f\"for the sample: '{sample}'.\"\n            )\n            raise ValueError(message)\n\n        # Get SNV class for each variant.\n        def one_row(r):\n            change = r.Reference_Allele + '>' + r.Tumor_Seq_Allele2\n            return SNV_CLASSES[change]['class']\n        df['SNV_Class'] = df.apply(one_row, axis=1)\n\n        # Convert string chromosomes to integers for ordering.\n        def one_row(r):\n            r.Chromosome = int(r.Chromosome.replace(\n                'chr', '').replace('X', '23').replace('Y', '24'))\n            return r\n        df = df.apply(one_row, axis=1)\n        df = df[['Chromosome', 'Start_Position', 'SNV_Class']]\n        df = df.sort_values(['Chromosome', 'Start_Position'])\n\n        # Update positions as if all chromosomes are one long molecule.\n        def one_row(r):\n            if r.Chromosome == 1:\n                return r\n            r.Start_Position += sum(CHROM_LENGTHS['hg19'][:r.Chromosome-1])\n            return r\n        df = df.apply(one_row, axis=1)\n        s = np.diff(df.Start_Position)\n        s = np.insert(s, 0, 0)\n        s = np.log10(s + 1)\n        df['Interevent_Distance'] = s\n        df = df.reset_index(drop=True)\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        bounds = [0] + df.drop_duplicates(subset=['Chromosome'],\n            keep='last').index.to_list()\n\n        xticks = []\n        for i, bound in enumerate(bounds):\n            if i == 0:\n                continue\n            elif i == 1:\n                xticks.append(bound \/ 2)\n            else:\n                xticks.append(bounds[i-1] + (bound - bounds[i-1]) \/ 2)\n\n        for bound in bounds:\n            ax.axvline(x=bound, color='lightgray', zorder=1)\n\n        sns.scatterplot(\n            x=df.index, y='Interevent_Distance', data=df, hue='SNV_Class',\n            hue_order=SNV_CLASS_ORDER, palette=palette, ax=ax, legend=legend,\n            zorder=2, **kwargs\n        )\n\n        ax.set_xlabel('Chromosomes')\n        ax.set_ylabel('Interevent distance')\n        ax.set_xticks(xticks)\n        ax.set_xticklabels(['X' if x == 23 else 'Y' if x == 24 else x\n            for x in df.Chromosome.unique()])\n\n        return ax\n\n    def plot_snvclsc(\n        self, af=None, group_col=None, group_order=None, palette=None,\n        flip=False, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a bar plot summarizing the count distrubtions of the six\n        :ref:`glossary:SNV classes` for all samples.\n\n        A grouped bar plot can be created with ``group_col`` (requires an AnnFrame).\n\n        Parameters\n        ----------\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        palette : str, optional\n            Name of the seaborn palette. See the :ref:`tutorials:Control plot\n            colors` tutorial for details.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        See Also\n        --------\n        MafFrame.plot_snvclsp\n            Create a box plot summarizing the proportion distrubtions of\n            the six :ref:`glossary:SNV classes` for all sample.\n        MafFrame.plot_snvclss\n            Create a bar plot showing the proportions of the six\n            :ref:`glossary:SNV classes` for individual samples.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> import seaborn as sns\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_snvclsc(palette=sns.color_palette('Dark2'))\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_snvclsc(af=af,\n            ...                 group_col='FAB_classification',\n            ...                 group_order=['M0', 'M1', 'M2'])\n            >>> plt.tight_layout()\n        \"\"\"\n        # Add the SNV_Class column.\n        df = self.df[self.df.Variant_Type == 'SNP']\n        def one_row(r):\n            change = r.Reference_Allele + '>' + r.Tumor_Seq_Allele2\n            return SNV_CLASSES[change]['class']\n        s = df.apply(one_row, axis=1)\n        s.name = 'SNV_Class'\n        df = pd.concat([df, s], axis=1)\n\n        # Count the occurance of each SNV class.\n        if group_col is not None:\n            df = pd.merge(df, af.df[group_col], left_on='Tumor_Sample_Barcode',\n                right_index=True)\n            s = df.groupby([group_col]).SNV_Class.value_counts()\n            df = s.to_frame().rename(columns={'SNV_Class': 'Count'}\n                ).reset_index()\n        else:\n            s = df.SNV_Class.value_counts()\n            df = s.to_frame().reset_index()\n            df.columns = ['SNV_Class', 'Count']\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = 'Count', 'SNV_Class'\n            xlabel, ylabel = 'Count', ''\n        else:\n            x, y = 'SNV_Class', 'Count'\n            xlabel, ylabel = '', 'Count'\n\n        sns.barplot(\n            x=x, y=y, data=df, ax=ax, hue=group_col, hue_order=group_order,\n            palette=palette, order=SNV_CLASS_ORDER, **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_snvclsp(\n        self, af=None, group_col=None, group_order=None, palette=None, flip=False,\n        ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a box plot summarizing the proportion distrubtions of the six\n        :ref:`glossary:SNV classes` for all sample.\n\n        Parameters\n        ----------\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        palette : str, optional\n            Name of the seaborn palette. See the :ref:`tutorials:Control plot\n            colors` tutorial for details.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.boxplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        See Also\n        --------\n        MafFrame.plot_snvclsc\n            Create a bar plot summarizing the count distrubtions of the six\n            :ref:`glossary:SNV classes` for all samples.\n        MafFrame.plot_snvclss\n            Create a bar plot showing the proportions of the six\n            :ref:`glossary:SNV classes` for individual samples.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> import seaborn as sns\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_snvclsp(palette=sns.color_palette('Set2'))\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_snvclsp(af=af,\n            ...                 group_col='FAB_classification',\n            ...                 group_order=['M0', 'M1', 'M2'])\n            >>> plt.tight_layout()\n        \"\"\"\n        # Add the SNV_Class column.\n        df = self.df[self.df.Variant_Type == 'SNP']\n        def one_row(r):\n            change = r.Reference_Allele + '>' + r.Tumor_Seq_Allele2\n            return SNV_CLASSES[change]['class']\n        s = df.apply(one_row, axis=1)\n        s.name = 'SNV_Class'\n        df = pd.concat([df, s], axis=1)\n\n        # Compute the proportions of SNV classes in each sample.\n        s = df.groupby('Tumor_Sample_Barcode')['SNV_Class'].value_counts()\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n        df = df.pivot(index='Tumor_Sample_Barcode', columns='SNV_Class')\n        df = df.fillna(0)\n        df = df.apply(lambda r: r\/r.sum(), axis=1)\n        df.columns = df.columns.get_level_values(1)\n        df.columns.name = ''\n\n        if group_col is None:\n            df = pd.melt(df, var_name='SNV_Class', value_name='Proportion')\n        else:\n            df = pd.merge(df, af.df[group_col], left_index=True, right_index=True)\n            df = pd.melt(df, id_vars=[group_col], var_name='SNV_Class',\n                value_name='Proportion')\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = 'Proportion', 'SNV_Class'\n            xlabel, ylabel = 'Proportion', ''\n        else:\n            x, y = 'SNV_Class', 'Proportion'\n            xlabel, ylabel = '', 'Proportion'\n\n        sns.boxplot(\n            x=x, y=y, data=df, hue=group_col, hue_order=group_order,\n            palette=palette, ax=ax, **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_snvclss(\n        self, samples=None, color=None, colormap=None, width=0.8,\n        legend=True, flip=False, to_csv=None, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a bar plot showing the proportions of the six\n        :ref:`glossary:SNV classes` for individual samples.\n\n        Parameters\n        ----------\n        samples : list, optional\n            List of samples to display (in that order too). If samples that\n            are absent in the MafFrame are provided, the method will give a\n            warning but still draw an empty bar for those samples.\n        color : list, optional\n            List of color tuples. See the :ref:`tutorials:Control plot\n            colors` tutorial for details.\n        colormap : str or matplotlib colormap object, optional\n            Colormap to select colors from. See the :ref:`tutorials:Control\n            plot colors` tutorial for details.\n        width : float, default: 0.8\n            The width of the bars.\n        legend : bool, default: True\n            Place legend on axis subplots.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        to_csv : str, optional\n            Write the plot's data to a CSV file.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`pandas.DataFrame.plot.bar` or\n            :meth:`pandas.DataFrame.plot.barh`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        See Also\n        --------\n        MafFrame.plot_snvclsc\n            Create a bar plot summarizing the count distrubtions of the six\n            :ref:`glossary:SNV classes` for all samples.\n        MafFrame.plot_snvclsp\n            Create a box plot summarizing the proportion distrubtions of\n            the six :ref:`glossary:SNV classes` for all sample.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> ax = mf.plot_snvclss(width=1, color=plt.get_cmap('Set2').colors)\n            >>> ax.legend(loc='upper right')\n            >>> plt.tight_layout()\n        \"\"\"\n        # Add the SNV_Class column.\n        df = self.df[self.df.Variant_Type == 'SNP']\n        def one_row(r):\n            change = r.Reference_Allele + '>' + r.Tumor_Seq_Allele2\n            return SNV_CLASSES[change]['class']\n        s = df.apply(one_row, axis=1)\n        s.name = 'SNV_Class'\n        df = pd.concat([df, s], axis=1)\n\n        # Compute the proportions of SNV classes in each sample.\n        s = df.groupby('Tumor_Sample_Barcode')['SNV_Class'].value_counts()\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n        df = df.pivot(index='Tumor_Sample_Barcode', columns='SNV_Class')\n        df = df.fillna(0)\n        df = df.apply(lambda r: r\/r.sum(), axis=1)\n        df.columns = df.columns.get_level_values(1)\n        df.columns.name = ''\n        for x in SNV_CLASS_ORDER:\n            if x not in df.columns:\n                df[x] = 0\n        df = df[SNV_CLASS_ORDER]\n\n        # Determine which samples should be displayed.\n        if samples is not None:\n            missing_samples = []\n            missing_data = []\n            for sample in samples:\n                if sample not in df.index:\n                    missing_samples.append(sample)\n                    missing_data.append([0] * 6)\n            if missing_samples:\n                message = (\n                    'Although the following samples are absent in the '\n                    'MafFrame, they will still be displayed as empty bar: '\n                    f'{missing_samples}.'\n                )\n                warnings.warn(message)\n                temp = pd.DataFrame(missing_data)\n                temp.index = missing_samples\n                temp.columns = SNV_CLASS_ORDER\n                df = pd.concat([df, temp]).loc[samples]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            kind = 'barh'\n            xlabel, ylabel = 'Proportion', 'Samples'\n        else:\n            kind = 'bar'\n            xlabel, ylabel = 'Samples', 'Proportion'\n\n        df.plot(\n            kind=kind, ax=ax, stacked=True, legend=legend, width=width,\n            color=color, colormap=colormap, **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        if flip:\n            ax.set_yticks([])\n        else:\n            ax.set_xticks([])\n\n        # Write the DataFrame to a CSV file.\n        if to_csv is not None:\n            df.to_csv(to_csv)\n\n        return ax\n\n    def plot_titv(\n        self, af=None, group_col=None, group_order=None, flip=False, ax=None,\n        figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a box plot showing the :ref:`Ti\/Tv <glossary:Transitions (Ti)\n        and transversions (Tv)>` proportions of samples.\n\n        Parameters\n        ----------\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.boxplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        See Also\n        --------\n        fuc.api.pyvcf.VcfFrame.plot_titv\n            Similar method for the :class:`fuc.api.pyvcf.VcfFrame` class.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_titv()\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_titv(af=af,\n            ...              group_col='FAB_classification',\n            ...              group_order=['M0', 'M1', 'M2'])\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.df[self.df.Variant_Type == 'SNP']\n        def one_row(r):\n            change = r.Reference_Allele + '>' + r.Tumor_Seq_Allele2\n            return SNV_CLASSES[change]['type']\n        s = df.apply(one_row, axis=1)\n        s.name = 'SNV_Type'\n        df = pd.concat([df, s], axis=1)\n        s = df.groupby('Tumor_Sample_Barcode')['SNV_Type'].value_counts()\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n        df = df.pivot(index='Tumor_Sample_Barcode', columns='SNV_Type')\n\n        df = df.fillna(0)\n        df = df.apply(lambda r: r\/r.sum(), axis=1)\n        df.columns = df.columns.get_level_values(1)\n        df.columns.name = ''\n\n        if group_col is not None:\n            df = pd.merge(df, af.df[group_col], left_index=True, right_index=True)\n            df = df.reset_index(drop=True)\n            df = df.set_index(group_col)\n            df = pd.melt(df, var_name='SNV_Type', value_name='Proportion',\n                ignore_index=False)\n            df = df.reset_index()\n        else:\n            df = pd.melt(df, var_name='SNV_Type', value_name='Proportion')\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = 'Proportion', 'SNV_Type'\n            xlabel, ylabel = 'Proportion', ''\n        else:\n            x, y = 'SNV_Type', 'Proportion'\n            xlabel, ylabel = '', 'Proportion'\n\n        sns.boxplot(\n            x=x, y=y, data=df, hue=group_col, hue_order=group_order, ax=ax,\n            **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_summary(\n        self, figsize=(15, 10), title_fontsize=16, ticklabels_fontsize=12,\n        legend_fontsize=12\n\n    ):\n        \"\"\"Create a summary figure for MafFrame.\n\n        Parameters\n        ----------\n        figsize : tuple, default: (15, 10)\n            Width, height in inches. Format: (float, float).\n        title_fontsize : float, default: 16\n            Font size of subplot titles.\n        ticklabels_fontsize : float, default: 12\n            Font size of tick labels.\n        legend_fontsize : float, default: 12\n            Font size of legend texts.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_summary()\n        \"\"\"\n        g = {'height_ratios': [10, 10, 1]}\n        fig, axes = plt.subplots(3, 3, figsize=figsize, gridspec_kw=g)\n        [[ax1, ax2, ax3], [ax4, ax5, ax6], [ax7, ax8, ax9]] = axes\n        gs = axes[2, 0].get_gridspec()\n        for ax in axes[2, :]:\n            ax.remove()\n        axbig = fig.add_subplot(gs[2, :])\n\n        # Create the 'Variant classification (variants)' figure.\n        self.plot_varcls(ax=ax1)\n        ax1.set_yticks([])\n        ax1.set_title('Variant classification (variants)',\n                      fontsize=title_fontsize)\n        ax1.set_xlabel('')\n        ax1.tick_params(axis='x', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Create the 'Variant type' figure.\n        self.plot_vartype(ax=ax2, palette='Pastel1', flip=True)\n        ax2.set_title('Variant type', fontsize=title_fontsize)\n        ax2.set_xlabel('')\n        ax2.tick_params(axis='both', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Create the 'SNV class' figure.\n        self.plot_snvclsc(ax=ax3, flip=True,\n            palette=sns.color_palette('Set2'))\n        ax3.set_title('SNV class', fontsize=title_fontsize)\n        ax3.set_xlabel('')\n        ax3.tick_params(axis='both', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Create the 'Variants per sample' figure.\n        median = self.matrix_tmb().sum(axis=1).median()\n        self.plot_tmb(ax=ax4, width=1)\n        ax4.set_title(f'Variants per sample (median={median:.1f})',\n                      fontsize=title_fontsize)\n        ax4.set_xlabel('')\n        ax4.set_ylabel('')\n        ax4.tick_params(axis='y', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        ax4.axhline(y=median, color='red', linestyle='dashed')\n\n        # Create the 'Variant classification (samples)' figure.\n        self.plot_varsum(ax=ax5)\n        ax5.set_title('Variant classification (samples)',\n                      fontsize=title_fontsize)\n        ax5.set_yticks([])\n        ax5.set_xlabel('')\n        ax5.tick_params(axis='x', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Create the 'Top 10 mutated genes' figure.\n        self.plot_genes(ax=ax6)\n        ax6.set_title('Top 10 mutated genes', fontsize=title_fontsize)\n        ax6.set_xlabel('')\n        ax6.tick_params(axis='both', which='major',\n                        labelsize=ticklabels_fontsize)\n\n        # Add the legend.\n        axbig.legend(\n            handles=common.legend_handles(NONSYN_NAMES, colors=NONSYN_COLORS),\n            title='Variant_Classification',\n            loc='upper center',\n            ncol=3,\n            fontsize=legend_fontsize,\n            title_fontsize=legend_fontsize\n        )\n        axbig.axis('off')\n\n        plt.tight_layout()\n\n    def plot_tmb(\n        self, samples=None, width=0.8, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a bar plot showing the :ref:`TMB <glossary:Tumor mutational\n        burden (TMB)>` distributions of samples.\n\n        Parameters\n        ----------\n        samples : list, optional\n            List of samples to display (in that order too). If samples that\n            are absent in the MafFrame are provided, the method will give a\n            warning but still draw an empty bar for those samples.\n        width : float, default: 0.8\n            The width of the bars.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`pandas.DataFrame.plot.bar`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n        Below is a simple example:\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_tmb(width=1)\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.matrix_tmb()\n\n        if samples is not None:\n            df = df.T\n            missing_samples = []\n            for sample in samples:\n                if sample not in df.columns:\n                    missing_samples.append(sample)\n            if missing_samples:\n                message = (\n                    'Although the following samples are absent in the '\n                    'MafFrame, they will still be displayed as empty bar: '\n                    f'{missing_samples}.'\n                )\n                warnings.warn(message)\n                for missing_sample in missing_samples:\n                    df[missing_sample] = 0\n            df = df[samples]\n            df = df.T\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        df.plot.bar(stacked=True, ax=ax, width=width, legend=False,\n            color=NONSYN_COLORS, **kwargs)\n\n        ax.set_xlabel('Samples')\n        ax.set_ylabel('Count')\n        ax.set_xticks([])\n\n        return ax\n\n    def plot_tmb_matched(\n        self, af, patient_col, group_col, group_order=None, patients=None,\n        legend=True, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a grouped bar plot showing TMB distributions for different\n        group levels in each patient.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        patient_col : str\n            AnnFrame column containing patient information.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        patients : list, optional\n            List of patient names.\n        legend : bool, default: True\n            Place legend on axis subplots.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`pandas.DataFrame.plot.bar`\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        \"\"\"\n        df = self.matrix_tmb().T\n\n        for sample in af.samples:\n            if sample not in df.columns:\n                df[sample] = 0\n\n        s = df.sum()\n        s.name = 'TMB'\n        df = pd.concat([s, af.df[[patient_col, group_col]]], axis=1)\n\n        df = df.pivot(index=patient_col, columns=group_col, values='TMB')\n\n        if group_order is not None:\n            df = df[group_order]\n\n        i = df.sum(axis=1).sort_values(ascending=False).index\n        df = df.loc[i]\n\n        if patients is not None:\n            df = df.loc[patients]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        df.plot(ax=ax, kind='bar', stacked=True, legend=legend, **kwargs)\n\n        ax.set_xlabel('')\n        ax.set_ylabel('TMB')\n\n        return ax\n\n    def plot_vaf(\n        self, vaf_col, count=10, af=None, group_col=None, group_order=None,\n        flip=False, sort=True, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a box plot showing the :ref:`VAF <glossary:Variant allele\n        frequency (VAF)>` distributions of top mutated genes.\n\n        A grouped box plot can be created with ``group_col`` (requires an\n        AnnFrame).\n\n        Parameters\n        ----------\n        vaf_col : str\n            MafFrame column containing VAF data.\n        count : int, default: 10\n            Number of top mutated genes to display.\n        af : AnnFrame, optional\n            AnnFrame containing sample annotation data.\n        group_col : str, optional\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        sort : bool, default: True\n            If False, do not sort the genes by median value.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.boxplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        Below is a simple example:\n\n        .. plot::\n            :context: close-figs\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_vaf('i_TumorVAF_WU')\n            >>> plt.tight_layout()\n\n        We can create a grouped bar plot based on FAB classification:\n\n        .. plot::\n            :context: close-figs\n\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_vaf('i_TumorVAF_WU',\n            ...             af=af,\n            ...             group_col='FAB_classification',\n            ...             group_order=['M1', 'M2', 'M3'],\n            ...             count=5)\n            >>> plt.tight_layout()\n        \"\"\"\n        genes = self.matrix_genes(count=count).index.to_list()\n\n        if sort:\n            medians = self.df.groupby('Hugo_Symbol')[vaf_col].median()\n            genes = medians[genes].sort_values(\n                ascending=False).index.to_list()\n\n        df = self.df[self.df.Hugo_Symbol.isin(genes)]\n\n        if group_col is not None:\n            df = pd.merge(df, af.df, left_on='Tumor_Sample_Barcode',\n                right_index=True)\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = vaf_col, 'Hugo_Symbol'\n            xlabel, ylabel = 'VAF', ''\n        else:\n            x, y = 'Hugo_Symbol', vaf_col\n            xlabel, ylabel = '', 'VAF'\n\n        sns.boxplot(\n            x=x, y=y, data=df, ax=ax, order=genes, hue=group_col,\n            hue_order=group_order, **kwargs\n        )\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_varcls(self, ax=None, figsize=None, **kwargs):\n        \"\"\"Create a bar plot for the nonsynonymous variant classes.\n\n        Parameters\n        ----------\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`matplotlib.axes.Axes.bar` and :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_varcls()\n            >>> plt.tight_layout()\n        \"\"\"\n        d = self.df.Variant_Classification.value_counts().to_dict()\n        counts = {}\n        for varcls in NONSYN_NAMES:\n            if varcls in d:\n                counts[varcls] = d[varcls]\n            else:\n                counts[varcls] = 0\n        s = pd.Series(counts).reindex(index=NONSYN_NAMES)\n        df = s.to_frame().reset_index()\n        df.columns = ['Variant_Classification', 'Count']\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.barplot(x='Count', y='Variant_Classification', data=df,\n                    ax=ax, palette=NONSYN_COLORS, **kwargs)\n\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_matrixg(\n        self, gene, af, group_col, group_order=None, cbar=True, ax=None,\n        figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a heatmap of count matrix with a shape of (sample groups,\n        protein changes).\n\n        Parameters\n        ----------\n        gene : str\n            Name of the gene.\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list, optional\n            List of sample group names.\n        cbar : bool, default: True\n            Whether to draw a colorbar.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.heatmap`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> annot_file = '~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> af = common.AnnFrame.from_file(annot_file, sample_col=0)\n            >>> mf.plot_matrixg('IDH1', af, 'FAB_classification', linewidth=0.5, square=True, annot=True)\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.df[self.df.Hugo_Symbol == gene]\n\n        if df.empty:\n            raise ValueError(f'No protein changes were found: {gene}')\n\n        df = df[['Tumor_Sample_Barcode', 'Protein_Change']]\n        df = df[df.Protein_Change != '.']\n        df = df.merge(af.df[group_col], left_on='Tumor_Sample_Barcode', right_index=True)\n        s = df.groupby(group_col)['Protein_Change'].value_counts()\n        s.name = 'Count'\n        df = s.to_frame().reset_index()\n        df = df.pivot(index=group_col,\n                      columns='Protein_Change',\n                      values='Count')\n        df = df.fillna(0)\n\n        if group_order is not None:\n            missing_groups = []\n            for group in group_order:\n                if group not in df.index:\n                    missing_groups.append(group)\n            if missing_groups:\n                message = (\n                    'Although the following sample groups are absent in the '\n                    'MafFrame, they will still be displayed as empty bar: '\n                    f'{missing_groups}.'\n                )\n                warnings.warn(message)\n                df = df.T\n                for missing_group in missing_groups:\n                    df[missing_group] = 0\n                df = df[groups]\n                df = df.T\n\n        # Sort protein changes by position.\n        f = lambda s: int(''.join([x for x in list(s) if x.isdigit()]))\n        l = df.columns\n        s = pd.Series([f(x) for x in l], index=l).sort_values()\n        df = df[s.index]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.heatmap(\n            df, ax=ax, cbar=cbar, **kwargs\n        )\n\n        ax.set_xlabel('')\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_matrixs(\n        self, gene, samples=None, c0='lightgray', c1='red', l0='0', l1='1',\n        cbar=True, square=False, ax=None, figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a heatmap of presence\/absence matrix with a shape of (samples,\n        protein changes).\n\n        Parameters\n        ----------\n        gene : str\n            Name of the gene.\n        samples : list, optional\n            List of samples to display (in that order too). If samples that\n            are absent in the MafFrame are provided, the method will give a\n            warning but still draw an empty bar for those samples.\n        c0 : str, default: 'lightgray'\n            Color for absence.\n        c1 : str, default: 'red'\n            Color for presence.\n        l0 : str, default: '0'\n            Label for absence.\n        l1 : str, default: '1'\n            Label for presence.\n        cbar : bool, default: True\n            Whether to draw a colorbar.\n        square : bool, default: False\n            If True, set the Axes aspect to \"equal\" so each cell will be\n            square-shaped.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.heatmap`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_matrixs('KRAS', linewidth=0.5, square=True)\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.df[self.df.Hugo_Symbol == gene]\n\n        if df.empty:\n            raise ValueError(f'No protein changes were found: {gene}')\n\n        df = df[['Tumor_Sample_Barcode', 'Protein_Change']]\n        df = df[df.Protein_Change != '.']\n        df['Presence'] = 1\n        df = df.pivot(index='Tumor_Sample_Barcode',\n                      columns='Protein_Change',\n                      values='Presence')\n        df = df.fillna(0)\n\n        if samples is not None:\n            missing_samples = []\n            for sample in samples:\n                if sample not in df.index:\n                    missing_samples.append(sample)\n            if missing_samples:\n                message = (\n                    'Although the following samples are absent in the '\n                    'MafFrame, they will still be displayed as empty bar: '\n                    f'{missing_samples}.'\n                )\n                warnings.warn(message)\n                df = df.T\n                for missing_sample in missing_samples:\n                    df[missing_sample] = 0\n                df = df[samples]\n                df = df.T\n\n        # Sort protein changes by position.\n        f = lambda s: int(''.join([x for x in list(s) if x.isdigit()]))\n        l = df.columns\n        s = pd.Series([f(x) for x in l], index=l).sort_values()\n        df = df[s.index]\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if len(np.unique(df.values)) == 1:\n            cmap = [c1]\n            cbar_ticklabels = [l1]\n        else:\n            cmap = [c0, c1]\n            cbar_ticklabels = [l0, l1]\n\n        sns.heatmap(\n            df, cbar=cbar, cmap=cmap, square=square, ax=ax, **kwargs\n        )\n\n        if cbar:\n            colorbar = ax.collections[0].colorbar\n            n=len(cmap)\n            r = colorbar.vmax - colorbar.vmin\n            colorbar.set_ticks([colorbar.vmin + r\/n * (0.5+i) for i in range(n)])\n            colorbar.set_ticklabels(cbar_ticklabels)\n\n        ax.set_xlabel('')\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_varsum(self, flip=False, ax=None, figsize=None):\n        \"\"\"\n        Create a summary box plot for variant classifications.\n\n        Parameters\n        ----------\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_varsum()\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.matrix_tmb()\n        df = pd.melt(df, value_vars=df.columns)\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = 'variable', 'value'\n            xlabel, ylabel = '', 'Samples'\n        else:\n            x, y = 'value', 'variable'\n            xlabel, ylabel = 'Samples', ''\n\n        sns.boxplot(x=x, y=y, data=df, ax=ax, showfliers=False,\n            palette=NONSYN_COLORS)\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n        return ax\n\n    def plot_vartype(self, palette=None, flip=False, ax=None, figsize=None, **kwargs):\n        \"\"\"\n        Create a bar plot summarizing the count distrubtions of viaration\n        types for all samples.\n\n        Parameters\n        ----------\n        palette : str, optional\n            Name of the seaborn palette. See the :ref:`tutorials:Control plot\n            colors` tutorial for details.\n        flip : bool, default: False\n            If True, flip the x and y axes.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.barplot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_vartype()\n            >>> plt.tight_layout()\n        \"\"\"\n        s = self.df.Variant_Type.value_counts()\n        df = s.to_frame().reset_index()\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        if flip:\n            x, y = 'Variant_Type', 'index'\n            xlabel, ylabel = 'Count', ''\n        else:\n            x, y = 'index', 'Variant_Type'\n            xlabel, ylabel = '', 'Count'\n\n        sns.barplot(x=x, y=y, data=df, ax=ax, palette=palette, **kwargs)\n\n        ax.set_xlabel(xlabel)\n        ax.set_ylabel(ylabel)\n\n        return ax\n\n    def plot_waterfall(\n        self, count=10, keep_empty=False, samples=None, ax=None,\n        figsize=None, **kwargs\n    ):\n        \"\"\"\n        Create a waterfall plot (oncoplot).\n\n        See this :ref:`tutorial <tutorials:Create customized oncoplots>` to\n        learn how to create customized oncoplots.\n\n        Parameters\n        ----------\n        count : int, default: 10\n            Number of top mutated genes to display.\n        keep_empty : bool, default: False\n            If True, display samples that do not have any mutations.\n        samples : list, optional\n            List of samples to display (in that order too). If samples that\n            are absent in the MafFrame are provided, the method will give a\n            warning but still draw an empty bar for those samples.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n        kwargs\n            Other keyword arguments will be passed down to\n            :meth:`seaborn.heatmap`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n\n        Examples\n        --------\n\n        .. plot::\n\n            >>> import matplotlib.pyplot as plt\n            >>> from fuc import common, pymaf\n            >>> common.load_dataset('tcga-laml')\n            >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n            >>> mf = pymaf.MafFrame.from_file(maf_file)\n            >>> mf.plot_waterfall(linewidths=0.5)\n            >>> plt.tight_layout()\n        \"\"\"\n        df = self.matrix_waterfall(count=count, keep_empty=keep_empty)\n\n        if samples is not None:\n            missing_samples = []\n            for sample in samples:\n                if sample not in df.columns:\n                    missing_samples.append(sample)\n            if missing_samples:\n                message = (\n                    'Although the following samples are absent in the '\n                    'MafFrame, they will still be displayed as empty bar: '\n                    f'{missing_samples}.'\n                )\n                warnings.warn(message)\n                for missing_sample in missing_samples:\n                    df[missing_sample] = 'None'\n            df = df[samples]\n\n        # Apply the mapping between items and integers.\n        l = reversed(NONSYN_NAMES + ['Multi_Hit', 'None'])\n        d = {k: v for v, k in enumerate(l)}\n        df = df.applymap(lambda x: d[x])\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        colors = list(reversed(NONSYN_COLORS + ['k', 'lightgray']))\n\n        sns.heatmap(df, cmap=colors, ax=ax, xticklabels=False,\n            cbar=False, **kwargs)\n\n        ax.set_xlabel('Samples')\n        ax.set_ylabel('')\n\n        return ax\n\n    def plot_waterfall_matched(\n        self, af, patient_col, group_col, group_order, count=10, ax=None,\n        figsize=None\n    ):\n        \"\"\"\n        Create a waterfall plot using matched samples from each patient.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        patient_col : str\n            AnnFrame column containing patient information.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list\n            List of sample group names.\n        count : int, default: 10\n            Number of top mutated genes to include.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        \"\"\"\n        df = self.matrix_waterfall_matched(af, patient_col,\n            group_col, group_order, count=count)\n        genes = df.index.get_level_values(0).unique().to_list()\n\n        l = reversed(NONSYN_NAMES + ['Multi_Hit', 'None'])\n        d = {k: v for v, k in enumerate(l)}\n        df = df.applymap(lambda x: d[x])\n\n        colors = list(reversed(NONSYN_COLORS + ['k', 'lightgray']))\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        sns.heatmap(df, cmap=colors, xticklabels=True, cbar=False, ax=ax)\n\n        n = len(group_order)\n        i = n \/ 2\n        yticks = []\n        for gene in genes:\n            yticks.append(i)\n            i += n\n\n        ax.set_xlabel('')\n        ax.set_ylabel('')\n        ax.set_yticks(yticks)\n        ax.set_yticklabels(genes)\n\n        # Add horizontal lines.\n        for i, gene in enumerate(genes, start=1):\n            ax.axhline(i*n, color='white')\n\n        # Add vertical lines.\n        for i, sample in enumerate(af.samples, start=1):\n            ax.axvline(i, color='white')\n\n        return ax\n\n    def matrix_waterfall_matched(\n        self, af, patient_col, group_col, group_order, count=10\n    ):\n        \"\"\"\n        Compute a matrix of variant classifications with a shape of\n        (gene-group pairs, patients).\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        patient_col : str\n            AnnFrame column containing patient information.\n        group_col : str\n            AnnFrame column containing sample group information.\n        group_order : list\n            List of sample group names.\n        count : int, default: 10\n            Number of top mutated genes to include.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        \"\"\"\n        df = self.matrix_waterfall(count=count)\n\n        genes = df.index\n\n        missing_samples = {}\n\n        for sample in af.samples:\n            if sample not in df.columns:\n                missing_samples[sample] = ['None'] * len(genes)\n\n        df = pd.concat(\n            [df, pd.DataFrame(missing_samples, index=genes)], axis=1)\n\n        df = df[af.samples].T\n        df = df.merge(af.df[[patient_col, group_col]],\n            left_index=True, right_index=True)\n        df = df.reset_index(drop=True)\n\n        temps = []\n\n        for group in group_order:\n            temp = df[df[group_col] == group].set_index(patient_col)[genes]\n            tuples = [(x, group) for x in genes]\n            mi = pd.MultiIndex.from_tuples(tuples, names=['Gene', 'Group'])\n            temp.columns = mi\n            temps.append(temp)\n\n        df = pd.concat(temps, axis=1)\n\n        tuples = []\n\n        for gene in genes:\n            for group in group_order:\n                tuples.append((gene, group))\n\n        df = df[tuples]\n        df = df.T\n\n        c = df.applymap(lambda x: 0 if x == 'None' else 1).sort_values(\n            df.index.to_list(), axis=1, ascending=False).columns\n        df = df[c]\n\n        return df\n\n\n    def to_vcf(\n        self, fasta=None, ignore_indels=False, cols=None, names=None\n    ):\n        \"\"\"\n        Write the MafFrame to a sorted VcfFrame.\n\n        Converting from MAF to VCF is pretty straightforward for SNVs, but it\n        can be challenging for INDELs and complex events involving multiple\n        nucleotides (e.g. 'AAGG' → 'CCCG'). This is because, for the latter\n        case we need to identify the \"anchor\" nucleotide for each event,\n        which is crucial for constructing a properly formatted VCF. For\n        example, a deletion event 'AGT' → '-' in MAF would have to be\n        converted to 'CAGT' → 'C' in the VCF where 'C' is our anchor\n        nucleotide. The position should be shifted by one as well.\n\n        In order to tackle this issue, the method makes use of a reference\n        assembly (i.e. FASTA file). If SNVs are your only concern, then you\n        do not need a FASTA file and can just set ``ignore_indels`` as True.\n        If you are going to provide a FASTA file, please make sure to select\n        the appropriate one (e.g. one that matches the genome assembly). For\n        example, if your MAF is in hg19\/GRCh37, use the 'hs37d5.fa' file\n        which can be freely downloaded from the 1000 Genomes Project.\n\n        Parameters\n        ----------\n        fasta : str, optional\n            FASTA file. Required if ``ignore_indels`` is False.\n        ignore_indels : bool, default: False\n            If True, do not include INDELs in the VcfFrame. Useful when\n            a FASTA file is not available.\n        cols : str or list, optional\n            Column(s) in the MafFrame which contain additional genotype\n            data of interest. If provided, these data will be added to\n            individual sample genotypes (e.g. '0\/1:0.23').\n        names : str or list, optional\n            Name(s) to be displayed in the FORMAT field (e.g. AD, AF, DP).\n            If not provided, the original column name(s) will be displayed.\n\n        Returns\n        -------\n        VcfFrame\n            The VcfFrame object.\n\n        Examples\n        --------\n\n        >>> from fuc import pymaf\n        >>> mf = pymaf.MafFrame.from_file('in.maf')\n        >>> vf = mf.to_vcf(fasta='hs37d5.fa')\n        >>> vf = mf.to_vcf(ignore_indels=True)\n        >>> vf = mf.to_vcf(fasta='hs37d5.fa', cols='i_TumorVAF_WU', names='AF')\n        \"\"\"\n        if not ignore_indels and fasta is None:\n            raise ValueError(\"A FASTA file is required when 'ignore_indels' \"\n                             \"argument is False.\")\n\n        if cols is None:\n            cols = []\n        if names is None:\n            names = []\n\n        if isinstance(cols, str):\n            cols = [cols]\n        if isinstance(names, str):\n            names = [names]\n\n        if cols and not names:\n            names = cols\n        if len(cols) != len(names):\n            raise ValueError(\"Arguments 'cols' and 'names' \"\n                             \"have different lengths.\")\n\n        # Create the minimal VCF.\n        index_cols = ['Chromosome', 'Start_Position',\n                      'Reference_Allele', 'Tumor_Seq_Allele2']\n        df = self.df.pivot(index=index_cols,\n                           columns='Tumor_Sample_Barcode',\n                           values='Tumor_Seq_Allele2')\n        f = lambda x: '0\/0' if pd.isnull(x) else '0\/1'\n        df = df.applymap(f)\n        df.columns.name = None\n        df = df.reset_index()\n        df = df.rename(columns={'Chromosome': 'CHROM',\n                                'Start_Position': 'POS',\n                                'Reference_Allele': 'REF',\n                                'Tumor_Seq_Allele2': 'ALT'})\n        df['ID'] = '.'\n        df['QUAL'] = '.'\n        df['FILTER'] = '.'\n        df['INFO'] = '.'\n        df['FORMAT'] = 'GT'\n        df = df[pyvcf.HEADERS + self.samples]\n\n        # Add requested genotype information.\n        f = lambda x: '.' if pd.isnull(x) else str(x)\n        for i, col in enumerate(cols):\n            _ = self.df.pivot(index=index_cols,\n                              columns='Tumor_Sample_Barcode',\n                              values='i_TumorVAF_WU')\n            _ = _.reset_index()\n            _ = _.drop(index_cols, axis=1)\n            _ = _[self.samples]\n            _ = _.applymap(f)\n            df.iloc[:, 9:] = df.iloc[:, 9:] + ':' + _\n            df.FORMAT = df.FORMAT + ':' + names[i]\n\n        # Handle INDELs.\n        l = ['A', 'C', 'G', 'T']\n        if ignore_indels:\n            i = (df.REF.isin(l)) & (df.ALT.isin(l))\n            df = df[i]\n        else:\n            def one_row(r):\n                if r.REF in l and r.ALT in l:\n                    return r\n                region = f'{r.CHROM}:{r.POS-1}-{r.POS-1}'\n                anchor = common.extract_sequence(fasta, region)\n                if not anchor:\n                    return r\n                r.POS = r.POS - 1\n                if r.ALT == '-':\n                    r.REF = anchor + r.REF\n                    r.ALT = anchor\n                elif r.REF == '-':\n                    r.REF = anchor\n                    r.ALT = anchor + r.ALT\n                else:\n                    r.REF = anchor + r.REF\n                    r.ALT = anchor + r.ALT\n                return r\n            df = df.apply(one_row, axis=1)\n\n        # Create the metadata.\n        meta = [\n            '##fileformat=VCFv4.3',\n            '##source=fuc.api.pymaf.MafFrame.to_vcf',\n        ]\n\n        # Create the VcfFrame.\n        vf = pyvcf.VcfFrame(meta, df)\n        vf = vf.sort()\n\n        return vf\n\n    def to_file(self, fn):\n        \"\"\"Write MafFrame to a MAF file.\n\n        Parameters\n        ----------\n        fn : str\n            MAF file path.\n        \"\"\"\n        with open(fn, 'w') as f:\n            f.write(self.to_string())\n\n    def to_string(self):\n        \"\"\"Render MafFrame to a console-friendly tabular output.\n\n        Returns\n        -------\n        str\n            String representation of MafFrame.\n        \"\"\"\n        return self.df.to_csv(index=False, sep='\\t')\n\n    def filter_annot(self, af, expr):\n        \"\"\"\n        Filter the MafFrame using sample annotation data.\n\n        Samples are selected by querying the columns of an AnnFrame with a\n        boolean expression. Samples not present in the MafFrame will be\n        excluded automatically.\n\n        Parameters\n        ----------\n        af : AnnFrame\n            AnnFrame containing sample annotation data.\n        expr : str\n            Query expression to evaluate.\n\n        Returns\n        -------\n        MafFrame\n            Filtered MafFrame.\n\n        Examples\n        --------\n\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> mf = pymaf.MafFrame.from_file('~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz')\n        >>> af = common.AnnFrame.from_file('~\/fuc-data\/tcga-laml\/tcga_laml_annot.tsv', sample_col=0)\n        >>> filtered_mf = mf.filter_annot(af, \"FAB_classification == 'M4'\")\n        \"\"\"\n        samples = af.df.query(expr).index\n        i = self.df.Tumor_Sample_Barcode.isin(samples)\n        df = self.df[i]\n        mf = self.__class__(df)\n        return mf\n\n    def filter_indel(self, opposite=False, as_index=False):\n        \"\"\"\n        Remove rows with an indel.\n\n        Parameters\n        ----------\n        opposite : bool, default: False\n            If True, return rows that don't meet the said criteria.\n        as_index : bool, default: False\n            If True, return boolean index array instead of MafFrame.\n\n        Returns\n        -------\n        MafFrame or pandas.Series\n            Filtered MafFrame or boolean index array.\n\n        Examples\n        --------\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        >>> mf.filter_indel().df.Variant_Type.unique()\n        array(['SNP'], dtype=object)\n        >>> mf.filter_indel(opposite=True).df.Variant_Type.unique()\n        array(['DEL', 'INS'], dtype=object)\n        \"\"\"\n        def one_row(r):\n            if (len(r.Reference_Allele) == 1 and\n                len(r.Tumor_Seq_Allele1) == 1 and\n                len(r.Tumor_Seq_Allele2) == 1 and\n                '-' not in r.Reference_Allele and\n                '-' not in r.Tumor_Seq_Allele1 and\n                '-' not in r.Tumor_Seq_Allele2):\n                return False\n            else:\n                return True\n        i = ~self.df.apply(one_row, axis=1)\n        if opposite:\n            i = ~i\n        if as_index:\n            return i\n        return self.__class__(self.df[i])\n\n    def variants(self):\n        \"\"\"\n        List unique variants in MafFrame.\n\n        Returns\n        -------\n        list\n            List of unique variants.\n\n        Examples\n        --------\n\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        >>> mf.variants()[:5]\n        ['1:1571791:1571791:G:A', '1:1747228:1747228:T:G', '1:2418350:2418350:C:T', '1:3328523:3328523:G:A', '1:3638739:3638739:C:T']\n        \"\"\"\n        if self.df.empty:\n            return []\n        cols = ['Chromosome', 'Start_Position', 'End_Position', 'Reference_Allele', 'Tumor_Seq_Allele2']\n        df = self.df.drop_duplicates(cols)\n        df = df[cols]\n        df = df.sort_values(cols)\n        df = df.applymap(str)\n        s = df.apply(lambda r: r.str.cat(sep=':'), axis=1)\n        return s.to_list()\n\n    def subset(self, samples, exclude=False):\n        \"\"\"\n        Subset MafFrame for specified samples.\n\n        Parameters\n        ----------\n        samples : str, list, or pandas.Series\n            Sample name or list of names (the order does not matters).\n        exclude : bool, default: False\n            If True, exclude specified samples.\n\n        Returns\n        -------\n        MafFrame\n            Subsetted MafFrame.\n\n        Examples\n        --------\n\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        >>> mf.shape\n        (2207, 193)\n        >>> mf.subset(['TCGA-AB-2988', 'TCGA-AB-2869']).shape\n        (27, 2)\n        >>> mf.subset(['TCGA-AB-2988', 'TCGA-AB-2869'], exclude=True).shape\n        (2180, 191)\n        \"\"\"\n        if isinstance(samples, str):\n            samples = [samples]\n        elif isinstance(samples, pd.Series):\n            samples = samples.to_list()\n        elif isinstance(samples, list):\n            pass\n        else:\n            raise TypeError(f'Incorrect input type: {type(samples)}')\n\n        if exclude:\n            samples = [x for x in self.samples if x not in samples]\n\n        df = self.df[self.df.Tumor_Sample_Barcode.isin(samples)]\n\n        return self.__class__(df)\n\n    def calculate_concordance(self, a, b, c=None, mode='all'):\n        \"\"\"\n        Calculate genotype concordance between two (A, B) or three (A, B, C)\n        samples.\n\n        This method will return (Ab, aB, AB, ab) for comparison between two\n        samples and (Abc, aBc, ABc, abC, AbC, aBC, ABC, abc) for three\n        samples. Note that the former is equivalent to (FP, FN, TP, TN) if\n        we assume A is the test sample and B is the truth sample.\n\n        Parameters\n        ----------\n        a, b : str or int\n            Name or index of Samples A and B.\n        c : str or int, optional\n            Name or index of Sample C.\n        mode : {'all', 'snv', 'indel'}, default: 'all'\n            Determines which variant types should be analyzed:\n\n            - 'all': Include both SNVs and INDELs.\n            - 'snv': Include SNVs only.\n            - 'indel': Include INDELs only.\n\n        Returns\n        -------\n        tuple\n            Four- or eight-element tuple depending on the number of samples.\n\n        See Also\n        --------\n        fuc.api.common.sumstat\n            Return various summary statistics from (FP, FN, TP, TN).\n\n        Examples\n        --------\n\n        >>> from fuc import common, pymaf\n        >>> common.load_dataset('tcga-laml')\n        >>> maf_file = '~\/fuc-data\/tcga-laml\/tcga_laml.maf.gz'\n        >>> mf = pymaf.MafFrame.from_file(maf_file)\n        >>> mf.calculate_concordance('TCGA-AB-2988', 'TCGA-AB-2869')\n        (15, 12, 0, 2064)\n        >>> mf.calculate_concordance('TCGA-AB-2988', 'TCGA-AB-2869', 'TCGA-AB-3009')\n        (15, 12, 0, 42, 0, 0, 0, 2022)\n        \"\"\"\n        if mode == 'all':\n            mf = self.copy()\n        elif mode == 'snv':\n            mf = self.filter_indel()\n        elif mode == 'indel':\n            mf = self.filter_indel(opposite=True)\n        else:\n            raise ValueError(f'Incorrect mode: {mode}.')\n\n        if c is None:\n            result = self._compare_two(mf, a, b)\n        else:\n            result = self._compare_three(mf, a, b, c)\n\n        return result\n\n    def _compare_two(self, mf, a, b):\n        l = mf.variants()\n        A = mf.subset(a).variants()\n        B = mf.subset(b).variants()\n\n        Ab = aB = AB = ab = 0\n\n        for x in l:\n            if x in A and x in B:\n                AB += 1\n            elif x in A and x not in B:\n                Ab += 1\n            elif x not in A and x in B:\n                aB += 1\n            else:\n                ab += 1\n\n        return (Ab, aB, AB, ab)\n\n    def _compare_three(self, mf, a, b, c):\n        l = mf.variants()\n        A = mf.subset(a).variants()\n        B = mf.subset(b).variants()\n        C = mf.subset(c).variants()\n\n        Abc = aBc = ABc = abC = AbC = aBC = ABC = abc = 0\n\n        for x in l:\n            if (x in A) and (x not in B) and (x not in C):\n                Abc += 1\n            elif (x not in A) and (x in B) and (x not in C):\n                aBc += 1\n            elif (x in A) and (x in B) and (x not in C):\n                ABc += 1\n            elif (x not in A) and (x not in B) and (x in C):\n                abC += 1\n            elif (x in A) and (x not in B) and (x in C):\n                AbC += 1\n            elif (x not in A) and (x in B) and (x in C):\n                aBC += 1\n            elif (x in A) and (x in B) and (x in C):\n                ABC += 1\n            else:\n                abc += 1\n\n        return (Abc, aBc, ABc, abC, AbC, aBC, ABC, abc)\n\n    def plot_comparison(\n        self, a, b, c=None, labels=None, ax=None, figsize=None\n    ):\n        \"\"\"\n        Create a Venn diagram showing genotype concordance between groups.\n\n        This method supports comparison between two groups (Groups A & B)\n        as well as three groups (Groups A, B, & C).\n\n        Parameters\n        ----------\n        a, b : list\n            Sample names. The lists must have the same shape.\n        c : list, optional\n            Same as above.\n        labels : list, optional\n            List of labels to be displayed.\n        ax : matplotlib.axes.Axes, optional\n            Pre-existing axes for the plot. Otherwise, crete a new one.\n        figsize : tuple, optional\n            Width, height in inches. Format: (float, float).\n\n        Returns\n        -------\n        matplotlib.axes.Axes\n            The matplotlib axes containing the plot.\n        matplotlib_venn._common.VennDiagram\n            VennDiagram object.\n        \"\"\"\n        if len(a) != len(b):\n            raise ValueError('Groups A and B have different length.')\n        if c is not None and len(a) != len(c):\n            raise ValueError('Group C has unmatched length.')\n        if labels is None:\n            if c is None:\n                labels = ('A', 'B')\n            else:\n                labels = ('A', 'B', 'C')\n\n        if ax is None:\n            fig, ax = plt.subplots(figsize=figsize)\n\n        venn_kws = dict(ax=ax, alpha=0.5, set_labels=labels)\n        if c is None:\n            out = self._plot_comparison_two(a, b, venn_kws)\n        else:\n            out = self._plot_comparison_three(a, b, c, venn_kws)\n        return ax, out\n\n    def _plot_comparison_two(self, a, b, venn_kws):\n        n = [0, 0, 0, 0]\n        for i in range(len(a)):\n            n = [x + y for x, y in zip(n, self.calculate_concordance(a[i], b[i]))]\n        out = venn2(subsets=n[:-1], **venn_kws)\n        return out\n\n    def _plot_comparison_three(self, a, b, c, venn_kws):\n        n = [0, 0, 0, 0, 0, 0, 0, 0]\n        for i in range(len(a)):\n            n = [x + y for x, y in zip(n, self.calculate_concordance(a[i], b[i], c[i]))]\n        out = venn3(subsets=n[:-1], **venn_kws)\n        return out\n\n    def get_gene_concordance(self, gene, a, b):\n        \"\"\"\n        Test whether two samples have the identical mutation profile for\n        specified gene.\n\n        Parameters\n        ----------\n        gene : str\n            Name of the gene.\n        a, b : str\n            Sample name.\n\n        Returns\n        -------\n        bool\n            True if the two samples have the same mutation profile.\n        \"\"\"\n        df = self.df[self.df.Hugo_Symbol == gene]\n        df = df[df.Tumor_Sample_Barcode.isin([a, b])]\n\n        # Both samples don't have any mutations.\n        if df.empty:\n            return True\n\n        # Only one sample has mutation(s).\n        if df.Tumor_Sample_Barcode.nunique() == 1:\n            return False\n\n        p1 = set(df[df.Tumor_Sample_Barcode == a].Protein_Change)\n        p2 = set(df[df.Tumor_Sample_Barcode == b].Protein_Change)\n\n        return p1 == p2\n"}